Como usar o comando docker stack rm para remover pilhas

Introdução

Neste laboratório, você aprenderá como usar efetivamente o comando docker stack rm para remover pilhas (stacks) Docker implantadas em um ambiente Docker Swarm. Você começará preparando um Docker Swarm de nó único, inicializando-o e verificando seu status.

Após a configuração do ambiente, você implantará uma pilha de exemplo usando um arquivo Docker Compose para entender o processo de implantação. O cerne do laboratório se concentra na remoção de pilhas: você primeiro praticará a remoção de uma única pilha implantada e, em seguida, implantará várias pilhas para aprender como remover várias pilhas simultaneamente usando o comando docker stack rm. Essa experiência prática o equipará com as habilidades para gerenciar e limpar suas implantações Docker Swarm.

Preparar um ambiente Docker Swarm

Nesta etapa, você preparará seu ambiente para implantar pilhas (stacks) Docker inicializando um Docker Swarm. Docker Swarm é uma solução nativa de clustering e orquestração para Docker. Ele permite que você crie e gerencie um swarm de nós Docker.

Primeiro, vamos verificar se o Docker está em execução e acessível. Você pode fazer isso executando um comando Docker simples.

docker version

Você deve ver a saída mostrando as versões do cliente e do servidor Docker. Isso confirma que o Docker está instalado e em execução.

Em seguida, precisamos inicializar o Docker Swarm. Como este é um ambiente de nó único, inicializaremos o swarm na máquina atual.

docker swarm init

Este comando inicializa o swarm e torna o nó atual um nó gerente (manager node). A saída fornecerá informações sobre como ingressar outros nós no swarm, mas para este laboratório, usaremos apenas um único nó.

Para confirmar que o swarm foi inicializado com sucesso, você pode verificar o status do swarm.

docker info | grep Swarm

A saída deve mostrar Swarm: active, indicando que o swarm está ativo neste nó.

Finalmente, vamos verificar se o nó atual faz parte do swarm e é um gerente.

docker node ls

Você deve ver uma lista de nós no swarm, com o nó atual listado e seu status como Ready e Leader.

Implantar uma pilha de exemplo

Nesta etapa, você aprenderá como implantar uma aplicação de exemplo como uma pilha (stack) em seu Docker Swarm. Uma pilha é um grupo de serviços relacionados que compartilham dependências e podem ser gerenciados juntos. Usaremos um exemplo simples envolvendo um servidor web Nginx.

Antes de implantar a pilha, precisamos criar um arquivo Docker Compose que define os serviços em nossa pilha. Docker Compose é uma ferramenta para definir e executar aplicações Docker com múltiplos contêineres. Embora o Docker Compose não seja pré-instalado, o comando docker stack deploy pode ler arquivos Compose.

Primeiro, vamos criar um diretório para a definição da nossa pilha. Navegue até seu diretório home e crie um novo diretório chamado my-nginx-stack.

cd ~/project
mkdir my-nginx-stack
cd my-nginx-stack

Agora, crie um arquivo chamado docker-compose.yml dentro do diretório my-nginx-stack usando o editor nano.

nano docker-compose.yml

Cole o seguinte conteúdo no arquivo docker-compose.yml:

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
    deploy:
      replicas: 1
      restart_policy:
        condition: on-failure

Este arquivo docker-compose.yml define um único serviço chamado web que usa a imagem nginx:latest. Ele mapeia a porta 80 no host para a porta 80 no contêiner e especifica que deve haver uma réplica deste serviço. A restart_policy garante que o serviço será reiniciado se falhar.

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

Antes de implantar, vamos baixar a imagem nginx:latest para garantir que ela esteja disponível localmente.

docker pull nginx:latest

Agora, implante a pilha usando o comando docker stack deploy. Vamos nomear nossa pilha nginx_stack.

docker stack deploy -c docker-compose.yml nginx_stack

Este comando lê o arquivo docker-compose.yml e cria os serviços definidos nele como parte do nginx_stack.

Para verificar se a pilha foi implantada e o serviço está em execução, você pode listar os serviços na pilha.

docker stack services nginx_stack

Você deve ver a saída mostrando o serviço nginx_stack_web com 1/1 réplicas em execução.

Você também pode verificar os contêineres em execução para ver o contêiner Nginx.

docker ps

Você deve ver um contêiner executando a imagem nginx:latest, associado ao serviço nginx_stack_web.

Finalmente, você pode acessar o servidor web Nginx abrindo um navegador web e navegando para o endereço IP da sua VM LabEx. Você deve ver a página de boas-vindas padrão do Nginx.

Remover uma única pilha

Nesta etapa, você aprenderá como remover uma pilha implantada do seu Docker Swarm. Remover uma pilha irá parar e remover todos os serviços e contêineres associados a essa pilha.

Na etapa anterior, implantamos uma pilha chamada nginx_stack. Para remover esta pilha, usamos o comando docker stack rm seguido pelo nome da pilha.

docker stack rm nginx_stack

Este comando iniciará o processo de remoção. Docker Swarm irá parar e remover o serviço e seu contêiner associado.

Você deve ver a saída indicando que a pilha e seus serviços estão sendo removidos.

