Déployer un cluster Kubernetes chez OUTSCALE avec OKS

OUTSCALE Kubernetes as a Service (OKS) permet de déployer un cluster Kubernetes managé dans un environnement souverain, conforme aux exigences SecNumCloud 3.2. Grâce à des outils en ligne de commande simples et une gestion via API, OKS offre une solution sécurisée et performante pour orchestrer des applications cloud-natives. Ce guide vous accompagne pas à pas dans la création, le déploiement et la gestion d’un cluster Kubernetes avec OKS.

Présentation d’OUTSCALE Kubernetes as a Service (OKS)

En avril 2024, OUTSCALE, filiale cloud de Dassault Systèmes, a annoncé l’acquisition de Satelliz ↗, une entreprise française experte dans l’exploitation et la supervision de clusters Kubernetes. Cette opération stratégique visait à renforcer les capacités d’OUTSCALE en matière d’orchestration de conteneurs et à intégrer une expertise pointue dans ses offres souveraines.

Suite à cette acquisition, OUTSCALE a progressivement intégré les compétences, technologies et outils de Satelliz dans son infrastructure cloud, avec pour objectif de proposer une solution Kubernetes adaptée aux exigences de conformité, de souveraineté et de performance des entreprises françaises et européennes. Cette intégration a jeté les bases du lancement d’un nouveau service : OUTSCALE Kubernetes as a Service (OKS).

Qu’est-ce qu’OUTSCALE Kubernetes as a Service (OKS) ?

OKS est donc une offre managée qui permet de déployer des clusters Kubernetes dédiés dans un environnement cloud certifié SecNumCloud 3.2, garantissant ainsi un haut niveau d’isolation, de sécurité et de conformité réglementaire. Les clusters sont hébergés sur des ressources physiques isolées, et chaque client dispose de son propre environnement, distinct des autres utilisateurs.

Accessible via une interface en ligne de commande (OKS CLI) et une API REST, OKS permet de déployer un cluster en quelques minutes, de manière automatisée. Avec cette offre, OUTSCALE vise à fournir une solution cloud souveraine, adaptée aux besoins des organisations sensibles, tout en tirant parti des standards ouverts de l’écosystème Kubernetes.

Concepts clés d’OUTSCALE Kubernetes as a Service (OKS)

OUTSCALE Kubernetes as a Service (OKS) repose sur une architecture modulaire et sécurisée, facilitant la gestion des ressources Kubernetes. Les principaux éléments à comprendre sont les profils, les projets, les clusters et les nodepools.

Pour mieux visualiser ces concepts, voici un schéma récapitulatif :

Voici une explication très simple pour comprendre le schéma :

• Un profil, c’est un utilisateur ou une équipe.
• Chaque profil a plusieurs projets (par exemple : dev, test, prod).
• Dans chaque projet, on peut créer des clusters Kubernetes.
• Chaque cluster utilise des nodepools, c’est-à-dire des groupes de machines pour faire tourner les applications.
• Certains nodepools sont spéciaux, avec des GPU pour des workload de type IA.

C’est comme une arborescence : Profil → Projet → Cluster → Nodepools.

Profils OKS

Un profil OKS représente un compte OUTSCALE configuré pour interagir avec l’OKS CLI. Chaque profil est associé à des identifiants spécifiques (login/mot de passe ou clés d’accès) et à une région de déploiement.

L’utilisation de profils permet de :

• Isoler les environnements : séparer les projets par client ou par département.
• Gérer les accès : attribuer des droits spécifiques à chaque utilisateur.
• Suivre les coûts : associer des comptes de facturation distincts pour une meilleure gestion financière.

Projets

Un projet est une entité logique regroupant des clusters et d’autres ressources associées. Il permet d’organiser et d’isoler les ressources cloud, facilitant ainsi la gestion et la facturation.

Chaque projet nécessite la réservation d’un bloc CIDR pour le réseau :

• CIDR : plage d’adresses IP utilisée pour les sous-réseaux VPC.
• Tags : métadonnées associées pour une meilleure identification.

Attention : Une fois le projet créé, le CIDR ne peut plus être modifié.

