---
title: "Curso Golang Gratuito: Trilha Prática para Aprender Go do Zero"
url: "https://golang.com.br/aprenda/curso-golang-gratuito/"
markdown_url: "https://golang.com.br/aprenda/curso-golang-gratuito.MD"
description: "Curso Golang gratuito em português: trilha prática para aprender Go do zero, com instalação, sintaxe, módulos, API REST, testes, Docker, PostgreSQL, concorrência e preparação para vagas."
date: "2026-05-19"
author: "Golang Brasil"
---

# Curso Golang Gratuito: Trilha Prática para Aprender Go do Zero

Curso Golang gratuito em português: trilha prática para aprender Go do zero, com instalação, sintaxe, módulos, API REST, testes, Docker, PostgreSQL, concorrência e preparação para vagas.


Um bom **curso Golang gratuito** não precisa começar com promessa exagerada nem terminar em certificado vazio. O que faz alguém aprender Go de verdade é uma sequência simples: entender a linguagem, escrever código todo dia, construir uma API pequena, testar, conectar em banco, empacotar com Docker e ler documentação oficial sem medo.

Esta trilha foi pensada para quem quer aprender Go em português e chegar a um nível útil para backend, DevOps, plataforma ou vagas júnior/pleno. Ela usa os guias do Golang Brasil como base, aponta a documentação certa e organiza os próximos passos em uma ordem prática. Se você quer apenas uma visão geral da linguagem, comece pelo [Go tutorial em português](/aprenda/). Se quer seguir uma sequência de estudo como curso, fique nesta página e avance módulo por módulo.

A proposta é direta: em vez de assistir horas de vídeo passivamente, você vai escrever programas pequenos desde o primeiro dia. Go recompensa prática. A linguagem tem poucas palavras-chave, formatação automática, compilador rápido, biblioteca padrão forte e uma cultura que valoriza código legível. Isso torna o aprendizado mais objetivo do que em stacks cheias de frameworks obrigatórios.

## Para quem este curso de Golang faz sentido

Esta trilha serve para quatro perfis:

1. **Quem já programa e quer migrar para Go**: desenvolvedores Python, Java, JavaScript, PHP, Ruby, C# ou Kotlin que querem aprender uma linguagem forte para backend, infraestrutura e sistemas distribuídos.
2. **Quem está começando no backend**: pessoas que já sabem lógica básica e querem construir APIs, CLIs, workers e serviços pequenos com uma stack enxuta.
3. **Quem trabalha com DevOps ou plataforma**: profissionais que usam Docker, Kubernetes, Terraform, Prometheus ou ferramentas de linha de comando e querem entender por que tanto software de infraestrutura é escrito em Go.
4. **Quem mira vagas Go no Brasil**: estudantes e devs em transição que querem montar base para entrevistas, portfólio e leitura de código real.

Se você nunca programou, ainda dá para começar por Go, mas avance mais devagar. Antes de entrar em concorrência, banco de dados e Docker, garanta que você entende variáveis, funções, tipos, laços, condicionais e erros.

## Pré-requisitos mínimos

Você não precisa comprar curso, assinar plataforma ou instalar um framework grande. Para seguir a trilha, basta:

- um editor de código, como VS Code, GoLand ou Neovim;
- terminal básico;
- Go instalado na máquina;
- Git para versionar os exercícios;
- curiosidade para ler mensagens de erro com calma.

Comece pelo guia de [primeiros passos com Go](/aprenda/primeiros-passos/). Ele cobre instalação, `go version`, `go run`, `go build` e o primeiro programa. Depois leia [Go para iniciantes](/aprenda/go-para-iniciantes/) para fixar a ideia de pacote, função `main`, imports e execução local.

## Módulo 1: fundamentos da linguagem

O primeiro módulo deve responder uma pergunta: “consigo escrever um programa Go pequeno sem copiar tudo?”

Estude nesta ordem:

- variáveis com `var` e `:=`;
- tipos básicos: `string`, `int`, `float64`, `bool`;
- funções com retorno simples e múltiplo;
- `if`, `for` e `switch`;
- arrays, slices e maps;
- structs e métodos;
- ponteiros na prática, sem teoria excessiva.

