Kubernetes Secrets – So erstellen, verwenden und greifen Sie auf Secrets zu

Einführung

Die meisten Anwendungen, die über Kubernetes bereitgestellt werden, erfordern Zugriff auf Datenbanken, Dienste und andere Ressourcen, die sich extern befinden. Die einfachste Möglichkeit, die für den Zugriff auf diese Ressourcen erforderlichen Anmeldeinformationen zu verwalten, ist die Verwendung von Kubernetes-Secrets. Secrets helfen bei der Organisation und Verteilung vertraulicher Informationen in einem Cluster.

In diesem Tutorial erfahren Sie, was Kubernetes-Secrets sind und wie Sie sie in Ihrem Cluster erstellen und verwenden.

Voraussetzungen

• Ein Kubernetes-Cluster (zu Testzwecken können Sie ihn mit Minikube erstellen)
• Das kubectl-Befehlszeilentool von Kubernetes

Was sind Kubernetes-Geheimnisse?

Ein Kubernetes-Secret ist ein Objekt, das vertrauliche Daten wie Benutzernamen, Passwörter, Token und Schlüssel speichert. Geheimnisse werden vom System während einer App-Installation oder von Benutzern erstellt, wenn sie vertrauliche Informationen speichern und einem Pod zur Verfügung stellen müssen.

Wenn Passwörter, Token oder Schlüssel einfach Teil einer Pod-Definition oder eines Container-Images wären, könnten sie während Kubernetes-Vorgängen versehentlich offengelegt werden. Daher besteht die wichtigste Funktion des Geheimnisses darin, die versehentliche Offenlegung der darin gespeicherten Informationen zu verhindern und sie gleichzeitig dort verfügbar zu machen, wo der Benutzer sie benötigt.

Kubernetes-Secret-Typen

Kubernetes bietet zwei Kategorien von Geheimnissen:

• Die Dienstkonten des Systems erstellen automatisch integrierte Geheimnisse und verknüpfen Sie sie mit Containern zusammen mit API-Anmeldeinformationen.
• Sie können auch benutzerdefinierte Secrets erstellen für Anmeldeinformationen, die Sie Pods zur Verfügung stellen müssen.

Integrierte Geheimnisse gibt es in verschiedenen Arten, die gängigen Nutzungsszenarien entsprechen:

Eingebauter Typ	Beschreibung
Opaque	Dies ist der Standard-Secret-Typ. Die Geheimnisse, deren Konfigurationsdatei die Typanweisung nicht enthält, werden alle als von diesem Typ betrachtet. Undurchsichtige Geheimnisse dienen dazu, beliebige Benutzerdaten zu speichern.
kubernetes.io/service-account-token	Tokengeheimnisse für Dienstkonten speichern Tokens, die Dienstkonten identifizieren. Bei der Erstellung eines Pods erstellt Kubernetes automatisch dieses Geheimnis und ordnet es dem Pod zu, wodurch ein sicherer Zugriff auf die API ermöglicht wird. Dieses Verhalten kann deaktiviert werden.
kubernetes.io/dockercfg	Für den Zugriff auf eine Docker-Registrierung für Images sind gültige Docker-Anmeldeinformationen erforderlich. Diese Art von Geheimnis wird verwendet, um eine serialisierte ~/.dockercfg zu speichern Legacy-Format für die Docker-Befehlszeilenkonfiguration. Es enthält die base64-kodierte .dockercfg Schlüssel.
kubernetes.io/dockerconfigjson	Diese Art von Secret enthält eine .dockerconfigjson Schlüssel, der eine base64-codierte Version von ~/.docker/config.json ist Datei, eine neue Version der veralteten .dockercfg .
kubernetes.io/basic-auth	Das Geheimnis zum Speichern grundlegender Authentifizierungsdaten. Er muss zwei Schlüssel enthalten – username und password .
kubernetes.io/ssh-auth	Zum Speichern von Daten, die zum Herstellen einer SSH-Verbindung erforderlich sind, verwenden Sie ssh-auth Typ. Das Datenfeld dieses Typs muss einen ssh-privatekey enthalten Schlüssel-Wert-Paar.
kubernetes.io/tls	Dieser Typ wird zum Speichern von TLS-Zertifikaten und -Schlüsseln verwendet. Das häufigste Nutzungsszenario ist die Beendigung von Ingress-Ressourcen, aber die tls Typ wird manchmal auch mit anderen Ressourcen verwendet.
bootstrap.kubernetes.io/token	Tokens, die während des Bootstrap-Prozesses des Knotens verwendet werden, werden unter Verwendung des geheimen Typs des Tokens gespeichert. Dieser Typ wird normalerweise im kube-system erstellt Namensraum.