Clusters

Un cluster OKS est un cluster Kubernetes déployé selon une configuration spécifiée. Lors de la création d’un cluster avec OUTSCALE Kubernetes as a Service (OKS), vous devez choisir un type de plan de contrôle (control plane) adapté à vos besoins en termes de performances, de haute disponibilité (HA) et de capacité. Chaque option définit les ressources allouées au plan de contrôle, influençant ainsi la scalabilité et la résilience de votre cluster.

• cp.mono.master :

  • Description : Un seul nœud maître dédié avec 4 Gio de RAM.
  • Haute disponibilité : Non.
  • Mise à niveau : Non.
  • Taille maximale recommandée du cluster : Jusqu’à 10 nœuds.
  • Usage recommandé : Environnements de test ou clusters éphémères.
  • Limitations :
    • Pas d’options de haute disponibilité.
    • Pas d’accord de niveau de service (SLA) applicable.
    • Non adapté à une utilisation en production ou à long terme.
    • Impossible de le mettre à niveau vers une autre taille ; une recréation est nécessaire pour changer de configuration.

• cp.3.masters.small :

  • Description : Trois nœuds maîtres dédiés, chacun avec 4 Gio de RAM.
  • Haute disponibilité : Oui.
  • Mise à niveau : Oui.
  • Taille maximale recommandée du cluster : Jusqu’à 50 nœuds.
  • Usage recommandé : Petits environnements de production ou de développement nécessitant une haute disponibilité.

• cp.3.masters.medium :

  • Description : Trois nœuds maîtres dédiés, chacun avec 8 Gio de RAM.
  • Haute disponibilité : Oui.
  • Mise à niveau : Oui.
  • Taille maximale recommandée du cluster : Jusqu’à 200 nœuds.
  • Usage recommandé : Environnements de production de taille moyenne avec des charges de travail modérées.

• cp.3.masters.large :

  • Description : Trois nœuds maîtres dédiés, chacun avec 16 Gio de RAM.
  • Haute disponibilité : Oui.
  • Mise à niveau : Oui.
  • Taille maximale recommandée du cluster : Jusqu’à 400 nœuds.
  • Usage recommandé : Grands environnements de production avec des charges de travail élevées nécessitant une haute disponibilité renforcée.

Remarques importantes :

• Le choix du type de plan de contrôle n’affecte pas la disponibilité des outils de gestion des clusters.
• La taille maximale recommandée du cluster est basée sur des environnements à faible charge. Des clusters de production à forte charge peuvent nécessiter un plan de contrôle d’une plus grande taille.

Lors de la création d’un cluster, il est possible de spécifier :

• Nom du cluster : identifiant unique.
• Version de Kubernetes : version souhaitée.
• Type de plan de contrôle : détermine les caractéristiques matérielles.
• Plages CIDR pour pods et services : configuration réseau.

Nodepools

Un nodepool est un groupe de nœuds de travail homogènes au sein d’un cluster OKS. Chaque nodepool contient des nœuds du même type, situés dans une seule région ou répartis sur plusieurs sous-régions.

Caractéristiques des nodepools :

• Homogénéité : tous les nœuds ont le même type TINA.
• Flexibilité : possibilité de créer plusieurs nodepools pour un cluster et d’y attacher des GPU.
• Gestion simplifiée : ajout ou suppression de nœuds sans perturber la disponibilité du cluster.

Note : Les nœuds de travail ne sont ni visibles ni directement accessibles dans votre compte OUTSCALE, conformément aux meilleures pratiques Kubernetes.

Installation et configuration de l’OKS CLI

OKS CLI est l’outil en ligne de commande fourni par OUTSCALE pour gérer vos projets, clusters et nodepools dans l’environnement OKS. Il permet de piloter l’ensemble de votre infrastructure Kubernetes directement depuis un terminal.

Prérequis système

Avant d’installer l’OKS CLI, assurez-vous que votre environnement dispose des éléments suivants :

• Python 3.11 ou supérieur
• pip (le gestionnaire de paquets Python)
• virtualenv (optionnel mais recommandé pour isoler les dépendances)
• kubectl doit être installé au moment de la création des nodepools.

