Cette page a été traduite par l'API Cloud Translation.

Spécifier les dépendances en Python

Spécifiez les dépendances de votre application pour les versions Python compatibles en utilisant l'une des approches suivantes :

Utilisez un fichier requirements.txt dans le répertoire racine. Ce fichier doit se trouver dans le même répertoire que le fichier main.py qui contient votre code source. Le fichier requirements.txt contient une ligne par package. Chaque ligne contient le nom du package et, éventuellement, la version demandée. Pour éviter que votre compilation ne soit affectée par les modifications de version de dépendance, envisagez d'épingler vos packages de dépendances sur une version spécifique.

Voici un exemple de fichier requirements.txt :
```
functions-framework
requests==2.20.0
numpy
```
Utilisez un fichier pyproject.toml pour spécifier les dépendances. Si vous gérez les dépendances de votre application dans un fichier pyproject.toml au lieu du fichier requirements.txt, le buildpack Python détermine le gestionnaire de packages en fonction de la configuration que vous spécifiez dans le fichier pyproject.toml. Pour en savoir plus, consultez Déployer des applications Python avec un fichier pyproject.toml.

Si votre application utilise à la fois le fichier pyproject.toml et le fichier requirements.txt, le fichier requirements.txt est prioritaire.
- Voici un exemple de fichier 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"
```

Empaquetez les dépendances locales avec votre fonction.

La spécification des dépendances avec le fichier standard Pipfile/Pipfile.lock n'est actuellement pas possible. Votre projet ne doit pas contenir ce fichier.

Si vous utilisez un fichier requirements.txt pour gérer les dépendances, Cloud Run installe le Functions Framework pour vous lorsque vous créez une fonction. Toutefois, nous vous recommandons d'inclure le framework des fonctions en tant que dépendance explicite pour éviter les écarts.

Lorsque vous utilisez un fichier pyproject.toml, vous devez inclure le framework des fonctions en tant que dépendance, car Cloud Run ne l'installe pas pour vous.

Gestionnaire de packages

Si vous gérez vos dépendances à l'aide d'un fichier requirements.txt file, le gestionnaire de packages par défaut varie en fonction de la version de Python que vous configurez.

Si vous utilisez un fichier pyproject.toml pour gérer les dépendances au lieu d'un fichier requirements.txt, le buildpack Python détermine le gestionnaire de packages en fonction de vos paramètres de configuration dans le fichier pyproject.toml. Le pack de création est compatible avec les gestionnaires de packages pip, uv et Poetry. Pour en savoir plus, consultez Déployer des applications Python avec un fichier pyproject.toml.

Python 3.14 et versions ultérieures

À partir de la version 3.14 de Python (bêta), le buildpack Python utilise le gestionnaire de packages uv comme programme d'installation par défaut pour les dépendances que vous spécifiez dans votre fichier requirements.txt.

Pour utiliser pip comme gestionnaire de packages, configurez la variable d'environnement GOOGLE_PYTHON_PACKAGE_MANAGER="pip".

Exécutez la commande gcloud run deploy pour définir la variable d'environnement du gestionnaire de packages sur pip :

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

Remplacez SERVICE par le nom de votre service Cloud Run.

Python 3.13 et versions antérieures

Pour Python 3.13 et les versions antérieures, le buildpack Python utilise le gestionnaire de packages pip pour installer les dépendances que vous définissez dans le fichier requirements.txt.

Pour utiliser uv (aperçu) comme gestionnaire de packages, configurez la variable d'environnement GOOGLE_PYTHON_PACKAGE_MANAGER="uv".

Exécutez la commande gcloud beta run deploy pour définir la variable d'environnement du gestionnaire de packages sur uv :

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

Remplacez SERVICE par le nom de votre service Cloud Run.

Empaqueter les dépendances locales

Empaquetez et déployez les dépendances avec votre fonction. Cette approche est utile si votre dépendance n'est pas disponible lorsque vous utilisez un gestionnaire de packages compatible ou si l'accès Internet de votre environnement Cloud Run est limité.

Vous pouvez également utiliser un fichier requirements.txt pour spécifier des dépendances supplémentaires si vous ne les avez pas empaquetées avec votre fonction. Par exemple, vous pouvez utiliser la structure de répertoires suivante :

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

Importez le code à partir de localpackage à l'aide de l'instruction import suivante :

# code in main.py
from localpackage import script

Cette approche n'exécute aucun fichier setup.py. Vous pouvez regrouper les packages avec ces fichiers, mais il se peut que le package ne s'exécute pas correctement sur Cloud Run Functions.

Dépendances copiées

Les dépendances copiées sont des dépendances dont la source est incluse directement dans votre package de code source et reconstruite avec votre propre code. Utilisez la variable d'environnement de compilation GOOGLE_VENDOR_PIP_DEPENDENCIES pour créer des dépendances PIP copiées et éviter de les installer lors du déploiement.

Créer des dépendances copiées

Assurez-vous que python3 est installé sur votre système de développement.
Déclarez les dépendances de votre application dans un fichier requirements.txt situé dans le répertoire racine de l'arborescence de développement.
Déclarez le framework Functions comme exigence en incluant functions-framework sur une ligne distincte de votre fichier requirements.txt.
Téléchargez les dépendances de votre fonction dans votre répertoire local. La procédure à suivre varie selon que la dépendance est un fichier wheel Python (*.whl) ou un fichier tar (*.tar.gz).
1. Si la dépendance est de type wheel Python (*.whl), téléchargez-la dans le répertoire racine de l'arborescence de développement à l'aide de la commande pip suivante :
```
python3 -m pip download -r requirements.txt --only-binary=:all: \
   -d DIRECTORY \
   --python-version PYTHON_RUNTIME_VERSION \
   --platform manylinux2014_x86_64 \
   --implementation cp