Um einen benutzerdefinierten Secret-Typ zu definieren, weisen Sie dem type eine nicht leere Zeichenfolge als Wert zu Feld der geheimen Akte. Wenn Sie das Feld leer lassen, wird Kubernetes angewiesen, Opaque anzunehmen Typ. Der benutzerdefinierte Typ befreit das Geheimnis von Beschränkungen, die von eingebauten Typen auferlegt werden.

Kubernetes-Secrets verwenden

Wenn Sie ein Geheimnis erstellen, muss es von dem Pod referenziert werden, der es verwenden wird. So machen Sie ein Geheimnis für einen Pod verfügbar:

1. Stellen Sie das Geheimnis als Datei in einem Volume bereit, das für eine beliebige Anzahl von Containern in einem Pod verfügbar ist.

2. Importieren Sie das Geheimnis als Umgebungsvariable in einen Container.

3. Verwenden Sie kubelet und imagePullSecrets Feld.

In den folgenden Abschnitten wird erläutert, wie Sie Kubernetes-Secrets erstellen, entschlüsseln und darauf zugreifen.

Kubernetes-Secrets erstellen

Um ein Kubernetes-Secret zu erstellen, wenden Sie eine der folgenden Methoden an:

• Verwenden Sie kubectl für einen befehlszeilenbasierten Ansatz.
• Erstellen Sie eine Konfigurationsdatei für das Geheimnis.
• Verwenden Sie einen Generator wie Kustomize, um das Geheimnis zu generieren.

Secrets mit kubectl erstellen

1. Beginnen Sie mit der Erstellung eines Secrets mit kubectl , erstellen Sie zuerst die Dateien zum Speichern der vertraulichen Informationen:

echo -n '[username]' > [file1]
echo -n '[password]' > [file2]

Das -n Option sagt echo keine neue Zeile am Ende der Zeichenfolge anhängen. Die neue Zeile wird auch als Zeichen behandelt, also würde sie zusammen mit den restlichen Zeichen kodiert werden und einen anderen kodierten Wert erzeugen.

2. Verwenden Sie jetzt kubectl um ein Geheimnis mit den Dateien aus dem vorherigen Schritt zu erstellen. Verwenden Sie den generischen Unterbefehl, um ein Opaque zu erstellen Geheimnis. Fügen Sie außerdem --from-file hinzu Option für jede der einzuschließenden Dateien:

kubectl create secret generic [secret-name] \  
--from-file=[file1] \
--from-file=[file2]

Die Ausgabe bestätigt die Erstellung des Geheimnisses:

3. Um Schlüssel für im Geheimnis gespeicherte Werte bereitzustellen, verwenden Sie die folgende Syntax:

kubectl create secret generic [secret-name] \  
--from-file=[key1]=[file1] \  
--from-file=[key2]=[file2]

4. Überprüfen Sie, ob das Geheimnis erfolgreich erstellt wurde, indem Sie Folgendes eingeben:

kubectl get secrets

Der Befehl zeigt die Liste der verfügbaren Geheimnisse – ihre Namen, Typen, Anzahl der enthaltenen Datenwerte und ihr Alter:

Secrets in einer Konfigurationsdatei erstellen

1. Um ein Geheimnis zu erstellen, indem Sie die erforderlichen Informationen in einer Konfigurationsdatei angeben, beginnen Sie mit der Codierung der Werte, die Sie speichern möchten:

echo -n '[value1]' | base64
echo -n '[value2]' | base64

2. Erstellen Sie nun mit einem Texteditor eine yaml-Datei. Die Datei sollte folgendermaßen aussehen:

apiVersion: v1
kind: Secret
metadata:  
  name: newsecret
