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

Créez un cluster Kubernetes pour permettre le déploiement de charges de travail de conteneurs. Les clusters sont des ressources zonales et ne peuvent pas s'étendre sur plusieurs zones. Pour exploiter des clusters dans un déploiement multizone, vous devez créer manuellement des clusters dans chaque zone.

Avant de commencer

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

Google Distributed Cloud (GDC) sous air gap présente les limites suivantes 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

Configurer le bloc CIDR du pod

Le cluster suit cette logique lors de l'attribution des adresses IP :

  • Kubernetes attribue un bloc CIDR /24 composé de 256 adresses à chacun des nœuds. Ce nombre respecte la limite maximale par défaut de 110 pods par nœud pour les clusters d'utilisateur.
  • 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 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 à configurer pour le cluster d'utilisateur 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é que nous avons une taille de masque par nœud par défaut de /24 , reportez-vous au 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

Créer un cluster Kubernetes

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

Console

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

  2. Cliquez sur Créer un cluster.

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

  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.

    Créez un cluster à l'aide de la console.

  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.

    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.

  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.

API

Pour créer un cluster à l'aide de l'API directement, appliquez une ressource personnalisée à votre instance 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
  loadBalancer:
    ingressServiceIPSize: LOAD_BALANCER_POOL_SIZE
  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 de 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 de Kubernetes du cluster, telle que 1.26.5-gke.2100. Pour lister les versions Kubernetes disponibles à configurer, consultez Lister les versions Kubernetes disponibles pour un cluster.
    • LOAD_BALANCER_POOL_SIZE : taille des pools d'adresses IP non chevauchants utilisés par les services d'équilibrage de charge. Si elle n'est pas définie, la valeur par défaut 20 est utilisée.
    • 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. Exemple :mixed-2 Le GPU n'est pas partitionné si ce champ n'est pas défini. Pour connaître les profils MIG (Multi-Instance GPU) disponibles, consultez Profils MIG compatibles.

  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 la zone cible, consultez Se connecter pour en savoir plus.

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"
      }
      "loadBalancer" = {
        "ingressServiceIPSize" = "LOAD_BALANCER_POOL_SIZE"
      }
      "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 au fichier kubeconfig du serveur d'API zonal. Si vous n'avez pas encore généré de fichier kubeconfig pour le serveur d'API dans la zone cible, consultez Se connecter pour en savoir plus.
    • 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 de 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 de Kubernetes du cluster, telle que 1.26.5-gke.2100. Pour lister les versions Kubernetes disponibles à configurer, consultez Lister les versions Kubernetes disponibles pour un cluster.
    • LOAD_BALANCER_POOL_SIZE : taille des pools d'adresses IP non chevauchants utilisés par les services d'équilibrage de charge. Si elle n'est pas définie, la valeur par défaut 20 est utilisée.
    • 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. Exemple :mixed-2 Le GPU n'est pas partitionné si ce champ n'est pas défini. Pour connaître les profils MIG (Multi-Instance GPU) disponibles, consultez Profils MIG compatibles.

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

    terraform apply

Lister les versions Kubernetes disponibles pour un cluster

Vous pouvez lister les versions de Kubernetes disponibles dans votre instance GDC à l'aide de la CLI kubectl :

kubectl get userclustermetadata.upgrade.private.gdc.goog \
    -o=custom-columns=K8S-VERSION:.spec.kubernetesVersion \
    --kubeconfig MANAGEMENT_API_SERVER

Remplacez MANAGEMENT_API_SERVER par le chemin d'accès kubeconfig du serveur d'API zonal de votre cluster.

La sortie ressemble à ceci :

K8S-VERSION
1.25.10-gke.2100
1.26.5-gke.2100
1.27.4-gke.500

Prendre en charge les charges de travail GPU dans un cluster

Distributed Cloud est compatible avec les GPU NVIDIA pour les clusters Kubernetes, et exécute vos appareils GPU en tant que charges de travail utilisateur. Par exemple, vous pouvez préférer exécuter des notebooks d'intelligence artificielle (IA) et de machine learning (ML) dans un environnement GPU. Avant d'utiliser des notebooks d'IA et de ML, assurez-vous que votre cluster est compatible avec les appareils GPU. La prise en charge des GPU est activée par défaut pour les clusters pour lesquels des machines GPU ont été provisionnées.

Vous pouvez créer des clusters à l'aide de la console ou de l'API GDC. Assurez-vous de provisionner des machines GPU pour votre cluster afin de prendre en charge les charges de travail GPU sur ses conteneurs associés. Pour en savoir plus, consultez Créer un cluster Kubernetes.

Les GPU sont alloués de manière statique. Les quatre premiers GPU sont toujours dédiés aux charges de travail telles que les API d'intelligence artificielle (IA) et de machine learning (ML) préentraînés. Ces GPU ne s'exécutent pas sur un cluster Kubernetes. Les GPU restants sont disponibles pour les clusters Kubernetes. Les notebooks d'IA et de ML s'exécutent sur des clusters Kubernetes.

Veillez à allouer des machines GPU aux types de clusters appropriés pour vous assurer que les composants tels que les API d'IA et de ML, ainsi que les notebooks, peuvent être utilisés.