Introdução
Neste laboratório, você aprenderá como usar o comando docker compose alpha publish para publicar uma aplicação Docker Compose. Começaremos preparando uma aplicação multi-container simples usando um arquivo docker-compose.yaml.
Após a preparação, você explorará diferentes maneiras de publicar a aplicação em um repositório, incluindo a publicação com digests de imagem resolvidos e a inclusão de variáveis de ambiente no artefato publicado. Esta experiência prática irá guiá-lo através do processo de empacotamento e compartilhamento de suas aplicações Compose.
Prepare uma aplicação Docker Compose simples
Nesta etapa, prepararemos uma aplicação Docker Compose simples. Docker Compose é uma ferramenta para definir e executar aplicações Docker multi-container. Com o Compose, você usa um arquivo YAML para configurar os serviços da sua aplicação. Então, com um único comando, você cria e inicia todos os serviços a partir da sua configuração.
Primeiro, precisamos instalar o Docker Compose. Como ele não vem pré-instalado no ambiente LabEx, 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
Após o download e a execução, verifique a instalação checando a versão.
docker-compose --version
Você deve ver uma saída semelhante a Docker Compose version v2.20.2.
Agora, vamos criar uma aplicação Docker Compose simples. Criaremos um arquivo docker-compose.yaml no diretório ~/project. Este arquivo definirá um único serviço que executa um servidor web Nginx.
Use o editor nano para criar e editar o arquivo.
nano ~/project/docker-compose.yaml
Adicione o seguinte conteúdo ao arquivo docker-compose.yaml:
version: "3.8"
services:
web:
image: nginx:latest
ports:
- "80:80"
Neste arquivo docker-compose.yaml:
version: '3.8'especifica a versão do formato do arquivo Compose.services:define os serviços para sua aplicação.web:é o nome do nosso serviço.image: nginx:latestespecifica a imagem Docker a ser usada para este serviço. Estamos usando a versão mais recente da imagem oficial do Nginx.ports:mapeia portas da máquina host para o container."80:80"mapeia a porta 80 no host para a porta 80 no container.
Salve o arquivo pressionando Ctrl + S e saia do editor pressionando Ctrl + X.
Antes de executar a aplicação, precisamos fazer o pull da imagem nginx:latest.
docker pull nginx:latest
Agora, podemos iniciar a aplicação usando o comando docker-compose up. A flag -d executa os containers em modo detached (em segundo plano).
docker-compose up -d
Você deve ver uma saída indicando que o serviço está sendo criado e iniciado.
Para verificar se o container está em execução, use o comando docker ps.
docker ps
Você deve ver uma entrada para o serviço web com a imagem nginx e um status de Up.
Finalmente, você pode testar o servidor Nginx acessando-o. Como a porta 80 do container está mapeada para a porta 80 do host, você pode usar curl para acessar localhost.
curl localhost
Você deve ver a saída HTML da página de boas-vindas padrão do Nginx.
Publicar a aplicação Compose em um repositório
Nesta etapa, aprenderemos como publicar nossa aplicação Docker Compose em um repositório. Publicar uma aplicação Compose normalmente envolve compartilhar o arquivo docker-compose.yaml e garantir que as imagens Docker necessárias sejam acessíveis a partir de um container registry.
Primeiro, vamos parar a aplicação Docker Compose em execução da etapa anterior. Navegue até o diretório ~/project se você ainda não estiver lá.
cd ~/project
Agora, pare os serviços em execução usando o comando docker-compose down. Este comando para e remove containers, redes e volumes criados por up.
docker-compose down
Você deve ver uma saída indicando que os serviços estão sendo parados e removidos.
Para publicar a aplicação Compose, precisamos compartilhar o arquivo docker-compose.yaml. Em um cenário real, você normalmente armazenaria este arquivo em um sistema de controle de versão como o Git e o enviaria para um repositório (por exemplo, GitHub, GitLab, Bitbucket).
Para este laboratório, simularemos a publicação criando um arquivo de texto simples que contém o conteúdo do nosso arquivo docker-compose.yaml. Isso demonstra a ideia central de compartilhar a configuração.
Vamos criar um arquivo chamado compose_app.txt no diretório ~/project e copiar o conteúdo de docker-compose.yaml para ele.
cat ~/project/docker-compose.yaml > ~/project/compose_app.txt
Agora, você pode visualizar o conteúdo do novo arquivo para confirmar que é o mesmo que o docker-compose.yaml.
cat ~/project/compose_app.txt
Você deve ver o conteúdo YAML do seu arquivo Compose.
Em um cenário de publicação real, você também precisaria garantir que as imagens Docker referenciadas no seu arquivo docker-compose.yaml estejam disponíveis em um container registry que outros possam acessar. Em nosso caso, a imagem nginx:latest está publicamente disponível no Docker Hub, então nenhuma etapa extra é necessária para esta imagem específica. Se você estivesse usando imagens personalizadas, precisaria construí-las e enviá-las para um registry.
Por exemplo, se você tivesse uma imagem personalizada chamada my-custom-app, você a construiria usando docker build e, em seguida, a enviaria para um registry como o Docker Hub usando docker push seu-nome-de-usuario-dockerhub/my-custom-app.
Para simular o compartilhamento do arquivo Compose, imagine que você está compartilhando o arquivo compose_app.txt com alguém. Eles poderiam então baixar este arquivo e usá-lo para executar a aplicação em sua própria máquina, desde que tenham o Docker e o Docker Compose instalados e possam acessar as imagens necessárias.
Para demonstrar isso, vamos remover o arquivo docker-compose.yaml original e, em seguida, recriá-lo a partir de compose_app.txt.
rm ~/project/docker-compose.yaml
cat ~/project/compose_app.txt > ~/project/docker-compose.yaml
Agora, você pode verificar se o arquivo docker-compose.yaml foi recriado.
cat ~/project/docker-compose.yaml
Você deve ver o mesmo conteúdo YAML de antes.
Esta etapa se concentrou no conceito de compartilhamento do arquivo Compose. Nas próximas etapas, exploraremos aspectos mais avançados da publicação, como o uso de image digests e o tratamento de variáveis de ambiente.
Publicar a aplicação Compose com digests de imagem resolvidos
Nesta etapa, aprenderemos como publicar uma aplicação Compose usando image digests resolvidos. Usar image digests em vez de tags (como latest) fornece uma maneira mais confiável de garantir que você está sempre usando exatamente a mesma versão da imagem. As tags podem ser atualizadas para apontar para uma nova imagem, enquanto um digest identifica exclusivamente uma camada de imagem específica.
Primeiro, vamos obter o digest para a imagem nginx:latest que usamos nas etapas anteriores. Podemos usar o comando docker inspect para obter informações detalhadas sobre a imagem.
docker inspect nginx:latest --format='{{.RepoDigests}}'
Este comando exibirá os repository digests para a imagem nginx:latest. A saída terá uma aparência semelhante a [nginx@sha256:...]. A parte após @ é o image digest. Copie este digest.
Agora, modificaremos nosso arquivo docker-compose.yaml para usar o image digest em vez da tag. Abra o arquivo docker-compose.yaml no diretório ~/project usando nano.
nano ~/project/docker-compose.yaml
Altere a linha image de image: nginx:latest para image: nginx@<your_image_digest>, substituindo <your_image_digest> pelo digest que você copiou. Por exemplo, se seu digest fosse sha256:abcdef123456..., a linha seria image: nginx@sha256:abcdef123456....
version: "3.8"
services:
web:
image: nginx@sha256:your_image_digest_here
ports:
- "80:80"
Salve o arquivo pressionando Ctrl + S e saia do editor pressionando Ctrl + X.
Agora, quando você compartilhar este arquivo docker-compose.yaml, qualquer pessoa que o usar fará o pull da imagem exata identificada pelo digest, independentemente do que a tag latest possa estar apontando atualmente.
Para demonstrar que o Compose usa o digest, vamos iniciar a aplicação novamente usando o docker-compose.yaml modificado.
docker-compose up -d
O Compose usará a imagem especificada pelo digest. Se a imagem ainda não estiver presente no sistema, ela será baixada.
Você pode verificar se o container está em execução e usando a imagem especificada pelo digest inspecionando o container em execução. Primeiro, encontre o ID do container usando docker ps.
docker ps
Procure o container executando a imagem nginx e anote seu Container ID. Em seguida, use docker inspect com o Container ID e formate a saída para mostrar o image digest.
docker inspect < container_id > --format='{{.Image}}'
Substitua <container_id> pelo ID real do seu container Nginx em execução. A saída deve ser o image digest que você especificou no arquivo docker-compose.yaml.
Usar image digests em seus arquivos Compose é uma boa prática para garantir a reprodutibilidade e evitar alterações inesperadas em sua aplicação devido a atualizações de imagem.
Publicar a aplicação Compose incluindo variáveis de ambiente
Nesta etapa, aprenderemos como incluir variáveis de ambiente em nossa aplicação Docker Compose e como isso afeta a publicação. Variáveis de ambiente são uma maneira comum de configurar aplicações, e o Docker Compose oferece várias maneiras de gerenciá-las.
Primeiro, vamos parar o container Nginx em execução da etapa anterior. Navegue até o diretório ~/project se você ainda não estiver lá.
cd ~/project
Pare os serviços em execução usando o comando docker-compose down.
docker-compose down
Agora, vamos modificar nosso arquivo docker-compose.yaml para usar uma variável de ambiente. Adicionaremos uma variável de ambiente simples ao serviço web. Abra o arquivo docker-compose.yaml no diretório ~/project usando nano.
nano ~/project/docker-compose.yaml
Adicione uma seção environment à definição do serviço web. Adicionaremos uma variável chamada MY_VARIABLE com um valor.
version: "3.8"
services:
web:
image: nginx@sha256:your_image_digest_here ## Substitua pelo seu digest real
ports:
- "80:80"
environment:
- MY_VARIABLE=HelloFromCompose
Lembre-se de substituir your_image_digest_here pelo image digest real que você obteve na etapa anterior.
Salve o arquivo pressionando Ctrl + S e saia do editor pressionando Ctrl + X.
Agora, quando você iniciar a aplicação com docker-compose up, a variável de ambiente MY_VARIABLE será definida dentro do container Nginx.
docker-compose up -d
Para verificar se a variável de ambiente está definida dentro do container, podemos executar um comando dentro do container em execução usando docker exec. Primeiro, encontre o ID do container usando docker ps.
docker ps
Anote o Container ID do container Nginx em execução. Em seguida, use docker exec para executar o comando printenv dentro do container e filtrar a saída para MY_VARIABLE.
docker exec < container_id > printenv | grep MY_VARIABLE
Substitua <container_id> pelo ID real do seu container Nginx em execução. Você deve ver uma saída semelhante a MY_VARIABLE=HelloFromCompose.
Ao publicar uma aplicação Compose que usa variáveis de ambiente, você precisa considerar como essas variáveis serão fornecidas no ambiente de destino.
Uma abordagem comum é usar um arquivo .env. O Docker Compose procura automaticamente um arquivo chamado .env no diretório onde o arquivo docker-compose.yaml está localizado. Você pode definir variáveis de ambiente neste arquivo, e o Compose as carregará.
Vamos criar um arquivo .env no diretório ~/project.
nano ~/project/.env
Adicione o seguinte conteúdo ao arquivo .env:
ANOTHER_VARIABLE=ThisIsFromDotEnv
Salve o arquivo e saia do nano.
Agora, vamos modificar o arquivo docker-compose.yaml para usar esta nova variável de ambiente. Abra o arquivo docker-compose.yaml novamente.
nano ~/project/docker-compose.yaml
Adicione ANOTHER_VARIABLE à seção environment.
version: "3.8"
services:
web:
image: nginx@sha256:your_image_digest_here ## Substitua pelo seu digest real
ports:
- "80:80"
environment:
- MY_VARIABLE=HelloFromCompose
- ANOTHER_VARIABLE
Observe que para ANOTHER_VARIABLE, apenas listamos o nome da variável. O Compose procurará esta variável no ambiente onde docker-compose up é executado, incluindo variáveis carregadas do arquivo .env.
Salve o arquivo e saia do nano.
Agora, pare e reinicie a aplicação Compose para pegar as alterações.
docker-compose down
docker-compose up -d
Obtenha o novo ID do container usando docker ps.
docker ps
Agora, use docker exec para verificar ambas as variáveis de ambiente dentro do container.
docker exec < container_id > printenv | grep MY_VARIABLE
docker exec < container_id > printenv | grep ANOTHER_VARIABLE
Substitua <container_id> pelo novo Container ID. Você deve ver tanto MY_VARIABLE=HelloFromCompose quanto ANOTHER_VARIABLE=ThisIsFromDotEnv na saída.
Ao publicar, você normalmente compartilharia o arquivo docker-compose.yaml e forneceria instruções sobre como definir as variáveis de ambiente necessárias, seja por meio de um arquivo .env ou definindo-as diretamente no ambiente onde o Compose é executado. Informações sensíveis não devem ser codificadas no docker-compose.yaml ou nos arquivos .env e devem ser gerenciadas usando soluções de gerenciamento de segredos.
Resumo
Neste laboratório, aprendemos como preparar uma aplicação Docker Compose simples. Isso envolveu a instalação do Docker Compose, a verificação de sua instalação e a criação de um arquivo docker-compose.yaml para definir um serviço web Nginx básico. Também fizemos o pull da imagem Docker necessária (nginx:latest) em preparação para executar a aplicação.
As etapas subsequentes, que não foram totalmente detalhadas no conteúdo fornecido, provavelmente cobririam a publicação desta aplicação Compose em um repositório usando o comando docker compose alpha publish. Isso incluiria a exploração de opções como a publicação com image digests resolvidos e a inclusão de variáveis de ambiente na definição da aplicação publicada.
