Teamressourcen in der gesamten Flotte verwalten

Auf dieser Seite wird erläutert, wie Sie mit Config Sync und Terraform dynamisch teambezogene Ressourcen in einer Reihe von Clustern erstellen. Config Sync erweitert die Funktionen der Flottenteamverwaltung, um Infrastruktur- und Clusterkonfigurationen in Ihren Flotten zu erstellen und zu verwalten.

In dieser Anleitung wird davon ausgegangen, dass Sie mit den Konzepten der Flottenteamverwaltung wie Teambereiche und Flotten-Namespaces vertraut sind. Weitere Informationen finden Sie in der Übersicht zur Flottenteamverwaltung.

Eine End-to-End-Anleitung mit Beispielkonfigurationen finden Sie in der Anleitung zur Flotten-Mandantenfähigkeit im Beispiel-Repository.

Eine Liste der für Config Sync in Terraform unterstützten Felder finden Sie in der Terraform-Referenzdokumentation für GKE-Flottenfeatures.

Beispielworkflow

Sie sind ein Plattformadministrator, der Ressourcen für eine Flotte von Clustern dynamisch erstellen möchte, bei denen verschiedene Teams unterschiedliche Anforderungen haben. Sie können beispielsweise eine NetworkPolicy auf die Namespaces des Backend-Teams anwenden, nicht jedoch auf die Namespaces Ihres Frontend-Teams. In diesem Szenario gehen Sie so vor, um teambezogene Ressourcen in einem Namespace zu erstellen:

Wählen Sie die Flotte aus, in der Sie Ressourcen für Teams verwalten möchten, oder erstellen Sie eine.
Richten Sie Ihre "Source of Truth" ein. Die "Source of Truth" enthält die NamespaceSelector-Objekte, mit denen Sie Namespaces auf Flottenebene in Ihren Teambereichen auswählen, sowie alle Ressourcen (z. B. NetworkPolicy), die Sie über diese Namespaces hinweg synchronisieren möchten..

Schlüsselbegriff: NamespaceSelector ist ein spezieller Konfigurationstyp, der von Config Sync verwendet wird, um einzuschränken, auf welche Namespaces sich eine andere Konfiguration auswirkt. Weitere Informationen finden Sie unter Begrenzen, welche Namespaces von einer Konfiguration betroffen sind.
Erstellen Sie die Standardkonfiguration für Config Sync auf Flottenebene. Config Sync verwendet diese Standardeinstellungen bei der Synchronisierung aus der im vorherigen Schritt erstellten "Source of Truth". Diese Config Sync-Einstellungen gelten für alle neuen Cluster, die in der Flotte erstellt werden.

Wichtig: Sie müssen die Standardkonfiguration auf Flottenebene erstellen, bevor Sie neue Cluster erstellen. Diese Einstellungen werden nur automatisch auf neue Cluster angewendet, die in der Flotte erstellt werden. Informationen zum Anwenden dieser Einstellungen auf vorhandene Cluster finden Sie in der Config Sync-Installationsanleitung unter Standardeinstellungen auf Flottenebene konfigurieren.
Cluster in Ihrer Flotte erstellen
Erstellen Sie die Frontend- und Backend-Teambereiche und -Namespaces, damit Config Sync Ressourcen in Ihren Namespaces erkennen und abgleichen kann.

Nachdem Sie diese Schritte ausgeführt haben, erstellt Config Sync die NetworkPolicy basierend auf dem NamespaceSelector und wendet sie auf die Namespaces des Backend-Teams an. Wenn Sie Ressourcen ändern oder hinzufügen, erkennt Config Sync kontinuierlich und wendet kontinuierlich an: Änderungen an Ihren Konfigurationsdateien, Teambereichen, Flotten-Namespaces und Flottenmitgliedern.

Preise

Config Sync und Features zur Flottenteamverwaltung sind nur für Nutzer verfügbar, die GKE Enterprise aktiviert haben. Weitere Informationen zu den GKE Enterprise-Preisen finden Sie auf der Seite GKE-Preise.

