Pular para o conteúdo principal

TP12.2 - Pipeline CI/CD e Deploy

Objetivos do Exercício Prático​

Neste exercício, você irá:

  1. ✅ Criar um workflow completo do GitHub Actions
  2. ✅ Automatizar testes, build e publicação Docker
  3. ✅ Fazer deploy na Railway (ou alternativa)
  4. ✅ Configurar deploy automático

Duração estimada: 1h30

Pré-requisitos: TP12.1 finalizado, conta no GitHub, conta na Railway

Contexto​

Você irá automatizar o deploy do aplicativo Todo do TP12.1. Cada push na branch main dispara:

  1. Testes automáticos
  2. Build da imagem Docker
  3. Publicação no Docker Hub
  4. Deploy na Railway

Parte 1: Preparação​

Estrutura de Arquivos​

.github/
└── workflows/
    ├── ci.yml           # Testes em cada PR
    ├── cd.yml           # Build + Deploy na main
    └── docker-publish.yml  # Publicação Docker

Criar os Secrets no GitHub​

Vá em: Repositório → Settings → Secrets and variables → Actions

# Docker Hub
DOCKERHUB_USERNAME=seu-username
DOCKERHUB_TOKEN=seu-token

# Railway
RAILWAY_TOKEN=seu-token

# (Opcional) Heroku
HEROKU_API_KEY=sua-api-key
HEROKU_APP_NAME=seu-app
HEROKU_EMAIL=seu-email

Parte 2: Workflow CI (Testes)​

.github/workflows/ci.yml​

name: CI - Tests

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    name: Run Tests
    runs-on: ubuntu-latest
    
    services:
      postgres:
        image: postgres:15-alpine
        env:
          POSTGRES_DB: testdb
          POSTGRES_USER: test
          POSTGRES_PASSWORD: test
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
    
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      
      - name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          distribution: 'temurin'
          java-version: '17'
          cache: 'maven'
      
      - name: Run Unit Tests
        run: mvn test -Dspring.profiles.active=test
      
      - name: Run Integration Tests
        run: mvn verify -Dspring.profiles.active=test
        env:
          SPRING_DATASOURCE_URL: jdbc:postgresql://localhost:5432/testdb
          SPRING_DATASOURCE_USERNAME: test
          SPRING_DATASOURCE_PASSWORD: test
      
      - name: Upload Test Results
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: test-results
          path: target/surefire-reports/
      
      - name: Generate Coverage Report
        run: mvn jacoco:report
      
      - name: Upload Coverage
        uses: codecov/codecov-action@v3
        with:
          files: target/site/jacoco/jacoco.xml
          fail_ci_if_error: false

Parte 3: Workflow CD (Build & Deploy)​

.github/workflows/cd.yml​

name: CD - Build and Deploy

on:
  push:
    branches: [main]
  release:
    types: [published]

env:
  REGISTRY: docker.io
  IMAGE_NAME: ${{ secrets.DOCKERHUB_USERNAME }}/todo-app

jobs:
  # ===== JOB 1: Test =====
  test:
    name: Test
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          distribution: 'temurin'
          java-version: '17'
          cache: 'maven'
      
      - name: Run Tests
        run: mvn test

  # ===== JOB 2: Build Docker =====
  build:
    name: Build and Push Docker
    runs-on: ubuntu-latest
    needs: test
    
    outputs:
      image-tag: ${{ steps.meta.outputs.tags }}
      version: ${{ steps.meta.outputs.version }}
    
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
      
      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}
      
      - name: Extract metadata
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ env.IMAGE_NAME }}
          tags: |
            type=ref,event=branch
            type=sha,prefix=
            type=raw,value=latest,enable=${{ github.ref == 'refs/heads/main' }}
      
      - name: Build and push
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha
          cache-to: type=gha,mode=max
      
      - name: Print image info
        run: |
          echo "Image pushed: ${{ env.IMAGE_NAME }}"
          echo "Tags: ${{ steps.meta.outputs.tags }}"

  # ===== JOB 3: Deploy to Railway =====
  deploy:
    name: Deploy to Railway
    runs-on: ubuntu-latest
    needs: build
    if: github.ref == 'refs/heads/main'
    environment: production
    
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      
      - name: Install Railway CLI
        run: npm i -g @railway/cli
      
      - name: Deploy to Railway
        run: railway up --detach
        env:
          RAILWAY_TOKEN: ${{ secrets.RAILWAY_TOKEN }}
      
      - name: Print deployment info
        run: |
          echo "✅ Deployed to Railway!"
          echo "Image: ${{ needs.build.outputs.image-tag }}"

Parte 4: Configuração Railway​

