Créer et personnaliser un pool de nœuds

Cette page explique comment créer un pool de nœuds dans GKE sur AWS et comment personnaliser la configuration de vos nœuds à l'aide d'un fichier de configuration.

Pour créer un pool de nœuds, vous devez fournir les ressources suivantes :

• Le nom d'un cluster AWS existant dans lequel créer le pool de nœuds.
• Un profil d'instance IAM pour les VM de pool de nœuds.
• Un sous-réseau dans lequel exécuter les VM du pool de nœuds.

Si vous souhaitez accéder à vos nœuds via SSH, vous pouvez créer une paire de clés EC2.

Cette page s'adresse aux administrateurs et opérateurs informatiques qui souhaitent configurer, surveiller et gérer l'infrastructure cloud. Pour en savoir plus sur les rôles courants et les exemples de tâches que nous citons dans le contenu Google Cloud , consultez Rôles utilisateur et tâches courantes de GKE.

Créer un pool de nœuds standard

Une fois ces ressources disponibles, vous pouvez créer un pool de nœuds à l'aide de la commande suivante :

gcloud container aws node-pools create NODE_POOL_NAME \
    --cluster CLUSTER_NAME \
    --instance-type INSTANCE_TYPE \
    --root-volume-size ROOT_VOLUME_SIZE \
    --iam-instance-profile NODEPOOL_PROFILE \
    --node-version NODE_VERSION \
    --min-nodes MIN_NODES \
    --max-nodes MAX_NODES \
    --max-pods-per-node MAX_PODS_PER_NODE \
    --location GOOGLE_CLOUD_LOCATION \
    --subnet-id NODEPOOL_SUBNET \
    --ssh-ec2-key-pair SSH_KEY_PAIR_NAME \
    --config-encryption-kms-key-arn CONFIG_KMS_KEY_ARN \
    --tags "Name=CLUSTER_NAME-NODE_POOL_NAME"

Remplacez les éléments suivants :

• NODE_POOL_NAME : nom que vous avez choisi pour votre pool de nœuds.
• CLUSTER_NAME : nom du cluster auquel associer le pool de nœuds.
• INSTANCE_TYPE : type d'instance de machine AWS souhaité pour ce pool de nœuds (par exemple, m5.large).
• ROOT_VOLUME_SIZE : taille souhaitée pour le volume racine de chaque nœud, en Go.
• NODEPOOL_PROFILE : profil d'instance IAM pour les VM de pool de nœuds. Pour savoir comment mettre à jour un profil d'instance IAM, consultez Mettre à jour un profil d'instance IAM AWS.
• NODE_VERSION : version de Kubernetes à installer sur chaque nœud du pool de nœuds (par exemple, "1.32.4-gke.200")
• MIN_NODES : nombre minimal de nœuds que le pool de nœuds peut contenir.
• MAX_NODES : nombre maximal de nœuds que le pool de nœuds peut contenir.
• MAX_PODS_PER_NODE : nombre maximal de pods pouvant être créés sur un nœud unique du pool.
• GOOGLE_CLOUD_LOCATION : nom de l'emplacement Google Cloudà partir duquel ce pool de nœuds sera géré.
• NODEPOOL_SUBNET : ID du sous-réseau sur lequel le pool de nœuds sera exécuté.
  • Il ne doit pas y avoir de chevauchement entre les plages d'adresses IP des pods/services du cluster et le réseau de sous-réseau du pool de nœuds. Pour en savoir plus sur la sélection des plages d'adresses IP des pods et des services pour votre cluster, consultez la page Sélectionner des plages CIDR pour votre cluster.
  • Si ce sous-réseau se trouve en dehors du bloc CIDR principal du VPC, certaines étapes supplémentaires sont nécessaires. Pour en savoir plus, consultez la section Groupes de sécurité.
• SSH_KEY_PAIR_NAME : nom de la paire de clés SSH AWS créée pour l'accès SSH (facultatif).
• CONFIG_KMS_KEY_ARN : nom de ressource Amazon (ARN) de la clé KMS AWS qui chiffre les données utilisateur.

S'il est présent, le paramètre --tags applique le tag donné à tous les nœuds de votre pool de nœuds. Cet exemple applique à tous les nœuds du pool des tags contenant les noms du cluster et du pool de nœuds auxquels le nœud appartient.

Personnaliser la configuration du système de nœud

