Saltar al contenido

Acelere Elixir en GitHub Actions

Última actualización

Para acelerar Elixir en GitHub Actions, instale Erlang y Elixir con erlef/setup-beam, guarde en caché deps y _build con una clave generada a partir de mix.lock y las versiones de OTP y Elixir, y reparta las pruebas con mix test --partitions. Elixir compila rápido, pero una compilación en frío compila todas las dependencias, incluidas las que usan C, como bcrypt_elixir, y ahí se pierde la mayor parte del tiempo.

Esta guía muestra un flujo de trabajo completo de Phoenix. Para el enfoque general, lea cómo acelerar GitHub Actions.

Instalar Erlang y Elixir

erlef/setup-beam es la acción estándar de la comunidad. Según su README, puede definir otp-version y elixir-version como cadenas de texto, o usar version-file para leer un archivo .tool-versions (los archivos que terminan en .toml se analizan como configuración de mise). Si usa un archivo de versiones, el README indica que version-type debe ser strict. No combine un archivo de versiones con las entradas YAML; la acción termina con un error. El README recomienda la etiqueta móvil v1, o una etiqueta exacta como v1.8.0 si quiere fijar la versión.

- uses: actions/checkout@v7
- uses: erlef/setup-beam@v1
  id: beam
  with:
    otp-version: "27"
    elixir-version: "1.18"

El README enumera otp-version y elixir-version como salidas, que contienen las versiones exactas instaladas. Utilícelas en su clave de caché.

Guardar en caché deps y _build

El README no incluye una receta de caché, así que deberá crearla. Importan dos carpetas: deps (dependencias descargadas) y _build (salida compilada). La clave debe cambiar cuando cambie el archivo de bloqueo o cualquiera de las dos versiones de runtime, ya que _build no es portable entre versiones de OTP.

- uses: actions/cache@v6
  with:
    path: |
      deps
      _build
    key: mix-${{ runner.os }}-${{ steps.beam.outputs.otp-version }}-${{ steps.beam.outputs.elixir-version }}-${{ hashFiles('**/mix.lock') }}
    restore-keys: |
      mix-${{ runner.os }}-${{ steps.beam.outputs.otp-version }}-${{ steps.beam.outputs.elixir-version }}-
- run: mix deps.get
- run: mix compile --warnings-as-errors

El mecanismo de respaldo restore-keys significa que, si cambia mix.lock, se parte del _build anterior y Mix solo recompila las dependencias que han cambiado. Ejecutar mix deps.get después de restaurar la caché es seguro y rápido; solo descarga lo que falta. Mantenga MIX_ENV coherente: _build/test y _build/dev son carpetas separadas, y la CI solo debe compilar test.

env:
  MIX_ENV: test

Las entradas de caché son inmutables y tienen límites de tamaño y de tiempo; consulte límites de caché de GitHub Actions. Si _build crece con el tiempo, incluya un prefijo de versión (mix-v2-) en la clave para poder reiniciarla.

Usar un servicio de Postgres

Las aplicaciones Phoenix con Ecto necesitan una base de datos. Añada un servicio con una comprobación de estado:

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

Apunte config/test.exs a localhost y lea el host desde una variable de entorno para que funcione tanto en local como en CI. El SQL sandbox de Ecto permite ejecutar las pruebas en paralelo, cada una en su propia transacción; use use MyApp.DataCase, async: true en todas las pruebas que no compartan estado global.

Dividir las pruebas: concurrencia y luego particiones

Elixir tiene dos niveles de paralelismo en las pruebas.

Dentro de una máquina: ExUnit ejecuta de forma concurrente los módulos de prueba con async: true. El valor predeterminado de max_cases es el doble del número de planificadores, así que más núcleos significan más pruebas a la vez. Convierta en async: true tantos módulos como pueda. Las pruebas que usan el sistema de archivos, procesos con nombre, configuración global o Application.put_env deben seguir siendo síncronas.

Entre máquinas: mix test --partitions N divide los archivos de prueba en N particiones y ejecuta una, seleccionada mediante la variable de entorno MIX_TEST_PARTITION. Use una matriz:

strategy:
  fail-fast: false
  matrix:
    partition: [1, 2, 3, 4]
steps:
  # ...checkout, setup-beam, cache, deps...
  - run: mix test --partitions 4
    env:
      MIX_TEST_PARTITION: ${{ matrix.partition }}

Con particiones, la documentación de Ecto sugiere incluir el número de partición en el nombre de la base de datos, para que cada trabajo tenga su propia base: en config/test.exs, use database: "myapp_test#{System.get_env("MIX_TEST_PARTITION")}". Esto es necesario cuando las particiones comparten un mismo servidor de base de datos, por ejemplo al ejecutar varias particiones en la misma máquina. Para trabajos separados con contenedores de servicio independientes no es imprescindible, aunque tampoco perjudica. Consulte fragmentación de pruebas en GitHub Actions y la calculadora de fragmentos de pruebas.

Linting, formato y Dialyzer en trabajos separados

  • mix format --check-formatted no necesita compilar; ejecútelo primero, así falla rápido.
  • mix credo --strict es rápido.
  • Dialyzer (mediante Dialyxir) es lento porque construye una PLT (tabla persistente de búsqueda) de módulos de Erlang y Elixir. Guarde en caché la carpeta de la PLT, por ejemplo priv/plts, con una clave basada en la versión de OTP, la versión de Elixir y mix.lock. Con una PLT caliente, una ejecución de diez minutos se convierte en una corta. Manténgalo en un trabajo propio para que nunca bloquee las pruebas.

Releases y Docker

Si construye una imagen de release, compile las dependencias en una capa de Docker anterior al código de la aplicación, y use la caché de BuildKit. Consulte caché de capas de Docker en CI.

Lo que aportan más núcleos de CPU

La BEAM usa todos los núcleos para las pruebas concurrentes, y mix compile compila los archivos en paralelo. Nuestros benchmarks incluyen Phoenix LiveView + Postgres: 2m07s en un runner alojado por GitHub y 1m03s en compiler.dev (2.0x), una ejecución completa de CI con 10 particiones de pruebas y una base de datos real, medida el 8 de octubre de 2026. Las suites con muchas pruebas asíncronas son las que más se benefician, ya que max_cases escala con la máquina.

Para probarlo en su caso, cambie una línea a runs-on: [self-hosted, Linux, compiler-ci]. Consulte precios y comparativa. Relacionado: la plantilla de Elixir y caché en GitHub Actions.

Preguntas frecuentes

¿Qué debe contener la clave de caché de Elixir?

El sistema operativo del runner, la versión de OTP, la versión de Elixir y un hash de mix.lock. _build no es seguro de reutilizar entre versiones de OTP.

¿Funciona mix test --partitions con Ecto?

Sí. Use la variable MIX_TEST_PARTITION para que el nombre de la base de datos sea único por partición cuando las particiones comparten un servidor de base de datos.

¿Debo guardar en caché _build o solo deps?

Ambos. Guardar solo deps ahorra descargas, pero guardar _build ahorra el tiempo de compilación, que suele ser mayor.

¿Cómo acelero Dialyzer en CI?

Guarde en caché el directorio de la PLT con una clave basada en la versión de OTP, la versión de Elixir y mix.lock, y ejecútelo como un trabajo independiente.

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

Pruébelo gratis