Créer un cluster partagé pour exécuter des charges de travail de conteneurs

Partagés

Ce document explique comment créer un cluster Kubernetes partagé dans une zone isolée Google Distributed Cloud (GDC). Un cluster partagé s'étend sur plusieurs projets et inclut des services complets gérés par GDC. Il offre une configuration de cluster Kubernetes très spécifique, moins configurable que le cluster standard. Pour en savoir plus sur les clusters standards, consultez Configurations de cluster Kubernetes.

Les clusters partagés sont une ressource zonale et ne peuvent pas s'étendre sur plusieurs zones. Pour exploiter des clusters dans un univers multizone, vous devez créer manuellement des clusters dans chaque zone.

Ce document s'adresse à des audiences telles que les développeurs d'applications du groupe d'opérateurs d'applications, qui sont chargés de gérer les charges de travail de conteneurs au sein de leur organisation. Pour en savoir plus, consultez Audiences pour la documentation GDC sous air gap.

Avant de commencer

• Pour obtenir les autorisations nécessaires pour créer un cluster partagé, demandez à votre administrateur IAM de l'organisation de vous accorder le rôle d'administrateur de cluster utilisateur (user-cluster-admin). Ce rôle n'est pas lié à un espace de noms.

• Planifiez les limites suivantes de Google Distributed Cloud (GDC) sous air gap pour les clusters Kubernetes :

  • 16 clusters par organisation
  • 42 nœuds de calcul par cluster, avec un minimum de trois nœuds de calcul
  • 4 620 pods par cluster
  • 110 pods par nœud

Remarque : En raison d'une limite de scalabilité actuelle, si vous préférez allouer le minimum de trois nœuds de calcul dans votre cluster Kubernetes, vous devez allouer le type de machine pour les nœuds de calcul en tant que n2-standard-8 ou utiliser des machines GPU.

Planifier le bloc CIDR du pod

Pour allouer le bloc CIDR de pod de taille appropriée à vos charges de travail, vous devez calculer le nombre d'adresses IP requises pour votre cluster Kubernetes avant de le créer. La plupart des paramètres réseau ne peuvent pas être modifiés une fois le cluster créé.

Un cluster Kubernetes suit la logique suivante lors de l'attribution d'adresses IP :

• Kubernetes attribue un bloc CIDR /24 composé de 256 adresses à chacun des nœuds. Ce nombre respecte le nombre maximal par défaut de 110 pods par nœud pour les clusters Kubernetes.
• La taille du bloc CIDR attribué à un nœud dépend du nombre maximal de pods par valeur de nœud.
• Le bloc contient toujours au moins deux fois plus d'adresses que le nombre maximal de pods par nœud.

Consultez l'exemple suivant pour comprendre comment la valeur par défaut de Taille du masque par nœud= /24 a été calculée pour prendre en charge 110 pods :

Maximum pods per node = 110
Total number of IP addresses required = 2 * 110 = 220

Per node mask size = /24
Number of IP addresses in a /24 = 2(32 - 24) = 256

Déterminez le masque CIDR de pod requis pour configurer le cluster Kubernetes en fonction du nombre de nœuds requis. Planifiez l'ajout de futurs nœuds au cluster lors de la configuration de la plage CIDR :

  Total number of nodes supported = 2(Per node mask size - pod CIDR mask)

Étant donné qu'il existe une taille de masque par nœud par défaut de /24 , consultez le tableau suivant qui mappe le masque CIDR du pod au nombre de nœuds compatibles.

Masque CIDR du pod	Calcul : 2^(taille du masque par nœud – masque CIDR)	Nombre maximal de nœuds compatibles, y compris les nœuds du plan de contrôle
/21	2^(24 - 21)	8
/20	2^(24-20)	16
/19	2^(24 - 19)	32
/18	2^(24 - 18)	64

Avertissement : Si un masque CIDR insuffisant est fourni, la création du cluster peut rester bloquée dans une phase de réconciliation avec des pods affichant l'état CrashLoopBackOff.

Après avoir calculé le bloc CIDR de votre pod pour votre cluster Kubernetes, configurez-le dans le workflow de création de cluster de la section suivante.

Créer un cluster partagé

Pour créer un cluster Kubernetes partagé :

Console

1. Dans le menu de navigation, sélectionnez Kubernetes Engine > Clusters.

   Important : Notez que vous ne pouvez pas sélectionner de projet dans le sélecteur de champ d'application lorsque vous créez un cluster partagé. En effet, le cluster est limité à l'organisation. Pour en savoir plus, consultez la hiérarchie des ressources.

2. Cliquez sur Créer un cluster.

3. Dans le champ Nom, spécifiez un nom pour le cluster.

   Important : Le nom du cluster ne doit pas se terminer par -system. Le suffixe -system est réservé aux clusters créés par GDC.

4. Sélectionnez la version de Kubernetes pour le cluster.

5. Sélectionnez la zone dans laquelle créer le cluster.

