Diese Seite wurde von der Cloud Translation API übersetzt.

Teamressourcen in der gesamten Flotte verwalten

Auf dieser Seite wird erläutert, wie Sie mit Config Sync und Terraform dynamisch teambezogene Ressourcen in einer Flotte von Clustern erstellen. Config Sync erweitert die Funktionen der Flottenteamverwaltung, sodass Sie Infrastruktur- und Clusterkonfigurationen für Ihre Flotten erstellen und verwalten können.

In diesem Leitfaden wird davon ausgegangen, dass Sie mit Konzepten der Flottenteamverwaltung wie Teambereichen und Flotten-Namespaces vertraut sind. Weitere Informationen finden Sie in der Übersicht über die Flottenteamverwaltung.

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

Eine Liste der Felder, die für Config Sync in Terraform unterstützt werden, finden Sie in der Terraform-Referenzdokumentation für GKE-Flottenfunktionen.

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 möchten beispielsweise eine NetworkPolicy auf die Namespaces Ihres Backend-Teams, aber nicht auf die Namespaces Ihres Frontend-Teams anwenden. In diesem Szenario gehen Sie so vor, um Ressourcen mit Teambereich in einem Namespace zu erstellen:

Wählen Sie die Flotte aus, in der Sie Ressourcen für Teams verwalten möchten, oder erstellen Sie sie.
Richten Sie Ihre aktuelle Informationsquelle 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 :Ein NamespaceSelector ist ein spezieller Konfigurationstyp, der von Config Sync verwendet wird, um zu begrenzen, 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 auf Flottenebene für Config Sync. 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. Wenn Sie diese Einstellungen auf vorhandene Cluster anwenden möchten, lesen Sie die Anleitung zur Installation von Config Sync unter Standardeinstellungen auf Flottenebene konfigurieren.
Erstellen Sie Cluster in Ihrer Flotte.
Erstellen Sie die Teambereiche und Namespaces für das Frontend und das Backend, damit Config Sync Ressourcen in Ihren Namespaces erkennen und abgleichen kann.

Nachdem Sie diese Schritte ausgeführt haben, erstellt und wendet Config Sync die NetworkPolicy basierend auf der NamespaceSelector 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 Flottenteamverwaltungsfunktionen sind nur für Nutzer verfügbar, die GKE Enterprise aktiviert haben. Weitere Informationen zu den Preisen für GKE Enterprise finden Sie auf der GKE-Preisseite.

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.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

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.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

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.

Erstellen Sie eine „Source of Truth“ (entweder ein Git-Repository oder ein OCI-Image), in der Sie Ihre Konfigurationsdateien speichern können, oder verschaffen Sie sich Zugriff darauf. In den Beispielen in diesem Leitfaden wird ein Git-Repository verwendet.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das 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: Administrator für Kubernetes Engine-Cluster (roles/container.clusterAdmin)
GKE Enterprise aktivieren: Service Usage Admin (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

Wenn Sie die Terraform-Befehle in diesem Leitfaden in Ihrer lokalen Umgebung ausführen möchten, führen Sie den folgenden Befehl aus, um neue Nutzeranmeldedaten zu erhalten:

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 Flottenkonfiguration. Fügen Sie diesem Verzeichnis eine Datei main.tf und eine Datei variables.tf 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, in der Sie die Flotte erstellen möchten.
Initialisieren Sie Terraform im erstellten Verzeichnis:
```
terraform init
```
Prüfen Sie, ob die vorgeschlagenen Änderungen mit Terraform dem erwarteten Plan entsprechen:
```
terraform plan
```
Flotte erstellen, APIs aktivieren und Dienstkonto erstellen:
```
terraform apply
```
Es kann manchmal einige Minuten dauern, bis alle Dienste aktiviert sind.

Aktuelle Informationsquelle einrichten

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

So richten Sie Ihre Single 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 des Teambereichs, z. B. backend.
Alle Namespaces, die Teil eines Flotten-Namespace sind, haben automatisch das Label fleet.gke.io/fleet-scope: SCOPE_NAME. Mit NamespaceSelector werden alle Flotten-Namespaces eines Teambereichs mit diesem Label ausgewählt. 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 des Objekts fest:

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

Ein 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.

So erstellen Sie eine Standardkonfiguration auf Flottenebene für Config Sync:

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

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

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

Fügen Sie 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) ist die Config Sync-Versionsnummer. 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 ist der Pfad im Git-Repository, der die oberste Ebene des Repositorys darstellt, das Sie synchronisieren möchten.
SECRET ist der Secret-Authentifizierungstyp.