A melhor forma de treinar é criar programas de terminal. Faça uma calculadora simples, um conversor de temperatura, um contador de palavras, um gerador de senha e um parser de CSV pequeno. Não tente aprender tudo da linguagem antes de escrever código. Em Go, os conceitos aparecem melhor quando você compila e corrige erros reais.

Use também a [cheat sheet de sintaxe Go](/cheatsheet/sintaxe-basica/) como cola rápida. Ela é útil para revisar sintaxe sem interromper o fluxo de prática.

## Módulo 2: módulos, pacotes e organização

Depois dos fundamentos, aprenda como um projeto Go é organizado. O comando `go mod init` cria um módulo; `go mod tidy` limpa dependências; `go test ./...` roda testes; `go fmt ./...` formata tudo.

Leia o guia de [Go Modules](/aprenda/go-modules/) e pratique criando um repositório próprio. Separe uma função em outro pacote, importe esse pacote no `main` e escreva um teste simples. O objetivo não é criar arquitetura sofisticada. É entender import path, módulo, pacote, função exportada e dependência externa.

Uma regra boa para iniciantes: comece simples. Não crie pastas `domain`, `infra`, `application`, `ports` e `adapters` no primeiro exercício. Em Go, uma estrutura pequena e clara vence uma arquitetura copiada de outro ecossistema.

## Módulo 3: erros e leitura de documentação

Go trata erro como valor. Isso parece repetitivo no começo, mas deixa o fluxo explícito:

```go
arquivo, err := os.Open("dados.csv")
if err != nil {
    return fmt.Errorf("abrir arquivo: %w", err)
}
defer arquivo.Close()
```

Estude `error`, `fmt.Errorf`, `%w`, `errors.Is` e `errors.As`. Depois leia o guia de [tratamento de erros em Go](/aprenda/golang-erros/). Aprenda também a consultar a [documentação Go em português](/aprenda/documentacao-go/) para usar `pkg.go.dev`, `go doc` e `go help`.

Este módulo é importante porque a maioria dos problemas reais não vem da sintaxe. Vem de entender biblioteca, contrato de função, erro retornado e comportamento de pacote.

## Módulo 4: API REST com Go

Quando os fundamentos estiverem confortáveis, construa uma API HTTP. Comece com a biblioteca padrão: `net/http`, handlers, rotas simples, JSON e status codes. Depois, se quiser produtividade com roteamento e middleware, veja Gin ou Chi.

Siga o guia de [API REST com Go](/aprenda/api-rest-go/) e implemente:

- `GET /health`;
- `GET /tarefas`;
- `POST /tarefas`;
- `GET /tarefas/{id}`;
- `PUT /tarefas/{id}`;
- `DELETE /tarefas/{id}`.

No começo, use memória. Depois conecte com PostgreSQL no módulo seguinte. O ponto é entender request, response, JSON, validação e separação mínima entre handler e regra de negócio.

## Módulo 5: PostgreSQL e dados reais

Backend sem banco vira exercício incompleto. Use PostgreSQL para persistir dados, aprender migrations, conexão, contexto, timeout e queries parametrizadas.

Leia [Go com PostgreSQL](/aprenda/golang-postgresql/). Crie uma tabela `tarefas`, escreva migrations e substitua o armazenamento em memória da API por operações no banco. Evite concatenar SQL com dados do usuário. Use parâmetros. Teste erro de conexão, registro não encontrado e validação de entrada.

Neste ponto, você já terá um projeto de portfólio mais útil do que dezenas de exercícios isolados: uma API Go com banco real.

## Módulo 6: testes, benchmarks e confiança

Go tem ferramenta de teste integrada. Você não precisa instalar um ecossistema inteiro para começar. Aprenda `testing`, testes de tabela, `httptest`, mocks pequenos por interface e benchmarks.

Siga [Testes em Go](/aprenda/testes-go/) e o guia de [table-driven tests](/blog/testes-tabela-go-guia-table-driven-tests/). Escreva testes para validação, handlers HTTP e camada de dados quando possível. Não busque 100% de cobertura por vaidade. Busque confiança para alterar o código sem medo.

Um bom marco é conseguir rodar:

```bash
go fmt ./...
go test ./...
go vet ./...
```

antes de cada commit.

## Módulo 7: Docker, configuração e deploy