Vous pouvez personnaliser la configuration de vos nœuds à l'aide de différentes méthodes. Par exemple, vous pouvez spécifier des paramètres tels que la limite de processeur du pod lorsque vous créez un pool de nœuds.

Vous pouvez utiliser une configuration de système de nœuds pour spécifier des paramètres personnalisés pour l'agent de nœud Kubernetes (kubelet) et des configurations de noyau Linux de bas niveau (sysctl) dans vos pools de nœuds.

Configurer l'agent kubelet

Pour personnaliser la configuration des nœuds à l'aide de kubelet, utilisez la Google Cloud CLI ou Terraform.

gcloud

Vous pouvez spécifier des paramètres personnalisés pour l'agent de nœud Kubernetes (kubelet) lorsque vous créez vos pools de nœuds. Par exemple, pour configurer kubelet afin d'utiliser la règle de gestion du processeur statique, exécutez la commande suivante :

  gcloud container aws node-pools create POOL_NAME \
       --cluster CLUSTER_NAME \
       --location=LOCATION \
       --kubelet_config_cpu_manager_policy=static

Remplacez les éléments suivants :

• POOL_NAME : nom de votre pool de nœuds.
• CLUSTER_NAME : nom du cluster auquel vous souhaitez ajouter un pool de nœuds.
• LOCATION : zone ou région de calcul du cluster.

Pour obtenir la liste complète des champs que vous pouvez ajouter à la commande précédente, consultez Options de configuration Kubelet.

Terraform

Pour en savoir plus sur l'utilisation de Terraform dans un environnement AWS, consultez la documentation de référence sur le pool de nœuds Terraform.

1. Définissez les variables Terraform en incluant le bloc suivant dans le fichier variables.tf :

   variable "node_pool_kubelet_config_cpu_manager" {
     default     = "none"
   }
   
   variable "node_pool_kubelet_config_cpu_cfs_quota" {
     default     = "true"
   }
   
   variable "node_pool_kubelet_config_cpu_cfs_quota_period" {
     default     = "100ms"
   }
   
   variable "node_pool_kubelet_config_pod_pids_limit" {
     default     = -1
   }
   

2. Ajoutez le bloc suivant à votre configuration Terraform :

   resource "google_container_aws_node_pool" "NODE_POOL_RESOURCE_NAME" {
    provider           = google
    cluster            = CLUSTER_NAME
    name               = POOL_NAME
    subnet_id          = SUBNET_ID
    version            = CLUSTER_VERSION
    location           = CLUSTER_LOCATION
   
    kubelet_config {
      cpu_manager_policy = var.node_pool_kubelet_config_cpu_manager
      cpu_cfs_quota = var.node_pool_kubelet_config_cpu_cfs_quota
      cpu_cfs_quota_period = var.node_pool_kubelet_config_cpu_cfs_quota_period
      pod_pids_limit = var.node_pool_kubelet_config_pod_pids_limit
    }
   }
   

   Remplacez les éléments suivants :

   • NODE_POOL_RESOURCE_NAME : nom de la ressource du pool de nœuds dans le modèle Terraform.
   • CLUSTER_NAME : nom du cluster existant.
   • POOL_NAME : nom du pool de nœuds à personnaliser.
   • SUBNET_ID : sous-réseau attribué au pool de nœuds.
   • CLUSTER_VERSION : version du plan de contrôle et des nœuds du cluster GKE sur AWS.
   • CLUSTER_LOCATION : région ou zone Compute Engine du cluster.

Configurer l'utilitaire sysctl

Pour personnaliser la configuration de votre système de nœuds à l'aide de sysctl, envoyez une requête POST à la méthode awsClusters.awsNodePools.create. Cette requête POST crée un pool de nœuds avec les personnalisations que vous avez spécifiées. Dans l'exemple suivant, les paramètres busy_poll et busy_read sont configurés sur 5 000 microsecondes chacun :

POST https://ENDPOINT/v1/projects/PROJECT_ID/locations/GOOGLE_CLOUD_LOCATION/CLUSTER_NAME/awsNodePools

{
    "name": NODE_POOL_NAME,
    "version": CLUSTER_VERSION,
    "config": {
        "linuxNodeConfig": {
            "sysctls": {
                "net.core.busy_poll": "5000",
                "net.core.busy_read": "5000",
            }
        }
    }
}

Remplacez les éléments suivants :

