Criando seu processo de CI/CD com GitHub Actions

Felipe Maciel Ramos Vieira — Tue, 02 May 2023 13:08:04 +0000

E aí, já conhece o Github Actions?

O GitHub Actions é uma ferramenta massa para automatizar seus workflows de CI/CD direto no GitHub. Com ele, dá para rodar os testes e fazer builds e deploys de forma bem simples. Vamos ver como fazer!

Nessa publicação eu vou mostrar como criar um workflow para um projeto com Ruby on Rails, Docker e Docker Compose, mas o exemplo serve perfeitamente para outros tipos de projeto com algumas pequenas alterações!

Você precisará ter um projeto rails com docker, docker compose e os testes e para isso você pode encontrar um guia aqui!

Com o seu projeto pronto:

Crie uma pasta chamada .github/workflows na raiz. Dentro dessa pasta crie um arquivo yaml. O nome é com você. Eu vou chamar de ci.yaml
Crie o seu fluxo. Aqui, basicamente você define o passo a passo que vai ser executado a cada ação(push, pull request, issues, fork...). Para esse exemplo, eu quero que o criar triggers para quando o houver push ou quando for criado pull request apontando para a branch main. Em seguida explico um pouco mais, mas o arquivo fica assim:

name: Rails CI

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

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout
        uses: actions/checkout@v2

      - name: Build and Test
        run: |
          docker compose build
          docker compose run --rm web bundle install
          docker compose run --rm web bundle exec rails db:create
          docker compose run --rm web bundle exec rails db:migrate
          docker compose run --rm web bundle exec rspec

Vamos aos detalhes:

name: É o nome do workflow
on: É onde se define os eventos que disparam o workflow
jobs: São as atividades que serão executadas em paralelo
build: É o ID do job. Poderia ser qualquer identificador único dentro da cadeia de jobs.
runs-on: Define o tipo de máquina a ser executado o job id que criamos.
steps: Define a sequência de tarefas que vai ser executada no naquele job/job_id.
checkout: O Primeiro step consiste em fazer checkout do repositório
run: executa comandos no shell do SO. Nesse caso, estou executando uma série de comandos do docker.

Se tudo der certo, ao fazer push ou pull request na master, sua action vai ser disparada.

Agora é so fazer commit e push para ver o que acontece.

Como verificar?

E o exemplo de uma action que passou:

Agora é com você! Dá uma explorada na aba actions e nesse check status que marquei!

Receita de API Rails com Docker

Felipe Maciel Ramos Vieira — Sat, 04 Mar 2023 16:05:10 +0000

Criar uma API Ruby on Rails do zero nunca foi complexo, mas com docker e docker compose fica ainda mais simples pois não se depende de instação de dependências locais, como rvm ou rbenv, ruby, bundler, banco, redis ou qualquer outra coisa que sua aplicação precise.

As únicas dependências serão realmente o docker e o docker compose, portanto, se não tiver instalado em sua máquina, precisará fazê-lo.

Vamos à receita:

Crie o dockerfile

Esse é o cara que vai criar a sua imagem docker(tipo a máquina virtual) para rodar a sua aplicação:

FROM ruby:3.1.2-slim

RUN apt-get update -qq && apt-get install -yq --no-install-recommends \
    build-essential \
    gnupg2 \
    less \
    git \
    libpq-dev \
    postgresql-client \
    libvips42 \
  && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

ENV LANG=C.UTF-8 \
  BUNDLE_JOBS=4 \
  BUNDLE_RETRY=3

RUN gem update --system && gem install bundler

WORKDIR /usr/src/app

ENTRYPOINT ["./entrypoint.sh"]

EXPOSE 3001

CMD ["bundle", "exec", "rails", "s", "-b", "0.0.0.0"]

Crie o entrypoint.sh

Esse cara vai dizer o que o seu container precisa fazer depois que ele for inicializado:

#!/bin/bash
set -e

# Remove a potentially pre-existing server.pid for Rails.
rm -f /usr/src/app/tmp/pids/server.pid

echo "bundle install..."
bundle check || bundle install --jobs 4

# Then exec the container's main process (what's set as CMD in the Dockerfile).
exec "$@"

Vai, nem é tão difícil assim de entender...

Agora adicione permissão de execução desse arquivo:
chmod +x entrypoint.sh

Crie o Gemfile

Inicialmente só precisa disso mesmo. Depois que gerar o app, o rails injeta o restante.

source "https://rubygems.org"
gem "rails", "~> 7.0.4", ">= 7.0.4.2"

Crie um arquivo vazio Gemfile.lock

touch Gemfile.lock
Dont worry, você não vai precisar alterar isso

Crie o docker-compose.yml

Esse arquivo conecta todos os serviços que a sua aplicação vai precisar: banco, redis, rede, armazenamento, e por aí vai...

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile
    command: bash -c "rm -f tmp/pids/server.pid && bin/rails s -p 3001 -b '0.0.0.0'"
    volumes:
      - .:/usr/src/app
      - bundle:/usr/local/bundle
    ports:
      - "3001:3001"
    env_file:
      - .env
    environment:
      - HISTFILE=/usr/src/app/log/.bash_history
      - ENVIRONMENT=local
    depends_on:
      - db
  db:
    image: postgres:13
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_PASSWORD=123123
    volumes:
      - pg_data:/var/lib/postgresql/data
volumes:
  pg_data:
  redis_data:
  bundle:

Crie o seu .env

para armazenar qualquer informação para sua aplicação:

PGHOST=db
PGUSER=postgres
PGPASSWORD=123123

Gere uma nova aplicação a partir desta receita de container:

docker compose run web rails new . --force --database=postgresql --api

Receita pronta

Agora que a receita está pronta, resta servir: docker compose up

Para executar qualquer comando da aplicação:
docker compose exec web rails db:create
outro, como exemplo: docker compose exec web rails g scaffold user name

Agora, ao acessar http://localhost:3001/users você já tem a sua rota de usuários prontinha...

DEV Community: Felipe Maciel Ramos Vieira