Go: Introdução ao Go e instalação

Go é uma linguagem concorrente compilada desenvolvida pelo Google — ela resolve problemas de engenharia com uma sintaxe mínima, tornando “rápido e simples” uma realidade.

Este tutorial foi elaborado para iniciantes sem experiência prévia. Ele começa com o básico — “O que é Go?” — e orienta você durante todo o processo até a criação e execução de sua primeira ferramenta de linha de comando em Go. O Go é o padrão de fato em ambientes nativos da nuvem (Docker/Kubernetes), microsserviços e ferramentas de linha de comando, e é utilizado por mais de 3 milhões de desenvolvedores em todo o mundo.

1. O que você vai aprender

• O que é o Go? Quem o criou e quais problemas ele resolve?
• Principais diferenças entre Go e Python, Java e C++
• As três filosofias de design do Go (simplicidade, concorrência, velocidade)
• Instale o Go 1.22 ou superior no Windows, macOS ou Linux
• Escreva seu primeiro programa “Hello World”
• go run / go build / go fmt — Os três comandos básicos
• Implantar a semente de gerenciamento de dependências go mod init (Lição 8: Aprofundamento)

2. A história real de um engenheiro de backend

(1) Problema: A API do Python trava sob carga simultânea

Alice é engenheira de backend, e o serviço de API que ela desenvolveu em Python vem apresentando problemas recentemente:

“Durante o evento online, recebemos 10.000 solicitações simultâneas, o que fez com que os tempos de resposta da API disparassem de 100 ms para 8 segundos e que o uso da CPU chegasse a 95%. O serviço quase travou.”

Depois de analisar os logs do backend, ela descobriu que:

• GIL Global Lock: O módulo threading do Python não consegue aproveitar plenamente as vantagens das CPUs com vários núcleos
• Complexidade assíncrona: asyncio Curva de aprendizado íngreme, baixa legibilidade do código
• Pico de memória: Cada solicitação consome 50 MB; com 10.000 solicitações simultâneas, são consumidos 500 GB de memória
• Mudança lenta de processo: A mudança para multiprocessing resulta em uma inicialização lenta e em alta sobrecarga de comunicação

Seu chefe perguntou a ela: “Podemos mudar para uma linguagem de programação diferente?” Depois de pesquisar um pouco, Alice decidiu optar pelo Go.

(2) A Solução do Go

Veja como Alice reescreveu a mesma lógica de negócios em Go:

// main.go
package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello from Go!")
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

Comparação de desempenho (10.000 usuários simultâneos para o mesmo cenário de negócios):

(3) Benefícios: Por que vale a pena aprender Go?

Depois de concluir esta lição, você dará seu primeiro passo:

• Entendendo a filosofia de design por trás do Go: Saiba quais são os pontos críticos que o Go resolve para evitar seguir tendências cegamente
• Configure seu ambiente de desenvolvimento: Escolha entre Windows, macOS ou Linux — leva apenas 10 minutos.
• Como fazer o “Hello World” funcionar: No momento em que você vir a saída do Hello, World!, você já terá pegado o jeito.
• Domine os três comandos principais: go run / go build / go fmt — o suficiente para o desenvolvimento diário

3. O que é o Go?

Go (também conhecido como Golang) é uma linguagem de código aberto e compilada criada em 2009 e projetada por Robert Griesemer, Rob Pike e Ken Thompson, do Google. Todos os três são colaboradores principais da linguagem C e do Unix.

(1) A motivação por trás da criação do Go

Em 2007, o Google enfrentou um problema interno:

• A compilação em C++ é muito lenta: a compilação completa de um grande projeto em C++ leva 45 minutos
• Gerenciamento caótico de dependências: Um pesadelo de inclusões de arquivos de cabeçalho — alterar uma única linha de código afeta todo o projeto
• Desafios na programação concorrente: Escrever código concorrente com pthreads gera muitos erros e é difícil de depurar.
• Equipe numerosa: Com dezenas de milhares de engenheiros colaborando, é difícil padronizar os estilos de codificação.

