Configuration de l'accès aux grappes

Découvrez les étapes de configuration de l'accès aux grappes que vous créez à l'aide de Kubernetes Engine (OKE). Une fois ces étapes exécutées, vous pouvez commencer à utiliser kubectl pour gérer la grappe.

Pour accéder à une grappe à l'aide de kubectl, vous devez configurer un fichier de configuration Kubernetes (généralement appelé fichier kubeconfig) pour la grappe. Le fichier kubeconfig (nommé config et stocké par défaut dans le répertoire $HOME/.kube) fournit les détails nécessaires pour accéder à la grappe. Une fois le fichier kubeconfig configuré, vous pouvez commencer à utiliser kubectl pour gérer la grappe.

Les étapes à suivre lors de la configuration du fichier kubeconfig dépendent de la façon dont vous voulez accéder à la grappe :

Pour accéder à la grappe à l'aide de kubectl dans Cloud Shell, exécutez une commande de l'interface CLI pour Oracle Cloud Infrastructure dans la fenêtre Cloud Shell afin de configurer le fichier kubeconfig.

Voir Configuration de l'accès aux grappes à l'aide de Cloud Shell.
Pour accéder à la grappe à l'aide d'une installation locale de kubectl :
- Générez une paire de clés de signature d'API (si vous n'en avez pas déjà une).
- Chargez la clé publique de la paire de clés de signature d'API.
- Installez et configurez l'interface de ligne de commande d'Oracle Cloud Infrastructure.
- Configurez le fichier kubeconfig.
Voir Configuration de l'accès local aux grappes.

Configuration de l'accès aux grappes à l'aide de Cloud Shell

Lorsque le point d'extrémité de l'API Kubernetes d'une grappe a une adresse IP publique, vous pouvez accéder à la grappe dans Cloud Shell en configurant un fichier kubeconfig.

Note

Pour accéder à une grappe avec un point d'extrémité d'API Kubernetes privé dans Cloud Shell, vous pouvez configurer un hôte bastion à l'aide du service Oracle Cloud Infrastructure Bastion. Pour plus d'informations, voir Configuration d'un hôte bastion pour l'accès à une grappe.

Pour configurer le fichier kubeconfig :

Étape 1 : Configurer le fichier kubeconfig

Dans la page de liste Grappes, sélectionnez le nom de la grappe à accéder à l'aide de kubectl. Si vous avez besoin d'aide pour trouver la page de liste ou la grappe, voir Liste des grappes.
Sélectionnez le bouton Access Cluster (Accéder à la grappe) pour afficher la boîte de dialogue Access Your Cluster (Accéder à votre grappe).
Sélectionner un accès Cloud Shell.
Sélectionnez Lancer Cloud Shell pour afficher la fenêtre Cloud Shell. Pour plus d'informations sur Cloud Shell (y compris la politique GIA requise), voir Cloud Shell.
Exécutez la commande d'interface CLI d'Oracle Cloud Infrastructure permettant de configurer le fichier kubeconfig et de l'enregistrer dans un emplacement accessible à kubectl.

Par exemple, entrez la commande suivante (ou copiez-la et collez-la à partir de la boîte de dialogue Accéder à votre grappe ) dans la fenêtre Cloud Shell :
```
oci ce cluster create-kubeconfig --cluster-id ocid1.cluster.oc1.phx.aaaaaaaaae... --file $HOME/.kube/config  --region us-phoenix-1 --token-version 2.0.0 --kube-endpoint PUBLIC_ENDPOINT
```
où :
- ocid1.cluster.oc1.phx.aaaaaaaaae... est l'OCID de la grappe courante. Pour des raisons pratiques, la commande figurant dans la boîte de dialogue Accéder à votre grappe inclut déjà l'OCID de la grappe.
- --kube-endpoint PUBLIC_ENDPOINT indique d'ajouter l'adresse IP publique du point d'extrémité de l'API Kubernetes de la grappe au fichier kubeconfig. Pour plus d'informations, voir Plan de contrôle de grappe Kubernetes et API Kubernetes.
Si un fichier kubeconfig existe déjà à l'emplacement indiqué, les détails de la grappe sont ajoutés en tant que nouveau contexte au fichier kubeconfig existant. L'élément current-context: du fichier kubeconfig est défini de manière à pointer vers le contexte qui vient d'être ajouté.