Étapes d’installation

Commençons par vérifier que vous disposez de Python 3.11 ou supérieur, car l’OKS CLI nécessite cette version minimale.

python3 --version

Si la version est inférieure à 3.11, installez une version plus récente avec pyenv ou brew par exemple.

Créez ensuite un environnement virtuel pour isoler les dépendances de l’OKS CLI :

python3 -m venv oks-env
source oks-env/bin/activate

Ensuite, mettez à jour pip pour vous assurer que vous disposez de la dernière version :

pip install --upgrade pip

Installez l’OKS CLI en utilisant pip :

pip install https://docs.eu-west-2.oks.outscale.com/oks-cli/oks_cli-latest.zip

Note : Vous pouvez aussi installer oks-cli avec pipx.

Vous pouvez ensuite vérifier l’installation avec :

oks-cli --help

Configuration de l’OKS CLI

Activation de l’autocomplétion

L’OKS CLI prend en charge l’autocomplétion pour les commandes, sous-commandes et paramètres. Pour l’activer, vous devez générer les scripts d’autocomplétion pour votre shell préféré (Bash, Zsh ou Fish) et les ajouter à votre configuration de shell.

• Pour Bash :

mkdir -p ~/.oks_cli/completions
_OKS_CLI_COMPLETE=bash_source oks-cli > $HOME/.oks_cli/completions/oks-cli.bash
echo '. $HOME/.oks_cli/completions/oks-cli.bash' >> $HOME/.bashrc
source $HOME/.oks_cli/completions/oks-cli.bash

• Pour Zsh :

mkdir -p ~/.oks_cli/completions
_OKS_CLI_COMPLETE=zsh_source oks-cli > $HOME/.oks_cli/completions/oks-cli.zsh
echo '. $HOME/.oks_cli/completions/oks-cli.zsh' >> $HOME/.zshrc
source $HOME/.oks_cli/completions/oks-cli.zsh

• Pour Fish :

mkdir -p ~/.oks_cli/completions
_OKS_CLI_COMPLETE=fish_source oks-cli > $HOME/.config/fish/completions/oks-cli.fish

Ajout d’un profil OKS

Dans un premier temps, vous devez configurer un profil OKS. Deux méthodes d’authentification sont disponibles :

Par identifiants (login/mot de passe) :

oks-cli profile add \
  --profile-name "default" \
  --username "MON_LOGIN" \
  --password "MON_MOT_DE_PASSE" \
  --region "eu-west-2"

Par clés d’accès (access key/secret key) :

oks-cli profile add \
  --profile-name "default" \
  --access-key "MA_ACCESS_KEY" \
  --secret-key "MA_SECRET_KEY" \
  --region "eu-west-2"

Remarque : L’authentification utilise un mot de passe à usage unique (OTP) si l’authentification multifacteur est activée.

Les profils sont enregistrés dans le fichier ~/.oks_cli/config.json. Vous pouvez y gérer plusieurs profils pour différents environnements ou régions.

Consultation des projets

Pour lister tous les projets existants :

oks-cli project list

+------+---------+---------+--------+---------+
| NAME | CREATED | UPDATED | STATUS | DEFAULT |
+------+---------+---------+--------+---------+
+------+---------+---------+--------+---------+

Cette commande affiche les colonnes suivantes :

• NAME : Nom du projet.
• CREATED : Temps écoulé depuis la création.
• UPDATED : Temps écoulé depuis la dernière mise à jour.
• STATUS : État actuel (pending, ready, deleting).
• DEFAULT : Indique si le projet est défini par défaut (*).

Création et gestion des projets OKS

Dans OUTSCALE Kubernetes as a Service (OKS), un projet constitue une entité logique regroupant des clusters et des ressources associées. Il permet d’organiser, d’isoler et de contrôler les environnements, facilitant ainsi la gestion et la facturation.

Création d’un projet

Pour créer un projet, utilisez la commande suivante :