type: Opaque
data:
  username: dXNlcg==
  password: NTRmNDFkMTJlOGZh

3. Speichern Sie die Datei und verwenden Sie kubectl apply Befehl zum Erstellen des Geheimnisses:

kubectl apply -f [file]

Kubernetes Secret mit Generatoren erstellen

Generatoren wie Kustomize helfen dabei, Geheimnisse schnell zu generieren.

1. Um ein Geheimnis mit Kustomize zu erstellen, erstellen Sie eine Datei mit dem Namen kustomization.yaml und formatieren Sie es wie folgt:

secretGenerator:
- name: db-credentials 
  files:
  - username.txt
  - password.txt

Das obige Beispiel besagt db-credentials als Name des Geheimnisses und verwendet zwei zuvor erstellte Dateien, username.txt , und password.txt , als Datenwerte.

2. Um alternativ die unverschlüsselte wörtliche Version der Datenwerte bereitzustellen, fügen Sie die literals ein Abschnitt mit Schlüssel-Wert-Paaren, die Sie speichern möchten:

secretGenerator:
- name: db-credentials
  literals:
  - username=user
  - password=54f41d12e8fa

3. Speichern Sie die Datei und verwenden Sie den folgenden Befehl in dem Ordner, in dem sich kustomization.yaml befindet befindet sich:

kubectl apply -k .

Die Ausgabe bestätigt die Erstellung des Geheimnisses:

Verwenden Sie kubectl description, um erstellte Secrets anzuzeigen

Die kubectl describe Der Befehl zeigt grundlegende Informationen zu Kubernetes-Objekten an. Verwenden Sie es, um die Beschreibung eines Geheimnisses anzuzeigen.

kubectl describe secrets/[secret]

Das erste Beispiel zeigt das Geheimnis, das durch die Bereitstellung von Dateien als Datenwerte erstellt wird:

Das zweite Beispiel beschreibt das mithilfe von Zeichenfolgenliteralen erstellte Geheimnis. Beachten Sie die Änderung in den Data Abschnitt, der jetzt die Namen der Schlüssel anstelle der Dateinamen anzeigt:

Geheimnisse entschlüsseln

1. Um die Werte in einem Geheimnis zu entschlüsseln, greifen Sie darauf zu, indem Sie den folgenden Befehl eingeben:

kubectl get secret [secret] -o jsonpath='{.data}'

Die Ausgabe zeigt die codierten Schlüssel-Wert-Paare, die im Datenabschnitt gespeichert sind:

2. Geben Sie mit dem echo-Befehl die codierte Zeichenfolge ein und leiten Sie die Ausgabe an base64 weiter Befehl:

echo '[encoded-value]' | base64 --decode

Die dekodierten Strings erscheinen als Ausgabe:

Zugriff auf in einem Volume geladene Geheimnisse

1. Um auf Secrets zuzugreifen, die in einem Pod in einem separaten Volume gemountet sind, ändern Sie die Definition des Pods, um ein neues Volume einzuschließen. Wählen Sie einen beliebigen Volume-Namen, aber stellen Sie sicher, dass er mit dem Namen des geheimen Objekts identisch ist.

2. Achten Sie darauf, readOnly anzugeben als wahr. Die Pod-Definition könnte beispielsweise so aussehen:

apiVersion: v1
kind: Pod
metadata:
  name: test-pod
  spec:
    containers:
      - name: test-pod
        image: redis
        volumeMounts:
        - name: newsecret
          mountPath: “/etc/newsecret”
          readOnly: true
    volumes:
    - name: newsecret
      secret:
        secretName: newsecret

2. Öffnen Sie eine andere Terminalinstanz und verwenden Sie kubectl exec Befehl für den Zugriff auf die Bash-Shell des Pods:

kubectl exec -it [pod] -- /bin/bash

3. cd in /etc/newsecret , und finden Sie die im Geheimnis enthaltenen Dateien:

cd /etc/newsecret

Projizieren Sie Geheimnisse mithilfe von Umgebungsvariablen in einen Container

