Especificar dependencias

Las apps que se ejecutan en el entorno de ejecución estándar de Go 1.12 y versiones posteriores pueden usar cualquier paquete compatible con linux/amd64.

App Engine requiere todas las declaraciones de importación en tu código de Go para especificar rutas absolutas. Por ejemplo, usa esto:

import "github.com/example/mypackage"

Usa módulos de Go

Te recomendamos usar los módulos de Go para administrar las dependencias en la app de Go. Puedes seguir usando el modo GOPATH anterior si no estás listo para migrar a los módulos de Go.

A partir de la versión 1.22 de Go y posteriores:

No puedes usar go get fuera de un módulo en el modo heredado GOPATH (GO111MODULE=off). Para obtener más información, consulta Herramientas.
Go recomienda que uses un archivo go.mod para administrar dependencias. Para instalar dependencias durante la implementación, incluye un archivo go.mod en la misma carpeta que el archivo app.yaml. Si deseas obtener más información sobre las versiones de Go y la administración de dependencias para directorios de proveedores, consulta GOPATH y módulos.

Cuando implementas la app, App Engine usa el comando go build para compilarla y coincide con el comportamiento de Go. Para asegurarte de que la app use el modo module-aware, haz lo siguiente en el entorno de desarrollo:

Crea el archivo go.mod del módulo en el mismo directorio que el archivo app.yaml. App Engine busca en el directorio actual y en los directorios superiores sucesivos hasta encontrar un archivo go.mod.

Si App Engine no encuentra un archivo go.mod, sigue el modo GOPATH.
Si configuras la variable de entorno GO111MODULE, asegúrate de que el valor de la variable habilite el modo module-aware. Cuando implementas la app, App Engine comprueba que tu entorno tenga GO111MODULE y coincida con el comportamiento de Go. App Engine solo aplica la configuración de la variable GO111MODULE si incluiste un archivo go.mod para tu app.
Para Go 1.12, no ubiques el directorio de tu app dentro de la carpeta $GOPATH/src. Si tu aplicación de Go 1.12 se encuentra en cualquier parte del árbol de directorios $GOPATH/src, App Engine sigue el modo GOPATH, incluso si definiste un archivo go.mod para la aplicación.

Para Go 1.13 y versiones posteriores, App Engine usa el modo module-aware de forma predeterminada, a menos que GO111MODULE anule el valor predeterminado o que un archivo go.mod no exista en el directorio de la aplicación.

Dependecias de vendoring

Mediante el vendoring, se copian los paquetes que usa tu app en el directorio de la aplicación en lugar de descargar módulos de sus fuentes durante el proceso de compilación. Go proporciona el comando go build para hacer el vendoring de los paquetes que necesita tu app en un directorio llamado vendor en el directorio raíz de tu app.

En Go 1.14 y versiones posteriores, si el directorio raíz de tu app contiene un directorio llamado vendor, el comando go build y el proceso de implementación de App Engine usan los paquetes del directorio del proveedor en lugar de descargar módulos.

En Go 1.13 y versiones anteriores, el proveedor solo está disponible si configuras tu entorno para usar el modo GOPATH.

Usa dependencias privadas

App Engine no puede descargar tus dependencias privadas durante el proceso de compilación, por lo que debes incluir las dependencias con tu código de la aplicación en la implementación.

Usa la directiva replace en tu archivo go.mod para declarar dependencias privadas. En el siguiente ejemplo, se supone que la app se encuentra en el directorio /myapp/:

Cambia al directorio de tu app:
```
cd /myapp
```
Crea un directorio que contenga tus dependencias privadas:
```
mkdir private
```
Asegúrate de que la dependencia privada se encuentre en el directorio private. Un enfoque consiste en crear un symlink:
```
mkdir private/private.example.com
ln -s /path/to/private.example.com/foo private/private.example.com/foo
```

Actualiza el archivo go.mod con el objetivo de usar la directiva replace a fin de usar el directorio private para tu dependencia:

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

El archivo go.mod debería verse de la siguiente manera:

Archivo `go.mod` final

module private.example.com/myapp

require private.example.com/foo v1.2.3

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

Archivo `go.mod` original

module private.example.com/myapp

require private.example.com/foo v1.2.3

No modifiques la forma en la que importas y usas tu paquete privado. La declaración import debería verse de la siguiente manera:
```
import "private.example.com/foo"
```
Mediante la implementación de la app, incluye tu dependencia privada:
```
gcloud app deploy
```