O objetivo do Go: resolver problemas de engenharia com uma sintaxe mínima, tornando a colaboração entre equipes grandes tão tranquila quanto em equipes pequenas.

(2) As três principais filosofias de design do Go

graph TB
    A[Go Design Philosophy] --> B[Simplicity]
    A --> C[Concurrency]
    A --> D[Speed]

    B --> B1[25 keywords<br/>No inheritance/No issues]
    B --> B2[gofmt standard format<br/>No style debates in team code]

    C --> C1[goroutine<br/>2KB stack, start 1μs]
    C --> C2[channel<br/>CSP concurrency model]

    D --> D1[Compiled<br/>Compilation in seconds, 20ms start]
    D --> D2[Static link<br/>Single binary deployment]

graph TB
    A[Go Design Philosophy] --> B[Simplicity]
    A --> C[Concurrency]
    A --> D[Speed]

    B --> B1[25 keywords<br/>No inheritance/No issues]
    B --> B2[gofmt standard format<br/>No style debates in team code]

    C --> C1[goroutine<br/>2KB stack, start 1μs]
    C --> C2[channel<br/>CSP concurrency model]

    D --> D1[Compiled<br/>Compilation in seconds, 20ms start]
    D --> D2[Static link<br/>Single binary deployment]

(3) Áreas típicas de aplicação do Go

4. Diferenças entre o Go e outras linguagens

(1) Noções básicas sobre localização de idiomas

graph TB
    subgraph L[Division of Labor Among Programming Languages]
        direction TB
        G[Go<br/>Back-end Services/Cloud-native/CLI]
        P[Python<br/>Data Science/AI/Script]
        J[Java<br/>Enterprise-level/Android/Big Data]
        C[C++<br/>Games/System Software/Embedded]
        R[Rust<br/>System-level/Embedded/Security-sensitive]
    end

graph TB
    subgraph L[Division of Labor Among Programming Languages]
        direction TB
        G[Go<br/>Back-end Services/Cloud-native/CLI]
        P[Python<br/>Data Science/AI/Script]
        J[Java<br/>Enterprise-level/Android/Big Data]
        C[C++<br/>Games/System Software/Embedded]
        R[Rust<br/>System-level/Embedded/Security-sensitive]
    end

(2) Go x Python x Java x C++

(3) Você também deve estar ciente das “fraquezas” do Go

• Os genéricos têm uma história recente: o Go só adicionou genéricos a partir da versão 1.18, o que dificulta o trabalho dos mantenedores de projetos legados
• Tratamento detalhado de erros: if err != nil { return err } Escrever isso 100 vezes é o normal
• Sem tratamento de exceções com try/catch: Confie nos valores de retorno error e panic/recover
• Ecossistema relativamente novo: a qualidade das bibliotecas varia bastante; em algumas áreas, Python ou Java são opções mais seguras

5. Instalar o Go

(1) Link para download

Link oficial para download: https://go.dev/dl/

(2) ▶ Exemplo: Instalação gráfica do Go no Windows

# Steps 1: Double-click go1.22.x.windows-amd64.msi
# Steps 2: All the Way Next (Installed by default to C:\Program Files\Go)
# Steps 3: Check the box "Add Go to PATH" (Automatically Configure Environment Variables)
# Steps 4: Finish
# Steps 5: Verify Installation
go version

Saída:

go version go1.22.x windows/amd64

(3) ▶ Exemplo: Instalando o Homebrew no macOS

# Steps 1: Install Homebrew (If you haven't installed it yet)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Steps 2: Installation Go
brew install go

# Steps 3: Verification
go version

Saída:

go version go1.22.x darwin/arm64

(4) ▶ Exemplo: Extração e instalação manuais no Linux

# Steps 1: Download (Using 1.22.x as an example)
wget https://go.dev/dl/go1.22.x.linux-amd64.tar.gz

# Steps 2: Extract to /usr/local
sudo tar -C /usr/local -xzf go1.22.x.linux-amd64.tar.gz

# Steps 3: Configure PATH (Write to ~/.bashrc or ~/.zshrc)
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
source ~/.bashrc