Quando sua API estiver funcionando, empacote com Docker. Go combina muito bem com imagem multi-stage: compila em uma etapa e roda um binário pequeno em outra.

Leia [Go com Docker](/aprenda/golang-docker/) e crie:

- `Dockerfile` multi-stage;
- `docker-compose.yml` com API e PostgreSQL;
- variáveis de ambiente para porta e conexão;
- healthcheck simples;
- README com comandos de execução.

Esse módulo aproxima seu estudo de produção. Vagas de Go raramente pedem apenas sintaxe. Elas pedem serviço rodando, container, logs, banco e entendimento de deploy.

## Módulo 8: concorrência sem exagero

Go é famoso por goroutines e channels, mas concorrência deve entrar depois dos fundamentos. Primeiro entenda funções, erros, API, banco e testes. Depois avance para goroutines, channels, `select`, `context` e `sync.WaitGroup`.

Leia [Concorrência em Go](/aprenda/concorrencia-go/) e depois o tutorial de [worker pool em Go](/blog/worker-pool-go-fila-jobs/). Um bom exercício é criar um worker que processa tarefas pendentes do banco em paralelo, com limite de workers e cancelamento por contexto.

A regra: não use goroutine para parecer avançado. Use para controlar trabalho concorrente com limite, observabilidade e encerramento correto.

## Projeto final do curso

O projeto final recomendado é uma API de tarefas, finanças pessoais, biblioteca, agenda de estudos ou controle de candidaturas. O domínio importa menos que a qualidade técnica. Inclua:

- API REST em Go;
- PostgreSQL;
- migrations;
- testes de handlers e regras;
- Docker Compose;
- logs com `slog`;
- configuração por variável de ambiente;
- README com instruções;
- pelo menos uma rotina concorrente simples, como job de limpeza ou processamento assíncrono.

Se quiser conectar estudo com mercado, transforme o projeto em uma ferramenta de busca de vagas: salve vagas, status da candidatura, empresa, stack, salário e data de follow-up. Depois leia os guias de [primeira vaga Go no Brasil](/carreira/primeira-vaga-go-brasil-2026/), [currículo para desenvolvedor Go](/carreira/curriculo-desenvolvedor-go-2026/) e [salários Go no Brasil](/carreira/salarios-go-brasil/).

## Roteiro de 8 semanas

Uma sugestão realista:

| Semana | Foco | Entrega |
|---|---|---|
| 1 | Instalação, sintaxe, funções | 5 programas pequenos |
| 2 | Slices, maps, structs, erros | CLI simples com arquivos |
| 3 | Módulos, pacotes, documentação | Biblioteca pequena testada |
| 4 | HTTP e JSON | API em memória |
| 5 | PostgreSQL | API persistente |
| 6 | Testes e refatoração | `go test ./...` confiável |
| 7 | Docker e configuração | Projeto rodando com Compose |
| 8 | Concorrência e README | Projeto final publicável |

Se você já programa, pode condensar em duas ou três semanas. Se está começando, transforme cada semana em duas.

## O que estudar depois

Depois deste curso Golang gratuito, avance por interesse:

- APIs profissionais: autenticação, rate limit, paginação e OpenAPI;
- observabilidade: logs, métricas e tracing;
- mensageria: RabbitMQ, Kafka, NATS ou SQS;
- gRPC: contratos fortes entre serviços;
- Kubernetes: deploy de serviços Go em produção;
- performance: profiling, benchmarks e pprof;
- arquitetura: simplicidade, interfaces pequenas e limites claros.

O caminho completo está no [roadmap Go 2026](/aprenda/roadmap-go-2026/). Para comparar Go com outras escolhas, veja [Go vs Python](/aprenda/go-vs-python/), [Go vs Node.js](/aprenda/go-vs-node/) e [Go vs Java](/aprenda/go-vs-java/).

## Conclusão

Aprender Go não exige um curso caro. Exige sequência, prática e projetos que saem do tutorial. Se você seguir esta trilha, escrever código todo dia e terminar uma API com banco, testes e Docker, já terá base para ler projetos reais, contribuir em ferramentas internas e disputar vagas que pedem Golang no Brasil.

Comece pequeno: instale Go, rode o primeiro programa, crie um módulo e faça o primeiro teste passar. Depois repita. Go foi feita para reduzir cerimônia. Use isso a seu favor.