Criar um Projeto Railway​

  1. Acesse railway.app
  2. "New Project" → "Empty Project"
  3. "Add Service" → "GitHub Repo" → Selecione seu repositório
  4. "Add Database" → "PostgreSQL"

Obter o Token Railway​

  1. Account Settings → Tokens
  2. "Create Token"
  3. Copie o token para os Secrets do GitHub

Variáveis de Ambiente Railway​

No dashboard da Railway, configure:

SPRING_PROFILES_ACTIVE=prod
DATABASE_URL=${{Postgres.DATABASE_URL}}
# A Railway injeta automaticamente DATABASE_URL do PostgreSQL

railway.json (opcional)​

{
  "$schema": "https://railway.app/railway.schema.json",
  "build": {
    "builder": "DOCKERFILE",
    "dockerfilePath": "Dockerfile"
  },
  "deploy": {
    "numReplicas": 1,
    "healthcheckPath": "/actuator/health",
    "healthcheckTimeout": 30,
    "restartPolicyType": "ON_FAILURE",
    "restartPolicyMaxRetries": 3
  }
}

Parte 5: Alternativa Heroku​

.github/workflows/deploy-heroku.yml​

name: Deploy to Heroku

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      
      - name: Deploy to Heroku
        uses: akhileshns/heroku-deploy@v3.12.14
        with:
          heroku_api_key: ${{ secrets.HEROKU_API_KEY }}
          heroku_app_name: ${{ secrets.HEROKU_APP_NAME }}
          heroku_email: ${{ secrets.HEROKU_EMAIL }}
          usedocker: true

Arquivos Necessários para Heroku​

heroku.yml:

build:
  docker:
    web: Dockerfile
run:
  web: java -Dserver.port=$PORT -jar app.jar

Parte 6: Testar o Pipeline​

1. Push Inicial​

git add .
git commit -m "Add CI/CD pipeline"
git push origin main

2. Verificar GitHub Actions​

  1. Vá até a aba Actions
  2. Verifique se o workflow está rodando
  3. Cada job deve ficar verde ✅

3. Verificar Docker Hub​

  1. Acesse hub.docker.com
  2. Verifique se a imagem foi publicada
  3. Verifique as tags

4. Verificar o Deploy​

# Railway
curl https://your-app.railway.app/actuator/health

# Ou Heroku
curl https://your-app.herokuapp.com/actuator/health

Parte 7: Workflow com Notificações​

Notificações Slack/Discord​

  notify:
    name: Notify
    runs-on: ubuntu-latest
    needs: [deploy]
    if: always()
    
    steps:
      - name: Send Slack notification
        uses: 8398a7/action-slack@v3
        with:
          status: ${{ job.status }}
          fields: repo,message,commit,author,action,eventName,ref,workflow
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK }}
        if: always()

Parte 8: Badge de Status​

Adicionar ao README.md​

# Todo App

![CI Status](https://github.com/YOUR_USERNAME/todo-app/workflows/CI%20-%20Tests/badge.svg)
![CD Status](https://github.com/YOUR_USERNAME/todo-app/workflows/CD%20-%20Build%20and%20Deploy/badge.svg)

## Descrição
Aplicação de gerenciamento de tarefas com Spring Boot.

## Links
- Produção: https://your-app.railway.app
- API Docs: https://your-app.railway.app/swagger-ui.html

Verificação Final​

Checklist​

  • Push dispara o workflow CI
  • Testes passam no GitHub Actions
  • Imagem Docker publicada no Docker Hub
  • Aplicação implantada na Railway
  • /actuator/health retorna UP
  • A API funciona em produção

URLs para Verificar​

# Health check
curl https://your-app.railway.app/actuator/health

# API
curl https://your-app.railway.app/api/todos

# Criar um todo em produção
curl -X POST https://your-app.railway.app/api/todos \
  -H "Content-Type: application/json" \
  -d '{"title": "Testando em produção!"}'

🎯 Módulo Concluído!​

Parabéns! Você concluiu o Módulo 12 - Deploy e Produção.

Resumo:

  • Capítulo 1: Preparação para produção
  • Capítulo 2: Docker e conteinerização
  • Capítulo 3: CI/CD com GitHub Actions
  • Capítulo 4: Deploy em nuvem
  • TP12.1: Dockerização completa
  • TP12.2: Pipeline CI/CD

Competências adquiridas:

  • ✅ Perfis Spring Boot (dev, prod, docker)
  • ✅ Dockerfile multi-stage otimizado
  • ✅ Docker Compose com PostgreSQL
  • ✅ Workflows GitHub Actions
  • ✅ Deploy automático na Railway
  • ✅ Monitoramento e health checks

➡️ Voltar ao Módulo 12

⬅️ Voltar ao Plano de Curso