{"meta":{"title":"Referencia de almacenamiento en caché de dependencias","intro":"Encuentra información sobre la funcionalidad del almacenamiento en caché de dependencias en los flujos de trabajo.","product":"GitHub Actions","breadcrumbs":[{"href":"/es/actions","title":"GitHub Actions"},{"href":"/es/actions/reference","title":"Referencia"},{"href":"/es/actions/reference/workflows-and-actions","title":"Flujos de trabajo y acciones"},{"href":"/es/actions/reference/workflows-and-actions/dependency-caching","title":"Almacenamiento en caché de dependencias"}],"documentType":"article"},"body":"# Referencia de almacenamiento en caché de dependencias\n\nEncuentra información sobre la funcionalidad del almacenamiento en caché de dependencias en los flujos de trabajo.\n\n## Uso de la acción `cache`\n\nLa acción [`cache`](https://github.com/actions/cache) intentará la siguiente secuencia al restaurar una caché:\n\n1. En primer lugar, busca una coincidencia exacta con la `key` proporcionada.\n2. Si no se encuentra ninguna coincidencia exacta, buscará coincidencias parciales de `key`.\n3. Si todavía no se encuentra ninguna coincidencia y has proporcionado `restore-keys`, estas claves se comprobarán secuencialmente para buscar coincidencias parciales. Para obtener más información, consulta [Coincidencia de clave de caché](#cache-key-matching).\n\nSi hay una coincidencia exacta con el elemento `key` proporcionado, se considera un acierto de caché. Si ninguna memoria caché coincide exactamente con el elemento `key` proporcionado, se considera un error de caché. En un error de caché, la acción crea automáticamente una nueva memoria caché si el trabajo se completa correctamente. La nueva caché usará el elemento `key` que proporcionaste y contiene los archivos que especificaste en `path`. Para obtener más información sobre cómo se controla esto, consulte [Aciertos y errores de caché](#cache-hits-and-misses).\n\nNo se puede cambiar el contenido de una memoria caché existente. En su lugar, puedes crear una nueva memoria caché con una nueva clave.\n\n### Parámetros de entrada de la acción `cache`\n\n* `key`: **obligatorio** La clave creada al guardar una memoria caché y la clave usada para buscar una caché. Puede ser cualquier combinación de variables, valores de contexto, cadenas estáticas y funciones. Las claves tienen una longitud máxima de 512 caracteres y las claves más largas que la longitud máxima provocarán un error en la acción.\n\n* `path`: **obligatorio** Las rutas de acceso en el ejecutor para almacenar en caché o restaurar.\n  * Puedes especificar una única ruta de acceso o agregar varias rutas de acceso en líneas independientes. Por ejemplo:\n\n    ```yaml\n    - name: Cache Gradle packages\n      uses: actions/cache@v4\n      with:\n        path: |\n          ~/.gradle/caches\n          ~/.gradle/wrapper\n    ```\n\n  * Puedes especificar directorios o archivos únicos, y los patrones globales son compatibles.\n\n  * Puedes especificar rutas de acceso absolutas o rutas de acceso relativas al directorio del área de trabajo.\n\n* `restore-keys`: **opcional** Una cadena que contiene claves de restauración alternativas, con cada clave de restauración colocada en una nueva línea. Si no se produce ningún acierto de caché para `key`, estas claves de restauración se usan secuencialmente en el orden proporcionado para buscar y restaurar una caché. Por ejemplo:\n\n  ```yaml\n  restore-keys: |\n    npm-feature-${{ hashFiles('package-lock.json') }}\n    npm-feature-\n    npm-\n  ```\n\n* `enableCrossOsArchive`: **Optional** Valor booleano que, cuando está habilitado, permite a los ejecutores de Windows guardar o restaurar cachés independientemente del sistema operativo en el que se creó la memoria caché. Si no se establece este parámetro, el valor predeterminado es `false`. Para obtener más información, consulta la sección sobre [caché entre sistemas operativos](https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cross-os-cache) en la documentación de caché de Acciones.\n\n> \\[!NOTE]\n> Se recomienda no almacenar información confidencial, como tokens de acceso o credenciales de inicio de sesión, en los archivos de la ruta de acceso de la memoria caché. Cualquier usuario con acceso de lectura puede crear una solicitud de incorporación de cambios en un repositorio y acceder a los contenidos de una caché. Además, las bifurcaciones de un repositorio pueden crear solicitudes de extracción en la rama base y acceder a las cachés en la rama base.\n\n### Parámetros de salida de la acción `cache`\n\n* `cache-hit`: valor booleano para indicar que se encontró una coincidencia exacta para la clave.\n\n### Aciertos y errores de caché\n\nCuando `key` coincide exactamente con una memoria caché existente, se denomina un *acierto de caché* y la acción restaura los archivos almacenados en caché en el directorio `path`.\n\nCuando `key` no coincide con una caché existente, se denomina un *error de caché* y se crea automáticamente una caché si el trabajo se completa correctamente.\n\nCuando se produce un error de caché, la acción también busca los elementos `restore-keys` especificados en busca de coincidencias:\n\n1. Si proporcionas `restore-keys`, la acción `cache` busca secuencialmente las memorias caché que coincidan con la lista de `restore-keys`.\n   * Cuando hay una coincidencia exacta, la acción restaura los archivos en la memoria caché al directorio `path`.\n   * Si no hay coincidencias exactas, la acción busca coincidencias parciales de las claves de restauración. Cuando la acción encuentra una coincidencia parcial, se restaura la caché más reciente al directorio `path`.\n2. La acción `cache` se completa y se ejecuta el paso siguiente del flujo de trabajo.\n3. Si el trabajo se completa correctamente, la acción crea automáticamente una caché con los contenidos del directorio `path`.\n\nPara obtener una explicación más detallada del proceso de coincidencia de caché, consulta [Coincidencia de clave de caché](#cache-key-matching).\n\n### Ejemplo de uso de la acción `cache`\n\nEn este ejemplo se crea una nueva memoria caché cuando cambian los paquetes del archivo `package-lock.json` o cuando cambia el sistema operativo del ejecutor. La clave de caché usa contextos y expresiones para generar una clave que incluye el sistema operativo del ejecutor y un hash SHA-256 del archivo `package-lock.json`.\n\n```yaml copy\nname: Caching with npm\non: push\njobs:\n  build:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v6\n\n      - name: Cache node modules\n        id: cache-npm\n        uses: actions/cache@v4\n        env:\n          cache-name: cache-node-modules\n        with:\n          # npm cache files are stored in `~/.npm` on Linux/macOS\n          path: ~/.npm\n          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/package-lock.json') }}\n          restore-keys: |\n            ${{ runner.os }}-build-${{ env.cache-name }}-\n            ${{ runner.os }}-build-\n            ${{ runner.os }}-\n\n      - if: ${{ steps.cache-npm.outputs.cache-hit != 'true' }}\n        name: List the state of node modules\n        continue-on-error: true\n        run: npm list\n\n      - name: Install dependencies\n        run: npm install\n\n      - name: Build\n        run: npm run build\n\n      - name: Test\n        run: npm test\n```\n\n### Usar contextos para crear claves de caché\n\nUna clave de caché puede incluir cualquiera de los contextos, funciones, literales y operadores admitidos por GitHub Actions. Para más información, consulta [Contextos de referencia](/es/actions/learn-github-actions/contexts) y [Evaluación de expresiones en flujos de trabajo y acciones](/es/actions/learn-github-actions/expressions).\n\nUsar expresiones para crear un elemento `key` te permite crear automáticamente una caché cuando las dependencias cambian.\n\nPor ejemplo, puedes crear una `key` mediante una expresión que calcule el hash de un archivo `package-lock.json` de npm. Por lo tanto, cuando cambian las dependencias que componen el cambio en el archivo `package-lock.json`, la clave de caché cambia y se crea automáticamente una caché.\n\n```yaml\nnpm-${{ hashFiles('package-lock.json') }}\n```\n\nGitHub evalúa la expresión `hash \"package-lock.json\"` para generar el `key` final.\n\n```yaml\nnpm-d5ea0750\n```\n\n### Uso de la salida de la acción `cache`\n\nPuedes usar la salida de la acción `cache` para hacer algo en función de si se ha producido un acierto o un error en la caché. Si se encuentra una coincidencia exacta para la caché en la `key` especificada, la salida `cache-hit` se establece en `true`.\n\nEn el flujo de trabajo de ejemplo anterior, hay un paso que enumera el estado de los módulos de Node si se ha producido un error en la caché:\n\n```yaml\n- if: ${{ steps.cache-npm.outputs.cache-hit != 'true' }}\n  name: List the state of node modules\n  continue-on-error: true\n  run: npm list\n```\n\n## Coincidencia de clave de caché\n\nLa acción `cache` busca primero los aciertos de caché para `key` y la *versión* de la memoria caché en la rama que contiene la ejecución del flujo de trabajo. Si no hay ningún acierto, busca coincidencias de prefijo para `key` y, si aún no hay ningún acierto, busca `restore-keys` y la *versión*. Si sigue sin haber aciertos en la rama actual, la acción `cache` reintenta los mismos pasos en la rama predeterminada. Ten en cuenta que se aplican las restricciones de ámbito durante la búsqueda. Para obtener más información, consulte [Restricciones para acceder a una memoria caché](#restrictions-for-accessing-a-cache).\n\nLa versión de la memoria caché es una forma de marcar con un sello una memoria caché con metadatos de `path` y la herramienta de compresión que se usa al crear la memoria caché. Esto garantiza que la ejecución del flujo de trabajo de consumo coincida únicamente con una memoria caché que realmente puede descomprimir y usar. Para obtener más información, consulta [Versión de caché](https://github.com/actions/cache#cache-version) en la documentación de caché de Acciones.\n\n```\n          `restore-keys` permite especificar una lista de claves de restauración alternativas que se usarán cuando se produce un error de caché en `key`. Puedes crear múltiples claves de restauración ordenadas desde las más específicas hasta las menos específicas. La acción `cache` busca `restore-keys` en orden secuencial. Cuando una clave no coincide directamente, la acción busca las claves prefijadas con la clave de restauración. Si hay múltiples coincidencias parciales para una clave de restauración, la acción devuelve la caché que se creó más recientemente.\n```\n\n### Ejemplo usando múltiples claves de restauración\n\n```yaml\nrestore-keys: |\n  npm-feature-${{ hashFiles('package-lock.json') }}\n  npm-feature-\n  npm-\n```\n\nEl ejecutor evalúa las expresiones, que se resuelven en estos `restore-keys`:\n\n```yaml\nrestore-keys: |\n  npm-feature-d5ea0750\n  npm-feature-\n  npm-\n```\n\nLa clave de restauración `npm-feature-` coincide con cualquier clave que comience por la cadena `npm-feature-`. Por ejemplo, las claves `npm-feature-fd3052de` y `npm-feature-a9b253ff` coinciden con la clave de restauración. Se utilizará la caché con la fecha de creación más reciente. Las claves en este ejemplo se buscan en el siguiente orden:\n\n1. ```\n          **\n          `npm-feature-d5ea0750`\n          ** coincide con un hash específico.\n   ```\n2. ```\n          **\n          `npm-feature-`\n          ** coincide con las claves de caché con el prefijo `npm-feature-`.\n   ```\n3. ```\n          **\n          `npm-`\n          ** coincide con cualquier clave con el prefijo `npm-`.\n   ```\n\n#### Ejemplo de prioridad de búsqueda\n\n```yaml\nkey:\n  npm-feature-d5ea0750\nrestore-keys: |\n  npm-feature-\n  npm-\n```\n\nPor ejemplo, si una solicitud de incorporación de cambios contiene una rama `feature` y tiene como destino la rama predeterminada (`main`), la acción busca `key` y `restore-keys` en el orden siguiente:\n\n1. Clave `npm-feature-d5ea0750` en la rama `feature`\n2. Clave `npm-feature-` en la rama `feature`\n3. Clave `npm-` en la rama `feature`\n4. Clave `npm-feature-d5ea0750` en la rama `main`\n5. Clave `npm-feature-` en la rama `main`\n6. Clave `npm-` en la rama `main`\n\n## Acciones de `setup-*` para administradores de paquetes específicos\n\nSi almacenas en caché los administradores de paquetes que se enumeran debajo, el uso de sus respectivas acciones setup-\\* requiere una configuración mínima, y creará y restaurará las cachés de dependencias automáticamente.\n\n| Administradores de paquetes | acción de setup-\\* para almacenar en caché |\n| --------------------------- | ------------------------------------------ |\n| npm, Yarn, pnpm             |                                            |\n\n```\n          [setup-node](https://github.com/actions/setup-node#caching-global-packages-data)                  |\n```\n\n\\| pip, pipenv, Poetry |\n[setup-python](https://github.com/actions/setup-python#caching-packages-dependencies)             |\n\\| Gradle, Maven       |\n[setup-java](https://github.com/actions/setup-java#caching-packages-dependencies)                 |\n\\| RubyGems            |\n[setup-ruby](https://github.com/ruby/setup-ruby#caching-bundle-install-automatically)             |\n\\| Ir `go.sum`         |\n[setup-go](https://github.com/actions/setup-go#caching-dependency-files-and-build-outputs)        |\n\\| NuGet de .NET          |\n[setup-dotnet](https://github.com/actions/setup-dotnet?tab=readme-ov-file#caching-nuget-packages) |\n\n## Restricciones para acceder a una caché\n\nLas restricciones de acceso proporcionan aislamiento y seguridad de caché al crear una frontera lógica entre las ramas o etiquetas diferentes.\nLas ejecuciones de flujo de trabajo pueden restaurar las memorias caché creadas en la rama actual o en la rama predeterminada (normalmente `main`). Si se desencadena una ejecución de flujo de trabajo para una solicitud de incorporación de cambios, también puede restaurar las memorias caché creadas en la rama base, incluidas las ramas base de repositorios bifurcados. Por ejemplo, si la rama `feature-b` tiene la rama base `feature-a`, una ejecución de flujo de trabajo desencadenada en una solicitud de incorporación de cambios tendría acceso a las memorias caché creadas en la rama predeterminada `main`, la rama base `feature-a` y la rama actual `feature-b`.\n\nLas ejecuciones de flujo de trabajo no pueden restaurar las memorias caché creadas para ramas secundarias o ramas del mismo nivel. Por ejemplo, una memoria caché creada para la rama secundaria `feature-b` no sería accesible para una ejecución de flujo de trabajo desencadenada en la rama primaria `main`. De forma similar, una memoria caché creada para la rama `feature-a` con la rama `main` base no sería accesible para su la rama `feature-c` del mismo nivel con la rama base `main`. Las ejecuciones de flujo de trabajo tampoco pueden restaurar las memorias caché creadas para nombres de etiqueta diferentes. Por ejemplo, una memoria caché creada para la etiqueta `release-a` con la rama `main` no sería accesible para un flujo de trabajo desencadenado para la etiqueta `release-b` con la rama base `main`.\n\nCuando se crea una memoria caché mediante una ejecución de flujo de trabajo desencadenada en una solicitud de incorporación de cambios, dicha memoria caché se crea para la referencia de combinación (`refs/pull/.../merge`). Por este motivo, la memoria caché tendrá un ámbito limitado y solo se puede restaurar mediante nuevas ejecuciones de la solicitud de incorporación de cambios. No se puede restaurar mediante la rama base u otras solicitudes de incorporación de cambios destinadas a esa rama base.\n\nVarias ejecuciones de flujo de trabajo en un repositorio pueden compartir memorias caché. Se puede acceder a una memoria caché creada para una rama en una ejecución de flujo de trabajo y restaurarla desde otra ejecución de flujo de trabajo para el mismo repositorio y rama.\n\n## Límites de uso y política de desalojo\n\nGitHub aplica límites al almacenamiento en caché y la retención para administrar los costos de almacenamiento y evitar el abuso. Comprender estos límites le ayuda a optimizar el uso de la memoria caché.\n\n### Límites predeterminados\n\nGitHub quitará las entradas de caché a las que no se ha accedido en más de 7 días. No hay ningún límite en el número de memorias caché que puede almacenar, pero el tamaño total de todas las cachés de un repositorio está limitado. De forma predeterminada, el límite es de 10 GB por repositorio, pero este límite puede aumentarse por los propietarios de la empresa, los propietarios de la organización o los administradores de repositorios. Cualquier uso superior a 10 GB se factura a su cuenta. Una vez que un repositorio haya alcanzado su almacenamiento máximo de caché, la directiva de expulsión de caché creará espacio eliminando las cachés en orden de la última fecha de acceso, de más antigua a más reciente.\n\nSi excedes el límite, GitHub guardará la nueva caché, pero comenzará a desalojar las cachés hasta que el tamaño total sea inferior al límite del repositorio. El proceso de expulsión de caché puede provocar la paginación excesiva de caché, donde las memorias caché se crean y eliminan con una alta frecuencia. Para reducir esto, puede revisar las memorias caché de un repositorio y tomar medidas correctivas, como quitar el almacenamiento en caché de flujos de trabajo específicos o aumentar el tamaño de la caché. Esta funcionalidad solo está disponible para los usuarios con un método de pago registrado que han optado por configurar las opciones de caché. Consulta [Administración de cachés](/es/actions/how-tos/managing-workflow-runs-and-deployments/managing-workflow-runs/manage-caches).\n\nPuede crear entradas de caché a una velocidad de hasta 200 cargas por minuto por repositorio y descargarlas a una velocidad de 1500 descargas por minuto por repositorio. Si supera esta velocidad, se producirá un error en los intentos posteriores de carga o descarga de caché hasta que se restablezca el límite de velocidad correspondiente. El tiempo que falta para que se restablezca el límite de tasa se devuelve en el encabezado `Retry-After` de la respuesta. Consulte [Límites de acciones](/es/actions/reference/limits) para obtener más información sobre los límites de frecuencia de GitHub Actions.\n\n### Aumento del tamaño de la caché\n\nSi desea reducir la velocidad a la que se expulsan las entradas de caché, puede aumentar los límites de almacenamiento de la memoria caché en la configuración de acciones. Los repositorios propiedad de los usuarios pueden configurar hasta 10 TB por repositorio. En el caso de los repositorios propiedad de las organizaciones, el límite máximo configurable viene determinado por la configuración de la organización. En el caso de las organizaciones que pertenecen a una empresa, el límite máximo configurable viene determinado por la configuración de la empresa. Aumentar el límite más allá del valor predeterminado de 10 GB incurrirá en costos adicionales, si se usa ese almacenamiento.\n\nPara obtener más información, consulte:\n\n* [Administración de la configuración de GitHub Actions para un repositorio](/es/repositories/managing-your-repositorys-settings-and-features/enabling-features-for-your-repository/managing-github-actions-settings-for-a-repository#configuring-cache-settings-for-your-repository)\n* [Deshabilitación o limitación de GitHub Actions para su organización](/es/organizations/managing-organization-settings/disabling-or-limiting-github-actions-for-your-organization#managing-github-actions-cache-storage-for-your-organization)\n* [Aplicación de directivas para GitHub Actions en la empresa](/es/enterprise-cloud@latest/admin/enforcing-policies/enforcing-policies-for-your-enterprise/enforcing-policies-for-github-actions-in-your-enterprise#artifact-and-log-retention)\n\nEl uso de almacenamiento adicional también se controla mediante presupuestos establecidos para GitHub Actions o la SKU de almacenamiento en caché de acciones. Si tiene límites configurados y supera un presupuesto, la memoria caché pasará a ser de solo lectura hasta que se resuelva el estado de facturación, o el uso estará por debajo del límite gratuito de 10 GB al expirar o eliminarse explícitamente. Para obtener más información sobre cómo configurar presupuestos, consulte [Configuración de presupuestos para controlar el gasto en productos medidos](/es/billing/how-tos/set-up-budgets).\n\nSi se establecen presupuestos de SKU de almacenamiento en caché de acciones inferiores al coste total de uso del almacenamiento configurado durante el período de facturación, la caché puede entrar con frecuencia en modo de solo lectura. Por ejemplo, si el presupuesto de la SKU es de 0 USD y ha configurado el tamaño máximo de caché del repositorio a 20 GB, la memoria caché entrará en modo de solo lectura en cuanto el almacenamiento supere el umbral libre.\n\nA continuación se muestran algunos costes mensuales ilustrativos para informar de los presupuestos que puede desear establecer para la SKU de almacenamiento en caché de acciones.\n\n| Tamaño de memoria caché | Costo mensual (si se utiliza por completo) |\n| ----------------------- | ------------------------------------------ |\n| 50GB                    | $2,80                                      |\n| 200 GB                  | 13,30 USD                                  |\n| 1000 GB                 | 69,30 USD                                  |\n\n## Pasos siguientes\n\nPara administrar las memorias caché de dependencias, consulta [Administración de cachés](/es/actions/how-tos/managing-workflow-runs-and-deployments/managing-workflow-runs/manage-caches)."}