Aller au contenu

Lab 01 : Déploiement d'un cluster OKS

À l’issue de ce lab, vous serez capable de :

  • installer et configurer octl, l’interface en ligne de commande (CLI) d’OUTSCALE, et kubectl, la CLI de Kubernetes ;
  • créer un projet OKS et un cluster OKS (OUTSCALE Kubernetes as a Service) avec octl ;
  • récupérer le kubeconfig du cluster et le protéger sur votre poste ;
  • ajouter des NodePools (groupes de nœuds de travail) avec octl, puis avec un manifeste Kubernetes ;
  • identifier les nœuds du cluster avec kubectl.

Dans ce lab, vous travaillez depuis le terminal de votre poste de travail, dans la Région eu-west-2.

OKS organise les ressources en deux niveaux :

  • le projet OKS oks-lab01-project regroupe un ou plusieurs clusters. OKS lui associe un Net (réseau virtuel) dédié, dont la plage CIDR est choisie automatiquement (par exemple 10.50.0.0/16) ;
  • le cluster OKS oks-lab01-cluster est créé dans ce projet. Son control plane (plan de contrôle : API Kubernetes, etcd, scheduler) est entièrement géré par OUTSCALE. Vous ne voyez pas ses VMs (machines virtuelles) dans votre compte.

Un cluster nouvellement créé ne contient aucun nœud de travail. Vous ajoutez donc deux NodePools, des groupes de VMs qui exécutent vos Pods, dans la Sous-région eu-west-2a :

  • oks-lab01-nodepool-cli, créé avec octl ;
  • oks-lab01-nodepool-yaml, créé avec un manifeste Kubernetes appliqué par kubectl.

L’accès à l’API Kubernetes du cluster est limité à l’adresse IP publique de votre poste.

Le cluster créé dans ce lab est utilisé par tous les labs suivants du parcours OKS.

Avant de commencer, vous devez disposer :

  • d’un compte OUTSCALE actif ;
  • d’un accès à Cockpit, pour récupérer une access key ;
  • d’un terminal bash ou zsh sur Linux (x86_64) ou macOS, avec curl ;
  • d’une connexion Internet ;
  • de connaissances de base sur les conteneurs et Kubernetes (Pod, Deployment, Service, namespace).

Important : un compte OUTSCALE est limité par défaut à 2 projets OKS et à 2 clusters par projet. Si votre compte a déjà atteint cette limite, la création du projet échoue avec une erreur 403. Vérifiez vos quotas avec octl kube api GetQuotas une fois octl configuré (étape 2).

Ce lab ne réutilise aucune ressource d’un autre lab.

Le lab utilise la région eu-west-2.

Remarque : sous Windows, utilisez WSL (Windows Subsystem for Linux) pour suivre ce lab avec les mêmes commandes.

Important : octl est un projet open source récent, publié par OUTSCALE sur GitHub et en évolution rapide. Ce lab a été rédigé avec octl v0.0.35. Si une commande ne se comporte pas comme décrit, vérifiez votre version avec octl --version et consultez l’aide intégrée avec octl <commande> --help.

octl est distribué sous la forme d’un binaire unique : il n’y a ni dépendance ni environnement virtuel à installer.

Remarque : si vous avez déjà installé et configuré octl dans le Lab 05 du parcours Architecte, passez directement à l’étape 2.3.

  1. Installez octl en suivant uniquement la méthode de votre système.

    Sous Linux (x86_64) : téléchargez la dernière version et installez-la dans /usr/local/bin.

    Terminal window
    curl -L -o octl https://github.com/outscale/octl/releases/latest/download/octl_Linux_x86_64
    chmod +x octl
    sudo mv octl /usr/local/bin

    Sous macOS : installez octl avec Homebrew.

    Terminal window
    brew install octl
  2. Vérifiez l’installation :

    Terminal window
    octl --version

    La commande affiche la version d’octl, par exemple octl version v0.0.35.

  3. Affichez l’aide générale d’octl :

    Terminal window
    octl --help

    La documentation complète est disponible dans le dépôt GitHub d’octl.