Hinweise

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

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.

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

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.

Eine "Source of Truth" erstellen oder Zugriff darauf haben (entweder ein Git-Repository oder ein OCI-Image), in dem Sie Ihre Konfigurationsdateien speichern können. In den Beispielen in dieser Anleitung wird ein Git-Repository verwendet.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für Ihr Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen von Teamressourcen für Ihre Flotte benötigen:

Flottenressourcen verwalten: Fleet Admin (früher GKE Hub Admin) (roles/gkehub.admin)
GKE-Cluster erstellen: Kubernetes Engine-Clusteradministrator (roles/container.clusterAdmin)
GKE Enterprise aktivieren: Service Usage Administrator (roles/serviceusage.serviceUsageAdmin)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Nutzeranmeldedaten abrufen

Führen Sie zum Ausführen der Terraform-Befehle in dieser Anleitung in Ihrer lokalen Umgebung den folgenden Befehl aus, um neue Nutzeranmeldedaten abzurufen:

gcloud auth application-default login

Flotte einrichten

In diesem Abschnitt erstellen Sie Ihre Flotte und aktivieren die erforderlichen Dienste.

Führen Sie die folgenden Schritte aus, um den Flotte einzurichten:

Erstellen Sie ein Verzeichnis für die Terraform-Dateien der Fleet-Konfiguration. Fügen Sie diesem Verzeichnis eine main.tf- und eine variables.tf-Datei hinzu.

Fügen Sie in der Datei variables.tf die folgenden Variablen hinzu:

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

Fügen Sie in der Datei main.tf den folgenden Ressourcen hinzu:

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

Exportieren Sie die Variable PROJECT_ID:
```
export TF_VAR_project=PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch die Projekt-ID, unter der Sie die Flotte erstellen möchten.
Initialisieren Sie Terraform im von Ihnen erstellten Verzeichnis:
```
terraform init
```
Prüfen Sie, ob die vorgeschlagenen Änderungen mit Terraform dem erwarteten Plan entsprechen:
```
terraform plan
```
Erstellen Sie die Flotte, aktivieren Sie die APIs und erstellen Sie das Dienstkonto:
```
terraform apply
```
Es kann einige Minuten dauern, bis alle Dienste aktiviert sind.

„Source of Truth“ einrichten

In diesem Abschnitt fügen Sie einer "Source of Truth" Konfigurationsdateien hinzu. Für jeden Teambereich, den Sie verwenden möchten, benötigen Sie ein NamespaceSelector-Objekt. Wenn Sie beispielsweise Frontend- und Backend-Teams haben, müssen Sie für jedes Team ein NamespaceSelector-Objekt erstellen. Mit dem Objekt NamespaceSelector werden alle oder einige Namespaces innerhalb eines Teambereichs ausgewählt. Sie können der "Source of Truth" zusätzliche Teamressourcen hinzufügen, z. B. NetworkPolicy. Wenn Sie diese Ressourcen erstellen, verweisen Sie auf die NamespaceSelector, damit Config Sync diese Ressourcen dynamisch in Namespaces bereitstellen und synchronisieren kann.

So richten Sie Ihre „Source of Truth“ ein:

Erstellen Sie in Ihrer "Source of Truth" ein Verzeichnis für die Konfigurationsdateien, aus denen Config Sync synchronisiert werden soll.
Erstellen Sie für jedes Team ein NamespaceSelector-Objekt in Ihrem Konfigurationsverzeichnis:

Wichtig: Für NamespaceSelector muss der Modus auf dynamic festgelegt sein. Im dynamischen Modus können Namespaces ausgewählt werden, die sowohl statisch in der „Source of Truth“ deklariert als auch dynamisch im Cluster vorhanden sind.
```
apiVersion: configmanagement.gke.io/v1
kind: NamespaceSelector
metadata:
   name: NAMESPACE_SELECTOR_NAME
spec:
  mode: dynamic
  selector:
    matchLabels:
      fleet.gke.io/fleet-scope: SCOPE_NAME
