ConfigMap in Kubernetes

Eine ConfigMap wird zum Speichern nicht vertraulicher Daten verwendet. Die Daten liegen in Schlüssel-Werte-Paaren vor. Pods können ConfigMaps als Befehlszeilenargumente, Umgebungsvariablen oder als Konfigurationsdateien in einem Volume konsumieren.

Mit einer ConfigMap können wir die umgebungsspezifische Konfiguration von den Container-Images entkoppeln. ConfigMap bietet keine Verschlüsselung, daher ist es immer empfehlenswert, keine vertraulichen Informationen in der Configmap zu speichern. Anstatt Config zu verwenden, können Geheimnisse verwendet werden, um vertrauliche Informationen oder Sicherheitsschlüssel oder Passwörter zu speichern.

Es gibt folgende verschiedene Möglichkeiten, wie ConfigMap-Daten innerhalb eines Pods verwendet werden können:

1. Befehlszeilenargumente für einen Container
2. Umgebungsvariablen für einen Container
3. Fügen Sie eine Datei im schreibgeschützten Volume hinzu.
4. Schreiben Sie Code zur Ausführung innerhalb des Pods, der die Kubernetes-API zum Lesen einer ConfigMap verwendet.

Um mehr über Configmap zu erfahren, besuchen Sie die offizielle Seite von Kubernetes hier.

In diesem Artikel sehen wir zwei Beispiele für den Zugriff auf Daten aus Configmaps. In dem einen Beispiel werden wir Configmaps als Umgebungsvariablen im Pod-Befehl verwenden und in dem anderen Beispiel werden wir ein Volume mit Daten füllen, die in einer ConfigMap gespeichert sind.

Vorraussetzungen

1. Kubernetes Cluster mit mindestens 1 Worker-Knoten.
   Wenn Sie lernen möchten, wie man einen Kubernetes Cluster erstellt, klicken Sie hier. Dieses Handbuch hilft Ihnen, einen Kubernetes-Cluster mit 1 Master- und 2 Worker-Knoten auf AWS Ubuntu 18.04 EC2-Instanzen zu erstellen.

Was werden wir tun?

1. Eine Configmap erstellen und auf ihre Daten zugreifen

Erstellen Sie eine Configmap und greifen Sie auf deren Daten zu.

Erstellen Sie eine Datei mit der folgenden Configmap-Definition.

vim my-configmap-demo1.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-configmap-demo1
data:
  variable_one: one
  variable_two: two

Die Configmap kann mit dem folgenden Befehl erstellt werden.

kubectl create -f my-configmap-demo1.yaml

Erhalten Sie Details der von uns erstellten Configmap.

kubectl get configmaps

kubectl describe configmaps my-configmap-demo1

Im obigen Screenshot sehen Sie, dass wir unsere Daten „variable_eins“ und „variable_zwei“ in der von uns erstellten Configmap zur Verfügung haben.

Auf diese Config-Map kann nun im Pod zugegriffen werden.

Um auf die Daten der Configmap als Umgebungsvariablen in den Pod-Befehlen zuzugreifen, erstellen wir eine Pod-Definitionsdatei mit folgendem Inhalt.

vim my-pod-with-configmaps-as-environment-variables.yml

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-configmap-demo
spec:
  containers:
    - name: my-container-configmap-demo
      image: k8s.gcr.io/busybox
      command: [ "/bin/sh", "-c", "echo $(variable_one_env) $(variable_two_env)" ]
      env:
        - name: variable_one_env
          valueFrom:
            configMapKeyRef:
              name: my-configmap-demo1
              key: variable_one
        - name: variable_two_env
          valueFrom:
            configMapKeyRef:
              name: my-configmap-demo1
              key: variable_two
  restartPolicy: Never

Nun sind wir bereit, eine Pod zu erstellen, die auf Daten aus der Configmap als Umgebungsvariablen zugreifen kann.

kubectl get podss

kubectl create -f my-pod-with-configmaps-as-environment-variables.yml

kubectl get pod

Da der Pod seine Ausführung erfolgreich abgeschlossen hat und existiert, da es keinen Prozess gibt, der die Pods am Leben halten kann, können wir seine Protokolle überprüfen, um festzustellen, ob die Configmap im Pod verfügbar war oder nicht. Um dies zu überprüfen, haben wir den Befehl echo im Pod verwendet, der die Werte der Variablen ausgibt.

kubectl get pods

kubectl logs my-pod-configmap-demo

Im obigen Screenshot ist zu sehen, dass die Configmap-Daten im Pod zugänglich waren und die Werte mit dem echo-Befehl als „eins“ und „zwei“ ausgedruckt wurden.

Die Configmap-Daten sind auch als Dateien in Volumes verfügbar.

Um über das Volume auf die Configmap-Daten zuzugreifen, erstellen Sie eine Pod-Definition mit folgendem Inhalt.

vim my-pod-with-configmaps-added-to-volume.yml

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-configmap-demo2
spec:
  containers:
    - name: my-container-configmap-demo2
      image: k8s.gcr.io/busybox
      command: [ "/bin/sh", "-c", "ls /etc/myconfig/" ]
      volumeMounts:
      - name: my-config-volume
        mountPath: /etc/myconfig
  volumes:
    - name: my-config-volume
      configMap:
        name: my-configmap-demo1
  restartPolicy: Never

Lassen Sie uns nun einen Pod erstellen, der Configmap-Daten als Dateien vom Volume „my-config-volume“ zur Verfügung haben kann. Diese Configmap-Daten werden unter dem Verzeichnis „/etc/myconfig“ in der Pod verfügbar sein.

kubectl get pods

kubectl create -f my-pod-with-configmaps-added-to-volume.yml

kubectl get pods

Auch dieses Mal wurde der Pod erfolgreich beendet, da es keinen Prozess gibt, um den Pod am Leben zu erhalten.

Wir haben jedoch den Befehl „ls /etc/myconfig“ verwendet, der den Inhalt des Verzeichnisses „/etc/myconfig“ auflisten wird.

kubectl get pods

In den Protokollen können wir sehen, dass die Konfigurationsdaten als Dateien unter „/etc/myconfig“ verfügbar waren.

kubectl logs my-pod-configmap-demo2

Im obigen Screenshot sehen Sie, dass die Configmap-Daten in der Pod als „variable_eins“ und „variable_zwei“ Dateien verfügbar waren.

Schlussfolgerung

In diesem Artikel haben wir gelernt, eine Configmap zu erstellen und auf 2 Arten auf sie zuzugreifen. Wir sahen die Schritte zum Zugriff auf die Configmap-Daten als Umgebungsvariablen für den Pod-Befehl und Dateien im Volume im Pod.