# Steps 4: Verification
go version

Saída:

go version go1.22.x linux/amd64

(5) Verificar as variáveis de ambiente

6. O primeiro programa “Hello World”

(1) Criar um diretório de trabalho

mkdir hello-go
cd hello-go

(2) Escreva o arquivo main.go

# At hello-go, create a file in the directory
cat > main.go << 'EOF'
package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
    fmt.Println("Welcome to Go programming!")
}
EOF

(3) ▶ Exemplo: go run Executar diretamente (durante o desenvolvimento)

go run main.go

Saída:

Hello, World!
Welcome to Go programming!

go run irá compilar e executar, mas não salva o arquivo binário; é adequado para desenvolvimento e depuração.

(4) ▶ Exemplo: go build Compilar para binário (implantação em produção)

go build -o hello main.go

# Run the generated binary
./hello    # Linux/macOS
hello.exe  # Windows

go build Gera um único arquivo executável que pode ser copiado diretamente para qualquer servidor com a mesma arquitetura e executado sem instalar o runtime do Go.

(5) ▶ Exemplo: gofmt Formatação automática de código

# Format all .go files in the current directory
gofmt -w .

# Check that the format is correct (do not modify)
gofmt -l .

gofmt é a “polícia do estilo de código” da equipe Go — todo código Go deve passar pela verificação gofmt, sem margem para discussões sobre estilo.

7. go mod init: Preparando o terreno para o gerenciamento de dependências

O gerenciamento abrangente de dependências é abordado em profundidade na Lição 8: pacotes de erros. Aqui, vamos estabelecer as bases para que você entenda o que é um arquivo go.mod.

(1) Por que a gestão de dependências é necessária?

Suponha que seu projeto utilize uma biblioteca de terceiros. Como você a declara? Como você a atualiza? Como você garante que todos os membros da equipe estejam usando a mesma versão?

Resposta do Go: arquivo go.mod + comando go mod.

(2) ▶ Exemplo: go mod init Criar um projeto

# Run the following command in the project's root directory
cd hello-go
go mod init hello-go

Saída:

go: creating new go.mod: module hello-go
go: now you can use 'go get' to add dependencies

Arquivo go.mod gerado:

module hello-go

go 1.22

(3) O que essas duas linhas de código significam

8. Exemplo completo: sua primeira ferramenta de linha de comando em Go

Vamos reunir todo o conhecimento adquirido acima para criar uma ferramenta CLI simples chamada Cartão de Informações Pessoais.

# Steps 1: Create a project directory
mkdir my-card && cd my-card

# Steps 2: Initialize module
go mod init my-card

# Steps 3: Write code
cat > main.go << 'EOF'
package main

import "fmt"

func main() {
    // Define a variable
    name := "Alice"
    role := "Backend Engineer"
    yearsOfExperience := 5

    // Print Card
    fmt.Println("========================================")
    fmt.Println("         Personal Card CLI")
    fmt.Println("========================================")
    fmt.Printf("Name:               %s\n", name)
    fmt.Printf("Role:               %s\n", role)
    fmt.Printf("Years of Experience: %d\n", yearsOfExperience)
    fmt.Printf("Language:           Go %s\n", "1.22+")
    fmt.Println("========================================")
}
EOF

# Steps 4: Run
go run main.go

# Steps 5: Compile into an executable file
go build -o card main.go
./card

Resultado esperado:

========================================
         Personal Card CLI
========================================
Name:               Alice
Role:               Backend Engineer
Years of Experience: 5
Language:           Go 1.22+
========================================

❓ Perguntas Frequentes

P: Qual é a relação entre Go e Golang? R: O nome oficial do Go é “Go”, mas como “Go” é muito genérico e dificulta a busca por informações, a comunidade geralmente usa “Golang” como um apelido (o domínio golang.org também usa esse nome). Os dois termos são totalmente intercambiáveis; use o que preferir.