Para verificar se a pilha foi removida, você pode listar as pilhas implantadas novamente.

docker stack ls

A nginx_stack não deve mais aparecer na lista de pilhas implantadas.

Você também pode verificar os serviços em execução para confirmar que o serviço nginx_stack_web não está mais em execução.

docker stack services nginx_stack

Este comando deve retornar um erro ou nenhuma saída, indicando que a pilha e seus serviços foram removidos.

Finalmente, você pode verificar os contêineres em execução para garantir que o contêiner Nginx associado à pilha foi removido.

docker ps

O contêiner executando a imagem nginx:latest para o serviço nginx_stack_web não deve mais ser listado.

Implantar múltiplas pilhas de exemplo

Nesta etapa, você aprenderá como implantar múltiplas pilhas em seu Docker Swarm. Isso demonstra como você pode gerenciar diferentes aplicações ou serviços independentemente dentro do mesmo swarm.

Implantaremos duas pilhas simples: uma usando Nginx e outra usando o Apache HTTP Server.

Primeiro, vamos criar um diretório para a definição da pilha Apache. Navegue de volta para o diretório ~/project e crie um novo diretório chamado my-apache-stack.

cd ~/project
mkdir my-apache-stack
cd my-apache-stack

Agora, crie um arquivo chamado docker-compose.yml dentro do diretório my-apache-stack usando o editor nano.

nano docker-compose.yml

Cole o seguinte conteúdo no arquivo docker-compose.yml:

version: "3.8"
services:
  web:
    image: httpd:latest
    ports:
      - "81:80"
    deploy:
      replicas: 1
      restart_policy:
        condition: on-failure

Este arquivo docker-compose.yml define um serviço chamado web que usa a imagem httpd:latest. Ele mapeia a porta 81 no host para a porta 80 no contêiner para evitar conflitos de porta com a pilha Nginx que implantaremos mais tarde. Ele também especifica uma réplica e uma política de reinício.

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

Antes de implantar, vamos baixar a imagem httpd:latest.

docker pull httpd:latest

Agora, implante a pilha Apache usando o comando docker stack deploy. Vamos nomear esta pilha apache_stack.

docker stack deploy -c docker-compose.yml apache_stack

Este comando implanta a pilha Apache.

Em seguida, vamos voltar para o diretório my-nginx-stack para implantar a pilha Nginx novamente.

cd ~/project/my-nginx-stack

Implante a pilha Nginx usando o comando docker stack deploy. Vamos nomear esta pilha nginx_stack.

docker stack deploy -c docker-compose.yml nginx_stack

Agora, vamos verificar se ambas as pilhas foram implantadas. Liste as pilhas implantadas.

docker stack ls

Você deve ver tanto apache_stack quanto nginx_stack listadas.

Você também pode verificar os serviços para cada pilha individualmente.

docker stack services apache_stack
docker stack services nginx_stack

Você deve ver o serviço apache_stack_web e o serviço nginx_stack_web, ambos em execução com 1/1 réplicas.

Você pode acessar o servidor web Apache abrindo um navegador web e navegando para o endereço IP da sua VM LabEx na porta 81. Você deve ver a página de boas-vindas padrão do Apache. O servidor web Nginx ainda deve estar acessível na porta 80.

Remover múltiplas pilhas

Nesta etapa final, você aprenderá como remover múltiplas pilhas implantadas do seu Docker Swarm. Isso é semelhante a remover uma única pilha, mas você repetirá o processo para cada pilha que deseja remover.

Na etapa anterior, implantamos duas pilhas: apache_stack e nginx_stack. Agora removeremos ambas.

Primeiro, vamos remover a apache_stack. Use o comando docker stack rm seguido pelo nome da pilha.

docker stack rm apache_stack

Você deve ver a saída indicando que a apache_stack e seus serviços estão sendo removidos.

Em seguida, vamos remover a nginx_stack. Use o comando docker stack rm seguido pelo nome da pilha.

docker stack rm nginx_stack

Você deve ver a saída indicando que a nginx_stack e seus serviços estão sendo removidos.

Para verificar se ambas as pilhas foram removidas, liste as pilhas implantadas novamente.

docker stack ls

Nem apache_stack nem nginx_stack devem aparecer na lista de pilhas implantadas.

Você também pode verificar os contêineres em execução para garantir que os contêineres associados a ambas as pilhas foram removidos.

docker ps

Não deve haver contêineres executando as imagens httpd:latest ou nginx:latest que faziam parte dessas pilhas.

Isso conclui o laboratório sobre implantação e remoção de pilhas Docker. Você inicializou com sucesso um Docker Swarm, implantou e removeu pilhas únicas e múltiplas.

Resumo

Neste laboratório, você aprendeu como preparar um ambiente Docker Swarm inicializando um swarm de nó único e verificando seu status. Em seguida, você praticou a implantação de uma aplicação de exemplo como uma pilha usando um arquivo Docker Compose. Finalmente, você dominou o uso do comando docker stack rm para remover pilhas implantadas, tanto únicas quanto múltiplas, do seu Docker Swarm, demonstrando o processo de limpeza de recursos após a implantação.