Mantieni tutto organizzato con le raccolte
Salva e classifica i contenuti in base alle tue preferenze.
Le app che vengono 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 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 al di fuori 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 nel tuo ambiente è presente GO111MODULE 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 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:
mkdirprivate
Assicurati che la dipendenza privata sia nella directory private. Un
approccio è creare un link simbolico:
[[["Facile da capire","easyToUnderstand","thumb-up"],["Il problema è stato risolto","solvedMyProblem","thumb-up"],["Altra","otherUp","thumb-up"]],[["Difficile da capire","hardToUnderstand","thumb-down"],["Informazioni o codice di esempio errati","incorrectInformationOrSampleCode","thumb-down"],["Mancano le informazioni o gli esempi di cui ho bisogno","missingTheInformationSamplesINeed","thumb-down"],["Problema di traduzione","translationIssue","thumb-down"],["Altra","otherDown","thumb-down"]],["Ultimo aggiornamento 2025-09-04 UTC."],[[["\u003cp\u003eGo apps in App Engine must use absolute paths in import statements, such as \u003ccode\u003eimport "github.com/example/mypackage"\u003c/code\u003e.\u003c/p\u003e\n"],["\u003cp\u003eUsing Go modules is recommended for managing dependencies, and a \u003ccode\u003ego.mod\u003c/code\u003e file should be included in the same folder as \u003ccode\u003eapp.yaml\u003c/code\u003e for dependency installation during deployment.\u003c/p\u003e\n"],["\u003cp\u003eFor Go 1.22 and later, \u003ccode\u003ego get\u003c/code\u003e cannot be used outside of a module in legacy \u003ccode\u003eGOPATH\u003c/code\u003e mode, and the use of a \u003ccode\u003ego.mod\u003c/code\u003e file for dependency management is strongly encouraged.\u003c/p\u003e\n"],["\u003cp\u003eApp Engine's build process uses the \u003ccode\u003ego build\u003c/code\u003e command, matching Go's behavior, and it prioritizes \u003ccode\u003emodule-aware\u003c/code\u003e mode if a \u003ccode\u003ego.mod\u003c/code\u003e file is present, or if using Go 1.13 or later, unless \u003ccode\u003eGO111MODULE\u003c/code\u003e dictates otherwise.\u003c/p\u003e\n"],["\u003cp\u003eVendoring, or copying packages to a \u003ccode\u003evendor\u003c/code\u003e directory in your app, is supported from Go 1.14 and above. And for the use of private dependencies, you should use a \u003ccode\u003ereplace\u003c/code\u003e directive in the \u003ccode\u003ego.mod\u003c/code\u003e file, and then place those dependencies within the \u003ccode\u003eprivate\u003c/code\u003e directory of the app.\u003c/p\u003e\n"]]],[],null,["# Specify dependencies\n\nApps that run in the Go 1.12+ standard runtime can use any\nlinux/amd64-compatible package.\n\nApp Engine requires all import statements in your Go code to\nspecify absolute paths. For example, use: \n\n import \"github.com/example/mypackage\"\n\nUse Go modules\n--------------\n\nWe recommend that you use [Go modules](https://blog.golang.org/using-go-modules)\nto manage dependencies in your Go app. You can continue to use the older `GOPATH` mode\nif you aren't ready to [migrate\nto Go modules](https://blog.golang.org/migrating-to-go-modules).\n\nStarting in Go **version 1.22 and later**:\n\n- You can't use `go get` outside of a module in the legacy `GOPATH` mode\n (`GO111MODULE`=`off`). For more information, see [Tools](https://tip.golang.org/doc/go1.22#:%7E:text=enables%20this%20feature.-,Tools,-Go%20command).\n\n- Go recommends that you use a `go.mod` file for managing dependencies. To install\n dependencies during deployment, include a `go.mod` file in the same folder as\n the `app.yaml` file. For more information about Go versions, and managing\n dependencies for vendor directories, see [`GOPATH` and Modules](https://pkg.go.dev/cmd/go#hdr-GOPATH_and_Modules).\n\nWhen you deploy your app, App Engine uses the `go build` command to\nbuild your app and matches the behavior of Go itself. To ensure that\nyour app uses `module-aware` mode, do the following in your development\nenvironment:\n\n- Create your module's `go.mod` file in the same directory as your `app.yaml`\n file. App Engine searches the current directory and the successive\n parent directories until it finds a [`go.mod` file](https://golang.org/cmd/go/#hdr-Defining_a_module).\n\n If App Engine doesn't find a `go.mod` file, it follows\n `GOPATH` mode.\n- If you set the [`GO111MODULE` environment variable](https://golang.org/ref/mod#mod-commands),\n make sure that the variable's value enables\n `module-aware` mode. When you deploy your app, App Engine checks your\n environment for `GO111MODULE` and matches the behavior of Go itself.\n App Engine only applies the `GO111MODULE` variable setting if you have\n included a `go.mod` file for your app.\n\n- For Go 1.12, don't locate your app directory within the `$GOPATH/src` folder. If\n your Go 1.12 app is anywhere in the `$GOPATH/src` directory tree,\n App Engine follows `GOPATH` mode even if you've defined a `go.mod` file\n for your app.\n\n For Go 1.13 and later, App Engine uses\n [`module-aware` mode](https://golang.org/cmd/go/#hdr-Module_support)\n by default, unless `GO111MODULE` overrides the default or a `go.mod` file\n doesn't exist in the app's directory.\n\n### Vendoring dependencies\n\n**Vendoring** copies the packages your app uses into the application directory\ninstead of downloading modules from their sources during the build process. Go\nprovides the `go build` command to\n[vendor the packages your app needs](https://golang.org/cmd/go/#hdr-Modules_and_vendoring)\ninto a directory named `vendor` in your app's root directory.\n\nIn Go 1.14 and later, if your app's root directory contains a directory named\n`vendor`, the `go build` command and the App Engine\ndeployment process use the packages in the vendor directory instead of\ndownloading modules.\n\nIn Go 1.13 and earlier, vendoring is only available if you set up your\nenvironment to use [`GOPATH` mode](https://golang.org/cmd/go/#hdr-GOPATH_and_Modules).\n\n### Use private dependencies\n\nApp Engine can't download your private dependencies during the build\nprocess, so you must include the dependencies with your application code upon\ndeployment.\n\nUse the `replace` directive in your `go.mod` file to declare\nprivate dependencies. The following example assumes your app is in the `/myapp/`\ndirectory:\n\n1. Change to your app directory:\n\n cd /myapp\n\n2. Create a directory containing your private dependencies:\n\n mkdir private\n\n Make sure your private dependency is in the `private` directory. One\n approach is by creating a symlink: \n\n mkdir private/private.example.com\n ln -s /path/to/private.example.com/foo private/private.example.com/foo\n\n3. Update your `go.mod` file to use the `replace` directive to use the `private`\n directory for your dependency:\n\n go mod edit -replace=private.example.com/foo=./private/private.example.com/foo\n\n Your `go.mod` file should now look like: \n\n ### Final `go.mod` file\n\n module private.example.com/myapp\n\n require private.example.com/foo v1.2.3\n\n replace private.example.com/foo =\u003e ./private/private.example.com/foo\n\n ### Original `go.mod` file\n\n module private.example.com/myapp\n\n require private.example.com/foo v1.2.3\n\n4. Don't modify how you import and use your private package. Your `import`\n statement should look like this:\n\n import \"private.example.com/foo\"\n\n5. Include your private dependency in your deployment by deploying your app:\n\n gcloud app deploy"]]
