Tutorial passo a passo: Criar Ku­ber­ne­tes De­ploy­ment

A criação bem-sucedida de um Ku­ber­ne­tes De­ploy­ment é fun­da­men­tal para gerenciar apli­ca­ções de contêiner com efi­ci­ên­cia. Neste tutorial, apre­sen­ta­re­mos o passo a passo e as melhores práticas para criar um De­ploy­ment robusto no ambiente do Ku­ber­ne­tes.

O que é Ku­ber­ne­tes De­ploy­ment?

Ku­ber­ne­tes De­ploy­ment é um conceito essencial dentro da pla­ta­forma Ku­ber­ne­tes que sim­pli­fica a im­ple­men­ta­ção e o ge­ren­ci­a­mento de apli­ca­ções em con­têi­ne­res. Esse mecanismo de controle age como um in­ter­me­diá­rio entre a con­fi­gu­ra­ção e a execução no cluster do Ku­ber­ne­tes. O usuário determina o estado desejado de suas apli­ca­ções, incluindo detalhes de re­pli­ca­ção, imagens de contêiner e de­fi­ni­ções de con­fi­gu­ra­ção.

Em seguida, o Ku­ber­ne­tes De­ploy­ment assume a im­ple­men­ta­ção au­to­ma­ti­zada, organiza con­têi­ne­res em pods no Ku­ber­ne­tes e os distribui pelos recursos dis­po­ní­veis no cluster. O mecanismo também pos­si­bi­lita executar atu­a­li­za­ções graduais e minimizar o tempo de ina­ti­vi­dade. Funções de es­ca­lo­na­mento au­to­má­tico asseguram o ajuste dinâmico do número de ins­tân­cias em execução com base na carga atual.

A criação de um Ku­ber­ne­tes De­ploy­ment é realizada com um dos métodos básicos:

• Método im­pe­ra­tivo
• Método de­cla­ra­tivo

Como criar Ku­ber­ne­tes De­ploy­ment pelo método im­pe­ra­tivo

No método im­pe­ra­tivo, o usuário insere comandos es­pe­cí­fi­cos para realizar as ações desejadas. Isso pode incluir a criação de recursos, como pods e serviços, ou atu­a­li­za­ção de con­fi­gu­ra­ções. O método im­pe­ra­tivo é adequado para re­qui­si­tos si­tu­a­ci­o­nais ou ex­pe­ri­men­tais.

O comando a seguir cria um Ku­ber­ne­tes De­ploy­ment chamado nginx-deployment e o configura para im­ple­men­tar um servidor web Nginx em um contêiner da imagem oficial do Nginx na porta 80.

$ kubectl create deployment nginx-deployment --image nginx --port=80

Embora a im­ple­men­ta­ção do método im­pe­ra­tivo seja rápida, ela também tem algumas des­van­ta­gens. As etapas da abordagem im­pe­ra­tiva têm ligação direta com o status atual, o que pode di­fi­cul­tar a repetição de ações. Isso significa que a execução do mesmo comando nem sempre produz o mesmo resultado, es­pe­ci­al­mente se o status inicial tiver mudado.

Como criar Ku­ber­ne­tes De­ploy­ment pelo método de­cla­ra­tivo

Se comparado ao método im­pe­ra­tivo, o método de­cla­ra­tivo segue uma abordagem mais abstrata. O usuário define o estado desejado para a aplicação em um arquivo de con­fi­gu­ra­ção, e o Ku­ber­ne­tes assegura que o cluster atenda a ele. Basta descrever o que você deseja que seja feito e a pla­ta­forma assumirá sua im­ple­men­ta­ção e ma­nu­ten­ção.

Passo 1: Criar arquivo de con­fi­gu­ra­ção YAML

Primeiro, abra um editor de texto e crie o arquivo YAML nginx-deployment.yaml para definir a con­fi­gu­ra­ção do Ku­ber­ne­tes De­ploy­ment:

apiVersion: apps/v1 
kind: Deployment 
metadata: 
    name: nginx-deployment 
spec: 
    replicas: 3 
    selector: 
        matchLabels: 
            app: nginx 
    template: 
        metadata: 
            labels: 
                app: nginx 
        spec: 
            containers: 
            - name: nginx-container 
                image: nginx 
                ports: 
                - containerPort: 80

Na seção spec, você es­pe­ci­fica a con­fi­gu­ra­ção desejada. Em replicas: 3, definimos que o de­ploy­ment deve criar três réplicas (pods) da aplicação. A opção selector define como os pods são se­le­ci­o­na­dos. Nela, app=nginx atua como o critério de seleção. A seção template indica o modelo usado na criação dos pods, incluindo suas marcações (labels). Em containers, o contêiner nginx-container é con­fi­gu­rado usando a imagem do Nginx e escutando a porta 80.

Passo 2: Aplicar con­fi­gu­ra­ções ao cluster

Insira o seguinte na linha de comando para aplicar as con­fi­gu­ra­ções ao cluster:

kubectl apply -f nginx-deployment.yaml