Conseil

Pour les opérations de presse-papiers dans la fenêtre Cloud Shell, les utilisateurs de Windows peuvent utiliser les touches Ctrl-C ou Ctrl-Insérer pour copier et Maj-Insérer pour coller. Pour les utilisateurs de Mac OS, utilisez Cmd-C pour copier et Cmd-V pour coller.
Si vous n'enregistrez pas le fichier kubeconfig à l'emplacement par défaut ($HOME/.kube) ou sous le nom par défaut (config), réglez la valeur de la variable d'environnement KUBECONFIG pour qu'elle pointe vers le nom et l'emplacement du fichier kubeconfig. Par exemple, entrez la commande suivante dans la fenêtre Cloud Shell :
```
export KUBECONFIG=$HOME/.kube/config
```

Étape 2 : Vérifier que kubectl peut accéder à la grappe

Vérifiez que kubectl peut se connecter à la grappe en entrant la commande suivante dans la fenêtre Cloud Shell :

$ kubectl get nodes

Les informations sur les noeuds de la grappe s'affichent.

Vous pouvez maintenant utiliser kubectl pour effectuer des opérations sur la grappe.

Configuration de l'accès local aux grappes

Lorsque le point d'extrémité de l'API Kubernetes d'une grappe n'a pas d'adresse IP publique, vous pouvez accéder à la grappe à partir d'un terminal local si votre réseau est appairé avec le VCN de la grappe.

Note

Pour accéder à une grappe avec un point d'extrémité d'API Kubernetes privé à partir d'un terminal local, vous pouvez également configurer un hôte bastion à l'aide du service Oracle Cloud Infrastructure Bastion. Pour plus d'informations, voir Configuration d'un hôte bastion pour l'accès à une grappe.

Pour configurer le fichier kubeconfig :

Étape 1 : Générer une paire de clés de signature d'API

Si vous disposez déjà d'une paire de clés de signature d'API, passez directement à l'étape suivante. Sinon :

Utilisez les commandes OpenSSL pour générer la paire de clés dans le format PEM requis. Si vous utilisez Windows, vous devez installer Git Bash pour Windows et exécuter les commandes à l'aide de cet outil. Voir Comment générer une clé de signature d'API.
Copiez le contenu de la clé publique dans le presse-papiers (vous devrez la coller dans la console ultérieurement).

Étape 2 : Charger la clé publique de la paire de clés de signature d'API

Pour voir les détails : Dans le menu de navigation , sélectionnez le menu Profil , puis sélectionnez Paramètres de l'utilisateur ou Mon profil, selon l'option que vous voyez.
Sélectionnez Ajouter une clé publique.
Collez la valeur de la clé publique dans la fenêtre et sélectionnez Ajouter.

La clé est chargée et son empreinte numérique s'affiche (par exemple, d1 : b2 : 32 : 53 : d3 : 5f:cf : 68 : 2d:6f:8b:5f : 77 : 8f : 07 : 13).

Étape 3 : Installer et configurer l'interface CLI d'Oracle Cloud Infrastructure

Installez la version 2.6.4 (ou ultérieure) de l'interface CLI d'Oracle Cloud Infrastructure. Voir Installation de l'interface de ligne de commande.
Configurez l'interface CLI d'Oracle Cloud Infrastructure. Voir Configuration de l'interface de ligne de commande.

Étape 4 : Configurer le fichier kubeconfig

Dans la page de liste Grappes, sélectionnez le nom de la grappe à accéder à l'aide de kubectl. Si vous avez besoin d'aide pour trouver la page de liste ou la grappe, voir Liste des grappes.
Sélectionnez le bouton Access Cluster (Accéder à la grappe) pour afficher la boîte de dialogue Access Your Cluster (Accéder à votre grappe).
Sélectionnez Accès local.
Créez un répertoire où placer le fichier kubeconfig. Par défaut, le nom attendu pour ce répertoire est $HOME/.kube.

Par exemple, dans Linux, entrez la commande suivante (ou copiez-la et collez-la à partir de la boîte de dialogue Accéder à votre grappe) dans une fenêtre de terminal locale :
```
mkdir -p $HOME/.kube
```
Exécutez la commande d'interface CLI d'Oracle Cloud Infrastructure permettant de configurer le fichier kubeconfig et de l'enregistrer dans un emplacement accessible à kubectl.

