Saltar al contenido

Acelere React Native en GitHub Actions

Última actualización

Para acelerar React Native en GitHub Actions, ejecute el linter, la comprobación de tipos y Jest en Linux, compile Android en Linux con caché de Gradle, y use macOS solo para la compilación de iOS con CocoaPods y DerivedData en caché. La parte costosa del CI de React Native son las compilaciones nativas, y el ahorro más grande es no ejecutarlas en cada push.

Esta es la versión para React Native de nuestra guía general para acelerar GitHub Actions.

Separe por lo que requiere un Mac

Un repositorio de React Native tiene tres tipos de trabajo:

  1. Comprobaciones de JavaScript. ESLint, TypeScript y Jest. Linux.
  2. Compilación de Android. Gradle y el SDK de Android. Linux.
  3. Compilación de iOS. Xcode y CocoaPods. Solo macOS.

Ejecute (1) y (2) en cada PR. Ejecute (3) en main, en las ramas de release o cuando cambien ios/ y las dependencias nativas. Los minutos de macOS alojados tienen una tarifa más alta que los de Linux, así que consulte runners de macOS para CI de iOS para ver las cifras y opciones.

Comprobaciones de JavaScript

js:
  runs-on: ubuntu-latest
  timeout-minutes: 15
  steps:
    - uses: actions/checkout@v7
    - uses: actions/setup-node@v7
      with:
        node-version: 22
        cache: yarn
    - run: yarn install --frozen-lockfile
    - run: yarn tsc --noEmit
    - run: yarn lint
    - run: yarn jest --ci --maxWorkers=50%

actions/setup-node almacena en caché la caché de descargas del gestor de paquetes (npm, yarn o pnpm), como indica su README. Jest con --ci evita el comportamiento interactivo y la escritura de snapshots. Si Jest tarda demasiado, consulte Jest lento, incluido --shard.

Android: Gradle y el bundle de Metro

La compilación de Android ejecuta Gradle y empaqueta el JavaScript con Metro. Use gradle/actions/setup-gradle para la caché de Gradle (la guía de Gradle explica su funcionamiento y el archivo de propiedades), y configure Java con la versión que necesite su Android Gradle Plugin:

android:
  runs-on: ubuntu-latest
  timeout-minutes: 40
  steps:
    - uses: actions/checkout@v7
    - uses: actions/setup-node@v7
      with:
        node-version: 22
        cache: yarn
    - uses: actions/setup-java@v6
      with:
        distribution: temurin
        java-version: 17
    - uses: gradle/actions/setup-gradle@v6
    - run: yarn install --frozen-lockfile
    - run: ./gradlew assembleRelease
      working-directory: android

Ajustes útiles en android/gradle.properties:

  • org.gradle.caching=true y org.gradle.parallel=true.
  • org.gradle.jvmargs=-Xmx4g para el heap; las compilaciones de React Native consumen mucha memoria.
  • reactNativeArchitectures=arm64-v8a para compilaciones de prueba en CI. Por defecto se compilan cuatro ABI (armeabi-v7a, arm64-v8a, x86, x86_64), y el código nativo se compila una vez por ABI, así que limitarlas puede reducir una gran parte del tiempo de compilación de C++. Compile todas las ABI solo para los artefactos de release.
  • Hermes es el motor por defecto en las versiones actuales de React Native, y su paso de compilación a bytecode es rápido; hay poco que ajustar.

Metro almacena en caché los módulos transformados en una carpeta temporal. En una VM nueva empieza vacía. Puede definir una ubicación de caché estable y guardarla con actions/cache, aunque la mejora es modesta comparada con las cachés de Gradle y de la compilación nativa. Mida antes de añadir el paso.

iOS: CocoaPods y datos derivados

pod install descarga y descomprime todas las dependencias nativas. Almacene en caché la carpeta Pods con la clave basada en Podfile.lock. Añada ios/build o una ruta de DerivedData si compila desde cero con frecuencia; es una caché más grande y puede superar los límites de tamaño de GitHub, así que consulte límites de caché.