oks-cli project create \
    --project-name "mon-projet" \
    --description "Mon premier projet" \
    --cidr "10.50.0.0/16" \
    --tags "environnement=dev,projet=toto"
  {
      "id": "c4f5d04b-3cdd-4ba7-967e-a8840a5655b7",
      "name": "mon-projet",
      "description": "Mon premier projet",
      "cidr": "10.50.0.0/16",
      "region": "eu-west-2",
      "status": "pending",
      "tags": {
          "environnement": "dev",
          "projet": "toto"
      },
      "disable_api_termination": false,
      "created_at": "2025-06-06T16:09:59.306439Z",
      "updated_at": "2025-06-06T16:09:59.306439Z",
      "deleted_at": null
  }

Paramètres :

• --project-name : Nom unique du projet.
• --description : Description facultative.
• --cidr : Plage d’adresses IP au format CIDR pour les sous-réseaux VPC.
• --tags : Paires clé=valeur pour catégoriser le projet.

Remarques :

• Le CIDR doit être un bloc privé conforme à la RFC 1918, avec une taille minimale de /23.
• Le CIDR 172.31.0.0/16 est réservé et ne doit pas être utilisé.
• Une fois le projet créé, le CIDR ne peut plus être modifié.

Un projet est créé dans un état pending et passe à ready une fois toutes les ressources nécessaires provisionnées. Vous pouvez vérifier l’état du projet avec la commande oks-cli project list.

oks-cli project list
+------------+---------------+---------------+------------+---------+
|    NAME    |    CREATED    |    UPDATED    |   STATUS   | DEFAULT |
+------------+---------------+---------------+------------+---------+
| mon-projet | 3 minutes ago |  a second ago |   ready    |    *    |
+------------+---------------+---------------+------------+---------+

Ici mon projet est dans l’état ready, ce qui signifie qu’il est prêt à être utilisé. Il est donc possible d’y créer des clusters.

Définir un projet par défaut

Pour définir un projet comme projet par défaut :

oks-cli project login \
    --project-name "mon-projet"
Logged into project: mon-projet

Le projet est toujours en cours de création, mais il est déjà défini comme projet par défaut. Vous pouvez vérifier cela avec la commande oks-cli project list.

Mise à jour d’un projet

Certaines propriétés d’un projet peuvent être modifiées après sa création :

oks-cli project update \
    --project-name "mon-projet" \
    --tags "environnement=prod,projet=beta"

Paramètres modifiables :

• --disable-api-termination : Empêche la suppression du projet via l’API si défini sur true.
• --tags : Met à jour les tags associés au projet.

Suppression d’un projet

Pour supprimer un projet :

oks-cli project delete \
    --project-name "NOM_DU_PROJET"

Conditions :

• Le projet ne doit contenir aucun cluster actif.
• Si --disable-api-termination est défini sur true, il doit être réinitialisé à false avant la suppression.

Création et gestion des clusters OKS

Dans OUTSCALE Kubernetes as a Service (OKS), un cluster est une instance Kubernetes managée, composée d’un plan de contrôle (control plane) et de nœuds de travail (worker nodes). Le plan de contrôle est entièrement géré par OUTSCALE, assurant la gestion et la coordination des ressources du cluster. Lors de la création d’un cluster, seul le plan de contrôle est créé ; les nœuds de travail doivent être ajoutés ultérieurement via des nodepools.

Création d’un cluster

Utilisez la commande suivante pour créer un cluster :

oks-cli cluster create \
    --project-name "mon-projet" \
    --cluster-name "mon-cluster" \
    --admin "1.2.3.4/32" \
    --control-plane "cp.3.masters.small" \
    --version "1.31"

