Authentifizierungstoken von Serviceaccount zu einer Kubeconfig-Datei hinzufügen

Erfahren Sie, wie Sie der kubeconfig-Datei eines Kubernetes-Clusters, das Sie mit der Kubernetes Engine (OKE) erstellt haben, ein Serviceaccount-Authentifizierungstoken hinzufügen.

Wenn Sie die kubeconfig-Datei für ein Cluster einrichten, enthält diese standardmäßig einen Oracle Cloud Infrastructure-CLI-Befehl, mit dem ein kurzlebiges, clusterbezogenes und benutzerspezifisches Authentifizierungstoken generiert wird. Das vom CLI-Befehl generierte Authentifizierungstoken ist für die Authentifizierung einzelner Benutzer geeignet, die mit kubectl und dem Kubernetes-Dashboard auf das Cluster zugreifen.

Das generierte Authentifizierungstoken ist jedoch nicht zur Authentifizierung von Prozessen und Tools geeignet, die auf das Cluster zugreifen, wie z.B. Tools für kontinuierliche Integration und Bereitstellung (CI/CD). Um Zugriff auf das Cluster sicherzustellen, erfordern derartige Tools langlebige, nicht benutzerspezifische Authentifizierungstoken.

Eine Lösung besteht darin, einen Kubernetes-Serviceaccount zu verwenden, wie in diesem Thema beschrieben. Wenn Sie einen Serviceaccount erstellt haben, binden Sie diesen an ein clusterrolebinding, das Clusteradministrationsberechtigungen besitzt. Sie erstellen ein Authentifizierungstoken für den Serviceaccount, das als Kubernetes-Secret gespeichert wird. Anschließend können Sie den Serviceaccount (und dessen zugehöriges Authentifizierungstoken) als Benutzerdefinition in der kubeconfig-Datei selbst hinzufügen. Andere Tools können dann das Authentifizierungstoken des Serviceaccounts beim Zugriff auf das Cluster verwenden.

Um die Befehle in diesem Thema auszuführen, müssen Sie über die entsprechenden Berechtigungen verfügen. Siehe Info zu Access Control und Kubernetes Engine (OKE).

So fügen Sie ein Serviceaccount-Authentifizierungstoken zu einer kubeconfig-Datei hinzu:

Falls noch nicht geschehen, führen Sie die Schritte zum Einrichten der kubeconfig-Konfigurationsdatei des Clusters aus, und legen Sie (gegebenenfalls) die Umgebungsvariable KUBECONFIG so fest, dass sie auf die Datei verweist. Beachten Sie, dass Sie Ihre eigene kubeconfig-Datei einrichten müssen. Sie können nicht mit einer kubeconfig-Datei, die von einem anderen Benutzer eingerichtet wurde, auf ein Cluster zugreifen. Siehe Clusterzugriff einrichten.
Erstellen Sie in einem Terminalfenster einen neuen Serviceaccount im Namespace "kube-system", indem Sie den folgenden kubectl-Befehl eingeben:
```
kubectl -n kube-system create serviceaccount <service-account-name>
```
Beispiel: Um einen Serviceaccount namens "kubeconfig-sa" zu erstellen, geben Sie Folgendes ein:
```
kubectl -n kube-system create serviceaccount kubeconfig-sa
```
Die Ausgabe aus dem Befehl oben bestätigt die Erstellung des Serviceaccounts. Beispiel:
```
serviceaccount/kubeconfig-sa created
```
Beachten Sie, dass die Erstellung des Serviceaccounts im Namespace "kube-system" empfohlen wird und in den Anweisungen in diesem Thema vorausgesetzt wird. Sie können jedoch auch den Serviceaccount in einem anderen Namespace erstellen, auf den Sie Zugriff haben.
Erstellen Sie ein neues clusterrolebinding mit Clusteradministrationsberechtigungen, und binden Sie es an den gerade erstellten Serviceaccount, indem Sie den folgenden kubectl-Befehl eingeben:
```
kubectl create clusterrolebinding <binding-name> --clusterrole=cluster-admin --serviceaccount=kube-system:<service-account-name>
```
Beispiel: Um ein clusterrolebinding namens "add-on-cluster-admin" zu erstellen und an den Serviceaccount "kubeconfig-sa" zu binden, geben Sie Folgendes ein:
```
kubectl create clusterrolebinding add-on-cluster-admin --clusterrole=cluster-admin --serviceaccount=kube-system:kubeconfig-sa
```
Die Ausgabe aus dem Befehl oben bestätigt die Erstellung des clusterrolebinding. Beispiel:
```
clusterrolebinding.rbac.authorization.k8s.io/add-on-cluster-admin created
```
Rufen Sie wie folgt ein Authentifizierungstoken für den kubeconfig-sa-Serviceaccount ab:
1. Erstellen Sie in einem Texteditor eine Datei (z.B. oke-kubeconfig-sa-token.yaml), um ein Secret (z.B. oke-kubeconfig-sa-token) mit dem folgenden Inhalt zu erstellen:
```
apiVersion: v1
kind: Secret
metadata:
  name: oke-kubeconfig-sa-token
  namespace: kube-system
  annotations:
    kubernetes.io/service-account.name: kubeconfig-sa
type: kubernetes.io/service-account-token
```
2. Erstellen Sie das Serviceaccounttoken, indem Sie Folgendes eingeben:
```
kubectl apply -f <filename>
```
  Hierbei ist <filename> der Name der Datei, die Sie zuvor erstellt haben. Beispiel:
```
kubectl apply -f oke-kubeconfig-sa-token.yaml
```
3. Zeigen Sie die Details des Secrets an, indem Sie Folgendes eingeben:
```
kubectl describe secrets oke-kubeconfig-sa-token -n kube-system
```
  Die Ausgabe aus dem obigen Befehl beinhaltet ein Authentifizierungstoken (eine lange alphanumerische Zeichenfolge) als Wert des Elements token:, wie unten dargestellt:
```
Name:         oke-kubeconfig-sa-token
Namespace:    kube-system
Labels:       <none>
Annotations:  kubernetes.io/service-account.name: kubeconfig-sa
kubernetes.io/service-account.uid: 6d0fda1c-b456-44b3-25fd-4a824bef1936
Type:  kubernetes.io/service-account-token
Data
====
ca.crt:     1289 bytes
namespace:  11 bytes
token:      bxYk______rz15A
```
  Im obigen Beispiel ist bxYk______rz15A (zur besseren Lesbarkeit abgekürzt) das Authentifizierungstoken.
Ermitteln Sie den Wert des Authentifizierungstokens für den Serviceaccount, und weisen Sie diesen Wert (von base64 decodiert) einer Umgebungsvariablen zu. Bei diesen Anweisungen wird davon ausgegangen, dass Sie TOKEN als Namen der Umgebungsvariable angeben. Die Befehle zur Eingabe hängen vom Betriebssystem ab:
- Um den Wert des Authentifizierungstokens für den Serviceaccount in einer MacOS-, Linux- oder Unix-Umgebung abzurufen, geben Sie den folgenden Befehl ein:
```
TOKEN=`kubectl -n kube-system get secret oke-kubeconfig-sa-token -o jsonpath='{.data.token}' | base64 --decode`
```
- So ermitteln Sie den Wert des Authentifizierungstokens für den Serviceaccount in einer Windows-Umgebung:
  1. Geben Sie folgenden Befehl ein:
```
kubectl -n kube-system get secret oke-kubeconfig-sa-token -o jsonpath='{.data.token}'
```
  2. Kopieren Sie die Ausgabe aus dem obigen Befehl, und fügen Sie sie in einen base64-Decodierer ein (Beispiel: https://www.base64decode.org, https://www.base64decode.net oder ähnliche Decodierer).
  3. Kopieren Sie die Ausgabe vom base64-Decodierer.
  4. Geben Sie folgenden Befehl ein:
```
TOKEN=`[<base64-decoded-output>]`
```
    Dabei ist <base64-decoded-output> die Ausgabe, die Sie aus dem base64-Decodierer kopiert haben.
Fügen Sie den Serviceaccount (und dessen Authentifizierungstoken) als neue Benutzerdefinition in der kubeconfig-Datei hinzu, indem Sie den folgenden kubectl-Befehl eingeben:
```
kubectl config set-credentials <service-account-name> --token=$TOKEN
```
Der Serviceaccount und sein Authentifizierungstoken werden der Liste der Benutzer hinzugefügt, die in der kubeconfig-Datei definiert sind.

Beispiel: Um den Serviceaccount "kubeconfig-sa" und das zugehörige Authentifizierungstoken der kubeconfig-Datei hinzuzufügen, geben Sie Folgendes ein:
```
kubectl config set-credentials kubeconfig-sa --token=$TOKEN
```
Die Ausgabe des oben aufgeführten Befehls bestätigt, dass der Serviceaccount der kubeconfig-Datei hinzugefügt wurde. Beispiel:
```
User "kubeconfig-sa" set.
```
Legen Sie den Benutzer, der in der kubeconfig-Datei für den aktuellen Kontext angegeben ist, als den neuen Serviceaccountbenutzer fest, den Sie erstellt haben. Geben Sie dazu den folgenden kubectl-Befehl ein:
```
kubectl config set-context --current --user=<service-account-name>
```
Beispiel:
```
kubectl config set-context --current --user=kubeconfig-sa
```
Die Ausgabe des obigen Befehls bestätigt, dass der aktuelle Kontext geändert wurde. Beispiel:
```
Context "context-ctdiztdhezd" modified.
```
(Optional) Um zu prüfen, ob die Authentifizierung wie erwartet funktioniert, führen Sie einen kubectl-Befehl aus. So bestätigen Sie, dass der Serviceaccountbenutzer erfolgreich mit dem Authentifizierungstoken des Serviceaccounts authentifiziert werden kann.

Beispiel: Wenn Sie zuvor eine Nginx-Beispielanwendung im Cluster bereitgestellt haben (siehe Nginx-Beispielanwendung mit kubectl auf einem Cluster bereitstellen), geben Sie den folgenden Befehl ein:
```
kubectl get pods -n kube-system
```
Die Ausgabe des oben aufgeführten Befehls zeigt die auf dem Cluster ausgeführten Pods an. Wenn der Befehl erfolgreich ausgeführt wird, wurde der Serviceaccountbenutzer in der kubeconfig-Datei erfolgreich mit dem Authentifizierungstoken des Serviceaccounts authentifiziert.
Verteilen Sie die kubeconfig-Datei nach Bedarf, damit andere Prozesse und Tools (wie Tools für kontinuierliche Integration und Bereitstellung (CI/CD)) auf das Cluster zugreifen können.

Hinweis

Wenn Sie den Zugriff auf das Cluster anschließend vom Serviceaccount entfernen möchten, löschen Sie das Kubernetes-Secret, das das Authentifizierungstoken für den Serviceaccount enthält. Geben Sie dazu den folgenden Befehl ein:

kubectl -n kube-system delete secret <secret-name>

Oracle Cloud Infrastructure - Dokumentation

Authentifizierungstoken von Serviceaccount zu einer Kubeconfig-Datei hinzufügen