L’autocomplétion propose les commandes, les options et certaines valeurs avec la touche Tab. Pour OKS, elle propose aussi les versions de Kubernetes et les tailles de control plane disponibles.

  1. Identifiez votre shell :

    Terminal window
    echo $SHELL

    Le shell par défaut est /bin/zsh sous macOS et /bin/bash sous la plupart des distributions Linux.

  2. Ajoutez le chargement de l’autocomplétion à la fin du fichier de configuration de votre shell, puis rechargez ce fichier.

    Pour bash (~/.bashrc) :

    Terminal window
    echo 'source <(octl completion bash)' >> ~/.bashrc
    source ~/.bashrc

    Remarque : sous Linux, l’autocomplétion de bash nécessite le paquet bash-completion (par exemple sudo apt install bash-completion sous Ubuntu).

    Pour zsh (~/.zshrc) :

    Terminal window
    echo 'autoload -Uz compinit && compinit' >> ~/.zshrc
    echo 'source <(octl completion zsh)' >> ~/.zshrc
    source ~/.zshrc

    Remarque : la ligne compinit active le système de complétion de zsh. Elle doit précéder la ligne octl completion. Si votre ~/.zshrc contient déjà compinit (par exemple avec Oh My Zsh), n’ajoutez que la deuxième ligne.

  3. Tapez octl kube (avec l’espace final), sans valider avec Entrée, puis appuyez deux fois sur Tab : la liste des ressources OKS gérées par octl s’affiche (project, cluster, nodepool, etc.).

octl s’authentifie auprès des API OUTSCALE avec une access key : un couple formé d’un identifiant (Access Key ID) et d’une clé secrète (Secret Key). octl organise vos access keys en profils : un profil associe une access key à une Région.

  1. Dans Cockpit, ouvrez la page de gestion des Access Keys de votre compte.

  2. Créez une nouvelle access key, ou utilisez une access key existante.

  3. Notez l’Access Key ID et la Secret Key.

Important : utilisez une access key du compte OUTSCALE. L’API OKS refuse les access keys des utilisateurs EIM, avec l’erreur 403 Forbidden: User type not allowed.

Attention : la Secret Key donne accès à toutes les ressources de votre compte. Ne la copiez jamais dans un script, un dépôt Git, un message ou une capture d’écran. Dans ce lab, elle est stockée uniquement dans le fichier de configuration de votre répertoire personnel.

  1. Créez un profil nommé default, en remplaçant <ACCESS_KEY_ID> par votre Access Key ID :

    Terminal window
    octl profile add default --ak <ACCESS_KEY_ID> --region eu-west-2
  2. Saisissez votre Secret Key quand octl vous la demande. Elle ne s’affiche pas pendant la saisie et n’apparaît donc pas dans l’historique de votre terminal.

octl enregistre le profil dans le fichier ~/.osc/config.json. Un profil nommé default est utilisé par défaut par toutes les commandes octl.

Remarque : les noms de profils doivent être uniques. Pour travailler avec plusieurs comptes ou plusieurs Régions, créez un profil par compte (par exemple octl profile add formation --ak <ACCESS_KEY_ID> --region eu-west-2), puis ajoutez l’option --profile formation à vos commandes.

  1. Listez les profils configurés :

    Terminal window
    octl profile list

    Exemple de sortie :

    Unable to format as a table, switching to YAML...
    - name: default
    default: true
    access_key: <ACCESS_KEY_ID>
    secret_key: 43...D4
    region: eu-west-2

    octl affiche les profils au format YAML. La Secret Key est masquée : seuls ses deux premiers et ses deux derniers caractères s’affichent.

  2. Affichez le profil actif :

    Terminal window
    octl profile current

    Le profil default s’affiche, avec la Région eu-west-2. La Secret Key est masquée.

  3. Listez vos projets OKS :

    Terminal window
    octl kube project list

    octl affiche un tableau, vide si votre compte ne contient encore aucun projet OKS. Une erreur d’authentification indique une access key incorrecte : recommencez l’étape 2.2.

  4. Affichez les quotas OKS de votre compte :

    Terminal window
    octl kube api GetQuotas

    Le champ Projects indique le nombre maximal de projets OKS, et ClustersPerProject le nombre maximal de clusters par projet. Si octl kube project list affiche déjà autant de projets que la valeur de Projects, vous ne pourrez pas créer le projet du lab.