Par exemple, dans Linux, entrez la commande suivante (ou copiez-la et collez-la à partir de la boîte de dialogue Accéder à votre grappe) dans une fenêtre de terminal locale :
```
oci ce cluster create-kubeconfig --cluster-id ocid1.cluster.oc1.phx.aaaaaaaaae... --file $HOME/.kube/config  --region us-phoenix-1 --token-version 2.0.0 --kube-endpoint PRIVATE_ENDPOINT|PUBLIC_ENDPOINT
```
où :
- ocid1.cluster.oc1.phx.aaaaaaaaae... est l'OCID de la grappe courante. Pour des raisons pratiques, la commande figurant dans la boîte de dialogue Accéder à votre grappe inclut déjà l'OCID de la grappe.
- --kube-endpoint PRIVATE_ENDPOINT|PUBLIC_ENDPOINT indique si l'adresse IP privée ou l'adresse IP publique du point d'extrémité de l'API Kubernetes de la grappe doit être ajoutée au fichier kubeconfig. Pour plus d'informations, voir Plan de contrôle de grappe Kubernetes et API Kubernetes.
Si un fichier kubeconfig existe déjà à l'emplacement indiqué, les détails de la grappe sont ajoutés en tant que nouveau contexte au fichier kubeconfig existant. L'élément current-context: du fichier kubeconfig est défini de manière à pointer vers le contexte qui vient d'être ajouté.
Si vous n'enregistrez pas le fichier kubeconfig à l'emplacement par défaut ($HOME/.kube) ou sous le nom par défaut (config), réglez la valeur de la variable d'environnement KUBECONFIG pour qu'elle pointe vers le nom et l'emplacement du fichier kubeconfig. Par exemple, dans Linux, entrez la commande suivante (ou copiez-la et collez-la à partir de la boîte de dialogue Accéder à votre grappe) dans une fenêtre de terminal locale :
```
export KUBECONFIG=$HOME/.kube/config
```

Étape 5 : Vérifier que kubectl peut accéder à la grappe

Vérifiez que kubectl est disponible en entrant la commande suivante dans une fenêtre de terminal locale :
```
kubectl version
```
La réponse affiche les éléments suivants :
- la version de kubectl est installée et exécutée localement
- la version de Kubernetes (la version de kube-apiserver à proprement parler) qui s'exécute sur le noeud de plan de contrôle de la grappe
Notez que la version de kubectl ne doit pas être inférieure ou supérieure de plus d'une version mineure à la version de Kubernetes qui s'exécute sur les noeuds de plan de contrôle. Si kubectl est antérieur ou ultérieur de plus d'une version mineure, installez une version appropriée de kubectl. Voir Version de Kubernetes et politique de prise en charge d'asymétrie de version dans la documentation sur Kubernetes.

Si la commande retourne une erreur indiquant que kubectl n'est pas disponible, installez kubectl (voir la documentation sur kubectl) et répétez cette étape.
Vérifiez que kubectl peut se connecter à la grappe en entrant la commande suivante dans une fenêtre de terminal locale :
```
kubectl get nodes
```
Les informations sur les noeuds de la grappe s'affichent.

Vous pouvez maintenant utiliser kubectl pour effectuer des opérations sur la grappe.

Notes relatives aux fichiers Kubeconfig

Notez les informations suivantes sur les fichiers kubeconfig :

