Como usar o comando docker stack deploy para gerenciar serviços do Swarm

Introdução

Neste laboratório, você aprenderá como gerenciar efetivamente serviços Docker Swarm usando o comando docker stack deploy. Começaremos preparando um simples arquivo docker-compose.yml, que serve como o projeto para nossa pilha de aplicações.

Após a preparação, você implantará essa pilha em seu Docker Swarm, verificará a implantação bem-sucedida dos serviços definidos e, em seguida, explorará como atualizar a pilha modificando o arquivo compose. Finalmente, você aprenderá como podar (prune) serviços que não são mais referenciados na configuração atualizada, garantindo que seu Swarm permaneça limpo e eficiente.

Prepare um arquivo docker-compose simples para implantação no Swarm

Nesta etapa, prepararemos um arquivo docker-compose.yml simples que usaremos para implantar uma pilha em um Docker Swarm. Antes de podermos usar o docker-compose, precisamos instalá-lo.

Primeiro, vamos instalar o docker-compose. Faremos o download do binário e o tornaremos executável.

sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Este comando baixa o binário docker-compose da página oficial de lançamentos do GitHub e o salva em /usr/local/bin/docker-compose. As partes $(uname -s) e $(uname -m) detectam automaticamente seu sistema operacional e arquitetura. O comando chmod +x torna o arquivo baixado executável.

Agora, vamos verificar a instalação verificando a versão.

docker-compose --version

Você deve ver a versão instalada do docker-compose impressa no console.

Em seguida, criaremos um arquivo docker-compose.yml simples no diretório ~/project. Este arquivo definirá um único serviço usando a imagem nginx.

nano ~/project/docker-compose.yml

Cole o seguinte conteúdo no editor nano:

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"

Vamos detalhar este arquivo docker-compose.yml:

• version: '3.8' especifica a versão do formato do arquivo Compose. A versão 3.8 é adequada para implantações no Swarm.
• services: define os serviços que compõem sua aplicação.
• web: é o nome do nosso serviço. Você pode escolher qualquer nome que desejar.
• image: nginx:latest especifica a imagem Docker a ser usada para este serviço. Estamos usando a versão mais recente da imagem oficial nginx.
• ports: mapeia as portas entre o host e o container. "80:80" mapeia a porta 80 no host para a porta 80 no container.

Salve o arquivo pressionando Ctrl + X, depois Y e, em seguida, Enter.

Antes de podermos implantar este serviço, precisamos garantir que a imagem nginx:latest esteja disponível localmente. Podemos baixar a imagem usando o comando docker pull.

docker pull nginx:latest

Este comando baixa a imagem nginx:latest do Docker Hub para sua máquina local.

Agora você tem um arquivo docker-compose.yml simples pronto para implantação e a imagem necessária baixada.

Implantar uma stack no Swarm usando o arquivo compose

Nesta etapa, implantaremos a pilha definida em nosso arquivo docker-compose.yml em um Docker Swarm. Antes de podermos implantar uma pilha, precisamos inicializar um Docker Swarm.

Primeiro, vamos inicializar o Swarm. Como estamos usando uma única VM, vamos inicializá-lo como um Swarm de nó único.

docker swarm init

Este comando inicializa um novo Swarm e torna o nó atual um nó gerente (manager node). Você deve ver uma saída indicando que o Swarm foi inicializado.

Agora que o Swarm está inicializado, podemos implantar nossa pilha usando o comando docker stack deploy. Daremos à nossa pilha um nome, por exemplo, mywebstack.

docker stack deploy -c ~/project/docker-compose.yml mywebstack

Vamos detalhar este comando:

• docker stack deploy é o comando usado para implantar uma pilha em um Swarm.
• -c ~/project/docker-compose.yml especifica o arquivo Compose a ser usado para a implantação. Estamos usando o arquivo que criamos na etapa anterior.
• mywebstack é o nome que estamos dando à nossa pilha. Este nome será usado para identificar os serviços e containers pertencentes a esta pilha dentro do Swarm.

