Si vous créez une fonction, consultez le guide de démarrage rapide de la console sur Cloud Run. Le contenu de cette page ne s'applique qu'aux anciennes fonctions existantes créées avec l'API Cloud Functions v1.

Spécifier des dépendances en Python (1re génération)

Il existe deux manières de spécifier des dépendances Cloud Run Functions rédigées en Python : en utilisant le fichier requirements.txt du gestionnaire de paquets pip ou en empaquetant les dépendances locales avec votre fonction.

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

Spécifier des dépendances avec pip

Les dépendances en Python sont gérées avec pip et exprimées dans un fichier de métadonnées appelé requirements.txt. Ce fichier doit se trouver dans le même répertoire que le fichier main.py qui contient le code de votre fonction.

Lorsque vous déployez ou redéployez votre fonction, Cloud Run Functions utilise pip pour télécharger et installer la dernière version de vos dépendances, comme déclaré dans le fichier requirements.txt. Le fichier requirements.txt contient une ligne par package. Chaque ligne contient le nom du package et, éventuellement, la version demandée. Pour en savoir plus, consultez la documentation de référence sur requirements.txt.

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

Le framework Functions est une dépendance requise pour toutes les fonctions. Bien que Cloud Run Functions l'installe en votre nom lors de la création de la fonction, nous vous recommandons de l'inclure en tant que dépendance explicite pour plus de clarté.

Si votre fonction repose sur des dépendances privées, nous vous recommandons de mettre en miroir functions-framework dans votre registre privé. Incluez la valeur functions-framework mise en miroir en tant que dépendance à votre fonction pour éviter d'installer le package depuis l'Internet public.

Empaqueter les dépendances locales

Vous pouvez également empaqueter et déployer les dépendances avec votre fonction. Cette approche est utile si votre dépendance n'est pas disponible avec le gestionnaire de paquets pip ou si l'accès Internet de votre environnement Cloud Run Functions est limité.

Par exemple, vous pouvez utiliser une structure de répertoires comme suit :

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

Vous pouvez ensuite importer le code comme d'habitude à partir de localpackage en utilisant l'instruction import suivante.

# Code in main.py
from localpackage import script

Notez qu'avec cette approche, les fichiers setup.py ne sont pas exécutés. Les packages comprenant ces fichiers peuvent toujours être regroupés, mais il se peut qu'ils ne s'exécutent pas correctement sur Cloud Run Functions.

Dépendances intégrées par vendoring

Les dépendances intégrées par vendoring sont des dépendances dont la source est incluse directement dans votre package de code source et qui sont recréées avec votre propre code. Utilisez la variable d'environnement de compilation GOOGLE_VENDOR_PIP_DEPENDENCIES pour créer des dépendances pip intégrées par vendoring et éviter de les installer lors du déploiement.

Créer des dépendances intégrées par vendoring

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 :
  - 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, 311 pour Python 3.11).
    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++, vous devez la télécharger et la compiler séparément.
Déployez votre fonction et ses dépendances intégrées par vendoring :
```
gcloud functions deploy FUNCTION_NAME \
  --runtime PYTHON_RUNTIME_NAME \
  --set-build-env-vars GOOGLE_VENDOR_PIP_DEPENDENCIES=DIRECTORY
```
Remplacez :
- FUNCTION_NAME : nom de la fonction Cloud Run 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 de l'environnement d'exécution Python que celle utilisée dans votre environnement de développement local.
- DIRECTORY : nom du répertoire contenant vos dépendances intégrées par vendoring

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

Utiliser des dépendances privées

Dépendances privées d'Artifact Registry

Un dépôt Python Artifact Registry peut héberger des dépendances privées pour votre fonction Python. Lors du déploiement sur Cloud Run Functions, le processus de compilation génère automatiquement des identifiants Artifact Registry pour le compte de service Cloud Build. Il vous suffit d'inclure 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 dépendances sont installées dans un environnement Cloud Build qui ne fournit pas d'accès aux clés SSH. Les packages hébergés dans des dépôts nécessitant une authentification SSH doivent être fournis et importés avec le code de votre projet, comme décrit dans la section précédente.

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

Les packages Python suivants sont automatiquement installés avec votre fonction lors du déploiement. Si vous utilisez l'un de ces packages dans le code de votre fonction, nous vous recommandons d'inclure les versions suivantes dans votre fichier requirements.txt :

Python 3.7

aiohttp==3.8.1
aiosignal==1.2.0
async-timeout==4.0.2
attrs==21.4.0
cachetools==4.2.4
certifi==2021.10.8
chardet==4.0.0
charset-normalizer==2.0.10
click==8.0.3
Flask==2.0.2
frozenlist==1.2.0
google-api-core==2.3.2
google-api-python-client==2.34.0
google-auth==2.3.3
google-auth-httplib2==0.1.0
google-cloud-core==2.2.1
google-cloud-trace==1.5.1
googleapis-common-protos==1.54.0
grpcio==1.43.0
grpcio-status==1.43.0
httplib2==0.20.2
idna==3.3
itsdangerous==2.0.1
Jinja2==3.1.6
MarkupSafe==2.0.1
multidict==5.2.0
opencensus==0.8.0
opencensus-context==0.1.2
packaging==21.3
proto-plus==1.19.8
protobuf==3.19.1
pyasn1==0.4.8
pyasn1-modules==0.2.8
pyparsing==3.0.6
pytz==2021.3
PyYAML==6.0
requests==2.27.1
rsa==4.8
setuptools==60.3.1
six==1.16.0
uritemplate==4.1.1
urllib3==1.26.7
Werkzeug==2.0.2
wrapt==1.13.3
yarl==1.7.2

Python 3.8 et versions ultérieures

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
starlette==0.44.0
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

* `pip` (latest version)
* `setuptools` (latest version)
* `wheel` (determined by product requirements)

L'environnement d'exécution Python inclut également un certain nombre de packages système. Si votre fonction utilise une dépendance nécessitant un package système non répertorié, vous pouvez le demander.