Introdução
Neste laboratório, você aprenderá como usar o comando docker compose events para monitorar eventos de contêineres. Começaremos preparando um projeto Docker Compose simples, incluindo a instalação do Docker Compose e a criação de um arquivo docker-compose.yml básico.
Após a configuração, você iniciará os serviços definidos no projeto e observará os eventos básicos gerados. Em seguida, exploraremos como usar a flag --json para gerar esses eventos em um formato JSON estruturado. Finalmente, você aprenderá como filtrar eventos para monitorar apenas aqueles relacionados a serviços específicos dentro de sua aplicação Docker Compose.
Prepare um projeto Docker Compose simples
Nesta etapa, prepararemos um projeto Docker Compose simples. Como o Docker Compose não está pré-instalado no ambiente LabEx, primeiro o instalaremos. Docker Compose é uma ferramenta para definir e executar aplicações Docker com múltiplos contêineres. Com o Compose, você usa um arquivo YAML para configurar os serviços da sua aplicação. Em seguida, com um único comando, você cria e inicia todos os serviços a partir da sua configuração.
Primeiro, vamos instalar o Docker Compose. Faremos o download do binário do Docker Compose 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
Após a instalação, você pode verificar a instalação verificando a versão do Docker Compose.
docker-compose --version
Você deve ver uma saída semelhante a Docker Compose version v2.20.2.
Agora, vamos criar um diretório para nosso projeto e navegar até ele. Criaremos um projeto simples com um único serviço.
mkdir ~/project/my-compose-app
cd ~/project/my-compose-app
Em seguida, criaremos um arquivo docker-compose.yml neste diretório. Este arquivo definirá nosso serviço. Usaremos o editor nano para criar e editar o arquivo.
nano docker-compose.yml
No editor nano, cole o seguinte conteúdo. Esta configuração define um serviço chamado web que usa a imagem nginx:latest.
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 Docker Compose.services:define os serviços que compõem sua aplicação.web:é o nome do nosso serviço.image: nginx:latestespecifica a imagem Docker a ser usada para este serviço. Neste caso, estamos usando a versão mais recente da imagem oficial do Nginx.ports:mapeia portas entre o host e o contêiner."80:80"mapeia a porta 80 no host para a porta 80 no contêiner.
Salve o arquivo pressionando Ctrl + X, depois Y e Enter.
Antes de iniciar o serviço, vamos fazer o pull da imagem nginx:latest. Embora o Docker Compose faça o pull da imagem se ela não estiver presente, fazer o pull explicitamente com antecedência pode, às vezes, ser útil.
docker pull nginx:latest
Você deve ver uma saída indicando que a imagem está sendo puxada e baixada.
Agora temos nosso arquivo docker-compose.yml pronto e a imagem necessária puxada. Na próxima etapa, iniciaremos o serviço definido neste arquivo.
Iniciar os serviços e observar eventos básicos
Nesta etapa, iniciaremos os serviços definidos em nosso arquivo docker-compose.yml e observaremos os eventos básicos gerados pelo Docker. Eventos do Docker são informações em tempo real sobre o que está acontecendo com seu daemon e contêineres Docker, como criação, início, parada e destruição de contêineres.
Primeiro, certifique-se de estar no diretório ~/project/my-compose-app onde você criou o arquivo docker-compose.yml na etapa anterior.
cd ~/project/my-compose-app
Agora, usaremos o comando docker-compose up para iniciar o serviço. A flag -d executa os contêineres em modo detached (desconectado), o que significa que eles serão executados em segundo plano e não bloquearão seu terminal.
docker-compose up -d
Você deve ver uma saída indicando que a rede e o contêiner do serviço web estão sendo criados e iniciados.
[+] Running 2/2
⠿ Network my-compose-app_default Created
⠿ Container my-compose-app-web-1 Started
Para observar os eventos básicos do Docker, usaremos o comando docker events. Este comando transmite eventos do daemon Docker.
docker events
Você verá um fluxo contínuo de eventos relacionados ao seu ambiente Docker. Como acabamos de iniciar um contêiner, você deve ver eventos relacionados à criação, início e, possivelmente, outras ações relacionadas ao contêiner my-compose-app-web-1. A saída será semelhante a esta (os timestamps e detalhes específicos variarão):
2023-10-27T10:00:00.123456789Z container create 1234567890abcdef... (image=nginx:latest, name=my-compose-app-web-1, ...)
2023-10-27T10:00:01.987654321Z container start 1234567890abcdef... (image=nginx:latest, name=my-compose-app-web-1, ...)
...
O comando docker events continuará sendo executado e exibindo novos eventos à medida que eles ocorrem. Para parar o comando e retornar ao seu prompt de terminal, pressione Ctrl + C.
Você também pode observar o contêiner em execução usando o comando docker ps.
docker ps
Você deve ver o contêiner my-compose-app-web-1 listado com o status Up.
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
... nginx:latest "nginx -g 'daemon off" About a minute ago Up About a minute 0.0.0.0:80->80/tcp, :::80->80/tcp my-compose-app-web-1
Nesta etapa, iniciamos com sucesso nosso serviço Docker Compose e observamos os eventos básicos gerados pelo Docker. Na próxima etapa, exploraremos como gerar esses eventos em formato JSON.
Use a flag --json para exibir eventos em formato JSON
Nesta etapa, aprenderemos como gerar eventos do Docker em formato JSON usando a flag --json com o comando docker events. Gerar eventos em formato JSON é útil para processamento programático e integração com outras ferramentas.
Primeiro, certifique-se de estar no diretório ~/project/my-compose-app.
cd ~/project/my-compose-app
Agora, vamos executar o comando docker events com a flag --json. Isso transmitirá os eventos em formato JSON.
docker events --json
Você verá um fluxo contínuo de objetos JSON, onde cada objeto representa um evento do Docker. A saída será semelhante a esta (os detalhes variarão):
{"status":"create","id":"1234567890abcdef...","from":"nginx:latest","Type":"container","Action":"create","Actor":{"ID":"1234567890abcdef...","Attributes":{"image":"nginx:latest","name":"my-compose-app-web-1"}},"scope":"local","time":1678886400,"timeNano":1678886400123456789}
{"status":"start","id":"1234567890abcdef...","from":"nginx:latest","Type":"container","Action":"start","Actor":{"ID":"1234567890abcdef...","Attributes":{"image":"nginx:latest","name":"my-compose-app-web-1"}},"scope":"local","time":1678886401,"timeNano":1678886401987654321}
...
Cada linha é um objeto JSON válido contendo informações detalhadas sobre o evento, como o status do evento, o id do objeto afetado, Type, Action e detalhes do Actor, incluindo Attributes como o nome da imagem e o nome do contêiner.
Para demonstrar a captura desses eventos, vamos parar e, em seguida, iniciar o serviço web novamente enquanto o comando docker events --json está sendo executado em outro terminal ou em segundo plano. Como estamos usando um único terminal neste laboratório, interromperemos o comando docker events --json primeiro pressionando Ctrl + C.
Agora, vamos parar o serviço web.
docker-compose stop web
Você deve ver uma saída indicando que o contêiner web está sendo parado.
[+] Stopping 1/1
⠿ Container my-compose-app-web-1 Stopped
Agora, vamos executar docker events --json em segundo plano e, em seguida, iniciar o serviço novamente. Usaremos o símbolo & para executar o comando em segundo plano.
docker events --json &
Você verá um ID de processo (PID) impresso, indicando que o comando está sendo executado em segundo plano.
Agora, inicie o serviço web novamente.
docker-compose start web
Você deve ver uma saída indicando que o contêiner web está sendo iniciado.
[+] Starting 1/1
⠿ Container my-compose-app-web-1 Started
O comando docker events --json em execução em segundo plano capturará os eventos stop e start. Para ver a saída do processo em segundo plano, pode ser necessário trazê-lo para o primeiro plano usando o comando fg ou verificar a saída do terminal após a parada do processo em segundo plano. No entanto, para o propósito desta etapa, simplesmente executar o comando com --json é suficiente para entender o formato.
Para interromper o processo docker events --json em segundo plano, você pode usar o comando jobs para listar os trabalhos em segundo plano e, em seguida, kill %<número_do_trabalho>. Alternativamente, você pode encontrar o ID do processo usando ps aux | grep 'docker events --json' e usar o comando kill com o PID. Uma maneira mais simples neste contexto é simplesmente prosseguir para a próxima etapa, pois o processo em segundo plano não interferirá significativamente.
Nesta etapa, usamos com sucesso a flag --json para visualizar eventos do Docker em um formato JSON estruturado, o que é valioso para automação e análise.
Filtrar eventos para serviços específicos
Nesta etapa, aprenderemos como filtrar eventos do Docker para ver apenas eventos relacionados a serviços ou contêineres específicos. Isso é muito útil em ambientes com muitos contêineres, onde você deseja monitorar eventos apenas para uma aplicação ou serviço específico.
O comando docker events suporta filtragem usando a flag --filter. Você pode filtrar por vários critérios, como container, image, event, label, etc.
Primeiro, certifique-se de estar no diretório ~/project/my-compose-app.
cd ~/project/my-compose-app
Nosso serviço é chamado web no arquivo docker-compose.yml, e o nome do contêiner gerado pelo Docker Compose geralmente está no formato <nome_do_projeto>_<nome_do_serviço>_<número_da_instância>. Em nosso caso, o nome do projeto é my-compose-app (derivado do nome do diretório), o nome do serviço é web e o número da instância é 1. Portanto, o nome do contêiner é my-compose-app-web-1.
Vamos filtrar eventos para mostrar apenas aqueles relacionados ao nosso contêiner web. Podemos usar o filtro container com o nome do contêiner.
docker events --filter container=my-compose-app-web-1
Este comando agora exibirá apenas eventos onde o objeto afetado é o contêiner chamado my-compose-app-web-1. Para ver isso em ação, vamos parar e iniciar o serviço web novamente enquanto este comando está sendo executado.
Primeiro, pare o comando docker events pressionando Ctrl + C.
Agora, execute o comando docker events filtrado em segundo plano.
docker events --filter container=my-compose-app-web-1 &
Você verá o ID do processo em segundo plano.
Agora, pare o serviço web usando o Docker Compose.
docker-compose stop web
Você deve ver a saída indicando que o contêiner está parando. O comando docker events em segundo plano deve capturar o evento stop para o contêiner my-compose-app-web-1.
Em seguida, inicie o serviço web novamente.
docker-compose start web
Você deve ver a saída indicando que o contêiner está iniciando. O comando docker events em segundo plano deve capturar o evento start para o contêiner my-compose-app-web-1.
Você também pode filtrar por outros critérios. Por exemplo, para filtrar eventos por imagem, você pode usar --filter image=nginx:latest.
Para interromper o processo docker events em segundo plano, você pode usar jobs e kill %<número_do_trabalho> ou encontrar o PID e usar kill <PID>. Para este laboratório, você pode simplesmente prosseguir.
Finalmente, vamos limpar o contêiner em execução e a rede criados pelo Docker Compose.
docker-compose down
Este comando irá parar e remover os contêineres, redes e volumes definidos no arquivo docker-compose.yml.
[+] Running 2/1
⠿ Container my-compose-app-web-1 Removed
⠿ Network my-compose-app_default Removed
Nesta etapa, aprendemos como filtrar eventos do Docker usando a flag --filter, o que é essencial para monitorar componentes específicos em um ambiente Docker movimentado. Também limpamos os recursos criados durante o laboratório.
Resumo
Neste laboratório, aprendemos como usar o comando docker compose events para monitorar eventos de contêineres. Começamos preparando um projeto Docker Compose simples, que envolveu a instalação do Docker Compose e a criação de um arquivo docker-compose.yml definindo um serviço Nginx básico.
Após a configuração do projeto, iniciamos os serviços e observamos os eventos básicos gerados pelo Docker Compose. Em seguida, exploramos como gerar esses eventos em formato JSON usando a flag --json para facilitar a análise e o processamento. Finalmente, aprendemos como filtrar os eventos para monitorar apenas aqueles relacionados a serviços específicos dentro do nosso projeto Docker Compose.
