Voltar ao Diminua Blog

Artigo

Dominando o Pipeline de CI/CD para Pequenos Projetos com GitHub Actions

Automatize testes, builds e deploys para entregar software mais rápido e com mais confiança.

Dominando o Pipeline de CI/CD para Pequenos Projetos com GitHub Actions

Introdução: Por que CI/CD é Essencial, Mesmo em Projetos Pequenos?

No mundo do desenvolvimento de software ágil, a Integração Contínua (CI) e a Entrega Contínua (CD) se tornaram pilares fundamentais. Para projetos pequenos, a tentação de pular essas práticas pode ser grande, dada a percepção de complexidade e custo. No entanto, ignorar CI/CD em qualquer escala é um erro que pode levar a ciclos de desenvolvimento mais longos, maior probabilidade de bugs e um processo de deploy estressante. Implementar um pipeline de CI/CD básico pode parecer intimidador, mas com as ferramentas certas, como o GitHub Actions, torna-se acessível e incrivelmente benéfico até mesmo para equipes enxutas ou desenvolvedores solo.

O Que São CI e CD?

Antes de mergulharmos nas ferramentas, vamos esclarecer os conceitos:

  • Integração Contínua (CI): O processo de mesclar o trabalho dos desenvolvedores em um repositório compartilhado várias vezes ao dia. Cada integração é verificada por um build automatizado (incluindo testes) para detectar erros de integração o mais rápido possível. O objetivo é evitar conflitos de código e garantir que a base de código esteja sempre em um estado funcional.
  • Entrega Contínua (CD): Uma extensão da CI. Após a fase de CI, a CD automatiza a entrega do software para um ambiente de teste ou produção. Isso significa que, após um build bem-sucedido e a passagem dos testes, o código é automaticamente implantado em um ambiente, pronto para ser lançado para os usuários finais com um clique (ou até mesmo automaticamente).
  • Deploy Contínuo: Um passo adiante na CD, onde cada mudança que passa por todos os estágios do pipeline de produção é automaticamente implantada em produção.

Para pequenos projetos, focar em CI e em uma CD que automatiza a entrega para um ambiente de staging ou produção (com aprovação manual, se necessário) já oferece um ganho significativo.

GitHub Actions: Seu Aliado para CI/CD

O GitHub Actions é uma plataforma de automação integrada diretamente ao GitHub. Ele permite que você automatize fluxos de trabalho de desenvolvimento de software, incluindo CI/CD, diretamente do seu repositório. A grande vantagem é que ele é baseado em eventos (como push, pull request, issues) e utiliza arquivos de configuração em YAML, o que o torna declarativo e fácil de versionar junto com o seu código.

Criando Seu Primeiro Workflow de CI

Vamos criar um workflow simples que roda testes sempre que código é enviado para o branch principal. Para isso, crie um diretório chamado .github/workflows na raiz do seu repositório e, dentro dele, um arquivo chamado ci.yml.

name: CI Pipeline

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

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v3
    - name: Set up Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '18'
    - name: Install dependencies
      run: npm ci
    - name: Run tests
      run: npm test

Explicação do Workflow:

  • name: Nome do workflow.
  • on: Define os eventos que disparam este workflow. Neste caso, um push ou pull_request para o branch main.
  • jobs: Define os jobs a serem executados. Um job é uma série de passos em um runner.
  • build: O nome do nosso job.
  • runs-on: Especifica o sistema operacional do runner. ubuntu-latest é uma opção comum e confiável.
  • steps: Uma sequência de tarefas.
  • uses: actions/checkout@v3: Um action pré-construído que clona o seu repositório para o runner.
  • uses: actions/setup-node@v3: Configura o ambiente Node.js na versão especificada.
  • run: npm ci: Executa o comando para instalar as dependências do projeto. npm ci é preferível em CI pois garante uma instalação limpa e determinística.
  • run: npm test: Executa os testes do seu projeto (assumindo que você tem um script test configurado no seu package.json).

Ao enviar este arquivo para o seu repositório e fazer um push para o branch main, o GitHub Actions automaticamente detectará e executará este workflow.

Automatizando o Deploy (CD)

Agora, vamos estender nosso workflow para incluir um passo de deploy. Para demonstração, vamos simular um deploy enviando o código para um servidor via SSH. Para isso, você precisará configurar credenciais SSH seguras como segredos do GitHub.

