Specifica le dipendenze in Python (1ª generazione.)

Ci sono due modi per specificare le dipendenze per Cloud Functions scritte in Python: utilizzo del gestore di pacchetti pip requirements.txt file o pacchetti di dipendenze locali insieme alla funzione.

La specifica delle dipendenze mediante lo standard Pipfile/Pipfile.lock è non supportati. Il progetto non deve includere questi file.

Specifica le dipendenze con pip

Le dipendenze in Python sono gestite con pip ed espresse in un file di metadati chiamata requirements.txt. Questo file deve trovarsi nella stessa directory del file main.py che contiene le tue della funzione.

Quando esegui il deployment o riesegui il deployment della funzione, Cloud Functions usa pip per scaricare e installare l'ultima versione del tuo come dichiarato nel file requirements.txt. Il file requirements.txt contiene una riga per pacchetto. Ogni riga contiene il nome del pacchetto e, facoltativamente, la versione richiesta. Per ulteriori dettagli, vedi il requirements.txt riferimento.

Per evitare che la build venga influenzata da modifiche alla versione delle dipendenze, valuta la possibilità di bloccare i pacchetti di dipendenze su una versione specifica.

Di seguito è riportato un file requirements.txt di esempio:

functions-framework
requests==2.20.0
numpy

Il framework delle funzioni è un la dipendenza richiesta per tutte le funzioni. Sebbene Cloud Functions lo installi per tuo conto quando viene creata la funzione, ti consigliamo includerla come dipendenza esplicita per maggiore chiarezza.

Se la funzione si basa su dipendenze private, ti consigliamo di esegui il mirroring di functions-framework nel tuo registro privato. Includi lo stato functions-framework come dipendenza dalla tua funzione per evitare di installare il componente dalla rete internet pubblica.

Pacchettizzazione delle dipendenze locali

Puoi anche pacchettizzare ed eseguire il deployment delle dipendenze insieme alla funzione. Questo è utile se la dipendenza non è disponibile tramite il pip gestore di pacchetti o se la configurazione l'accesso è limitato.

Ad esempio, potresti utilizzare una struttura di directory ad esempio:

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

Puoi quindi importare il codice come di consueto da localpackage utilizzando quanto segue Informativa import.

# Code in main.py
from localpackage import script

Tieni presente che questo approccio non esegue alcun file setup.py. Pacchetti con questi i file possono comunque essere raggruppati, ma potrebbero non essere eseguiti correttamente su Cloud Functions.

Dipendenze del fornitore

Le dipendenze del fornitore sono dipendenze la cui origine è inclusa direttamente nel tuo pacchetto di codice sorgente, e ricreati insieme al tuo codice. Utilizza la variabile di ambiente di build GOOGLE_VENDOR_PIP_DEPENDENCIES per creare dipendenze pip fornite dal fornitore ed evitare di installarle durante il deployment.

Creare dipendenze del fornitore

Assicurati che python3 sia installato il tuo sistema di sviluppo.
Dichiarare le dipendenze dell'applicazione in un file requirements.txt nella directory radice dell'albero di sviluppo.
Dichiara il framework di Functions come requisito includendo functions-framework su una riga separata nel file requirements.txt.
Scarica le dipendenze della funzione nella directory locale. I passaggi per Questo dipende dal fatto che la dipendenza sia un file della ruota Python (*.whl) o un file tar (*.tar.gz).
1. Se la dipendenza è una ruota Python (*.whl), scaricala del tuo albero di sviluppo con questo comando pip:
```
python3 -m pip download -r requirements.txt --only-binary=:all: \
   -d DIRECTORY \
   --python-version PYTHON_RUNTIME_NAME \
   --platform manylinux2014_x86_64 \
   --implementation cp
```
  Sostituisci:
  - DIRECTORY: il nome della directory locale da scarica su
  - PYTHON_RUNTIME_NAME: la versione Python da utilizzare per controlli di compatibilità
  La struttura della directory risultante dovrebbe avere l'aspetto seguente:
```
myfunction/
├── main.py
└── requirements.txt
└── DIRECTORY
   ├── dependency1.whl
   └── dependency2.whl
```
2. Se la dipendenza è un file tar (*.tar.gz):
  1. Se la dipendenza è scritta in Python, utilizza pip per scaricarla:
```
python3 -m pip download -r requirements.txt \
   -d DIRECTORY
```
  2. Se una dipendenza è composta da codice scritto in C o C++, devi scaricare e compilarlo separatamente.
Esegui il deployment della funzione e delle sue dipendenze fornite dal fornitore:
```
gcloud functions deploy FUNCTION_NAME \
  --runtime PYTHON_RUNTIME_NAME \
  --set-build-env-vars GOOGLE_VENDOR_PIP_DEPENDENCIES=DIRECTORY
```
Sostituisci:
- FUNCTION_NAME: il nome delle funzioni Cloud Functions funzione di cui esegui il deployment
- PYTHON_RUNTIME_NAME: il nome del runtime Python da esegui la funzione di cui hai eseguito il deployment, ad esempio python311. Deve essere la stessa versione di runtime Python che hai utilizzato nel tuo processo di sviluppo locale completamente gestito di Google Cloud.
- DIRECTORY:il nome della directory contenente di dipendenze del fornitore

Per maggiori dettagli sull'uso dei buildpack, vedi Crea una funzione con i buildpack.

Usa dipendenze private

Dipendenze private da Artifact Registry

Un Python di Artifact Registry repository privato può ospitare per la funzione Python. Durante il deployment in Cloud Functions, il processo di compilazione genererà automaticamente le credenziali Artifact Registry per Account di servizio Cloud Build. Devi eseguire devi includere l'URL di Artifact Registry in requirements.txt senza generando credenziali aggiuntive. Ad esempio:

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

Se la tua build ha bisogno di più repository, utilizza un'istanza Repository virtuale Artifact Registry per controllare in modo sicuro l'ordine con cui pip cerca nei repository.

Dipendenze private da altri repository

Le dipendenze vengono installate in un ambiente Cloud Build che che forniscono l'accesso alle chiavi SSH. Pacchetti ospitati in repository che richiedono L'autenticazione basata su SSH deve essere fornita da un fornitore e caricata insieme alle come descritto nella sezione precedente.

Puoi utilizzare il comando pip install con il Flag -t DIRECTORY in cui copiare le dipendenze private una directory locale prima di eseguire il deployment dell'app, come segue:

Copia la dipendenza in una directory locale:
```
pip install -t DIRECTORY DEPENDENCY
```
Aggiungi un file __init__.py vuoto a DIRECTORY per convertirlo in un modulo.
Importa da questo modulo per utilizzare la dipendenza:
```
import DIRECTORY.DEPENDENCY
```

Pacchetti preinstallati

I seguenti pacchetti Python vengono installati automaticamente insieme durante il deployment. Se utilizzi uno di questi pacchetti nella tua funzione, ti consigliamo di includere le seguenti versioni nel File 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 e versioni successive

click==8.1.7
cloudevents==1.9.0
deprecation==2.1.0
Flask==2.2.5
functions-framework==3.0.0
gunicorn==20.1.0
importlib-metadata==6.7.0
itsdangerous==2.1.2
Jinja2==3.1.2
MarkupSafe==2.1.3
packaging==23.1
typing_extensions==4.7.1
watchdog==1.0.2
Werkzeug==2.2.3
zipp==3.15.0

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

Inoltre, il runtime Python include una serie di pacchetti nell'esecuzione completamente gestito di Google Cloud. Se la funzione utilizza una dipendenza che richiede un pacchetto di sistema non è presente nell'elenco, puoi richiedere pacchetto.