{
    "project_id": "c4f5d04b-3cdd-4ba7-967e-a8840a5655b7",
    "id": "933d1896-9d94-4033-8ae8-0b1c63feb404",
    "name": "mon-cluster",
    "description": null,
    "cp_multi_az": false,
    "cp_subregions": [
        "2a"
    ],
    "version": "1.31",
    "cni": "cilium",
    "admin_lbu": false,
    "admission_flags": {
        "disable_admission_plugins": [],
        "enable_admission_plugins": [],
        "applied_admission_plugins": [
            "RuntimeClass",
            "DefaultTolerationSeconds",
            "PodSecurity",
            "ServiceAccount",
            "LimitRanger",
            "DefaultStorageClass",
            "ResourceQuota",
            "DefaultIngressClass",
            "ValidatingAdmissionPolicy",
            "Priority",
            "PersistentVolumeClaimResize",
            "NamespaceLifecycle",
            "CertificateSigning",
            "MutatingAdmissionWebhook",
            "ValidatingAdmissionWebhook",
            "ClusterTrustBundleAttest",
            "StorageObjectInUseProtection",
            "CertificateSubjectRestriction",
            "CertificateApproval",
            "TaintNodesByCondition"
        ]
    },
    "cidr_pods": "10.91.0.0/16",
    "cidr_service": "10.92.0.0/16",
    "cluster_dns": "10.92.0.10",
    "tags": {},
    "auto_maintenances": {
        "minor_upgrade_maintenance": {
            "enabled": true,
            "duration_hours": 1,
            "start_hour": 12,
            "week_day": "Tue",
            "tz": "UTC"
        },
        "patch_upgrade_maintenance": {
            "enabled": true,
            "duration_hours": 1,
            "start_hour": 12,
            "week_day": "Tue",
            "tz": "UTC"
        }
    },
    "control_planes": "cp.3.masters.small",
    "admin_whitelist": [
        "1.2.3.4/32"
    ],
    "statuses": {
        "created_at": "2025-06-07T07:32:38.835841Z",
        "deleted_at": null,
        "updated_at": "2025-06-07T07:32:38.835841Z",
        "status": "pending",
        "available_upgrade": ""
    },
    "disable_api_termination": false
}

Paramètres :

• --project-name : Nom du projet existant.
• --cluster-name : Nom unique du cluster (jusqu’à 40 caractères alphanumériques et tirets).
• --admin : Liste des CIDR autorisés à accéder au cluster.
• --control-plane : Type de plan de contrôle souhaité.
• --version : Version de Kubernetes à déployer.

Remarque : Le nom du cluster ne doit pas commencer ou se terminer par un tiret.

Comptez environ 10 minutes pour que le cluster soit créé et passe à l’état ready.

Lister les clusters

Pour afficher la liste des clusters dans un projet :

oks-cli cluster list \
    --project-name "mon-projet"
+--------------------------------------+-------------+---------------+---------------+------------+---------+
|                  ID                  |     NAME    |    CREATED    |    UPDATED    |   STATUS   | DEFAULT |
+--------------------------------------+-------------+---------------+---------------+------------+---------+
| 933d1896-9d94-4033-8ae8-0b1c63feb404 | mon-cluster |  a minute ago |  a minute ago |  pending   |         |
+--------------------------------------+-------------+---------------+---------------+------------+---------+

Cette commande retourne les informations suivantes :

• NAME : Nom du cluster.
• CREATED : Temps écoulé depuis la création.
• UPDATED : Temps écoulé depuis la dernière mise à jour.
• STATUS : État actuel du cluster (pending, ready, deleting).

Obtenir des informations sur un cluster

Pour obtenir des détails sur un cluster spécifique :

oks-cli cluster get -c mon-cluster \
    --project-name "mon-projet" \

Cette commande fournit des informations détaillées sur le cluster, y compris sa configuration, son état et ses ressources associées.

Mise à jour d’un cluster

Certaines propriétés d’un cluster peuvent être modifiées après sa création. Par exemple, pour mettre à jour la liste des CIDR autorisés :

oks-cli cluster update \
    --project-name "mon-projet" \
    --cluster-name "mon-cluster" \
    --admin "5.6.7.8/32"

Remarque :

• Les paramètres project-name et profile ne peuvent pas être modifiés après la création du cluster.
• Lors de la mise à jour, le cluster doit être dans un état ready.
• La mise à jour met le cluster dans un état updating jusqu’à ce que la modification soit appliquée.

Suppression d’un cluster

Pour supprimer un cluster :

oks-cli cluster delete \
    --project-name "mon-projet" \
    --cluster-name "mon-cluster"

Conditions :

• Le cluster doit être dans un état ready.
• Aucun nodepool ne doit être associé au cluster.

