Saltar al contenido

Sharding de tests: qué es, Jest, Gradle, Bazel y más

Última actualización

El sharding de pruebas divide una suite de pruebas en fragmentos que se ejecutan en paralelo, cada uno en su propio runner. Cuando una suite tarda 20 minutos, tiene dos formas de acelerarla: ejecutar las pruebas en paralelo dentro de un solo job, o repartirlas entre varios jobs (sharding). Ambas funcionan. Esta guía explica cuándo usar cada una, cómo configurar una matriz de shards para los frameworks más comunes y cómo evitar las trampas: shards desequilibrados, pérdida de cobertura y una factura más alta.

Paralelismo dentro de un job frente a sharding entre jobs

El paralelismo dentro de un job aprovecha los núcleos que ya tiene. Un runner de 2 vCPU admite como máximo unos dos procesos de trabajo, así que la mejora es pequeña a menos que pase a un runner más grande:

pytest -n auto            # pytest-xdist, one worker per core
npx jest --maxWorkers=100%
go test ./... -p 4

El sharding ejecuta la suite como N jobs separados, cada uno con su propio runner. El tiempo total se reduce aproximadamente N veces, descontando el tiempo de preparación. Los minutos facturados aumentan, porque cada shard paga por el checkout, la instalación y cualquier build.

Una regla sencilla: si la preparación tarda 1 minuto y la suite 20 minutos, 4 shards dan unos 6 minutos de tiempo total y 24 minutos facturados, frente a los 21 de un solo job. Use el planificador de sharding de pruebas para calcular el número de shards que se ajusta a su tiempo objetivo y a su presupuesto.

Una matriz de shards

Los jobs de matriz de GitHub pueden generar un job por shard. Pase el índice del shard al runner de pruebas:

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        shard: [1, 2, 3, 4]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm
      - run: npm ci
      - run: npx jest --shard=${{ matrix.shard }}/4

fail-fast: false permite que los demás shards terminen, de modo que ve todos los fallos en una sola ejecución en lugar de corregirlos uno a uno. Tenga en cuenta el límite: una matriz puede crear como máximo 256 jobs por ejecución de workflow, algo que no suele preocupar en el caso del sharding.

Otros frameworks siguen la misma idea:

npx playwright test --shard=2/4          # Playwright
npx vitest run --shard=2/4               # Vitest
pytest --splits 4 --group 2              # pytest-split

En Go, divida por lista de paquetes, por ejemplo con go list ./... | split o con una herramienta como gotestsum con una lista de paquetes por shard. Cypress y RSpec tienen herramientas de paralelización (Cypress Cloud, parallel_tests, knapsack) que equilibran según los tiempos pasados.

Equilibre los shards por tiempo, no por número

El sharding integrado suele dividir por número de archivos o por orden alfabético. Si un archivo tarda 8 minutos, el shard que lo contiene determina su tiempo total. Un mejor equilibrio usa las duraciones registradas:

  1. Ejecute la suite una vez con salida de tiempos (XML de JUnit o el reporter JSON del framework).
  2. Guarde las duraciones como artefacto o confirme un archivo de tiempos en el repositorio.
  3. Asigne los archivos a los shards con un algoritmo voraz: ordene por duración y coloque cada archivo en el shard con menos carga.

pytest-split guarda las duraciones en .test_durations y las utiliza. Playwright divide por archivo de pruebas, así que separar los archivos de spec grandes en otros más pequeños ayuda más que cualquier algoritmo. Un buen objetivo es que el shard más lento esté dentro del 10 al 15 por ciento de la media.

Combine informes y cobertura

Cada shard produce un informe parcial. Súbalos como artefactos con nombres únicos y combínelos en un job final:

      - uses: actions/upload-artifact@v4
        if: ${{ !cancelled() }}
        with:
          name: junit-${{ matrix.shard }}
          path: reports/

  report:
    needs: test
    if: ${{ !cancelled() }}
    runs-on: ubuntu-latest
    steps:
      - uses: actions/download-artifact@v4
        with:
          pattern: junit-*
          merge-multiple: true

Playwright tiene merge-reports para su reporter de blobs. Para la cobertura, suba el lcov o el XML de cobertura de cada shard y combínelos antes de enviarlos a su servicio de cobertura; de lo contrario, cada shard informa solo de su parte y el número parecerá bajo.

Un check obligatorio, no N

La protección de ramas necesita nombres de check estables. Una matriz produce nombres como test (1), test (2), y cambiar el número de shards cambia los nombres, lo que rompe los checks obligatorios. Añada un job final que dependa de todos los shards y exija solo ese:

  tests-passed:
    needs: test
    if: ${{ always() }}
    runs-on: ubuntu-latest
    steps:
      - run: |
          if [ "${{ needs.test.result }}" != "success" ]; then exit 1; fi

La condición always() es importante: si un shard falla, un job dependiente omitido se reporta como omitido, y un check obligatorio omitido puede contar como superado.

Mantenga la preparación pequeña

El sharding multiplica el coste de la preparación, así que recórtela:

  • Use caché para las dependencias (guía).
  • Si la compilación es lenta, compile una vez en un job previo y comparta el resultado como artefacto; después, los shards lo descargan.
  • Omita los navegadores que no usa. npx playwright install --with-deps chromium es más rápido que instalar los tres.

Vigile el coste

Cada shard se factura por minuto iniciado, redondeado al alza por job. Muchos shards muy pequeños desperdician dinero en redondeos y preparación. Con 4 shards de 5 minutos cada uno paga 20 minutos, lo mismo que un job de 20 minutos, y los desarrolladores esperan una cuarta parte del tiempo. Con 20 shards de 1 minuto más 1 minuto de preparación, paga 40. Pruebe el predictor para modelar el efecto mensual.

Qué significa el sharding de pruebas

El sharding de pruebas (también llamado división de pruebas) consiste en dividir una suite en N fragmentos disjuntos, llamados shards, y ejecutar cada fragmento como su propio proceso o job de CI. Cada prueba se ejecuta exactamente una vez entre todos los shards. El objetivo es el tiempo total: con cuatro shards de igual duración, la suite termina en aproximadamente una cuarta parte del tiempo. El sharding es distinto de los workers paralelos dentro de un job, que comparten una misma máquina. En una matriz de shards, cada shard tiene su propio runner. Para una visión más amplia de por qué se ralentizan las suites, consulte la guía de CI lento y la guía de pruebas e2e lentas.

Sharding de pruebas por framework

La mayoría de los frameworks necesitan un índice y un total. Este es el flag o enfoque de cada uno.

Jest

Integrado desde Jest 28: npx jest --shard=1/4. Divide por archivo de pruebas, así que los shards no están equilibrados por tiempo. Detalles en Jest lento.

Playwright

Integrado: npx playwright test --shard=1/4. Use el reporter de blobs y merge-reports para combinar resultados. Consulte Playwright tests lentos.

Vitest

Integrado: npx vitest run --shard=1/4, con informes de blobs que se pueden combinar. Consulte Vitest lento.

Cypress y pytest

Cypress reparte las especificaciones mediante Cypress Cloud o las divide con un plugin; pytest usa plugins como pytest-split. Consulte pruebas de Cypress lentas y pruebas lentas de pytest.

Gradle (JVM)

Gradle ejecuta las clases de prueba en paralelo dentro de una misma compilación con maxParallelForks, pero no reparte por sí solo una suite entre varios jobs de CI. Para fragmentar entre jobs, enumere sus clases de prueba y asigne a cada job un subconjunto con --tests, o use un plugin que distribuya según el tiempo de ejecución. Mantenga la división determinista, por ejemplo ordenando los nombres de las clases y tomando una de cada N.

# job INDEX of TOTAL: select every TOTAL-th class
./gradlew test $(./list-test-classes.sh | awk -v i=$INDEX -v n=$TOTAL 'NR % n == i {print "--tests " $1}')

Bazel

Bazel tiene sharding nativo. Defina shard_count en un target de prueba, y Bazel ejecuta ese número de shards en paralelo, pasando TEST_TOTAL_SHARDS y TEST_SHARD_INDEX a la prueba. Los frameworks de prueba que leen estas variables (muchos lo hacen, incluidos GoogleTest y los runners de JUnit) se dividen por sí mismos.

java_test(
    name = "integration_tests",
    srcs = glob(["*.java"]),
    shard_count = 4,
)

Bazel también puede elegir automáticamente el número de shards con --test_sharding_strategy. Consulte la documentación de Bazel para conocer los flags exactos de su versión.

Flutter

flutter test acepta --total-shards y --shard-index:

flutter test --total-shards 4 --shard-index 0

Ejecute un índice por job de la matriz (del 0 al 3).

.NET (dotnet test)

dotnet test no tiene un flag general de índice de shard. Los enfoques habituales son dividir por proyecto de prueba, dividir con expresiones --filter (por ejemplo, por namespace o por trait), o usar un runner o herramienta que admita la división según el tiempo de ejecución. Asegúrese de que los filtros juntos cubran todas las pruebas y haga fallar la compilación si una nueva prueba queda fuera de todos ellos.

dotnet test --filter "FullyQualifiedName~MyApp.Orders"

Android

Las pruebas instrumentadas admiten sharding mediante los argumentos del runner de pruebas de AndroidX numShards y shardIndex, que también funcionan a través de Gradle:

./gradlew connectedCheck \
  -Pandroid.testInstrumentationRunnerArguments.numShards=4 \
  -Pandroid.testInstrumentationRunnerArguments.shardIndex=0

Los device farms ofrecen sus propias opciones de sharding, así que consulte también su documentación. El arranque del emulador es un coste fijo elevado por cada shard, por lo que conviene usar menos shards, pero más grandes, que para las pruebas unitarias.

Preguntas frecuentes

¿Cuántos shards debo usar?

Empiece con el número que alcance su objetivo de tiempo según el planificador: tiempo de la suite dividido entre el objetivo, más un margen para la preparación. Después revise el shard más lento y reequilibre.

¿El sharding detecta más pruebas inestables?

Puede exponer dependencias de orden, ya que las pruebas ya no se ejecutan en un solo proceso. Corregirlo es útil. Consulte cómo tratar las pruebas inestables.

¿Es mejor un runner más grande que más shards?

Si el framework escala entre núcleos, un runner más grande evita configuraciones repetidas. Si las pruebas están limitadas por I/O o son de un solo proceso, los shards escalan mejor. Pruebe ambas opciones en un mismo workflow.

¿Qué significa el sharding de pruebas?

Dividir una suite de pruebas en N fragmentos (shards) y ejecutar cada uno por separado, normalmente como jobs de CI en paralelo, de modo que cada prueba se ejecute una vez y el tiempo total se reduzca.

¿El sharding de pruebas es lo mismo que las pruebas en paralelo?

Las pruebas en paralelo se ejecutan de forma concurrente en una misma máquina. El sharding reparte las pruebas entre varias máquinas o jobs. La mayoría de las suites grandes usan ambos.

¿Cómo mantengo las mismas pruebas en cada PR?

Fije el número de shards en la matriz y mantenga un único job de resumen obligatorio, como se muestra arriba.

Pruébelo en sus jobs

Compare el enfoque de sharding con una máquina única más rápida: el modo de comparación de compiler.dev ejecuta el mismo workflow en runners más grandes para que pueda ver el tiempo y el coste lado a lado antes de reestructurar sus pruebas.

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

Pruébelo gratis