Após executar este comando, o Docker Swarm criará os serviços definidos no arquivo docker-compose.yml. Você deve ver uma saída indicando que os serviços estão sendo criados ou atualizados.

Para verificar se a pilha foi implantada, podemos listar as pilhas em execução.

docker stack ls

Este comando mostrará uma lista de todas as pilhas implantadas em seu Swarm. Você deve ver mywebstack listado.

Também podemos listar os serviços em execução dentro de nossa pilha.

docker stack services mywebstack

Este comando mostrará os serviços associados à pilha mywebstack. Você deve ver o serviço mywebstack_web listado, juntamente com informações sobre suas réplicas e imagem.

Finalmente, vamos verificar o status das tarefas do serviço.

docker service ps mywebstack_web

Este comando mostra as tarefas (containers em execução) para o serviço mywebstack_web. Você deve ver pelo menos uma tarefa com o estado Running.

Você agora inicializou com sucesso um Docker Swarm e implantou uma pilha usando um arquivo docker-compose.yml.

Verificar os serviços implantados

Nesta etapa, verificaremos se os serviços implantados na etapa anterior estão sendo executados corretamente e são acessíveis. Implantamos um servidor web Nginx, que deve estar ouvindo na porta 80.

Primeiro, vamos usar o comando docker service ls para ver a lista de serviços em execução no Swarm.

docker service ls

Você deve ver o serviço mywebstack_web listado com 1/1 réplicas, indicando que uma instância do serviço está em execução.

Em seguida, podemos usar o curl para acessar o servidor web Nginx em execução dentro do container. Como mapeamos a porta 80 no host para a porta 80 no container, podemos acessá-lo via localhost na porta 80.

curl localhost:80

Este comando envia uma requisição HTTP para localhost na porta 80. Se o servidor Nginx estiver sendo executado corretamente, você deverá receber a página HTML de boas-vindas padrão do Nginx como saída. Isso confirma que o serviço está em execução e acessível a partir da máquina host.

Para inspecionar ainda mais o container em execução para o serviço web, podemos usar o comando docker ps.

docker ps

Este comando lista todos os containers em execução. Você deve ver um container executando a imagem nginx, com um nome semelhante a mywebstack_web.1.<task_id>. A coluna PORTS deve mostrar 0.0.0.0:80->80/tcp, confirmando o mapeamento da porta.

Também podemos inspecionar os detalhes do serviço usando o comando docker service inspect.

docker service inspect mywebstack_web

Este comando fornece informações detalhadas sobre o serviço mywebstack_web, incluindo sua configuração, tarefas e configurações de rede. Você pode percorrer a saída para ver vários detalhes sobre o serviço.

Ao realizar essas verificações, verificamos que nosso serviço Nginx implantado está sendo executado conforme o esperado e é acessível.

Atualizar a stack com um arquivo compose modificado

Nesta etapa, modificaremos nosso arquivo docker-compose.yml para atualizar a pilha implantada. Mudaremos a versão da imagem Nginx e adicionaremos um segundo serviço.

Primeiro, vamos editar o arquivo docker-compose.yml.

nano ~/project/docker-compose.yml

Modifique o arquivo para incluir um segundo serviço, por exemplo, um serviço alpine, e altere a versão da imagem Nginx para 1.21.6. O arquivo atualizado deve ser semelhante a este:

version: "3.8"
services:
  web:
    image: nginx:1.21.6
    ports:
      - "80:80"
  alpine:
    image: alpine:latest
    command: ["sleep", "infinity"]

Vamos analisar as mudanças:

• Mudamos a image para o serviço web de nginx:latest para nginx:1.21.6.
• Adicionamos um novo serviço chamado alpine.
• O serviço alpine usa a imagem alpine:latest.
• O command: ["sleep", "infinity"] mantém o container alpine em execução indefinidamente.

Salve o arquivo modificado pressionando Ctrl + X, depois Y e, em seguida, Enter.

