Halaman ini diterjemahkan oleh Cloud Translation API.

Mengelola resource tim di seluruh fleet

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

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

Untuk tutorial menyeluruh dengan contoh konfigurasi, lihat tutorial sewa armada di repositori sampel.

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

Contoh alur kerja

Anda adalah administrator platform yang ingin membuat resource secara dinamis di seluruh fleet cluster di mana 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 tepercaya. Sumber tepercaya berisi objek NamespaceSelector yang Anda gunakan untuk memilih namespace tingkat fleet dalam cakupan tim, dan resource apa pun (seperti NetworkPolicy) yang ingin Anda sinkronkan di seluruh namespace ini.
Buat konfigurasi default tingkat fleet untuk Config Sync. Config Sync menggunakan setelan default ini saat menyinkronkan dari sumber tepercaya yang dibuat pada langkah sebelumnya. Setelan Config Sync ini berlaku untuk setiap cluster baru yang dibuat dalam fleet.

Penting: Anda harus membuat konfigurasi default tingkat fleet sebelum membuat cluster baru. Setelan ini hanya secara otomatis diterapkan pada cluster baru yang dibuat dalam fleet. Jika Anda ingin menerapkan setelan ke cluster yang ada, lihat Mengonfigurasi default tingkat fleet dalam panduan penginstalan Config Sync.
Buat cluster di fleet Anda.
Membuat cakupan dan namespace tim Frontend dan Backend 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, Config Sync terus mendeteksi dan menerapkan setiap perubahan pada konfigurasi Anda file, cakupan tim, namespace fleet, dan anggota fleet.

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 atau image OCI) tempat Anda dapat menyimpan file konfigurasi. Contoh dalam panduan ini menggunakan sebuah repositori Git.

Peran yang diperlukan

Untuk memperoleh izin yang diperlukan guna membuat sumber daya tim untuk perangkat 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 cara memberikan peran, lihat Mengelola akses ke project, folder, dan organisasi.

Anda mungkin juga bisa mendapatkan izin yang diperlukan melalui perintah peran atau setelan standar lainnya peran tertentu.

Mendapatkan kredensial pengguna

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

gcloud auth application-default login

Menyiapkan fleet

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

Untuk menyiapkan perangkat Anda, selesaikan langkah-langkah berikut:

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

Di file variables.tf, tambahkan variabel berikut:

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

Di file main.tf, tambahkan resource 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 Anda gunakan. 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 sumber daya tim tambahan ke sumber tepercaya, seperti NetworkPolicy. Saat 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:

Di sumber tepercaya, buat direktori untuk file konfigurasi yang yang ingin Anda sinkronkan dengan 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 dalam dan namespace apa pun yang ada secara dinamis 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 dari cakupan tim menggunakan label tersebut. Untuk selengkapnya contoh 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 di {i>metadata<i} objek itu:

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

Misalnya, NetworkPolicy untuk tim Backend mungkin mirip dengan berikut ini:

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 default tingkat fleet untuk Config Sync

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

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

Di 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 disetel ke versi 1.17.0 atau yang lebih baru. Jika dibiarkan kosong, versi defaultnya adalah versi terbaru.
REPO: URL ke repositori yang berisi file konfigurasi Anda.
BRANCH: cabang repositori, misalnya main.
DIRECTORY: jalur dalam repositori Git yang mewakili tingkat teratas repositori yang ingin Anda sinkronkan.
SECRET: jenis autentikasi secret.

Untuk mengetahui daftar lengkap setelan yang didukung dalam blok git Config Sync, baca 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 disetel ke versi 1.17.0 atau yang lebih baru. Jika dibiarkan kosong, versi defaultnya adalah versi terbaru.
REPO: URL ke repositori image OCI yang berisi file konfigurasi.
DIRECTORY: jalur absolut direktori berisi resource yang ingin Anda sinkronkan. Biarkan kosong untuk menggunakan direktori root.
SECRET: jenis autentikasi secret.

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

Sebagai contoh, file main.tf berikut mengonfigurasi Config Sync yang akan disinkronkan 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
```
Buat 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. Untuk direktori tersebut, tambahkan file main.tf dan file variables.tf.

Di 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, seperti project dan ID armada 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
}

Dalam file main.tf, tambahkan resource 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 untuk modul cluster. MODULE_NAME dan CLUSTER_NAME dapat memiliki 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 memiliki 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 yang 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 ajukan 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. Kemudian, Anda membuat namespace fleet yang diperlukan, misalnya satu untuk setiap tim, di setiap cakupan, dan Config Sync akan membuat resource di seluruh namespace Anda.

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

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

Di file variables.tf, tambahkan variabel berikut:

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

Dalam file main.tf, tambahkan resource 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 dibutuhkan. Ketika namespace fleet yang dibuat di cluster, namespace akan otomatis diberi label dengan fleet.gke.io/fleet-scope: SCOPE_NAME, mengizinkan Config Sync untuk memilih namespace berdasarkan NamespaceSelector label yang ada saat menyinkronkan resource Kubernetes.

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

Tambahkan binding keanggotaan fleet untuk setiap 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. URL ini dapat sama dengan MEMBERSHIP_BINDING_NAME.
SCOPE_NAME: pemilih label yang Anda tentukan untuk cakupan 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 ruang lingkup tim untuk sebuah cluster, berarti cluster tersebut tidak 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 menyerupai hal 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 yang ingin Anda tentukan untuk tim:

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 ke namespace, misalnya backend-a.
SCOPE_NAME: pemilih label yang Anda berikan ke cakupan tim saat membuat NamespaceSelector, misalnya backend.
FLEET_NAMESPACE_ID: ID namespace. Nilai ini dapat sama dengan FLEET_NAMESPACE.

Misalnya, jika Anda ingin tim {i>Frontend<i} dan {i>Backend<i} memiliki dua namespace masing-masing, resource namespace fleet Anda mungkin 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 ajukan 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 mendeteksi namespace dan cakupannya, memilih resource di namespace fleet, dan merekonsiliasinya pada file konfigurasi Anda.

Anda dapat memeriksa apakah resource telah diterapkan ke cluster yang benar menggunakan nomos status atau dengan membuka Config Sync Packages 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 di sumber tepercaya Anda. Setiap kali Anda menambahkan sumber daya baru, selama Anda menyertakan anotasi NamespaceSelector yang benar, Config Sync secara otomatis merekonsiliasi resource tersebut di seluruh namespace tim.

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

Langkah selanjutnya

Pelajari lebih lanjut cara menyiapkan tim untuk armada Anda.