Saltar al contenido

Acelere .NET en GitHub Actions

Última actualización

Para acelerar .NET en GitHub Actions, almacene en caché la carpeta de paquetes NuGet con actions/setup-dotnet, restaure una sola vez y luego compile y pruebe con --no-restore y --no-build, de modo que cada paso haga solo su propio trabajo. La mayoría de los pipelines de .NET lentos ejecutan restore y build tres veces sin darse cuenta, porque dotnet test restaura y compila de forma predeterminada.

Esta guía cubre la caché, los comandos de compilación y prueba, las pruebas en paralelo y los servicios de base de datos. Para la versión general, consulte cómo acelerar GitHub Actions.

Deje de repetir restore y build

dotnet build ejecuta primero dotnet restore. dotnet test ejecuta build, que a su vez ejecuta restore. Si su workflow tiene pasos separados para restore, build, test y publish sin flags, cada uno repite trabajo. Ejecute cada etapa una sola vez:

- run: dotnet restore --locked-mode
- run: dotnet build --no-restore -c Release
- run: dotnet test --no-build -c Release
- run: dotnet publish src/Api -c Release --no-build -o out

--no-restore omite el restore implícito. --no-build omite la compilación implícita y usa la salida que ya existe, así que la configuración (-c Release) debe coincidir entre pasos. En una solución con muchos proyectos, esto por sí solo suele eliminar varios minutos.

Almacene en caché la carpeta de paquetes NuGet

actions/setup-dotnet tiene caché integrada. Según su README, está desactivada de forma predeterminada y se activa con cache: true. Almacena en caché la carpeta global de paquetes de NuGet, y la clave se construye a partir de packages.lock.json. El README indica que, si no existe ningún archivo de bloqueo, la acción produce un error, así que necesita archivos de bloqueo. Use cache-dependency-path cuando estén en subdirectorios.

- uses: actions/checkout@v7
- uses: actions/setup-dotnet@v6
  with:
    dotnet-version: 9.0.x
    cache: true
    cache-dependency-path: "**/packages.lock.json"

Para generar archivos de bloqueo, añada <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile> a su proyecto o a un Directory.Build.props, ejecute dotnet restore una vez en local y confirme los archivos packages.lock.json. En CI, dotnet restore --locked-mode falla si el archivo de bloqueo está desactualizado, lo que además hace los builds reproducibles. El README señala que solo se restaura la carpeta de paquetes, por lo que un restore puede mostrar la advertencia NU1403 a menos que aplique la configuración que describe; lea esa sección si la encuentra.

Si no desea archivos de bloqueo, use actions/cache sobre ~/.nuget/packages con una clave generada a partir de **/*.csproj y Directory.Packages.props:

- uses: actions/cache@v6
  with:
    path: ~/.nuget/packages
    key: nuget-${{ runner.os }}-${{ hashFiles('**/*.csproj', '**/Directory.Packages.props') }}
    restore-keys: nuget-${{ runner.os }}-

Paralelismo en build y test

  • Build. MSBuild compila proyectos en paralelo con -m (--maxcpucount). dotnet build lo activa de forma predeterminada, usando todos los núcleos. Si llama a msbuild directamente, pase -m.
  • Pruebas entre ensamblados. dotnet test ejecuta los proyectos de prueba en paralelo según la configuración de MSBuild, y ejecuta las pruebas de un mismo ensamblado siguiendo las reglas del propio framework.
  • xUnit. Las clases de prueba son colecciones separadas y se ejecutan en paralelo entre sí de forma predeterminada; las pruebas de una misma clase se ejecutan en orden. Ajústelo en xunit.runner.json con maxParallelThreads. Las pruebas que comparten estado deben agruparse en una [Collection] para que se ejecuten en serie.
  • NUnit y MSTest. Añada [Parallelizable] o [assembly: Parallelize]; por defecto se ejecutan en serie.

Revise el uso de CPU durante el paso de pruebas. Si se mantiene cerca de un solo núcleo, está desperdiciando velocidad.

Servicios para pruebas de integración

Una aplicación ASP.NET Core con SQL Server suele usar un contenedor de servicio:

services:
  sql:
    image: mcr.microsoft.com/mssql/server:2022-latest
    env:
      ACCEPT_EULA: "Y"
      MSSQL_SA_PASSWORD: "Your_password123"
    ports: ["1433:1433"]
    options: >-
      --health-cmd "/opt/mssql-tools18/bin/sqlcmd -C -S localhost -U sa -P Your_password123 -Q 'SELECT 1'"
      --health-interval 10s --health-timeout 5s --health-retries 12

SQL Server necesita al menos 2 GB de memoria y tarda más en arrancar que Postgres, por lo que una comprobación de estado (health check) es esencial. La ruta de sqlcmd dentro de la imagen ha cambiado entre versiones, así que confírmela para la etiqueta que fije. Si usa Testcontainers, los mismos costes de arranque se aplican por contenedor; comparta un contenedor por ejecución de pruebas mediante un fixture de colección, y haga que cada prueba cree su propia base de datos o esquema.

Un workflow completo

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

concurrency:
  group: dotnet-${{ github.ref }}
  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}

env:
  DOTNET_NOLOGO: true
  DOTNET_CLI_TELEMETRY_OPTOUT: true
  DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true

jobs:
  test:
    runs-on: ubuntu-latest
    timeout-minutes: 20
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-dotnet@v6
        with:
          dotnet-version: 9.0.x
          cache: true
          cache-dependency-path: "**/packages.lock.json"
      - run: dotnet restore --locked-mode
      - run: dotnet build --no-restore -c Release
      - run: dotnet test --no-build -c Release --logger "trx;LogFileName=test.trx"

Las variables DOTNET_* desactivan el trabajo de la primera ejecución y la telemetría, lo que ahorra un poco en cada VM nueva. Para builds de release, ReadyToRun y el trimming añaden tiempo real, así que reserve esas opciones para el job de publish en main.

Lo que aportan más núcleos de CPU

MSBuild y el compilador Roslyn usan todos los núcleos, y los frameworks de pruebas en paralelo también. Nuestros benchmarks incluyen React + ASP.NET Core + SQL Server: 3m34s en un runner alojado en GitHub y 1m41s en compiler.dev (2.1x). Se trata de una ejecución completa de CI con 10 shards de pruebas y una base de datos real, medida el 8 de octubre de 2026. El consumo de memoria de SQL Server es parte de la razón por la que una máquina con 16 GB ayuda; un runner de 7 GB deja menos espacio para la base de datos y la compilación.

Para probarlo con el suyo, cambie una línea a runs-on: [self-hosted, Linux, compiler-ci]; consulte precios y comparativa. Relacionado: la plantilla de .NET, caché en GitHub Actions y sharding de pruebas.

Preguntas frecuentes

¿setup-dotnet almacena en caché los paquetes NuGet?

Sí, con cache: true. Necesita un packages.lock.json y dará error si no existe. Use cache-dependency-path para archivos de bloqueo en subcarpetas.

¿Qué hace dotnet test --no-build?

Ejecuta las pruebas a partir de la salida de compilación existente sin volver a compilar. El flag de configuración debe coincidir con la compilación anterior.

¿Por qué dotnet restore es lento en CI?

Una VM nueva tiene la caché de NuGet vacía y descarga todos los paquetes. Almacene en caché la carpeta de paquetes y use --locked-mode para restauraciones reproducibles.

¿Puedo ejecutar pruebas de .NET en paralelo?

Sí. xUnit paraleliza las colecciones de pruebas de forma predeterminada; NUnit y MSTest necesitan un atributo. Aísle primero el estado compartido.

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

Pruébelo gratis