Setup moderno de Go: Olvidate del GOPATH y dominá Go Modules

Si estás pensando en meterte en el mundo de Go (o Golang), es muy probable que te encuentres con una montaña de tutoriales viejos que te hablan de configurar variables de entorno complejas, mover tus proyectos a carpetas específicas y pelearte con el famoso GOPATH.

Dejame decirte algo: todo eso ya es historia.

En este post, vamos a configurar un entorno de desarrollo moderno, limpio y profesional. Vamos a entender por qué el modelo de módulos cambió las reglas del juego, cómo instalar las herramientas correctamente y cómo gestionar tus binarios sin volverte loco. Este tutorial está pensado para desarrolladores que quieren empezar con el pie derecho, evitando vicios de hace cinco años que solo te van a traer dolores de cabeza.

¿Por qué Go es distinto? El cambio de paradigma

Antes de tirar comandos a la consola, tenés que entender qué cambió. Históricamente, Go funcionaba bajo un modelo donde todo tu código tenía que vivir dentro de una carpeta específica llamada $GOPATH/src. Si querías hacer un proyecto, no podías ponerlo en tu Documents o en un Desktop; tenías que meterlo sí o sí dentro de esa estructura. Esto era un dolor de cabeza para la gestión de dependencias y la colaboración.

Con la llegada de Go Modules, ese paradigma murió. Ahora podés crear tu proyecto en cualquier carpeta de tu máquina, y Go se encarga de gestionar las dependencias de forma aislada y declarativa, similar a como lo hace npm con package.json en Node.js o cargo en Rust.

1. Instalación limpia de Go

Lo primero es lo primero: instalar el binario. No te recomiendo usar los gestores de paquetes de tu distro de Linux (como apt) a menos que necesites una versión muy específica, porque suelen estar desactualizados. Lo ideal es ir directo a la fuente.

En macOS (usando Homebrew)

Si usás Mac, tenés la vida resuelta:

brew install go

En Linux y Windows

Lo mejor es descargar el instalador oficial desde go.dev/dl.

Una vez que termine la instalación, lo primero que tenés que hacer es verificar que tu terminal reconozca el comando. Abrí una nueva sesión de tu terminal y ejecutá:

go version

Salida esperada:

go version go1.22.1 linux/amd64 (o darwin/arm64 si es Mac)

Configurando el PATH

Aunque Go Modules nos liberó del GOPATH, todavía necesitamos que nuestro sistema sepa dónde encontrar los binarios que instalemos con Go. Por eso, tenés que asegurarte de que el directorio bin de Go esté en tu variable de entorno PATH.

Agregá esto a tu archivo de configuración de shell (.zshrc o .bashrc):

export PATH=$PATH:$(go env GOPATH)/bin

Para verificar que el comando go env funciona y ver tu configuración actual, ejecutá:

go env GOPATH

2. El fin de la era GOPATH: Bienvenidos a Go Modules

Acá es donde la mayoría de los que vienen de otros lenguajes se confunden. Vamos a hacer un ejercicio práctico para que veas la diferencia.

Creando un proyecto desde cero

Imaginá que querés crear un microservicio llamado api-server. No crees una carpeta llamada src dentro de tu home. Simplemente creá una carpeta donde vos quieras.

mkdir mi-proyecto-cool
cd mi-proyecto-cool

Ahora, el paso crucial. Para decirle a Go "che, este es un proyecto moderno y quiero que gestiones sus dependencias", ejecutamos:

go mod init github.com/tu-usuario/mi-proyecto-cool

Este comando crea un archivo llamado go.mod. Este archivo es el corazón de tu proyecto; ahí se van a registrar todas las librerías que uses.

Salida esperada:

added go.mod

Agregando una dependencia

Supongamos que querés usar gin, un framework web muy popular. En lugar de ir a buscar el código a mano, simplemente hacés:

go get github.com/gin-gonic/gin

¿Qué pasó acá?

1. Go descargó la librería.
2. Se actualizó tu archivo go.mod con la versión de Gin.
3. Se creó un archivo go.sum, que contiene los checksums para asegurar que nadie haya hackeado la librería y te esté mandando código malicioso. Nunca borres el go.sum.

Ejemplo de código ejecutable

Vamos a crear un archivo main.go rápido para probar que todo esto funciona. Copiá este código en un archivo llamado main.go dentro de tu carpeta:

package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"net/http"
)

func main() {
	// Creamos un router de Gin
	r := gin.Default()

	r.GET("/ping", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{
			"message": "pong",
		})
	})

	fmt.Println("Servidor corriendo en http://localhost:8080")
	// En un entorno real usaríamos r.Run(), pero para el playground 
	// simulamos una respuesta rápida.
	fmt.Println("Simulación de respuesta: {\"message\": \"pong\"}")
}

Nota: En el entorno de ejecución del blog, el servidor de Gin no podrá levantar un puerto real, pero el código es perfectamente válido para tu máquina local.

3. go install: Instalando herramientas globales

Seguro escuchaste hablar de go install. Es una herramienta fundamental para instalar herramientas de CLI escritas en Go.

Si necesitás una herramienta como golangci-lint (un linter de altísima calidad), no descargás un .exe o un .deb. Simplemente ejecutás:

go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

¿Qué hace esto exactamente?

• Descarga el código fuente de la herramienta.
• Lo compila.
• Pone el binario resultante en $(go env GOPATH)/bin.

Como configuramos el PATH en el paso 1, ahora podés ejecutar golangci-lint desde cualquier parte de tu terminal. Es una maravilla la limpieza que esto aporta.

Buenas prácticas y errores comunes

Para que no pases un mal rato, anotá estos consejos de alguien que ya rompió suficientes cosas:

✅ Lo que SÍ tenés que hacer

• Usar siempre go mod init: No empieces un proyecto sin esto. Es la base de todo.
• Commitear go.mod y go.sum: Estos archivos deben ir a tu repositorio de Git. Permiten que tus compañeros (o vos mismo en otro servidor) tengan exactamente las mismas versiones de las dependencias.
• Usar go mod tidy: Este comando es tu mejor amigo. Limpia el archivo go.mod, borra dependencias que ya no usás y agrega las que te faltan. Ejecutalo seguido.

❌ Lo que NO tenés que hacer

• No toques el GOPATH manualmente: No crees carpetas src o pkg a mano para tus proyectos. Dejá que Go lo maneje.
• No edites go.sum a mano: Si tenés un error de checksum, es porque algo falló en la descarga o la librería fue alterada. Usá go clean -modcache para limpiar la caché y reintentar.
• No uses versiones viejas: Go evoluciona rápido. Mantenete en las versiones estables más recientes para tener las mejores mejoras de performance y seguridad.

Conclusión

Configurar Go hoy en día es mucho más sencillo de lo que era hace unos años. Al entender que Go Modules es el estándar y que el GOPATH ahora es mayormente un lugar para guardar herramientas y caché, te ahorrás el 90% de los problemas de configuración inicial.

Resumen de tu nuevo workflow:

1. Instalás Go.
2. Agregás el directorio bin de Go a tu PATH.
3. Creás tu carpeta de proyecto.
4. Ejecutás go mod init <nombre>.
5. Usás go get para dependencias y go install para herramientas.

¡Listo! Ya tenés un entorno profesional. Ahora, lo único que te queda es empezar a escribir código. ¡A darle átomos!