1. Eine andere Möglichkeit, auf Geheimnisse in einem Kubernetes-Pod zuzugreifen, besteht darin, sie als Umgebungsvariablen zu importieren, indem Sie die Pod-Definition so ändern, dass sie Verweise auf sie enthält. Zum Beispiel:

apiVersion: v1 
kind: Pod 
metadata: 
  name: secret-env-pod 
spec: 
  containers: 
  - name: secret-env-pod
    image: redis 
    env: 
      - name: SECRET_USERNAME 
        valueFrom: 
          secretKeyRef: 
            name: newsecret 
            key: username 
      - name: SECRET_PASSWORD 
        valueFrom: 
          secretKeyRef: 
            name: newsecret 
            key: password 
  restartPolicy: Never

2. Verwenden Sie kubectl exec erneut, um in eine Kapsel einzuschlagen.

3. Testen Sie die Umgebungsvariable mit echo Befehl:

echo $[VARIABLE]

Die Befehlsausgabe zeigt den der Variablen zugeordneten Wert:

Secrets verwenden, um Docker-Images aus privaten Docker-Registries abzurufen

1. Um private Docker-Registrierungen zu verwenden, müssen Sie sich zuerst bei Docker anmelden:

docker login

2. Geben Sie bei Aufforderung Ihre Anmeldeinformationen ein:

3. Wenn die Anmeldung erfolgreich ist, aktualisiert Docker die config.json Datei mit Ihren Daten. Verwenden Sie den cat-Befehl, um die Datei anzuzeigen:

cat ~/.docker/config.json

Die auths Abschnitt enthält den auth Schlüssel, der eine verschlüsselte Version der Docker-Anmeldeinformationen ist.

4. Verwenden Sie kubectl um ein Geheimnis zu erstellen, indem Sie den Speicherort von config.json angeben Datei und den Typ des Geheimnisses:

kubectl create secret generic [secret] \
--from-file=.dockerconfigjson=./.docker/config.json \
--type=kubernetes.io/dockerconfigjson

Alternativ können Sie alle oben genannten Schritte, einschließlich der Anmeldung bei Docker, in derselben Zeile ausführen:

kubectl create secret docker-registry [secret] --docker-server:[address] --docker-username=[username] --docker-password=[password] --docker-email=[email]

5. Um einen Pod zu erstellen, der Zugriff auf dieses Geheimnis hat, erstellen Sie eine yaml Datei, die es definiert. Die Datei sollte folgendermaßen aussehen:

apiVersion: v1
kind: Pod
metadata:
  name: private-reg
spec: 
  containers:
  - name: private-reg-container
    image:   
  imagePullSecrets:  
  - name: regcred

6. Beenden Sie die Erstellung des Pods, indem Sie ihn mit kubectl apply aktivieren :

kubectl apply -f [file]

Überlegungen zu Kubernetes Secrets

Kubernetes-Geheimnisse sind eine sichere Möglichkeit, vertrauliche Informationen zu speichern. Bevor Sie sich jedoch für die beste Methode für Ihr Nutzungsszenario entscheiden, sollten Sie die folgenden Punkte berücksichtigen:

• Benutzernamen und Passwörter in Secrets sind mit Base-64 kodiert. Diese Textcodierungstechnik verschleiert Daten und verhindert eine versehentliche Offenlegung, ist jedoch nicht sicher vor böswilligen Cyberangriffen.
• Secrets sind nur in dem Cluster verfügbar, in dem sie sich befinden.
• Geheimnisse beruhen normalerweise auf einem Hauptschlüssel, der verwendet wird, um sie alle zu entsperren. Es gibt zwar Methoden zum Sichern des Hauptschlüssels, aber deren Verwendung erzeugt nur ein weiteres Hauptschlüsselszenario.

Um diese Probleme zu mindern, wenden Sie einige der folgenden Lösungen an:

• Integrieren Sie ein Geheimnisverwaltungstool, das das Kubernetes-Dienstkonto verwendet, um Benutzer zu authentifizieren, die Zugriff auf den geheimen Tresor benötigen.
• Integrieren Sie ein IAM-Tool (Identitäts- und Zugriffsverwaltung), damit das System Token von einem sicheren Token-Dienst verwenden kann.
• Integrieren Sie einen Secrets-Manager eines Drittanbieters in Pods.