Erstellen und verwenden von ConfigMaps in Kubernetes

In der Programmierung verwenden wir Env-Dateien oder separate Konfigurationsdateien, um Einstellungen, Konfigurationen oder Variablen zu speichern, die für die Ausführung des Programms erforderlich sind. In Kubernetes können wir ConfigMaps verwenden, um dieselbe Funktionalität zu erreichen. Um ConfigMap richtig zu verstehen, sollten Sie einige Kenntnisse von Kubernetes, Pods und grundlegendem Kubernetes-Clustermanagement haben.

Was ist ein ConfigMap?

Ein ConfigMap ist ein Kubernetes-API-Objekt, das verwendet werden kann, um Daten als Schlüssel-Wert-Paare zu speichern. Kubernetes-Pods können die erstellten ConfigMaps als Folgendes verwenden:

• Konfigurationsdatei
• Umweltvariable
• Kommandozeilen-Argument

ConfigMaps ermöglicht es, Anwendungen portabel zu machen, indem es umgebungsspezifische Konfigurationen von den Containern entkoppelt. Wichtig ist, dass ConfigMaps nicht für die Speicherung vertraulicher Daten geeignet sind. Sie bieten keine Art von Verschlüsselung, und alle darin enthaltenen Daten sind für jeden sichtbar, der Zugriff auf die Datei hat. (Kubernetes bietet Geheimnisse , die zur Speicherung sensibler Informationen verwendet werden können.) Ein weiterer Aspekt bei ConfigMaps ist die Dateigröße, da wir versuchen, Anwendungskonfigurations-ConfigMap-Dateien auf 1 MB begrenzt zu speichern. Für größere Datensätze ist es besser, separate Dateimounts, Datenbanken oder Dateidienste zu verwenden.

ConfigMap-Beispiel

In einer ConfigMap können die erforderlichen Informationen im Datenfeld gespeichert werden. Wir können Werte auf zwei Arten speichern:

• Als individuelle Schlüsselpaar-Eigenschaften
• In einem granularen Format, in dem sie Fragmente eines Konfigurationsformats sind. (Dateiähnliche Tasten)

Wie man ConfigMaps erstellt

ConfigMaps und Pods gehen Hand in Hand, da ConfigMaps als Umgebungsvariablen und Konfigurationsinformationen in einem Kubernetes-Pod verwendet werden können. In diesem Abschnitt schauen wir uns an, wie man ConfigMaps erstellt. Hier sind einige Anmerkungen, bevor wir anfangen:

• Wir werden eine Windows-Umgebung mit dem Windows-Subsystem für Linux (Ubuntu) als Terminalumgebung verwenden.
• Der Docker-Desktop wird so konfiguriert, dass er eine Kubernetes-Umgebung ermöglicht.
• Wir werden die offiziellen Beispieldateien von Kubernetes verwenden, um die Funktionalität von ConfigMap zu demonstrieren.

Erstellen von ConfigMaps aus Verzeichnissen

Wir können den folgenden Befehl verwenden, um ConfigMap-Verzeichnisse zu erstellen.

Es sucht nach passenden Dateien (regulären Dateien) in einem bestimmten Verzeichnis, mit denen man eine ConfigMap erstellen kann, während andere Dateitypen (versteckte Dateien, Unterverzeichnisse, Symlinks usw.) ignoriert werden. Zuerst erstellen wir ein Verzeichnis mit diesem Befehl:

Dann laden wir die erforderlichen Beispieldateien in das Verzeichnis herunter. Diese Dateien werden verwendet, um die ConfigMap zu generieren.

Schauen wir uns nun den Dateiinhalt mit den folgenden Befehlen an.

Beim Erstellen von ConfigMaps mit Verzeichnissen ist der wichtigste Faktor, dass man die Schlüssel-Wert-Paare in jeder Datei korrekt definieren muss. Danach erstellen wir die ConfigMap mit dem Befehl create configmap.

Dieser Befehl packt die Dateien im angegebenen Verzeichnis und erstellt eine ConfigMap-Datei. Wir können den Befehl kubectl describe verwenden, um die ConfigMap-Datei anzuzeigen.