• ENDPOINT : votre Google Cloud point de terminaison de service.
• PROJECT_ID : ID de votre projet Google Cloud .
• GOOGLE_CLOUD_LOCATION : Google Cloud emplacement du cluster.
• CLUSTER_NAME : nom du cluster auquel vous souhaitez ajouter un pool de nœuds.
• NODE_POOL_NAME : nom de votre pool de nœuds.
• CLUSTER_VERSION : numéro de version de votre cluster, par exemple 1.31.0-gke.500.

Pour obtenir la liste complète des paires clé-valeur que vous pouvez ajouter à la requête JSON précédente, consultez Options de configuration Sysctl.

Options de configuration pour l'agent kubelet

Le tableau suivant présente les options de kubelet que vous pouvez modifier.

Paramètres de configuration Kubelet	Restrictions	Paramètre par défaut	Description
kubelet_config_cpu_manager_policy	La valeur doit être none ou static.	"none"	Ce paramètre contrôle la règle du gestionnaire de processeur du kubelet. La valeur par défaut est none, ce qui correspond au schéma d'affinité de processeur par défaut, qui ne fournit aucune affinité au-delà de celle qui est fournie automatiquement par le programmeur du système d'exploitation. Si vous définissez cette valeur sur static, les pods de la classe QoS garantie ayant des requêtes de processeurs entières se voient attribuer une utilisation exclusive des processeurs.
kubelet_config_cpu_cfs_quota	La valeur doit être true ou false.	true	Ce paramètre applique la limite de processeur du pod. Définir cette valeur sur false signifie que les limites du processeur pour les pods sont ignorées. Il est préférable d'ignorer les limites du processeur dans certains scénarios où les pods sont sensibles aux limites du processeur. Le risque lié à la désactivation de cpuCFSQuota est qu'un pod non autorisé peut consommer plus de ressources de processeur que prévu.
kubelet_config_cpu_cfs_quota_period	La valeur doit être une durée.	"100ms"	Ce paramètre définit la valeur de période de quota du CFS du processeur (cpu.cfs_period_us) qui spécifie la période à laquelle l'accès d'un groupe aux ressources du processeur doit être réattribué. Cette option vous permet d'ajuster le comportement de limitation du processeur.
kubelet_config_pod_pids_limit	La valeur doit être comprise entre 1 024 et 4 194 304	-1	Ce paramètre définit le nombre maximal d'ID de processus (PID) que chaque pod peut utiliser. Si la valeur par défaut est définie, la limite de PID est automatiquement ajustée en fonction de la taille de la machine sous-jacente.

Options de configuration de l'utilitaire sysctl

Pour ajuster les performances de votre système, vous pouvez modifier les attributs suivants :

• net.core.busy_poll
• net.core.busy_read
• net.core.netdev_max_backlog
• net.core.rmem_max
• net.core.wmem_default
• net.core.wmem_max
• net.core.optmem_max
• net.core.somaxconn
• net.ipv4.tcp_rmem
• net.ipv4.tcp_wmem
• net.ipv4.tcp_tw_reuse
• net.ipv6.conf.all.disable_ipv6
• net.ipv6.conf.default.disable_ipv6
• vm.max_map_count

Pools de nœuds d'instances Spot

Preview

Ce produit ou cette fonctionnalité sont soumis aux "Conditions des offres de pré-DG" de la section "Conditions générales du service" des Conditions spécifiques du service. Les produits et fonctionnalités de pré-DG sont proposés "en l'état" et peuvent avoir une compatibilité limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

GKE sur AWS est compatible avec les pools de nœuds d'instance spot AWS en version preview. Les pools de nœuds d'instances spot sont des pools d'instances spot Amazon EC2 disponibles sur AWS à moindre coût.

Les instances Spot peuvent permettre de réaliser des économies pour les applications sans état, tolérantes aux pannes et flexibles. Toutefois, elles ne sont pas adaptées aux charges de travail rigides, avec état, intolérantes aux pannes ou étroitement couplées entre les nœuds d'instance. Amazon EC2 peut interrompre les instances de spot lorsqu'il a besoin de récupérer la capacité. Elles sont donc soumises aux fluctuations du marché spot. Si vos charges de travail nécessitent une capacité garantie et ne peuvent pas tolérer des périodes d'indisponibilité occasionnelles, choisissez un pool de nœuds standard plutôt qu'un pool de nœuds d'instances Spot.

