go build, run, install & clean

Estos cuatro comandos cubren cómo Go convierte el código fuente en binarios, los ejecuta localmente, instala herramientas globalmente y restablece las cachés al depurar compilaciones obsoletas.

Resumen

go build compila paquetes en artefactos que distribuyes.

go run es un atajo de desarrollo que compila a un archivo temporal y lo ejecuta inmediatamente.

go install coloca los binarios de comandos en tu PATH a través de GOBIN o GOPATH/bin.

go clean elimina las salidas de compilación y las entradas de caché cuando necesitas una reconstrucción en frío.

Los cuatro comparten el mismo cargador de paquetes y respetan las etiquetas de compilación, GOOS, GOARCH y la configuración de módulos.

Receta

Tarjeta de referencia rápida - lista para copiar y pegar.

# Compila un binario de servicio con flags enfocados en el tamaño
go build -trimpath -ldflags="-s -w" -o bin/api ./cmd/api
 
# Ejecuta localmente con argumentos
go run ./cmd/api --addr :8080
 
# Instala una herramienta CLI en la versión del módulo en go.mod
go install golang.org/x/tools/cmd/goimports@latest
 
# Limpia la caché de resultados de pruebas después de arreglar una prueba inestable
go clean -testcache

Cuándo usar esto:

• Usa go build para artefactos de lanzamiento, imágenes de Docker y binarios de CI.
• Usa go run para una iteración rápida en paquetes main.
• Usa go install para herramientas de desarrollador (goimports, staticcheck, CLIs de generación de código).
• Usa go clean -cache solo cuando diagnostiques aciertos de caché corruptos o imposibles.

Ejemplo de Trabajo

# Diseño del módulo:
# .
# ├── go.mod
# ├── cmd/seed/main.go
# └── internal/seed/seed.go
 
go build -o bin/seed ./cmd/seed
./bin/seed --count 5
 
go run ./cmd/seed --count 3
 
go install ./cmd/seed   # instala en $(go env GOPATH)/bin o GOBIN
 
go clean -i ./cmd/seed  # elimina el binario instalado para esta ruta de importación

// cmd/seed/main.go
package main
 
import (
    "flag"
    "fmt"
    "example.com/tooldemo/internal/seed"
)
 
func main() {
    n := flag.Int("count", 1, "registros a crear")
    flag.Parse()
    fmt.Println(seed.Generate(*n))
}

// internal/seed/seed.go
package seed
 
import "fmt"
 
func Generate(n int) string {
    return fmt.Sprintf("generados %d registros", n)
}

Lo que esto demuestra:

• go build -o nombra la salida explícitamente para scripts de despliegue.
• go run acepta la misma ruta de paquete y reenvía flags después de -- cuando es necesario.
• go install con un ./cmd/seed relativo instala desde el módulo actual sin un go get separado.
• go clean -i elimina el binario instalado que coincide con la ruta de importación de ese paquete.

Análisis Profundo

Cómo Funciona

• El cargador resuelve el patrón de paquete a una ruta de importación, aplica las restricciones de compilación y construye un grafo de acciones.
• Los pasos de compilación escriben archivos de archivo en GOCACHE; los pasos de enlace combinan los archivos de archivo en ejecutables.
• go run enlaza a un ejecutable temporal en el directorio temporal del sistema operativo y lo elimina después de salir (a menos que -work deje los intermediarios para inspección).
• go install omite la copia al directorio actual; solo actualiza el destino de instalación.

Flags de Compilación de un Vistazo

Objetivos de go clean

Notas de Go

# Inspecciona dónde van los artefactos
go env GOCACHE GOMODCACHE GOPATH GOBIN
 
# Imprime el ID de compilación invocado por el enlazador incrustado en los binarios
go tool buildid bin/seed

Trampas Comunes

• Usar go run en scripts de producción - compila en cada invocación y oculta la ruta del artefacto. Solución: go build una vez, ejecuta el binario.
• Olvidar -o en CI - los nombres de salida predeterminados colisionan al compilar múltiples comandos en un solo directorio. Solución: siempre establece -o bin/<nombre>.
• go install sin una versión fuera de un módulo - @latest puede adelantarse a los pines de CI. Solución: ejecuta desde un módulo con un require registrado o fija @v1.2.3.
• go clean -modcache en CI compartida - fuerza la redescarga completa y ralentiza cada trabajo. Solución: haz caché de GOMODCACHE entre ejecuciones; limpia solo ante errores de corrupción.
• Compilación cruzada de paquetes cgo - necesita una cadena de herramientas C cruzada, no solo GOOS/GOARCH. Solución: deshabilita cgo (CGO_ENABLED=0) o instala el compilador cruzado correspondiente.
• Expectativas obsoletas de -trimpath - los panics todavía incluyen nombres de funciones; solo se recortan las rutas de archivo. Solución: sube símbolos por separado si necesitas depuración a nivel de ruta.

Alternativas

Preguntas Frecuentes

Relacionado

• El Comando go: Ciclo de Vida de Compilación, Pruebas y Módulos - grafo de acciones y cachés
• Conceptos Básicos de la Cadena de Herramientas de Go - ejemplos de comandos introductorios
• Etiquetas de Compilación y Compilación Condicional - fuentes controladas por etiquetas
• Compilación Cruzada y Proxies de Módulos Privados - matriz GOOS/GOARCH
• Mejores Prácticas de la Cadena de Herramientas de Go - compilaciones de lanzamiento reproducibles

Versiones de Stack: Esta página fue escrita para Go 1.26.x (predeterminado Green Tea GC, go fix modernizadores - verifica el parche en la compilación), chi (última - verifica en la compilación), gin (última - verifica en la compilación), echo (última - verifica en la compilación), google.golang.org/grpc (última - verifica en la compilación), sigs.k8s.io/controller-runtime (última - verifica en la compilación), kubebuilder (última - verifica en la compilación), tinygo (última - verifica objetivos de placa en la compilación), wazero (última - verifica en la compilación) y golangci-lint (última - verifica el conjunto de linters en la compilación).