Esta página foi traduzida pela API Cloud Translation.

Colocar pods do GKE em zonas específicas

Autopilot Standard

Nesta página, mostramos como instruir o Google Kubernetes Engine (GKE) a executar pods em nós em zonas Google Cloud específicas usando a topologia zonal. Esse tipo de posicionamento é útil em situações como as seguintes:

Os pods precisam acessar dados armazenados em um disco permanente zonal do Compute Engine.
Os pods precisam ser executados com outros recursos zonais, como instâncias do Cloud SQL.

Também é possível usar a colocação zonal com roteamento de tráfego com reconhecimento de topologia para reduzir a latência entre clientes e cargas de trabalho. Para detalhes sobre o roteamento de tráfego com reconhecimento de topologia, consulte Roteamento ciente de topologia.

O uso de topologia zonal para controlar a colocação de pods é um mecanismo avançado do Kubernetes que só deve ser usado se a situação exigir que os pods sejam executados em zonas específicas. Na maioria dos ambientes de produção, recomendamos o uso de recursos regionais, que é o padrão do GKE, quando possível.

Métodos de posicionamento por zona

A topologia zonal é integrada ao Kubernetes com o rótulo de nó topology.kubernetes.io/zone: ZONE. Para instruir o GKE a colocar um pod em uma zona específica, use um dos seguintes métodos:

nodeAffinity: especifique uma regra de nodeAffinity na especificação do pod para uma ou mais zonas Google Cloud . Esse método é mais flexível que um nodeSelector porque permite colocar pods em várias zonas.
nodeSelector: especifique um nodeSelector na especificação do pod para uma única zona Google Cloud .
Classes de computação: configure o pod para usar uma classe de computação do GKE. Com essa abordagem, é possível definir uma lista priorizada de conjuntos de Google Cloud zonas. Isso permite que a carga de trabalho seja movida dinamicamente para o conjunto de zonas preferido quando os nós estão disponíveis nessas zonas. Para mais informações, consulte Sobre as classes de computação personalizadas.

Considerações

O posicionamento do pod zonal usando a topologia zonal tem as seguintes considerações:

O cluster precisa estar na mesma região Google Cloud que as zonas solicitadas.
Em clusters padrão, é preciso usar o provisionamento automático de nós ou criar pools de nós com zonas nas zonas solicitadas. Os clusters do Autopilot gerenciam esse processo automaticamente para você.
Os clusters padrão precisam ser regionais.

Preços

A topologia zonal é um recurso de programação do Kubernetes e é oferecida sem nenhum custo extra no GKE.

Para detalhes sobre preços, consulte Preços do GKE.

Antes de começar

Antes de começar, veja se você realizou as seguintes tarefas:

Ative a API Google Kubernetes Engine.

Ativar a API Google Kubernetes Engine

Se você quiser usar a CLI do Google Cloud para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a gcloud CLI anteriormente, instale a versão mais recente executando gcloud components update.
Observação: para instalações atuais da gcloud CLI, defina as propriedades compute/region e compute/zone. Ao definir locais padrão, é possível evitar erros na CLI gcloud, como: One of [--zone, --region] must be supplied: Please specify location.

Verifique se você tem um cluster do GKE na mesma regiãoGoogle Cloud que as zonas em que quer colocar os pods. Para criar um novo cluster, consulte Criar um cluster do Autopilot.

Colocar pods em várias zonas usando nodeAffinity

O nodeAffinity do Kubernetes fornece um mecanismo de controle de programação flexível compatível com vários seletores de rótulos e operadores lógicos. Use nodeAffinity se quiser permitir que os pods sejam executados em uma de um conjunto de zonas (por exemplo, em us-central1-a ou us-central1-f).

Salve o seguinte manifesto como multi-zone-affinity.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-multi-zone
  template:
    metadata:
      labels:
        app: nginx-multi-zone
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: topology.kubernetes.io/zone
                operator: In
                values:
                - us-central1-a
                - us-central1-f

Esse manifesto cria uma implantação com três réplicas e coloca os pods em us-central1-a ou us-central1-f com base na disponibilidade do nó.

Verifique se o cluster está na região us-central1. Se o cluster estiver em uma região diferente, altere as zonas no campo de valores do manifesto para zonas válidas na região do cluster.

