Gerenciar recursos da equipe em toda a frota

Nesta página, explicamos como usar o Config Sync e o Terraform para criar dinamicamente recursos no escopo da equipe em uma frota de clusters. O Config Sync amplia os recursos de gerenciamento de equipes de frota para criar e gerenciar configurações de infraestrutura e clusters em todas as frotas.

Neste guia, pressupomos que você já conhece os conceitos de gerenciamento de equipes de frotas, como escopos de equipe e namespaces de frota. Para mais informações, consulte a visão geral do gerenciamento de equipes da frota.

Para conferir um tutorial completo com exemplos de configurações, consulte o tutorial de locação de frota no repositório de exemplo.

Para conferir uma lista de campos compatíveis com o Config Sync no Terraform, consulte a documentação de referência do Terraform para recursos de frota do GKE.

Exemplo de fluxo de trabalho

Você é um administrador de plataforma que quer criar recursos dinamicamente em uma frota de clusters em que diferentes equipes têm necessidades diferentes. Por exemplo, talvez você queira aplicar um NetworkPolicy aos namespaces da equipe de back-end, mas não aos namespaces da equipe de front-end. Nesse cenário, o procedimento para criar recursos no escopo da equipe em um namespace é o seguinte:

1. Escolha ou crie a frota em que você quer gerenciar os recursos das equipes.

2. Configure sua fonte da verdade. A fonte da verdade contém os objetos NamespaceSelector que você usa para selecionar namespaces no nível da frota nos escopos da equipe e todos os recursos (como um NetworkPolicy) que você quer sincronizar nesses namespaces.

   Termo-chave :um NamespaceSelector é um tipo especial de configuração usado pelo Config Sync para limitar quais namespaces outra configuração afeta. Para mais informações, consulte Limitar os namespaces afetados por um config.

3. Crie a configuração padrão no nível da frota para o Config Sync. O Config Sync usa essas configurações padrão ao sincronizar com base na fonte de verdade criada na etapa anterior. Essas configurações do Config Sync são aplicadas a todos os novos clusters criados na frota.

   Importante: é necessário criar a configuração padrão no nível da frota antes de criar novos clusters. Essas configurações são aplicadas automaticamente apenas aos novos clusters criados na frota. Se você quiser aplicar essas configurações a clusters existentes, consulte Configurar padrões no nível da frota no guia de instalação do Config Sync.

4. Crie clusters na frota.

5. Crie os escopos e namespaces da equipe de front-end e back-end para que o Config Sync possa detectar e reconciliar recursos nos namespaces.

Depois de concluir essas etapas, o Config Sync cria e aplica o NetworkPolicy com base no NamespaceSelector aos namespaces da equipe de back-end. Se você mudar ou adicionar recursos, o Config Sync vai detectar e aplicar continuamente as mudanças nos arquivos de configuração, nos escopos da equipe, nos namespaces da frota e nos membros da frota.

Preços

O Config Sync e os recursos de gerenciamento de equipe da frota só estão disponíveis para usuários que ativaram o GKE Enterprise. Para mais informações sobre os preços do GKE Enterprise, consulte a página de preços do GKE.

Antes de começar

1. 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.
2. Install the Google Cloud CLI.

3. To initialize the gcloud CLI, run the following command:

   gcloud init

4. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the 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.

5. Install the Google Cloud CLI.

6. To initialize the gcloud CLI, run the following command:

   gcloud init

7. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the 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.

8. Crie ou tenha acesso a uma fonte de informações (um repositório Git ou uma imagem OCI) em que você possa armazenar seus arquivos de configuração. Os exemplos neste guia usam um repositório Git.

Funções exigidas

Para receber as permissões necessárias para criar recursos de equipe na sua frota, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto:

• Gerenciamento de recursos da frota: Administrador da frota (antigo Administrador do GKE Hub) (roles/gkehub.admin)
• Criação de clusters do GKE: Administrador de cluster do Kubernetes Engine (roles/container.clusterAdmin)
• Ativar o GKE Enterprise: Administrador do Service Usage (roles/serviceusage.serviceUsageAdmin)

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias por meio de papéis personalizados ou de outros papéis predefinidos.

Adquirir credenciais do usuário

Para executar os comandos do Terraform neste guia no seu ambiente local, execute o comando a seguir para adquirir novas credenciais de usuário:

gcloud auth application-default login

Configurar seus dispositivos

Nesta seção, você cria a frota e ativa os serviços necessários.

Para configurar a frota, siga estas etapas:

1. Crie um diretório para os arquivos do Terraform de configuração da frota. Adicione um arquivo main.tf e um variables.tf a esse diretório.

2. No arquivo variables.tf, adicione as seguintes variáveis:

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

3. No arquivo main.tf, adicione os seguintes recursos:

   Observação: se você estiver usando uma frota, omita a seção que declara uma frota no projeto.
   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]
   }

4. Exporte a variável PROJECT_ID:

   export TF_VAR_project=PROJECT_ID
   

   Substitua PROJECT_ID pelo ID do projeto em que você quer criar a frota.

5. Inicialize o Terraform no diretório criado:

   terraform init
   

6. Verifique se as alterações propostas pelo Terraform correspondem ao plano esperado:

   terraform plan
   

7. Crie a frota, ative as APIs e crie a conta de serviço:

   terraform apply
   

   Às vezes, pode levar alguns minutos para ativar todos os serviços.

Configurar a fonte da verdade

Nesta seção, você vai adicionar arquivos de configuração a uma fonte de verdade. Você precisa de um objeto NamespaceSelector para cada escopo de equipe que você quer usar. Por exemplo, se você tiver equipes de front-end e back-end, crie um objeto NamespaceSelector para cada equipe. O objeto NamespaceSelector seleciona todos ou alguns dos espaços de nomes no escopo de uma equipe. É possível adicionar outros recursos da equipe à sua fonte confiável, como um NetworkPolicy. Ao criar esses recursos, você faz referência ao NamespaceSelector para que o Config Sync possa implantar e sincronizar esses recursos dinamicamente em todos os namespaces.

Para configurar sua fonte de verdade, siga estas etapas:

1. Na sua fonte de verdade, crie um diretório para os arquivos de configuração que você quer sincronizar com o Config Sync.

2. Para cada equipe, crie um objeto NamespaceSelector no diretório de configuração:

   Importante: o modo do NamespaceSelector precisa estar definido como dynamic. O modo dinâmico permite a seleção de namespaces declarados de forma estática na fonte da verdade e de qualquer namespace dinamicamente presente no 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
   

   Substitua:

   • NAMESPACE_SELECTOR_NAME: o nome do objeto NamespaceSelector, por exemplo, backend-scope.
   • SCOPE_NAME: o nome do escopo da equipe, por exemplo, backend.

   Todos os namespaces que fazem parte de um namespace de frota têm o rótulo fleet.gke.io/fleet-scope: SCOPE_NAME automaticamente. O NamespaceSelector seleciona todos os namespaces da frota de um escopo da equipe usando esse identificador. Para mais exemplos sobre como incluir ou excluir namespaces, consulte Exemplos de NamespaceSelector.

3. Crie os objetos que você quer sincronizar entre os namespaces.

   Para sincronizar um objeto apenas com uma equipe específica, defina a seguinte anotação nos metadados desse objeto:

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

   Por exemplo, um NetworkPolicy para a equipe de back-end pode ser parecido com este:

   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

Criar padrões no nível da frota para o Config Sync

Nesta seção, você cria padrões no nível da frota para o Config Sync, que aplica a mesma configuração do Config Sync a todos os clusters criados na frota.

Observação: se você já instalou o Config Sync e configurou os padrões da frota, incluindo a configuração git ou oci, usando a CLI Terraform ou gcloud, pule esta seção. Se você usou o console Google Cloud para definir as configurações padrão da frota, talvez seja necessário importar as configurações de recursos atuais usando terraform import antes de executar terraform plan e terraform apply.

Para criar uma configuração padrão no nível da frota para o Config Sync, siga estas etapas:

1. Crie um diretório para os arquivos de configuração de frota padrão do Terraform. Adicione um arquivo main.tf e um variables.tf a esse diretório.

2. No arquivo variables.tf, adicione as seguintes variáveis:

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

