Auf einen Blick: Kubernetes Secrets speichern sensible Daten wie Passwörter und Token sicher und verhindern so eine Offenlegung im Klartext. Dieser Leitfaden erklärt, wie man Geheimnisse erstellt und verwaltet, einschließlich ihrer Verwendung als Umweltvariablen oder Volumes in Pods.
- Geheimnisse können manuell oder automatisch von Kubernetes erstellt werden.
- Sie können in Pods über Volumenhalterungen oder Umweltvariablen genutzt werden.
In diesem Blogbeitrag werden wir K8s-Geheimnisse besprechen, darunter:
- Was Geheimnisse sind
- Wie man ein Geheimnis erstellt
- Wie man mit Geheimnissen umgeht
Ich nehme an, du hast ein grundlegendes Verständnis von Kubernetes und Konzepten wie Pod, Deployment, Service usw. Um es zu verstehen, brauchst du kubectl und minikube installiert.
Was ist das Geheimnis eines K8s?
Ein Geheimnis, wie der Name schon sagt, sind alle Informationen, die vertraulich behandelt werden müssen, wie Passwort, Token usw. Man kann die Zugangsdaten technisch gesehen direkt in einer Pod-Spezifikation im Klartext einfügen, aber das ist, wie man sich vorstellen kann, nicht sehr sicher. Um das zu lösen, hat Kubernetes das Konzept von Geheimnissen, bei denen man seine sensiblen Informationen sicher speichern und gleichzeitig steuern kann, wie ein Pod sie konsumiert.
Wie schafft man Geheimnisse?
Im Allgemeinen können sowohl der Benutzer als auch Kubernetes selbst ein Geheimnis erstellen. Wenn du nur einen sicheren Zugriff auf die API brauchst, kann K8s automatisch ein Geheimnis an ein Dienstkonto anlegen, das Zugangsdaten enthält, um auf die API zuzugreifen. Das ist die empfohlene Methode, um auf die API zuzugreifen. In der Situation, dass wir ein eigenes Geheimnis für andere Zwecke erstellen müssen, können wir das ebenfalls tun. Nehmen wir zum Beispiel einen Pod, der unsere Anwendung ausführt und auf ein anderes System mit dem Benutzernamen "example-user" und dem Passwort "example-password" zugreifen muss – wie erstellen wir das Secret und sorgen dafür, dass unser Pod die Zugangsdaten erkennt und verwendet? Wir können es manuell erstellen oder mit einer Yaml-Datei oder "kubectl create".
Manuell ein Geheimnis erstellen
Um Secret manuell zu erstellen, müssen wir zuerst die Zeichenkette in base64 konvertieren.
$ echo -n 'example-user' | base64
4oCYZXhhbXBsZS11c2Vy4oCZ
$ echo -n 'example-password' | base64
4oCYZXhhbXBsZS1wYXNzd29yZOKAmQ==
Dann erstellen wir eine Yaml-Datei (example.yaml) mit unseren geheimen Spezifikationen.
apiVersion: v1
kind: Secret
metadata:
name: demo
type: Opaque
data:
username: 4oCYZXhhbXBsZS11c2Vy4oCZ
password: 4oCYZXhhbXBsZS1wYXNzd29yZOKAmQ==
Wir können überprüfen, ob das Geheimnis erstellt wurde
$ kubectl get secret
NAME TYPE DATA AGE
default-token-v8gqd kubernetes.io/service-account-token 3 6m
demo Opaque 2 11s
Wie du siehst, haben wir ein systemgeneriertes Geheimnis und das, das wir gerade erstellt haben. Wir können unser Geheimnis auch beschreiben, nur um sicherzugehen, dass es nicht im Klartext ist.
Type: Opaque
Data
====
username: 18 bytes
password: 22 bytes
Geheimnis mit kubectl erstellen
Wir können auch ein Geheimnis aus einer Datei erstellen, die die Zugangsdaten enthält. Zum Beispiel könnten wir dasselbe Geheimnis erstellen, indem wir den Benutzernamen in einer Datei namens username.txt und Passwort in password.txt speichern. Wir können dann ausführen: "kubectl create secret generic demo-creds --from-file=./username.txt --from-file=./password.txt".
Wie nutzt man das Geheimnis?
Es gibt zwei Wege, das oben geschaffene Geheimnis zu konsumieren:
- Datenvolumen
- Env-Variable
Wir werden beides mit einem einfachen Beispiel demonstrieren.
Consuming Secret in einem Band
Um ein Geheimnis in einem Volume zu konsumieren, müssen wir zunächst sicherstellen, dass das Volumen im Pod-Manifest definiert ist und der Name des Geheimnisses angegeben ist, damit der Container es verwenden kann. Wir können auch Dinge wie Dateipfad und Berechtigungen ändern.
apiVersion: v1
kind: Pod
metadata:
name: volume-pod
spec:
containers:
- name: mycontainer
image: redis
volumeMounts: #We mount our volume
- name: foo
mountPath: "/etc/foo"
readOnly: true
volumes: #We use the volume and defined our secret
- name: foo
secret:
secretName: demo
Wir sehen, dass unser Geheimnis genutzt wird
Volumes:
foo:
Type: Secret (a volume populated by a Secret)
SecretName: demo
Optional: false
default-token-v8gqd:
Type: Secret (a volume populated by a Secret)
SecretName: default-token-v8gqd
Optional: false
Um nun zu überprüfen, dass das Geheimnis das oben definierte ist, können wir "kubectl exec" verwenden, um in den Container zu gelangen und zu prüfen.
$ kubectl exec -ti mypod bash
root@mypod:/data# cat /etc/foo/username
'Example-user'
root@mypod:/data# cat /etc/foo/password
‘example-password’
Wir sehen, dass der Container im Pod tatsächlich die oben erstellten Zugangsdaten verwendet. Als Nächstes sehen wir, wie es aussieht, wenn man dieselbe Secret-in-Env-Variable verwendet.
Consuming Secret in der Env-Variable
apiVersion: v1
kind: Pod
metadata:
name: secret-env-pod
spec:
containers:
- name: mycontainer
image: redis
env:
- name: SECRET_USERNAME
valueFrom:
secretKeyRef:
name: demo #Name of secret
key: username #secret key
- name: SECRET_PASSWORD
valueFrom:
secretKeyRef:
name: demo
key: password
restartPolicy: Never
Wie Sie sehen können, definieren wir statt der Volumes env[].valueFrom.secretKeyRef und beziehen sich auf den Schlüssel im Secret. Schauen wir uns an, wie dieser Pod nach der Erstellung aussieht.
root@secret-env-pod:/data# env | grep SECRET
SECRET_PASSWORD='example-password'
SECRET_USERNAME='example-user'
Abschließende Tipps zu K8s-Geheimnissen
Ein paar weitere Dinge, die Sie beachten sollten:
- Wenn du das bereits verbrauchte Geheimnis aktualisierst, stellt Kubelet sicher, dass der Schlüssel automatisch aktualisiert wird.
- Eine Kapsel ist nicht das einzige Objekt, das ein Geheimnis verwendet, auch andere Teile des Systems können ein Geheimnis verwenden.
- Ein Geheimnis kann von mehr als einer Kapsel konsumiert werden.
Zusätzliche Ressourcen
Für mehr Informationen zu Kubernetes entdecken Sie diese Ressourcen:
Kubernetes-Leitfaden
- Was ist Kubernetes (K8s)? Ein Tutorial zu den Grundlagen von Kubernetes
- Kubernetes Best Practices für verbesserte Cluster-Effizienz
- Best Practices: Wie man Anwendungen für Kubernetes architekt
- Kubernetes Pods: Eine Einführung
- Kubernetes ReplicaSets: Eine kurze Einführung
- Kubernetes-Deployments vollständig erklärt
- Wie man Kubernetes DaemonSets verwendet und verwaltet
- Wie Kubernetes-Dienste funktionieren
- Verwendung von Kubernetes Port, TargetPort und NodePort
- Erstellen und verwenden von ConfigMaps in Kubernetes
- Einführung in Kubernetes-Geheimnisse
- Kubernetes-Netzwerkgrundlagen
- Kubernetes-Ingress erklärt
- Einführung in Kubernetes Helm Charts
- Was ist das Kubernetes-Operator-Muster?
- Bereitstellung von PostgreSQL als StatefulSet in Kubernetes
- Kubernetes Custom Resource Definition (CRDs) erklärt
- 3 Kubernetes-Muster für Cloud-native Anwendungen
- Kubernetes Compute-Ressourcen erklärt
- Kubernetes-Sicherheit für DevOps-Pipelines
- Verwendung von Spinnaker mit Kubernetes für Continuous Delivery
- Kubernetes-Multi-Cluster: Wie und warum man sie verwendet.
- Kubernetes-Überwachung: Ein umfassender Leitfaden
- Kubernetes vs. Docker: Ein kurzer Vergleich
- Kubernetes vs. Docker Swarm: Vergleich von Container-Orchestrierungstools
- Kubernetes vs. OpenShift: Was ist der Unterschied?
- 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.