Skip to main content

Esta versión de GitHub Enterprise Server se discontinuará el 2024-03-07. No se realizarán lanzamientos de patch, ni siquiera para problemas de seguridad críticos. Para obtener rendimiento mejorado, seguridad mejorada y nuevas características, actualice a la versión más reciente de GitHub Enterprise Server. Para obtener ayuda con la actualización, póngase en contacto con el soporte técnico de GitHub Enterprise.

Crear y probar en Node.js

Puedes crear un flujo de trabajo de integración continua (CI) para construir y probar tu proyecto Node.js.

Nota: Actualmente los ejecutores hospedados en GitHub no se admiten en GitHub Enterprise Server. Puede ver más información sobre la compatibilidad futura planeada en GitHub public roadmap.

Introducción

Esta guía te muestra cómo crear un flujo de trabajo de integración continua (CI) que construye y prueba código Node.js. Si tus pruebas de CI se superan, es posible que desees implementar tu código o publicar un paquete.

Prerrequisitos

Te recomendamos que tengas una comprensión básica de Node.js, YAML, las opciones de configuración de flujo de trabajo y cómo crear un archivo de flujo de trabajo. Para más información, consulte:

Utilizar ejecutores auto-hospedados en GitHub Enterprise Server

Cuando use acciones de configuración, (como actions/setup-LANGUAGE) en GitHub Enterprise Server con ejecutores autohospedados, es posible que necesite configurar la caché de herramientas en los ejecutores que no tienen acceso a Internet. Para obtener más información, vea «Configurar el caché de la herramienta en ejecutores auto-hospedados sin acceso a internet».

Utilizar un flujo de trabajo inicial de Node.js

Para comenzar rápidamente, agrega un flujo de trabajo de inicio al directorio .github/workflows del repositorio.

GitHub proporciona un flujo de trabajo inicial para Node.js que debería funcionar para la mayoría de los proyectos de Node.js. En las secciones siguientes de esta guía se proporcionan ejemplos de cómo puedes personalizar este flujo de trabajo de inicio.

  1. En tu instancia de GitHub Enterprise Server, navega a la página principal del repositorio.

  2. En el nombre del repositorio, haz clic en Acciones.

    Captura de pantalla de las pestañas del repositorio "github/docs". La pestaña "Proyectos" aparece resaltada con un contorno naranja.

  3. Si ya tiene un flujo de trabajo en su repositorio, haga clic en New workflow (Nuevo flujo de trabajo).

  4. La página "Elegir un flujo de trabajo" muestra una selección de flujos de trabajo de inicio recomendados. Busca «Node.js».

  5. Filtra la selección de flujos de trabajo con un clic en Integración continua.

  6. En el flujo de trabajo "Node.js", haga clic en Configurar.

    Si no encuentras el flujo de trabajo de inicio "Node.js", copia el siguiente código de flujo de trabajo en un nuevo archivo llamado node.js.yml en el directorio .github/workflows de tu repositorio.

    YAML
    name: Node.js CI
    
    on:
      push:
        branches: [ "main" ]
      pull_request:
        branches: [ "main" ]
    
    jobs:
      build:
        runs-on: ubuntu-latest
    
        strategy:
          matrix:
            node-version: [14.x, 16.x, 18.x]
            # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
    
        steps:
        - uses: actions/checkout@v4
        - name: Use Node.js ${{ matrix.node-version }}
          uses: actions/setup-node@v3
          with:
            node-version: ${{ matrix.node-version }}
            cache: 'npm'
        - run: npm ci
        - run: npm run build --if-present
        - run: npm test
    
  7. Edita el flujo de trabajo según sea necesario. Por ejemplo, cambia las versiones de Node que desea usar.

  8. Haga clic en Commit changes (Confirmar cambios).

Especificar la versión de Node.js

La forma más fácil de especificar una versión de Node.js consiste en usar la acción setup-node proporcionada por GitHub. Para más información, vea setup-node.

La acción setup-node toma una versión de Node.js como entrada y la configura en el ejecutor. La acción setup-node busca una versión específica de Node.js en la caché de herramientas en cada ejecutor y agrega los archivos binarios necesarios a PATH, que se conserva para el resto del trabajo. El uso de la acción setup-node es la forma recomendada de utilizar Node.js con GitHub Actions, ya que garantiza el comportamiento coherente entre los distintos ejecutores y versiones de Node.js. Si va a usar un ejecutor autohospedado, debe instalar Node.js y agregarlo a PATH.

