Gérez les ressources d'équipe de votre parc

Cette page explique comment utiliser Config Sync et Terraform pour créer de manière dynamique des ressources à l'échelle de l'équipe sur un parc de clusters. Config Sync étend les fonctionnalités de gestion des équipes de parc pour créer et gérer des configurations d'infrastructure et de cluster pour 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 niveaux d'accès 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 suivre un tutoriel de bout en bout avec des exemples de configurations, consultez le tutoriel sur la location de parc 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 sur les fonctionnalités de parc GKE.

Exemple de workflow

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

Choisissez ou créez le parc dans lequel vous souhaitez gérer les ressources des équipes.
Configurez votre source de référence. La source de référence contient les objets NamespaceSelector que vous utilisez pour sélectionner des espaces de noms au niveau du parc dans les niveaux d'accès de votre équipe, ainsi que toutes les ressources (comme NetworkPolicy) que vous souhaitez synchroniser sur ces espaces de noms.
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 fiable créée à l'étape précédente. Ces paramètres Config Sync s'appliquent à tous les clusters créés dans le parc.

Important :Vous devez créer la configuration par défaut au niveau du parc avant de créer des clusters. Ces paramètres ne s'appliquent automatiquement qu'aux nouveaux clusters créés dans le parc. Si vous souhaitez appliquer ces paramètres à des clusters existants, consultez la section Configurer les valeurs par défaut au niveau du parc dans le guide d'installation de Config Sync.
Créez des clusters dans votre parc.
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 et applique le NetworkPolicy en fonction du NamespaceSelector aux espaces de noms de l'équipe backend. Si vous modifiez ou ajoutez des ressources, Config Sync détecte et applique en continu toutes les modifications apportées à vos fichiers de configuration, vos niveaux d'accès d'équipe, vos espaces de noms de parc et vos membres de parc.

Tarification

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

Avant de commencer

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.

Installez Google Cloud CLI.

Pour initialiser gcloudCLI, exécutez la commande suivante :

gcloud init

Créez ou sélectionnez un projet Google Cloud.

Créez un projet Google Cloud :
```
gcloud projects create PROJECT_ID
```
Remplacez PROJECT_ID par le nom du projet Google Cloud que vous créez.
Sélectionnez le projet Google Cloud que vous avez créé :
```
gcloud config set project PROJECT_ID
```
Remplacez PROJECT_ID par le nom de votre projet Google Cloud.

Installez Google Cloud CLI.

Pour initialiser gcloudCLI, exécutez la commande suivante :

gcloud init

Créez ou sélectionnez un projet Google Cloud.

Créez un projet Google Cloud :
```
gcloud projects create PROJECT_ID
```
Remplacez PROJECT_ID par le nom du projet Google Cloud que vous créez.
Sélectionnez le projet Google Cloud que vous avez créé :
```
gcloud config set project PROJECT_ID
```
Remplacez PROJECT_ID par le nom de votre projet Google Cloud.

Créez ou avez accès à une source de référence (un dépôt Git ou une 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 attribuer les rôles IAM suivants sur votre projet:

Gestion des ressources du parc : Administrateur de parc (anciennement administrateur GKE Hub) (roles/gkehub.admin)
Création de clusters GKE : Administrateur de cluster Kubernetes Engine (roles/container.clusterAdmin)
Activation de GKE Enterprise : Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin)

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.

Obtenir des identifiants utilisateur

Pour exécuter les commandes Terraform présentées dans ce guide dans votre environnement local, exécutez la commande suivante afin d'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:

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.

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

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

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]
}

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.
Initialisez Terraform dans le répertoire que vous avez créé:
```
terraform init
```
Vérifiez que les modifications que vous proposez avec Terraform correspondent au plan attendu:
```
terraform plan
```
Créez le parc, activez les API, puis créez le compte de service:
```
terraform apply
```
L'activation de tous les services peut parfois prendre quelques minutes.

Configurez votre source de référence

Dans cette section, vous allez ajouter des fichiers de configuration à une source fiable. Vous avez besoin d'un objet NamespaceSelector pour chaque niveau d'accès 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 d'un niveau d'accès d'équipe. Vous pouvez ajouter des ressources d'équipe supplémentaires à votre source de référence, comme un NetworkPolicy. Lorsque vous créez ces ressources, vous référencez 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:

Dans votre source de référence, créez un répertoire pour les fichiers de configuration à partir desquels vous souhaitez que Config Sync soit synchronisé.
Pour chaque équipe, créez un objet NamespaceSelector dans le répertoire de configuration:

Important :Le mode de NamespaceSelector doit être défini sur dynamic. Le mode dynamique permet de sélectionner des espaces de noms à la fois déclarés de manière statique dans la source de référence et tous les espaces de noms présents dynamiquement dans le cluster.
```
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 du niveau d'accès de votre équipe, par exemple backend.
Tous les espaces de noms faisant partie d'un espace de noms de parc sont automatiquement associés au libellé fleet.gke.io/fleet-scope: SCOPE_NAME. NamespaceSelector sélectionne tous les espaces de noms de parc d'un niveau d'accès d'équipe utilisant ce libellé. Pour plus d'exemples sur la façon d'inclure ou d'exclure des espaces de noms, consultez les exemples de NamespaceSelector.

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

Pour synchroniser un objet uniquement avec 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, qui applique 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:

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.

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

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

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 aucune valeur n'est spécifiée, 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 sur 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 aucune valeur n'est spécifiée, 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 le 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 sur 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, ainsi que 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"
        }
      }
    }
  }
}

Initialisez Terraform dans le répertoire que vous avez créé:
```
terraform init
```
Vérifiez que les modifications que vous proposez avec Terraform correspondent au plan attendu:
```
terraform plan
```
Créez les configurations de membres du 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 des clusters dans votre parc.

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

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.

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

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

Créez un fichier cluster.tf contenant les valeurs par défaut utilisées dans 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
}

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 donner au module du cluster. MODULE_NAME et CLUSTER_NAME peuvent être la même valeur (par exemple, us-east-cluster).
CLUSTER_CONFIGURATION_FILEPATH: chemin d'accès relatif au fichier cluster.tf que vous avez créé.
CLUSTER_NAME : nom du cluster MODULE_NAME et CLUSTER_NAME peuvent être la même valeur (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"
}

Initialisez Terraform dans le répertoire que vous avez créé:
```
terraform init
```
Vérifiez que les modifications que vous proposez avec Terraform correspondent au plan attendu:
```
terraform plan
```
Créez les clusters:
```
terraform apply
```

Configurer les niveaux d'accès d'équipe et les espaces de noms de parc

Dans cette section, vous allez créer les niveaux d'accès d'équipe et associer vos clusters à ces champs d'application. Créez ensuite les espaces de noms de parc dont vous avez besoin, par exemple un pour chaque équipe, dans chaque niveau d'accès. Config Sync crée ensuite les ressources pour l'ensemble de vos espaces de noms.

Pour configurer les niveaux d'accès et les espaces de noms d'équipe, procédez comme suit:

Créez un répertoire pour les fichiers Terraform de configuration du niveau d'accès de l'équipe et de l'espace de noms. Dans ce répertoire, ajoutez un fichier main.tf et un fichier variables.tf.

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

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

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

Ajoutez les informations sur le fournisseur:

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

provider "google" {
  project = var.project
}

Ajoutez la ressource de niveau d'accès de l'é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 du niveau d'accès de votre équipe, par exemple backend.
- SCOPE_NAME_2: niveau d'accès d'équipe supplémentaire si vous en avez créé un.
Vous pouvez ajouter autant de niveaux d'accès d'équipe que nécessaire. Lorsqu'un espace de noms de parc est créé dans le cluster, il est automatiquement associé au 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 pour le niveau d'accès d'une équipe, incluant à la fois l'équipe frontend et l'équipe backend, peut se présenter comme suit:
```
resource "google_gke_hub_scope" "scope" {
  provider = google
  for_each = toset([
    "backend",
    "frontend",
  ])
  scope_id = each.value
}
```

Ajoutez une liaison d'appartenance au parc pour chaque cluster que vous souhaitez appliquer à un niveau d'accès 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 liaison d'appartenance. Il peut être identique à MEMBERSHIP_BINDING_NAME.
SCOPE_NAME: sélecteur de libellés que vous avez attribué à votre é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 de clusters, par exemple us-east-cluster.
CLUSTER_LOCATION: emplacement du cluster, par exemple us-east1.

Vous devez définir une liaison d'appartenance au parc pour chaque cluster. Si vous ne définissez pas de niveau d'accès d'équipe pour un cluster, ce cluster n'est pas créé pour cet espace de noms. Par exemple, si vous avez trois clusters dans les régions us-east1, us-west1 et us-central1, mais que le cluster us-central1 est réservé à l'équipe frontend, votre ressource de liaison d'appartenance ressemblera à ce qui suit:

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]
}

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 donner à l'espace de noms, par exemple backend-a.
SCOPE_NAME: sélecteur de libellés que vous avez attribué à votre é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, la ressource d'espace de noms de votre 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]
}

Initialisez Terraform dans le répertoire que vous avez créé:
```
terraform init
```
Vérifiez que les modifications que vous proposez avec Terraform correspondent au plan attendu:
```
terraform plan
```
Créez les niveaux d'accès et les espaces de noms du parc:
```
terraform apply
```

Une fois que vous avez créé les niveaux d'accès et les espaces de noms du 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 avec vos fichiers de configuration.

Vous pouvez vérifier que vos ressources sont appliquées au bon cluster en utilisant nomos status ou en accédant à l'onglet Packages de Config Sync dans la console Google Cloud et en sélectionnant la case d'option Afficher par sur Cluster.

Accéder aux packages

Config Sync synchronise vos ressources sur les espaces de noms en fonction des niveaux d'accès de votre équipe et en fonction de la configuration stockée dans votre source de référence. Chaque fois que vous ajoutez une ressource, tant que vous incluez la bonne annotation NamespaceSelector, Config Sync consolide automatiquement cette ressource entre les espaces de noms de votre équipe.

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

Étapes suivantes

En savoir plus sur la configuration d'équipes pour votre parc