Wir können die ConfigMap im YAML-Format mit folgendem Befehl erhalten.

Erstellen von ConfigMaps aus Dateien

So wie wir ConfigMaps mit Verzeichnissen erstellt haben, können wir auch ConfigMaps mit Dateien erstellen, indem wir den Parameter --from-file verwenden, um auf eine einzelne Datei im kubectl create configmap-Befehl zu zeigen. Also erstellen wir eine ConfigMap mit der game.properties-Datei, wie unten gezeigt.

Wir können mehrere --from-file-Argumente mehrfach definieren, um eine einzige ConfigMap-Datei mit mehreren verschiedenen Dateien zu erstellen.

Erstellen von ConfigMaps aus einer Umgebungsdatei

Kubernetes ermöglicht es Benutzern, ConfigMaps mit Env-Dateien zu erstellen. Wir können das --from-env-file-Argument verwenden, wenn wir eine Env-Datei definieren. Dieses Argument kann auch mehrfach verwendet werden, um mehrere Env-Dateien zu definieren. Bei Verwendung von Env-Dateien sollte jede Zeile dem

= Format. Leere Zeilen und Kommentare werden ignoriert, während Anführungszeichen Teil von ConfigMap sind. cat configmap-example/game-env-file.properties kubectl erstellen CONFIGMAP game-config-env-file-example --from-env-file=configmap-example/game-env-file.properties kubectl erhalten configmap game-config-env-file-example -o yaml Erstellen von ConfigMap aus einer Datei mit einem vordefinierten Schlüssel Beim Erstellen einer ConfigMap können wir das folgende Format im --from-file-Argument verwenden, um einen Schlüsselnamen zu definieren, der den im Datenabschnitt verwendeten Dateinamen überschreibt. Das folgende Beispiel zeigt, wie man einen Schlüssel definiert, während man eine ConfigMap erstellt. kubectl create configmap game-config-key-example --from-file=game-key-example-data=configmap-example/game.properties kubectl bekommt configmap game-config-key-example -o yaml Erstellung von ConfigMaps aus Werten Eine weitere Möglichkeit, ConfigMaps zu erstellen, besteht darin, literale Werte als Parameter im create configmap-Befehl anzugeben. Dafür können wir das --from-literal-Argument verwenden, um jedes Schlüsselpaar zu übergeben. Das ist besonders praktisch, wenn wir ConfigMaps spontan erstellen müssen. kubectl create configmap config-example-values --from-literal=example.value=one --from-literal=2 --from-literal=example.url="http://example.com" kubectl erhalten configmap config-example-values -o yaml Nutzung von ConfigMaps in Pods Jetzt haben wir ein grundlegendes Verständnis dafür, wie man ConfigMaps erstellt. Der nächste Schritt ist, die erstellten ConfigMaps zur Erstellung eines Pods zu verwenden. In diesem Abschnitt erstellen wir eine einfache ConfigMap und verwenden sie beim Erstellen eines Pods in Kubernetes. Als ersten Schritt erstellen wir eine Datei namens "app-basic.properties" und fügen zwei Schlüssel-Wert-Paare hinzu. app-basic.properties system.type="TESTING CONFIGMAP" system.number=12345 Wir erstellen eine ConfigMap namens "app-basic-configmap" mit der obigen Datei und der --from-file-Option. kubectl erstellen CONFIGMAP app-basic-configmap --from-file=configmap-example/app-basic.properties kubectl erhalten configmap app-basic-configmap -o yaml Abschließend erstellen wir einen Pod, der auf die neu erstellte ConfigMap verweist example-pod.yaml apiVersion: v1 type: Pod metadata: name: configmap-example-pod spec: containers: - name: configmap-example-busybox image: k8s.gcr.io/busybox Befehl: [ "/bin/sh", "-c", "env" ] envFrom: # Lade die vollständige ConfigMap - configMapRef: name: app-basic-configmap restartPolicy: Never Wie du aus dem obigen Beispiel sehen kannst, werden wir die vollständige ConfigMap, die wir erstellt haben, auf den Kubernetes Pod laden. kubectl create -f example-pod.yaml kubectl get pods kubectl logs configmap-example-pod | grep system.number Das obige Ergebnis zeigt an, dass die ConfigMap "app-basic-configmap" beim Erstellen des Kubernetes Pods erfolgreich geladen wurde. Schlüssel von ConfigMaps auf Pods zuordnen Eine weitere Möglichkeit, ConfigMaps zu verwenden, ist, Werte direkt von ConfigMaps auf die spezifischen Umweltvariablen im Pod zu mappen. In diesem Abschnitt erstellen wir zwei einfache Configmap-Dateien manuell und laden und mappen die Werte direkt auf den Kubernetes Pod. Dort definieren wir die ConfigMaps als YAML-Dateien und verwenden dann den Befehl kubectl create, um die ConfigMaps zu generieren. application-defaults.yaml apiVersion: v1 art: ConfigMap metadata: name: application-configs namespace: default data: app.value: "45000" app.type: test-application app.ui: web application-logs.yaml apiVersion: v1 type: ConfigMap metadata: name: application-log-configs namespace: default data: log_level: WARNUNG log_type: TEXT kubectl create -f application-defaults.yaml kubectl create -f application-logs.yaml example-pod.yaml apiVersion: v1 type: Pod metadata: name: configmap-example-pod spec: Container: - name: configmap-example-busybox image: k8s.gcr.io/busybox Befehl: [ "/bin/sh", "-c", "env" ] env: - name: APPLICATION_TYPE valueFrom: configMapKeyRef: name: application-configs schlüssel: app.type - name: APPLICATION_UI_TYPE valueFrom: configMapKeyRef: name: application-configs schlüssel: app.ui - name: LOG_LEVEL valueFrom: configMapKeyRef: name: application-log-configs schlüssel: log_level restartPolicy: Never In dieser Konfiguration mappen wir Umweltvariablen auf Werte innerhalb jeder ConfigMap. Im Folgenden ist die grundlegende Struktur zur Abbildung eines Wertes. Im Bereich Umgebung in der YAML-Datei definieren wir einen Variablennamen und referenzieren die ConfigMap über das Element "configMapKeyRef" mit dem "valueFrom". Hier stellen wir bereit: Der Name ConfigMap Der Schlüssel, von dem der Wert abgebildet werden soll, als Nächstes erstellen wir den Pod mit dem unten gezeigten Befehl kubectl create. kubectl create -f example-pod.yaml kubectl get pods Nach erfolgreicher Erstellung des Pods können wir die unten gezeigten Umgebungsvariablen erkunden. kubectl logs configmap-example-pod | grep APPLICATION_TYPE kubectl logs configmap-example-pod | grep APPLICATION_UI_TYPE kubectl logs configmap-example-pod | grep LOG_LEVEL Die obigen Ergebnisse zeigen, dass die Werte korrekt auf Umweltvariablen mit benutzerdefinierten Namen innerhalb des Kubernetes-Pods abgebildet wurden. ConfigMap-definierte Umgebungsvariablen in Pod-Befehlen Eine weitere Möglichkeit, ConfigMap-definierte Umweltvariablen zu nutzen, besteht darin, sie in Pod-Befehlen zu verwenden. Dies kann sowohl für die Befehls- als auch für die Args-Elemente in einer YAML-Datei mit der $(VARIABLE_NAME) Kubernetes-Substitutionssyntax gemacht werden. Der folgende Codeblock zeigt, wie diese Umweltvariablen im Befehlselement verwendet werden können, wobei example-pod.yaml als Basis dient. apiVersion: v1 type: Pod metadata: name: configmap-example-pod spec: containers: - name: configmap-example-busybox image: k8s.gcr.io/busybox Befehl: [ "/bin/echo", "Application Type $(APPLICATION_TYPE) - $(APPLICATION_UI_TYPE)" ] env: - name: APPLICATION_TYPE valueFrom: configMapKeyRef: name: application-configs schlüssel: app.type - name: APPLICATION_UI_TYPE valueFrom: configMapKeyRef: name: application-configs schlüssel: app.ui - name: LOG_LEVEL valueFrom: configMapKeyRef: name: application-log-configs schlüssel: log_level restartPolicy: Never In diesem Fall werden die Umweltvariablen bei der Ausführung des Befehls (am Containerstart) identifiziert und direkt im Terminal angezeigt. Hinzufügen von ConfigMap-Daten zu einem Volume Benutzer können ConfigMaps nutzen, indem sie die ConfigMap-Daten in ein Kubernetes-Volume einbinden. Im folgenden Beispiel mounten wir die "application-log-config" ConfigMap-Daten auf ein Volume namens "config-volume", das in "/etc/config" im Container montiert ist. Dann haben wir einen Befehl konfiguriert, der alle Dateien im /etc/config-Verzeichnis auflistet. apiVersion: v1 type: Pod metadata: name: configmap-example-volume-pod spec: containers: - name: configmap-volume-example-busybox image: k8s.gcr.io/busybox Befehl: [ "/bin/sh", "-c", "ls /etc/config/" ] volumeMounts: - name: config-volume mountPath: /etc/config volumes: - name: config-volume configMap: name: application-log-configs restartPolicy: Never Mounted ConfigMaps werden automatisch aktualisiert. Kubelt überprüft regelmäßig, ob das mounted ConfigMap aktuell ist, und aktualisiert das Mount entsprechend. Dieser automatische Update-Mechanismus gilt jedoch nicht für als SubPath-Volume abgebildete Volumes. Damit ist dieses Tutorial abgeschlossen. Entdecken Sie weitere Kubernetes-Themen im rechten Menü. ConfigMaps sind für K8s-Cluster unerlässlich. In diesem Artikel haben wir Kubernetes ConfigMaps kennengelernt, einschließlich mehrerer Möglichkeiten, ConfigMaps zu erstellen, und wie man ConfigMaps in einem Kubernetes-Pod nutzt. ConfigMaps sind ein wesentlicher Bestandteil jedes Kubernetes-Clusters und bieten eine robuste Methode, um einfache und häufig genutzte Anwendungs- oder Containerdaten zu speichern. Verwandte Lektüre: BMC DevOps Blog Kubernetes Guide mit 20+ Tutorials Kubernetes-Zertifizierungen: Wie und warum man zertifiziert wird Die 12-Faktor-App-Methodik erklärt Wie und warum man eine Softwarefabrik wird

