Gérer les ressources d'équipe dans votre parc

Cette page explique comment utiliser Config Sync et Terraform pour créer de manière dynamique des ressources au niveau de l'équipe sur un parc de clusters. Config Sync étend les capacités de gestion des équipes de parc pour créer et gérer des configurations d'infrastructure et de clusters sur l'ensemble de vos parcs.

Dans ce guide, nous partons du principe que vous connaissez déjà les concepts de gestion des équipes de parc, tels que les champs d'application d'équipe et les espaces de noms de parc. Pour en savoir plus, consultez la présentation de la gestion des équipes de parc.

Pour obtenir un tutoriel de bout en bout avec des exemples de configurations, consultez le tutoriel sur la location de parcs dans l'exemple de dépôt.

Pour obtenir la liste des champs compatibles avec Config Sync dans Terraform, consultez la documentation de référence de Terraform pour les fonctionnalités de parc GKE.

Exemple de workflow

Vous êtes un administrateur de plate-forme et vous souhaitez créer des ressources de manière dynamique sur un parc de clusters où différentes équipes ont des besoins différents. Par exemple, vous pouvez appliquer un élément NetworkPolicy aux espaces de noms de votre équipe backend, mais pas à ceux de votre équipe frontend. Dans ce scénario, la procédure à suivre pour créer des ressources à l'échelle d'une équipe dans un espace de noms est la suivante :

  1. Sélectionnez ou créez le parc dans lequel vous souhaitez gérer les ressources pour les équipes.
  2. Configurez votre source de référence. La source de vérité contient les objets NamespaceSelector que vous utilisez pour sélectionner des espaces de noms au niveau du parc dans vos champs d'application d'équipe, ainsi que toutes les ressources (telles que NetworkPolicy) que vous souhaitez synchroniser sur ces espaces de noms.

  3. Créez la configuration par défaut au niveau du parc pour Config Sync. Config Sync utilise ces paramètres par défaut lors de la synchronisation à partir de la source de référence créée à l'étape précédente. Ces paramètres Config Sync s'appliquent à tous les nouveaux clusters créés dans le parc.

  4. Créez des clusters dans votre parc.

  5. Créez les champs d'application et les espaces de noms de vos équipes frontend et backend afin que Config Sync puisse détecter et rapprocher les ressources dans vos espaces de noms.

Une fois ces étapes terminées, Config Sync crée puis applique le NetworkPolicy basé sur le NamespaceSelector aux espaces de noms de l'équipe backend. Si vous modifiez ou ajoutez des ressources, Config Sync détecte et applique en continu les modifications apportées à vos fichiers de configuration, aux champs d'application d'équipe, aux espaces de noms du parc et aux membres du parc.

Tarification

Config Sync et les fonctionnalités de gestion des équipes de parc ne sont disponibles que pour les utilisateurs qui ont activé GKE Enterprise. Pour en savoir plus sur les tarifs de GKE Enterprise, consultez la page Tarifs de GKE.

Avant de commencer

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. Installez Google Cloud CLI.

  3. Pour initialiser gcloudCLI, exécutez la commande suivante : 

    gcloud init

  4. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

    5.
  5. Installez Google Cloud CLI.

  6. Pour initialiser gcloudCLI, exécutez la commande suivante : 

    gcloud init

  7. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

    8.

  8. Créez ou assurez-vous d'avoir accès à une source fiable (dépôt Git ou image OCI) dans laquelle vous pouvez stocker vos fichiers de configuration. Les exemples de ce guide utilisent un dépôt Git.

Rôles requis

Pour obtenir les autorisations nécessaires pour créer des ressources d'équipe pour votre parc, demandez à votre administrateur de vous accorder les rôles IAM suivants sur votre projet :

Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.

Acquérir les identifiants utilisateur

Pour exécuter les commandes Terraform de ce guide dans votre environnement local, exécutez la commande suivante pour acquérir de nouveaux identifiants utilisateur :

gcloud auth application-default login

Configurer votre parc

Dans cette section, vous allez créer votre parc et activer les services requis.

Pour configurer votre parc, procédez comme suit :

  1. Créez un répertoire pour les fichiers Terraform de configuration du parc. Dans ce répertoire, ajoutez un fichier main.tf et un fichier variables.tf.

  2. Dans le fichier variables.tf, ajoutez les variables suivantes :

    variable "project" {
  type = string
  description = "GCP project ID"
}

  3. Dans le fichier main.tf, ajoutez les ressources suivantes :

    terraform {
  required_providers {
    google = {
      source = "hashicorp/google"
      version = ">= 5.16.0"
    }
  }
}

