Infra

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
Começar o TP

Fundamentos de Docker Compose

Construir e lançar uma aplicação multisserviços com dois Dockerfiles personalizados.

3h30 · indicativo Fundamentos 18 etapas

Resultado esperado

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/

Etapas do TP

Tomar conta do projeto

  1. Etapa 1 : Verificar os pré-requisitos

    Explicar a diferença entre Docker Engine, imagem, contentor e Compose.

    docker version && docker compose version

    As versões são apresentadas sem erro.

  2. 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.

  3. 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

  1. 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/Dockerfile

    O Dockerfile identifica corretamente a sua imagem de base e o seu diretório de trabalho.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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

  1. 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.

  2. 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.

  3. 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.

  4. 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 --build

    O comando termina sem erro e constrói api e app.

  5. 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 api

    Os serviços úteis estão em execução e o MariaDB passa a healthy.

Verificar o funcionamento de ponta a ponta

  1. 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/hello

    A página apresenta as informações transmitidas pela API.

  2. 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.

  3. 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.

  4. Etapa 18 : Parar sem perder os volumes

    Parar a stack e explicar a diferença entre down e down -v.

    docker compose down

    Os contentores e a rede são eliminados; os volumes com nome são conservados.

Recursos

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

Resultado esperado

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

Etapas do TP

Preparar os valores do projeto

  1. 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 .env

    Um ficheiro .env está presente e não se destina a ser versionado.

  2. 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.

  3. 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.

  4. 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

  1. 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.

  2. 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.

  3. 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.

  4. 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

  1. 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.

  2. 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.

  3. 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.

  4. 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 config

    As tags, as portas e os build.args correspondem ao .env.

  5. 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 ps

    Os cinco serviços estão ativos e o Hello World funciona.

Testar as consequências de uma alteração

  1. 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 ps

    O navegador responde na porta do anfitrião indicada em .env.

  2. 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_ENV

    O valor devolvido é coerente com a configuração.

  3. 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).

  4. 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

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

Resultado esperado

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

Etapas do TP

Introduzir o reverse proxy

  1. 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 .env

    O ficheiro de ambiente existe e os serviços estão identificados.

  2. 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.

  3. 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.

  4. 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.

  5. 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

  1. 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.

  2. 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.

  3. 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.

  4. Etapa 9 : Encaminhar o phpMyAdmin

    Criar db.tp.localhost para a porta interna 80.

    O phpMyAdmin responde no seu subdomínio de laboratório.

  5. Etapa 10 : Encaminhar o Mailpit

    Criar mail.tp.localhost para a porta interna 8025.

    A interface do Mailpit é acessível através do Traefik.

  6. 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

  1. 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.

  2. 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.

  3. 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

  1. 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 --build

    A stack está operacional e o Traefik arranca corretamente.

  2. 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/hello

    A resposta JSON da API é devolvida pelo Traefik.

  3. 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.

  4. 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 down

    As rotas são compreendidas; os dados do volume não são apagados.

Recursos

Na mesma série Etapa 2 de 2

  1. 1 Curso Docker e Docker Compose — O curso
  2. 2 TP Trabalhos práticos Docker e Docker Compose Está aqui

Partilhar este artigo

Na mesma categoria

Curso

Infra · Intermédio

Kubernetes — O curso

Pods, implementações, serviços, configuração e armazenamento: orquestrar contentores, da teoria ao kubectl.

3 guias · 159 noções Na mesma série

Curso

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.

3 guias · 146 noções Na mesma série