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

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

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.

  • Pour utiliser l'API ou Terraform afin de créer un cluster partagé, 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 zonal.

  • 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 de la valeur maximale 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 accepter 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

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 partagé

Pour créer un cluster Kubernetes partagé :

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 des détails du projet. Vous devez associer un projet à votre cluster avant de déployer des charges de travail de conteneurs.

    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 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 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 de pod à utiliser. Le cluster alloue 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 Modifier pour modifier le pool de nœuds par défaut.

  10. Pour créer des pools de nœuds supplémentaires, sélectionnez 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 partagé peut prendre jusqu'à 90 minutes.

API

  1. Créez la ressource personnalisée Cluster :

    kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
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
EOF

    Remplacez les éléments suivants :

    • MANAGEMENT_API_SERVER: chemin d'accès à kubeconfig du serveur d'API zonal.
    • 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 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 de Kubernetes du cluster, par exemple 1.26.5-gke.2100. Pour afficher la liste des versions Kubernetes disponibles à configurer, consultez la section 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 é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 la section Profils MIG compatibles.

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

  2. Créez la ressource personnalisée ProjectBinding :

    kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
apiVersion: resourcemanager.gdc.goog/v1
kind: ProjectBinding
metadata:
  name: CLUSTER_NAME-PROJECT_NAME
  namespace: platform
  labels:
    resourcemanager.gdc.goog/projectbinding-for-user-project: "true"
spec:
  clusterRef:
    name: CLUSTER_NAME
  selector:
    nameSelector:
      matchNames:
      - PROJECT_NAME
EOF

    Remplacez les éléments suivants :

    • MANAGEMENT_API_SERVER: chemin d'accès à kubeconfig du serveur d'API zonal.
    • CLUSTER_NAME : nom du cluster.
    • PROJECT_NAME: nom du projet à lier. Chaque ressource ProjectBinding ne peut être mappée qu'à un seul cluster. Si un projet nécessite d'accéder à plusieurs clusters, un ProjectBinding unique doit être créé pour chaque cluster.

    Vous devez associer un projet à votre cluster avant qu'un développeur puisse y déployer des charges de travail de conteneurs.

Terraform

  1. Dans un fichier de configuration Terraform, insérez l'extrait de code suivant pour créer la ressource personnalisée Cluster :

    provider "kubernetes" {
  config_path = "MANAGEMENT_API_SERVER"
}

resource "kubernetes_manifest" "CLUSTER_RESOURCE_NAME" {
  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.
    • CLUSTER_RESOURCE_NAME: nom de ressource Terraform unique du cluster, tel que cluster-1. Ce nom est utilisé par Terraform pour identifier votre cluster, mais pas par GDC.
    • 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 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 de Kubernetes du cluster, par exemple 1.26.5-gke.2100. Pour afficher la liste des versions Kubernetes disponibles à configurer, consultez la section 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 é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 la section Profils MIG compatibles.

  2. Dans un fichier de configuration Terraform, insérez l'extrait de code suivant pour créer la ressource personnalisée ProjectBinding :

    provider "kubernetes" {
  config_path = "MANAGEMENT_API_SERVER"
}

resource "kubernetes_manifest" "PROJECT_BINDING_RESOURCE_NAME" {
  manifest = {
    "apiVersion" = "resourcemanager.gdc.goog/v1"
    "kind" = "ProjectBinding"
    "metadata" = {
      "name" = "CLUSTER_NAME-PROJECT_NAME"
      "namespace" = "platform"
      "labels" = {
        "resourcemanager.gdc.goog/projectbinding-for-user-project" = "true"
      }
    }
    "spec" = {
      "clusterRef" = {
        "name" = "CLUSTER_NAME"
      }
      "selector" = {
        "nameSelector" = {
          "matchNames" = [
            "PROJECT_NAME",
          ]
        }
      }
    }
  }
}

    Remplacez les éléments suivants :

    • MANAGEMENT_API_SERVER: chemin d'accès à kubeconfig du serveur d'API zonal.
    • PROJECT_BINDING_RESOURCE_NAME: nom de ressource Terraform de la liaison de projet, tel que project-binding-1. Ce nom est utilisé par Terraform pour identifier votre liaison de projet, mais pas par GDC.
    • CLUSTER_NAME : nom du cluster.
    • PROJECT_NAME: nom du projet à lier. Chaque ressource ProjectBinding ne peut être mappée qu'à un seul cluster. Si un projet nécessite d'accéder à plusieurs clusters, un ProjectBinding unique doit être créé pour chaque cluster.

    Vous devez associer un projet à votre cluster avant qu'un développeur puisse y déployer des charges de travail de conteneurs.

  3. Appliquez les nouvelles ressources personnalisées à l'aide de Terraform :

    terraform apply

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

Étape suivante