Questa pagina è stata tradotta dall'API Cloud Translation.

Specifica delle dipendenze

Le app che vengono eseguite nel runtime standard Go 1.12 o versioni successive possono utilizzare qualsiasi pacchetto compatibile con linux/amd64.

App Engine richiede che tutte le istruzioni di importazione nel codice Go specifichino percorsi assoluti. Ad esempio, utilizza:

import "github.com/example/mypackage"

Utilizzare i moduli Go

Ti consigliamo di utilizzare i moduli Go per gestire le dipendenze nella tua app Go. Puoi continuare a utilizzare la modalità GOPATH precedente se non è ancora il momento di eseguire la migrazione ai moduli Go.

A partire dalla versione 1.22 e successive di Go:

Non puoi utilizzare go get all'esterno di un modulo nella modalità GOPATH precedente (GO111MODULE=off). Per ulteriori informazioni, consulta Strumenti.
Go consiglia di utilizzare un file go.mod per gestire le dipendenze. Per installare le dipendenze durante il deployment, includi un file go.mod nella stessa cartella del file app.yaml. Per ulteriori informazioni sulle versioni di Go e sulla gestione delle dipendenze per le directory dei fornitori, consulta GOPATH e Moduli.

Quando esegui il deployment dell'app, App Engine utilizza il comando go build per compilarla e corrisponde al comportamento di Go stesso. Per assicurarti che la tua app utilizzi la modalità module-aware, svolgi i seguenti passaggi nell'ambiente di sviluppo:

Crea il file go.mod del modulo nella stessa directory del file app.yaml. App Engine cerca la directory corrente e le directory principali successive finché non trova un file go.mod.

Se App Engine non trova un file go.mod, segue la modalità GOPATH.
Se imposti la variabile di ambiente GO111MODULE, assicurati che il valore della variabile attivi la modalità module-aware. Quando esegui il deployment dell'app, App Engine controlla se GO111MODULE è presente nel tuo ambiente e ne associa il comportamento a quello di Go. App Engine applica l'impostazione della variabile GO111MODULE solo se hai incluso un file go.mod per la tua app.
Per Go 1.12, non cercare la directory dell'app nella cartella $GOPATH/src. Se la tua app Go 1.12 si trova in qualsiasi posizione della struttura ad albero della directory $GOPATH/src, App Engine segue la modalità GOPATH anche se hai definito un file go.mod per la tua app.

Per Go 1.13 e versioni successive, App Engine utilizza per impostazione predefinita la modalità module-aware, a meno che GO111MODULE non sostituisca il valore predefinito o non esista un file go.mod nella directory dell'app.

Dipendenze dal fornitore

Il vendoring copia i pacchetti utilizzati dall'app nella directory dell'applicazione anziché scaricare i moduli dalle relative origini durante il processo di compilazione. Go fornisce il comando go build per caricare i pacchetti di cui ha bisogno la tua app in una directory denominata vendor nella directory principale dell'app.

In Go 1.14 e versioni successive, se la directory principale dell'app contiene una directory denominata vendor, il comando go build e la procedura di deployment di App Engine utilizzano i pacchetti nella directory del fornitore anziché scaricare i moduli.

In Go 1.13 e versioni precedenti, il vendoring è disponibile solo se configuri il tuo ambiente in modo da utilizzare la modalità GOPATH.

Utilizzare dipendenze private

App Engine non può scaricare le dipendenze private durante il processo di compilazione, quindi devi includerle nel codice dell'applicazione al momento del deployment.

Utilizza l'istruzione replace nel file go.mod per dichiarare le dipendenze private. Nell'esempio seguente si presuppone che l'app si trovi nella directory /myapp/:

Passa alla directory dell'app:
```
cd /myapp
```
Crea una directory contenente le dipendenze private:
```
mkdir private
```
Assicurati che la dipendenza privata sia nella directory private. Un approccio è creare un link simbolico:
```
mkdir private/private.example.com
ln -s /path/to/private.example.com/foo private/private.example.com/foo
```

Aggiorna il file go.mod in modo da utilizzare la direttiva replace per utilizzare la directory private per la dipendenza:

go mod edit -replace=private.example.com/foo=./private/private.example.com/foo

Il file go.mod dovrebbe avere il seguente aspetto:

File `go.mod` finale

module private.example.com/myapp

require private.example.com/foo v1.2.3

replace private.example.com/foo => ./private/private.example.com/foo

File `go.mod` originale

module private.example.com/myapp

require private.example.com/foo v1.2.3

Non modificare il modo in cui importi e utilizzi il pacchetto privato. L'istruzione import dovrebbe avere il seguente aspetto:
```
import "private.example.com/foo"
```
Includi la dipendenza privata nel deployment dell'app:
```
gcloud app deploy
```