Un fichier kubeconfig peut inclure les détails de plusieurs grappes, en tant que contextes multiples. La grappe sur laquelle les opérations seront effectuées est spécifiée par l'élément current-context: dans le fichier kubeconfig.
Un fichier kubeconfig contient une commande CLI Oracle Cloud Infrastructure qui génère un jeton d'authentification de manière dynamique et l'insère lors de l'exécution d'une commande kubectl. L'interface CLI d'Oracle Cloud Infrastructure doit être disponible dans le chemin des exécutables de l'interpréteur de commandes (par exemple, $PATH sous Linux).
Les jetons générés par la commande d'interface CLI d'Oracle Cloud Infrastructure dans le fichier kubeconfig ont une durée de vie courte, et sont propres à une grappe et associés à des utilisateurs individuels. Ainsi, vous ne pouvez pas partager les fichiers kubeconfig entre plusieurs utilisateurs pour accéder aux grappes Kubernetes.
La commande CLI Oracle Cloud Infrastructure du fichier kubeconfig utilise votre profil de CLI courant lors de la génération d'un jeton d'authentification. Si vous avez défini plusieurs profils dans différentes locations dans le fichier de configuration de l'interface CLI (par exemple, dans ~/.oci/config), indiquez le profil à utiliser lors de la génération du jeton d'authentification comme suit. Dans les deux cas, <profile-name> est le nom du profil défini dans le fichier de configuration de l'interface CLI :
- Ajoutez --profile à la section args: du fichier kubeconfig comme suit :
```
user:
  exec:
    apiVersion: client.authentication.k8s.io/v1beta1
    args:
    - ce
    - cluster
    - generate-token
    - --cluster-id
    - <cluster ocid>
    - --profile
    - <profile-name>
    command: oci
    env: []
```
- Indiquez en tant que valeur de la variable d'environnement OCI_CLI_PROFILE le nom du profil défini dans le fichier de configuration de l'interface CLI avant d'exécuter les commandes kubectl. Par exemple :
```
export OCI_CLI_PROFILE=<profile-name>
```
```
kubectl get nodes
```
Les jetons d'authentification générés par la commande de l'interface de ligne de commande Oracle Cloud Infrastructure dans le fichier kubeconfig sont appropriés pour authentifier des utilisateurs individuels qui accèdent à la grappe à l'aide de kubectl. Les jetons d'authentification générés sont toutefois inadéquats si vous voulez que d'autres processus et outils accèdent à la grappe, tels que les outils d'intégration et de livraison en continu (CI/CD). Dans ce cas, envisagez la création d'un compte de service Kubernetes et l'ajout du jeton d'authentification associé au fichier kubeconfig. Pour plus d'informations, voir Ajout d'un jeton d'authentification de compte de service dans un fichier Kubeconfig.
Une politique IAM a peut-être été définie pour limiter l'accès aux grappes aux utilisateurs qui ont été vérifiés avec l'authentification multifacteur. Si une telle politique existe, vous devez ajouter des arguments --profile et --auth au fichier kubeconfig pour permettre à un utilisateur vérifié par l'authentification multifacteur d'accéder à la grappe à l'aide de kubectl, comme suit. Dans les deux cas, <profile-name> est le nom du profil de l'utilisateur vérifié par l'authentification multifacteur défini dans le fichier de configuration de l'interface CLI d'Oracle Cloud Infrastructure :
- Ajoutez les arguments suivants à la section args: du fichier kubeconfig :
```
    - --profile
    - <profile-name>
    - --auth
    - security_token
```
  Par exemple :
```
user:
  exec:
    apiVersion: client.authentication.k8s.io/v1beta1
    args:
    - ce
    - cluster
    - generate-token
    - --cluster-id
    - <cluster ocid>
    - --profile
    - <profile-name>
    - --auth
    - security_token
    command: oci
    env: []
```
- Réglez la variable d'environnement OCI_CLI_PROFILE au nom du profil de l'utilisateur vérifié par l'authentification multifacteur défini dans le fichier de configuration de l'interface de ligne de commande avant d'exécuter les commandes kubectl. Par exemple :
```
export OCI_CLI_PROFILE=<profile-name>
```
```
kubectl get nodes
```
Après la mise à jour du fichier kubeconfig, l'utilisateur que vous utilisez pour accéder à la grappe doit être vérifié par l'authentification multifacteur. Si vous tentez d'accéder à la grappe à l'aide d'un utilisateur qui n'a pas été vérifié par l'authentification multifacteur, le message error: You must be logged in to the server (Unauthorized) s'affiche.

Pour plus d'informations sur les utilisateurs vérifiés par l'authentification multifacteur, voir Gestion de l'authentification multifacteur.

Mise à niveau des fichiers Kubeconfig de la version 1.0.0 vers la version 2.0.0

Kubernetes Engine prend actuellement en charge les fichiers kubeconfig version 2.0.0 et les fichiers kubeconfig version 1.0.0.

