Tutorial passo a passo: Criar Kubernetes Deployment

A criação bem-sucedida de um Kubernetes Deployment é fundamental para gerenciar aplicações de contêiner com eficiência. Neste tutorial, apresentaremos o passo a passo e as melhores práticas para criar um Deployment robusto no ambiente do Kubernetes.

O que é Kubernetes Deployment?

Kubernetes Deployment é um conceito essencial dentro da plataforma Kubernetes que simplifica a implementação e o gerenciamento de aplicações em contêineres. Esse mecanismo de controle age como um intermediário entre a configuração e a execução no cluster do Kubernetes. O usuário determina o estado desejado de suas aplicações, incluindo detalhes de replicação, imagens de contêiner e definições de configuração.

Em seguida, o Kubernetes Deployment assume a implementação automatizada, organiza contêineres em pods no Kubernetes e os distribui pelos recursos disponíveis no cluster. O mecanismo também possibilita executar atualizações graduais e minimizar o tempo de inatividade. Funções de escalonamento automático asseguram o ajuste dinâmico do número de instâncias em execução com base na carga atual.

A criação de um Kubernetes Deployment é realizada com um dos métodos básicos:

• Método imperativo
• Método declarativo

Como criar Kubernetes Deployment pelo método imperativo

No método imperativo, o usuário insere comandos específicos para realizar as ações desejadas. Isso pode incluir a criação de recursos, como pods e serviços, ou atualização de configurações. O método imperativo é adequado para requisitos situacionais ou experimentais.

O comando a seguir cria um Kubernetes Deployment chamado nginx-deployment e o configura para implementar 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 implementação do método imperativo seja rápida, ela também tem algumas desvantagens. As etapas da abordagem imperativa têm ligação direta com o status atual, o que pode dificultar a repetição de ações. Isso significa que a execução do mesmo comando nem sempre produz o mesmo resultado, especialmente se o status inicial tiver mudado.

Como criar Kubernetes Deployment pelo método declarativo

Se comparado ao método imperativo, o método declarativo segue uma abordagem mais abstrata. O usuário define o estado desejado para a aplicação em um arquivo de configuração, e o Kubernetes assegura que o cluster atenda a ele. Basta descrever o que você deseja que seja feito e a plataforma assumirá sua implementação e manutenção.

Passo 1: Criar arquivo de configuração YAML

Primeiro, abra um editor de texto e crie o arquivo YAML nginx-deployment.yaml para definir a configuração do Kubernetes Deployment:

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ê especifica a configuração desejada. Em replicas: 3, definimos que o deployment deve criar três réplicas (pods) da aplicação. A opção selector define como os pods são selecionados. 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 é configurado usando a imagem do Nginx e escutando a porta 80.

Passo 2: Aplicar configurações ao cluster

Insira o seguinte na linha de comando para aplicar as configurações ao cluster:

kubectl apply -f nginx-deployment.yaml

A opção -f especifica o caminho para o arquivo YAML ou JSON que contém a configuração dos recursos do Kubernetes.

Passo 3: Verificar status do Deployment

Este passo informa se o Kubernetes Deployment foi criado com sucesso e quantos pods estão disponí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 atualizados com a última configuração.
• AVAILABLE: Lista o número de pods que estão disponíveis e que aceitam solicitações.
• AGE: Indica há quanto tempo o Deployment está em execução.

Passo 4: Exibir informações adicionais

O comando a seguir apresenta informações detalhadas sobre o seu Kubernetes Deployment, as estraté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 estratégia de atualização foi configurada como Rolling Update, com o máximo de 25% de indisponibilidade e um aumento de até 25% de pods adicionais durante uma atualização.

Passo 5: Escalonar Deployment

Para ajustar o número de pods em um Kubernetes Deployment, use o comando kubectl scale.

kubectl scale deployment nginx-deployment --replicas=2

Após executar esse comando, o Kubernetes atualizará o Deployment e garantirá que o número desejado de réplicas fique disponível. No nosso exemplo, reduzimos o número de pods em execução para 2.

Estratégias com Kubernetes Deployment

As estratégias que usam o Kubernetes Deployment definem a forma como as mudanças em uma aplicação são implementadas no cluster.

• Rolling Deployment (padrão): Esse é o método padrão para os Deployments no Kubernetes. Novos pods são implementados em estágios, enquanto os antigos são removidos gradualmente. Esse processo assegura disponibilidade contínua durante o processo de atualização.
• Recreate Deployment: Com essa estratégia, todos os pods existentes são removidos primeiro. Em seguida, os pods atualizados são iniciados. Esse método pode resultar em uma interrupção temporária do serviço, pois nenhum pod fica disponível durante o processo de recriação.
• Blue/Green Deployment: Nesse método, dois conjuntos de pods (azul e verde) são criados. Um deles representa a versão atual da aplicação, enquanto o outro traz a nova versão. Ao atribuir labels específicas a esses pods, o tráfego é redirecionado de maneira segura entre as duas versões. Isso permite alternar rapidamente entre ambas e reverter mudanças com facilidade.

Reverter Kubernetes Deployment

Se um erro ocorrer na versão mais recente da sua aplicação, é crucial reverter as alterações o mais rápido possível. No Kubernetes, você pode iniciar o processo de reversão ao verificar o histórico de revisões do seu Deployment e retornar a uma versão anterior, se necessário.

Verificar histórico de revisões

Para exibir o histórico de revisões do seu Deployment, 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 considerada estável:

kubectl rollout undo deployment/nginx-deployment

Reverter para versão específica

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

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