Información sobre GOPATH

Introducción

Este artículo le servirá como guía para comprender GOPATH, su funcionamiento y su configuración. Este paso es crucial para configurar un entorno de desarrollo de Go, así como para comprender cómo se ubican, instalan y construyen archivos de origen en Go. En este artículo, usaremos GOPATH al hacer referencia al concepto de estructura de carpetas que analizaremos. Usaremos $GOPATH para hacer referencia a la variable de entorno que se utiliza en Go para encontrar la estructura de carpetas.

Un espacio de trabajo de Go es la alternativa con la que se administran en Go nuestros archivos de origen, binarios compilados y objetos almacenados en caché que se utilizan para acelerar la compilación posteriormente. Es habitual, y también aconsejable, tener solo un espacio de trabajo de Go, aunque es posible contar con varios. GOPATH funciona como una carpeta root de un espacio de trabajo.

Configurar la variable de entorno $GOPATH

En la variable de entorno $GOPATH se listan las ubicaciones para que en Go se busquen los espacios de trabajo de Go.

Por defecto, en Go se supone que nuestra ubicación de GOPATH se encuentra en $HOME/go, donde $HOME es el directorio root de nuestra cuenta de usuario en nuestra computadora. Podemos cambiarlo configurando la variable de entorno $GOPATH. Para obtener más información, siga este tutorial sobre lectura y configuración de variables de entorno en Linux.

Para obtener más información sobre la configuración de la variable $GOPATH, consulte la documentación de Go.

Además, en esta serie se analizan la instalación de Go y la configuración de un entorno de desarrollo del mismo.

$GOPATH No es $GOROOT

$GOROOT es el punto en el que se encuentran el código, el compilador y las herramientas de Go, no es nuestro código fuente. $GOROOT generalmente es similar a /usr/local/go. Nuestra $GOPATH generalmente es similar a $HOME/go.

Aunque ya no necesitamos configurar la variable $GOROOT específicamente , todavía se hace referencia a esta en documentos anteriores.

Ahora, revisaremos la estructura del espacio de trabajo de Go.

Anatomía del espacio de trabajo de Go

Dentro de un espacio de trabajo de Go, o GOPATH, hay tres directorios: bin, pkg y src. Cada uno de estos directorios tiene un significado especial para las herramientas de Go.

.
├── bin
├── pkg
└── src
  └── github.com/foo/bar
    └── bar.go

Revisemos cada uno de estos directorios.

En el directorio $GOPATH/bin es donde Go dispone los binarios que se compilan en go install. Nuestro sistema operativo utiliza la variable de entorno $PATH para encontrar aplicaciones binarias que pueden ejecutarse sin una ruta completa. Se recomienda añadir este directorio a nuestra variable global $PATH.

Por ejemplo, si no añadimos $GOPATH/bin a $PATH para ejecutar un programa desde este, tendríamos que ejecutar lo siguiente:

$GOPATH/bin/myapp

Cuando $GOPATH/bin se añade a $PATH, podemos realizar la misma invocación como se muestra a continuación:

myapp

En el directorio $GOPATH/pkg se almacenan los archivos de objetos previamente compilados de Go para acelerar la compilación posterior de los programas. Normalmente, la mayoría de los desarrolladores no necesitarán acceder a este directorio. Si experimenta problemas relacionados con la compilación, puede eliminar este directorio sin peligro; Go lo reconstruirá.

El directorio src es el punto en el que todos nuestros archivos .go o de código fuente deben ubicarse. Esto no debe confundirse con el código fuente que se utiliza en la herramienta de Go, el cual se encuentra en el $GOROOT. A medida que escribamos aplicaciones, paquetes y bibliotecas de Go, dispondremos estos archivos en $GOPATH/src/path/to/code.

¿Qué son los paquetes?

El código de Go se organiza en paquetes. Un paquete representa todos los archivos en un solo directorio en el disco. Un directorio solo puede contener ciertos archivos del mismo paquete. Los paquetes se almacenan, con todos los archivos de origen de Go escritos por los usuarios, en el directorio $GOPATH/src. Podemos comprender la resolución de paquetes importando diferentes paquetes.

Si nuestro código reside en $GOPATH/src/blue/red, entonces el nombre de su paquete debería ser red.

La instrucción import para el paquete red sería la siguiente:

import "blue/red"

Los paquetes que se alojan en los repositorios de código fuente, como GitHub y BitBucket, tienen la ubicación completa del repositorio como parte de su ruta de importación.

Por ejemplo, importaríamos el código fuente de https://github.com/gobuffalo/buffalo usando la siguiente ruta de importación:

import "github.com/gobuffalo/buffalo"

Por lo tanto, este código fuente se encontraría en la siguiente ubicación en el disco:

$GOPATH/src/github.com/gobuffalo/buffalo

Conclusión

A través de este artículo, analizamos GOPATH como un conjunto de carpetas en las que Go prevé que se encuentra nuestro código fuente, y también vimos qué son y qué contienen estas carpetas. Analizamos la forma de cambiar esa ubicación de la predeterminada $HOME/go por la que el usuario prefiera configurando la variable de entorno $GOPATH. Por último, analizamos la forma en que Go se busca paquetes dentro de esa estructura de carpetas.

Los Go Modules se introdujeron en Go 1.11 y su propósito es sustituir los espacios de trabajo de Go y GOPATH. Si bien se recomienda comenzar a usar módulos, es posible que algunos entornos, como los corporativos, no estén listos para utilizar módulos.

GOPATH es uno de los aspectos más complicados de la configuración de Go, pero una vez que está listo normalmente no hay de qué preocuparse.