Kubernetes-Leitfaden

1. Was ist Kubernetes (K8s)? Ein Tutorial zu den Grundlagen von Kubernetes
2. Kubernetes Best Practices für verbesserte Cluster-Effizienz
3. Best Practices: Wie man Anwendungen für Kubernetes architekt
4. Kubernetes Pods: Eine Einführung
5. Kubernetes ReplicaSets: Eine kurze Einführung
6. Kubernetes-Deployments vollständig erklärt
7. Wie man Kubernetes DaemonSets verwendet und verwaltet
8. Wie Kubernetes-Dienste funktionieren
9. Verwendung von Kubernetes Port, TargetPort und NodePort
10. Erstellen und verwenden von ConfigMaps in Kubernetes
11. Einführung in Kubernetes-Geheimnisse
12. Kubernetes-Netzwerkgrundlagen
13. Kubernetes-Ingress erklärt
14. Einführung in Kubernetes Helm Charts
15. Was ist das Kubernetes-Operator-Muster?
16. Bereitstellung von PostgreSQL als StatefulSet in Kubernetes
17. Kubernetes Custom Resource Definition (CRDs) erklärt
18. 3 Kubernetes-Muster für Cloud-native Anwendungen
19. Kubernetes Compute-Ressourcen erklärt
20. Kubernetes-Sicherheit für DevOps-Pipelines
21. Verwendung von Spinnaker mit Kubernetes für Continuous Delivery
22. Kubernetes-Multi-Cluster: Wie und warum man sie verwendet.
23. Kubernetes-Überwachung: Ein umfassender Leitfaden
24. Kubernetes vs. Docker: Ein kurzer Vergleich
25. Kubernetes vs. Docker Swarm: Vergleich von Container-Orchestrierungstools
26. Kubernetes vs. OpenShift: Was ist der Unterschied?
27. Kubernetes-Zertifizierungen: Wie und warum man zertifiziert wird

Diese Beiträge sind meine eigenen und spiegeln nicht unbedingt die Position, Strategien oder Meinung von BMC wider.