{"id":122,"date":"2017-05-04T21:09:03","date_gmt":"2017-05-05T00:09:03","guid":{"rendered":"https:\/\/www.linuxpro.com.br\/2017\/05\/instalando-golang-no-linux\/"},"modified":"2026-09-08T03:38:31","modified_gmt":"2026-09-08T06:38:31","slug":"instalando-golang-no-linux","status":"publish","type":"post","link":"https:\/\/www.linuxpro.com.br\/es\/2017\/05\/instalando-golang-no-linux\/","title":{"rendered":"Go en Ubuntu: instalando y escribiendo tu primer programa"},"content":{"rendered":"

\"Mascote<\/p>\n

Nota (2026):<\/strong> Esta entrada era, en 2017, la instalaci\u00f3n de Go 1.8.3 con GOPATH<\/code>, una forma de trabajar que el propio lenguaje abandon\u00f3. La reescribimos como un hello world<\/em> de verdad en Ubuntu, con la versi\u00f3n actual y con m\u00f3dulos.<\/div>\n

Este es el camino m\u00e1s corto entre un Ubuntu limpio y tu primer programa en Go<\/strong> funcionando. Lleva unos diez minutos, y al final sales con un binario \u00fanico que corre en cualquier Linux: sin int\u00e9rprete, sin m\u00e1quina virtual, sin dependencias que instalar en el servidor.<\/p>\n

Por qu\u00e9 Go, en dos frases<\/h2>\n

Go fue dise\u00f1ado en Google en 2007 porque C++ tardaba demasiado en compilar y la concurrencia daba demasiado trabajo. El resultado: compila en segundos, tiene concurrencia incorporada en el lenguaje y ofrece un binario est\u00e1tico<\/strong>. Por eso Docker, Kubernetes, Terraform y Prometheus est\u00e1n escritos en \u00e9l. La historia completa est\u00e1 en La historia del lenguaje Go<\/a>.<\/p>\n

Instalaci\u00f3n en Ubuntu<\/h2>\n

Existen tres caminos. El tarball oficial es el recomendado<\/strong> \u2014 el paquete de apt<\/code> suele quedarse una o dos versiones atr\u00e1s, y en Go eso importa porque el lenguaje lanza una versi\u00f3n cada seis meses.<\/p>\n

# descobre a vers\u00e3o atual sem abrir o navegador\nVER=$(curl -fsSL 'https:\/\/go.dev\/VERSION?m=text' | head -n1)\necho \"$VER\"\n\n# baixa e instala no lugar can\u00f4nico\ncd \/tmp\ncurl -fLO \"https:\/\/go.dev\/dl\/${VER}.linux-amd64.tar.gz\"\nsudo rm -rf \/usr\/local\/go\nsudo tar -C \/usr\/local -xzf \"${VER}.linux-amd64.tar.gz\"<\/code><\/pre>\n
F\u00edjate en el rm -rf \/usr\/local\/go<\/code> antes de extraer: es el paso que la documentaci\u00f3n oficial exige y que casi todos los tutoriales olvidan. Extraer sobre una instalaci\u00f3n antigua mezcla archivos de dos versiones y genera un error dif\u00edcil de diagnosticar.<\/p>\n
Ahora el PATH<\/code>. Para que tenga efecto en todo el sistema y sobreviva a nuevos usuarios:<\/p>\n
echo 'export PATH=$PATH:\/usr\/local\/go\/bin' | sudo tee \/etc\/profile.d\/go.sh\nsource \/etc\/profile.d\/go.sh\n\ngo version<\/code><\/pre>\n
Si ha aparecido algo como go version go1.27.1 linux\/amd64<\/code>, est\u00e1 listo. Si el comando no se ha encontrado, el source<\/code> anterior lo aplica en la sesi\u00f3n actual; en las pr\u00f3ximas se cargar\u00e1 solo.<\/p>\n
En una m\u00e1quina ARM, como una Raspberry Pi, cambia linux-amd64<\/code> por linux-arm64<\/code>.<\/p>\n
Las alternativas, y cu\u00e1ndo usarlas<\/h3>\n
# snap \u2014 vers\u00e3o recente, atualiza sozinho\nsudo snap install go --classic\n\n# apt \u2014 mais simples, vers\u00e3o mais velha\nsudo apt install golang-go<\/code><\/pre>\n
El apt<\/code> sirve si solo necesitas compilar algo de terceros y no te importa la versi\u00f3n. Para desarrollar, qu\u00e9date con el tarball.<\/p>\n
Hello, world<\/h2>\n
Antes de cualquier estructura de proyecto, mira el lenguaje puro. Crea ola.go<\/code>:<\/p>\n
package main\n\nimport \"fmt\"\n\nfunc main() {\n    fmt.Println(\"Ol\u00e1, mundo!\")\n}<\/code><\/pre>\n
go run ola.go<\/code><\/pre>\n
El go run<\/code> compila y ejecuta en memoria, sin dejar binario: es el modo de experimentar. Tres cosas a tener en cuenta: todo programa ejecutable empieza en package main<\/code>; la funci\u00f3n de entrada es func main()<\/code>; y el import<\/code> es obligatorio y no puede sobrar<\/strong>. Si importas un paquete y no lo usas, Go se niega a compilar. Es r\u00edgido a prop\u00f3sito.<\/p>\n
Ahora como es debido: un m\u00f3dulo<\/h2>\n
En la pr\u00e1ctica nadie trabaja con un archivo suelto. Go organiza los proyectos en m\u00f3dulos<\/strong> desde la versi\u00f3n 1.11, y ese es el cambio que jubil\u00f3 al viejo GOPATH<\/code> de esta entrada en 2017:<\/p>\n
mkdir ~\/ola && cd ~\/ola\ngo mod init exemplo.com\/ola<\/code><\/pre>\n
Esto crea el go.mod<\/code>, que declara el nombre del m\u00f3dulo y la versi\u00f3n del lenguaje. Ahora un programa un poco m\u00e1s interesante \u2014 crea main.go<\/code>:<\/p>\n
package main\n\nimport (\n    \"bufio\"\n    \"fmt\"\n    \"os\"\n    \"strings\"\n)\n\nfunc main() {\n    fmt.Print(\"Qual o seu nome? \")\n\n    leitor := bufio.NewReader(os.Stdin)\n    nome, err := leitor.ReadString('n')\n    if err != nil {\n        fmt.Fprintln(os.Stderr, \"erro ao ler a entrada:\", err)\n        os.Exit(1)\n    }\n\n    nome = strings.TrimSpace(nome)\n    if nome == \"\" {\n        fmt.Println(\"Voc\u00ea n\u00e3o digitou nada.\")\n        return\n    }\n\n    fmt.Printf(\"Ol\u00e1, %s! Bem-vindo ao Go.n\", nome)\n}<\/code><\/pre>\n
go run .<\/code><\/pre>\n
Aqu\u00ed aparece la marca registrada del lenguaje: el if err != nil<\/code>. En Go no existe la excepci\u00f3n \u2014 toda funci\u00f3n que puede fallar devuelve el error junto con el resultado, y est\u00e1s obligado a decidir qu\u00e9 hacer con \u00e9l. Es verboso, se critica, y es intencionado: el camino del error queda visible en el c\u00f3digo, no escondido en un catch<\/code> lejos.<\/p>\n
Generando el binario<\/h2>\n
Esta es la parte que vende el lenguaje a quien administra servidores:<\/p>\n
go build -o ola\nls -lh ola\n.\/ola<\/code><\/pre>\n
El archivo ola<\/code> es un ejecutable completo. C\u00f3pialo a otro Linux y funciona \u2014 no hace falta instalar Go all\u00ed, ni runtime, ni bibliotecas. Y se puede compilar para otro sistema sin salir del tuyo:<\/p>\n
GOOS=linux   GOARCH=arm64 go build -o ola-arm      # Raspberry Pi\nGOOS=windows GOARCH=amd64 go build -o ola.exe      # Windows\nGOOS=darwin  GOARCH=arm64 go build -o ola-mac      # Mac com Apple Silicon<\/code><\/pre>\n
Compilaci\u00f3n cruzada en una variable de entorno, sin toolchain extra. Por eso tantas herramientas de l\u00ednea de comandos modernas se distribuyen como un binario por plataforma.<\/p>\n
Usando una dependencia<\/h2>\n
go get github.com\/fatih\/color<\/code><\/pre>\n
package main\n\nimport \"github.com\/fatih\/color\"\n\nfunc main() {\n    color.Green(\"Ol\u00e1, mundo!\")\n    color.New(color.FgYellow, color.Bold).Println(\"agora em amarelo e negrito\")\n}<\/code><\/pre>\n
go mod tidy    # ajusta o go.mod: adiciona o que falta, remove o que sobra\ngo run .<\/code><\/pre>\n
El go.sum<\/code>, creado autom\u00e1ticamente, guarda el hash de cada dependencia: es lo que garantiza que la versi\u00f3n descargada ma\u00f1ana es byte a byte la misma de hoy. Versiona ambos archivos<\/strong>, go.mod<\/code> y go.sum<\/code>, junto con el c\u00f3digo.<\/p>\n
Un adelanto de concurrencia<\/h2>\n
No se puede presentar Go sin mostrar la goroutine<\/em>, que es el motivo por el que el lenguaje ha conquistado la infraestructura:<\/p>\n
package main\n\nimport (\n    \"fmt\"\n    \"net\/http\"\n    \"time\"\n)\n\nfunc checar(url string, resultado chan<- string) {\n    inicio := time.Now()\n    resp, err := http.Get(url)\n    if err != nil {\n        resultado <- fmt.Sprintf(\"%-28s ERRO: %v\", url, err)\n        return\n    }\n    defer resp.Body.Close()\n    resultado <- fmt.Sprintf(\"%-28s %s em %v\", url, resp.Status, time.Since(inicio).Round(time.Millisecond))\n}\n\nfunc main() {\n    sites := []string{\n        \"https:\/\/www.linuxpro.com.br\",\n        \"https:\/\/go.dev\",\n        \"https:\/\/kernel.org\",\n    }\n\n    resultado := make(chan string)\n    for _, s := range sites {\n        go checar(s, resultado)     \/\/ dispara os tr\u00eas ao mesmo tempo\n    }\n\n    for range sites {\n        fmt.Println(<-resultado)    \/\/ recebe conforme forem chegando\n    }\n}<\/code><\/pre>\n
go run .<\/code><\/pre>\n
Los tres sitios se consultan en paralelo<\/strong>, y el total tarda lo que el m\u00e1s lento, no la suma de los tres. Esto es una palabra \u2014 go<\/code> \u2014 y un canal. Sin biblioteca, sin pool de threads, sin callback<\/em>.<\/p>\n
Las herramientas que ya vienen incluidas<\/h2>\n
go fmt .\/...      # formata no padr\u00e3o oficial; n\u00e3o h\u00e1 debate de estilo em Go\ngo vet .\/...      # aponta erro prov\u00e1vel que compila mesmo assim\ngo test .\/...     # roda os testes\ngo doc fmt.Println   # documenta\u00e7\u00e3o sem sair do terminal\ngo clean -cache   # limpa o cache de build quando algo fica estranho<\/code><\/pre>\n
El go fmt<\/code> merece destaque: el lenguaje tiene un<\/em> estilo oficial, aplicado por una herramienta. Esto zanj\u00f3, de ra\u00edz, la discusi\u00f3n sobre tabulaci\u00f3n y llaves que consume tiempo en otras comunidades.<\/p>\n
Varias versiones en la misma m\u00e1quina<\/h2>\n
Cuando un proyecto est\u00e1 atascado en una versi\u00f3n antigua, el propio Go lo resuelve \u2014 sin gestor externo:<\/p>\n
go install golang.org\/dl\/go1.26@latest\ngo1.26 download\ngo1.26 version<\/code><\/pre>\n
Y, desde la 1.21, existe algo a\u00fan mejor: si el go.mod<\/code> del proyecto pide una versi\u00f3n que no tienes, el GOTOOLCHAIN<\/code> descarga la correcta en el momento del build, por s\u00ed solo.<\/p>\n
Por d\u00f3nde seguir<\/h2>\n