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

Standard

Ce document explique comment créer un cluster Kubernetes standard dans une zone isolée de Google Distributed Cloud (GDC). Un cluster standard fournit un cluster Kubernetes hautement configurable et limité au projet, qui inclut un ensemble minimal de services gérés. Le cluster standard offre plus de flexibilité pour la configuration des services que le cluster partagé, mais il nécessite également une surcharge de gestion plus importante. Pour en savoir plus sur les clusters standards, consultez Configurations de cluster Kubernetes.

Les clusters standards 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 créer un cluster standard, demandez les autorisations nécessaires et préparez votre environnement.

Demander des rôles IAM

Contactez l'administrateur IAM de votre organisation pour qu'il vous attribue les rôles suivants :

• Administrateur IAM du projet (project-iam-admin) : accordez à d'autres utilisateurs les rôles nécessaires pour gérer l'accès dans les clusters standards.
• Administrateur de cluster standard (standard-cluster-admin) : créez des clusters standards dans le projet.

Ces rôles sont liés à l'espace de noms de votre projet.

Préparer votre environnement

• Vérifiez que vous disposez de la configuration appropriée pour accéder aux clusters standards et les gérer. Pour en savoir plus, consultez Gérer l'accès aux clusters standards.
• Générez le fichier kubeconfig du serveur d'API zonal pour héberger votre cluster. Définissez la variable d'environnement MANAGEMENT_API_SERVER sur le chemin d'accès kubeconfig. Pour en savoir plus, consultez Ressources du serveur d'API de gestion zonale.
• Consultez les limites de cluster pour connaître les considérations relatives aux ressources.

Planifier le bloc CIDR des pods

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

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

• Kubernetes attribue un bloc CIDR /24 composé de 256 adresses à chacun des nœuds. Cette quantité respecte la limite maximale 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 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 Per node mask size= /24 a été calculée pour accueillir 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 à configurer pour le cluster Kubernetes en fonction du nombre de nœuds requis. Planifiez les futurs ajouts de 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 valeur par défaut Per node mask size= /24 , reportez-vous au tableau suivant qui mappe le masque CIDR de pod au nombre de nœuds compatibles.

Masque CIDR de pod	Calcul : 2^(Per node mask size - CIDR mask)	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é votre bloc CIDR de pod pour votre cluster Kubernetes, configurez-le dans le cadre du workflow de création de cluster dans la section suivante.

Créer un cluster standard

Pour créer un cluster standard, procédez comme suit :

Console

1. Dans le sélecteur de projet, choisissez votre projet.

   Les clusters standards sont des ressources limitées au projet. Si vous sélectionnez une organisation à la place, vous créez un cluster partagé, qui est limité à l'organisation. Pour en savoir plus, consultez la section Hiérarchie des ressources.

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

3. Cliquez sur Créer un cluster.

4. Dans le champ Name (Nom), spécifiez un nom pour le cluster.

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

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

7. Cliquez sur Suivant.

8. Configurez les paramètres réseau de votre cluster. Vous ne pourrez plus modifier ces paramètres réseau une fois le cluster créé. Le protocole Internet par défaut et seul compatible pour 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 recevez zéro nœud, et le trafic de l'équilibreur de charge transite par les nœuds du plan de contrôle.

   2. Sélectionnez le CIDR de service (Classless Inter-Domain Routing) à utiliser. Vos services déployés, tels que les équilibreurs de charge, reçoivent des adresses IP de cette plage.

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

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

   4. Cliquez sur Suivant.

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

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

10. Pour créer des pools de nœuds supplémentaires, sélectionnez Add Node Pool (Ajouter un pool de nœuds). Lorsque vous modifiez le pool de nœuds par défaut ou que vous ajoutez un pool de nœuds, vous le personnalisez avec les options suivantes :

    1. Attribuez un nom au pool de nœuds. Vous ne pourrez plus modifier le nom une fois le pool de nœuds créé.
    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. Affichez 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 standard peut prendre jusqu'à 60 minutes.

API

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

   apiVersion: cluster.gdc.goog/v1
   kind: Cluster
   metadata:
     name: CLUSTER_NAME
     namespace: PROJECT_NAME
   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.
   • PROJECT_NAME : nom du projet dans lequel créer le cluster.
   • POD_CIDR: taille des plages réseau à partir desquelles les adresses IP virtuelles des pods sont allouées. Si cette règle n'est pas configurée, la valeur par défaut 21 est utilisée.
   • SERVICE_CIDR: taille des plages réseau à partir desquelles les adresses IP virtuelles des services sont allouées. Si cette règle n'est pas configurée, la valeur par défaut 23 est utilisée.
   • KUBERNETES_VERSION: version Kubernetes du cluster, telle que 1.26.5-gke.2100. Pour afficher la liste des versions Kubernetes disponibles à configurer, consultez Afficher la liste des versions Kubernetes disponibles pour un cluster.
   • MACHINE_TYPE: type de machine pour les nœuds de calcul du pool de nœuds. Affichez les types de machines disponibles pour connaître les éléments configurables.
   • 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 GPU multi-instance (MIG) disponibles, consultez Profils MIG compatibles.
   Remarque : Vous ne pouvez pas modifier les configurations de nœud, telles que le partitionnement du GPU, une fois qu' un pool de nœuds de cluster est 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 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.

La création d'un cluster standard peut prendre jusqu'à 60 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" = "PROJECT_NAME"
       }
       "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.
   • PROJECT_NAME: nom du projet dans lequel créer le cluster.
   • POD_CIDR: taille des plages réseau à partir desquelles les adresses IP virtuelles des pods sont allouées. Si cette règle n'est pas configurée, la valeur par défaut 21 est utilisée.
   • SERVICE_CIDR: taille des plages réseau à partir desquelles les adresses IP virtuelles des services sont allouées. Si cette règle n'est pas configurée, la valeur par défaut 23 est utilisée.
   • KUBERNETES_VERSION: version Kubernetes du cluster, telle que 1.26.5-gke.2100. Pour afficher la liste des versions Kubernetes disponibles à configurer, consultez Afficher la liste des versions Kubernetes disponibles pour un cluster.
   • MACHINE_TYPE: type de machine pour les nœuds de calcul du pool de nœuds. Affichez les types de machines disponibles pour connaître les éléments configurables.
   • 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 GPU multi-instance (MIG) disponibles, consultez Profils MIG compatibles.

2. Appliquez le nouveau cluster standard à l'aide de Terraform :

   terraform apply
   

La création d'un cluster standard peut prendre jusqu'à 60 minutes.

Étape suivante

• Gérer l'accès aux clusters standards
• Déployer une application de conteneur à haute disponibilité
• Charges de travail de conteneur dans GDC
• Hiérarchie des ressources
• Configurer Cloud NAT pour les clusters standards