Criar um cluster compartilhado para executar cargas de trabalho de contêiner

Este documento explica como criar um cluster compartilhado do Kubernetes em uma zona isolada do Google Distributed Cloud (GDC). Um cluster compartilhado abrange vários projetos e inclui serviços abrangentes gerenciados pelo GDC que oferecem uma configuração de cluster do Kubernetes altamente opinativa e menos configurável do que o cluster padrão. Para mais informações sobre clusters padrão, consulte Configurações de cluster do Kubernetes.

Os clusters compartilhados são um recurso zonal e não podem abranger várias zonas. Para operar clusters em um universo multizonal, é necessário criar clusters manualmente em cada zona.

Este documento é destinado a públicos-alvo, como desenvolvedores de aplicativos no grupo de operadores de aplicativos, que são responsáveis por gerenciar cargas de trabalho de contêiner na organização. Para mais informações, consulte Públicos-alvo da documentação do GDC com isolamento físico.

Antes de começar

  • Para ter as permissões necessárias para criar um cluster compartilhado, peça ao administrador do IAM da organização para conceder a você o papel de administrador do cluster de usuário (user-cluster-admin). Esse papel não está vinculado a um namespace.

  • Para usar a API ou o Terraform para criar um cluster compartilhado, gere o arquivo kubeconfig do servidor da API zonal para hospedar o cluster. Defina a variável de ambiente MANAGEMENT_API_SERVER para o caminho kubeconfig. Para mais informações, consulte Recursos do servidor da API de gerenciamento zonal.

  • Analise os limites do cluster para considerações de recursos.

Planejar o bloco CIDR do pod

Para alocar o bloco CIDR do pod de tamanho adequado para suas cargas de trabalho, é necessário calcular a quantidade de endereços IP necessários para o cluster do Kubernetes antes de criá-lo. A maioria dos parâmetros de rede não pode ser alterada após a criação do cluster.

Um cluster do Kubernetes segue a lógica de procedimento ao alocar endereços IP:

  • O Kubernetes atribui um bloco CIDR /24 composto por 256 endereços a cada um dos nós. Essa quantidade segue o máximo padrão de 110 pods por nó para clusters do Kubernetes.
  • O tamanho do bloco CIDR atribuído a um nó depende dos pods máximos por valor de nó.
  • O bloco sempre contém, pelo menos, o dobro de endereços do número máximo de pods por nó.

Consulte o exemplo a seguir para entender como o valor padrão de Tamanho da máscara por nó= /24 foi calculado para acomodar 110 pods:

Maximum pods per node = 110
Total number of IP addresses required = 2 * 110 = 220

Per node mask size = /24
Number of IP addresses in a /24 = 2(32 - 24) = 256

Determine a máscara CIDR do pod necessária para configurar o cluster do Kubernetes com base no número de nós necessários. Planeje futuras adições de nós ao cluster ao configurar o intervalo CIDR:

  Total number of nodes supported = 2(Per node mask size - pod CIDR mask)

Como há um Tamanho da máscara por nó= /24 padrão , consulte a seguinte tabela que mapeia a máscara CIDR do pod para o número de nós compatíveis.

Máscara CIDR do pod Cálculo: 2(Tamanho da máscara por nó - máscara CIDR máscara) Número máximo de nós compatíveis, incluindo nós do plano de controle nodes
/21 2(24 - 21) 8
/20 2(24-20) 16
/19 2(24 - 19) 32
/18 2(24 - 18) 64

Depois de calcular o bloco CIDR do pod para o cluster do Kubernetes, configure-o como parte do fluxo de trabalho de criação do cluster na próxima seção.

Criar um cluster compartilhado

Conclua as etapas a seguir para criar um cluster compartilhado do Kubernetes:

Console

  1. No seletor de projetos, selecione sua organização.

    Os clusters compartilhados são recursos com escopo da organização. Se você selecionar um projeto, vai criar um cluster padrão, que tem escopo do projeto. Para mais informações, consulte a hierarquia de recursos.

  2. No menu de navegação, selecione Kubernetes Engine > Clusters.

  3. Clique em Criar cluster.

  4. No campo Nome, especifique um nome para o cluster.

  5. Selecione a versão do Kubernetes para o cluster.

  6. Selecione a zona em que o cluster será criado.

  7. Clique em Anexar projeto e selecione um projeto atual para anexar ao cluster. Em seguida, clique em Salvar. É possível anexar ou desanexar projetos depois de criar o cluster na página de detalhes do projeto. É necessário ter um projeto anexado ao cluster antes de implantar cargas de trabalho de contêiner.

    Crie um cluster usando o console.

  8. Clique em Próxima.

  9. Configure as definições de rede do cluster. Não é possível mudar essas configurações de rede depois de criar o cluster. O protocolo de Internet padrão e compatível para clusters do Kubernetes é a versão 4 do protocolo de Internet (IPv4).

    1. Se você quiser criar nós de balanceador de carga dedicados, insira o número de nós a serem criados. Por padrão, você recebe zero nós, e o tráfego do balanceador de carga é executado pelos nós de controle.

    2. Selecione o CIDR de serviço (roteamento entre domínios sem classe) a ser usado. Os serviços implantados, como balanceadores de carga, recebem endereços IP desse intervalo.

    3. Selecione o CIDR do pod a ser usado. O cluster aloca endereços IP desse intervalo para seus pods e VMs.

    4. Clique em Próxima.

  10. Analise os detalhes do pool de nós padrão gerado automaticamente para o cluster. Clique em Editar para modificar o pool de nós padrão.

  11. Para criar outros pools de nós, selecione Adicionar pool de nós. Ao editar o pool de nós padrão ou adicionar um novo pool de nós, você o personaliza com as seguintes opções:

    1. Atribua um nome ao pool de nós. Não é possível modificar o nome depois de criar o pool de nós.
    2. Especifique o número de nós de trabalho a serem criados no pool de nós.

    3. Selecione a classe de máquina mais adequada para os requisitos da carga de trabalho. Confira a lista das seguintes configurações:

      • Tipo de máquina
      • CPU
      • Memória

    4. Clique em Salvar.

  12. Clique em Criar para criar o cluster.

