CI/CD para projetos Go: Configuração do GitHub Actions

Treinador Online de Python para Iniciantes

Aprenda Python facilmente sem sobrecarga teórica. Resolva tarefas práticas com verificação automática e escreva código diretamente no navegador.

Start Course

Introdução: Por que CI/CD é importante para projetos Go

O desenvolvimento moderno em Go (Golang) requer não apenas escrever código limpo e eficiente, mas também configurar processos que automatizem a verificação, construção e entrega de aplicações. CI/CD (Continuous Integration / Continuous Delivery) é um conjunto de práticas que permite entregar mudanças para produção de forma rápida e segura. Para desenvolvedores Go, o GitHub Actions se tornou uma das ferramentas mais populares devido à sua integração estreita com repositórios e simplicidade de configuração.

Neste artigo, vamos abordar como criar um pipeline CI/CD completo para um projeto Go usando GitHub Actions. Você aprenderá como automatizar testes, construção de binários e deploy para um servidor. Todos os exemplos serão em Go (Golang) com passos práticos.

1. Fundamentos do GitHub Actions para Go

GitHub Actions é um sistema de automação de fluxos de trabalho (workflows) integrado. Cada workflow é um arquivo YAML que descreve as etapas de construção, teste e implantação. Para projetos Go, um pipeline mínimo inclui:

Instalação do Go
Cache de dependências
Execução de testes
Construção da aplicação

Estrutura do arquivo de workflow

Crie no diretório raiz do repositório a pasta .github/workflows/ e o arquivo ci.yml. Aqui está uma configuração básica para Go:

name: CI para projeto Go

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

jobs:  build-and-test:    runs-on: ubuntu-latest    steps:      - uses: actions/checkout@v4

      - name: Instalação do Go        uses: actions/setup-go@v5        with:          go-version: '1.22'

      - name: Cache de módulos        uses: actions/cache@v3        with:          path: ~/go/pkg/mod          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}          restore-keys: |            ${{ runner.os }}-go-

      - name: Download de dependências        run: go mod download

      - name: Linting de código        run: go vet ./...

      - name: Execução de testes        run: go test -v -race -coverprofile=coverage.out ./...

      - name: Construção do binário        run: go build -o myapp ./cmd/main.go

Este workflow é executado ao fazer push para main ou develop, e também ao criar um pull request. Ele verifica o código em busca de erros, executa testes com a flag race (detector de data races) e compila o binário.

2. Pipeline avançado: Testes e qualidade de código

A verificação básica é boa, mas para um projeto Go sério, é necessário mais. Vamos adicionar análise estática e verificação de cobertura de código.

Adicionando golangci-lint

golangci-lint é um agregador de linters que inclui go vet, errcheck, staticcheck e outros. Vamos adicioná-lo ao workflow:

      - name: Instalação do golangci-lint        uses: golangci/golangci-lint-action@v4        with:          version: latest

      - name: Execução do linter        run: golangci-lint run ./...

Relatório de cobertura de código

Cobertura de testes é uma métrica de qualidade importante. O GitHub Actions pode gerar relatórios e até bloquear PRs com cobertura baixa:

      - name: Geração de relatório de cobertura        run: go test -coverprofile=coverage.out -covermode=atomic ./...

      - name: Verificação de cobertura mínima        run: |          go tool cover -func=coverage.out | grep total | awk '{print $3}' | sed 's/%//' > coverage.txt          if [ $(cat coverage.txt) -lt 70 ]; then            echo "Cobertura de código menor que 70%"            exit 1          fi

Agora o workflow falhará se a cobertura de testes cair abaixo de 70%. Esta é uma excelente prática para manter a qualidade de um projeto Go.