A opção -f es­pe­ci­fica o caminho para o arquivo YAML ou JSON que contém a con­fi­gu­ra­ção dos recursos do Ku­ber­ne­tes.

Passo 3: Verificar status do De­ploy­ment

Este passo informa se o Ku­ber­ne­tes De­ploy­ment foi criado com sucesso e quantos pods estão dis­po­ní­veis no momento.

kubectl get deployments nginx-deployment

O resultado mostrará o seguinte:

NAME                            READY   UP-TO-DATE   AVAILABLE   AGE 
nginx-deployment         3/3              3                         3           2m

• READY: Informa o número de pods em execução em relação ao número desejado.
• UP-TO-DATE: Informa o número de pods que foram atu­a­li­za­dos com a última con­fi­gu­ra­ção.
• AVAILABLE: Lista o número de pods que estão dis­po­ní­veis e que aceitam so­li­ci­ta­ções.
• AGE: Indica há quanto tempo o De­ploy­ment está em execução.

Passo 4: Exibir in­for­ma­ções adi­ci­o­nais

O comando a seguir apresenta in­for­ma­ções de­ta­lha­das sobre o seu Ku­ber­ne­tes De­ploy­ment, as es­tra­té­gias usadas, as réplicas atuais e as desejadas e os rótulos do seletor.

kubectl describe deployment nginx-deployment

O resultado é o seguinte:

Name:                               nginx-deployment 
Namespace:                    default 
CreationTimestamp:      Thu, 22 Feb 2024 12:34:56 +0000 
Labels:                              <none> 
Annotations:                   deployment.kubernetes.io/revision: 1 
Selector:                           app=nginx 
Replicas:                           3 desired | 3 updated | 3 total | 3 available | 0 unavailable 
StrategyType:                  RollingUpdate 
MinReadySeconds:         0 
RollingUpdateStrategy:  25% max unavailable, 25% max surge

A es­tra­té­gia de atu­a­li­za­ção foi con­fi­gu­rada como Rolling Update, com o máximo de 25% de in­dis­po­ni­bi­li­dade e um aumento de até 25% de pods adi­ci­o­nais durante uma atu­a­li­za­ção.

Passo 5: Escalonar De­ploy­ment

Para ajustar o número de pods em um Ku­ber­ne­tes De­ploy­ment, use o comando kubectl scale.

kubectl scale deployment nginx-deployment --replicas=2

Após executar esse comando, o Ku­ber­ne­tes atu­a­li­zará o De­ploy­ment e garantirá que o número desejado de réplicas fique dis­po­ní­vel. No nosso exemplo, reduzimos o número de pods em execução para 2.

Es­tra­té­gias com Ku­ber­ne­tes De­ploy­ment

As es­tra­té­gias que usam o Ku­ber­ne­tes De­ploy­ment definem a forma como as mudanças em uma aplicação são im­ple­men­ta­das no cluster.

• Rolling De­ploy­ment (padrão): Esse é o método padrão para os De­ploy­ments no Ku­ber­ne­tes. Novos pods são im­ple­men­ta­dos em estágios, enquanto os antigos são removidos gra­du­al­mente. Esse processo assegura dis­po­ni­bi­li­dade contínua durante o processo de atu­a­li­za­ção.
• Recreate De­ploy­ment: Com essa es­tra­té­gia, todos os pods exis­ten­tes são removidos primeiro. Em seguida, os pods atu­a­li­za­dos são iniciados. Esse método pode resultar em uma in­ter­rup­ção tem­po­rá­ria do serviço, pois nenhum pod fica dis­po­ní­vel durante o processo de recriação.
• Blue/Green De­ploy­ment: Nesse método, dois conjuntos de pods (azul e verde) são criados. Um deles re­pre­senta a versão atual da aplicação, enquanto o outro traz a nova versão. Ao atribuir labels es­pe­cí­fi­cas a esses pods, o tráfego é re­di­re­ci­o­nado de maneira segura entre as duas versões. Isso permite alternar ra­pi­da­mente entre ambas e reverter mudanças com fa­ci­li­dade.

Reverter Ku­ber­ne­tes De­ploy­ment

Se um erro ocorrer na versão mais recente da sua aplicação, é crucial reverter as al­te­ra­ções o mais rápido possível. No Ku­ber­ne­tes, você pode iniciar o processo de reversão ao verificar o histórico de revisões do seu De­ploy­ment e retornar a uma versão anterior, se ne­ces­sá­rio.

Verificar histórico de revisões

Para exibir o histórico de revisões do seu De­ploy­ment, use o comando a seguir:

kubectl rollout history deployment/nginx-deployment

Reverter para versão anterior

Este comando realiza a reversão para a versão anterior con­si­de­rada estável:

kubectl rollout undo deployment/nginx-deployment

Reverter para versão es­pe­cí­fica

Se você quer retornar a uma versão es­pe­cí­fica, insira o comando a seguir e o número da revisão desejada:

kubectl rollout undo deployment/nginx-deployment --to-revision=1