Les commandes OKS d’octl suivent toutes la même structure : octl kube <ressource> <action>. Les actions courantes sont list, describe, create, update et delete.

kubectl est la CLI officielle de Kubernetes. Vous l’utilisez pour gérer les ressources à l’intérieur du cluster (Pods, Services, NodePools, etc.), alors qu’octl gère les ressources OKS autour du cluster (projets, clusters).

Important : la version de kubectl ne doit pas différer de plus d’une version mineure de celle du cluster. Dans ce lab, le cluster est créé en version 1.35 : installez kubectl 1.35. La dernière version stable de kubectl peut être trop récente (par exemple 1.37).

  1. Installez kubectl en suivant uniquement la méthode de votre système.

    Sous Linux (x86_64) : téléchargez la dernière version 1.35 et installez-la dans /usr/local/bin.

    Terminal window
    curl -LO "https://dl.k8s.io/release/$(curl -Ls https://dl.k8s.io/release/stable-1.35.txt)/bin/linux/amd64/kubectl"
    chmod +x kubectl
    sudo mv kubectl /usr/local/bin/kubectl

    Sous macOS (Apple Silicon) : téléchargez la dernière version 1.35 et installez-la dans /usr/local/bin. Sur un Mac à processeur Intel, remplacez arm64 par amd64.

    Terminal window
    curl -LO "https://dl.k8s.io/release/$(curl -Ls https://dl.k8s.io/release/stable-1.35.txt)/bin/darwin/arm64/kubectl"
    chmod +x kubectl
    sudo mv kubectl /usr/local/bin/kubectl

    stable-1.35.txt renvoie le numéro de la dernière version corrective de kubectl 1.35.

  2. Vérifiez l’installation :

    Terminal window
    kubectl version --client

Les autres méthodes d’installation sont décrites dans la documentation officielle de Kubernetes.

  1. Ajoutez un alias k et l’autocomplétion de kubectl à la fin du fichier de configuration de votre shell.

    Pour bash (~/.bashrc) :

    Terminal window
    alias k='kubectl'
    source <(kubectl completion bash)
    complete -o default -F __start_kubectl k

    Pour zsh (~/.zshrc) :

    Terminal window
    alias k='kubectl'
    source <(kubectl completion zsh)
  2. Rechargez votre configuration :

    Terminal window
    source ~/.bashrc # ou : source ~/.zshrc

Vous pouvez désormais taper k au lieu de kubectl, avec l’autocomplétion. Dans la suite des labs, les commandes sont écrites avec kubectl.

Chaque cluster OKS appartient à un projet. Vous créez d’abord le projet, puis le cluster.

  1. Créez le projet oks-lab01-project :

    Terminal window
    octl kube project create \
    --name oks-lab01-project \
    --description "Projet du parcours OKS"

    octl complète la requête avec le modèle par défaut d’OKS : la Région eu-west-2 de votre profil et une plage CIDR pour le Net du projet. La réponse de l’API s’affiche au format YAML.

    Remarque : vous pouvez imposer la plage CIDR du Net avec l’option --cidr, par exemple --cidr 10.50.0.0/16. Choisissez une plage qui ne chevauche pas celle des Nets avec lesquels le cluster devra communiquer (Labs 05 et 07).

  2. Attendez que le projet soit prêt :

    Terminal window
    octl kube project describe oks-lab01-project --waitfor '.status=="ready"'

    octl interroge l’API toutes les 5 secondes, jusqu’à ce que le projet passe à l’état ready.

  1. Listez vos projets :

    Terminal window
    octl kube project list
  2. Affichez le détail du projet :

    Terminal window
    octl kube project describe oks-lab01-project

    Notez la valeur du champ cidr : c’est la plage d’adresses du Net du projet, dans laquelle les nœuds du cluster recevront leurs IPs privées.

Pour ne pas répéter l’option --project dans chaque commande, définissez oks-lab01-project comme projet par défaut du profil :

Terminal window
octl kube project use oks-lab01-project

