Esta página foi traduzida pela API Cloud Translation.

Gerenciar recursos da equipe em toda a frota

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

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

Para um tutorial completo com exemplos de configurações, consulte o tutorial de locatário da frota no repositório de amostras.

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 da 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 equipes diferentes têm necessidades diferentes. Por exemplo, talvez você queira aplicar um NetworkPolicy aos namespaces da equipe de back-end, mas não aos da equipe de front-end. Nesse cenário, o procedimento para criar recursos no escopo da equipe em um namespace é o seguinte:

Escolha ou crie a frota em que você quer gerenciar recursos para equipes.
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 quais namespaces uma configuração afeta.
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 a fonte de verdade criada na etapa anterior. Essas configurações do Config Sync são válidas para todos os novos clusters criados na frota.

Importante: crie a configuração padrão no nível da frota antes de criar novos clusters. Essas configurações são aplicadas automaticamente apenas a novos clusters criados na frota. Se você quiser aplicar essas configurações a clusters atuais, consulte Configurar padrões no nível da frota no guia de instalação do Config Sync.
Crie clusters na sua frota.
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 vai criar e aplicar 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 aos arquivos de configuração, escopos de equipe, namespaces e membros da frota.

Preços

O Config Sync e os recursos de gerenciamento de equipe da frota estão disponíveis apenas 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

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.

Crie ou tenha acesso a uma fonte de informações (um repositório Git ou uma imagem OCI) onde 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 para sua frota, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto:

Gerenciar recursos da frota: Administrador da frota (antigo Administrador do GKE Hub) (roles/gkehub.admin)
Criar clusters do GKE: Administrador de cluster do Kubernetes Engine (roles/container.clusterAdmin)
Para 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 de 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ê vai criar sua frota e ativar os serviços necessários.

Para configurar sua frota, siga estas etapas:

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

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

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

No arquivo main.tf, adicione os seguintes recursos:

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

Exporte a variável PROJECT_ID:
```
export TF_VAR_project=PROJECT_ID
```
Substitua PROJECT_ID pelo ID do projeto em que você quer criar sua frota.
Inicialize o Terraform no diretório criado:
```
terraform init
```
Verifique se as alterações propostas pelo Terraform correspondem ao plano esperado:
```
terraform plan
```
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 sua fonte da verdade

Nesta seção, você adiciona arquivos de configuração a uma fonte de verdade. Você precisa de um objeto NamespaceSelector para cada escopo de equipe que quiser usar. Por exemplo, se você tiver equipes de front-end e back-end, crie um objeto NamespaceSelector para cada uma delas. O objeto NamespaceSelector seleciona todos ou alguns dos namespaces em um escopo de equipe. Você pode adicionar outros recursos da equipe à sua fonte de informações, 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 namespaces.

Para configurar sua fonte da verdade, siga estas etapas:

Na sua fonte de verdade, crie um diretório para os arquivos de configuração que você quer que o Config Sync sincronize.
Para cada equipe, crie um objeto NamespaceSelector no diretório de configuração:

Importante: o NamespaceSelector precisa estar no modo dynamic. O modo dinâmico permite a seleção de namespaces declarados estaticamente na fonte da verdade e de namespaces presentes dinamicamente 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 recebem automaticamente o rótulo fleet.gke.io/fleet-scope: SCOPE_NAME. O NamespaceSelector seleciona todos os namespaces da frota de um escopo de equipe usando esse rótulo. Para mais exemplos de como incluir ou excluir namespaces, consulte Exemplos de NamespaceSelector.

Crie os objetos que você quer sincronizar entre 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 semelhante a 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.

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

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

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

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

No arquivo main.tf, adicione o seguinte recurso para configurar as definiçõ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 do secret.

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 de um repositório Git e sincroniza 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"
        }
      }
    }
  }
}

Inicialize o Terraform no diretório criado:
```
terraform init
```
Verifique se as alterações propostas pelo Terraform correspondem ao plano esperado:
```
terraform plan
```
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 compartilhada e, em seguida, criar clusters na sua frota.

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

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

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

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

Crie um arquivo cluster.tf que contenha valores padrão usados em todos os seus clusters, como IDs de projeto e 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
}

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

Inicialize o Terraform no diretório criado:
```
terraform init
```
Verifique se as alterações propostas pelo Terraform correspondem ao plano esperado:
```
terraform plan
```
Crie os clusters:
```
terraform apply
```

Configurar escopos de equipe e namespaces da frota

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

Para configurar escopos e namespaces de equipe, siga estas etapas:

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

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

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

No arquivo main.tf, adicione os seguintes recursos:

Adicione as informações do provedor:

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

provider "google" {
  project = var.project
}

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 forem necessários. Quando um namespace da frota é criado no cluster, ele é automaticamente rotulado 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 front-end e back-end pode ser semelhante a este:
```
resource "google_gke_hub_scope" "scope" {
  provider = google
  for_each = toset([
    "backend",
    "frontend",
  ])
  scope_id = each.value
}
```

Adicione uma vinculação de associação da 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 assinatura, 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 ao criar um 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 da frota 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, o recurso de vinculação de associação será semelhante a este:

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

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 ao criar um NamespaceSelector, por exemplo, backend.
FLEET_NAMESPACE_ID: o ID do namespace. Pode ser o mesmo valor de FLEET_NAMESPACE.

Por exemplo, se você quisesse que as equipes de front-end e back-end tivessem dois namespaces cada, o recurso de namespace da frota seria semelhante a este:

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

Inicialize o Terraform no diretório criado:
```
terraform init
```
Verifique se as alterações propostas pelo Terraform correspondem ao plano esperado:
```
terraform plan
```
Crie os escopos e namespaces da frota:
```
terraform apply
```

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

Para verificar se os recursos foram aplicados ao cluster correto, use nomos status ou acesse a guia Pacotes do Config Sync no console do Google Cloud e mude o botão de opção Visualizar por 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ê adiciona um novo recurso, desde que inclua a anotação NamespaceSelector correta, o Config Sync reconcilia automaticamente esse recurso em todos os namespaces da sua equipe.

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

A seguir

Saiba mais sobre como configurar equipes para sua frota.

Gerenciar recursos da equipe em toda a frota Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Exemplo de fluxo de trabalho

Preços

Antes de começar

Funções exigidas

Adquirir credenciais de usuário

Configurar seus dispositivos

Configurar sua fonte da verdade

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

git

OCI

Criar clusters na frota

Configurar escopos de equipe e namespaces da frota

A seguir

Gerenciar recursos da equipe em toda a frota