P: Para que o Go é mais adequado? R: Os pontos fortes do Go estão no desenvolvimento do lado do servidor: APIs/microsserviços, ferramentas de linha de comando (CLI), aplicativos nativos da nuvem (tanto o Docker quanto o K8s são escritos em Go), bancos de dados e filas de mensagens. O Go não é adequado para interfaces gráficas de usuário (GUIs) de desktop, aplicativos móveis, desenvolvimento front-end ou motores de jogos (outras linguagens são mais adequadas para essas áreas).

P: Qual é a diferença de desempenho entre Go e Python? R: Para tarefas que exigem muito da CPU, o Go costuma ser de 30 a 100 vezes mais rápido que o Python; para tarefas que exigem muito de E/S, ele pode ser de 10 a 50 vezes mais rápido quando se utilizam goroutines. A diferença decorre dos seguintes fatores: compilação versus interpretação, goroutines versus o GIL e otimizações decorrentes da tipagem forte.

P: O que devo fazer se o go version exibir a mensagem “comando não encontrado” após a instalação? R: Isso geralmente ocorre porque o PATH não está configurado. No Windows, reinicie o terminal ou faça logout e login novamente; no Linux/macOS, execute source ~/.bashrc (ou ~/.zshrc). Se isso ainda não funcionar, verifique se $GOROOT/bin está incluído em $PATH: echo $PATH | grep go.

P: Existem diferenças significativas entre o Go 1.22 e as versões anteriores? R: O Go 1.22 traz três mudanças importantes: (1) aprimoramentos no roteamento HTTP mux.HandleFunc("GET /path/{id}", h); (2) loops for-range para inteiros for i := range 10; (3) otimizações no modelo de memória. Este tutorial se baseia no Go 1.22 ou versões posteriores.

P: Preciso aprender C antes de aprender Go? R: Não. Um dos objetivos de design do Go é ser “mais simples que o C++”. Desde que você tenha um conhecimento básico de qualquer linguagem de programação (Python, Java ou JavaScript servem), pode começar a aprender Go imediatamente. O Go tem apenas 25 palavras-chave, menos do que a maioria das linguagens.

P: Qual é a diferença entre go run e go build? R: go run = Compilar + Executar + Limpar arquivos intermediários (para desenvolvimento); go build = Apenas compilar, gerar um arquivo executável (para implantação em produção). go run não mantém o arquivo .exe, enquanto go build o mantém.

📖 Resumo

• Go é uma linguagem compilada lançada pelo Google em 2009, projetada especificamente para a colaboração em projetos de engenharia em grande escala
• Três filosofias centrais de design: Simplicidade (25 palavras-chave + gofmt), Concorrência (goroutines + canais), Velocidade (compilação em segundos + um único binário)
• Casos de uso típicos: Nativo da nuvem (Docker/K8s), microsserviços, ferramentas de CLI, bancos de dados
• Go x Python/Java/C++: desempenho 30 a 100 vezes mais rápido, uso de memória 1/30 menor e suporte nativo à concorrência
• Instalação: A página oficial de download go.dev/dl disponibiliza pacotes de instalação para Windows, macOS e Linux.
• Três comandos básicos: go run (Executar) / go build (Compilar) / go fmt (Formatar)
• go mod init Inicializar o módulo e gerar o arquivo go.mod para declarar os metadados do projeto

📝 Exercícios

1. Exercício básico (Dificuldade ⭐): Instale o Go 1.22 ou uma versão posterior localmente, execute go version e faça uma captura de tela para verificar; escreva hello.go para exibir “Hello, Go!”.

2. Problema avançado (Dificuldade ⭐⭐): Amplie a CLI do Cartão Pessoal apresentada acima adicionando duas variáveis, city := "Shanghai" e hobby := "Coding", e acrescentando essas duas linhas ao final do cartão. Por fim, compile-o em um arquivo executável usando go build.

3. Desafio (Dificuldade: ⭐⭐⭐): Pesquise uma ferramenta de linha de comando que você use com frequência (como git / docker / kubectl) para verificar se ela foi escrita em Go. Se for o caso, escreva um texto de 200 caracteres explicando “por que o Go é adequado para ferramentas de linha de comando” (dica: compilação multiplataforma, binário único, inicialização rápida).

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós