{"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\/en\/2017\/05\/instalando-golang-no-linux\/","title":{"rendered":"Go on Ubuntu: installing and writing your first program"},"content":{"rendered":"

\"Mascote<\/p>\n

Note (2026):<\/strong> In 2017, this post covered installing Go 1.8.3 with GOPATH<\/code> \u2014 a way of working that the language itself abandoned. We rewrote it as a hello world<\/em> that actually runs on Ubuntu, with the current version and modules.<\/div>\n

This is the shortest path from a clean Ubuntu installation to your first Go<\/strong> program running. It takes about ten minutes, and you end up with a single binary that runs on any Linux system \u2014 no interpreter, no virtual machine, no dependencies to install on the server.<\/p>\n

Why Go, in two sentences<\/h2>\n

Go was designed at Google in 2007 because C++ took too long to compile and concurrency was too much work. The result: it compiles in seconds, has concurrency built into the language, and produces a static binary<\/strong>. That is why Docker, Kubernetes, Terraform, and Prometheus are written in it. The full story is in The history of the Go language<\/a>.<\/p>\n

Installing on Ubuntu<\/h2>\n

There are three options. The official tarball is recommended<\/strong> \u2014 the package from apt<\/code> usually lags one or two versions behind, and that matters in Go because the language releases every six months.<\/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
Notice rm -rf \/usr\/local\/go<\/code> before extracting: it is the step the official documentation requires and almost every tutorial forgets. Extracting over an old installation mixes files from two versions and produces errors that are hard to diagnose.<\/p>\n
Now for PATH<\/code>. To apply it system-wide and make it work for new users:<\/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
If you see something like go version go1.27.1 linux\/amd64<\/code>, you are ready. If the command was not found, the source<\/code> above fixes it for the current session \u2014 in future sessions it loads automatically.<\/p>\n
On an ARM machine, such as a Raspberry Pi, replace linux-amd64<\/code> with linux-arm64<\/code>.<\/p>\n
The alternatives, and when to use them<\/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
apt<\/code> works if you only need to compile someone else's software and do not care about the version. For development, stick with the tarball.<\/p>\n
Hello, world<\/h2>\n
Before setting up a project structure, look at the bare language. Create 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
go run<\/code> compiles and runs in memory without leaving a binary \u2014 it is the way to experiment. Three things to notice: every executable program starts with package main<\/code>; the entry-point function is func main()<\/code>; and an import<\/code> is required and cannot be unused<\/strong>. If you import a package without using it, Go refuses to compile. It is deliberately strict.<\/p>\n
Now the right way: a module<\/h2>\n
In practice, nobody works with standalone files. Go has organized projects into modules<\/strong> since version 1.11, and this is the change that retired the old GOPATH<\/code> from this post in 2017:<\/p>\n
mkdir ~\/ola && cd ~\/ola\ngo mod init exemplo.com\/ola<\/code><\/pre>\n
This creates go.mod<\/code>, which declares the module name and language version. Now for a slightly more interesting program \u2014 create 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
Here is the language's signature feature: if err != nil<\/code>. Go has no exceptions \u2014 every function that can fail returns an error along with its result, and you must decide what to do with it. It is verbose, it is criticized, and it is intentional: the error path is visible in the code, not hidden in a catch<\/code> far away.<\/p>\n
Building the binary<\/h2>\n
This is the part that sells the language to server administrators:<\/p>\n
go build -o ola\nls -lh ola\n.\/ola<\/code><\/pre>\n
The file ola<\/code> is a complete executable. Copy it to another Linux system and it runs \u2014 no need to install Go there, or a runtime, or a library. You can also compile for another system without leaving your own:<\/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
Cross-compilation with one environment variable, no extra toolchain. That is why so many modern command-line tools are distributed as one binary per platform.<\/p>\n
Using a dependency<\/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
The go.sum<\/code> file, created automatically, stores the hash of each dependency \u2014 ensuring that the version downloaded tomorrow is byte-for-byte identical to today's. Keep both files under version control<\/strong>, go.mod<\/code> and go.sum<\/code>, along with the code.<\/p>\n
A taste of concurrency<\/h2>\n
You cannot introduce Go without showing the goroutine<\/em>, which is why the language won over infrastructure:<\/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
The three sites are queried in parallel<\/strong>, and the total takes as long as the slowest, not the sum of all three. That takes one word \u2014 go<\/code> \u2014 and one channel. No library, no thread pool, no callback<\/em>.<\/p>\n
The tools that come included<\/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
go fmt<\/code> deserves special mention: the language has one<\/em> official style, enforced by a tool. From the outset, this ended the debate over tabs and braces that consumes time in other communities.<\/p>\n
Multiple versions on the same machine<\/h2>\n
When a project is stuck on an older version, Go itself handles it \u2014 no external manager:<\/p>\n
go install golang.org\/dl\/go1.26@latest\ngo1.26 download\ngo1.26 version<\/code><\/pre>\n
And since 1.21, there is something even better: if the go.mod<\/code> for the project requires a version you do not have, GOTOOLCHAIN<\/code> downloads the right one at build time, automatically.<\/p>\n
Where to go next<\/h2>\n