```
Ersetzen Sie Folgendes:
- NAMESPACE_SELECTOR_NAME: der Name des NamespaceSelector-Objekts, z. B. backend-scope.
- SCOPE_NAME: der Name Ihres Teambereichs, z. B. backend.
Alle Namespaces, die Teil eines Flotten-Namespace sind, haben automatisch das Label fleet.gke.io/fleet-scope: SCOPE_NAME. Der NamespaceSelector wählt alle Flotten-Namespaces eines Teambereichs mit diesem Label aus. Weitere Beispiele zum Ein- oder Ausschließen von Namespaces finden Sie unter NamespaceSelector-Beispiele.

Erstellen Sie alle Objekte, die Sie über Namespaces hinweg synchronisieren möchten.

Wenn Sie ein Objekt nur mit einem bestimmten Team synchronisieren möchten, legen Sie die folgende Annotation in den Metadaten dieses Objekts fest:

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

Eine NetworkPolicy für das Backend-Team könnte beispielsweise so aussehen:

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

Standardeinstellungen auf Flottenebene für Config Sync erstellen

In diesem Abschnitt erstellen Sie Standardeinstellungen für Config Sync auf Flottenebene, wodurch dieselbe Config Sync-Konfiguration auf alle in Ihrer Flotte erstellten Cluster angewendet wird.

Führen Sie die folgenden Schritte aus, um eine Standardkonfiguration auf Flottenebene für Config Sync zu erstellen:

Erstellen Sie ein Verzeichnis für die Terraform-Dateien der Standardkonfiguration der Flotte. Fügen Sie diesem Verzeichnis eine main.tf- und eine variables.tf-Datei hinzu.

Fügen Sie in der Datei variables.tf die folgenden Variablen hinzu:

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

Fügen Sie in der Datei main.tf die folgende Ressource hinzu, um die Einstellungen von Config Sync zu konfigurieren:

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

Ersetzen Sie Folgendes:

VERSION: (Optional) Die Config Sync-Versionsnummer. Sie muss auf Version 1.17.0 oder höher festgelegt sein. Wenn Sie dieses Feld leer lassen, wird die Standardeinstellung verwendet, nämlich die neueste Version.
REPO ist die URL zum Repository mit Ihren Konfigurationsdateien.
BRANCH ist der Repository-Zweig, z. B. main.
DIRECTORY: der Pfad im Git-Repository, der die oberste Ebene des Repositorys darstellt, das Sie synchronisieren möchten.
SECRET: der Secret-Authentifizierungstyp.

Eine vollständige Liste der im Config Sync-Block git unterstützten Einstellungen finden Sie in der Terraform-Referenzdokumentation für GKE-Hub-Features.

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

Ersetzen Sie Folgendes:

VERSION: Die Config Sync-Versionsnummer. Sie muss auf Version 1.17.0 oder höher festgelegt sein. Wenn Sie dieses Feld leer lassen, wird die Standardeinstellung verwendet, nämlich die neueste Version.
REPO ist die URL zum OCI-Image-Repository mit Konfigurationsdateien.
DIRECTORY ist der absolute Pfad des Verzeichnisses mit den Ressourcen, die Sie synchronisieren möchten. Lassen Sie das Feld leer, wenn Sie das Stammverzeichnis verwenden möchten.
SECRET ist der Secret-Authentifizierungstyp.

Eine vollständige Liste der im Config Sync-Block oci unterstützten Einstellungen finden Sie in der Terraform-Referenzdokumentation für GKE-Hub-Features.

Die folgende main.tf-Datei konfiguriert Config Sync beispielsweise für die Synchronisierung aus einem Git-Repository und synchronisiert alle Objekte im Verzeichnis 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"
        }
      }
    }
  }
}

Initialisieren Sie Terraform im von Ihnen erstellten Verzeichnis:
```
terraform init
```
Prüfen Sie, ob die vorgeschlagenen Änderungen mit Terraform dem erwarteten Plan entsprechen:
```
terraform plan
```
Erstellen Sie die Standardkonfigurationen für die Flottenmitglieder:
```
terraform apply
```

Cluster in Ihrer Flotte erstellen

In diesem Abschnitt erstellen Sie eine freigegebene Clusterkonfiguration und dann Cluster in Ihrer Flotte.

Führen Sie die folgenden Schritte aus, um neue Cluster in Ihrer Flotte zu erstellen und zu registrieren:

Erstellen Sie ein Verzeichnis für die Terraform-Dateien der Clusterkonfiguration. Fügen Sie diesem Verzeichnis eine main.tf- und eine variables.tf-Datei hinzu.

Fügen Sie in der Datei variables.tf die folgenden Variablen hinzu:

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

Erstellen Sie eine cluster.tf-Datei, die Standardwerte enthält, die für alle Cluster verwendet werden, z. B. Ihre Projekt- und Flotten-IDs:

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
}

Fügen Sie in der Datei main.tf den folgenden Ressourcen hinzu:

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

Ersetzen Sie Folgendes:

MODULE_NAME: der Name, den Sie dem Clustermodul geben möchten MODULE_NAME und CLUSTER_NAME können derselbe Wert sein, z. B. us-east-cluster.
CLUSTER_CONFIGURATION_FILEPATH: der relative Pfad zur von Ihnen erstellten cluster.tf-Datei.
CLUSTER_NAME: Der Name Ihres Clusters. MODULE_NAME und CLUSTER_NAME können derselbe Wert sein, z. B. us-east-cluster.
CLUSTER_LOCATION: Der Standort Ihres Clusters, z. B. us-east1.

Sie können beliebig viele Cluster erstellen. Mit der folgenden main.tf-Datei werden beispielsweise drei Cluster in verschiedenen Regionen erstellt:

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

Initialisieren Sie Terraform im von Ihnen erstellten Verzeichnis:
```
terraform init
```
Prüfen Sie, ob die vorgeschlagenen Änderungen mit Terraform dem erwarteten Plan entsprechen:
```
terraform plan
```
Erstellen Sie die Cluster:
```
terraform apply
```

Teambereiche und Flotten-Namespaces konfigurieren

In diesem Abschnitt erstellen Sie Ihre Teambereiche und verknüpfen Ihre Cluster mit diesen Bereichen. Anschließend erstellen Sie die erforderlichen Flotten-Namespaces, z. B. einen für jedes Team in jedem Bereich, und Config Sync erstellt die Ressourcen in Ihren Namespaces.

Führen Sie die folgenden Schritte aus, um Teambereiche und Namespaces zu konfigurieren:

Erstellen Sie ein Verzeichnis für die Terraform-Dateien der Teambereichs- und Namespace-Konfiguration. Fügen Sie diesem Verzeichnis eine main.tf- und eine variables.tf-Datei hinzu.

Fügen Sie in der Datei variables.tf die folgenden Variablen hinzu:

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

Fügen Sie in der Datei main.tf den folgenden Ressourcen hinzu:

Fügen Sie die Anbieterinformationen hinzu:

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

provider "google" {
  project = var.project
}

Fügen Sie die Teambereichsressource hinzu:
```
resource "google_gke_hub_scope" "scope" {
  provider = google
  for_each = toset([
    "SCOPE_NAME",
    "SCOPE_NAME_2",
  ])
  scope_id = each.value
}
```
Ersetzen Sie Folgendes:
- SCOPE_NAME: der Name Ihres Teambereichs, z. B. backend.
- SCOPE_NAME_2: ein zusätzlicher Teambereich, falls Sie einen erstellt haben.
Sie können beliebig viele Teambereiche hinzufügen. Wenn ein Flotten-Namespace im Cluster erstellt wird, erhält er automatisch das Label fleet.gke.io/fleet-scope: SCOPE_NAME, sodass Config Sync Namespaces anhand der vorhandenen NamespaceSelector-Labels auswählen kann, wenn es Kubernetes-Ressourcen Synchronisiert.

Eine Terraform-Ressource für einen Teambereich, die einen Bereich für das Frontend- und für das Backend-Team enthält, könnte beispielsweise so aussehen:
```
resource "google_gke_hub_scope" "scope" {
  provider = google
  for_each = toset([
    "backend",
    "frontend",
  ])
  scope_id = each.value
}
```

Fügen Sie eine Bindung der Flottenmitgliedschaft für jeden Cluster hinzu, den Sie auf einen Teambereich anwenden möchten:

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

Ersetzen Sie Folgendes:

MEMBERSHIP_BINDING_NAME: der Name der Mitgliedschaftsbindung, z. B. us-east-backend.
MEMBERSIP_BINDING_ID: die ID der Mitgliedschaftsbindung. Dieser kann mit MEMBERSHIP_BINDING_NAME identisch sein.
SCOPE_NAME ist die Labelauswahl, die Sie Ihrem Teambereich beim Erstellen eines NamespaceSelector zugewiesen haben, z. B. backend.
CLUSTER_NAME: der Name des Clusters, den Sie beim Erstellen von Clustern angelegt haben, z. B. us-east-cluster.
CLUSTER_LOCATION: Der Clusterstandort, z. B. us-east1.

Sie müssen für jeden Cluster eine Bindung der Flottenmitgliedschaft definieren. Definieren Sie für einen Cluster keinen Teambereich, wird dieser Cluster nicht für diesen Namespace erstellt. Wenn Sie beispielsweise drei Cluster in den Regionen us-east1, us-west1 und us-central1 haben, der us-central1-Cluster jedoch nur für das Frontend-Team bestimmt ist, würde Ihre Mitgliedschaftsbindungsressource so aussehen:

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

Fügen Sie alle Namespaces hinzu, die Sie für Ihre Teams definieren möchten:

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

Ersetzen Sie Folgendes:

FLEET_NAMESPACE: der Name, den Sie dem Namespace geben möchten, z. B. backend-a.
SCOPE_NAME ist die Labelauswahl, die Sie Ihrem Teambereich beim Erstellen eines NamespaceSelector zugewiesen haben, z. B. backend.
FLEET_NAMESPACE_ID: die Namespace-ID. Dieser kann mit FLEET_NAMESPACE identisch sein.

Wenn Sie beispielsweise möchten, dass sowohl das Frontend- als auch das Backend-Team zwei Namespaces haben, könnte Ihre Flotten-Namespace-Ressource so aussehen:

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

Initialisieren Sie Terraform im von Ihnen erstellten Verzeichnis:
```
terraform init
```
Prüfen Sie, ob die vorgeschlagenen Änderungen mit Terraform dem erwarteten Plan entsprechen:
```
terraform plan
```
Erstellen Sie die Flottenbereiche und -Namespaces:
```
terraform apply
```

Nachdem Sie Flottenbereiche und Namespaces erstellt haben, erkennt Config Sync diese neuen Namespaces und ihre Bereiche, wählt Ressourcen in den Flotten-Namespaces aus und gleicht sie mit Ihren Konfigurationsdateien ab.

Sie können prüfen, ob Ihre Ressourcen auf den richtigen Cluster angewendet werden. Verwenden Sie dazu nomos status oder rufen Sie in der Google Cloud Console den Config Sync-Tab Pakete auf und ändern Sie das Optionsfeld Anzeigen nach auf Cluster.

Zu "Pakete"

Config Sync synchronisiert Ihre Ressourcen über Namespaces hinweg basierend auf Ihren Teambereichen gemäß der in Ihrer „Source of Truth“ gespeicherten Konfiguration. Wenn Sie eine neue Ressource hinzufügen, gleicht Config Sync diese Ressource automatisch mit den verschiedenen Namespaces Ihres Teams ab, sofern Sie die richtige Annotation NamespaceSelector angeben.

Wenn Sie die Config Sync-Einstellungen auf Ihre vorhandenen Cluster anwenden möchten, lesen Sie die Anleitung unter Standardeinstellungen auf Flottenebene konfigurieren in der Config Sync-Installationsanleitung.

Nächste Schritte

Weitere Informationen zum Einrichten von Teams für Ihren Flotte