Introdução

Neste laboratório, você obterá experiência prática usando o comando docker service create para implantar e gerenciar serviços dentro de um Docker Swarm. Você aprenderá como criar e inspecionar diferentes tipos de serviços, incluindo serviços replicados simples para alta disponibilidade e escalabilidade, e serviços globais que são executados em cada nó.

Além disso, você explorará configurações avançadas de serviços, como a implementação de políticas de atualização contínua (rolling update) para implantações contínuas, a utilização de bind mounts e variáveis de ambiente para persistência de dados e configuração, e a aplicação de restrições e preferências de posicionamento para controlar onde as tarefas do seu serviço são executadas dentro do swarm. Ao concluir estas etapas, você desenvolverá uma sólida compreensão de como gerenciar efetivamente aplicações em contêineres em um ambiente Docker Swarm.

Criar um serviço replicado simples

Nesta etapa, você aprenderá como criar um serviço replicado simples no Docker Swarm. Um serviço replicado é um serviço que executa múltiplas tarefas idênticas em todo o swarm. Isso proporciona alta disponibilidade e escalabilidade.

Primeiro, vamos garantir que o Docker esteja em execução e que você esteja no diretório correto.

docker version
pwd

Você deve ver a saída indicando a versão do Docker e seu diretório atual como /home/labex/project.

Antes de criar um serviço, precisamos baixar a imagem Docker necessária. Usaremos a imagem nginx para este exemplo.

docker pull nginx:latest

Este comando baixa a versão mais recente da imagem nginx do Docker Hub.

Agora, vamos criar um serviço replicado simples chamado my-nginx-service com 3 réplicas.

docker service create --name my-nginx-service --replicas 3 nginx:latest

Este comando cria um novo serviço chamado my-nginx-service usando a imagem nginx:latest e define o número de réplicas desejadas para 3. O Docker Swarm distribuirá então essas 3 tarefas pelos nós disponíveis no swarm.

Para verificar o status do serviço e suas tarefas, você pode usar os comandos docker service ls e docker service ps.

docker service ls
docker service ps my-nginx-service

O comando docker service ls lista todos os serviços em execução no swarm, mostrando seu ID, nome, modo, réplicas e imagem. O comando docker service ps my-nginx-service mostra as tarefas associadas ao my-nginx-service, incluindo seu estado (por exemplo, Running, Shutdown), estado desejado e o nó em que estão sendo executadas. Você deve ver 3 tarefas no estado "Running".

Criar um serviço global e inspecionar suas tarefas

Nesta etapa, você aprenderá como criar um serviço global no Docker Swarm. Diferente dos serviços replicados, que executam um número especificado de tarefas, um serviço global executa exatamente uma tarefa em cada nó do swarm que atenda às restrições do serviço. Isso é útil para serviços como agentes de monitoramento ou coletores de logs que precisam ser executados em cada nó.

Usaremos a imagem busybox para este exemplo. Vamos baixar a imagem primeiro.

docker pull busybox:latest

Este comando baixa a versão mais recente da imagem busybox.

Agora, vamos criar um serviço global chamado my-global-service.

docker service create --name my-global-service --mode global busybox:latest sleep infinity

Este comando cria um novo serviço chamado my-global-service usando a imagem busybox:latest. A flag --mode global especifica que este é um serviço global. O comando sleep infinity é usado para manter o contêiner em execução indefinidamente.

Para inspecionar as tarefas do serviço global, você pode usar o comando docker service ps.

docker service ps my-global-service

Este comando mostrará as tarefas associadas ao my-global-service. Como este é um serviço global, você deve ver uma tarefa em execução para cada nó no seu swarm. Neste ambiente de laboratório, você provavelmente verá apenas uma tarefa, pois há apenas um nó. A saída mostrará o estado da tarefa, o estado desejado e o nó em que ela está sendo executada.

Você também pode inspecionar a configuração do serviço usando o comando docker service inspect.

docker service inspect my-global-service

Este comando fornece informações detalhadas sobre o serviço, incluindo seu modo, réplicas (que serão 0 para um serviço global na lista de serviços, mas o docker service ps mostrará tarefas por nó) e outros detalhes de configuração.

Criar um serviço com réplicas e política de atualização contínua

Nesta etapa, você aprenderá como criar um serviço replicado e configurar sua política de atualização contínua (rolling update). As atualizações contínuas permitem que você atualize seu serviço para uma nova versão sem tempo de inatividade, substituindo gradualmente as tarefas pela nova versão.

Continuaremos usando a imagem nginx. Vamos criar um serviço replicado chamado my-nginx-update-service com 5 réplicas e uma política de atualização contínua.

