Mengelola resource tim di seluruh fleet

Halaman ini menjelaskan cara menggunakan Config Sync dan Terraform untuk membuat resource cakupan tim secara dinamis pada fleet cluster. Config Sync memperluas kemampuan pengelolaan tim fleet untuk membuat serta mengelola konfigurasi cluster dan infrastruktur di seluruh fleet Anda.

Panduan ini mengasumsikan bahwa Anda sudah memahami konsep pengelolaan tim fleet seperti cakupan tim dan namespace fleet. Untuk informasi selengkapnya, lihat ringkasan pengelolaan tim armada.

Untuk tutorial menyeluruh tentang contoh konfigurasi, lihat tutorial tenancy fleet di repositori contoh.

Untuk mengetahui daftar kolom yang didukung untuk Config Sync di Terraform, baca dokumentasi referensi Terraform untuk fitur fleet GKE.

Contoh alur kerja

Anda adalah administrator platform yang ingin membuat resource secara dinamis di fleet cluster, dan tim yang berbeda memiliki kebutuhan yang berbeda. Misalnya, Anda mungkin ingin menerapkan NetworkPolicy ke namespace tim Backend, tetapi tidak ke namespace tim Frontend. Dalam skenario ini, prosedur untuk membuat resource cakupan tim di seluruh namespace adalah sebagai berikut:

Pilih atau buat fleet tempat Anda ingin mengelola resource untuk tim.
Siapkan sumber kebenaran Anda. Sumber tepercaya berisi objek NamespaceSelector yang Anda gunakan untuk memilih namespace level fleet dalam cakupan tim, dan resource apa pun (seperti NetworkPolicy) yang ingin Anda sinkronkan di seluruh namespace ini.
Membuat konfigurasi default tingkat fleet untuk Config Sync. Config Sync menggunakan setelan default ini saat melakukan sinkronisasi dari sumber tepercaya yang dibuat pada langkah sebelumnya. Setelan Config Sync ini berlaku untuk setiap cluster baru yang dibuat di fleet.

Penting: Anda harus membuat konfigurasi default tingkat fleet sebelum membuat cluster baru. Setelan ini hanya otomatis diterapkan ke cluster baru yang dibuat dalam fleet. Jika Anda ingin menerapkan setelan ini ke cluster yang ada, lihat bagian Mengonfigurasi default level fleet di panduan penginstalan Config Sync.
Buat cluster di fleet Anda.
Buat cakupan dan namespace tim Frontend dan Backend Anda agar Config Sync dapat mendeteksi dan merekonsiliasi resource di namespace Anda.

Setelah Anda menyelesaikan langkah-langkah ini, Config Sync akan membuat dan menerapkan NetworkPolicy berdasarkan NamespaceSelector ke namespace tim Backend. Jika Anda mengubah atau menambahkan resource apa pun, Config Sync akan terus mendeteksi dan menerapkan perubahan apa pun pada file konfigurasi, cakupan tim, namespace fleet, dan anggota fleet Anda.

Harga

Fitur Config Sync dan pengelolaan tim fleet hanya tersedia untuk pengguna yang telah mengaktifkan GKE Enterprise. Untuk mengetahui informasi selengkapnya tentang harga GKE Enterprise, lihat halaman Harga GKE.

Sebelum memulai

Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

Menginstal Google Cloud CLI.

Untuk initialize gcloud CLI, jalankan perintah berikut:

gcloud init

Buat atau pilih project Google Cloud.

Membuat project Google Cloud:
```
gcloud projects create PROJECT_ID
```
Ganti PROJECT_ID dengan nama untuk project Google Cloud yang Anda buat.
Pilih project Google Cloud yang Anda buat:
```
gcloud config set project PROJECT_ID
```
Ganti PROJECT_ID dengan nama project Google Cloud Anda.

Menginstal Google Cloud CLI.

Untuk initialize gcloud CLI, jalankan perintah berikut:

gcloud init

Buat atau pilih project Google Cloud.

Membuat project Google Cloud:
```
gcloud projects create PROJECT_ID
```
Ganti PROJECT_ID dengan nama untuk project Google Cloud yang Anda buat.
Pilih project Google Cloud yang Anda buat:
```
gcloud config set project PROJECT_ID
```
Ganti PROJECT_ID dengan nama project Google Cloud Anda.

Membuat, atau memiliki akses ke, sumber tepercaya (baik repositori Git maupun image OCI) tempat Anda dapat menyimpan file konfigurasi. Contoh dalam panduan ini menggunakan repositori Git.

Peran yang diperlukan

