Esta página foi traduzida pela API Cloud Translation.

Manter clusters do Kubernetes

Com o Google Distributed Cloud (GDC) isolado por ar, é possível gerenciar seus clusters do Kubernetes após a criação usando o GKE no GDC. Esse serviço permite que você se adapte aos requisitos de carga de trabalho de contêiner em evolução.

Antes de começar

Para conferir e gerenciar pools de nós em um cluster do Kubernetes, é preciso ter as seguintes<0x<0A>

Administrador do cluster de usuários (user-cluster-admin)
Leitor de nós do cluster de usuário (user-cluster-node-viewer)

Essas funções não estão vinculadas a um namespace.

Para executar comandos em um cluster do Kubernetes, verifique se você tem os seguintes recursos:

Localize o nome do cluster do Kubernetes ou pergunte ao administrador da plataforma.
Faça login e gere o arquivo kubeconfig para o cluster do Kubernetes se você não tiver um.
Use o caminho kubeconfig do cluster do Kubernetes para substituir KUBERNETES_CLUSTER_KUBECONFIG nestas instruções.

Realizar manutenção do nó

Quando você precisar reparar ou manter os nós, primeiro coloque-os no modo de manutenção. Colocar nós no modo de manutenção drena os pods e as cargas de trabalho com segurança e exclui os nós da programação de pods. No modo de manutenção, é possível trabalhar nos nós sem o risco de interromper o tráfego dos pods.

Como funciona

O modo de manutenção para GDC é semelhante à execução de kubectl cordon e kubectl drain para um nó específico. Confira alguns detalhes relevantes para o modo de manutenção:

Os nós especificados são marcados como não programáveis. Essa é a ação que o kubectl cordon faz.
Os taints de nó são adicionados aos nós especificados para indicar que nenhum pod pode ser programado ou executado neles. Essa ação é semelhante a kubectl drain.
É aplicado um tempo limite de 20 minutos para garantir que os nós não fiquem travados aguardando o encerramento dos pods. Os pods não serão encerrados se estiverem configurados para tolerar todos os taints ou tiverem finalizadores. Os clusters do GDC tentam encerrar todos os pods, mas, se o tempo limite for excedido, o nó será colocado no modo de manutenção. Esse tempo limite impede que os pods em execução bloqueiem os upgrades.
Se você tiver uma carga de trabalho baseada em VM em execução no nó, os clusters do GDC vão aplicar um NodeSelector ao pod da instância de máquina virtual (VMI) e, em seguida, interromper o pod. O NodeSelector garante que o pod VMI seja reiniciado no mesmo nó quando ele for removido do modo de manutenção.

Colocar um nó no modo de manutenção

Escolha os nós que você quer colocar no modo de manutenção especificando os intervalos de endereços IP dos nós selecionados na seção maintenanceBlocks do arquivo de configuração do cluster. Os nós escolhidos precisam estar no estado Ready e funcionando no cluster.

Para colocar nós no modo de manutenção:

Edite o arquivo de configuração do cluster para selecionar os nós que você quer colocar no modo de manutenção.

É possível editar o arquivo de configuração com um editor de sua preferência ou editar o recurso personalizado do cluster diretamente executando o seguinte comando:
```
kubectl edit cluster KUBERNETES_CLUSTER_NAME \
    -n KUBERNETES_CLUSTER_NAMESPACE \
    --kubeconfig KUBERNETES_CLUSTER_KUBECONFIG
```
Substitua o seguinte pelo cluster do Kubernetes:
- KUBERNETES_CLUSTER_NAME: o nome do cluster.
- KUBERNETES_CLUSTER_NAMESPACE: o namespace do cluster.
- KUBERNETES_CLUSTER_KUBECONFIG: o caminho do arquivo kubeconfig.
Depois que a configuração do cluster for aplicada, ele colocará os nós aplicáveis no modo de manutenção.
Adicione a seção maintenanceBlocks ao arquivo de configuração do cluster para especificar um único endereço IP ou um intervalo de endereços para os nós que você quer colocar no modo de manutenção.

O exemplo a seguir mostra como selecionar vários nós especificando um intervalo de endereços IP:
```
...
metadata:
  name: my-cluster
  namespace: cluster-my-cluster
spec:
  maintenanceBlocks:
    cidrBlocks:
    - 172.16.128.1-172.16.128.64
...
```

Confira o status dos nós no cluster:

kubectl get nodes -n KUBERNETES_CLUSTER_NAME \
    --kubeconfig KUBERNETES_CLUSTER_KUBECONFIG

A resposta é semelhante a esta:

NAME                STATUS                     ROLES    AGE     VERSION
user-gdc-01        Ready                      master   2d22h   v1.23.5-gke.1502
user-gdc-04        Ready                      none     2d22h   v1.23.5-gke.1502
user-gdc-05        Ready,SchedulingDisabled   none     2d22h   v1.23.5-gke.1502
user-gdc-06        Ready                      none     2d22h   v1.23.5-gke.1502

O status SchedulingDisabled indica que um nó está no modo de manutenção.

Confira o número de nós no modo de manutenção:
```
kubectl get nodepools --kubeconfig KUBERNETES_CLUSTER_KUBECONFIG
```
A resposta será semelhante a esta:
```
NAME   READY   RECONCILING   STALLED   UNDERMAINTENANCE   UNKNOWN
np1    3       0             0         1                  0
```
A coluna UNDERMAINTENANCE neste exemplo mostra que um nó está no modo de manutenção.

Os clusters também adicionam os seguintes taints aos nós quando eles são colocados no modo de manutenção:

baremetal.cluster.gke.io/maintenance:NoExecute
baremetal.cluster.gke.io/maintenance:NoSchedule

Redimensionar pools de nós

O pool de nós de qualquer cluster do KUBERNETES no ambiente do GDC pode ser redimensionado para escalonar com as mudanças na carga de trabalho. Para gerenciar pools de nós em um cluster do Kubernetes, é necessário ter o papel Administrador do cluster de usuário (user-cluster-admin). Essa função não está vinculada a um namespace.

Para escalonar um pool de nós em um cluster, siga estas etapas:

Console

No painel, selecione o projeto em que o cluster que você quer editar está.
No menu de navegação, selecione Kubernetes Engine > Clusters.
Selecione o nome do cluster associado ao pool de nós. A página Detalhes do cluster é exibida.
Clique na guia Pools de nós.
Selecione o ícone Editar do pool de nós que você quer redimensionar. A solicitação Editar pool de nós é exibida.
Atualize o campo Número de nós para refletir a nova quantidade de nós necessária no pool de nós. É possível aumentar ou diminuir o número de nós para atender aos requisitos da sua carga de trabalho.

Observação: a redução do pool de nós pode causar problemas de recursos se os nós restantes não tiverem memória suficiente para processar as cargas de trabalho atuais.
Clique em Salvar.
Volte para a guia Pools de nós do cluster e confirme se o pool de nós redimensionado tem o status Ready e o número correto de nós. Pode levar alguns minutos para que o pool de nós seja escalonado de acordo com sua especificação.

API

Abra a especificação do recurso personalizado Cluster com a CLI kubectl usando o editor interativo:
```
kubectl edit clusters.cluster.gdc.goog/KUBERNETES_CLUSTER_NAME -n platform \
      --kubeconfig MANAGEMENT_API_SERVER
```
Substitua:
- KUBERNETES_CLUSTER_NAME: o nome do cluster que hospeda o pool de nós.
- MANAGEMENT_API_SERVER: o caminho kubeconfig do servidor da API zonal em que o cluster do Kubernetes está hospedado. Se você ainda não gerou um arquivo kubeconfig para o servidor da API na zona de destino, consulte Fazer login para mais detalhes.
Atualize o campo nodeCount para o pool de nós a ser redimensionado:
```
nodePools:
...
- machineTypeName: n2-standard-2-gdc
  name: nodepool-1
  nodeCount: NUMBER_OF_WORKER_NODES
```
Substitua NUMBER_OF_WORKER_NODES pelo número atualizado de nós de trabalho a serem provisionados no pool de nós.
Salve o arquivo e saia do editor.
Verifique se o escalonamento de nós foi concluído conferindo a configuração do pool de nós:
```
kubectl get clusters.cluster.gdc.goog/KUBERNETES_CLUSTER_NAME -n platform -o json \
    --kubeconfig MANAGEMENT_API_SERVER | jq .status.workerNodePoolStatuses
```
Confirme se o número readyNodes reflete a quantidade de nós definida para o pool de nós. Pode levar alguns minutos para o pool de nós ser escalonado de acordo com sua especificação.

Mover clusters na hierarquia do projeto

Os projetos oferecem um agrupamento lógico de instâncias de serviço. É possível adicionar e remover clusters do Kubernetes da hierarquia de projetos do GDC para agrupar seus serviços adequadamente.

Anexar um projeto a um cluster

Ao criar um cluster no console do GDC, é necessário anexar pelo menos um projeto antes de implantar cargas de trabalho de contêiner nele. Se você precisar adicionar mais projetos a um cluster atual, siga estas etapas:

No menu de navegação, selecione Kubernetes Engine > Clusters.
Clique no cluster na lista para abrir a página Detalhes do cluster.
Selecione Anexar projeto.
Selecione os projetos disponíveis para adicionar na lista. Clique em Salvar.

Remover um projeto de um cluster