docker service create \
  --name my-nginx-update-service \
  --replicas 5 \
  --update-delay 10s \
  --update-parallelism 2 \
  nginx:latest

Este comando cria um serviço com as seguintes configurações:

• --name my-nginx-update-service: Define o nome do serviço.
• --replicas 5: Define o número desejado de réplicas para 5.
• --update-delay 10s: Define o atraso entre a atualização de cada grupo de tarefas para 10 segundos.
• --update-parallelism 2: Define o número de tarefas a serem atualizadas simultaneamente para 2.

Esses parâmetros de atualização definem como o serviço será atualizado quando você implantar uma nova versão da imagem. O Docker Swarm atualizará 2 tarefas por vez, esperando 10 segundos antes de atualizar o próximo lote.

Você pode verificar o status do serviço e suas tarefas usando os comandos docker service ls e docker service ps.

docker service ls
docker service ps my-nginx-update-service

Você deve ver my-nginx-update-service listado com 5/5 réplicas e as tarefas no estado "Running".

Agora, vamos simular uma atualização alterando a imagem para uma versão diferente. Usaremos a imagem nginx:1.21. Primeiro, baixe a imagem.

docker pull nginx:1.21

Agora, atualize o serviço para usar a imagem nginx:1.21.

docker service update --image nginx:1.21 my-nginx-update-service

Este comando inicia uma atualização contínua. O Docker Swarm começará a substituir as tarefas nginx:latest por tarefas nginx:1.21 de acordo com as configurações --update-parallelism e --update-delay que você configurou anteriormente.

Você pode observar o processo de atualização contínua executando repetidamente docker service ps my-nginx-update-service.

docker service ps my-nginx-update-service

Você verá as tarefas transitando de "Running" com a imagem antiga para "Shutdown" e, em seguida, novas tarefas iniciando com a nova imagem e entrando no estado "Running". A atualização acontecerá em lotes de 2 tarefas com um atraso de 10 segundos entre os lotes.

Criar um serviço com bind mounts e variáveis de ambiente

Nesta etapa, você aprenderá como criar um serviço que usa bind mounts para persistir dados e variáveis de ambiente para configurar a aplicação dentro do contêiner. Os bind mounts permitem que você monte um arquivo ou diretório da máquina host em um contêiner, tornando os dados acessíveis ao contêiner e persistentes, mesmo que o contêiner seja removido. As variáveis de ambiente são uma maneira comum de passar informações de configuração para as aplicações.

Primeiro, vamos criar um diretório na máquina host que montaremos no contêiner.

mkdir -p ~/project/html

Este comando cria um diretório chamado html dentro do seu diretório ~/project.

Agora, vamos criar um arquivo HTML simples dentro deste diretório.

echo "<h1>Hello from Bind Mount!</h1>" > ~/project/html/index.html

Este comando cria um arquivo chamado index.html no diretório ~/project/html com o conteúdo "

Hello from Bind Mount!

Usaremos a imagem nginx novamente. Vamos criar um serviço replicado chamado my-nginx-volume-service com 1 réplica, montando o diretório ~/project/html no diretório webroot padrão do Nginx dentro do contêiner (/usr/share/nginx/html) e definindo uma variável de ambiente.

docker service create \
  --name my-nginx-volume-service \
  --replicas 1 \
  --publish published=8080,target=80 \
  --mount type=bind,source=/home/labex/project/html,target=/usr/share/nginx/html \
  --env MY_VARIABLE=hello \
  nginx:latest

Vamos detalhar as novas opções:

• --publish published=8080,target=80: Isso mapeia a porta 8080 no host para a porta 80 dentro do contêiner, permitindo que você acesse o servidor web Nginx da sua máquina host.
• --mount type=bind,source=/home/labex/project/html,target=/usr/share/nginx/html: Isso cria um bind mount. type=bind especifica o tipo de montagem. source=/home/labex/project/html é o caminho na máquina host. target=/usr/share/nginx/html é o caminho dentro do contêiner onde o diretório host será montado.
• --env MY_VARIABLE=hello: Isso define uma variável de ambiente chamada MY_VARIABLE com o valor hello dentro do contêiner.

Verifique o status do serviço e as tarefas:

docker service ls
docker service ps my-nginx-volume-service

Aguarde a tarefa estar no estado "Running".

Agora, você pode acessar o servidor web Nginx em execução no contêiner visitando http://localhost:8080 em um navegador web ou usando curl.

curl http://localhost:8080

Você deve ver o conteúdo do arquivo index.html que você criou: <h1>Hello from Bind Mount!</h1>. Isso confirma que o bind mount está funcionando corretamente.