El flujo de trabajo inicial incluye una estrategia de matriz que compila y prueba tu código con cuatro versiones de Node.js publicadas en node-version. La «x» en el número de versión es un carácter comodín que coincide con el último lanzamiento menor y de parche disponible para una versión. Cada versión de Node.js que se especifica en la matriz node-version crea un trabajo que ejecuta los mismos pasos.

Cada trabajo puede acceder al valor definido en la matriz node-version de matrices mediante el contexto matrix. La acción setup-node usa el contexto como entrada node-version. La acción setup-node configura cada trabajo con una versión diferente de Node.js antes de compilar y probar el código. Para más información sobre las estrategias y contextos de matriz, consulta "Sintaxis del flujo de trabajo para Acciones de GitHub" y "Contextos".

YAML
strategy:
  matrix:
    node-version: ['14.x', '16.x', '18.x']

steps:
- uses: actions/checkout@v4
- name: Use Node.js ${{ matrix.node-version }}
  uses: actions/setup-node@v3
  with:
    node-version: ${{ matrix.node-version }}

Como alternativa, puedes construir y probar con las versiones exactas de Node.js.

YAML
strategy:
  matrix:
    node-version: ['10.17.0', '17.9.0']

O bien, puedes construir y probar mediante una versión única de Node.js.

YAML
name: Node.js CI

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4
      - name: Use Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18.x'
      - run: npm ci
      - run: npm run build --if-present
      - run: npm test

Si no especificas una versión de Node.js, GitHub utiliza la versión de Node.js por defecto del entorno. Para obtener más información, consulta "Utilizar los ejecutores hospedados en GitHub".

Instalación de dependencias

Los ejecutores alojados en GitHub tienen instalados administradores de dependencias de npm y Yarn. Puedes usar npm y Yarn para instalar dependencias en tu flujo de trabajo antes de construir y probar tu código. Los ejecutores Windows y Linux alojados en GitHub también tienen instalado Grunt, Gulp y Bower.

También puedes almacenar en caché las dependencias para acelerar el flujo de trabajo. Para obtener más información, consulta "Almacenar en caché las dependencias para agilizar los flujos de trabajo".

Ejemplo con npm

En este ejemplo se instalan las versiones del archivo package-lock.json o npm-shrinkwrap.json, y evita las actualizaciones del archivo de bloqueo. El uso de npm ci suele ser más rápido que la ejecución de npm install. Para más información, vea npm ci e "Introducción de npm ci para compilaciones más rápidas y confiables".

YAML
steps:
- uses: actions/checkout@v4
- name: Use Node.js
  uses: actions/setup-node@v3
  with:
    node-version: '18.x'
- name: Install dependencies
  run: npm ci

Con npm install, se instalan las dependencias definidas en el archivo package.json. Para más información, vea npm install.

YAML
steps:
- uses: actions/checkout@v4
- name: Use Node.js
  uses: actions/setup-node@v3
  with:
    node-version: '18.x'
- name: Install dependencies
  run: npm install

Ejemplo con Yarn

En este ejemplo se instalan las dependencias definidas en el archivo yarn.lock y se impide que se actualicen al archivo yarn.lock. Para más información, vea yarn install.

YAML
steps:
- uses: actions/checkout@v4
- name: Use Node.js
  uses: actions/setup-node@v3
  with:
    node-version: '18.x'
- name: Install dependencies
  run: yarn --frozen-lockfile

Como alternativa, puedes instalar las dependencias definidas en el archivo package.json.

YAML
steps:
- uses: actions/checkout@v4
- name: Use Node.js
  uses: actions/setup-node@v3
  with:
    node-version: '18.x'
- name: Install dependencies
  run: yarn

Ejemplo de uso de un registro privado y la creación del archivo .npmrc

Puede usar la acción setup-node para crear un archivo .npmrc local en el ejecutor que configure el registro y el ámbito predeterminados. La acción setup-node también acepta un token de autenticación como entrada, que se usa para acceder a los registros privados o publicar paquetes de nodos. Para más información, vea setup-node.