6. Cliquez sur Associer un projet, puis sélectionnez un projet existant à associer à votre cluster. Cliquez ensuite sur Enregistrer. Vous pouvez associer ou dissocier des projets après avoir créé le cluster à partir de la page d'informations sur le projet. Vous devez associer un projet à votre cluster avant de déployer des charges de travail de conteneur.

   

7. Cliquez sur Suivant.

8. Configurez les paramètres réseau de votre cluster. Vous ne pouvez pas modifier ces paramètres réseau après avoir créé le cluster. Le protocole Internet par défaut et unique compatible avec les clusters Kubernetes est le protocole Internet version 4 (IPv4).

   1. Si vous souhaitez créer des nœuds d'équilibreur de charge dédiés, saisissez le nombre de nœuds à créer. Par défaut, vous ne recevez aucun nœud et le trafic de l'équilibreur de charge transite par les nœuds de contrôle.

   2. Sélectionnez le CIDR de service (Classless Inter-Domain Routing) à utiliser. Les adresses IP de vos services déployés, tels que les équilibreurs de charge, sont allouées à partir de cette plage.

      Important : Il peut s'agir de n'importe quelle plage RFC 1918 qui n'entre pas en conflit avec d'autres plages d'adresses IP dans les ressources de cluster et de pool de nœuds. Pour en savoir plus, consultez la RFC 1918.

   3. Sélectionnez le CIDR du pod à utiliser. Le cluster alloue des adresses IP de cette plage à vos pods et VM.

   4. Cliquez sur Suivant.

9. Consultez les détails du pool de nœuds par défaut généré automatiquement pour le cluster. Cliquez sur Modifier pour modifier le pool de nœuds par défaut.

   Important : Si vous prévoyez d'exécuter des charges de travail d'unité de traitement graphique (GPU) dans le cluster, vous devez provisionner un type de machine GPU dans votre cluster. Pour en savoir plus, consultez Charges de travail de GPU dans un cluster Kubernetes.

10. Pour créer d'autres pools de nœuds, sélectionnez Ajouter un pool de nœuds. Lorsque vous modifiez le pool de nœuds par défaut ou que vous en ajoutez un, vous pouvez le personnaliser à l'aide des options suivantes :

    1. Attribuez un nom au pool de nœuds. Vous ne pouvez pas modifier le nom après avoir créé le pool de nœuds.
    2. Spécifiez le nombre de nœuds de calcul à créer dans le pool de nœuds.

    3. Sélectionnez la classe de machine qui correspond le mieux aux exigences de votre charge de travail. Consultez la liste des paramètres suivants :

       • Type de machine
       • Processeur
       • Mémoire

    4. Cliquez sur Enregistrer.

11. Cliquez sur Créer pour créer le cluster.

La création d'un cluster partagé peut prendre jusqu'à 90 minutes.

API

Pour créer un cluster directement à l'aide de l'API, appliquez une ressource personnalisée à votre zone GDC :

1. Créez une ressource personnalisée Cluster et enregistrez-la en tant que fichier YAML, par exemple cluster.yaml :

   apiVersion: cluster.gdc.goog/v1
   kind: Cluster
   metadata:
     name: CLUSTER_NAME
     namespace: platform
   spec:
     clusterNetwork:
       podCIDRSize: POD_CIDR
       serviceCIDRSize: SERVICE_CIDR
     initialVersion:
       kubernetesVersion: KUBERNETES_VERSION
     nodePools:
     - machineTypeName: MACHINE_TYPE
       name: NODE_POOL_NAME
       nodeCount: NUMBER_OF_WORKER_NODES
       taints: TAINTS
       labels: LABELS
       acceleratorOptions:
         gpuPartitionScheme: GPU_PARTITION_SCHEME
     releaseChannel:
       channel: UNSPECIFIED
   

   Remplacez les éléments suivants :

   • CLUSTER_NAME : nom du cluster. Le nom du cluster ne doit pas se terminer par -system. Le suffixe -system est réservé aux clusters créés par GDC.
   • POD_CIDR : taille des plages réseau à partir desquelles les adresses IP virtuelles des pods sont allouées. Si elle n'est pas définie, la valeur par défaut 21 est utilisée.
   • SERVICE_CIDR : taille des plages de réseau à partir desquelles les adresses IP virtuelles de service sont allouées. Si elle n'est pas définie, la valeur par défaut 23 est utilisée.
   • KUBERNETES_VERSION : version Kubernetes du cluster, par exemple 1.26.5-gke.2100. Pour lister les versions Kubernetes disponibles à configurer, consultez Lister les versions Kubernetes disponibles pour un cluster.
   • MACHINE_TYPE : type de machine pour les nœuds de calcul du pool de nœuds. Consultez les types de machines disponibles pour connaître les configurations possibles.
   • NODE_POOL_NAME : nom du pool de nœuds.
   • NUMBER_OF_WORKER_NODES : nombre de nœuds de calcul à provisionner dans le pool de nœuds.
   • TAINTS : rejets à appliquer aux nœuds de ce pool de nœuds. Ce champ est facultatif.
   • LABELS : libellés à appliquer aux nœuds de ce pool de nœuds. Il contient une liste de paires clé/valeur. Ce champ est facultatif.
   • GPU_PARTITION_SCHEME : schéma de partitionnement du GPU, si vous exécutez des charges de travail GPU. Ce champ est facultatif. Exemple :mixed-2 Le GPU n'est pas partitionné si ce champ n'est pas défini. Pour en savoir plus sur les profils MIG (Multi-Instance GPU) disponibles, consultez Profils MIG compatibles.
   Important : Vous ne pouvez pas modifier les configurations de nœuds, comme le partitionnement GPU, une fois qu'un pool de nœuds de cluster a été créé.