Untuk mendapatkan izin yang diperlukan guna membuat resource tim untuk fleet Anda, minta administrator untuk memberi Anda peran IAM berikut pada project Anda:

Mengelola resource fleet: Fleet Admin (sebelumnya GKE Hub Admin) (roles/gkehub.admin)
Membuat cluster GKE: Admin Cluster Kubernetes Engine (roles/container.clusterAdmin)
Mengaktifkan GKE Enterprise: Service Usage Admin (roles/serviceusage.serviceUsageAdmin)

Untuk mengetahui informasi selengkapnya tentang pemberian peran, lihat Mengelola akses.

Anda mungkin juga bisa mendapatkan izin yang diperlukan melalui peran khusus atau peran bawaan lainnya.

Mendapatkan kredensial pengguna

Untuk menjalankan perintah Terraform dalam panduan ini di lingkungan lokal Anda, jalankan perintah berikut untuk mendapatkan kredensial pengguna baru:

gcloud auth application-default login

Siapkan perangkat Anda

Di bagian ini, Anda akan membuat perangkat dan mengaktifkan layanan yang diperlukan.

Untuk menyiapkan perangkat, selesaikan langkah-langkah berikut:

Buat direktori untuk file Terraform konfigurasi fleet. Ke direktori tersebut, tambahkan file main.tf dan file variables.tf.

Dalam file variables.tf, tambahkan variabel berikut:

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

Di file main.tf, tambahkan referensi berikut:

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

Ekspor variabel PROJECT_ID:
```
export TF_VAR_project=PROJECT_ID
```
Ganti PROJECT_ID dengan project ID tempat Anda ingin membuat fleet.
Lakukan inisialisasi Terraform di direktori yang Anda buat:
```
terraform init
```
Pastikan perubahan yang Anda usulkan dengan Terraform sesuai dengan rencana yang diharapkan:
```
terraform plan
```
Buat fleet, aktifkan API, dan buat akun layanan:
```
terraform apply
```
Terkadang diperlukan waktu beberapa menit untuk mengaktifkan semua layanan.

Menyiapkan sumber tepercaya

Di bagian ini, Anda akan menambahkan file konfigurasi ke sumber tepercaya. Anda memerlukan objek NamespaceSelector untuk setiap cakupan tim yang ingin digunakan. Misalnya, jika memiliki tim Frontend dan Backend, Anda harus membuat objek NamespaceSelector untuk setiap tim. Objek NamespaceSelector memilih semua atau beberapa namespace dalam cakupan tim. Anda dapat menambahkan resource tim tambahan ke sumber tepercaya, seperti NetworkPolicy. Saat Anda membuat resource ini, Anda mereferensikan NamespaceSelector sehingga Config Sync dapat men-deploy dan menyinkronkan resource tersebut secara dinamis di seluruh namespace.

Untuk menyiapkan sumber tepercaya, selesaikan langkah-langkah berikut:

Dalam sumber tepercaya, buat direktori untuk file konfigurasi yang ingin Anda sinkronkan ke Config Sync.
Untuk setiap tim, buat objek NamespaceSelector di direktori konfigurasi Anda:

