Specifica delle dipendenze

Le app eseguite nel runtime standard Go 1.12 e 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 Moduli Go per gestire le dipendenze nella tua app Go. Puoi continuare a utilizzare la modalità GOPATH precedente se non vuoi eseguire la migrazione ai moduli Go.

A partire da Go 1.22 e versioni successive:

Non puoi utilizzare go get al di fuori di un modulo in modalità GOPATH legacy (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 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 creare l'app e corrisponde al comportamento di Go. Per assicurarti che l'app utilizzi la modalità module-aware, procedi nel seguente modo nel tuo ambiente di sviluppo:

Crea il file go.mod del modulo nella stessa directory del file app.yaml. App Engine cerca nella directory attuale e nelle directory padre 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 la presenza di GO111MODULE nell'ambiente e rileva il comportamento 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 individuare la directory dell'app all'interno della cartella $GOPATH/src. Se la tua app Go 1.12 si trova in qualsiasi punto della struttura di 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 la modalità module-aware per impostazione predefinita, a meno che GO111MODULE non sostituisca il valore predefinito o non esista un file go.mod nella directory dell'app.

Dipendenze di fornitore

Vendoring copia i pacchetti che la tua app utilizza nella directory dell'applicazione invece di scaricare i moduli dalle rispettive origini durante il processo di compilazione. Go fornisce il comando go build per fornire i pacchetti necessari alla tua app in una directory denominata vendor nella directory root dell'app.

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

In Go 1.13 e versioni precedenti, l'acquisizione da parte dei clienti è disponibile solo se configuri il tuo ambiente per l'utilizzo della modalità GOPATH.

Utilizza dipendenze private

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

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

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

Aggiorna il file go.mod per utilizzare l'istruzione replace e utilizzare la directory private per la dipendenza:

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

Il tuo file go.mod ora 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 tua dipendenza privata nel deployment eseguendo il deployment dell'app:
```
gcloud app deploy
```