CI/CD para Java: GitHub Actions da configuração à implantação

Introdução: Por que CI/CD é um must-have para desenvolvedores Java

O desenvolvimento Java moderno é impensável sem automação. Executar testes manualmente, compilar arquivos .jar e fazer deploy no servidor consomem horas e levam a erros humanos. CI/CD (Continuous Integration / Continuous Deployment) resolve esse problema: cada commit no repositório é automaticamente verificado, compilado e, se necessário, enviado para produção.

GitHub Actions é uma ferramenta integrada do GitHub que permite criar pipelines diretamente no repositório. É gratuito para projetos públicos, integra-se facilmente com Maven/Gradle e suporta Java 8–21. Neste artigo, vamos abordar o ciclo completo: desde o trigger no push até a publicação do artefato.

1. Fundamentos do GitHub Actions: estrutura do workflow

Workflow (fluxo de trabalho) é um arquivo YAML localizado em .github/workflows/. Ele consiste em:

• Triggers (push, pull_request, schedule);
• Jobs (tarefas) que são executados em máquinas virtuais (runners);
• Steps (etapas) dentro de cada tarefa.

Para um projeto Java, um workflow típico inclui instalação do JDK, execução de testes Maven/Gradle e compilação do artefato.

1.1. Primeiro workflow: testando um projeto Java

Crie o arquivo .github/workflows/ci.yml com o seguinte conteúdo:

name: Java CI

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4
    - name: Set up JDK 17
      uses: actions/setup-java@v4
      with:
        java-version: '17'
        distribution: 'temurin'
        cache: maven
    - name: Build with Maven
      run: mvn -B package --file pom.xml
    - name: Run tests
      run: mvn test

O que acontece aqui:

• actions/checkout — clona o repositório;
• setup-java — instala o JDK 17 (Temurin) e armazena em cache as dependências do Maven;
• mvn package — compila o projeto e executa os testes;
• mvn test — execução explícita dos testes (pode ser combinado com package).

Após um push no main, você verá uma marca de verificação verde ao lado do commit — isso significa que o pipeline foi bem-sucedido.

2. Configuração avançada para Java: matriz de versões e cache

Projetos reais frequentemente exigem verificação em múltiplas versões do Java. GitHub Actions suporta matriz de estratégias (matrix strategy).

2.1. Matriz JDK

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        java: [11, 17, 21]
    steps:
    - uses: actions/checkout@v4
    - name: Set up JDK ${{ matrix.java }}
      uses: actions/setup-java@v4
      with:
        java-version: ${{ matrix.java }}
        distribution: 'temurin'
        cache: maven
    - run: mvn test

Essa abordagem garante que seu código seja compatível com as versões LTS do Java. As tarefas são executadas em paralelo, economizando tempo.

2.2. Cache de dependências

Já especificamos cache: maven — isso armazena automaticamente em cache o diretório ~/.m2/repository. Para Gradle, use cache: gradle. O cache acelera a compilação em 2 a 3 vezes.

3. Compilação e publicação de artefatos (JAR/Docker)

Após testes bem-sucedidos, é necessário obter o artefato final. Vamos considerar dois cenários populares.

3.1. Upload do arquivo JAR para artefatos do GitHub

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Set up JDK 17
      uses: actions/setup-java@v4
      with:
        java-version: '17'
        distribution: 'temurin'
    - run: mvn clean package
    - name: Upload JAR
      uses: actions/upload-artifact@v4
      with:
```