provider "google" {
  # project variable must be provided at runtime
  project = var.project
}

# Enable API services
resource "google_project_service" "services" {
  for_each = toset([
    "gkehub.googleapis.com",
    "container.googleapis.com",
    "connectgateway.googleapis.com",
    "cloudresourcemanager.googleapis.com",
    "iam.googleapis.com",
    "anthos.googleapis.com",
    "anthosconfigmanagement.googleapis.com",
  ])
  service = each.value
  disable_on_destroy = false
}

# Declare a fleet in the project
resource "google_gke_hub_fleet" "default" {
  display_name = "demo"

  depends_on = [google_project_service.services]
}

  4. Exportez la variable PROJECT_ID :

    export TF_VAR_project=PROJECT_ID

    Remplacez PROJECT_ID par l'ID du projet dans lequel vous souhaitez créer votre parc.

  5. Initialisez Terraform dans le répertoire que vous avez créé :

    terraform init

  6. Vérifiez que les modifications que vous proposez avec Terraform correspondent au plan attendu :

    terraform plan

  7. Créez le parc, activez les API et créez le compte de service :

    terraform apply

    L'activation de tous les services peut parfois prendre quelques minutes.

Configurer votre source de référence

Dans cette section, vous allez ajouter des fichiers de configuration à une source de référence. Vous avez besoin d'un objet NamespaceSelector pour chaque champ d'application d'équipe que vous souhaitez utiliser. Par exemple, si vous avez des équipes frontend et backend, vous devez créer un objet NamespaceSelector pour chaque équipe. L'objet NamespaceSelector sélectionne tout ou partie des espaces de noms dans un champ d'application d'équipe. Vous pouvez ajouter des ressources d'équipe supplémentaires à votre source de référence (par exemple, NetworkPolicy). Lorsque vous créez ces ressources, vous référencez le NamespaceSelector afin que Config Sync puisse les déployer et les synchroniser de manière dynamique sur les espaces de noms.

Pour configurer votre source de référence, procédez comme suit :

  1. Dans votre source fiable, créez un répertoire pour les fichiers de configuration à partir desquels vous souhaitez que Config Sync soit synchronisé.

  2. Pour chaque équipe, créez un objet NamespaceSelector dans votre répertoire de configuration :

    apiVersion: configmanagement.gke.io/v1
kind: NamespaceSelector
metadata:
   name: NAMESPACE_SELECTOR_NAME
spec:
  mode: dynamic
  selector:
    matchLabels:
      fleet.gke.io/fleet-scope: SCOPE_NAME

    Remplacez les éléments suivants :

    • NAMESPACE_SELECTOR_NAME : nom de l'objet NamespaceSelector (par exemple, backend-scope).
    • SCOPE_NAME : nom de votre champ d'application d'équipe (par exemple, backend).

    Tous les espaces de noms qui font partie d'un espace de noms de parc portent automatiquement le libellé fleet.gke.io/fleet-scope: SCOPE_NAME. Le fichier NamespaceSelector sélectionne tous les espaces de noms de parc d'un champ d'application d'équipe utilisant ce libellé. Pour plus d'exemples sur la manière d'inclure ou d'exclure des espaces de noms, consultez les exemples NamespaceSelector.

  3. Créez les objets que vous souhaitez synchroniser sur plusieurs espaces de noms.

    Pour ne synchroniser un objet qu'à une équipe particulière, définissez l'annotation suivante dans les métadonnées de cet objet :

    annotations:
  configmanagement.gke.io/namespace-selector: NAMESPACE_SELECTOR_NAME

    Par exemple, un NetworkPolicy pour l'équipe backend peut se présenter comme suit :

    apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: be-deny-all
  annotations:
    configmanagement.gke.io/namespace-selector: backend-scope # Actuate this resource in the namespaces with labels matched by the namespace selector
spec:
  ingress:
  - from:
    - podSelector: {}
  podSelector:
    matchLabels: null

Créer des valeurs par défaut au niveau du parc pour Config Sync

Dans cette section, vous allez créer des valeurs par défaut au niveau du parc pour Config Sync, afin d'appliquer la même configuration Config Sync à tous les clusters créés dans votre parc.

