Gerenciar recursos de 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 estende os recursos do gerenciamento de equipe de frota para criar e gerenciar configurações de infraestrutura e cluster em todas as suas frotas.

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

Para ver um tutorial completo com exemplos de configuração, consulte o tutorial de locação da frota no repositório de amostra.

Para 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 equipes diferentes têm necessidades distintas. 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 com escopo de 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 de informações. A fonte de verdade contém os objetos NamespaceSelector usados para selecionar namespaces no nível da frota nos escopos da equipe e todos os recursos (como NetworkPolicy) que você quer sincronizar entre esses namespaces.

  3. Criar 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 a partir da fonte de verdade criada na etapa anterior. Essas configurações do Config Sync se aplicam a todos os novos clusters criados na frota.

  4. Crie clusters na sua frota.

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

Depois que você concluir essas etapas, o Config Sync criará e aplicará o NetworkPolicy com base no NamespaceSelector aos namespaces da equipe de back-end. Se você alterar ou adicionar recursos, o Config Sync detectará e aplicará continuamente as alterações aos arquivos de configuração, escopos de equipe, namespaces da frota e membros da frota.

Preços

Os recursos do Config Sync e 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

  1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
  2. Instale a CLI do Google Cloud.

  3. Para inicializar a CLI gcloud, execute o seguinte comando: 

    gcloud init

  4. Crie ou selecione um projeto do Google Cloud.

    • Crie um projeto do Google Cloud:

      gcloud projects create PROJECT_ID

      Substitua PROJECT_ID por um nome para o projeto do Google Cloud que você está criando.

    • Selecione o projeto do Google Cloud que você criou:

      gcloud config set project PROJECT_ID

      Substitua PROJECT_ID pelo nome do projeto do Google Cloud.

    5.
  5. Instale a CLI do Google Cloud.

  6. Para inicializar a CLI gcloud, execute o seguinte comando: 

    gcloud init

  7. Crie ou selecione um projeto do Google Cloud.

    • Crie um projeto do Google Cloud:

      gcloud projects create PROJECT_ID

      Substitua PROJECT_ID por um nome para o projeto do Google Cloud que você está criando.

    • Selecione o projeto do Google Cloud que você criou:

      gcloud config set project PROJECT_ID

      Substitua PROJECT_ID pelo nome do projeto do Google Cloud.

    8.

  8. Criar ou ter acesso a uma fonte de verdade (um repositório Git ou uma imagem OCI) para armazenar arquivos de configuração. Os exemplos neste guia usam um repositório Git.

Funções exigidas

Para ter 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 seu projeto:

Para mais informações sobre como conceder papéis, consulte Gerenciar acesso.

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 seguinte comando 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:

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

  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:

    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 sua frota.

  5. Inicialize o Terraform no diretório que você criou:

    terraform init

  6. Verifique se as alterações propostas com o 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.

Configure sua fonte de informações

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 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 dentro de um escopo de equipe. É possível adicionar outros recursos de 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 entre namespaces.

Para configurar essa fonte, 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 seu diretório de configuração:

    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 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 sobre como incluir ou excluir namespaces, consulte Exemplos de NamespaceSelector.

  3. 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 ao seguinte:

    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:

  1. Crie um diretório para os arquivos de configuração padrão da frota do Terraform. Nesse diretório, adicione um arquivo main.tf e um variables.tf.

  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 definir 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. Precisa ser definido para a versão 1.17.0 ou mais recente. Se deixado em branco, o padrão será a versão mais recente.
    • REPO: o URL para o 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 que você quer sincronizar.
    • SECRET: o tipo de autenticação do secret.

    Para uma lista completa de configurações compatíveis com o bloco git do Config Sync, consulte a documentação de referência do Terraform para recursos de 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. Precisa ser definido para a versão 1.17.0 ou mais recente. Se deixado em branco, o padrão será a versão mais recente.
    • REPO: o URL para o repositório de imagens OCI que contém arquivos de configuração.
    • DIRECTORY: o caminho absoluto do diretório que contém os recursos que você quer sincronizar. Deixe em branco para usar o diretório raiz.
    • SECRET: o tipo de autenticação do secret.

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

  4. Inicialize o Terraform no diretório que você criou:

    terraform init

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

    terraform plan

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

    terraform apply

Criar clusters na sua frota

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

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

  1. Crie um diretório para os arquivos de configuração do cluster do Terraform. Nesse diretório, adicione um arquivo main.tf e um variables.tf.

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

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

    É possível criar quantos clusters você quiser. Por exemplo, o arquivo main.tf a seguir cria três clusters em diferentes regiões:

    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 que você criou:

    terraform init

  6. Verifique se as alterações propostas com o 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 da equipe e associa os clusters a esses escopos. Em seguida, você cria os namespaces da frota necessários, por exemplo, um para cada equipe, em cada escopo, e o Config Sync cria os recursos nos namespaces.

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

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

  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.

      É possível adicionar quantos escopos de equipe forem necessários. Quando um namespace de 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 se parecer 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 de 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 de assinatura. Pode ser igual a MEMBERSHIP_BINDING_NAME.
      • SCOPE_NAME: o seletor de rótulo que você atribuiu à equipe ao criar um NamespaceSelector. Por exemplo, backend.
      • CLUSTER_NAME: o nome do cluster que você criou quando criou clusters, por exemplo, us-east-cluster.
      • CLUSTER_LOCATION: o local do cluster. Por exemplo, us-east1.

      É necessário definir uma vinculação de associação de 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 seria 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]
}

    4. Adicione os namespaces que você quiser 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ótulo que você atribuiu à equipe ao criar um NamespaceSelector. Por exemplo, backend.
      • FLEET_NAMESPACE_ID: o ID do namespace. Pode ter o mesmo valor 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 poderá 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 que você criou:

    terraform init

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

    terraform plan

  6. Crie os escopos e namespaces da frota:

    terraform apply

Depois que você cria escopos e namespaces da frota, o Config Sync detecta esses novos namespaces e os escopos deles, seleciona recursos nos namespaces da frota e os reconcilia com os arquivos de configuração.

É possível verificar se os recursos estão aplicados ao cluster correto usando nomos status ou acessando a guia Pacotes do Config Sync no console do Google Cloud e alterando o botão de opção Visualizar por para Cluster.

Acessar "Pacotes"

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

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

A seguir