3. No arquivo main.tf, adicione o seguinte recurso para configurar as configurações do 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"
           }
         }
       }
     }
   }
   

   Substitua:

   • VERSION: (opcional) o número da versão do Config Sync. Se ficar em branco, o padrão será a versão mais recente.
   • REPO: o URL do repositório que contém os arquivos de configuração.
   • BRANCH: a ramificação do repositório, por exemplo, main.
   • DIRECTORY: o caminho no repositório Git que representa o nível superior do repositório para sincronizar.
   • SECRET: o tipo de autenticação secreta.

   Para ver uma lista completa de configurações compatíveis no bloco git do Config Sync, consulte a documentação de referência do Terraform para recursos do hub do 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"
        }
       }
       }
     }
   }
   

   Substitua:

   • VERSION: o número da versão do Config Sync. Se ficar em branco, o padrão será a versão mais recente.
   • REPO: o URL do repositório de imagens OCI que contém arquivos de configuração.
   • DIRECTORY: o caminho absoluto do diretório que contém os recursos para sincronizar. Deixe em branco para usar o diretório raiz.
   • SECRET: o tipo de autenticação secreta.

   Para ver uma lista completa de configurações compatíveis no bloco oci do Config Sync, consulte a documentação de referência do Terraform para recursos do hub do GKE.

   Por exemplo, o arquivo main.tf a seguir configura o Config Sync para sincronizar um repositório Git e todos os objetos presentes no diretório 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"
           }
         }
       }
     }
   }

4. Inicialize o Terraform no diretório criado:

   terraform init
   

5. Verifique se as alterações propostas pelo Terraform correspondem ao plano esperado:

   terraform plan
   

6. Crie as configurações padrão dos membros da frota:

   terraform apply
   

Criar clusters na frota

Nesta seção, você vai criar uma configuração de cluster compartilhado e depois clusters na sua frota.

Para criar e registrar novos clusters na frota, siga estas etapas:

1. Crie um diretório para os arquivos do Terraform de configuração do cluster. Adicione um arquivo main.tf e um variables.tf a esse diretório.

2. No arquivo variables.tf, adicione as seguintes variáveis:

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

3. Crie um arquivo cluster.tf que contenha valores padrão usados em todos os clusters, como os IDs do projeto e da frota:

   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
   }
   

4. No arquivo main.tf, adicione os seguintes recursos:

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

   Substitua:

   • MODULE_NAME: o nome que você quer dar ao módulo do cluster. MODULE_NAME e CLUSTER_NAME podem ter o mesmo valor, por exemplo, us-east-cluster.
   • CLUSTER_CONFIGURATION_FILEPATH: o caminho relativo para o arquivo cluster.tf que você criou.
   • CLUSTER_NAME: o nome do cluster. MODULE_NAME e CLUSTER_NAME podem ter o mesmo valor, por exemplo, us-east-cluster.
   • CLUSTER_LOCATION: o local do cluster, por exemplo, us-east1.

   Você pode criar quantos clusters quiser. Por exemplo, o arquivo main.tf a seguir cria três clusters em regiões diferentes:

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

5. Inicialize o Terraform no diretório criado:

   terraform init
   

6. Verifique se as alterações propostas pelo Terraform correspondem ao plano esperado:

   terraform plan
   

7. Crie os clusters:

   terraform apply
   

Configurar escopos de equipe e namespaces da frota

Nesta seção, você cria os escopos de equipe e associa os clusters a eles. Em seguida, crie os namespaces de frota necessários, por exemplo, um para cada equipe, em cada escopo, e o Config Sync cria os recursos em todos os namespaces.

Para configurar os escopos e namespaces da equipe, siga estas etapas:

1. Crie um diretório para os arquivos de configuração do Terraform do escopo da equipe e do namespace. Adicione um arquivo main.tf e um variables.tf a esse diretório.

2. No arquivo variables.tf, adicione as seguintes variáveis:

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