Pour créer une configuration par défaut au niveau du parc pour Config Sync, procédez comme suit :

  1. Créez un répertoire pour les fichiers Terraform de configuration par défaut du parc. Dans ce répertoire, ajoutez un fichier main.tf et un fichier variables.tf.

  2. Dans le fichier variables.tf, ajoutez les variables suivantes :

    variable "project" {
  type = string
  description = "GCP project ID"
}

  3. Dans le fichier main.tf, ajoutez la ressource suivante pour configurer les paramètres de Config Sync :

    git

    terraform {
  required_providers {
    google = {
      source = "hashicorp/google"
      version = ">=5.16.0"
     }
   }
 }

provider "google" {
  project = var.project
}

resource "google_gke_hub_feature" "feature" {
  name = "configmanagement"
  location = "global"
  provider = google
  fleet_default_member_config {
    configmanagement {
    version = "VERSION"
 config_sync {
   source_format = "unstructured"
   git {
     sync_repo = "REPO"
     sync_branch = "BRANCH"
     policy_dir = "DIRECTORY"
     secret_type = "SECRET"
        }
      }
    }
  }
}

    Remplacez les éléments suivants :

    • VERSION (facultatif) : numéro de version de Config Sync. Doit être défini sur la version 1.17.0 ou ultérieure. Si vous ne renseignez pas ce champ, la valeur par défaut est la dernière version.
    • REPO : URL du dépôt contenant vos fichiers de configuration.
    • BRANCH : branche du dépôt, par exemple main.
    • DIRECTORY : chemin d'accès dans le dépôt Git qui représente le niveau supérieur du dépôt que vous souhaitez synchroniser.
    • SECRET : type d'authentification du secret.

    Pour obtenir la liste complète des paramètres compatibles avec le bloc Config Sync git, consultez la documentation de référence de Terraform pour les fonctionnalités de GKE Hub.

    OCI

    terraform {
  required_providers {
    google = {
      source = "hashicorp/google"
      version = ">=5.16.0"
     }
   }
 }

provider "google" {
  project = var.project
}

resource "google_gke_hub_feature" "feature" {
  name = "configmanagement"
  location = "global"
  provider = google
  fleet_default_member_config {
    configmanagement {
    version = "VERSION"
    config_sync {
    source_format = "unstructured"
    oci {
     sync_repo = "REPO"
     policy_dir = "DIRECTORY"
     secret_type = "SECRET"
     }
    }
    }
  }
}

    Remplacez les éléments suivants :

    • VERSION : numéro de version de Config Sync. Doit être défini sur la version 1.17.0 ou ultérieure. Si vous ne renseignez pas ce champ, la valeur par défaut est la dernière version.
    • REPO : URL du dépôt d'images OCI contenant les fichiers de configuration.
    • DIRECTORY : chemin absolu du répertoire contenant les ressources que vous souhaitez synchroniser. Laissez ce champ vide pour utiliser le répertoire racine.
    • SECRET : type d'authentification du secret.

    Pour obtenir la liste complète des paramètres compatibles avec le bloc Config Sync oci, consultez la documentation de référence de Terraform pour les fonctionnalités de GKE Hub.

    Par exemple, le fichier main.tf suivant configure Config Sync pour qu'il se synchronise à partir d'un dépôt Git et synchronise tous les objets présents dans le répertoire config :

    terraform {
  required_providers {
    google = {
      source = "hashicorp/google"
      version = ">= 5.16.0"
    }
  }
}

provider "google" {
  project = var.project
}

resource "google_gke_hub_feature" "feature" {
  name = "configmanagement"
  location = "global"
  provider = google
  fleet_default_member_config {
    configmanagement {
      # version = "1.17.0" # Use the default latest version; if specifying a version, it must be at or after 1.17.0
      config_sync {
        source_format = "unstructured"
        git {
          sync_repo = "https://github.com/GoogleCloudPlatform/anthos-config-management-samples"
          sync_branch = "main"
          policy_dir = "fleet-tenancy/config"
          secret_type = "none"
        }
      }
    }
  }
}

  4. Initialisez Terraform dans le répertoire que vous avez créé :

    terraform init

  5. Vérifiez que les modifications que vous proposez avec Terraform correspondent au plan attendu :

    terraform plan

  6. Créez les configurations de membres de parc par défaut :

    terraform apply

