Se usó la API de Cloud Translation para traducir esta página.

Especifica dependencias en Python

Especifica las dependencias de tu aplicación para las versiones de Python compatibles con cualquiera de los siguientes enfoques:

Usa un archivo requirements.txt en el directorio raíz. Este archivo debe estar en el mismo directorio que el archivo main.py que contiene tu código fuente. El archivo requirements.txt contiene una línea por paquete. Cada línea contiene el nombre del paquete y, de manera opcional, la versión solicitada. Para evitar que la compilación se vea afectada por los cambios en la versión de la dependencia, considera fijar los paquetes de dependencias a una versión específica.

El siguiente es un archivo requirements.txt de ejemplo:
```
functions-framework
requests==2.20.0
numpy
```
Usa un archivo pyproject.toml para especificar dependencias. Si administras las dependencias de tu aplicación en un archivo pyproject.toml en lugar del archivo requirements.txt, el paquete de compilación de Python determinará el administrador de paquetes según la configuración que especifiques en el archivo pyproject.toml. Para obtener más información, consulta Implementa aplicaciones de Python con un archivo pyproject.toml.

Si tu aplicación usa el archivo pyproject.toml y el archivo requirements.txt, este último tiene prioridad.requirements.txt
- El siguiente es un archivo pyproject.toml de ejemplo:
```
[project]
name = "demo-app"
version = "0.1.0"
description = ""
requires-python = ">=3.10"
dependencies = [
    "flask>=3.1.1",
    "gunicorn>=23.0.0",
]

[build-system]
requires = ["setuptools>=61.0"]
build-backend = "setuptools.build_meta"
```

Empaqueta las dependencias locales junto con tu función.

No se admite la especificación de dependencias que usa el estándar Pipfile/Pipfile.lock. Tu proyecto no debe incluir estos archivos.

Si usas un archivo requirements.txt para administrar las dependencias, Cloud Run instala Functions Framework por ti cuando creas una función. Sin embargo, te recomendamos que incluyas Functions Framework como una dependencia explícita para evitar discrepancias.

Cuando usas un archivo pyproject.toml, debes incluir Functions Framework como una dependencia, ya que Cloud Run no lo instala por ti.

Administrador de paquetes

Si administras tus dependencias con un requirements.txt file, el administrador de paquetes predeterminado varía según la versión de Python que configures.

Si usas un archivo pyproject.toml para administrar las dependencias en lugar de un archivo requirements.txt, el buildpack de Python determinará el administrador de paquetes según la configuración del archivo pyproject.toml. El paquete de compilación admite los administradores de paquetes pip, uv y Poetry. Para obtener más información, consulta Implementa aplicaciones de Python con un archivo pyproject.toml.

Python 3.14 y versiones posteriores

A partir de la versión 3.14 de Python (versión preliminar) y versiones posteriores, el paquete de compilación de Python usa el administrador de paquetes uv como instalador predeterminado para las dependencias que especifiques en tu archivo requirements.txt.

Para usar pip como administrador de paquetes, configura la variable de entorno GOOGLE_PYTHON_PACKAGE_MANAGER="pip".

Ejecuta el comando gcloud run deploy para establecer la variable de entorno del administrador de paquetes en pip:

gcloud run deploy SERVICE --source . \
  --set-build-env-vars=GOOGLE_PYTHON_PACKAGE_MANAGER=pip

SERVICE por el nombre de tu servicio de Cloud Run.

Python 3.13 y versiones anteriores

Para la versión 3.13 y las anteriores de Python, el paquete de compilación de Python usa el administrador de paquetes pip para instalar las dependencias que definas en el archivo requirements.txt.

Para usar uv (versión preliminar) como administrador de paquetes, configura la variable de entorno GOOGLE_PYTHON_PACKAGE_MANAGER="uv".

Ejecuta el comando gcloud beta run deploy para establecer la variable de entorno del administrador de paquetes en uv:

gcloud beta run deploy SERVICE --source . \
  --set-build-env-vars=GOOGLE_PYTHON_PACKAGE_MANAGER=uv

SERVICE por el nombre de tu servicio de Cloud Run.

Empaqueta las dependencias locales

Empaqueta e implementa dependencias junto con tu función. Este enfoque es útil si tu dependencia no está disponible cuando usas un administrador de paquetes compatible o si el acceso a Internet de tu entorno de Cloud Run está restringido.

También puedes usar un archivo requirements.txt para especificar dependencias adicionales que no empaquetaste junto con tu función. Por ejemplo, podrías usar la siguiente estructura de directorio:

myfunction/
├── main.py
└── localpackage/
    ├── __init__.py
    └── script.py

Importa el código desde localpackage con la siguiente sentencia import:

# code in main.py
from localpackage import script

Este enfoque no ejecutará ningún archivo setup.py. Puedes agrupar los paquetes con esos archivos, pero es posible que el paquete no se ejecute correctamente en Cloud Run Functions.

Dependencias copiadas

Las dependencias copiadas son aquellas cuyo origen se incluye directamente en tu paquete de código fuente y que se vuelven a compilar junto con tu propio código. Usa la variable de entorno de compilación GOOGLE_VENDOR_PIP_DEPENDENCIES para crear copias de las dependencias de pip y evitar instalarlas durante la implementación.

Crea dependencias copiadas

