Arquitetura

Arquitetura de Microserviços com Go: Lições Aprendidas

4 min de leitura
Marco Ollivier
GoMicroserviçosArquiteturaBackend

Após anos trabalhando com microserviços em Go em empresas como Nubank e OLX, compartilho aqui as principais lições aprendidas sobre como estruturar, desenvolver e manter sistemas distribuídos robustos.

Por que Go para Microserviços?Link para esta seção

Go se tornou uma escolha natural para microserviços devido a suas características únicas:

  • Performance: Compilação para código nativo e garbage collector eficiente
  • Concorrência: Goroutines e channels facilitam programação concorrente
  • Simplicidade: Sintaxe limpa e curva de aprendizado suave
  • Tooling: Excelente ecossistema de ferramentas

Padrões Arquiteturais EssenciaisLink para esta seção

1. Domain-Driven Design (DDD)Link para esta seção

Estruturar o código seguindo os domínios do negócio:

Go
// internal/domain/user/user.go
type User struct {
    ID       string
    Email    string
    Name     string
    Status   UserStatus
}

type UserRepository interface {
    Save(ctx context.Context, user *User) error
    FindByID(ctx context.Context, id string) (*User, error)
}

2. Hexagonal ArchitectureLink para esta seção

Separar a lógica de negócio dos detalhes de implementação:

Go
// internal/application/user_service.go
type UserService struct {
    repo UserRepository
    eventBus EventBus
}

func (s *UserService) CreateUser(ctx context.Context, cmd CreateUserCommand) error {
    user := NewUser(cmd.Email, cmd.Name)

    if err := s.repo.Save(ctx, user); err != nil {
        return err
    }

    return s.eventBus.Publish(ctx, UserCreatedEvent{UserID: user.ID})
}

Comunicação Entre ServiçosLink para esta seção

HTTP vs gRPC vs MensageriaLink para esta seção

HTTP REST: Ideal para APIs públicas e integrações simples gRPC: Melhor performance para comunicação interna Mensageria: Para eventos assíncronos e desacoplamento

Exemplo com gRPCLink para esta seção

Go
// proto/user/user.proto
service UserService {
    rpc GetUser(GetUserRequest) returns (GetUserResponse);
    rpc CreateUser(CreateUserRequest) returns (CreateUserResponse);
}

// internal/grpc/user_handler.go
func (h *UserHandler) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.GetUserResponse, error) {
    user, err := h.userService.GetUser(ctx, req.UserId)
    if err != nil {
        return nil, status.Errorf(codes.NotFound, "user not found: %v", err)
    }

    return &pb.GetUserResponse{
        User: &pb.User{
            Id:    user.ID,
            Email: user.Email,
            Name:  user.Name,
        },
    }, nil
}

Observabilidade e MonitoramentoLink para esta seção

Structured LoggingLink para esta seção

Go
import "go.uber.org/zap"

logger, _ := zap.NewProduction()
defer logger.Sync()

logger.Info("user created",
    zap.String("user_id", user.ID),
    zap.String("email", user.Email),
    zap.Duration("duration", time.Since(start)),
)

Métricas com PrometheusLink para esta seção

Go
var (
    requestsTotal = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "http_requests_total",
            Help: "Total number of HTTP requests",
        },
        []string{"method", "endpoint", "status"},
    )
)

func init() {
    prometheus.MustRegister(requestsTotal)
}

Testes em MicroserviçosLink para esta seção

Pirâmide de TestesLink para esta seção

  1. Unit Tests: Testam componentes isolados
  2. Integration Tests: Testam interação entre componentes
  3. Contract Tests: Garantem compatibilidade entre serviços
  4. End-to-End Tests: Testam fluxos completos

Exemplo de Test ContainerLink para esta seção

Go
func TestUserRepository(t *testing.T) {
    ctx := context.Background()

    // Inicia container PostgreSQL para teste
    postgres, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
        ContainerRequest: testcontainers.ContainerRequest{
            Image:        "postgres:13",
            ExposedPorts: []string{"5432/tcp"},
            Env: map[string]string{
                "POSTGRES_PASSWORD": "password",
                "POSTGRES_DB":       "testdb",
            },
        },
        Started: true,
    })
    require.NoError(t, err)
    defer postgres.Terminate(ctx)

    // Testa repository com banco real
    repo := NewUserRepository(db)
    user := &User{ID: "123", Email: "test@example.com"}

    err = repo.Save(ctx, user)
    assert.NoError(t, err)
}

Deployment e DevOpsLink para esta seção

Docker Multi-stageLink para esta seção

Dockerfile
## Build stage
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o main ./cmd/api

## Runtime stage
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/main .
CMD ["./main"]

Kubernetes DeploymentLink para esta seção

YAML
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
        - name: user-service
          image: user-service:latest
          ports:
            - containerPort: 8080
          env:
            - name: DATABASE_URL
              valueFrom:
                secretKeyRef:
                  name: db-secret
                  key: url

Lições AprendidasLink para esta seção

1. Comece SimplesLink para esta seção

Não crie microserviços desde o início. Comece com um monólito bem estruturado e extraia serviços conforme necessário.

2. Observabilidade é FundamentalLink para esta seção

Implemente logging, métricas e tracing desde o início. Sem observabilidade, debugar sistemas distribuídos é impossível.

3. Testes de ContratoLink para esta seção

Use ferramentas como Pact para garantir que mudanças em um serviço não quebrem outros.

4. Circuit BreakersLink para esta seção

Implemente circuit breakers para evitar cascata de falhas:

Go
import "github.com/sony/gobreaker"

cb := gobreaker.NewCircuitBreaker(gobreaker.Settings{
    Name:        "external-api",
    MaxRequests: 3,
    Interval:    time.Minute,
    Timeout:     time.Minute * 2,
})

result, err := cb.Execute(func() (interface{}, error) {
    return externalAPI.Call()
})

5. Versionamento de APIsLink para esta seção

Sempre versione suas APIs para permitir evolução sem quebrar clientes:

Go
// v1/user.go
type UserV1 struct {
    ID   string `json:"id"`
    Name string `json:"name"`
}

// v2/user.go
type UserV2 struct {
    ID        string `json:"id"`
    FirstName string `json:"first_name"`
    LastName  string `json:"last_name"`
}

ConclusãoLink para esta seção

Microserviços com Go oferecem uma base sólida para sistemas distribuídos, mas requerem disciplina arquitetural e operacional. As lições compartilhadas aqui foram aprendidas na prática, trabalhando em sistemas de alta escala.

O mais importante é lembrar que microserviços são uma ferramenta, não um objetivo. Use-os quando fizerem sentido para seu contexto específico.