3. No arquivo main.tf, adicione os seguintes recursos:

   1. Adicione as informações do provedor:

      terraform {
        required_providers {
          google = {
            source = "hashicorp/google"
            version = ">=5.16.0"
           }
         }
       }
      
      provider "google" {
        project = var.project
      }
      

   2. Adicione o recurso de escopo da equipe:

      resource "google_gke_hub_scope" "scope" {
        provider = google
        for_each = toset([
          "SCOPE_NAME",
          "SCOPE_NAME_2",
        ])
        scope_id = each.value
      }
      

      Substitua:

      • SCOPE_NAME: o nome do escopo da equipe, por exemplo, backend.
      • SCOPE_NAME_2: um escopo de equipe adicional, se você tiver criado um.

      Você pode adicionar quantos escopos de equipe precisar. Quando um namespace de frota é criado no cluster, ele é rotulado automaticamente com fleet.gke.io/fleet-scope: SCOPE_NAME, permitindo que o Config Sync selecione namespaces com base nos rótulos NamespaceSelector presentes ao sincronizar recursos do Kubernetes.

      Por exemplo, um recurso do Terraform de escopo de equipe que inclui um escopo para as equipes de frontend e de back-end pode ser parecido com o seguinte:

      resource "google_gke_hub_scope" "scope" {
        provider = google
        for_each = toset([
          "backend",
          "frontend",
        ])
        scope_id = each.value
      }

   3. Adicione uma vinculação de associação de frota para cada cluster que você quer aplicar a um escopo da equipe:

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

      Substitua:

      • MEMBERSHIP_BINDING_NAME: o nome da vinculação de associação, por exemplo, us-east-backend.
      • MEMBERSIP_BINDING_ID: o ID de vinculação da assinatura. Pode ser o mesmo que MEMBERSHIP_BINDING_NAME.
      • SCOPE_NAME: o seletor de rótulos que você atribuiu ao escopo da equipe quando criou uma NamespaceSelector, por exemplo, backend.
      • CLUSTER_NAME: o nome do cluster que você criou ao criar clusters, por exemplo, us-east-cluster.
      • CLUSTER_LOCATION: o local do cluster, por exemplo, us-east1.

      É necessário definir uma vinculação de assinatura do Fleet para cada cluster. Se você não definir um escopo de equipe para um cluster, ele não será criado para esse namespace. Por exemplo, se você tiver três clusters nas regiões us-east1, us-west1 e us-central1, mas o cluster us-central1 for apenas para a equipe de front-end, seu recurso de vinculação de associação vai se parecer com o seguinte:

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

   4. Adicione os namespaces que você quer definir para suas equipes:

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

      Substitua:

      • FLEET_NAMESPACE: o nome que você quer dar ao namespace, por exemplo, backend-a.
      • SCOPE_NAME: o seletor de rótulos que você atribuiu ao escopo da equipe quando criou uma NamespaceSelector, por exemplo, backend.
      • FLEET_NAMESPACE_ID: o ID do namespace. Pode ser o mesmo que FLEET_NAMESPACE.

      Por exemplo, se você quiser que as equipes de front-end e back-end tenham dois namespaces cada, o recurso de namespace da frota pode ser semelhante ao seguinte:

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

4. Inicialize o Terraform no diretório criado:

   terraform init
   

5. Verifique se as alterações propostas pelo Terraform correspondem ao plano esperado:

   terraform plan
   

6. Crie os escopos e namespaces da frota:

   terraform apply
   

Depois de criar escopos e namespaces da frota, o Config Sync detecta esses novos namespace e os escopos, seleciona recursos nos namespaces da frota e os concilia com seus arquivos de configuração.

Para verificar se os recursos foram aplicados ao cluster correto, use nomos status ou acesse a guia Packages do Config Sync no console do Google Cloud e mude o botão de opção View by para Cluster.

Acessar "Pacotes"

O Config Sync sincroniza seus recursos em namespaces com base nos escopos da equipe de acordo com a configuração armazenada na fonte da verdade. Sempre que você adicionar um novo recurso, desde que inclua a anotação NamespaceSelector correta, o Config Sync reconciliará automaticamente esse recurso nos namespaces da equipe.

Se você quiser aplicar as configurações do Config Sync aos clusters atuais, consulte as instruções para Configurar padrões de frota no guia de instalação do Config Sync.

A seguir

• Saiba como configurar equipes para sua frota.