Créer des clusters dans votre parc

Dans cette section, vous allez créer une configuration de cluster partagé, puis créer des clusters dans votre parc.

Pour créer et enregistrer des clusters dans votre parc, procédez comme suit :

  1. Créez un répertoire pour les fichiers Terraform de configuration du cluster. Dans ce répertoire, ajoutez un fichier main.tf et un fichier variables.tf.

  2. Dans le fichier variables.tf, ajoutez les variables suivantes :

    variable "project" {
  type = string
  description = "GCP project ID"
}

  3. Créez un fichier cluster.tf contenant les valeurs par défaut utilisées sur tous vos clusters, telles que les ID de projet et de parc :

    variable "location" {
  type = string
}

variable "cluster_name" {
  type = string
}

data "google_project" "project" {
  provider = google
}

resource "google_container_cluster" "cluster" {
 provider = google
 name               = var.cluster_name
 location           = var.location
 initial_node_count = 3
 project = data.google_project.project.project_id
 fleet {
   project = data.google_project.project.project_id
 }
 workload_identity_config {
   workload_pool = "${data.google_project.project.project_id}.svc.id.goog"
 }
 deletion_protection = false
}

  4. Dans le fichier main.tf, ajoutez les ressources suivantes :

    terraform {
  required_providers {
    google = {
    source = "hashicorp/google"
    version = ">=5.16.0"
    }
  }
}

provider "google" {
  project = var.project
}

module "MODULE_NAME" {
  source = "CLUSTER_CONFIGURATION_FILEPATH"
  cluster_name = "CLUSTER_NAME"
  location="CLUSTER_LOCATION"
}

    Remplacez les éléments suivants :

    • MODULE_NAME : nom que vous souhaitez attribuer au module de cluster. MODULE_NAME et CLUSTER_NAME peuvent être identiques (par exemple, us-east-cluster).
    • CLUSTER_CONFIGURATION_FILEPATH : chemin relatif du fichier cluster.tf que vous avez créé.
    • CLUSTER_NAME : nom du cluster MODULE_NAME et CLUSTER_NAME peuvent être identiques (par exemple, us-east-cluster).
    • CLUSTER_LOCATION : emplacement de votre cluster (par exemple, us-east1).

    Vous pouvez créer autant de clusters que vous le souhaitez. Par exemple, le fichier main.tf suivant crée trois clusters dans différentes régions :

    terraform {
  required_providers {
    google = {
      source = "hashicorp/google"
      version = ">= 5.16.0"
    }
  }
}

provider "google" {
  project = var.project
}

module "us-west-cluster" {
  source = "./cluster"
  cluster_name = "us-west-cluster"
  location="us-west1-a"
}

module "us-east-cluster" {
  source = "./cluster"
  cluster_name = "us-east-cluster"
  location="us-east1-b"
}

module "us-central-cluster" {
  source = "./cluster"
  cluster_name = "us-central-cluster"
  location="us-central1-c"
}

  5. Initialisez Terraform dans le répertoire que vous avez créé :

    terraform init

  6. Vérifiez que les modifications que vous proposez avec Terraform correspondent au plan attendu :

    terraform plan

  7. Créez les clusters :

    terraform apply

Configurer les champs d'application d'équipe et les espaces de noms du parc

Dans cette section, vous allez créer les champs d'application d'équipe et associer vos clusters à ces champs d'application. Vous créerez ensuite les espaces de noms de parc dont vous avez besoin, par exemple un pour chaque équipe dans chaque champ d'application, après quoi Config Sync créera les ressources sur vos espaces de noms.

Pour configurer les champs d'application d'équipe et les espaces de noms, procédez comme suit :

  1. Créez un répertoire pour les fichiers Terraform de configuration de champ d'application d'équipe et d'espace de noms. Dans ce répertoire, ajoutez un fichier main.tf et un fichier variables.tf.

  2. Dans le fichier variables.tf, ajoutez les variables suivantes :

    variable "project" {
  type = string
  description = "GCP project ID"
}

  3. Dans le fichier main.tf, ajoutez les ressources suivantes :

    1. Ajoutez les informations sur le fournisseur :

      terraform {
  required_providers {
    google = {
      source = "hashicorp/google"
      version = ">=5.16.0"
     }
   }
 }

