Questa pagina è stata tradotta dall'API Cloud Translation.

Specifica delle dipendenze

Le app eseguite nel runtime standard Go 1.12+ possono usare qualsiasi compatibile con linux/amd64.

App Engine richiede che tutte le istruzioni di importazione nel codice Go e specificare 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 nell'app Go. Puoi continuare a usare la modalità GOPATH precedente se non è tutto pronto per eseguire la migrazione ai moduli Go.

A partire dalla versione 1.22 e successive di Go:

Non puoi utilizzare go get al di fuori di un modulo nella modalità GOPATH precedente (GO111MODULE=off). Per ulteriori informazioni, consulta la sezione Strumenti.
Go consiglia di utilizzare un file go.mod per gestire le dipendenze. Per installare delle dipendenze durante il deployment, includi un file go.mod nella stessa cartella del il 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 usa il comando go build per creare la tua app e si adatti al comportamento di Go stesso. Per garantire che la tua app utilizza la modalità module-aware, svolgi i seguenti passaggi nella fase di sviluppo questo ambiente:

Crea il file go.mod del modulo nella stessa directory in cui si trova 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 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 del fornitore

Il fornitore copia i pacchetti utilizzati dalla tua app nella directory dell'applicazione. anziché scaricare i moduli dalle origini durante il processo di compilazione. Vai fornisce il comando go build fornitore i pacchetti necessari alla tua app in una directory denominata vendor nella directory principale dell'app.

In Go 1.14 e versioni successive, se la directory radice dell'app contiene una directory denominata vendor, il comando go build e App Engine di deployment usano i pacchetti nella directory del fornitore 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.

Usa 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. Uno. è la creazione di 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 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 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. Il tuo 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
```