Eine vollständige Liste der im Config Sync-git-Block 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 ist die Config Sync-Versionsnummer. 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-oci-Block unterstützten Einstellungen finden Sie in der Terraform-Referenzdokumentation für GKE-Hub-Features.

Mit der folgenden main.tf-Datei wird Config Sync beispielsweise so konfiguriert, dass die Synchronisierung aus einem Git-Repository erfolgt und alle Objekte im Verzeichnis config synchronisiert werden:

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 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 Flottenmitglieder:
```
terraform apply
```

Cluster in Ihrer Flotte erstellen

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

So erstellen und registrieren Sie neue Cluster in Ihrer Flotte:

Erstellen Sie ein Verzeichnis für die Terraform-Dateien der Clusterkonfiguration. Fügen Sie diesem Verzeichnis eine Datei main.tf und eine Datei variables.tf 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 Ihre 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 denselben Wert haben, z. B. us-east-cluster.
CLUSTER_CONFIGURATION_FILEPATH: der relative Pfad zur von Ihnen erstellten Datei cluster.tf.
CLUSTER_NAME: Der Name Ihres Clusters. MODULE_NAME und CLUSTER_NAME können denselben Wert haben, z. B. us-east-cluster.
CLUSTER_LOCATION: Der Standort Ihres Clusters, z. B. us-east1.

Sie können beliebig viele Cluster erstellen. Die folgende main.tf-Datei erstellt beispielsweise drei Cluster in verschiedenen Regionen:

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 erstellten Verzeichnis:
```
terraform init
```
Prüfen Sie, ob die vorgeschlagenen Änderungen mit Terraform dem erwarteten Plan entsprechen:
```
terraform plan
```
Cluster erstellen:
```
terraform apply
```

Teambereiche und Flotten-Namespaces konfigurieren

In diesem Abschnitt erstellen Sie Ihre Teambereiche und ordnen Ihre Cluster diesen Bereichen zu. Anschließend erstellen Sie die benötigten 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 Datei main.tf und eine Datei variables.tf 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 Ressource für den Teambereich 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 des 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 für jeden Cluster, den Sie auf einen Teambereich anwenden möchten, eine Bindung für die Flottenmitgliedschaft hinzu:

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 ist 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 erstellt haben, z. B. us-east-cluster.
CLUSTER_LOCATION: Der Clusterstandort, z. B. us-east1.

Sie müssen für jeden Cluster eine Flottenmitgliedschaftsbindung definieren. Wenn Sie keinen Teambereich für einen Cluster definieren, 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 jeweils 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 erstellten Verzeichnis:
```
terraform init
```
Prüfen Sie, ob die vorgeschlagenen Änderungen mit Terraform dem erwarteten Plan entsprechen:
```
terraform plan
```
Flottenbereiche und ‑Namespaces erstellen:
```
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 und die richtige NamespaceSelector-Annotation angeben, gleicht Config Sync diese Ressource automatisch in Ihren Team-Namespaces ab.

Wenn Sie Config Sync-Einstellungen auf Ihre vorhandenen Cluster anwenden möchten, folgen Sie der Anleitung zum Konfigurieren von Standardeinstellungen auf Flottenebene im Installationsleitfaden für Config Sync.

Nächste Schritte

Weitere Informationen zum Einrichten von Teams für Ihren Flotte

Teamressourcen in der gesamten Flotte verwalten Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Beispielworkflow

Preise

Hinweise

Erforderliche Rollen

Nutzeranmeldedaten abrufen

Flotte einrichten

Aktuelle Informationsquelle einrichten

Standardeinstellungen auf Flottenebene für Config Sync erstellen

git

OCI

Cluster in Ihrer Flotte erstellen

Teambereiche und Flotten-Namespaces konfigurieren

Nächste Schritte

Teamressourcen in der gesamten Flotte verwalten