Esta página se ha traducido con Cloud Translation API.

Especificar dependencias en Python

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

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 el código fuente. El archivo requirements.txt contiene una línea por paquete. Cada línea contiene el nombre del paquete y, opcionalmente, la versión solicitada. Para evitar que la compilación se vea afectada por los cambios en la versión de las dependencias, te recomendamos que fijes los paquetes de dependencias a una versión específica.

A continuación, se muestra un ejemplo de archivo requirements.txt:
```
functions-framework
requests==2.20.0
numpy
```
Usa un archivo pyproject.toml para especificar las dependencias. Si gestionas las dependencias de tu aplicación en un archivo pyproject.toml en lugar de en el archivo requirements.txt, el paquete de compilación de Python determinará el gestor de paquetes en función de la configuración que especifiques en el archivo pyproject.toml. Para obtener más información, consulta el artículo Desplegar aplicaciones Python con un archivo pyproject.toml.

Si tu aplicación usa tanto el archivo pyproject.toml como el archivo requirements.txt, este último tiene prioridad.requirements.txt
- A continuación, se muestra un ejemplo de archivo pyproject.toml:
```
[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 mediante el estándar Pipfile/Pipfile.lock. Tu proyecto no debe incluir estos archivos.

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

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

Gestor de paquetes

Si gestionas tus dependencias con un requirements.txt file, el gestor de paquetes predeterminado varía en función de la versión de Python que configures.

Si usas un archivo pyproject.toml para gestionar las dependencias en lugar de un archivo requirements.txt, el paquete de compilación de Python determinará el gestor de paquetes en función de los ajustes de configuración del archivo pyproject.toml. El buildpack es compatible con los gestores de paquetes pip, uv y Poetry. Para obtener más información, consulta Implementar aplicaciones de Python con un archivo pyproject.toml.

Python 3.14 y versiones posteriores

A partir de la versión 3.14 (vista previa) de Python, el paquete de compilación de Python usa el gestor de paquetes uv como instalador predeterminado de las dependencias que especifiques en el archivo requirements.txt.

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

Ejecuta el comando gcloud run deploy para asignar el valor pip a la variable de entorno del gestor de paquetes:

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

Sustituye SERVICE por el nombre de tu servicio de Cloud Run.

Python 3.13 y versiones anteriores

En las versiones de Python 3.13 y anteriores, 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 (vista previa) como gestor de paquetes, configura la variable de entorno GOOGLE_PYTHON_PACKAGE_MANAGER="uv".

Ejecuta el comando gcloud beta run deploy para asignar el valor uv a la variable de entorno del gestor de paquetes:

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

Sustituye SERVICE por el nombre de tu servicio de Cloud Run.

Empaquetar dependencias locales

Empaqueta y despliega las dependencias junto con tu función. Este enfoque es útil si tu dependencia no está disponible cuando usas un gestor 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 hayas empaquetado junto con tu función. Por ejemplo, puede usar la siguiente estructura de directorios:

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

Importa el código de localpackage con la siguiente instrucción import:

# code in main.py
from localpackage import script

Con este método no se ejecutará ningún archivo setup.py. Puedes agrupar los paquetes con esos archivos, pero es posible que el paquete no se ejecute correctamente en las funciones de Cloud Run.

Dependencias copiadas

Las dependencias copiadas son aquellas cuyo origen se incluye directamente en tu paquete de código fuente y se vuelven a compilar junto con tu 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.

Crear dependencias copiadas

Asegúrate de que python3 esté instalado en tu sistema de desarrollo.
Declara las dependencias de tu aplicación en un archivo requirements.txt del directorio raíz de tu árbol de desarrollo.
Declara Functions Framework como requisito incluyendo functions-framework en una línea independiente de tu archivo requirements.txt.
Descarga las dependencias de tu función en tu directorio local. Los pasos para hacerlo dependen de si la dependencia es un archivo de rueda de Python (*.whl) o un archivo tar (*.tar.gz).
1. Si la dependencia es un wheel de Python (*.whl), descárgala en el directorio raíz de tu á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
```
  Haz los cambios siguientes:
  - DIRECTORY: nombre del directorio local en el que se descargará.
  - PYTHON_RUNTIME_VERSION: la versión de Python que se va a usar para las comprobaciones de compatibilidad. Por ejemplo, 314 para Python 3.14.
    Esta versión debe coincidir con uno de los runtimes de Python compatibles.
  La estructura de directorios resultante debería ser similar a esta:
```
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 consta de código escrito en C o C++, descarga y compila el código por separado.
Despliega 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
```
Haz los cambios siguientes:
- FUNCTION_NAME: el nombre de la función que vas a implementar.
- PYTHON_RUNTIME_NAME: el nombre de uno de los runtimes de Python admitidos para ejecutar la función implementada (por ejemplo, python311). Debe ser la misma versión del tiempo de ejecución de Python que hayas usado en tu entorno de desarrollo local.
- DIRECTORY: el nombre del directorio que contiene las dependencias copiadas.

Para obtener más información sobre cómo usar paquetes de compilación, consulta Compilar una función con paquetes de compilación.

Usar dependencias privadas

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

Dependencias privadas de Artifact Registry

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

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

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

Dependencias privadas de otros repositorios

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

Usa el comando pip install con la marca -t DIRECTORY para copiar las dependencias privadas en un directorio local antes de implementar tu aplicación, como se indica a continuación:

Copia la dependencia en un directorio local:
```
pip install -t DIRECTORY DEPENDENCY
```
Añade 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 despliegas tu función. Si usas alguno de estos paquetes en el código de tu función, incluye las siguientes versiones en el 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 a una versión específica:

pip (última versión)
setuptools (última versión)
wheel (determinado por los requisitos del producto)

El tiempo de ejecución de Python también incluye varios paquetes del sistema en el entorno de ejecución.

Especificar dependencias en Python Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.