Saltar al contenido

Acelere Rails en GitHub Actions

Última actualización

Para acelerar Rails en GitHub Actions, guarde en caché sus gemas con ruby/setup-ruby, evite precompilar assets que no prueba, prepare la base de datos a partir de un archivo de esquema en lugar de ejecutar todas las migraciones, y reparta su suite de pruebas entre varios procesos y jobs. La mayor parte del tiempo de CI de Rails se va en el arranque, la preparación de la base de datos y una larga ejecución de pruebas en un solo proceso.

Esta es la versión para Rails de nuestra guía general para acelerar GitHub Actions. Las mismas ideas se aplican a RSpec y Minitest.

Dónde gasta tiempo el CI de Rails

Ejecute una compilación y revise los tiempos de cada paso. En una aplicación Rails típica el orden es: instalación de gemas (guárdela en caché), preparación de la base de datos (a menudo entre 20 y 60 segundos), compilación de JavaScript y assets (si tiene pruebas de sistema) y la ejecución de las pruebas en sí. Esta última suele ser la más larga. Atienda cada una según el esfuerzo que requiera, no según su tamaño.

Guardar gemas en caché de forma sencilla

ruby/setup-ruby puede instalar y guardar en caché sus gemas por usted. Su README indica que bundler-cache: true ejecuta bundle install y guarda las gemas en caché automáticamente, usando el lockfile en la clave de caché.

- uses: ruby/setup-ruby@v1
  with:
    bundler-cache: true

La versión de Ruby se toma de .ruby-version o .tool-versions si no define ruby-version. Si un conjunto de gemas en caché se corrompe, defina cache-version: 1 (cualquier valor distinto de 0) para empezar de nuevo. No añada un segundo paso actions/cache para vendor/bundle; la acción ya lo hace.

Preparar la base de datos desde el esquema

Un servicio de Postgres recién iniciado está vacío. Ejecutar 400 migraciones en cada job es lento y frágil. Cargue el esquema en su lugar. Este es un job completo con servicios de Postgres y Redis:

jobs:
  test:
    runs-on: ubuntu-latest
    timeout-minutes: 25
    services:
      postgres:
        image: postgres:17
        env:
          POSTGRES_PASSWORD: postgres
        ports: ["5432:5432"]
        options: >-
          --health-cmd "pg_isready -U postgres"
          --health-interval 5s --health-timeout 5s --health-retries 10
      redis:
        image: redis:7
        ports: ["6379:6379"]
        options: >-
          --health-cmd "redis-cli ping"
          --health-interval 5s --health-timeout 5s --health-retries 10
    env:
      RAILS_ENV: test
      DATABASE_URL: postgres://postgres:postgres@localhost:5432/app_test
      REDIS_URL: redis://localhost:6379/0
    steps:
      - uses: actions/checkout@v7
      - uses: ruby/setup-ruby@v1
        with:
          bundler-cache: true
      - run: bin/rails db:schema:load
      - run: bundle exec rspec

Incluya en el control de versiones db/schema.rb o db/structure.sql y manténgalo actualizado. Las comprobaciones de estado son importantes: sin ellas, la primera prueba puede ejecutarse antes de que Postgres acepte conexiones, y obtendrá fallos aleatorios que parecen pruebas inestables.

Una base de datos de pruebas desechable no necesita durabilidad. Si inicia Postgres usted mismo, -c fsync=off -c synchronous_commit=off -c full_page_writes=off abarata las escrituras. No lo use nunca con datos reales.

Bootsnap y el tiempo de arranque

Bootsnap guarda en caché las rutas de carga de Ruby y el bytecode compilado, y viene en el Gemfile por defecto de las aplicaciones Rails recientes. Su caché se encuentra en tmp/cache/bootsnap, que está vacía en una VM nueva, por lo que el primer arranque es lento. Guárdela en caché:

- uses: actions/cache@v6
  with:
    path: tmp/cache/bootsnap
    key: bootsnap-${{ runner.os }}-${{ hashFiles('Gemfile.lock', '.ruby-version') }}

La ganancia es de unos segundos por job. Es más importante cuando divide en muchos jobs paralelos, ya que cada uno paga el coste del arranque.

Omita el trabajo que sus pruebas no necesitan

  • Assets. Si solo las pruebas de sistema necesitan assets compilados, ejecute bin/rails assets:precompile solo en ese job. Guarde node_modules en caché mediante actions/setup-node.
  • Carga anticipada (eager loading). Definir config.eager_load = ENV["CI"].present? en el entorno de pruebas detecta errores de carga, pero añade tiempo de arranque por proceso. Considérelo solo para un job.
  • Registro. Defina config.log_level = :warn en test; los registros de depuración intensivos ralentizan las suites grandes.
  • Pruebas de sistema. Coloque las pruebas de navegador en su propio job para que no bloqueen las pruebas unitarias y de peticiones. Consulte pruebas E2E inestables si no son fiables.

Dividir la suite

Un único bundle exec rspec se ejecuta en un solo proceso. Dos palancas:

  1. Procesos en una misma máquina. La gema parallel_tests ejecuta los archivos de especificaciones en varios núcleos de CPU, con una base de datos por proceso (parallel_rspec spec). Rails también incluye parallelize(workers: :number_of_processors) integrado para Minitest.
  2. Jobs en varias máquinas. Use una matriz y reparta los archivos según el tiempo de ejecución registrado. Knapsack equilibra según esos tiempos; parallel_tests puede agrupar por tiempo de ejecución a partir de un archivo de registro.

Una matriz que usa la agrupación de parallel_tests (aquí -n 4 es el número total de grupos):

strategy:
  fail-fast: false
  matrix:
    group: [1, 2, 3, 4]
steps:
  - uses: actions/checkout@v7
  - uses: ruby/setup-ruby@v1
    with:
      bundler-cache: true
  - run: bin/rails db:schema:load
  - run: bundle exec parallel_rspec --only-group ${{ matrix.group }} --group-by runtime -n 4 spec

Proporcione a parallel_tests un registro de tiempos de ejecución (tmp/parallel_runtime_rspec.log, que puede guardar como artefacto o en caché) para que los grupos queden equilibrados. Sin él, recurre al tamaño de los archivos. Más información sobre la idea en división de pruebas en GitHub Actions, y la calculadora de shards de pruebas estima el número de shards.

Núcleos y Rails

Las pruebas de Rails son principalmente Ruby de un solo proceso, que usa un núcleo, por lo que una máquina más grande solo ayuda cuando ejecuta parallel_tests o parallelize de Minitest para aprovechar los núcleos. Entonces, 8 vCPU pueden ejecutar 8 workers en un solo job en lugar de pagar por cuatro jobs, cada uno con su propio arranque e instalación. No tenemos una fila de Rails en nuestros benchmarks, así que no citaremos una mejora de velocidad.

Puede probar su propia suite en compiler.dev cambiando una línea a runs-on: [self-hosted, Linux, compiler-ci]. Consulte precios y el selector de tamaño de runner. Relacionado: la plantilla para Rails, la caché en GitHub Actions y CI lento.

Preguntas frecuentes

¿Cómo guardo gemas en caché en GitHub Actions para Rails?

Use ruby/setup-ruby con bundler-cache: true. Instala las gemas y las guarda en caché usando su Gemfile.lock.

¿Es mejor parallel_tests o una matriz de jobs para Rails?

Use parallel_tests para aprovechar los núcleos de una máquina y una matriz para repartir la carga entre máquinas. Muchos equipos combinan ambos: una matriz de 3 a 4 jobs, cada uno ejecutando varios procesos.

¿Por qué mis pruebas de Rails fallan de forma intermitente solo en CI?

Causas habituales: Postgres no está listo (añada una comprobación de estado), estado compartido entre procesos paralelos (use una base de datos por proceso) y pruebas dependientes del tiempo.

¿Debo ejecutar db:migrate o db:schema:load en CI?

Cargue el esquema para ganar velocidad. Ejecute las migraciones en una comprobación aparte para asegurarse de que siguen aplicándose.

Ejecute este workflow en compiler.dev Sin tarjeta · 200 minutos gratuitos

Pruébelo gratis