Ajout d'un jeton d'authentification de compte de service à un fichier Kubeconfig

Découvrez comment ajouter un jeton d'authentification de compte de service au fichier kubeconfig d'un cluster Kubernetes que vous avez créé à l'aide de Kubernetes Engine (OKE).

Lorsque vous configurez le fichier Kubeconfig d'un cluster, il contient par défaut une commande d'interface de ligne de commande Oracle Cloud Infrastructure en mesure de générer un jeton d'authentification à court terme, niveau cluster et propre à l'utilisateur. Le jeton d'authentification généré par la commande d'interface de ligne de commande permet d'authentifier les utilisateurs individuels qui accèdent au cluster à l'aide de kubectl et du tableau de bord Kubernetes.

Toutefois, le jeton d'authentification généré ne permet pas d'authentifier les processus et les outils qui accèdent au cluster, tels que les outils d'intégration continue et de déploiement continu. Pour garantir leur accès au cluster, ces outils requièrent des jetons d'authentification à long terme qui ne sont pas propres à l'utilisateur.

L'une des solutions consiste à utiliser un compte de service Kubernetes, comme décrit dans cette rubrique. Une fois le compte de service créé, vous le liez à un objet clusterrolebinding disposant de droits d'accès d'administration de cluster. Vous créez un jeton d'authentification pour le compte de service, qui est stocké en tant que clé secrète Kubernetes. Vous pouvez ensuite ajouter le compte de service (et le jeton d'authentification de compte de service associé) en tant que définition utilisateur dans le fichier kubeconfig lui-même. D'autres outils peuvent ensuite utiliser le jeton d'authentification de compte de service lors de l'accès au cluster.

Pour exécuter les commandes de cette rubrique, vous devez disposer des droits d'accès appropriés. Reportez-vous à A propos du contrôle d'accès et du moteur Kubernetes (OKE).

Pour ajouter un jeton d'authentification de compte de service à un fichier Kubeconfig, procédez comme suit :

Si vous ne l'avez pas encore fait, suivez les étapes permettant de configurer le fichier de configuration Kubeconfig du cluster et (si nécessaire) de définir la variable d'environnement KUBECONFIG de sorte qu'elle pointe vers le fichier. Vous devez configurer votre propre fichier Kubeconfig. Vous ne pouvez pas accéder à un cluster à l'aide d'un fichier Kubeconfig configuré par un autre utilisateur. Reportez-vous à Configuration de l'accès à un cluster.
Dans une fenêtre de terminal, créez un compte de service dans l'espace de noms kube-system en saisissant la commande kubectl suivante :
```
kubectl -n kube-system create serviceaccount <service-account-name>
```
Par exemple, pour créer un compte de service nommé kubeconfig-sa, saisissez ce qui suit :
```
kubectl -n kube-system create serviceaccount kubeconfig-sa
```
La sortie de la commande ci-dessus confirme la création du compte de service. Par exemple :
```
serviceaccount/kubeconfig-sa created
```
La création du compte de service dans l'espace de noms kube-system est une bonne pratique recommandée et fait partie des instructions de cette rubrique. Toutefois, si vous préférez, vous pouvez créer le compte de service dans un autre espace de noms auquel vous avez accès.
Créez un objet clusterrolebinding doté de droits d'accès d'administration de cluster et liez-le au compte de service que vous venez de créer en saisissant la commande kubectl suivante :
```
kubectl create clusterrolebinding <binding-name> --clusterrole=cluster-admin --serviceaccount=kube-system:<service-account-name>
```
Par exemple, pour créer un objet clusterrolebinding nommé add-on-cluster-admin et le lier au compte de service kubeconfig-sa, saisissez ce qui suit :
```
kubectl create clusterrolebinding add-on-cluster-admin --clusterrole=cluster-admin --serviceaccount=kube-system:kubeconfig-sa
```
La sortie de la commande ci-dessus confirme la création de l'objet clusterrolebinding. Par exemple :
```
clusterrolebinding.rbac.authorization.k8s.io/add-on-cluster-admin created
```
Obtenez un jeton d'authentification pour le compte de service kubeconfig-sa comme suit :
1. Dans un éditeur de texte, créez un fichier (par exemple, appelé oke-kubeconfig-sa-token.yaml) pour créer une clé secrète (par exemple, nommée oke-kubeconfig-sa-token) avec le contenu suivant :
```
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. Créez le jeton de compte de service en saisissant ce qui suit :
```
kubectl apply -f <filename>
```
  où <filename> est le nom du fichier créé précédemment. Par exemple :
```
kubectl apply -f oke-kubeconfig-sa-token.yaml
```
3. Affichez les détails de la clé secrète en saisissant ce qui suit :
```
kubectl describe secrets oke-kubeconfig-sa-token -n kube-system
```
  La sortie de la commande ci-dessus inclut un jeton d'authentification (une longue chaîne alphanumérique) en tant que valeur de l'élément token:, comme indiqué ci-dessous :
```
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
```
  Dans l'exemple ci-dessus, bxYk______rz15A (abrégé pour plus de lisibilité) est le jeton d'authentification.
Obtenez la valeur du jeton d'authentification de compte de service et affectez-la (une fois décodée à partir du format Base64) à une variable d'environnement. Ces instructions supposent que vous nommiez la variable d'environnement TOKEN. Les commandes à saisir dépendent du système d'exploitation :
- Pour obtenir la valeur du jeton d'authentification de compte de service dans un environnement MacOS, Linux ou Unix, entrez la commande ci-dessous :
```
TOKEN=`kubectl -n kube-system get secret oke-kubeconfig-sa-token -o jsonpath='{.data.token}' | base64 --decode`
```
- Pour obtenir la valeur du jeton d'authentification de compte de service dans un environnement Windows, procédez comme suit :
  1. Saisissez la commande suivante :
```
kubectl -n kube-system get secret oke-kubeconfig-sa-token -o jsonpath='{.data.token}'
```
  2. Copiez la sortie de la commande ci-dessus et collez-la dans un décodeur de format Base64 (par exemple, https://www.base64decode.org, https://www.base64decode.net ou similaire).
  3. Copiez la sortie générée par le décodeur de format Base64.
  4. Saisissez la commande suivante :
```
TOKEN=`[<base64-decoded-output>]`
```
    où <base64-decoded-output> correspond à la sortie que vous avez copiée à partir du décodeur de format Base64.
Ajoutez le compte de service (et son jeton d'authentification) en tant que nouvelle définition utilisateur dans le fichier Kubeconfig en saisissant la commande kubectl suivante :
```
kubectl config set-credentials <service-account-name> --token=$TOKEN
```
Le compte de service (et son jeton d'authentification) est ajouté à la liste des utilisateurs définis dans le fichier Kubeconfig.

Par exemple, pour ajouter le compte de service kubeconfig-sa et son jeton d'authentification au fichier Kubeconfig, saisissez :
```
kubectl config set-credentials kubeconfig-sa --token=$TOKEN
```
La sortie de la commande ci-dessus confirme l'ajout du compte de service au fichier Kubeconfig. Par exemple :
```
User "kubeconfig-sa" set.
```
Définissez l'utilisateur indiqué dans le fichier Kubeconfig pour le contexte en cours en tant que nouvel utilisateur du compte de service que vous avez créé en saisissant la commande kubectl suivante :
```
kubectl config set-context --current --user=<service-account-name>
```
Par exemple :
```
kubectl config set-context --current --user=kubeconfig-sa
```
La sortie de la commande ci-dessus confirme la modification du contexte en cours. Par exemple :
```
Context "context-ctdiztdhezd" modified.
```
(Facultatif) Pour vérifier que l'authentification fonctionne comme prévu, exécutez une commande kubectl afin de s'assurer que l'utilisateur du compte de service peut être authentifié à l'aide du jeton d'authentification de compte de service.

Par exemple, si vous avez déjà déployé une application Nginx échantillon sur le cluster (reportez-vous à Déploiement d'une application Nginx échantillon sur un cluster à l'aide de kubectl), saisissez la commande ci-dessous :
```
kubectl get pods -n kube-system
```
La sortie de la commande ci-dessus indique les pods en cours d'exécution sur le cluster. Lorsque la commande est exécutée correctement, l'utilisateur du compte de service dans le fichier Kubeconfig est authentifié à l'aide du jeton d'authentification de compte de service.
Distribuez le fichier Kubeconfig de manière à permettre à d'autres processus et outils (tels que les outils d'intégration continue et de déploiement continu) d'accéder au cluster.

Remarque

Si vous souhaitez ensuite enlever l'accès au cluster à partir du compte de service, supprimez la clé secrète Kubernetes contenant le jeton d'authentification de compte de service en saisissant la commande ci-dessous :

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

Documentation Oracle Cloud Infrastructure

Ajout d'un jeton d'authentification de compte de service à un fichier Kubeconfig