Remarque : pour revenir à l’état initial, exécutez octl kube project use sans argument. Dans ce lab, l’option --project est conservée dans les commandes de création, pour que chaque commande reste explicite.

  1. Récupérez votre adresse IP publique :

    Terminal window
    MON_IP=$(curl -s -4 https://api.ipify.org)
    echo $MON_IP

    Votre adresse IP publique s’affiche. Seule cette adresse sera autorisée à joindre l’API Kubernetes du cluster.

  2. Affichez les versions de Kubernetes disponibles :

    Terminal window
    octl kube api GetKubernetesVersions
  3. Affichez les tailles de control plane disponibles :

    Terminal window
    octl kube api GetControlPlanePlans

    Dans ce lab, vous utilisez cp.mono.master : un control plane avec un seul nœud maître, suffisant pour un environnement de formation. Les tailles cp.3.masters.small, cp.3.masters.medium et cp.3.masters.large déploient trois nœuds maîtres, répartis sur plusieurs Sous-régions, pour la haute disponibilité en production.

  1. Créez le cluster oks-lab01-cluster en version 1.35, la version de kubectl installée à l’étape 3 :

    Terminal window
    octl kube cluster create \
    --project oks-lab01-project \
    --name oks-lab01-cluster \
    --version 1.35 \
    --control-plane cp.mono.master \
    --allow-from "$MON_IP/32"
    • --project : projet OKS dans lequel le cluster est créé.
    • --name : nom du cluster, unique dans le projet (lettres minuscules, chiffres et tirets).
    • --version : version de Kubernetes. Elle doit figurer dans la liste affichée à l’étape 5.1. Si vous omettez cette option, octl utilise la version du modèle par défaut d’OKS.
    • --control-plane : taille du control plane.
    • --allow-from : adresses IP ou plages CIDR autorisées à joindre l’API Kubernetes. /32 désigne une seule adresse IP.

    Conseil : l’autocomplétion propose les valeurs possibles de --version et --control-plane : tapez --version puis appuyez deux fois sur Tab.

    La réponse de l’API s’affiche au format YAML. Le champ statuses.status vaut pending : le cluster est en cours de création.

  2. Attendez que le cluster soit prêt. Le déploiement prend généralement 5 à 10 minutes. La commande rend la main, sans rien afficher, quand le cluster passe à l’état ready :

    Terminal window
    octl kube cluster describe oks-lab01-cluster \
    --waitfor '.statuses.status=="ready"' --waitfor-timeout 30m
Terminal window
octl kube cluster describe oks-lab01-cluster

La réponse contient notamment :

  • admin_whitelist : les adresses autorisées à joindre l’API Kubernetes (votre IP en /32) ;
  • cidr_pods et cidr_service : les plages d’adresses internes des Pods et des Services Kubernetes ;
  • statuses.status : l’état du cluster (ready).

kubectl lit l’adresse de l’API Kubernetes et vos identifiants dans un fichier kubeconfig.

  1. Récupérez le kubeconfig du cluster dans le fichier oks-lab01-kubeconfig.yaml, en limitant ses droits à votre seul utilisateur :

    Terminal window
    (umask 077; octl kube cluster kubeconfig oks-lab01-cluster --project oks-lab01-project > oks-lab01-kubeconfig.yaml)

    umask 077 crée le fichier avec les droits 600 : seul votre utilisateur peut le lire.

    Attention : le kubeconfig contient un certificat qui donne un accès administrateur au cluster. Ne le partagez pas et ne le copiez pas dans un dépôt Git. Le Lab 04 revient en détail sur la protection des kubeconfigs.

  2. Indiquez à kubectl d’utiliser ce fichier :

    Terminal window
    export KUBECONFIG=$PWD/oks-lab01-kubeconfig.yaml

    Attention : ne fusionnez pas ce fichier avec d’autres kubeconfigs OKS (par exemple dans ~/.kube/config ou dans une variable KUBECONFIG qui liste plusieurs fichiers). Tous les kubeconfigs générés par OKS nomment leur utilisateur cluster-admin : en cas de fusion, kubectl utilise le certificat d’un autre cluster et l’API répond Unauthorized.

    Remarque : la variable KUBECONFIG est perdue si vous fermez votre terminal. Dans ce cas, exécutez de nouveau la commande export depuis le répertoire qui contient le fichier.

  1. Listez les namespaces du cluster :

    Terminal window
    kubectl get namespaces

    Les namespaces système (default, kube-system, etc.) s’affichent : kubectl communique bien avec l’API Kubernetes du cluster.

  2. Listez les nœuds du cluster :

    Terminal window
    kubectl get nodes

    La commande affiche No resources found : le cluster ne contient encore aucun nœud de travail.

Conseil : octl peut aussi lancer kubectl sans kubeconfig à gérer, en le récupérant et en le renouvelant lui-même : octl kube kubectl --cluster oks-lab01-cluster -- get nodes. Tout ce qui suit -- est passé à kubectl.

Un NodePool est un groupe de VMs de même type, qui deviennent les nœuds de travail du cluster. OKS crée, met à jour et remplace ces VMs pour vous.

  1. Créez le NodePool oks-lab01-nodepool-cli :

    Terminal window
    octl kube nodepool create \
    --project oks-lab01-project \
    --cluster oks-lab01-cluster \
    --name oks-lab01-nodepool-cli \
    --node-type tinav6.c4r6p2 \
    --desired-nodes 3 \
    --zones eu-west-2a
    • --project et --cluster : projet et cluster dans lesquels le NodePool est créé.
    • --name : nom du NodePool.
    • --node-type : type de VM des nœuds. tinav6.c4r6p2 correspond à une VM de génération 6 avec 4 vCPUs, 6 Gio de mémoire et une performance de niveau 2.
    • --desired-nodes : nombre de nœuds souhaité.
    • --zones : Sous-région(s) dans lesquelles les nœuds sont déployés.

    octl part du modèle de NodePool d’OKS et y applique vos options. La réponse affiche notamment les valeurs par défaut de ce modèle : un volume racine (volumes) de 100 Gio de type gp2 par nœud, et autoHealing: true.

  2. Listez les NodePools du cluster :

    Terminal window
    kubectl get nodepools

Remarque : un NodePool est une ressource Kubernetes du cluster. octl la crée en passant par l’API Kubernetes, avec le kubeconfig qu’il récupère lui-même. C’est pourquoi kubectl get nodepools l’affiche.

7.2 Créer un NodePool avec un manifeste Kubernetes

Section intitulée « 7.2 Créer un NodePool avec un manifeste Kubernetes »

Les NodePools peuvent aussi être gérés de manière déclarative, comme toute autre ressource Kubernetes.

  1. Créez un fichier oks-lab01-nodepool.yaml avec le contenu suivant :

    apiVersion: oks.dev/v1beta2
    kind: NodePool
    metadata:
    name: oks-lab01-nodepool-yaml
    spec:
    desiredNodes: 2
    nodeType: tinav7.c2r4p2
    zones:
    - eu-west-2a
    upgradeStrategy:
    maxUnavailable: 1
    maxSurge: 0
    autoUpgradeEnabled: true
    autoUpgradeMaintenance:
    durationHours: 1
    startHour: 12
    weekDay: Tue
    autoHealing: true
    • upgradeStrategy : mise à jour des nœuds un par un (maxUnavailable: 1), sans nœud supplémentaire (maxSurge: 0), automatiquement le mardi entre 12 h et 13 h.
    • autoHealing : OKS remplace automatiquement un nœud défaillant.
  2. Appliquez le manifeste :

    Terminal window
    kubectl apply -f oks-lab01-nodepool.yaml
  3. Listez les NodePools du cluster :

    Terminal window
    kubectl get nodepools

    Les deux NodePools oks-lab01-nodepool-cli et oks-lab01-nodepool-yaml s’affichent : le NodePool créé avec octl est bien une ressource Kubernetes, au même titre que celui créé avec le manifeste.

  1. Attendez que les cinq nœuds soient prêts (quelques minutes). Appuyez sur Ctrl+C pour arrêter la surveillance :

    Terminal window
    kubectl get nodes -w

    Exemple de sortie :

    NAME STATUS ROLES AGE VERSION
    ip-10-50-34-159 Ready <none> 3m v1.35.6
    ip-10-50-42-1 Ready <none> 3m v1.35.6
    ip-10-50-57-106 Ready <none> 3m v1.35.6
    ip-10-50-60-12 Ready <none> 2m v1.35.6
    ip-10-50-62-80 Ready <none> 2m v1.35.6

    Chaque nœud apparaît d’abord à l’état NotReady, le temps que ses composants système démarrent, puis passe à l’état Ready en moins d’une minute. Le nom de chaque nœud reprend son IP privée, prise dans la plage CIDR du projet.

  2. Affichez le détail du premier nœud de la liste :

    Terminal window
    kubectl describe node $(kubectl get nodes -o name | head -n 1)

    kubectl get nodes -o name | head -n 1 renvoie le nom du premier nœud, que la commande describe utilise directement.

    La commande affiche notamment les labels, les taints, la capacité (CPU, mémoire), les conditions et les Pods exécutés sur le nœud.

Pour valider votre lab, vérifiez les points suivants :

  • octl profile current affiche le profil default avec la Région eu-west-2.
  • octl kube project list affiche le projet oks-lab01-project.
  • octl kube cluster describe oks-lab01-cluster affiche status: ready dans la section statuses.
  • octl kube cluster describe oks-lab01-cluster affiche votre IP publique en /32 dans admin_whitelist.
  • Le fichier oks-lab01-kubeconfig.yaml a les droits -rw------- (ls -l oks-lab01-kubeconfig.yaml).
  • kubectl get nodepools affiche oks-lab01-nodepool-cli et oks-lab01-nodepool-yaml.
  • kubectl get nodes affiche cinq nœuds à l’état Ready.
  1. Sans recréer le cluster, ajoutez une deuxième adresse IP autorisée à joindre l’API Kubernetes (par exemple l’IP publique d’un collègue).
  2. Passez le NodePool oks-lab01-nodepool-yaml de 2 à 3 nœuds, puis revenez à 2 nœuds.

Question : Lancez octl iaas vm list. Pourquoi ni le control plane ni les nœuds du cluster n’apparaissent-ils parmi les VMs de votre compte ?

💡 Correction — Ajout d'une adresse IP autorisée

L’option --admin-whitelist de octl kube cluster update remplace la liste complète : indiquez votre IP et la nouvelle.

Terminal window
octl kube cluster update oks-lab01-cluster \
--project oks-lab01-project \
--admin-whitelist "$MON_IP/32,<AUTRE_IP>/32"

Vérifiez avec octl kube cluster describe oks-lab01-cluster.

💡 Correction — Modification du nombre de nœuds

Modifiez la valeur desiredNodes: 3 dans le fichier oks-lab01-nodepool.yaml, puis appliquez-le de nouveau :

Terminal window
kubectl apply -f oks-lab01-nodepool.yaml
kubectl get nodes -w

Remettez ensuite desiredNodes: 2 et appliquez le fichier. Avec une approche déclarative, le manifeste reste la référence de l’état souhaité.

💡 Correction — Question du challenge

OKS est un service managé : le control plane et les nœuds des NodePools sont créés et administrés par OKS. Ils n’apparaissent pas parmi les VMs de votre compte.

Vous gérez le control plane avec octl kube cluster, et les nœuds uniquement à travers les NodePools, avec kubectl ou octl kube nodepool. Il en va de même pour les autres ressources créées par OKS dans les labs suivants : load balancers, volumes BSU, snapshots et connexions VPN.

Attention : ne supprimez aucune ressource de ce lab. Le projet, le cluster, les NodePools et le kubeconfig créés ici sont utilisés par tous les labs suivants du parcours OKS. Leur suppression est décrite à la fin du Lab 07, le dernier lab du parcours.

Conservez les ressources suivantes jusqu’à la fin du parcours OKS :

  • le projet OKS : oks-lab01-project ;
  • le cluster OKS : oks-lab01-cluster ;
  • les NodePools : oks-lab01-nodepool-cli et oks-lab01-nodepool-yaml ;
  • le fichier kubeconfig : oks-lab01-kubeconfig.yaml.

Conseil : si vous faites une pause de plusieurs heures entre deux labs, vous pouvez réduire les coûts en supprimant uniquement les NodePools, qui portent les VMs des nœuds : kubectl delete nodepool oks-lab01-nodepool-cli oks-lab01-nodepool-yaml. Recréez-les ensuite avec les commandes de l’étape 7 : le projet et le cluster restent en place.

Aucune : ce lab ne crée aucune ressource temporaire.