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

Crie um cluster do Kubernetes para permitir a implantação de cargas de trabalho de contêineres. Os clusters são um recurso zonal e não podem abranger várias zonas. Para operar clusters em uma implantação multizona, é necessário criar manualmente clusters em cada zona.

Antes de começar

Para receber as permissões necessárias para criar um cluster do Kubernetes, 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.

O Google Distributed Cloud (GDC) com isolamento físico tem os seguintes limites para clusters do Kubernetes:

  • 16 clusters por organização
  • 42 nós de trabalho por cluster e um mínimo de três nós de trabalho
  • 4.620 pods por cluster
  • 110 pods por nó;

Configurar o bloco CIDR do pod

O cluster segue esta lógica ao alocar endereços IP:

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

Confira 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 de CIDR de pod necessária para configurar o cluster de usuário com base no número de nós necessários. Planeje futuras adições de nós ao cluster ao configurar o intervalo de CIDR:

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

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

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

Criar um cluster do Kubernetes

Siga estas etapas para criar um cluster do Kubernetes:

Console

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

  2. Clique em Criar cluster.

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

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

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

  6. Clique em Anexar projeto e selecione um projeto para anexar ao cluster. Clique em Salvar. É possível anexar ou separar 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êineres nele.

    Crie um cluster usando o console.

  7. Clique em Próxima.

  8. 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 único compatível com clusters do Kubernetes é o protocolo de Internet versão 4 (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. Seus 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.

  9. Revise 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.

  10. 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, personalize-o 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 sua carga de trabalho. Confira a lista das seguintes configurações:

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

    4. Clique em Salvar.

  11. Clique em Criar para gerar o cluster.

API

Para criar um cluster usando a API diretamente, aplique um recurso personalizado à sua instância do GDC:

  1. Crie um recurso personalizado Cluster e salve-o como um arquivo YAML, como cluster.yaml:

    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
  loadBalancer:
    ingressServiceIPSize: LOAD_BALANCER_POOL_SIZE
  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:

    • 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 de 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 de 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 para configuração, consulte Listar as versões disponíveis do Kubernetes para um cluster.
    • LOAD_BALANCER_POOL_SIZE: o tamanho dos pools de endereços IP não sobrepostos usados pelos serviços de balanceador de carga. Se não for definido, um valor padrão 20 será usado.
    • MACHINE_TYPE: o tipo de máquina para os nós de trabalho do pool de nós. Consulte os tipos de máquina disponíveis para saber o que pode ser configurado.
    • 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 deste pool de nós. Esse campo é opcional.
    • LABELS: os rótulos a serem aplicados aos nós deste 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. Por exemplo, mixed-2. A GPU não será particionada se esse campo não for definido. Para ver os perfis de GPU de várias instâncias (MIG) disponíveis, consulte Perfis de MIG compatíveis.

  2. Aplique o recurso personalizado à sua instância do GDC:

    kubectl apply -f cluster.yaml --kubeconfig MANAGEMENT_API_SERVER

    Substitua MANAGEMENT_API_SERVER pelo caminho do kubeconfig do servidor de API zonal. Se você ainda não gerou um arquivo kubeconfig para o servidor da API na zona de destino, consulte Fazer login para mais detalhes.

Terraform

  1. Em um arquivo de configuração do Terraform, insira o seguinte snippet de código:

    provider "kubernetes" {
  config_path = "MANAGEMENT_API_SERVER"
}

resource "kubernetes_manifest" "cluster-create" {
  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"
      }
      "loadBalancer" = {
        "ingressServiceIPSize" = "LOAD_BALANCER_POOL_SIZE"
      }
      "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. Se você ainda não gerou um arquivo kubeconfig para o servidor da API na zona de destino, consulte Fazer login para mais detalhes.
    • 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 de 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 de 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 para configuração, consulte Listar as versões disponíveis do Kubernetes para um cluster.
    • LOAD_BALANCER_POOL_SIZE: o tamanho dos pools de endereços IP não sobrepostos usados pelos serviços de balanceador de carga. Se não for definido, um valor padrão 20 será usado.
    • MACHINE_TYPE: o tipo de máquina para os nós de trabalho do pool de nós. Consulte os tipos de máquina disponíveis para saber o que pode ser configurado.
    • 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 deste pool de nós. Esse campo é opcional.
    • LABELS: os rótulos a serem aplicados aos nós deste 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. Por exemplo, mixed-2. A GPU não será particionada se esse campo não for definido. Para ver os perfis de GPU de várias instâncias (MIG) disponíveis, consulte Perfis de MIG compatíveis.

  2. Aplique o novo cluster do Kubernetes usando o Terraform:

    terraform apply

Listar as versões disponíveis do Kubernetes para um cluster

É possível listar as versões disponíveis do Kubernetes na sua instância do GDC usando a CLI kubectl:

kubectl get userclustermetadata.upgrade.private.gdc.goog \
    -o=custom-columns=K8S-VERSION:.spec.kubernetesVersion \
    --kubeconfig MANAGEMENT_API_SERVER

Substitua MANAGEMENT_API_SERVER pelo caminho kubeconfig do servidor da API zonal do cluster.

A saída será assim:

K8S-VERSION
1.25.10-gke.2100
1.26.5-gke.2100
1.27.4-gke.500

Suporte a cargas de trabalho de GPU em um cluster

O Distributed Cloud oferece suporte a GPUs NVIDIA para clusters do Kubernetes, e eles executam seus dispositivos de GPU como cargas de trabalho do usuário. Por exemplo, talvez você prefira executar notebooks de inteligência artificial (IA) e machine learning (ML) em um ambiente de GPU. Verifique se o cluster é compatível com dispositivos de GPU antes de usar notebooks de IA e ML. O suporte a GPU é ativado por padrão para clusters que têm máquinas de GPU provisionadas.

Os clusters podem ser criados usando o console ou a API do GDC diretamente. Provisione máquinas com GPU para que o cluster seja compatível com cargas de trabalho de GPU nos contêineres associados. Para mais informações, consulte Criar um cluster do Kubernetes.

As GPUs são alocadas de forma estática. As quatro primeiras GPUs são sempre dedicadas a cargas de trabalho como APIs de inteligência artificial (IA) e machine learning (ML) pré-treinadas. Essas GPUs não são executadas em um cluster do Kubernetes. As GPUs restantes estão disponíveis para clusters do Kubernetes. Os notebooks de IA e ML são executados em clusters do Kubernetes.

Alocar máquinas de GPU para os tipos de cluster corretos para garantir que componentes como APIs de IA e ML e notebooks possam ser usados.