```
  Remplacez les éléments suivants :
  - DIRECTORY : nom du répertoire local dans lequel effectuer le téléchargement.
  - PYTHON_RUNTIME_VERSION : version de Python à utiliser pour les vérifications de compatibilité (par exemple, 314 pour Python 3.14).
    Cette version doit correspondre à l'un des environnements d'exécution Python pris en charge.
  La structure de répertoires obtenue doit se présenter comme suit :
```
myfunction/
├── main.py
└── requirements.txt
└── DIRECTORY
   ├── dependency1.whl
   └── dependency2.whl
```
2. Si la dépendance est un fichier tar (*.tar.gz) :
  1. Si la dépendance est écrite en Python, utilisez pip pour la télécharger :
```
python3 -m pip download -r requirements.txt \
   -d DIRECTORY
```
  2. Si une dépendance comprend du code écrit en C ou C++, téléchargez et compilez le code séparément.
Déployez votre fonction et ses dépendances copiées :
```
gcloud functions deploy FUNCTION_NAME \
  --runtime PYTHON_RUNTIME_NAME \
  --set-build-env-vars GOOGLE_VENDOR_PIP_DEPENDENCIES=DIRECTORY
```
Remplacez les éléments suivants :
- FUNCTION_NAME : nom de la fonction que vous déployez.
- PYTHON_RUNTIME_NAME : nom de l'un des environnements d'exécution Python pris en charge dans lequel exécuter la fonction déployée (par exemple, python311). Il doit s'agir de la même version d'exécution Python que celle utilisée dans votre environnement de développement local.
- DIRECTORY : nom du répertoire contenant vos dépendances copiées.

Pour en savoir plus sur l'utilisation des buildpacks, consultez Créer une fonction à l'aide de buildpacks.

Utiliser des dépendances privées

Vous pouvez utiliser des dépendances privées provenant d'Artifact Registry ou d'autres dépôts.

Dépendances privées d'Artifact Registry

Un dépôt Python Artifact Registry héberge des dépendances privées pour votre fonction Python. Lors du déploiement sur Cloud Run, le processus de compilation génère automatiquement des identifiants Artifact Registry pour le compte de service Cloud Build. Incluez l'URL Artifact Registry dans votre fichier requirements.txt sans générer d'identifiants supplémentaires. Exemple :

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

Si votre build nécessite plusieurs dépôts, utilisez un dépôt virtuel Artifact Registry pour contrôler de manière sécurisée l'ordre dans lequel pip recherche vos dépôts.

Dépendances privées d'autres dépôts

Les buildpacks installent les dépendances dans un environnement Cloud Build qui ne fournit pas d'accès aux clés SSH. Copiez les packages que vous hébergez dans des dépôts nécessitant une authentification SSH, puis importez-les avec le code de votre projet.

Pour copier des dépendances privées dans un répertoire local avant de déployer votre application, vous pouvez utiliser la commande pip install avec l'indicateur -t DIRECTORY. Pour ce faire, procédez comme suit :

Copiez votre dépendance dans un répertoire local :
```
pip install -t DIRECTORY DEPENDENCY
```
Ajoutez un fichier __init__.py vide au répertoire DIRECTORY pour le transformer en module.
Importez depuis ce module pour utiliser votre dépendance :
```
import DIRECTORY.DEPENDENCY
```

Packages pré-installés

Le buildpack Python installe les packages Python suivants lorsque vous déployez votre fonction. Si vous utilisez l'un de ces packages dans le code de votre fonction, incluez les versions suivantes dans votre fichier requirements.txt :

Pour éviter les problèmes liés aux mises à jour des versions de dépendances, épinglez le package sur une version spécifique.

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

Le buildpack Python installe les packages suivants épinglés à une version spécifique :

pip (dernière version)
setuptools (dernière version)
wheel (déterminé par les exigences liées aux produits)

L'environnement d'exécution Python inclut également un certain nombre de packages système.

Spécifier les dépendances en Python Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.