Création et gestion des nodepools OKS

Dans OUTSCALE Kubernetes as a Service (OKS), un nodepool est un groupe homogène de nœuds de travail (worker nodes) au sein d’un cluster. Chaque nodepool contient des nœuds du même type TINA, situés dans une seule région ou répartis sur plusieurs sous-régions.

Création d’un nodepool

Utilisez la commande suivante pour créer un nodepool :

oks-cli cluster \
    --project-name "mon-projet" \
    --cluster-name "mon-cluster" \
    nodepool create \
    --nodepool-name "mon-nodepool" \
    --count 2 \
    --type "tinav6.c1r1p2"
nodepool.oks.dev/mon-nodepool created

Paramètres :

• --project-name : Nom du projet existant.
• --cluster-name : Nom du cluster existant.
• --nodepool-name : Nom unique du nodepool.
• --count : Nombre de nœuds à créer.
• --type : Type de nœud, au format tinavW.cXrYpZ (par exemple, tinav6.c1r1p2) ou tinav6.c1r1p2.gpu pour un nodepool avec GPU.
• --zone : (optionnel) Sous-région où déployer les nœuds.

Remarque :

• Tous les nœuds d’un nodepool doivent être du même type. Si vous avez besoin de types différents, créez plusieurs nodepools correspondants.
• Le cluster doit être dans un état ready avant de pouvoir y ajouter des nodepools.
• L’IP depuis la machine où vous exécutez la commande doit être autorisée dans la liste des admins du cluster.

Lister les nodepools

Pour afficher la liste des nodepools d’un cluster :

oks-cli cluster nodepool \
    --project-name "mon-projet" \
    --cluster-name "mon-cluster" \
    list
NAME           TYPE            DESIRED NODES   ATTACHED   READY   RUNNING   PENDING   STOPPING   STOPPED   SHUTTING DOWN   CURRENT PROCESSING PHASE   LAST ERROR
mon-nodepool   tinav6.c1r1p2   2               0          0       0         2         0          0         0               creation                   None

Cette commande retourne les informations suivantes :

• NAME : Nom du nodepool.
• TYPE : Type de nœud.
• DESIRED NODES : Nombre de nœuds souhaités.
• ATTACHED : Nombre de nœuds attachés.
• READY : Nombre de nœuds prêts.
• RUNNING : Nombre de nœuds en cours d’exécution.
• PENDING : Nombre de nœuds en attente.
• STOPPING : Nombre de nœuds en cours d’arrêt.
• STOPPED : Nombre de nœuds arrêtés.
• SHUTTING DOWN : Nombre de nœuds en cours de suppression.
• CURRENT PROCESSING PHASE : Phase de traitement actuelle.
• LAST ERROR : Dernière erreur rencontrée.

Suppression d’un nodepool

Pour supprimer un nodepool :

oks-cli cluster nodepool \
    --project-name "NOM_DU_PROJET" \
    --cluster-name "NOM_DU_CLUSTER" \
    delete \
    --nodepool-name "NOM_DU_NODEPOOL"

Remarque : La suppression d’un nodepool entraîne la suppression de tous les nœuds associés.

Récupération du fichier kubeconfig

OUTSCALE Kubernetes as a Service (OKS) permet d’interagir avec un cluster via kubectl. Pour cela, il est nécessaire de générer un fichier kubeconfig contenant les informations d’accès au cluster.

Prérequis

• Un cluster OKS dans un état ready
• L’OKS CLI installé et configuré
• kubectl installé sur votre machine

Récupérer le fichier kubeconfig

Utilisez la commande suivante pour récupérer le kubeconfig :

oks-cli cluster \
  kubeconfig
  --project-name "mon-projet" \
  --cluster-name "mon-cluster" \
  --print-path

Le fichier est généré dans le répertoire ~/.oks_cli :

/home/outscale/.oks_cli/cache/c4f5d04b-3cdd-4ba7-967e-a8840a5655b7-933d1896-9d94-4033-8ae8-0b1c63feb404/default/default/kubeconfig

Utiliser le kubeconfig avec kubectl