Para separar um projeto de um cluster do Kubernetes, siga estas etapas:

No menu de navegação, selecione Kubernetes Engine > Clusters.
Clique no cluster na lista para abrir a página Detalhes do cluster.
Clique em Desanexar para o projeto que você quer desanexar do cluster.

Observação: separar um projeto de um cluster pode causar mudanças significativas, como a exclusão de cargas de trabalho em execução em um cluster. Entenda as consequências antes de confirmar a remoção do projeto de um cluster.

Ver todos os clusters em uma organização

É possível conferir todos os clusters do Kubernetes disponíveis em uma organização, incluindo os status, as versões do Kubernetes e outros detalhes. Como os clusters do Kubernetes são um recurso zonal, só é possível listar clusters por zona.

Console

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

Todos os clusters disponíveis na organização com os respectivos status e outras informações são exibidos:

`kubectl`

Liste os clusters do Kubernetes disponíveis de uma organização em uma zona:
```
kubectl get clusters.cluster.gdc.goog -n platform \
    --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.

O resultado será assim:
```
NAME        STATE     K8S VERSION
user-vm-1   Running   1.25.10-gke.2100
user-test   Running   1.26.5-gke.2100
```

Ver propriedades atualizáveis

Para cada cluster do Kubernetes, um conjunto de propriedades está disponível para mudança após a criação. Só é possível mudar as propriedades mutáveis que estão no spec do recurso personalizado Cluster. Nem todas as propriedades em spec podem ser atualizadas depois que o cluster é provisionado. Para conferir essas propriedades atualizáveis, siga estas etapas:

Console

No menu de navegação, selecione Kubernetes Engine > Clusters.
Na lista de clusters do Kubernetes, clique no nome de um cluster para conferir as propriedades dele.
As propriedades editáveis têm um ícone Editar.

`kubectl`

Confira a lista de propriedades da especificação Cluster e os valores válidos correspondentes a cada propriedade:

kubectl explain clusters.cluster.gdc.goog.spec \
    --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.

O resultado será assim:

KIND:     Cluster
VERSION:  cluster.gdc.goog/v1

RESOURCE: spec <Object>

DESCRIPTION:
    <empty>

FIELDS:
  clusterNetwork    <Object>
    The cluster network configuration. If unset, the default configurations
    with pod and service CIDR sizes are used. Optional. Mutable.

  initialVersion    <Object>
    The GDC air-gapped version information of the user cluster during cluster creation.
    Optional. Default to use the latest applicable version. Immutable.

  loadBalancer  <Object>
    The load balancer configuration. If unset, the default configuration with
    the ingress service IP address size is used. Optional. Mutable.

  nodePools <[]Object>
    The list of node pools for the cluster worker nodes. Optional. Mutable.

  releaseChannel    <Object>
    The release channel a cluster is subscribed to. When a cluster is
    subscribed to a release channel, GDC maintains the cluster versions for
    users. Optional. Mutable.

Atualize essas configurações usando o console do GDC ou a CLI kubectl. Por exemplo, é possível redimensionar um pool de nós.

Ajustar o tamanho do endereço IP do serviço de entrada

É possível escalonar o tamanho do endereço IP do serviço de entrada depois de criar um cluster do Kubernetes.

Abra a especificação do recurso personalizado Cluster com a CLI kubectl usando o editor interativo:
```
kubectl edit clusters.cluster.gdc.goog/KUBERNETES_CLUSTER_NAME -n platform \
    --kubeconfig MANAGEMENT_API_SERVER
```
Substitua:
- KUBERNETES_CLUSTER_NAME: o nome do cluster que fornece o endereço IP.
- MANAGEMENT_API_SERVER: o caminho kubeconfig do servidor da API zonal em que o cluster do Kubernetes está hospedado. Se você ainda não gerou um arquivo kubeconfig para o servidor da API na zona de destino, consulte Fazer login para mais detalhes.
Atualize o campo ingressServiceIPSize para o novo tamanho do endereço IP:
```
...
spec:
...
  loadBalancer:
    ingressServiceIPSize: INGRESS_SERVICE_IP_SIZE
...
```
Substitua INGRESS_SERVICE_IP_SIZE pelo tamanho atualizado do endereço IP do serviço de entrada.
Salve o arquivo e saia do editor.

Não há um limite definido para o tamanho do endereço IP do serviço de entrada. A quantidade de endereços IP solicitados é atendida com base na sua organização. Se a solicitação não puder ser atendida, o cluster vai informar um erro.

Fazer upgrade de um cluster do Kubernetes

É possível fazer um upgrade automático ou manual do cluster do Kubernetes. Para mais instruções sobre como fazer upgrade do cluster, consulte a seção Upgrade do cluster.