Crie a implantação:
```
kubectl create -f multi-zone-affinity.yaml
```
O GKE cria os pods em nós em uma das zonas especificadas. Vários pods podem ser executados no mesmo nó. Opcionalmente, é possível usar a antiafinidade de pods para instruir o GKE a colocar cada pod em um nó separado.

Colocar pods em uma única zona usando um nodeSelector

Para colocar pods em uma única zona, use um nodeSelector na especificação do pod. Um nodeSelector é equivalente a uma regra de nodeAffinity requiredDuringSchedulingIgnoredDuringExecution que tem uma única zona especificada.

Salve o seguinte manifesto como single-zone-selector.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-singlezone
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-singlezone
  template:
    metadata:
      labels:
        app: nginx-singlezone
    spec:
      nodeSelector:
        topology.kubernetes.io/zone: "us-central1-a"
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80

Esse manifesto informa ao GKE para colocar todas as réplicas na implantação na zona us-central1-a.

Crie a implantação:

kubectl create -f single-zone-selector.yaml

Priorizar a colocação de pods em zonas selecionadas usando uma classe de computação

As classes de computação do GKE oferecem um mecanismo de controle que permite definir uma lista de prioridades de configuração de nós. Com as preferências zonais, você define as zonas em que quer que o GKE coloque os pods. Para definir preferências zonais em classes de computação, é necessário o GKE versão 1.33.1-gke.1545000 ou mais recente.

O exemplo a seguir cria uma classe de computação que especifica uma lista de zonas preferenciais para pods.

Nestas etapas, presumimos que o cluster está na região us-central1. Se o cluster estiver em uma região diferente, altere os valores das zonas no manifesto para zonas válidas na região do cluster.

Salve o seguinte manifesto como zones-custom-compute-class.yaml:
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: zones-custom-compute-class
spec:
  priorities:
  - location:
    zones: [us-central1-a, us-central1-b]
  - location:
    zones: [us-central1-c]
  activeMigration:
    optimizeRulePriority: true
  nodePoolAutoCreation:
    enabled: true
  whenUnsatisfiable: ScaleUpAnyway
```
O manifesto da classe de computação muda o comportamento de escalonamento da seguinte maneira:
1. O GKE tenta colocar os pods em us-central1-a ou em us-central1-b.
2. Se us-central1-a e us-central1-b não tiverem capacidade disponível, o GKE tentará colocar pods em us-central1-c.
3. Se us-central1-c não tiver capacidade disponível, o campo whenUnsatisfiable: ScaleUpAnyway fará com que o GKE coloque os pods em qualquer zona disponível na região.
4. Se uma zona com maior prioridade na classe de computação ficar disponível depois, o campo activeMigration.optimizeRulePriority: true fará com que o GKE mova os pods para essa zona de qualquer zona de prioridade inferior. Essa migração usa o orçamento de interrupção do pod para garantir a disponibilidade do serviço.
Crie a classe de computação personalizada:
```
kubectl create -f zones-custom-compute-class.yaml
```
O GKE cria uma classe de computação personalizada que pode ser referenciada pelas suas cargas de trabalho.

Salve o seguinte manifesto como custom-compute-class-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-zonal-preferences
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-zonal-preferences
  template:
    metadata:
      labels:
        app: nginx-zonal-preferences
    spec:
      nodeSelector:
        cloud.google.com/compute-class: "zones-custom-compute-class"
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80

Crie a implantação:

kubectl create -f custom-compute-class-deployment.yaml

Verificar o posicionamento do pod

Para verificar o posicionamento do pod, liste os pods e verifique os rótulos dos nós. Vários pods podem ser executados em um único nó. Portanto, talvez você não veja pods espalhados por várias zonas se tiver usado nodeAffinity.

Liste os pods:
```
kubectl get pods -o wide
```
A saída é uma lista de pods em execução e o nó do GKE correspondente.

Descreva os nós:

kubectl describe node NODE_NAME | grep "topology.kubernetes.io/zone"

Substitua NODE_NAME pelo nome do nó.

O resultado será assim:

topology.kubernetes.io/zone: us-central1-a

Se você quiser que o GKE distribua os pods uniformemente entre várias zonas para melhorar o failover em vários domínios de falha, use topologySpreadConstraints.