Définissez la variable d’environnement KUBECONFIG pour pointer vers le fichier généré :

export KUBECONFIG=`oks-cli cluster kubeconfig --project-name "mon-projet" --cluster-name "mon-cluster" --print-path`

Vous pouvez ensuite interroger le cluster :

kubectl get nodes
NAME              STATUS   ROLES    AGE     VERSION
ip-10-50-59-222   Ready    <none>   6m54s   v1.31.2
ip-10-50-59-77    Ready    <none>   6m54s   v1.31.2

Bonnes pratiques de sécurité

• Le fichier kubeconfig contient des informations sensibles : stockez-le dans un répertoire sécurisé.
• Il est possible de régénérer le fichier à tout moment via la même commande.
• Le kubeconfig est valide 24 heures par défaut ; une nouvelle génération sera nécessaire après expiration.

Services fournis par défaut dans un cluster OKS

Dans un cluster OUTSCALE Kubernetes (OKS), seuls les composants essentiels sont déployés automatiquement. Cela garantit un environnement léger, sécurisé et personnalisable, sans surcharge logicielle.

kubectl get pods -n kube-system

NAMESPACE     NAME                                  READY   STATUS    RESTARTS   AGE
kube-system   cilium-6slqd                          1/1     Running   0          34m
kube-system   cilium-b6n28                          1/1     Running   0          34m
kube-system   cilium-envoy-5fnwt                    1/1     Running   0          34m
kube-system   cilium-envoy-lxx7c                    1/1     Running   0          34m
kube-system   cilium-operator-57d947b96b-7kfxq      1/1     Running   0          55m
kube-system   coredns-5658776d8b-pch29              1/1     Running   0          55m
kube-system   coredns-5658776d8b-wvbrq              1/1     Running   0          55m
kube-system   imds-provider-ip-10-50-59-222         1/1     Running   0          34m
kube-system   imds-provider-ip-10-50-59-77          1/1     Running   0          34m
kube-system   konnectivity-agent-rwrwq              1/1     Running   0          34m
kube-system   konnectivity-agent-v5plx              1/1     Running   0          34m
kube-system   metrics-server-56478ff848-ssp28       1/1     Running   0          55m
kube-system   osc-csi-node-9bwcm                    3/3     Running   0          34m
kube-system   osc-csi-node-g48rs                    3/3     Running   0          34m
kube-system   snapshot-controller-9c8bd95c5-bwcvj   1/1     Running   0          54m
kube-system   snapshot-controller-9c8bd95c5-kdp5f   1/1     Running   0          54m

Voici la liste complète des services installés par défaut :

• Cilium : connectivité réseau entre pods, application des politiques réseau.
• Konnectivity-agent : communication sécurisée entre le control plane et les nœuds
• CoreDNS : résolution DNS interne pour les services et pods
• imds-provider : accès aux métadonnées OUTSCALE pour les applications
• Metrics-server : collecte des métriques (CPU, mémoire) pour l’observabilité et l’autoscaling horizontal des pods
• osc-csi-node : plugin CSI pour attacher/détacher les volumes block OUTSCALE
• snapshot-controller : gestion des snapshots de volumes persistants

Ce choix minimaliste permet de conserver un contrôle total sur les outils supplémentaires que vous souhaitez installer, tout en bénéficiant d’un cluster immédiatement opérationnel.

Conclusion

Voilà, vous avez déployé votre premier cluster OKS, configuré et prêt à l’emploi. Vous disposez désormais d’un environnement Kubernetes souverain, épuré et sécurisé, entièrement géré par OUTSCALE.

Dans un prochain guide, nous verrons comment :

• Déployer vos applications dans le cluster
• Utiliser des volumes persistants pour stocker des données
• Effectuer des sauvegardes grâce aux snapshots
• Exposer vos services à l’extérieur à l’aide des Load Balancers

Vous êtes prêt à passer à l’étape suivante. Alors suivez-moi sur mon compte linkedin ↗ pour ne rien manquer !

Ressources utiles

• Documentation officielle d’OUTSCALE ↗
• Référentiel GitHub d’OUTSCALE ↗