Para verificar a variável de ambiente, você pode executar um comando dentro do contêiner em execução. Primeiro, encontre o ID da tarefa do serviço em execução.

docker service ps my-nginx-volume-service

Anote o ID da Tarefa na saída. Em seguida, use docker exec para executar um comando dentro do contêiner. Substitua <task_id> pelo ID da Tarefa real.

docker exec < task_id > env | grep MY_VARIABLE

Este comando executa o comando env dentro do contêiner associado ao ID da tarefa e canaliza a saída para grep MY_VARIABLE para encontrar a variável de ambiente. Você deve ver MY_VARIABLE=hello na saída.

Criar um serviço com restrições e preferências de posicionamento

Nesta etapa, você aprenderá como usar restrições e preferências de posicionamento para controlar onde as tarefas do seu serviço são implantadas dentro do Docker Swarm. As restrições de posicionamento são requisitos rígidos que um nó deve atender para que uma tarefa seja agendada nele. As preferências de posicionamento são requisitos flexíveis que influenciam o agendamento, mas não impedem que uma tarefa seja agendada se nenhum nó atender à preferência.

Primeiro, vamos inspecionar o nó atual para ver seus rótulos. Os rótulos são pares chave-valor que você pode anexar aos nós para fornecer metadados.

docker node inspect self --format '{{ .Spec.Labels }}'

Este comando inspeciona o nó atual (identificado por self) e formata a saída para mostrar seus rótulos. Por padrão, pode não haver nenhum rótulo personalizado.

Vamos adicionar um rótulo ao nó atual. Adicionaremos um rótulo node_type=app.

docker node update --label-add node_type=app self

Este comando atualiza o nó atual e adiciona o rótulo node_type=app.

Agora, vamos verificar se o rótulo foi adicionado.

docker node inspect self --format '{{ .Spec.Labels }}'

Você deve ver map[node_type:app] na saída, indicando que o rótulo foi adicionado com sucesso.

Agora, vamos criar um serviço replicado chamado my-constrained-service com uma restrição de posicionamento que exige que o nó tenha o rótulo node_type=app. Usaremos a imagem nginx.

docker service create \
  --name my-constrained-service \
  --replicas 1 \
  --constraint 'node.labels.node_type == app' \
  nginx:latest

Este comando cria um serviço com uma restrição. --constraint 'node.labels.node_type == app' especifica que as tarefas para este serviço só podem ser agendadas em nós onde o rótulo node_type é igual a app. Como adicionamos este rótulo ao nó atual, a tarefa deve ser agendada aqui.

Verifique o status do serviço e as tarefas:

docker service ls
docker service ps my-constrained-service

Você deve ver my-constrained-service listado e sua tarefa em execução no nó atual.

Agora, vamos criar outro serviço com uma preferência de posicionamento. As preferências de posicionamento são usadas para orientar o agendador, mas não são estritamente aplicadas. Usaremos a imagem busybox e preferiremos nós com o rótulo node_type=database. Como nosso nó atual não possui este rótulo, a tarefa ainda será agendada no nó atual, mas se houvesse outros nós com esse rótulo, o agendador os preferiria.

Primeiro, baixe a imagem busybox.

docker pull busybox:latest

Agora, crie o serviço com uma preferência de posicionamento.

docker service create \
  --name my-preferred-service \
  --replicas 1 \
  --placement-pref 'spread=node.labels.node_type' \
  busybox:latest sleep infinity

A opção --placement-pref 'spread=node.labels.node_type' diz ao agendador para distribuir as tarefas entre os nós com base no valor do rótulo node_type. Em um swarm de vários nós com diferentes rótulos node_type, isso distribuiria as tarefas de forma mais uniforme. Neste ambiente de nó único, a tarefa simplesmente será agendada no nó disponível.

Verifique o status do serviço e as tarefas:

docker service ls
docker service ps my-preferred-service

Você deve ver my-preferred-service listado e sua tarefa em execução no nó atual.

Resumo

Neste laboratório, aprendemos como usar o comando docker service create para implantar e gerenciar serviços no Docker Swarm. Começamos criando um serviço replicado simples usando a imagem nginx, especificando o número desejado de réplicas para alta disponibilidade e escalabilidade. Em seguida, usamos docker service ls e docker service ps para verificar o status do serviço e inspecionar suas tarefas em execução.

Posteriormente, exploramos a criação de um serviço global, entendendo seu comportamento de executar uma tarefa em cada nó elegível no swarm. Isso demonstrou a flexibilidade do Docker Swarm na implantação de serviços com base em diferentes requisitos.