provider "google" {
  project = var.project
}

    2. Ajoutez la ressource de champ d'application d'équipe :

      resource "google_gke_hub_scope" "scope" {
  provider = google
  for_each = toset([
    "SCOPE_NAME",
    "SCOPE_NAME_2",
  ])
  scope_id = each.value
}

      Remplacez les éléments suivants :

      • SCOPE_NAME : nom de votre champ d'application d'équipe (par exemple, backend).
      • SCOPE_NAME_2 : champ d'application d'équipe supplémentaire si vous en avez créé un.

      Vous pouvez ajouter autant de champs d'application d'équipe que vous le souhaitez. Lorsqu'un espace de noms de parc est créé dans le cluster, il est automatiquement libellé fleet.gke.io/fleet-scope: SCOPE_NAME, ce qui permet à Config Sync de sélectionner des espaces de noms en fonction des libellés NamespaceSelector présents lors de la synchronisation des ressources Kubernetes.

      Par exemple, une ressource Terraform de champ d'application d'équipe incluant un champ d'application pour les équipes frontend et backend peut se présenter comme suit :

      resource "google_gke_hub_scope" "scope" {
  provider = google
  for_each = toset([
    "backend",
    "frontend",
  ])
  scope_id = each.value
}

    3. Ajoutez une liaison d'appartenance à un parc pour chaque cluster que vous souhaitez appliquer à un champ d'application d'équipe :

      resource "google_gke_hub_membership_binding" "membership-binding" {
  provider = google
  for_each = {
    MEMBERSHIP_BINDING_NAME = {
      membership_binding_id = "MEMBERSHIP_BINDING_ID"
      scope = google_gke_hub_scope.scope["SCOPE_NAME"].name
      membership_id = "CLUSTER_NAME"
      location = "CLUSTER_LOCATION"
    }
    MEMBERSHIP_BINDING_NAME_2 = {
      membership_binding_id = "MEMBERSHIP_BINDING_ID_2"
      scope = google_gke_hub_scope.scope["SCOPE_NAME_2"].name
      membership_id = "CLUSTER_NAME_2"
      location = "CLUSTER_LOCATION_2"
    }
  }
  membership_binding_id = each.value.membership_binding_id
  scope = each.value.scope
  membership_id = each.value.membership_id
  location = each.value.location

  depends_on = [google_gke_hub_scope.scope]
}

      Remplacez les éléments suivants :

      • MEMBERSHIP_BINDING_NAME : nom de la liaison d'appartenance, par exemple us-east-backend.
      • MEMBERSIP_BINDING_ID : ID de la liaison d'appartenance. Cette valeur peut être identique à MEMBERSHIP_BINDING_NAME.
      • SCOPE_NAME : sélecteur de libellés que vous avez attribué à votre champ d'application d'équipe lors de la création d'un NamespaceSelector (par exemple, backend).
      • CLUSTER_NAME : nom du cluster que vous avez créé lors de la création des clusters (par exemple, us-east-cluster).
      • CLUSTER_LOCATION : emplacement du cluster (par exemple, us-east1).

      Vous devez définir une liaison d'appartenance à un parc pour chaque cluster. Si vous ne définissez pas de champ d'application d'équipe pour un cluster, ce cluster n'est pas créé pour cet espace de noms. Par exemple, si vous disposez de trois clusters dans les régions us-east1, us-west1 et us-central1, mais que le cluster us-central1 ne concerne que l'équipe frontend, votre ressource de liaison d'adhésion ressemblerait à ceci :

      resource "google_gke_hub_membership_binding" "membership-binding" {
  provider = google
  for_each = {
    us-east-backend = {
      membership_binding_id = "us-east-backend"
      scope = google_gke_hub_scope.scope["backend"].name
      membership_id = "us-east-cluster"
      location = "us-east1"
    }
    us-west-backend = {
      membership_binding_id = "us-west-backend"
      scope = google_gke_hub_scope.scope["backend"].name
      membership_id = "us-west-cluster"
      location = "us-west1"
    }
    us-east-frontend = {
      membership_binding_id = "us-east-frontend"
      scope = google_gke_hub_scope.scope["frontend"].name
      membership_id = "us-east-cluster"
      location = "us-east1"
    }
    us-west-frontend = {
      membership_binding_id = "us-west-frontend"
      scope = google_gke_hub_scope.scope["frontend"].name
      membership_id = "us-west-cluster"
      location = "us-west1"
    }
    us-central-frontend = {
      membership_binding_id = "us-central-frontend"
      scope = google_gke_hub_scope.scope["frontend"].name
      membership_id = "us-central-cluster"
      location = "us-central1"
    }
  }

  membership_binding_id = each.value.membership_binding_id
  scope = each.value.scope
  membership_id = each.value.membership_id
  location = each.value.location

  depends_on = [google_gke_hub_scope.scope]
}

    4. Ajoutez les espaces de noms que vous souhaitez définir pour vos équipes :

      resource "google_gke_hub_namespace" "fleet_namespace" {
  provider = google

  for_each = {
    FLEET_NAMESPACE = {
      scope_id = "SCOPE_NAME"
      scope_namespace_id = "FLEET_NAMESPACE_ID"
      scope = google_gke_hub_scope.scope["SCOPE_NAME"].name
    }
    FLEET_NAMESPACE_2 = {
      scope_id = "SCOPE_NAME"
      scope_namespace_id = "FLEET_NAMESPACE_ID_2"
      scope = google_gke_hub_scope.scope["SCOPE_NAME"].name
    }

}

  scope_namespace_id = each.value.scope_namespace_id
  scope_id = each.value.scope_id
  scope = each.value.scope

  depends_on = [google_gke_hub_scope.scope]
}

      Remplacez les éléments suivants :

      • FLEET_NAMESPACE : nom que vous souhaitez attribuer à l'espace de noms, par exemple backend-a.
      • SCOPE_NAME : sélecteur de libellés que vous avez attribué à votre champ d'application d'équipe lors de la création d'un NamespaceSelector (par exemple, backend).
      • FLEET_NAMESPACE_ID : ID de l'espace de noms Il peut s'agir de la même valeur que FLEET_NAMESPACE.

      Par exemple, si vous souhaitez que l'équipe frontend et l'équipe backend disposent chacune de deux espaces de noms, votre ressource d'espace de noms de parc peut se présenter comme suit :

      resource "google_gke_hub_namespace" "fleet_namespace" {
  provider = google

  for_each = {
    bookstore = {
      scope_id = "backend"
      scope_namespace_id = "bookstore"
      scope = google_gke_hub_scope.scope["backend"].name
    }
    shoestore = {
      scope_id = "backend"
      scope_namespace_id = "shoestore"
      scope = google_gke_hub_scope.scope["backend"].name
    }
    frontend_a = {
      scope_id = "frontend"
      scope_namespace_id = "frontend-a"
      scope = google_gke_hub_scope.scope["frontend"].name
    }
    frontend_b = {
      scope_id = "frontend"
      scope_namespace_id = "frontend-b"
      scope = google_gke_hub_scope.scope["frontend"].name
    }
  }

  scope_namespace_id = each.value.scope_namespace_id
  scope_id = each.value.scope_id
  scope = each.value.scope

  depends_on = [google_gke_hub_scope.scope]
}

  4. Initialisez Terraform dans le répertoire que vous avez créé :

    terraform init

  5. Vérifiez que les modifications que vous proposez avec Terraform correspondent au plan attendu :

    terraform plan

  6. Créez les champs d'application et les espaces de noms du parc :

    terraform apply

Une fois que vous avez créé des champs d'application et des espaces de noms de parc, Config Sync détecte ces nouveaux espaces de noms et leurs champs d'application, sélectionne les ressources dans les espaces de noms du parc et les rapproche de vos fichiers de configuration.

Vous pouvez vérifier que vos ressources sont appliquées au cluster approprié à l'aide de nomos status ou en accédant à l'onglet Packages de Config Sync dans la console Google Cloud puis en modifiant la case d'option Afficher par pour choisir Cluster.

Accéder à "Packages"

Config Sync synchronise vos ressources entre les espaces de noms en fonction de vos champs d'application d'équipe, en se basant sur la configuration stockée dans votre source de référence. Chaque fois que vous ajoutez une ressource, tant que vous incluez l'annotation NamespaceSelector appropriée, Config Sync rapproche automatiquement cette ressource de vos espaces de noms d'équipe.

Si vous souhaitez appliquer les paramètres Config Sync à vos clusters existants, consultez les instructions de la section Configurer les valeurs par défaut au niveau du parc dans le guide d'installation de Config Sync.

Étapes suivantes