La stratégie d'allocation utilisée dans GKE sur AWS consiste à sélectionner les pools d'instances Spot ayant la plus grande capacité disponible, ce qui minimise le risque d'interruption. Cette approche est particulièrement utile pour les charges de travail présentant un coût plus élevé des interruptions, comme le rendu d'images et de contenus multimédias ou le deep learning. Plus précisément, la stratégie d'allocation capacityOptimized a été implémentée, comme décrit dans Stratégies d'allocation pour les instances Spot.

Créer un pool de nœuds Spot

Pour créer un pool de nœuds d'instances Spot, exécutez la commande suivante :

gcloud container aws node-pools create NODE_POOL_NAME \
    --cluster CLUSTER_NAME \
    --spot-instance-types INSTANCE_TYPE_LIST \
    --root-volume-size ROOT_VOLUME_SIZE \
    --iam-instance-profile NODEPOOL_PROFILE \
    --node-version NODE_VERSION \
    --min-nodes MIN_NODES \
    --max-nodes MAX_NODES \
    --max-pods-per-node MAX_PODS_PER_NODE \
    --location GOOGLE_CLOUD_LOCATION \
    --subnet-id NODEPOOL_SUBNET \
    --ssh-ec2-key-pair SSH_KEY_PAIR_NAME \
    --config-encryption-kms-key-arn CONFIG_KMS_KEY_ARN \
    --tags "Name=CLUSTER_NAME-NODE_POOL_NAME"

Remplacez les éléments suivants :

• NODE_POOL_NAME : nom que vous souhaitez attribuer à ce pool de nœuds.
• CLUSTER_NAME : nom du cluster auquel vous souhaitez associer ce pool de nœuds.
• INSTANCE_TYPE_LIST : liste de types d'instances AWS EC2 séparés par une virgule. Le pool de nœuds provisionne des instances Spot avec ces types d'instances. Les types d'instances doivent avoir la même architecture de processeur, le même nombre de de processeurs et la même quantité de mémoire. Par exemple : "c6g.large,c6gd.large,c6gn.large,c7g.large,t4g.medium". Vous pouvez utiliser l'outil Amazon EC2 Instance Selector pour trouver des types d'instances qui ont des configurations de processeur et de mémoire identiques.
• ROOT_VOLUME_SIZE : taille souhaitée pour le volume racine de chaque nœud, en Go.
• NODEPOOL_PROFILE : profil d'instance IAM pour les VM de pool de nœuds.
• NODE_VERSION : version de Kubernetes à installer sur chaque nœud du pool de nœuds (par exemple, "1.32.4-gke.200")
• MIN_NODES : nombre minimal de nœuds que le pool de nœuds peut contenir.
• MAX_NODES : nombre maximal de nœuds que le pool de nœuds peut contenir.
• MAX_PODS_PER_NODE : nombre maximal de pods pouvant être créés sur un nœud unique du pool.
• GOOGLE_CLOUD_LOCATION : nom de l'emplacement Google Cloudà partir duquel ce pool de nœuds sera géré.
• NODEPOOL_SUBNET : ID du sous-réseau sur lequel le pool de nœuds sera exécuté.
  • Il ne doit pas y avoir de chevauchement entre les plages d'adresses IP des pods/services du cluster et le réseau de sous-réseau du pool de nœuds. Pour en savoir plus sur la sélection des plages d'adresses IP des pods et des services pour votre cluster, consultez la page Sélectionner des plages CIDR pour votre cluster.
  • Si ce sous-réseau se trouve en dehors du bloc CIDR principal du VPC, certaines étapes supplémentaires sont nécessaires. Pour en savoir plus, consultez la section Groupes de sécurité.
• SSH_KEY_PAIR_NAME : nom de la paire de clés SSH AWS créée pour l'accès SSH (facultatif).
• CONFIG_KMS_KEY_ARN : nom de ressource Amazon (ARN) de la clé KMS AWS qui chiffre les données utilisateur.

Il est recommandé de répertorier un certain nombre de types d'instances dans le champ INSTANCE_TYPE_LIST. Cette bonne pratique est importante car si un pool de nœuds est configuré avec un seul type d'instance unique et que celui-ci n'est disponible dans aucune des zones de disponibilité souhaitées, le pool de nœuds ne peut pas provisionner de nouveaux nœuds. Cela peut affecter la disponibilité de vos applications et provoquer des interruptions de service.

Notez que le champ spot-instance-types s'exclut mutuellement avec le champ instance-type. Cela signifie que vous ne pouvez fournir qu'un seul de ces champs, et non les deux.