Pour simplifier les recherches et améliorer votre expérience avec la documentation, nous divisons les documentations consacrées à la 1re génération et à la 2e génération en ensembles distincts.

Spécifier les dépendances en Python

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 actuellement pas prise en charge. Votre projet ne doit pas contenir ces fichiers.

Spécifier des dépendances avec pip

Dans Python, les dépendances sont gérées avec piprequirements.txt et exprimées dans un fichier de métadonnées appelé . 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épendance sur une version spécifique.

Voici un exemple de fichier requirements.txt :

functions-framework
requests==2.20.0
numpy

Le Functions Framework 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.

Emballer 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 via 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, aucun fichier setup.py n'est exécuté. Les packages avec ces fichiers peuvent toujours être regroupés, mais peuvent ne pas s'exécuter correctement sur Cloud Run Functions.

Dépendances fournies par le fournisseur

Les dépendances fournies par le fournisseur 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 fournies par le fournisseur et éviter de les installer lors du déploiement.

Créer des dépendances fournies par le fournisseur

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 des fonctions 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:
```
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 compatibles.
  La structure de répertoire 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 fournies par le fournisseur :
```
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 Functions que vous déployez.
- PYTHON_RUNTIME_NAME : nom de l'un des environnements d'exécution Python compatibles dans lequel exécuter votre 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 fournies par le fournisseur

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 en toute sécurité 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.0.3
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

click==8.1.7
cloudevents==1.11.0
deprecation==2.1.0
Flask==2.2.5
functions-framework==3.8.1
gunicorn==23.0.0
importlib-metadata==6.7.0
itsdangerous==2.1.2
jinja2==3.1.4
MarkupSafe==2.1.5
packaging==24.0
typing_extensions==4.7.1
watchdog==3.0.0
Werkzeug==2.2.3
zipp==3.15.0

* `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 demander un package.