Laboratório: Pipeline CI/CD com Docker Compose e GitLab CE

Duração estimada

120 min

Passos

12

Validações

5

Versões da documentação consultada

Docker Engine a versão estável atual · Docker Compose a versão estável atual · GitLab CE a versão estável atual · GitLab Runner a versão estável atual

Topologia

Três máquinas virtuais: uma para o GitLab CE (192.168.56.10), uma para o runner GitLab (192.168.56.11) e uma para o ambiente de produção Docker Compose (192.168.56.12). O runner executa jobs definidos no repositório GitLab, que constroem e publicam imagens Docker para um registry privado, depois fazem deploy em produção via Compose.

           +---------------------+
           |     GitLab CE      |
           | 192.168.56.10      |
           +---------------------+
                    |
                    |
           +---------------------+
           |   GitLab Runner     |
           | 192.168.56.11      |
           +---------------------+
                    |
                    |
           +---------------------+
           | Docker Compose Host |
           | 192.168.56.12      |
           +---------------------+

Equipamentos e software

Roteiro

1. Preparar as VMs

   Crie três VMs Ubuntu 22.04 em sua máquina local ou ambiente virtualizado. Separe IPs privados para cada uma.

   O que você deve ver: Três sistemas acessíveis via SSH, cada um com seu IP.

2. Instalar Docker Engine e Compose

   No runner e no host de produção, instale Docker Engine e Docker Compose. O runner precisa construir imagens e o host vai rodar containers.

   sudo apt-get update
   sudo apt-get install -y ca-certificates curl gnupg
   sudo install -m 0755 -d /etc/apt/keyrings
   curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
   sudo chmod a+r /etc/apt/keyrings/docker.gpg
   echo "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
   sudo apt-get update
   sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
   sudo usermod -aG docker $USERCopiar

   O que você deve ver: Comando 'docker version' e 'docker compose version' retornam versões instaladas.

3. Instalar GitLab CE

   No servidor GitLab CE, instale a versão Community Edition seguindo o guia oficial.

   sudo apt-get update
   sudo apt-get install -y curl openssh-server ca-certificates tzdata perl
   curl https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.deb.sh | sudo bash
   sudo EXTERNAL_URL="http://192.168.56.10" apt-get install gitlab-ceCopiar

   O que você deve ver: A interface web do GitLab CE disponível em http://192.168.56.10.

4. Instalar GitLab Runner

   No runner, instale o GitLab Runner para executar jobs do pipeline.

   sudo apt-get install -y curl
   curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh | sudo bash
   sudo apt-get install gitlab-runnerCopiar

   O que você deve ver: Comando 'gitlab-runner --version' retorna versão instalada.

5. Registrar o Runner no GitLab

   No runner, registre o GitLab Runner usando o token do GitLab CE. Isso conecta o runner ao seu projeto.

   sudo gitlab-runner registerCopiar

   O que você deve ver: Runner aparece como ativo na interface do projeto no GitLab CE.

6. Criar um projeto de exemplo

   No GitLab CE, crie um novo projeto chamado 'webapp-docker'. Clone o repositório em sua máquina local.

   git clone http://192.168.56.10/usuario/webapp-docker.gitCopiar

   O que você deve ver: Repositório clonado com sucesso.

7. Adicionar aplicação de exemplo

   Adicione um app simples em Python Flask ao repositório. Crie os arquivos 'app.py', 'requirements.txt', 'Dockerfile' e 'docker-compose.yml'.

   echo "from flask import Flask
   app = Flask(__name__)
   @app.route('/')
   def hello():
       return 'Hello, Docker!'
   if __name__ == '__main__':
       app.run(host='0.0.0.0')" > app.py
   echo "flask" > requirements.txt
   echo "FROM python:3.11-slim
   WORKDIR /app
   COPY requirements.txt .
   RUN pip install --no-cache-dir -r requirements.txt
   COPY . .
   CMD [\"python\", \"app.py\"]" > Dockerfile
   echo "version: '3.8'
   services:
     web:
       build: .
       ports:
         - '5000:5000'" > docker-compose.ymlCopiar

   O que você deve ver: Arquivos criados no repositório local.

8. Configurar o registry privado do GitLab

   No GitLab CE, habilite o Container Registry (já vem habilitado por padrão, consulte a documentação para detalhes).

   O que você deve ver: URL do registry disponível na interface do projeto.

9. Adicionar pipeline .gitlab-ci.yml

   No repositório, crie o arquivo '.gitlab-ci.yml' para definir o pipeline de build, push e deploy.

   echo "stages:
     - build
     - deploy
   
   build-image:
     stage: build
     script:
       - docker build -t registry.192.168.56.10/usuario/webapp-docker:latest .
       - echo \"$CI_REGISTRY_PASSWORD\" | docker login -u \"$CI_REGISTRY_USER\" --password-stdin registry.192.168.56.10
       - docker push registry.192.168.56.10/usuario/webapp-docker:latest
     only:
       - main
   
   deploy:
     stage: deploy
     script:
       - ssh usuario@192.168.56.12 'docker pull registry.192.168.56.10/usuario/webapp-docker:latest && cd /home/usuario/webapp-docker && docker compose up -d'
     only:
       - main" > .gitlab-ci.ymlCopiar

   O que você deve ver: Arquivo .gitlab-ci.yml criado.

10. Configurar acesso SSH do Runner ao host de produção

    No runner, gere uma chave SSH e adicione a chave pública ao arquivo 'authorized_keys' do usuário no host de produção.

    ssh-keygen -t ed25519 -C "gitlab-runner"
    ssh-copy-id usuario@192.168.56.12Copiar

    O que você deve ver: Runner pode acessar o host de produção via SSH sem senha.

11. Fazer o primeiro push e rodar o pipeline

    Adicione, commite e faça push dos arquivos para o GitLab CE. O pipeline será disparado automaticamente.

    git add .
    git commit -m "App inicial"
    git push origin mainCopiar

    O que você deve ver: Pipeline inicia no GitLab CE e mostra logs de build, push e deploy.

12. Verificar o deploy em produção

    No host de produção, verifique se o container está rodando e a aplicação responde.

    docker ps
    curl http://192.168.56.12:5000Copiar

    O que você deve ver: Container do Flask rodando e resposta 'Hello, Docker!' no curl.

Como saber que funcionou

Troubleshooting

Segurança e hardening

• Utilize senhas fortes nos usuários das VMs.
• Restrinja o acesso SSH apenas ao runner e admin.
• Não exponha o registry do GitLab para a internet sem autenticação.
• Configure variáveis de ambiente sensíveis (como CI_REGISTRY_PASSWORD) apenas no escopo necessário.
• Atualize sempre as imagens base do Dockerfile.

Checklist final

• VMs criadas e acessíveis
• Docker Engine e Compose instalados
• GitLab CE e Runner instalados e integrados
• Projeto com app Flask e Dockerfile
• Pipeline CI/CD funcionando
• Deploy automático em produção com Docker Compose