Como fazer implementações graduais

Nesta página, explicamos como executar upgrades contínuos de aplicativos no Kubernetes Engine.

Visão geral

Você pode executar um upgrade contínuo para atualizar imagens, configuração, marcadores, anotações e limites/solicitações de recursos das cargas de trabalho nos clusters. Os upgrades contínuos substituem gradualmente os pods do recurso por outros novos, que são agendados em nós com recursos disponíveis. Os upgrades contínuos foram projetados para atualizar as cargas de trabalho sem inatividade.

Os objetos a seguir representam cargas de trabalho do Kubernetes. Você pode acionar uma atualização contínua nessas cargas de trabalho atualizando o modelo de pod:

  • DaemonSets
  • Implantações
  • StatefulSets

Cada um desses objetos tem um modelo de Pod, representado pelo campo spec: template no respectivo manifesto. O campo do modelo do pod contém uma especificação criada pelo controlador para perceber o estado ou o comportamento desejado para os pods. Atualize o spec: template do objeto para acionar uma implementação.

O modelo de pod inclui os campos a seguir:

Para saber mais sobre o modelo de pod, consulte a documentação de PodTemplateSpec.

Escalonar um recurso ou atualizar campos fora do modelo de pod não aciona uma implementação.

Antes de começar

Prepare-se para a tarefa tomando as seguintes medidas:

  • Verifique se você ativou a API Google Kubernetes Engine.
  • Ativar a API Google Kubernetes Engine
  • Verifique se o SDK do Cloud está instalado.
  • Defina o código do projeto padrão:
    gcloud config set project [PROJECT_ID]
  • Se você estiver trabalhando com clusters zonais, defina a zona de computação padrão:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Se você estiver trabalhando com clusters regionais, defina a região de computação padrão:
    gcloud config set compute/region [COMPUTE_REGION]
  • Atualize a gcloud para a versão mais recente:
    gcloud components update

Como atualizar um aplicativo

A seção a seguir explica como atualizar um aplicativo usando o Console do Google Cloud Platform ou o kubectl.

kubectl set

Use kubectl set para fazer alterações em image, resources (de recurso de computação, como CPU e memória) de um objeto ou nos campos selector.

Por exemplo, para atualizar uma implantação do nginx versão 1.7.9 para 1.9.1, execute o comando a seguir:

kubectl set image deployment nginx nginx=nginx:1.9.1

O comando kubectl set image atualiza a imagem nginx dos pods da implantação, um de cada vez.

Como outro exemplo, para definir os limites e as solicitações de recurso da implantação:

kubectl set resources deployment nginx --limits cpu=200m,memory=512Mi --requests cpu=100m,memory=256Mi

Ou para remover as solicitações de recurso da implantação:

kubectl set resources deployment nginx --limits cpu=0,memory=0 --requests cpu=0,memory=0

kubectl apply

Use kubectl apply para atualizar um objeto aplicando um arquivo de manifesto novo ou atualizado.

Para aplicar um novo arquivo de manifesto, execute o comando abaixo:

kubectl apply -f [MANIFEST]

em que [MANIFEST] é o arquivo de manifesto atualizado.

Console

Para editar a configuração em tempo real de um aplicativo, siga as etapas a seguir:

  1. Acesse o menu "Cargas de trabalho" do Google Kubernetes Engine no Console do GCP.

    Acessar o menu "Cargas de trabalho"

  2. Selecione a carga de trabalho desejada.

  3. Clique em Editar.

  4. Use o editor para fazer as mudanças desejadas nos rótulos do objeto ou no modelo de pod.

  5. Clique em Salvar.

Como gerenciar uma implementação de atualização

Use kubectl rollout para inspecionar uma distribuição conforme ela ocorre, pausá-la e retomá-la, reverter uma atualização e ver o histórico da distribuição de um objeto.

Como inspecionar uma implementação com kubectl rollout status

Você pode inspecionar o status de uma implementação usando o comando kubectl rollout status.

Por exemplo, você pode inspecionar a implementação da implantação do nginx executando o comando abaixo:

kubectl rollout status deployment nginx

O resultado será semelhante a:

Waiting for rollout to finish: 2 out of 3 new replicas have been updated...
deployment "nginx" successfully rolled out

Depois que a implementação for bem-sucedida, execute kubectl get deployment nginx para verificar se todos os pods dela estão sendo executados. O resultado será semelhante a:

NAME               DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
nginx              3         3         3            3           36s

Como pausar e retomar uma implementação

Use kubectl rollout pause para pausar uma implementação.

Por exemplo, para pausar a implementação da implantação do nginx, execute o comando abaixo:

kubectl rollout pause deployment nginx

Para continuar, execute o comando abaixo:

kubectl rollout resume deployment nginx

Como visualizar o histórico de implementação com kubectl rollout history

Você pode usar kubectl rollout history para visualizar o histórico de implementação de um objeto.

Por exemplo, para visualizar o histórico de implementação da implantação do nginx, execute o comando abaixo:

kubectl rollout history deployment nginx

Para consultar o histórico da terceira revisão, execute o comando abaixo:

kubectl rollout history deployment nginx --revision 3

Reverter uma atualização com kubectl rollout undo

Você pode reverter a implementação de um objeto usando o comando kubectl rollout undo.

Por exemplo, para voltar à versão anterior da implantação do nginx, execute o comando abaixo:

kubectl rollout undo deployments nginx

Ou, como outro exemplo, para reverter para a terceira revisão da implantação, execute o comando abaixo:

kubectl rollout undo deployment nginx --to-revision 3

Considerações sobre StatefulSets e DaemonSets

O StatefulSets, desde o Kubernetes 1.7, e o DaemonSets, desde o Kubernetes 1.6, usam uma estratégia de atualização para configurar e desativar upgrades contínuos e automáticos para contêineres, marcadores, limites e solicitações de recursos e anotações para os pods. A estratégia de atualização é configurada usando o campo updateStrategy.

O campo updateStrategy aceita OnDelete ou RollingUpdate como valores.

OnDelete é o comportamento padrão quando updateStrategy não está especificado. OnDelete impede o controlador de atualizar automaticamente os pods. É necessário excluir manualmente os pods para fazer com que o controlador crie novos pods que reflitam suas mudanças. OnDelete é útil se você preferir atualizar os pods manualmente.

RollingUpdate implementa atualizações contínuas e automáticas nos pods no StatefulSet. RollingUpdate faz com que o controlador exclua e recrie cada um dos pods, e um pod de cada vez. Ele espera até que um pod atualizado esteja em execução e pronto antes para atualizar o antecessor.

O controlador do StatefulSet atualiza todos os pods em ordem numérica inversa, respeitando as garantias dele.

Como usar a estratégia RollingUpdate

Você pode usar a estratégia RollingUpdate para atualizar automaticamente todos os pods em um StatefulSet ou DaemonSet.

Por exemplo, para corrigir o StatefulSet web para aplicar a estratégia RollingUpdate, execute o comando abaixo:

kubectl patch statefulset web -p '{"spec":{"updateStrategy":{"type":"rollingUpdate"}}}'

Em seguida, faça uma alteração no spec.template do StatefulSet. Por exemplo, você pode usar kubectl set para alterar a imagem do contêiner. No exemplo a seguir, o StatefulSet web está configurado para que o contêiner nginx execute a imagem nginx-slim:0.7:

kubectl set image statefulset web nginx=nginx-slim:0.7

Para verificar se os pods no StatefulSet em execução no container nginx estão atualizando, execute o comando abaixo:

kubectl get pods -l app=nginx -w

O resultado será semelhante a:

NAME      READY     STATUS    RESTARTS   AGE
web-0     1/1       Running   0          7m
web-1     1/1       Running   0          7m
web-2     1/1       Running   0          8m
web-2     1/1       Terminating   0         8m
web-2     1/1       Terminating   0         8m
web-2     0/1       Terminating   0         8m
web-2     0/1       Terminating   0         8m
web-2     0/1       Terminating   0         8m
web-2     0/1       Terminating   0         8m
web-2     0/1       Pending   0         0s
web-2     0/1       Pending   0         0s
web-2     0/1       ContainerCreating   0         0s
web-2     1/1       Running   0         19s
web-1     1/1       Terminating   0         8m
web-1     0/1       Terminating   0         8m
web-1     0/1       Terminating   0         8m
web-1     0/1       Terminating   0         8m
web-1     0/1       Pending   0         0s
web-1     0/1       Pending   0         0s
web-1     0/1       ContainerCreating   0         0s
web-1     1/1       Running   0         6s
web-0     1/1       Terminating   0         7m
web-0     1/1       Terminating   0         7m
web-0     0/1       Terminating   0         7m
web-0     0/1       Terminating   0         7m
web-0     0/1       Terminating   0         7m
web-0     0/1       Terminating   0         7m
web-0     0/1       Pending   0         0s
web-0     0/1       Pending   0         0s
web-0     0/1       ContainerCreating   0         0s
web-0     1/1       Running   0         10s

Os pods no StatefulSet são atualizados em ordem numeral inversa. O controlador do StatefulSet encerra cada pod e espera que ele fique em execução e pronto antes de atualizar o próximo.

Como particionar um RollingUpdate

Você pode especificar um campo RollingUpdate do StatefulSet para um parâmetro partition.

Se você especificar um partition, todos os pods com um número ordinal maior ou igual ao valor da partition serão atualizados. Nenhum pod com um número ordinal inferior ao valor do partition é atualizado e, mesmo que eles sejam excluídos, são recriados na versão anterior.

Se um valor de partition for maior do que o número de replicas dele, as atualizações não serão propagadas para os pods. O particionamento é útil se você quer fazer uma atualização, implementar um canário ou executar uma implementação gradual.

Por exemplo, para particionar o StatefulSet web, execute o comando abaixo:

kubectl patch statefulset web -p '{"spec":{"updateStrategy":{"type":"RollingUpdate","rollingUpdate":{"partition":3}}}}'

Isso faz com que pods com um número ordinal maior ou igual a 3 sejam atualizados.

Parâmetro maxUnavailable do DaemonSet

O parâmetro opcional maxUnavailable do DaemonSet é um filho do campo rollingUpdate dele.

O maxUnavailable determina o número máximo de pods do DaemonSet que podem não estar disponíveis durante as atualizações. O valor padrão, se omitido, é 1. O valor não pode ser 0. O valor pode ser um número absoluto ou uma porcentagem.

Como atualizar com a estratégia OnDelete

Se você preferir atualizar um StatefulSet ou DaemonSet manualmente, é possível omitir o campo updateStrategy, que instrui o controlador a usar a estratégia OnDelete.

Para atualizar um controlador que usa a estratégia OnDelete, é necessário excluir manualmente os pods dele depois de fazer alterações no modelo de pod.

Por exemplo, você pode configurar o StatefulSet web para usar a imagem nginx-slim:0.7:

kubectl set image statefulset web nginx=nginx-slim:0.7

Em seguida, para excluir o primeiro pod web, execute o comando a seguir:

kubectl delete pod web-0

Para acompanhar conforme o pod é recriado pelo StatefulSet e fica em execução e pronto, execute o comando a seguir:

kubectl get pod web-0 -w

A saída deste comando é semelhante a:

NAME      READY     STATUS               RESTARTS   AGE
web-0     1/1       Running              0          54s
web-0     1/1       Terminating          0         1m
web-0     0/1       Terminating          0         1m
web-0     0/1       Terminating          0         1m
web-0     0/1       Terminating          0         1m
web-0     0/1       Pending              0         0s
web-0     0/1       Pending              0         0s
web-0     0/1       ContainerCreating    0         0s
web-0     1/1       Running              0         3s

Como atualizar um job

Quando você atualiza a configuração de um job, o novo job e os pods dele são executados com a nova configuração. Depois de atualizar um job, é necessário excluir manualmente o job antigo e os pods dele, se você quiser.

Para excluir um job e todos os respectivos pods, execute o comando a seguir:

kubectl delete job my-job

Para excluir um job, mas manter os respectivos pods em execução, especifique a sinalização --cascade false:

kubectl delete job my-job --cascade false

Você também pode executar kubectl describe deployment nginx, que produz ainda mais informações sobre a implantação.

Próximas etapas

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Documentação do Kubernetes Engine