Trabalhos práticos Intermédio Gratuito
Trabalhos práticos Docker e Docker Compose
Três oficinas progressivas: construir, parametrizar e expor depois uma aplicação multisserviços com Compose.
- 3 oficinas
- 53 etapas
Fundamentos de Docker Compose
Construir e lançar uma aplicação multisserviços com dois Dockerfiles personalizados.
3h30 · indicativo Fundamentos 18 etapas
Uma página HTML chama a API PHP; o MariaDB é acessível no phpMyAdmin; uma mensagem de teste aparece no Mailpit.
Pré-requisitos
- Docker Engine ou Docker Desktop e Docker Compose V2 disponíveis
- Terminal, navegador e ligação à Internet para o primeiro build
- Pack dos estudantes: pasta ateliers/niveau-1/
Tomar conta do projeto
-
Etapa 1 : Verificar os pré-requisitos
Explicar a diferença entre Docker Engine, imagem, contentor e Compose.
docker version && docker compose versionAs versões são apresentadas sem erro.
-
Etapa 2 : Explorar a arborescência
Em ateliers/niveau-1, identificar compose.yaml, api/Dockerfile, app/Dockerfile e as fontes PHP/HTML/SCSS.
Os dois serviços construídos e as três imagens utilizadas diretamente estão identificados.
-
Etapa 3 : Definir o papel dos cinco serviços
Associar api, app, db, phpmyadmin e mailer às suas funções; precisar que o Mailpit recebe e-mails apenas a título de teste.
O esquema das trocas navegador → app/API → base de dados ou SMTP é explicado.
Criar as imagens personalizadas
-
Etapa 4 : Dockerfile da API: partir do Debian
Completar FROM, WORKDIR e a cópia das fontes; mostrar que o Debian não traz PHP pronto a utilizar.
cat api/DockerfileO Dockerfile identifica corretamente a sua imagem de base e o seu diretório de trabalho.
-
Etapa 5 : Instalar o PHP com RUN
Acrescentar php-cli, php-mysql, php-mbstring e as dependências através de apt-get; limpar as listas APT.
Os comandos RUN preparam as dependências durante o build.
-
Etapa 6 : Instalar o Composer e as dependências PHP
Instalar o Composer com verificação de assinatura; executar composer install a partir de composer.json.
O Composer está presente na imagem e as dependências estão instaladas.
-
Etapa 7 : Iniciar a API PHP
Preencher EXPOSE 8000 e CMD do servidor PHP de desenvolvimento. Distinguir a documentação de uma porta da publicação dessa porta pelo Compose.
A API escuta em 0.0.0.0:8000 no contentor.
-
Etapa 8 : Dockerfile da app: compilar os SCSS com o Node
Utilizar uma etapa Node para instalar o Sass e construir os ficheiros CSS.
A geração do CSS faz-se durante docker build.
-
Etapa 9 : Servir o frontend com o Nginx
Criar uma segunda etapa FROM nginx e copiar os recursos produzidos a partir da etapa Node.
A imagem final serve HTML/CSS/JS sem motor Node de execução.
Montar a stack Compose
-
Etapa 10 : Configurar o MariaDB
Declarar db através de image, environment e de um volume com nome; explicar o interesse da persistência.
db_data protege os ficheiros de dados contra a recriação ordinária do contentor.
-
Etapa 11 : Configurar o phpMyAdmin e o Mailpit
Utilizar as imagens existentes. Definir PMA_HOST=db e a interface web do Mailpit em 8025.
O phpMyAdmin visa db; o Mailpit recebe o SMTP da API em mailer:1025.
-
Etapa 12 : Configurar api e app com build
Preencher build.context e dockerfile para os dois serviços personalizados. Definir a ligação a db e ao SMTP, as dependências e as portas.
Os cinco serviços dispõem dos seus parâmetros essenciais.
-
Etapa 13 : Validar e construir o projeto
Corrigir os erros assinalados pelo Docker Compose; criar e lançar as imagens.
docker compose config && docker compose up -d --buildO comando termina sem erro e constrói api e app.
-
Etapa 14 : Observar os contentores e diagnosticar
Identificar os serviços iniciados, consultar os registos da API ou da base de dados, se necessário.
docker compose ps && docker compose logs --tail=60 apiOs serviços úteis estão em execução e o MariaDB passa a healthy.
Verificar o funcionamento de ponta a ponta
-
Etapa 15 : Verificar a interface e o Hello World
Abrir http://localhost:8080 e testar depois a resposta JSON do backend através do proxy Nginx.
curl -i http://localhost:8080/api/helloA página apresenta as informações transmitidas pela API.
-
Etapa 16 : Testar a base de dados
Aceder a http://localhost:8081, ligar-se com as credenciais fictícias do TP e identificar a base de dados tp_docker.
A ligação do phpMyAdmin ao MariaDB funciona.
-
Etapa 17 : Enviar uma mensagem de teste
Submeter o formulário, observar o registo na base de dados e a mensagem em http://localhost:8025.
curl -s -X POST http://localhost:8080/api/messages -H "Content-Type: application/json" -d '{"sender":"TP","content":"Bonjour Docker"}'Uma linha é criada na base de dados e um e-mail aparece no Mailpit.
-
Etapa 18 : Parar sem perder os volumes
Parar a stack e explicar a diferença entre down e down -v.
docker compose downOs contentores e a rede são eliminados; os volumes com nome são conservados.
Recursos
- Docker Compose — conceitos — Compreender projeto, serviço, rede e volume
- Referência do Dockerfile — Definição das instruções FROM, RUN, COPY, CMD, ARG e ENV
- Docker Compose — referência dos serviços — Sintaxe dos serviços, ports, environment, build e depends_on
- Build multi-stage — Utilizar o Node no build sem o conservar no contentor final
- Sass — CLI — Compilar ficheiros SCSS
- Mailpit — imagens Docker — Interface de captura de e-mails e porta SMTP interna
- phpMyAdmin — imagem Docker — Parâmetros PMA_HOST e ligação ao MariaDB
Configuração dinâmica com .env
Externalizar os valores, parametrizar os builds e distinguir ARG, ENV e interpolação Compose.
3h30 · indicativo Parametrização 17 etapas
A stack é reconstruída a partir de versões e parâmetros definidos em .env, e os estudantes explicam o que atua no build ou na execução.
Pré-requisitos
- Nível 1 concluído ou funcionamento do Docker Compose já dominado
- Pack dos estudantes: pasta ateliers/niveau-2/
- Compreender as diferenças entre o ficheiro .env, a interpolação YAML e as variáveis no contentor
Preparar os valores do projeto
-
Etapa 1 : Criar o ficheiro .env
Copiar o modelo fornecido na pasta do nível 2; verificar a diferença entre o modelo partilhado e os valores próprios do posto.
cp .env.example .envUm ficheiro .env está presente e não se destina a ser versionado.
-
Etapa 2 : Identificar as variáveis de imagens
Identificar DEBIAN_TAG, PHP_VERSION, NODE_VERSION, NGINX_VERSION, MARIADB_VERSION, PHPMYADMIN_VERSION e MAILPIT_VERSION.
As versões servem para selecionar uma base de build ou uma tag de imagem.
-
Etapa 3 : Identificar as portas e as credenciais
Identificar APP_PORT, API_PORT, PHPMYADMIN_PORT, MAILPIT_PORT e os parâmetros DB_*.
A correspondência entre os valores do .env e as portas/variáveis de execução é explicada.
-
Etapa 4 : Distinguir .env e environment
Compreender que uma variável do .env não aparece automaticamente num contentor: deve ser referenciada no Compose, se necessário.
As variáveis injetadas em api e db estão identificadas com precisão.
Parametrizar os Dockerfiles com ARG e ENV
-
Etapa 5 : Configurar o Debian e o PHP no build
Introduzir ARG DEBIAN_TAG antes de FROM e depois ARG PHP_VERSION para escolher o nome dos pacotes instalados pelo APT.
O papel dos dois ARG e o seu âmbito são conhecidos.
-
Etapa 6 : Verificar a disponibilidade real do PHP
Não presumir que um valor arbitrário de PHP_VERSION existe nos repositórios da imagem Debian selecionada.
O estudante sabe explicar uma falha de apt-get devida a uma versão indisponível.
-
Etapa 7 : Preencher ENV para a API
Utilizar ENV APP_ENV=development e reconhecer que um valor ENV pode ser sobrescrito pelo Compose.
APP_ENV é visível na execução e distinto dos ARG de build.
-
Etapa 8 : Parametrizar o build multi-stage do front-end
Definir NODE_VERSION antes de FROM node e NGINX_VERSION antes de FROM nginx, com o âmbito correto para cada etapa.
As duas etapas do Dockerfile selecionam as versões esperadas.
Interpretar e aplicar o Compose
-
Etapa 9 : Injetar os argumentos de build
Completar build.args para api e app utilizando as variáveis `${…}` do ficheiro .env.
A configuração resolvida contém os argumentos de build esperados.
-
Etapa 10 : Tornar as imagens e as portas parametrizáveis
Utilizar a interpolação nas tags MariaDB/phpMyAdmin/Mailpit e nas portas publicadas no lado do anfitrião.
Os valores ficam centralizados sem modificar as fontes Compose.
-
Etapa 11 : Conhecer os valores por omissão e obrigatórios
Explicar `${VAR:-valeur}` e `${VAR:?message}`; analisar o erro produzido quando falta uma variável obrigatória.
O Compose recusa uma configuração desprovida de uma variável obrigatória.
-
Etapa 12 : Apresentar a configuração efetivamente resolvida
Verificar a interpolação evitando partilhar as saídas que contêm credenciais.
docker compose config --environment && docker compose configAs tags, as portas e os build.args correspondem ao .env.
-
Etapa 13 : Reconstruir e reiniciar a stack
Reconstruir as imagens personalizadas e verificar os serviços e depois o acesso HTML/API.
docker compose up -d --build && docker compose psOs cinco serviços estão ativos e o Hello World funciona.
Testar as consequências de uma alteração
-
Etapa 14 : Testar uma porta personalizada
Alterar temporariamente APP_PORT no .env, recriar os serviços se necessário e controlar depois o novo URL.
docker compose up -d && docker compose psO navegador responde na porta do anfitrião indicada em .env.
-
Etapa 15 : Verificar o ambiente do contentor
Observar APP_ENV no contentor da API e descrever a diferença entre build e execução.
docker compose exec api printenv APP_ENVO valor devolvido é coerente com a configuração.
-
Etapa 16 : Compreender os limites do volume MariaDB
Explicar porque modificar DB_PASSWORD não altera automaticamente um utilizador já criado no volume existente.
O estudante identifica o risco associado a down -v (destruição dos dados).
-
Etapa 17 : Justificar a proteção dos segredos
Verificar .gitignore, não publicar as palavras-passe do TP, citar uma solução de segredos para um contexto real.
O ficheiro .env sensível está excluído do repositório e os limites do método são compreendidos.
Recursos
- Docker Compose — conceitos — Compreender projeto, serviço, rede e volume
- Referência do Dockerfile — Definição das instruções FROM, RUN, COPY, CMD, ARG e ENV
- Variáveis e interpolação Compose — Sintaxes ${VAR}, ${VAR:-defaut} e ${VAR:?obligatoire}
- Variáveis nos contentores — Comportamento da chave environment
- ARG e ENV no Dockerfile — Âmbito e utilizações dos argumentos de build e das variáveis de ambiente
- Segurança dos segredos Docker — Porque é que o .env não é um cofre de segredos
Traefik e reverse proxy
Centralizar a entrada HTTP, encaminhar por anfitrião e caminho e isolar as redes.
3h30 · indicativo Rede e exposição 18 etapas
O Traefik expõe a aplicação, a API, o phpMyAdmin e o Mailpit a partir de uma única porta HTTP local, enquanto o MariaDB permanece na rede interna.
Pré-requisitos
- Níveis 1 e 2 concluídos ou arquitetura Docker dominada
- Pack dos estudantes: pasta ateliers/niveau-3/
- Compreender a publicação de portas, a resolução DNS e o reverse proxy
Introduzir o reverse proxy
-
Etapa 1 : Recuperar o nível 3 e o seu ambiente
Copiar .env.example para .env, examinar o compose.yaml fornecido e comparar as portas com as do nível 2.
cp .env.example .envO ficheiro de ambiente existe e os serviços estão identificados.
-
Etapa 2 : Descrever um reverse proxy
Explicar como um ponto de entrada HTTP recebe um pedido e o envia depois para um serviço interno com base numa regra.
O percurso navegador → Traefik → app/API/ferramentas está corretamente descrito.
-
Etapa 3 : Configurar o serviço Traefik
Declarar uma imagem Traefik, o provider Docker, o entrypoint web e o painel, limitando a exposição ao posto local.
O Traefik escuta no ponto de entrada HTTP configurado.
-
Etapa 4 : Compreender o socket Docker
Analisar a montagem /var/run/docker.sock:ro necessária para a descoberta automática e o seu risco de segurança.
A montagem é identificada como sensível, e não adequada tal como está a uma exposição na Internet.
-
Etapa 5 : Publicar uma única porta HTTP
Publicar 127.0.0.1:8088:80 no Traefik e retirar as publicações diretas inúteis dos serviços aplicacionais.
O acesso HTTP externo faz-se apenas através do Traefik.
Criar as rotas através de labels Docker
-
Etapa 6 : Ativar explicitamente a descoberta
Configurar exposedbydefault=false e depois os labels traefik.enable=true apenas para os serviços a expor.
Um serviço sem o label adequado não é publicado.
-
Etapa 7 : Encaminhar o frontend
Criar a regra Host(`tp.localhost`) para a porta interna 80 do Nginx.
A interface é acessível em http://tp.localhost:8088.
-
Etapa 8 : Encaminhar a API em /api
Configurar Host(`tp.localhost`) && PathPrefix(`/api`) para a porta 8000; ajustar a prioridade, se necessário.
A chamada /api/hello é tratada pela API, e não pelo Nginx.
-
Etapa 9 : Encaminhar o phpMyAdmin
Criar db.tp.localhost para a porta interna 80.
O phpMyAdmin responde no seu subdomínio de laboratório.
-
Etapa 10 : Encaminhar o Mailpit
Criar mail.tp.localhost para a porta interna 8025.
A interface do Mailpit é acessível através do Traefik.
-
Etapa 11 : Ativar um painel de laboratório
Configurar um router para api@internal e abrir depois /dashboard/ com a barra final.
O painel Traefik local descreve os routers e os serviços detetados.
Separar as comunicações de rede
-
Etapa 12 : Definir uma rede proxy
Ligar o Traefik e os serviços web à rede proxy; fixar o label traefik.docker.network quando um serviço possui várias redes.
O Traefik alcança app, api, phpMyAdmin e mailer.
-
Etapa 13 : Definir uma rede backend interna
Ligar db, api, phpmyadmin e mailer à rede backend: internal: true; excluir db da rede proxy.
A base de dados não tem nenhuma porta publicada no anfitrião.
-
Etapa 14 : Explicar o DNS interno
Justificar porque DB_HOST=db e SMTP_HOST=mailer continuam utilizáveis entre serviços mesmo depois da introdução do Traefik.
A comunicação interna não depende dos nomes *.localhost.
Arrancar, verificar e proteger
-
Etapa 15 : Analisar e lançar o Compose
Resolver as referências de redes, labels e portas e arrancar depois a stack.
docker compose config && docker compose up -d --buildA stack está operacional e o Traefik arranca corretamente.
-
Etapa 16 : Testar o encaminhamento da API
Verificar Host e PathPrefix chamando a porta do Traefik; utilizar um Host explícito se *.localhost não for resolvido.
curl -i -H "Host: tp.localhost" http://127.0.0.1:8088/api/helloA resposta JSON da API é devolvida pelo Traefik.
-
Etapa 17 : Validar as quatro interfaces
Testar tp.localhost:8088, db.tp.localhost:8088, mail.tp.localhost:8088 e traefik.tp.localhost:8088/dashboard/.
Cada interface responde e a API continua a enviar e-mails para o Mailpit.
-
Etapa 18 : Inspecionar e limpar
Examinar os registos do Traefik e as redes; parar de forma limpa sem eliminar o volume da base de dados.
docker compose logs --tail=80 traefik && docker compose downAs rotas são compreendidas; os dados do volume não são apagados.
Recursos
- Docker Compose — conceitos — Compreender projeto, serviço, rede e volume
- Referência do Dockerfile — Definição das instruções FROM, RUN, COPY, CMD, ARG e ENV
- Traefik — provider Docker — Descoberta de serviços através do provider Docker
- Traefik — routers HTTP — Regras Host, PathPrefix e prioridade das rotas
- Redes Compose — Redes isoladas, DNS Docker e conectividade dos serviços
- Segurança do Docker Engine — Riscos ligados ao acesso ao daemon e ao socket Docker
Na mesma série Etapa 2 de 2
- 1 Curso Docker e Docker Compose — O curso
-
2 TP Trabalhos práticos Docker e Docker Compose Está aqui
Na mesma categoria
Infra · Intermédio
Docker e Docker Compose — O curso
Imagens, contentores, volumes, redes e Compose: o léxico, os comandos essenciais e as boas práticas.
Infra · Intermédio
Kubernetes — O curso
Pods, implementações, serviços, configuração e armazenamento: orquestrar contentores, da teoria ao kubectl.
Infra · Intermédio
Terraform e Ansible — O curso
Descrever a infraestrutura com o Terraform e configurá-la com o Ansible: providers, playbooks, papéis e idempotência.