2. Appliquez la ressource personnalisée à votre instance GDC :

   kubectl apply -f cluster.yaml --kubeconfig MANAGEMENT_API_SERVER
   

   Remplacez MANAGEMENT_API_SERVER par le chemin d'accès du fichier kubeconfig pour le serveur d'API zonal. Si vous n'avez pas encore généré de fichier kubeconfig pour le serveur d'API dans votre zone cible, consultez Se connecter.

La création d'un cluster partagé peut prendre jusqu'à 90 minutes.

Terraform

1. Dans un fichier de configuration Terraform, insérez l'extrait de code suivant :

   provider "kubernetes" {
     config_path = "MANAGEMENT_API_SERVER"
   }
   
   resource "kubernetes_manifest" "cluster-create" {
     manifest = {
       "apiVersion" = "cluster.gdc.goog/v1"
       "kind" = "Cluster"
       "metadata" = {
         "name" = "CLUSTER_NAME"
         "namespace" = "platform"
       }
       "spec" = {
         "clusterNetwork" = {
           "podCIDRSize" = "POD_CIDR"
           "serviceCIDRSize" = "SERVICE_CIDR"
         }
         "initialVersion" = {
           "kubernetesVersion" = "KUBERNETES_VERSION"
         }
         "nodePools" = [{
           "machineTypeName" = "MACHINE_TYPE"
           "name" = "NODE_POOL_NAME"
           "nodeCount" = "NUMBER_OF_WORKER_NODES"
           "taints" = "TAINTS"
           "labels" = "LABELS"
           "acceleratorOptions" = {
             "gpuPartitionScheme" = "GPU_PARTITION_SCHEME"
           }
         }]
         "releaseChannel" = {
           "channel" = "UNSPECIFIED"
         }
       }
     }
   }
   

   Remplacez les éléments suivants :

   • MANAGEMENT_API_SERVER : chemin d'accès kubeconfig du serveur d'API zonal. Si vous n'avez pas encore généré de fichier kubeconfig pour le serveur d'API dans votre zone cible, consultez Se connecter.
   • CLUSTER_NAME : nom du cluster. Le nom du cluster ne doit pas se terminer par -system. Le suffixe -system est réservé aux clusters créés par GDC.
   • POD_CIDR : taille des plages réseau à partir desquelles les adresses IP virtuelles des pods sont allouées. Si elle n'est pas définie, la valeur par défaut 21 est utilisée.
   • SERVICE_CIDR : taille des plages de réseau à partir desquelles les adresses IP virtuelles de service sont allouées. Si elle n'est pas définie, la valeur par défaut 23 est utilisée.
   • KUBERNETES_VERSION : version Kubernetes du cluster, par exemple 1.26.5-gke.2100. Pour lister les versions Kubernetes disponibles à configurer, consultez Lister les versions Kubernetes disponibles pour un cluster.
   • MACHINE_TYPE : type de machine pour les nœuds de calcul du pool de nœuds. Consultez les types de machines disponibles pour connaître les configurations possibles.
   • NODE_POOL_NAME : nom du pool de nœuds.
   • NUMBER_OF_WORKER_NODES : nombre de nœuds de calcul à provisionner dans le pool de nœuds.
   • TAINTS : rejets à appliquer aux nœuds de ce pool de nœuds. Ce champ est facultatif.
   • LABELS : libellés à appliquer aux nœuds de ce pool de nœuds. Il contient une liste de paires clé/valeur. Ce champ est facultatif.
   • GPU_PARTITION_SCHEME : schéma de partitionnement du GPU, si vous exécutez des charges de travail GPU. Ce champ est facultatif. Exemple :mixed-2 Le GPU n'est pas partitionné si ce champ n'est pas défini. Pour en savoir plus sur les profils MIG (Multi-Instance GPU) disponibles, consultez Profils MIG compatibles.

2. Appliquez le nouveau cluster Kubernetes partagé à l'aide de Terraform :

   terraform apply
   

La création d'un cluster partagé peut prendre jusqu'à 90 minutes.

Étapes suivantes

• Déployer une application de conteneur HA
• Charges de travail de conteneur dans GDC
• Hiérarchie des ressources