A criação de clusters compartilhados pode levar até 90 minutos para ser concluída.

API

  1. Crie o recurso personalizado Cluster:

    kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
apiVersion: cluster.gdc.goog/v1
kind: Cluster
metadata:
  name: CLUSTER_NAME
  namespace: platform
spec:
  clusterNetwork:
    podCIDRSize: POD_CIDR
    serviceCIDRSize: SERVICE_CIDR
  initialVersion:
    kubernetesVersion: KUBERNETES_VERSION
  nodePools:
  - machineTypeName: MACHINE_TYPE
    name: NODE_POOL_NAME
    nodeCount: NUMBER_OF_WORKER_NODES
    taints: TAINTS
    labels: LABELS
    acceleratorOptions:
      gpuPartitionScheme: GPU_PARTITION_SCHEME
  releaseChannel:
    channel: UNSPECIFIED
EOF

    Substitua:

    • MANAGEMENT_API_SERVER: o caminho kubeconfig do servidor da API zonal.
    • CLUSTER_NAME: o nome do cluster. O nome do cluster não pode terminar com -system. O sufixo -system é reservado para clusters criados pelo GDC.
    • POD_CIDR: o tamanho dos intervalos de rede em que os endereços IP virtuais do pod são alocados. Se não for definido, um valor padrão 21 será usado.
    • SERVICE_CIDR: o tamanho dos intervalos de rede em que os endereços IP virtuais de serviço são alocados. Se não for definido, um valor padrão 23 será usado.
    • KUBERNETES_VERSION: a versão do Kubernetes do cluster, como 1.26.5-gke.2100. Para listar as versões disponíveis do Kubernetes a serem configuradas, consulte Listar as versões disponíveis do Kubernetes para um cluster.
    • MACHINE_TYPE: o tipo de máquina para os nós de trabalho do pool de nós. Confira os tipos de máquina disponíveis para o que está disponível para configuração.
    • NODE_POOL_NAME: o nome do pool de nós.
    • NUMBER_OF_WORKER_NODES: o número de nós de trabalho a serem provisionados no pool de nós.
    • TAINTS: os taints a serem aplicados aos nós desse pool de nós. Esse campo é opcional.
    • LABELS: os rótulos a serem aplicados aos nós desse pool de nós. Ele contém uma lista de pares de chave-valor. Esse campo é opcional.
    • GPU_PARTITION_SCHEME: o esquema de particionamento de GPU, se você estiver executando cargas de trabalho de GPU. Esse campo é opcional. Por exemplo, mixed-2. A GPU não será particionada se esse campo não estiver definido. Para mais informações sobre os perfis de GPU de várias instâncias (MIG) disponíveis, consulte Perfis de MIG compatíveis.

    A criação de clusters compartilhados pode levar até 90 minutos para ser concluída.

  2. Crie o recurso personalizado ProjectBinding:

    kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
apiVersion: resourcemanager.gdc.goog/v1
kind: ProjectBinding
metadata:
  name: CLUSTER_NAME-PROJECT_NAME
  namespace: platform
  labels:
    resourcemanager.gdc.goog/projectbinding-for-user-project: "true"
spec:
  clusterRef:
    name: CLUSTER_NAME
  selector:
    nameSelector:
      matchNames:
      - PROJECT_NAME
EOF

    Substitua:

    • MANAGEMENT_API_SERVER: o caminho kubeconfig do servidor da API zonal.
    • CLUSTER_NAME: o nome do cluster.
    • PROJECT_NAME: o nome do projeto a ser vinculado. Cada recurso ProjectBinding só pode ser mapeado para um cluster. Se um projeto exigir acesso a vários clusters, um ProjectBinding exclusivo precisará ser criado para cada cluster.

    É necessário anexar um projeto ao cluster antes que um desenvolvedor possa implantar cargas de trabalho de contêiner no cluster.

Terraform

  1. Em um arquivo de configuração do Terraform, insira o snippet de código a seguir para criar o recurso personalizado Cluster:

    provider "kubernetes" {
  config_path = "MANAGEMENT_API_SERVER"
}