Antes de implantar a pilha atualizada, precisamos baixar as novas imagens nginx:1.21.6 e alpine:latest.

docker pull nginx:1.21.6
docker pull alpine:latest

Agora, podemos implantar a pilha atualizada usando o mesmo comando docker stack deploy e o mesmo nome da pilha. O Docker Swarm detectará as alterações no arquivo docker-compose.yml e atualizará a pilha existente.

docker stack deploy -c ~/project/docker-compose.yml mywebstack

O Docker Swarm executará uma atualização contínua (rolling update) para o serviço web, substituindo o antigo container nginx:latest por um novo usando nginx:1.21.6. Ele também criará o novo serviço alpine e seu container correspondente. Você deve ver a saída indicando que os serviços estão sendo atualizados ou criados.

Para verificar a atualização, vamos listar os serviços na pilha novamente.

docker stack services mywebstack

Você deve agora ver os serviços mywebstack_web e mywebstack_alpine listados. O serviço mywebstack_web deve mostrar a imagem atualizada nginx:1.21.6.

Você atualizou com sucesso sua pilha implantada modificando o arquivo docker-compose.yml e reimplantando-o.

Remover serviços não mais referenciados no arquivo compose

Nesta etapa, modificaremos nosso arquivo docker-compose.yml novamente, desta vez removendo um serviço. Quando reimplantarmos a pilha, o Docker Swarm detectará que um serviço não está mais definido no arquivo Compose e o removerá. Esse processo é, às vezes, referido como "podar" (pruning) serviços.

Primeiro, vamos editar o arquivo docker-compose.yml para remover o serviço alpine.

nano ~/project/docker-compose.yml

Remova toda a seção alpine: do arquivo. O arquivo deve retornar ao seu estado original, definindo apenas o serviço web:

version: "3.8"
services:
  web:
    image: nginx:1.21.6
    ports:
      - "80:80"

Salve o arquivo modificado pressionando Ctrl + X, depois Y e, em seguida, Enter.

Agora, implante a pilha novamente usando o arquivo docker-compose.yml modificado.

docker stack deploy -c ~/project/docker-compose.yml mywebstack

O Docker Swarm comparará o estado atual da pilha mywebstack com a definição no arquivo docker-compose.yml atualizado. Ele notará que o serviço alpine não está mais presente no arquivo e removerá o serviço correspondente e suas tarefas do Swarm. Você deve ver a saída indicando que o serviço alpine está sendo removido.

Para verificar se o serviço alpine foi removido, liste os serviços na pilha novamente.

docker stack services mywebstack

Você agora deve ver apenas o serviço mywebstack_web listado. O serviço mywebstack_alpine deve ter desaparecido.

Finalmente, para limpar o ambiente Swarm, podemos remover toda a pilha.

docker stack rm mywebstack

Este comando remove a pilha mywebstack, incluindo todos os seus serviços e tarefas. Você deve ver a saída confirmando a remoção.

Para verificar se a pilha foi removida, liste as pilhas novamente.

docker stack ls

O mywebstack não deve mais ser listado.

Você podou com sucesso um serviço de sua pilha removendo-o do arquivo docker-compose.yml e reimplantando, e então limpou o ambiente removendo toda a pilha.

Resumo

Neste laboratório, aprendemos como usar o comando docker stack deploy para gerenciar serviços do Docker Swarm. Começamos preparando um simples arquivo docker-compose.yml, que é a maneira padrão de definir aplicações multi-serviço para o Docker. Isso envolveu a instalação do docker-compose e a criação de um arquivo YAML básico definindo um único serviço Nginx com mapeamento de portas.

Após a preparação, implantamos essa pilha em um Docker Swarm usando docker stack deploy, verificamos a implantação bem-sucedida do serviço e, em seguida, praticamos a atualização da pilha modificando o arquivo docker-compose.yml e reimplantando. Finalmente, aprendemos como podar (prune) serviços que não são mais definidos no arquivo compose atualizado, garantindo que nosso ambiente Swarm permaneça limpo e reflita a definição atual da aplicação.