Trabalhando com cargas de trabalho do Kubernetes

Descobrindo implementações

Objectives

After completing this lesson, you will be able to:
  • Identificar os benefícios do uso de implementações
  • Descrever o manifesto de implementação
  • Escolha estratégias de implementação apropriadas
  • Saiba como usar a funcionalidade de histórico de implementação
  • Entenda como escalar as implementações

Apresentando implantações e seus benefícios

Síntese

Já introduzimos Implementações como abstrações de nível superior de ReplicaSets. Você pode utilizar Implementações para definir o estado desejado da sua aplicação de forma declarativa. Isso inclui o número de réplicas, as imagens do container e outras configurações. Implementações gerenciam ReplicaSets e ReplicaSets gerenciam Pods.

Um diagrama de arquitetura do Kubernetes mostrando uma Implantação gerenciando um ReplicaSet, que por sua vez gerencia três Pods. Cada Pod contém um container principal e um container Sidecar.

Benefícios das implementações

Considere o seguinte cenário: Você criou manualmente um Pod para um aplicativo com a versão 1.0.0. Depois de algum tempo, você deseja atualizar o aplicativo para a versão 1.0.1. Para isso, você deve criar um novo Pod com base na nova imagem, atualizar o serviço para apontar para o novo Pod e excluir o Pod antigo. Este é um monte de trabalho manual propenso a erros.

É aqui que entram em cena as Implementações para automatizar esse processo. Você pode usar Implementações para definir declarativamente o novo estado desejado do aplicativo e implementar a nova versão de forma confiável, sem causar nenhum tempo de inatividade do aplicativo atualmente em execução.

Clique nos botões abaixo para descobrir os principais benefícios das Implantações.

O manifesto de implementação

Uma vez que uma implementação gerencia o ReplicaSet, que, por sua vez, gerencia os Pods, o manifesto Deployment é muito semelhante ao manifesto ReplicaSet. No entanto, o manifesto Implementação utiliza campos e objetos específicos de implementação, por exemplo, o objeto strategy.

Code Snippet
12345678910111213141516171819
apiVersion: apps/v1 kind: Deployment metadata: name: hello-kyma spec: replicas: 3 selector: matchLabels: app: hello-kyma template: # Pod template metadata: labels: app: hello-kyma spec: containers: - name: hello-kyma image: ghcr.io/sap-samples/kyma-runtime-learning-journey/hello-kyma:1.0.0 ports: - containerPort: 8080

Este exemplo mostra um manifesto de implementação com o nome hello-kyma.

A implementação tem três réplicas e o modelo de pod utiliza a etiqueta app: hello-kyma. O modelo de Pod tem um contêiner com o nome hello-kyma e a imagem hello-kyma:1.0.0 extraída do GitHub Container Registry (ghcr.io). O recipiente expõe a porta: 8080.

Vejamos detalhadamente a seção spec do manifesto de implementação:.

A seção Especificação da implementação em detalhes

CampoDescriçãoObrigatórioValores possíveis
RéplicasO número de réplicas da aplicação.SimNúmero inteiro
SeletorO seletor para identificar os Pods gerenciados pela implementação.SimPelo menos um subconjunto das etiquetas definidas no modelo de pod.
ModeloO modelo de Pod utilizado para criar os pods administrados pela implementação.SimEtiquetas de pod e manifesto Pod.

Se quiser extrair a imagem de um registro privado, você pode fazer isso fornecendo as credenciais no campo spec.template.spec do manifesto Implantação:

Code Snippet
12345678910111213
... spec: ... template: ... spec: imagePullSecrets: - name: myregistrykey containers: - name: hello-kyma image: ghcr.io/sap-samples/kyma-runtime-learning-journey/hello-kyma:1.0.0 ports: - containerPort: 8080

Em relação ao objeto containers do modelo Pod, são recomendados os seguintes atributos:

Atributos recomendados no objeto de containers

CampoDescriçãoObrigatórioValores possíveis
NomeO nome do container.SimCadeia
ImagemA imagem do contêiner.SimCadeia
RecursosOs recursos do container.NãoNecessidades de recursos
ImagePullPolicyA política de pull de imagem.NãoAlways, IfNotPresent, Never
PortasAs portas do container.NãoPortas de container

Por padrão, o ImagePullPolicy está definido como IfNotPresent. Isso significa que a imagem só é puxada se não estiver presente localmente no nó do cluster. Se você quiser sempre puxar a imagem, pode definir o ImagePullPolicy como Always.

Nota

Se você especificar uma imagem com a tag latest e você ou o sistema criar um novo Pod, o Kubernetes sempre baixará a versão mais recente do latest. Isso pode levar a um comportamento inesperado, uma vez que outros pods ainda podem usar a imagem antiga. Por isso, recomenda-se a utilização de uma versão específica da imagem, por exemplo, hello-kyma:1.0.0.

Veja um exemplo de manifesto de implementação:

Code Snippet
1234567891011121314151617181920212223242526272829
apiVersion: apps/v1 kind: Deployment metadata: name: hello-kyma labels: app.kubernetes.io/name: hello-kyma spec: replicas: 3 selector: matchLabels: app: hello-kyma template: metadata: labels: app: hello-kyma spec: imagePullSecrets: [ ] containers: - name: hello-kyma image: 'ghcr.io/sap-samples/kyma-runtime-learning-journey/hello-kyma:1.0.0' resources: requests: memory: 64Mi # 64MiB (2^26 bytes) cpu: 50m # 50 millicores (1/20th of a core), 500m = 0.5 cores limits: memory: 128Mi cpu: 100m # 100 millicores (1/10th of a core), 1000m = 1 core ports: - containerPort: 8080

Para todos os outros campos, consulte a documentação de Implementação do Kubernetes.

Estratégias de implementação avançada

O Kubernetes suporta as duas estratégias de implementação seguintes:

Estratégias de implementação suportadas

EstratégiaExplicaçãoComentário
Atualização contínuaA estratégia padrão. A nova versão da aplicação é implementada de forma contínua. Durante um lançamento, os Pods novos substituem incrementalmente os Pods antigos. O Kubernetes espera que os novos Pods comecem antes de remover os antigos.Quando você deseja atualizar seu aplicativo sem tempo de inatividade.
RecriarA nova versão do aplicativo é implementada excluindo primeiro todos os pods da versão atual e, em seguida, criando os pods da nova versão.Quando você deseja ou pode atualizar seu aplicativo com tempo de inatividade.

Você pode indicar a estratégia de implementação no manifesto Implementação:

YAML
123456789101112131415161718192021222324
apiVersion: apps/v1 kind: Deployment metadata: name: hello-kyma spec: replicas: 3 selector: matchLabels: app: hello-kyma template: metadata: labels: app: hello-kyma spec: containers: - name: hello-kyma image: ghcr.io/sap-samples/kyma-runtime-learning-journey/hello-kyma:1.0.0 ports: - containerPort: 8080 strategy: type: RollingUpdate rollingUpdate: maxSurge: 25% maxUnavailable: 25%

Para o campo strategy.type, você pode especificar RollingUpdate ou Recreate. Uma vez que o RollingUpdate é a estratégia padrão e recomendada, é o foco desta lição.

Como mencionado, a estratégia RollingUpdate não exclui os pods antigos antes de criar os novos. Em vez disso, ele executa a atualização de forma contínua. Você pode definir exatamente a porcentagem de pods que podem ser atualizados ao mesmo tempo. Para isso, use os campos maxSurge e maxUnavailable:

  • O campo maxSurge define o número máximo de pods que podem ser criados acima do número desejado de pods.
  • O campo maxUnavailable define o número máximo de pods que podem estar indisponíveis durante a atualização.

Os valores propostos para ambos os campos são 25%. Com isso, os Pods antigos ainda recuperam o tráfego, enquanto você já está criando e servindo os novos Pods.

Nota

Atender duas versões de um aplicativo simultaneamente, por trás do mesmo serviço, também vem com alguns desafios. Por exemplo, você deve garantir que a nova versão da aplicação é compatível com a antiga. Esse requisito é conhecido como Compatibilidade de API. É altamente recomendado ter um conceito de criação de versões para suas APIs, de modo que elas sejam compatíveis com versões progressiva e regressiva.

Histórico de implementação

Cada implementação também contém um histórico de implementação completo. Isso permite que você reverta para uma versão anterior do seu aplicativo se algo der errado.

Você pode usar kubectl para verificar o histórico de implementação de uma Implementação:

Code Snippet
1
kubectl rollout history deployment hello-kyma

Para reverter para uma versão anterior do aplicativo, você pode usar o comando kubectl rollout undo:

Code Snippet
1
kubectl rollout undo deployment hello-kyma

Escalonamento de implementações

Você pode dimensionar sua implementação simplesmente atualizando o campo réplicas no manifesto de implementação. Da mesma forma, você também pode usar o kubectl para dimensionar sua implantação:

Code Snippet
1
kubectl scale deployment hello-kyma --replicas=5

A execução do comando atualiza o ReplicaSet subjacente e cria dois novos Pods. Você pode verificar isso usando:

Code Snippet
1
kubectl get deployments hello-kyma

A saída tem o seguinte aspecto:

Uma tabela com colunas: NAME, READY, UP-TO-DATE, AVAILABLE e AGE. Os dados da linha são: hello-kyma, 5/5, 5, 5 e 18h respectivamente.

Síntese

Implementações no Kubernetes são abstrações de alto nível de Pods e ReplicaSets, permitindo que você defina declarativamente o estado desejado do seu aplicativo. As implementações automatizam processos como atualizações e rollbacks, reduzindo o trabalho manual e possíveis erros. Eles suportam duas estratégias de implementação principais: Atualização contínua para atualizações de tempo de inatividade zero e Recriar para atualizações que toleram tempo de inatividade. Além disso, as implementações mantêm um histórico de alterações, permitindo que você reverta facilmente para uma versão anterior, se necessário, e pode ser escalada perfeitamente ajustando o número de réplicas.

Leitura adicional sobre a implementação do Kubernetes