<\> Casa do Dev
Notícias abrir
Ferramentas abrir
Vagas abrir
Aprender abrir
Comunidade abrir
Guia de Compras abrir

Go do zero: a linguagem da infraestrutura e do backend

DA

4 min

Go do zero: a linguagem da infraestrutura e do backend

Aprenda Go do zero: sintaxe, goroutines e concorrência, e por que ele move Kubernetes e APIs de alta vazão.

Neste artigo

Go é a linguagem que a Google criou para ser simples e rápida em sistemas de rede e infraestrutura. É ela que move o Kubernetes, o Docker e uma geração de APIs de alta vazão. Se você quer backend performático ou trabalhar com infraestrutura, Go é a resposta mais direta que existe hoje.

Go é uma linguagem compilada, de sintaxe enxuta e concorrência embutida via goroutines. Comece pelo pacote, a função main e a sintaxe mínima, e depois entenda a goroutine, que é o superpoder da linguagem. A visão completa está no guia completo de Go.

O que torna Go diferente

Go foi desenhado para resolver os problemas que linguagens antigas arrastavam: compilação lenta, complexidade assíncrona e ferramenta dispersa. Ele compila para binário único, tem o garbage collector embutido e a concorrência como recurso de primeira classe. A sintaxe é propositalmente pequena, para que o código pareça igual em qualquer projeto.

💡 Dica: a frase que define Go é "menos é mais". Não tem herança de classes nem exceção; a linguagem troca recursos por clareza. É uma escolha de design que faz código de time grande ficar legível.

Seu primeiro programa em Go

Todo programa Go pertence a um pacote e começa na função main. O exemplo imprime uma linha usando o pacote padrão fmt.

package main

import "fmt"

func main() {
    fmt.Println("Olá, mundo!")
}

O package main marca o executável, o import traz o fmt e o func main() é a entrada. A estrutura é mínima de propósito: não há classe, não há namespace, apenas pacote e função. Quem vem de outra linguagem estranha a ausência de cerimônia.

Variáveis, funções e a tipagem explícita

Go é tipado de forma estática, mas com inferência: o compilador descobre o tipo quando você usa o operador curto :=. Funções podem devolver vários valores, um recurso usado para o retorno de erro junto do resultado, o padrão Go de tratar falha.

func dobrar(n int) int {
    return n * 2
}

func dividir(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("divisão por zero")
    }
    return a / b, nil
}

O par "valor, erro" é a filosofia do Go: erro não é exceção, é valor de retorno que você verifica. Dá mais trabalho que lançar exceção, mas torna o caminho de falha explícito e difícil de esquecer, o que em sistema de produção é uma vantagem.

Goroutines: a concorrência que mudou o jogo

Concorrência é fazer várias tarefas avançarem ao mesmo tempo, e Go resolve isso com goroutine, um fio leve que você lança com a palavra go. Milhares de goroutines rodam sobre poucos processadores, e o canal coordena a troca de dados entre elas.

go func() {
    fmt.Println("executando em paralelo")
}()

Esse é o recurso que colocou Go no centro da infraestrutura: servidores que atendem milhares de conexões simultâneas sem afogar. Não é o primeiro conceito a aprender, mas é o que justifica escolher Go em vez de outra linguagem para backend de vazão.

Para quem é Go na carreira

Go é forte em três frentes: backend de rede, ferramenta de linha de comando e infraestrutura de nuvem. A demanda cresce junto com o uso em DevOps e microsserviços, e a curva curta é um atrativo para quem vem de outra linguagem. Para entender onde ele se encaixa entre os runtimes, o comparativo de runtimes ajuda a decidir.

Canais: como as goroutines conversam

Goroutines trabalham em paralelo, e os canais são o jeito que elas trocam dado com segurança, sem condition de corrida. Você cria um canal com make(chan tipo), uma goroutine envia e outra recebe. É essa coordenação que torna o paralelo em Go tão direto quanto o restante da linguagem.

numero := make(chan int)

go func() {
    numero <- 42 // envia
}()

valor := <-numero // recebe
fmt.Println(valor)

O símbolo <- indica a direção do dado, e o canal sincroniza as duas pontas. É a ferramenta que transforma o "rodar em paralelo" em "trabalhar em paralelo trocando resultado", e é onde a concorrência de Go se torna produtiva em vez de ser demonstração. Quando esse binário for para produção, o caminho continua no guia de Docker para quem nunca usou.

Os três erros de quem vem de linguagem dinâmica

O primeiro erro é tratar o zero-value como valor inválido: em Go, toda variável nasce com um valor definido, e quem programa como se viesse nil em tudo escreve checagem desnecessária e mascaramento de estado. O segundo é ignorar o error como cidadão de primeira classe: guardar exceção para depois não existe, e quem encapsula o erro em log silencioso perde a rastreabilidade que sustenta produção. O terceiro é abrir goroutine sem controle de término: cada uma que vaza segura memória e, em volume, derruba o processo.

Esses três aparecem na primeira semana de quem migra. A correção não é decorar regra, é rodar o vet e os testes com race detector em todo commit, porque a ferramenta pega exatamente a classe de erro que a linguagem não esconde. Quando o binário estiver estável, a entrega em container segue o guia de Docker para quem nunca usou, que cobre a parte que a linguagem propositalmente não cobre.

A ferramenta que acompanha a linguagem

Go vem com a oficina completa embutida em um único comando. O go mod init cria o módulo com o arquivo go.mod, que declara dependências e versões sem arquivo de configuração extra. O go build compila, o go test roda os testes que ficam no mesmo pacote, o gofmt padroniza o formato e o go vet aponta suspeitas comuns. Compilar, testar e formatar nunca exigiram instalar nada além da linguagem.

Esse detalhe explica parte da adoção em times grandes: quando o formato é decidido pela ferramenta, a discussão de estilo desaparece do code review, e qualquer pessoa compila o projeto com o mesmo comando. Se a dúvida é entre Go e a outra linguagem de sistemas da moda, o comparativo de Rust e Go para alto desempenho pesa os compromissos de cada uma com curva de aprendizado e segurança de memória.

Perguntas frequentes

Go é difícil para iniciantes?

A sintaxe é deliberadamente simples, então o começo é rápido. O que pede prática é pensar em concorrência, que é o diferencial. A curva é menor que a de linguagens com muito conceito de orientação a objetos.

Go serve para frontend?

Não diretamente. Go brilha no backend, na ferramenta de linha de comando e na infraestrutura. Para interface, o JavaScript continua o domínio.

Quando usar Go em vez de Node ou Python?

Go quando a prioridade é performance, concorrência e binário único; Node quando o time já domina JavaScript; Python quando o foco é dados e protótipo. A escolha segue o problema, não a moda.

O que são goroutines em uma frase?

São fios leves que rodam tarefas em paralelo dentro do mesmo processo, lançados com a palavra reservada go e coordenados por canais.

Produtos relacionados

Este conteúdo tem links de afiliado: se você comprar por eles, podemos receber uma comissão sem custo extra para você. A escolha dos produtos segue critérios próprios e não é influenciada por comissão.

O que você achou deste artigo?

Responda a Pergunta do Dia Teste seu conhecimento e mantenha sua streak. Crie seu Dev Card público Perfil dev compartilhável em um único link.

Depois dessa formação...

Veja vagas em tecnologia →

Vagas relacionadas

Ver todas as vagas →
DA

Escrito por

Dagmar

Atualizado em 06/10/2026 •

Ver perfil do autor

COMPARTILHAR