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

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

Lorsque vous configurez le fichier kubeconfig pour une grappe, il contient par défaut une commande d'interface CLI Oracle Cloud Infrastructure pour générer un jeton d'authentification de courte durée, applicable à la grappe et propre à utilisateur. Le jeton d'authentification généré par la commande de l'interface CLI convient pour authentifier les utilisateurs individuels qui accèdent à la grappe à l'aide de kubectl et du tableau de bord de Kubernetes.

Ce jeton d'authentification généré ne convient toutefois pas à l'authentification des processus et des outils qui accèdent à la grappe, tels que les outils d'intégration et de livraison en continu (CI/CD). Pour accéder à la grappe, ces outils ont besoin de jetons d'authentification de longue durée et non spécifiques à l'utilisateur.

Une solution consiste à utiliser un compte de service Kubernetes, tel qu'il est décrit dans cette rubrique. Après avoir créé un compte de service, vous devez le lier à une liaison de rôle de grappe disposant des autorisations d'administration de grappe. 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 associé) en tant que définition d'utilisateur dans le fichier kubeconfig. D'autres outils peuvent ensuite utiliser le jeton d'authentification de compte de service lors de l'accès à la grappe.

Notez que pour exécuter les commandes mentionnées dans cette rubrique, vous devez disposer des autorisations appropriées. Voir À 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 :

Si vous ne l'avez pas encore fait, suivez les étapes pour configurer le fichier de configuration kubeconfig de la grappe et (s'il y a lieu) définissez la variable d'environnement KUBECONFIG pour qu'elle pointe vers le fichier. Notez que vous devez configurer votre propre fichier kubeconfig. Vous ne pouvez pas accéder à une grappe à l'aide d'un fichier kubeconfig configuré par un autre utilisateur. Voir Configuration de l'accès aux grappes.
Dans une fenêtre de terminal, créez un nouveau compte de service dans l'espace de noms kube-system en entrant 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, entrez :
```
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
```
Il est à noter que la création du compte de service dans l'espace de noms kube-system est une pratique recommandée, qui est présumée appliquée dans les 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 une nouvelle liaison de rôle de grappe avec les autorisations d'administration des grappes et associez-la au compte de service que vous venez de créer, en entrant la commande kubectl suivante :
```
kubectl create clusterrolebinding <binding-name> --clusterrole=cluster-admin --serviceaccount=kube-system:<service-account-name>
```
Par exemple, pour créer une liaison de rôle de grappe appelée add-on-cluster-admin et la lier au compte de service kubeconfig-sa, entrez :
```
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 la liaison de rôle de grappe. 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 entrant :
```
kubectl apply -f <filename>
```
  où <filename> est le nom du fichier que vous avez créé précédemment. Par exemple :
```
kubectl apply -f oke-kubeconfig-sa-token.yaml
```
3. Voir les détails de la clé secrète en entrant :
```
kubectl describe secrets oke-kubeconfig-sa-token -n kube-system
```
  La sortie de la commande ci-dessus comprend un jeton d'authentification (une chaîne alphanumérique longue) comme 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 du compte de service et affectez cette valeur (décodée de base64) à une variable d'environnement. Ces instructions supposent que vous spécifiez TOKEN comme nom de la variable d'environnement. Les commandes à entrer dépendent du système d'exploitation :
- Pour obtenir la valeur du jeton d'authentification du compte de service dans un environnement MacOS, Linux ou Unix, entrez la commande suivante :
```
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 du compte de service dans un environnement Windows :
  1. Entrez 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 base64 (par exemple, https://www.base64decode.org, https://www.base64decode.net ou similaire).
  3. Copiez la sortie du décodeur base64.
  4. Entrez la commande suivante :
```
TOKEN=`[<base64-decoded-output>]`
```
    où <base64-decoded-output> est la sortie que vous avez copiée à partir du décodeur base64.
Ajoutez le compte de service (et son jeton d'authentification) en tant que nouvelle définition d'utilisateur dans le fichier kubeconfig en entrant 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 dans le fichier kubeconfig, entrez :
```
kubectl config set-credentials kubeconfig-sa --token=$TOKEN
```
La sortie de la commande ci-dessus confirme que le compte de service a été ajouté au fichier kubeconfig. Par exemple :
```
User "kubeconfig-sa" set.
```
Définissez l'utilisateur spécifié dans le fichier kubeconfig de façon que le contexte courant soit le nouvel utilisateur de compte de service que vous avez créé, en entrant 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 que le contexte courant a été modifié. Par exemple :
```
Context "context-ctdiztdhezd" modified.
```
(Facultatif) Pour vérifier que l'authentification fonctionne comme prévu, exécutez une commande kubectl pour confirmer que l'utilisateur de compte de service peut être authentifié avec succès à l'aide du jeton d'authentification de compte de service.

Par exemple, si vous avez déjà déployé un exemple d'application Nginx sur la grappe (voir Déploiement d'un exemple d'application Nginx sur une grappe à l'aide de Kubectl), entrez la commande suivante :
```
kubectl get pods -n kube-system
```
La sortie de la commande ci-dessus indique les pods qui s'exécutent sur la grappe. Si la commande s'exécute correctement, l'utilisateur de compte de service dans le fichier kubeconfig a été authentifié à l'aide du jeton d'authentification de compte de service.
Distribuez le fichier kubeconfig au besoin pour activer d'autres processus et outils (notamment les outils d'intégration et de livraison en continu (CI/CD)) pour accéder à la grappe.

Note

Pour supprimer l'accès du compte de service à la grappe, supprimez la clé secrète Kubernetes contenant le jeton d'authentification de compte de service, en entrant la commande suivante :

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

Documentation sur Oracle Cloud Infrastructure

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