Asegúrate de que python3 esté instalado en tu sistema de desarrollo.
Declara las dependencias de la aplicación en un archivo requirements.txt ubicado en el directorio raíz del árbol de desarrollo.
Declara Functions Framework como requisito incluyendo functions-framework en otra línea del archivo requirements.txt.
Descarga las dependencias de la función en el directorio local. Los pasos para hacerlo dependen de si la dependencia es un archivo wheel de Python (*.whl) o un archivo tar (*.tar.gz).
1. Si la dependencia es un archivo wheel de Python (*.whl), descárgala en el directorio raíz del árbol de desarrollo con este comando pip:
```
python3 -m pip download -r requirements.txt --only-binary=:all: \
   -d DIRECTORY \
   --python-version PYTHON_RUNTIME_VERSION \
   --platform manylinux2014_x86_64 \
   --implementation cp
```
  Reemplaza lo siguiente:
  - DIRECTORY: El nombre del directorio local en el que se descargará.
  - PYTHON_RUNTIME_VERSION: es la versión de Python que se usa para las verificaciones de compatibilidad. Por ejemplo, 314 para Python 3.14.
    Esta versión debe coincidir con uno de los entornos de ejecución de Python compatibles.
  La estructura del directorio resultante debería tener el aspecto siguiente:
```
myfunction/
├── main.py
└── requirements.txt
└── DIRECTORY
   ├── dependency1.whl
   └── dependency2.whl
```
2. Si la dependencia es un archivo tar (*.tar.gz):
  1. Si la dependencia está escrita en Python, usa pip para descargarla:
```
python3 -m pip download -r requirements.txt \
   -d DIRECTORY
```
  2. Si una dependencia consiste en código escrito en C o C++, descarga y compila el código por separado.
Implementa tu función y sus dependencias copiadas:
```
gcloud functions deploy FUNCTION_NAME \
  --runtime PYTHON_RUNTIME_NAME \
  --set-build-env-vars GOOGLE_VENDOR_PIP_DEPENDENCIES=DIRECTORY
```
Reemplaza lo siguiente:
- FUNCTION_NAME: Es el nombre de la función que estás implementando.
- PYTHON_RUNTIME_NAME: Es el nombre de uno de los entornos de ejecución de Python compatibles en los que se ejecutará la función implementada, por ejemplo, python311. Debe ser la misma versión del entorno de ejecución de Python que usaste en tu entorno de desarrollo local.
- DIRECTORY: Es el nombre del directorio que contiene las dependencias copiadas.

Para obtener más detalles sobre cómo se usan los buildpacks, consulta Compila una función con buildpacks.

Usa dependencias privadas

Puedes usar dependencias privadas de Artifact Registry o de otros repositorios.

Dependencias privadas de Artifact Registry

Un repositorio de Python para Artifact Registry aloja dependencias privadas para tu función de Python. Cuando se realiza la implementación en Cloud Run, el proceso de compilación genera automáticamente las credenciales de Artifact Registry para la cuenta de servicio de Cloud Build. Incluye la URL de Artifact Registry en tu requirements.txt sin generar credenciales adicionales. Por ejemplo:

--index-url REPOSITORY_URL
sampleapp
Flask==0.10.1
google-cloud-storage

Si la compilación necesita varios repositorios, usa un repositorio virtual de Artifact Registry para controlar de forma segura el orden en que pip busca los repositorios.

Dependencias privadas de otros repositorios

Los buildpacks instalan dependencias en un entorno de Cloud Build que no proporciona acceso a las llaves SSH. Copia los paquetes que alojas en repositorios que requieren autenticación basada en SSH y súbelos con el código de tu proyecto.

Usa el comando pip install con el parámetro -t DIRECTORY para copiar las dependencias privadas en un directorio local antes de implementar tu app, de la siguiente manera:

Copia tu dependencia en un directorio local:
```
pip install -t DIRECTORY DEPENDENCY
```
Agrega un archivo __init__.py vacío al directorio DIRECTORY para convertirlo en un módulo.
Importa desde este módulo para usar tu dependencia:
```
import DIRECTORY.DEPENDENCY
```

Paquetes preinstalados

El paquete de compilación de Python instala los siguientes paquetes de Python cuando implementas tu función. Si usas alguno de estos paquetes en el código de tu función, incluye las siguientes versiones en tu archivo requirements.txt:

Para evitar problemas con las actualizaciones de versiones de dependencias, fija el paquete a una versión específica.

anyio==4.5.2
blinker==1.8.2
click==8.1.8
cloudevents==1.11.0
deprecation==2.1.0
exceptiongroup==1.3.0
Flask==3.0.3
functions-framework==3.9.1
gunicorn==23.0.0
h11==0.16.0
idna==3.10
importlib_metadata==8.5.0
itsdangerous==2.2.0
Jinja2==3.1.6
MarkupSafe==2.1.5
packaging==25.0
sniffio==1.3.1
# Install starlette 0.44.0 for Python 3.8
starlette==0.44.0; python_version == '3.8'
# Install starlette 0.49.1 for Python versions greater than 3.8
starlette==0.49.1; python_version > '3.8'
typing_extensions==4.13.2
uvicorn==0.33.0
uvicorn-worker==0.2.0
watchdog==4.0.2
Werkzeug==3.0.6
zipp==3.20.2

El paquete de compilación de Python instala los siguientes paquetes fijados en una versión específica:

pip (versión más reciente)
setuptools (versión más reciente)
wheel (determinado por los requisitos del producto)

El entorno de ejecución de Python también incluye una serie de paquetes de sistema en el entorno de ejecución.

Especifica dependencias en Python Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.