Parmi les nouveautés des fichiers kubeconfig version 2.0.0 figurent des améliorations de sécurité pour l'environnement Kubernetes, notamment des jetons à durée de vie courte propres à une grappe avec actualisation automatique, ainsi que la prise en charge des principaux d'instance pour l'accès aux grappes Kubernetes. De plus, des jetons d'authentification sont générés sur demande pour chaque grappe. Ainsi, les fichiers kubeconfig version 2.0.0 ne peuvent pas être partagés entre plusieurs utilisateurs pour accéder aux grappes Kubernetes (contrairement aux fichiers kubeconfig version 1.0.0).

Notez que les fichiers kubeconfig version 2.0.0 ne sont pas compatibles avec les versions de kubectl antérieures à la version 1.11.9. Si vous exécutez actuellement kubectl version 1.10.x ou antérieure, mettez kubectl à niveau à la version 1.11.9 ou supérieure. Pour plus d'informations sur la compatibilité entre différentes versions de kubernetes et kubectl, voir la documentation relative à Kubernetes.

Suivez les instructions ci-dessous pour déterminer la version courante des fichiers kubeconfig et pour savoir comment mettre à niveau les fichiers kubeconfig version 1.0.0 restants vers la version 2.0.0.

Déterminer la version du fichier kubeconfig

Pour déterminer la version du fichier kubeconfig d'une grappe :

1. Dans une fenêtre de terminal (la fenêtre Cloud Shell ou une fenêtre de terminal locale, selon le cas), entrez la commande suivante pour voir le format du fichier kubeconfig actuellement pointé par la variable d'environnement KUBECONFIG :

kubectl config view

2. S'il s'agit d'un fichier kubeconfig version 1.0.0, une réponse dans le format suivant s'affiche :

users:
- name: <username>
  user:
    token: <token-value>

Si vous voyez une réponse dans le format ci-dessus, vous devez mettre à niveau le fichier kubeconfig. Voir Mise à niveau des fichiers Kubeconfig de la version 1.0.0 vers la version 2.0.0.

3. S'il s'agit d'un fichier kubeconfig version 2.0.0, une réponse dans le format suivant s'affiche :

user:
  exec:
    apiVersion: client.authentication.k8s.io/v1beta1
    args:
    - ce
    - cluster
    - generate-token
    - --cluster-id
    - <cluster ocid>
    command: oci
    env: []

Si vous voyez une réponse dans le format ci-dessus, aucune autre action n'est requise.

Mettre à niveau un fichier kubeconfig version 1.0.0 vers la version 2.0.0

Pour mettre à niveau un fichier kubeconfig version 1.0.0 :

Dans le cas d'une installation locale de kubectl, confirmez que la version 2.6.4 (ou plus récente) de l'interface de ligne de commande d'Oracle Cloud Infrastructure est installée en entrant la commande suivante :
```
oci -version
```
Si la version de l'interface CLI d'Oracle Cloud Infrastructure est antérieure à la version 2.6.4, mettez celle-ci à niveau vers une version ultérieure. Voir Mise à niveau de l'interface CLI.
Suivez les instructions appropriées pour configurer le fichier kubeconfig à utiliser dans Cloud Shell ou localement (voir Configuration de l'accès aux grappes à l'aide de Cloud Shell ou Configuration de l'accès local aux grappes). L'exécution de la commande oci ce cluster create-kubeconfig affichée dans la boîte de dialogue Accéder à votre grappe met à niveau le fichier kubeconfig version 1.0.0 existant. Si vous modifiez le nom ou l'emplacement du fichier kubeconfig, définissez la variable d'environnement KUBECONFIG de sorte qu'elle pointe vers le nouveau nom et le nouvel emplacement du fichier.
Vérifiez que la version du fichier kubeconfig est désormais 2.0.0 :
1. Dans une fenêtre de terminal (la fenêtre Cloud Shell ou une fenêtre de terminal locale, selon le cas), entrez la commande suivante :
```
kubectl config view
```
2. Vérifiez que la réponse qui s'affiche a le format suivant :
```
user:
  exec:
    apiVersion: client.authentication.k8s.io/v1beta1
    args:
    - ce
    - cluster
    - generate-token
    - --cluster-id
    - <cluster ocid>
    command: oci
    env: []
```