ios:
  runs-on: macos-latest
  timeout-minutes: 45
  steps:
    - uses: actions/checkout@v7
    - uses: actions/setup-node@v7
      with:
        node-version: 22
        cache: yarn
    - run: yarn install --frozen-lockfile
    - uses: ruby/setup-ruby@v1
      with:
        bundler-cache: true
    - uses: actions/cache@v6
      with:
        path: ios/Pods
        key: pods-${{ runner.os }}-${{ hashFiles('ios/Podfile.lock') }}
    - run: bundle exec pod install
      working-directory: ios
    - run: |
        xcodebuild -workspace ios/MyApp.xcworkspace -scheme MyApp \
          -configuration Release -sdk iphonesimulator \
          -destination 'generic/platform=iOS Simulator' \
          CODE_SIGNING_ALLOWED=NO build

Use ruby/setup-ruby con bundler-cache: true si gestiona CocoaPods a través de un Gemfile; la acción almacena las gemas en caché por usted. Compile para el simulador y con la firma desactivada en las comprobaciones de PR, ya que es más rápido y no necesita certificados. Haga las compilaciones para dispositivo y la firma solo en los jobs de release. Para más consejos sobre Xcode, consulte acelerar las compilaciones de Xcode en CI.

Expo y EAS

Si usa Expo, puede delegar las compilaciones nativas en EAS Build y dejar GitHub Actions solo para las comprobaciones de JS. Eso traslada el coste a otro lugar; compare el precio del servicio con los minutos de runner antes de decidir. En cualquier caso, el principio se mantiene: las compilaciones nativas son poco frecuentes y caras, así que desencadénelas de forma deliberada.

Detecte los cambios nativos

A change to JavaScript files cannot break the Gradle or Xcode build in most cases. Use path filters or a changed-files check so the native jobs run only when android/, ios/, package.json or the lockfile changes. Pair that with concurrency to cancel superseded runs.

Lo que aportan más núcleos de CPU

Gradle y la compilación de C++ de los módulos nativos usan muchos núcleos, así que las compilaciones de Android se benefician de una máquina Linux más grande. Las compilaciones de Xcode dependen del Mac. No tenemos una fila de React Native en nuestros benchmarks, así que no citamos una aceleración. compiler.dev tiene máquinas Linux de 8 vCPU / 16 GB por defecto ($0.008 por minuto) y macOS en acceso anticipado: VM Apple M4 Pro de 7 núcleos a $0.028 por minuto y de 14 núcleos a $0.055 por minuto, o un host dedicado desde $3,595 al mes. Para trabajo exclusivo de macOS, Namespace y otros también ofrecen runners de macOS; compare los precios actuales en sus páginas antes de elegir. Consulte precios y precios de runners.

Cambiar un job de Linux es una línea, runs-on: [self-hosted, Linux, compiler-ci]. Relacionado: la plantilla de React Native, la guía de Flutter y el caché en GitHub Actions.

Preguntas frecuentes

¿Puedo compilar React Native para iOS en Linux?

No. Las compilaciones de iOS requieren Xcode y macOS. Ejecute las comprobaciones de JS y la compilación de Android en Linux.

¿Cómo almaceno CocoaPods en caché en GitHub Actions?

Almacene en caché ios/Pods con actions/cache, usando como clave ios/Podfile.lock, y ejecute pod install después.

¿Por qué mi compilación de Android de React Native es tan lenta?

Normalmente compila código nativo para cuatro ABI y no tiene caché de Gradle. Limite reactNativeArchitectures para CI y use setup-gradle.

¿Debo ejecutar compilaciones de iOS en cada pull request?

Solo si su equipo publica cambios nativos con frecuencia. Muchos equipos ejecutan iOS en main y cuando cambian archivos nativos, lo que ahorra más minutos de los más caros.

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

Pruébelo gratis