Microsserviços em Go: por onde começar e não desistir

Por que Go é a melhor escolha para microsserviços (e quando não é)

Imagine que você está construindo um shopping center. Em vez de erguer um único edifício gigante, você constrói pavilhões separados: uma cafeteria, uma livraria, um supermercado. Cada um funciona por si só, mas juntos formam um complexo único. O elevador quebrou em algum lugar? A livraria continua funcionando. Acabaram os copos na cafeteria? Fechamos apenas ela, não o complexo inteiro.

Isso é a arquitetura de microsserviços. E Go (Golang) é o material ideal para construir esses "pavilhões". Por quê?

• Início rápido: compilação em um único binário. Sem JDK, máquinas virtuais ou node_modules.
• Desempenho: Go funciona no nível do C++, mas é escrito como Python.
• Concorrência embutida: goroutines e channels são o superpoder para processar centenas de requisições por segundo.
• Simplicidade: Go é intencionalmente limitado. Não tinha genéricos (até Go 1.18), não tem herança. O código é lido como um manual de aspirador de pó — fica claro imediatamente o que cada linha faz.

Mas também há desvantagens. Go não é adequado se você precisar de:

• Herança pesada de classes (aqui não existe).
• Uma enorme quantidade de bibliotecas prontas para qualquer tarefa (o ecossistema é mais pobre que o do Java ou Python).
• Tipagem dinâmica (Go é fortemente tipado, você terá que escrever mais boilerplate).

Se o seu projeto é uma API de alta carga, um backend para chat, um gateway de pagamento ou um sistema de monitoramento — Go é a sua escolha. Se você está escrevendo um protótipo em um fim de semana e não se importa com velocidade — use Python.

Etapa 1. Arrumando a mala: ferramentas e estrutura do projeto

O que instalar

Antes de escrever código, vamos configurar o ambiente. Você vai precisar de:

• Go (versão 1.21+). Baixe em go.dev.
• Docker (para conteinerização).
• curl ou Postman (para testar a API).
• Qualquer IDE: GoLand, VS Code com plugin Go, Vim. Recomendo VS Code — gratuito e prático.

Estrutura correta de pastas

Vamos combinar desde já: nada de bagunça. Aqui está a estrutura padrão para um microsserviço em Go:

/user-service├── cmd/│   └── server/│       └── main.go        # ponto de entrada├── internal/│   ├── handler/           # manipuladores HTTP│   ├── service/           # lógica de negócios│   ├── repository/        # trabalho com BD│   └── model/             # estruturas de dados├── pkg/│   └── middleware/        # utilitários comuns├── Dockerfile├── go.mod└── go.sum

Por que assim? Go é uma linguagem onde a estrutura de pastas dita a arquitetura. cmd/ é o ponto de entrada. internal/ é tudo que não pode ser importado de fora (proteção contra tolos). pkg/ é o que pode ser compartilhado com outros serviços.

Etapa 2. Escrevendo o primeiro microsserviço: Hello, World! 2.0

Vamos escrever um servidor HTTP simples em Go que retorna JSON. Este será nosso "microsserviço de saudações".

Passo 1. Inicialização do módulo

mkdir hello-servicecd hello-servicego mod init github.com/seu-usuario/hello-service

Passo 2. Escrevendo main.go

package main

import (    "encoding/json"    "log"    "net/http"    "time")

// GreetingResponse — estrutura de respostatype GreetingResponse struct {    Message   string `json:"message"`    Timestamp string `json:"timestamp"`}

func greetHandler(w http.ResponseWriter, r *http.Request) {    // Define os cabeçalhos    w.Header().Set("Content-Type", "application/json")    w.WriteHeader(http.StatusOK)

    // Cria a resposta    response := GreetingResponse{        Message:   "Olá, microsserviços!",