Penting: NamespaceSelector harus menyetel mode ke dynamic. Mode dinamis memungkinkan pemilihan namespace yang dideklarasikan secara statis secara statis dalam sumber kebenaran dan namespace apa pun yang secara dinamis ada di 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
```
Ganti kode berikut:
- NAMESPACE_SELECTOR_NAME: nama untuk objek NamespaceSelector, misalnya backend-scope.
- SCOPE_NAME: nama cakupan tim Anda, misalnya backend.
Setiap namespace yang merupakan bagian dari namespace fleet akan otomatis memiliki label fleet.gke.io/fleet-scope: SCOPE_NAME. NamespaceSelector memilih semua namespace fleet cakupan tim menggunakan label tersebut. Untuk contoh selengkapnya tentang cara menyertakan atau mengecualikan namespace, lihat contoh NamespaceSelector.

Buat objek apa pun yang ingin Anda sinkronkan di seluruh namespace.

Untuk menyinkronkan objek hanya ke tim tertentu, setel anotasi berikut dalam metadata objek tersebut:

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

Misalnya, NetworkPolicy untuk tim Backend mungkin terlihat seperti berikut:

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

Membuat setelan default tingkat fleet untuk Config Sync

Di bagian ini, Anda akan membuat setelan default level fleet untuk Config Sync, yang menerapkan konfigurasi Config Sync yang sama pada semua cluster yang dibuat di fleet Anda.

Untuk membuat konfigurasi default tingkat fleet untuk Config Sync, selesaikan langkah-langkah berikut:

Buat direktori untuk file Terraform konfigurasi default fleet. Ke direktori tersebut, tambahkan file main.tf dan file variables.tf.

Dalam file variables.tf, tambahkan variabel berikut:

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

Dalam file main.tf, tambahkan resource berikut untuk mengonfigurasi setelan 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"
        }
      }
    }
  }
}

Ganti kode berikut:

VERSION: (opsional) nomor versi Config Sync. Harus ditetapkan ke versi 1.17.0 atau yang lebih baru. Jika dibiarkan kosong, versi default-nya adalah versi terbaru.
REPO: URL ke repositori yang berisi file konfigurasi Anda.
BRANCH: cabang repositori, misalnya main.
DIRECTORY: jalur dalam repositori Git yang mewakili repositori tingkat teratas yang ingin Anda sinkronkan.
SECRET: jenis autentikasi rahasia.

Untuk mengetahui daftar lengkap setelan yang didukung dalam blok git Config Sync, lihat dokumentasi referensi Terraform untuk fitur hub GKE.

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

Ganti kode berikut:

VERSION: nomor versi Config Sync. Harus ditetapkan ke versi 1.17.0 atau yang lebih baru. Jika dibiarkan kosong, versi default-nya adalah versi terbaru.
REPO: URL ke repositori image OCI yang berisi file konfigurasi.
DIRECTORY: jalur absolut direktori yang berisi resource yang ingin Anda sinkronkan. Biarkan kosong untuk menggunakan direktori root.
SECRET: jenis autentikasi rahasia.

Untuk mengetahui daftar lengkap setelan yang didukung dalam blok oci Config Sync, lihat dokumentasi referensi Terraform untuk fitur hub GKE.

Sebagai contoh, file main.tf berikut mengonfigurasi Config Sync untuk menyinkronkan dari repositori Git dan menyinkronkan semua objek yang ada di direktori 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"
        }
      }
    }
  }
}

Lakukan inisialisasi Terraform di direktori yang Anda buat:
```
terraform init
```
Pastikan perubahan yang Anda usulkan dengan Terraform sesuai dengan rencana yang diharapkan:
```
terraform plan
```
Membuat konfigurasi anggota fleet default:
```
terraform apply
```

Membuat cluster di fleet Anda

Di bagian ini, Anda akan membuat konfigurasi cluster bersama, lalu membuat cluster di fleet Anda.

Untuk membuat dan mendaftarkan cluster baru ke fleet Anda, selesaikan langkah-langkah berikut:

Buat direktori untuk file Terraform konfigurasi cluster. Ke direktori tersebut, tambahkan file main.tf dan file variables.tf.

Dalam file variables.tf, tambahkan variabel berikut:

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

Buat file cluster.tf yang berisi nilai default yang digunakan di semua cluster Anda, seperti ID project dan fleet Anda:

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
}

Di file main.tf, tambahkan referensi berikut:

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

Ganti kode berikut:

MODULE_NAME: nama yang ingin Anda berikan ke modul cluster. MODULE_NAME dan CLUSTER_NAME dapat berupa nilai yang sama, misalnya us-east-cluster.
CLUSTER_CONFIGURATION_FILEPATH: jalur relatif ke file cluster.tf yang Anda buat.
CLUSTER_NAME: nama cluster Anda. MODULE_NAME dan CLUSTER_NAME dapat berupa nilai yang sama, misalnya us-east-cluster.
CLUSTER_LOCATION: lokasi cluster Anda, misalnya us-east1.

Anda dapat membuat cluster sebanyak yang Anda inginkan. Sebagai contoh, file main.tf berikut membuat 3 cluster di region berbeda:

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

Lakukan inisialisasi Terraform di direktori yang Anda buat:
```
terraform init
```
Pastikan perubahan yang Anda usulkan dengan Terraform sesuai dengan rencana yang diharapkan:
```
terraform plan
```
Buat cluster:
```
terraform apply
```

Mengonfigurasi cakupan tim dan namespace fleet

Di bagian ini, Anda akan membuat cakupan tim dan mengaitkan cluster Anda dengan cakupan tersebut. Selanjutnya, Anda akan membuat namespace fleet yang diperlukan, misalnya satu untuk setiap tim, dalam setiap cakupan, dan Config Sync akan membuat resource di seluruh namespace Anda.

Untuk mengonfigurasi cakupan dan namespace tim, selesaikan langkah-langkah berikut:

Buat direktori untuk file Terraform cakupan tim dan konfigurasi namespace. Ke direktori tersebut, tambahkan file main.tf dan file variables.tf.

Dalam file variables.tf, tambahkan variabel berikut:

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

Di file main.tf, tambahkan referensi berikut:

Tambahkan informasi penyedia:

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

provider "google" {
  project = var.project
}

Tambahkan resource cakupan tim:
```
resource "google_gke_hub_scope" "scope" {
  provider = google
  for_each = toset([
    "SCOPE_NAME",
    "SCOPE_NAME_2",
  ])
  scope_id = each.value
}
```
Ganti kode berikut:
- SCOPE_NAME: nama cakupan tim Anda, misalnya backend.
- SCOPE_NAME_2: cakupan tim tambahan jika Anda membuatnya.
Anda dapat menambahkan cakupan tim sebanyak yang diperlukan. Saat namespace fleet dibuat di cluster, namespace akan otomatis diberi label dengan fleet.gke.io/fleet-scope: SCOPE_NAME, sehingga Config Sync dapat memilih namespace berdasarkan label NamespaceSelector yang ada saat menyinkronkan resource Kubernetes.

Sebagai contoh, resource Terraform lingkup tim yang mencakup cakupan untuk tim Frontend dan Backend mungkin terlihat seperti berikut:
```
resource "google_gke_hub_scope" "scope" {
  provider = google
  for_each = toset([
    "backend",
    "frontend",
  ])
  scope_id = each.value
}
```

Tambahkan binding keanggotaan fleet untuk setiap cluster yang ingin Anda terapkan ke cakupan tim:

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

Ganti kode berikut:

MEMBERSHIP_BINDING_NAME: nama binding keanggotaan, misalnya us-east-backend.
MEMBERSIP_BINDING_ID: ID binding keanggotaan. Kolom ini dapat sama dengan MEMBERSHIP_BINDING_NAME.
SCOPE_NAME: pemilih label yang Anda beri cakupan kepada tim saat membuat NamespaceSelector, misalnya backend.
CLUSTER_NAME: nama cluster yang Anda buat saat membuat cluster, misalnya us-east-cluster.
CLUSTER_LOCATION: lokasi cluster, misalnya us-east1.

Anda perlu menentukan binding keanggotaan fleet untuk setiap cluster. Jika Anda tidak menentukan cakupan tim untuk sebuah cluster, cluster tersebut tidak akan dibuat untuk namespace tersebut. Misalnya, jika Anda memiliki tiga cluster di region us-east1, us-west1, dan us-central1, tetapi cluster us-central1 hanya untuk tim Frontend, resource binding keanggotaan Anda akan terlihat seperti berikut:

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

Tambahkan namespace apa pun yang ingin Anda tetapkan untuk tim Anda:

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

Ganti kode berikut:

FLEET_NAMESPACE: nama yang ingin Anda berikan namespace, misalnya backend-a.
SCOPE_NAME: pemilih label yang Anda beri cakupan kepada tim saat membuat NamespaceSelector, misalnya backend.
FLEET_NAMESPACE_ID: ID namespace. Ini dapat berupa nilai yang sama dengan FLEET_NAMESPACE.

Misalnya, jika Anda ingin tim Frontend dan Backend masing-masing memiliki dua namespace, resource namespace fleet Anda mungkin akan terlihat seperti berikut:

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

Lakukan inisialisasi Terraform di direktori yang Anda buat:
```
terraform init
```
Pastikan perubahan yang Anda usulkan dengan Terraform sesuai dengan rencana yang diharapkan:
```
terraform plan
```
Buat cakupan dan namespace fleet:
```
terraform apply
```

Setelah Anda membuat cakupan dan namespace fleet, Config Sync akan mendeteksi namespace baru tersebut beserta cakupannya, memilih resource pada namespace fleet, lalu merekonsiliasinya dengan file konfigurasi Anda.

Anda dapat memeriksa apakah resource diterapkan ke cluster yang benar menggunakan nomos status atau dengan membuka tab Packages Config Sync di Konsol Google Cloud dan mengubah tombol pilihan View by menjadi Cluster.

Buka Paket

Config Sync menyinkronkan resource Anda di seluruh namespace berdasarkan cakupan tim Anda sesuai dengan konfigurasi yang disimpan dalam sumber tepercaya Anda. Setiap kali Anda menambahkan resource baru, selama Anda menyertakan anotasi NamespaceSelector yang benar, Config Sync akan otomatis merekonsiliasi resource tersebut di seluruh namespace tim.

Jika Anda ingin menerapkan setelan Config Sync pada cluster yang ada, lihat petunjuk untuk Mengonfigurasi default tingkat fleet dalam panduan penginstalan Config Sync.

Langkah selanjutnya

Pelajari lebih lanjut cara menyiapkan tim untuk fleet Anda.