Configurando Segredos SSH

  1. Gere um par de chaves SSH (pública e privada) no seu ambiente local, se ainda não tiver. Use ssh-keygen -t rsa -b 4096.
  2. Adicione a chave pública gerada (~/.ssh/id_rsa.pub) ao arquivo ~/.ssh/authorized_keys no servidor de destino.
  3. No seu repositório GitHub, vá em Settings > Secrets and variables > Actions e clique em New repository secret.
  4. Crie um segredo chamado SSH_PRIVATE_KEY e cole o conteúdo da sua chave privada (~/.ssh/id_rsa) nele.
  5. Crie outro segredo chamado DEPLOY_SERVER_IP com o endereço IP do seu servidor de deploy.

Adicionando o Job de Deploy

Vamos adicionar um novo job ao nosso arquivo ci.yml. É uma boa prática separar o build/test do deploy, para que eles rodem em etapas distintas.

name: CI/CD Pipeline

on:
  push:
    branches: [ main ]

jobs:
  build_and_test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Set up Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '18'
    - name: Install dependencies
      run: npm ci
    - name: Run tests
      run: npm test

  deploy:
    needs: build_and_test
    runs-on: ubuntu-latest
    steps:
    - name: Deploy to Server
      uses: appleboy/ssh-action@master
      with:
        host: ${{ secrets.DEPLOY_SERVER_IP }}
        username: your_ssh_user
        key: ${{ secrets.SSH_PRIVATE_KEY }}
        script: |
          cd /path/to/your/app
          git pull origin main
          npm install --production
          npm run build
          pm2 restart your-app-name

Explicação das Novas Partes:

  • deploy: Um novo job que depende do job build_and_test (definido por needs: build_and_test).
  • uses: appleboy/ssh-action@master: Um action popular para executar comandos SSH.
  • host, username, key: Configurações para a conexão SSH, utilizando os segredos que definimos. Lembre-se de substituir your_ssh_user pelo seu nome de usuário SSH no servidor.
  • script: Contém os comandos a serem executados no servidor remoto. Neste exemplo:
    • cd /path/to/your/app: Navega até o diretório da sua aplicação no servidor.
    • git pull origin main: Atualiza o código fonte da aplicação com a versão mais recente do branch main.
    • npm install --production: Instala apenas as dependências de produção.
    • npm run build: Executa o script de build da sua aplicação (se aplicável).
    • pm2 restart your-app-name: Reinicia sua aplicação usando o PM2 (um gerenciador de processos Node.js). Adapte este comando ao seu ambiente de deploy (ex: systemctl restart sua-app.service).

Aviso de Segurança: Manipular chaves SSH requer cuidado. Certifique-se de que a chave privada seja armazenada apenas como segredo do GitHub e nunca exposta publicamente. Utilize um usuário SSH com permissões mínimas necessárias no servidor de deploy.

Melhores Práticas e Considerações

Para pequenos projetos, a simplicidade é chave. Comece com o básico e adicione complexidade conforme necessário:

  • Testes são Cruciais: Um pipeline de CI/CD sem testes automatizados é incompleto. Invista em testes unitários, de integração e, se possível, end-to-end.
  • Ambientes Separados: Se possível, tenha ambientes distintos para desenvolvimento, staging e produção. Seu pipeline de CD pode ser configurado para fazer deploy em cada um deles.
  • Gerenciamento de Dependências: Use ferramentas como npm ci (para Node.js) ou equivalentes em outras linguagens para garantir builds reproduzíveis.
  • Monitoramento e Observabilidade: Após o deploy, é fundamental saber o que está acontecendo. Ferramentas de monitoramento e logging (como o journalctl no Linux, que já cobrimos em um artigo anterior) são essenciais para identificar e resolver problemas rapidamente.
  • Estratégia de Branching: Para projetos pequenos, um fluxo simples como Gitflow ou um modelo baseado em trunk-based development com feature flags pode funcionar bem. O importante é que o branch principal (main) esteja sempre em um estado deployável.
  • Segurança: Revise regularmente as permissões dos segredos do GitHub e as credenciais de acesso ao servidor.

Conclusão

Implementar CI/CD em pequenos projetos não é um luxo, mas uma necessidade estratégica para manter a agilidade e a qualidade. O GitHub Actions oferece uma maneira poderosa e acessível de automatizar seus fluxos de trabalho, desde a execução de testes até o deploy em produção. Ao investir tempo na configuração de um pipeline robusto, você economizará horas de trabalho manual, reduzirá erros e ganhará confiança para entregar novas funcionalidades aos seus usuários de forma rápida e segura.

Foto de Felicity Tai no Pexels.