resource "kubernetes_manifest" "CLUSTER_RESOURCE_NAME" {
  manifest = {
    "apiVersion" = "cluster.gdc.goog/v1"
    "kind" = "Cluster"
    "metadata" = {
      "name" = "CLUSTER_NAME"
      "namespace" = "platform"
    }
    "spec" = {
      "clusterNetwork" = {
        "podCIDRSize" = "POD_CIDR"
        "serviceCIDRSize" = "SERVICE_CIDR"
      }
      "initialVersion" = {
        "kubernetesVersion" = "KUBERNETES_VERSION"
      }
      "nodePools" = [{
        "machineTypeName" = "MACHINE_TYPE"
        "name" = "NODE_POOL_NAME"
        "nodeCount" = "NUMBER_OF_WORKER_NODES"
        "taints" = "TAINTS"
        "labels" = "LABELS"
        "acceleratorOptions" = {
          "gpuPartitionScheme" = "GPU_PARTITION_SCHEME"
        }
      }]
      "releaseChannel" = {
        "channel" = "UNSPECIFIED"
      }
    }
  }
}

    Substitua:

    • MANAGEMENT_API_SERVER: o caminho kubeconfig do servidor da API zonal.
    • CLUSTER_RESOURCE_NAME: o nome exclusivo do recurso do Terraform do cluster, como cluster-1. Esse nome é usado pelo Terraform para identificar o cluster e não é usado pelo GDC.
    • CLUSTER_NAME: o nome do cluster. O nome do cluster não pode terminar com -system. O sufixo -system é reservado para clusters criados pelo GDC.
    • POD_CIDR: o tamanho dos intervalos de rede em que os endereços IP virtuais do pod são alocados. Se não for definido, um valor padrão 21 será usado.
    • SERVICE_CIDR: o tamanho dos intervalos de rede em que os endereços IP virtuais de serviço são alocados. Se não for definido, um valor padrão 23 será usado.
    • KUBERNETES_VERSION: a versão do Kubernetes do cluster, como 1.26.5-gke.2100. Para listar as versões disponíveis do Kubernetes a serem configuradas, consulte Listar as versões disponíveis do Kubernetes para um cluster.
    • MACHINE_TYPE: o tipo de máquina para os nós de trabalho do pool de nós. Confira os tipos de máquina disponíveis para o que está disponível para configuração.
    • NODE_POOL_NAME: o nome do pool de nós.
    • NUMBER_OF_WORKER_NODES: o número de nós de trabalho a serem provisionados no pool de nós.
    • TAINTS: os taints a serem aplicados aos nós desse pool de nós. Esse campo é opcional.
    • LABELS: os rótulos a serem aplicados aos nós desse pool de nós. Ele contém uma lista de pares de chave-valor. Esse campo é opcional.
    • GPU_PARTITION_SCHEME: o esquema de particionamento de GPU, se você estiver executando cargas de trabalho de GPU. Esse campo é opcional. Por exemplo, mixed-2. A GPU não será particionada se esse campo não estiver definido. Para mais informações sobre os perfis de GPU de várias instâncias (MIG) disponíveis, consulte Perfis de MIG compatíveis.

  2. Em um arquivo de configuração do Terraform, insira o snippet de código a seguir para criar o recurso personalizado ProjectBinding:

    provider "kubernetes" {
  config_path = "MANAGEMENT_API_SERVER"
}

resource "kubernetes_manifest" "PROJECT_BINDING_RESOURCE_NAME" {
  manifest = {
    "apiVersion" = "resourcemanager.gdc.goog/v1"
    "kind" = "ProjectBinding"
    "metadata" = {
      "name" = "CLUSTER_NAME-PROJECT_NAME"
      "namespace" = "platform"
      "labels" = {
        "resourcemanager.gdc.goog/projectbinding-for-user-project" = "true"
      }
    }
    "spec" = {
      "clusterRef" = {
        "name" = "CLUSTER_NAME"
      }
      "selector" = {
        "nameSelector" = {
          "matchNames" = [
            "PROJECT_NAME",
          ]
        }
      }
    }
  }
}

    Substitua:

    • MANAGEMENT_API_SERVER: o caminho kubeconfig do servidor da API zonal.
    • PROJECT_BINDING_RESOURCE_NAME: o nome do recurso do Terraform da vinculação de projeto, como project-binding-1. Esse nome é usado pelo Terraform para identificar a vinculação de projeto e não é usado pelo GDC.
    • CLUSTER_NAME: o nome do cluster.
    • PROJECT_NAME: o nome do projeto a ser vinculado. Cada recurso ProjectBinding só pode ser mapeado para um cluster. Se um projeto exigir acesso a vários clusters, um ProjectBinding exclusivo precisará ser criado para cada cluster.

    É necessário anexar um projeto ao cluster antes que um desenvolvedor possa implantar cargas de trabalho de contêiner no cluster.

  3. Aplique os novos recursos personalizados usando o Terraform:

    terraform apply

A criação de clusters compartilhados pode levar até 90 minutos para ser concluída.

A seguir