# Crear y probar en Node.js

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

## 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, vea:

* [Escritura de flujos de trabajo](/es/enterprise-cloud@latest/actions/learn-github-actions)
* [Introducción a Node.js](https://nodejs.org/en/docs/guides/getting-started-guide/)

## Uso de una plantilla de flujo de trabajo de Node.js

Para comenzar rápidamente, agregue una plantilla de flujo de trabajo al directorio `.github/workflows` del repositorio.

GitHub proporciona una plantilla de flujo de trabajo 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 puede personalizar esta plantilla de flujo de trabajo.

1. En GitHub, navegue hasta la página principal del repositorio.

2. En el nombre del repositorio, haz clic en **<svg version="1.1" width="16" height="16" viewBox="0 0 16 16" class="octicon octicon-play" aria-label="play" role="img"><path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Zm4.879-2.773 4.264 2.559a.25.25 0 0 1 0 .428l-4.264 2.559A.25.25 0 0 1 6 10.559V5.442a.25.25 0 0 1 .379-.215Z"></path></svg> Actions**.

   ![Captura de pantalla de las pestañas del repositorio "github/docs". La pestaña "Proyectos" aparece resaltada con un contorno naranja.](/assets/images/help/repository/actions-tab-global-nav-update.png)

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

4. En la página "Elegir un flujo de trabajo" se muestra una selección de plantillas de flujo de trabajo recomendadas. 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», haz clic en **Configurar**.

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).

El archivo de flujo de trabajo `node.js.yml` se agrega al directorio `.github/workflows` de tu repositorio.

## 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`](https://github.com/actions/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`.

La plantilla de flujo de trabajo incluye una estrategia de matriz que compila y prueba el código con cuatro versiones de Node.js enumeradas 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` utilizando 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 GitHub Actions](/es/enterprise-cloud@latest/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstrategymatrix) y [Contextos de referencia](/es/enterprise-cloud@latest/actions/learn-github-actions/contexts).

```yaml copy
strategy:
  matrix:
    node-version: ['18.x', '20.x']

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

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

```yaml copy
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 copy
name: Node.js CI

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v6
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20.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 más información, consulta [Ejecutores hospedados en GitHub](/es/enterprise-cloud@latest/actions/using-github-hosted-runners/about-github-hosted-runners#supported-software).

## 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 puede almacenar en caché sus dependencias para acelerar su flujo de trabajo. Para más información, consulta [Referencia de almacenamiento en caché de dependencias](/es/enterprise-cloud@latest/actions/using-workflows/caching-dependencies-to-speed-up-workflows).

### 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, consulta [`npm ci`](https://docs.npmjs.com/cli/ci.html) e [Introducción de `npm ci` para compilaciones más rápidas y confiables](https://blog.npmjs.org/post/171556855892/introducing-npm-ci-for-faster-more-reliable).

```yaml copy
steps:
- uses: actions/checkout@v6
- name: Use Node.js
  uses: actions/setup-node@v4
  with:
    node-version: '20.x'
- name: Install dependencies
  run: npm ci
```

Con `npm install`, se instalan las dependencias definidas en el archivo `package.json`. Para obtener más información, vea [`npm install`](https://docs.npmjs.com/cli/install).

```yaml copy
steps:
- uses: actions/checkout@v6
- name: Use Node.js
  uses: actions/setup-node@v4
  with:
    node-version: '20.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 obtener más información, vea [`yarn install`](https://yarnpkg.com/en/docs/cli/install).

```yaml copy
steps:
- uses: actions/checkout@v6
- name: Use Node.js
  uses: actions/setup-node@v4
  with:
    node-version: '20.x'
- name: Install dependencies
  run: yarn --frozen-lockfile
```

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

```yaml copy
steps:
- uses: actions/checkout@v6
- name: Use Node.js
  uses: actions/setup-node@v4
  with:
    node-version: '20.x'
- name: Install dependencies
  run: yarn
```

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

Puedes 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`](https://github.com/actions/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 más información, consulta [Uso de secretos en Acciones de GitHub](/es/enterprise-cloud@latest/actions/security-guides/using-secrets-in-github-actions).

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 obtener más información, vea [`npm-scope`](https://docs.npmjs.com/misc/scope).

```yaml copy
steps:
- uses: actions/checkout@v6
- name: Use Node.js
  uses: actions/setup-node@v4
  with:
    always-auth: true
    node-version: '20.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:

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

### Ejemplo de dependencias de almacenamiento en caché

Puedes almacenar en caché y restaurar las dependencias mediante la [acción `setup-node`](https://github.com/actions/setup-node).

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

```yaml copy
steps:
- uses: actions/checkout@v6
- uses: actions/setup-node@v4
  with:
    node-version: '20'
    cache: 'npm'
- run: npm install
- run: npm test
```

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

```yaml copy
steps:
- uses: actions/checkout@v6
- uses: actions/setup-node@v4
  with:
    node-version: '20'
    cache: 'yarn'
- run: yarn
- run: yarn test
```

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

```yaml copy
# 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@v6
- uses: pnpm/action-setup@0609f0983b7a228f052f81ef4c3d6510cae254ad
  with:
    version: 6.10.0
- uses: actions/setup-node@v4
  with:
    node-version: '20'
    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`](https://github.com/marketplace/actions/cache). Para más información, consulta [Referencia de almacenamiento en caché de dependencias](/es/enterprise-cloud@latest/actions/using-workflows/caching-dependencies-to-speed-up-workflows).

## 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 copy
steps:
- uses: actions/checkout@v6
- name: Use Node.js
  uses: actions/setup-node@v4
  with:
    node-version: '20.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 procesos de construcción y prueba para verlos una vez que el trabajo haya concluido. 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 más información, consulta [Almacenamiento y uso compartido de datos con artefactos de flujo de trabajo](/es/enterprise-cloud@latest/actions/using-workflows/storing-workflow-data-as-artifacts).

## Publicar en repositorios 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](/es/enterprise-cloud@latest/actions/publishing-packages/publishing-nodejs-packages).