Para autenticar tu registro privado, necesitarás almacenar tu token de autenticación de npm como un secreto. Por ejemplo, cree un secreto de repositorio denominado NPM_TOKEN. Para obtener más información, vea «Uso de secretos en Acciones de GitHub».

En el ejemplo siguiente, el secreto NPM_TOKEN almacena el token de autenticación de npm. La acción setup-node configura el archivo .npmrc para leer el token de autenticación de npm de la variable de entorno NODE_AUTH_TOKEN. Al usar la acción setup-node para crear un archivo .npmrc, debe establecer la variable de entorno NODE_AUTH_TOKEN con el secreto que contiene el token de autenticación de npm.

Antes de instalar las dependencias, use la acción setup-node para crear el archivo .npmrc. La acción tiene dos parámetros de entrada. El parámetro node-version establece la versión de Node.js y el parámetro registry-url establece el registro predeterminado. Si en el registro de paquetes se utilizan ámbitos, debe usar el parámetro scope. Para más información, vea npm-scope.

YAML
steps:
- uses: actions/checkout@v4
- name: Use Node.js
  uses: actions/setup-node@v3
  with:
    always-auth: true
    node-version: '18.x'
    registry-url: https://registry.npmjs.org
    scope: '@octocat'
- name: Install dependencies
  run: npm ci
  env:
    NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

En el ejemplo anterior se crea un archivo .npmrc con el contenido siguiente:

//registry.npmjs.org/:_authToken=${NODE_AUTH_TOKEN}
@octocat:registry=https://registry.npmjs.org/
always-auth=true

Ejemplo de dependencias en caché

Puedes almacenar en caché y restaurar las dependencias mediante la acción setup-node.

El siguiente ejemplo guarda las dependencias en caché para npm.

YAML
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v3
  with:
    node-version: '14'
    cache: 'npm'
- run: npm install
- run: npm test

El siguiente ejemplo guarda las dependencias en caché para Yarn.

YAML
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v3
  with:
    node-version: '14'
    cache: 'yarn'
- run: yarn
- run: yarn test

El siguiente ejemplo guarda las dependencias en caché para pnpm (v6.10+).

YAML
# Este flujo de trabajo usa acciones que no GitHub no certifica.
# Estas las proporcionan entidades terceras y las gobiernan
# condiciones de servicio, políticas de privacidad y documentación de soporte
# en línea.

# NOTE: pnpm caching support requires pnpm version >= 6.10.0

steps:
- uses: actions/checkout@v4
- uses: pnpm/action-setup@0609f0983b7a228f052f81ef4c3d6510cae254ad
  with:
    version: 6.10.0
- uses: actions/setup-node@v3
  with:
    node-version: '14'
    cache: 'pnpm'
- run: pnpm install
- run: pnpm test

Si tiene una necesidad específica o necesita controles más precisos para el almacenamiento en caché, puede usar la acción cache. Para obtener más información, vea «Almacenar en caché las dependencias para agilizar los flujos de trabajo».

Construir y probar tu código

Puedes usar los mismos comandos que usas de forma local para construir y probar tu código. Por ejemplo, si ejecuta npm run build para ejecutar los pasos de compilación definidos en el archivo package.json y npm test para ejecutar el conjunto de pruebas, tendría que agregar esos comandos en el archivo de flujo de trabajo.

YAML
steps:
- uses: actions/checkout@v4
- name: Use Node.js
  uses: actions/setup-node@v3
  with:
    node-version: '18.x'
- run: npm install
- run: npm run build --if-present
- run: npm test

Empaquetar datos de flujo de trabajo como artefactos

Puedes guardar los artefactos de tus pasos de construcción y prueba para verlos después de que se complete un trabajo. Por ejemplo, es posible que debas guardar los archivos de registro, los vaciados de memoria, los resultados de las pruebas o las capturas de pantalla. Para obtener más información, vea «Almacenar los datos de los flujos de trabajo como artefactos».

Publicar en registros de paquetes

Puedes configurar tu flujo de trabajo para que publique tu paquete Node.js en un registro de paquete después de que se aprueben tus pruebas de CI. Para más información sobre la publicación en npm y GitHub Packages consulta "Publicar paquetes Node.js".