Noções Básicas de Bibliotecas Essenciais

10 exemplos para você começar com Bibliotecas Essenciais - 7 básicos e 3 intermediários.

Pré-requisitos

• Instale o Go 1.26.x ou posterior em go.dev/dl.
• Crie um módulo: mkdir libdemo && cd libdemo && go mod init example.com/libdemo.
• Adicione bibliotecas comuns: go get go.uber.org/zap github.com/stretchr/testify/require github.com/spf13/viper github.com/go-chi/chi/v5.
• Execute os exemplos com go run . após salvar como main.go (ou divida os arquivos no mesmo módulo).

Exemplos Básicos

1. Logger de produção zap

Logs estruturados em JSON com configuração mínima.

package main
 
import (
    "go.uber.org/zap"
)
 
func main() {
    log, _ := zap.NewProduction()
    defer log.Sync()
    log.Info("service ready", zap.String("port", "8080"))
}

• NewProduction define saída JSON, amostragem e padrões sensatos.
• defer log.Sync() descarrega buffers ao desligar (ignore erros em algumas plataformas).
• Prefira injetar *zap.Logger em construtores em vez de estado global.

Relacionado: Logging: zap vs zerolog vs slog - quando escolher zap em vez de slog

2. Handler JSON do slog (alternativa da biblioteca padrão)

Nenhum logger de terceiros é necessário para campos estruturados.

package main
 
import (
    "log/slog"
    "os"
)
 
func main() {
    h := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo})
    slog.SetDefault(slog.New(h))
    slog.Info("ready", "service", "api")
}

• Go 1.21+ inclui log/slog na biblioteca padrão.
• Pares chave-valor seguem o argumento da mensagem.
• Muitas equipes padronizam o slog e mantêm o zap apenas para caminhos de latência crítica.

Relacionado: Logging Estruturado com slog - handlers e migração

3. Asserção testify require

Falhas de teste legíveis sem helpers personalizados.

package user_test
 
import (
    "testing"
    "github.com/stretchr/testify/require"
)
 
func sum(a, b int) int { return a + b }
 
func TestSum(t *testing.T) {
    require.Equal(t, 5, sum(2, 3))
}

• require interrompe o teste em caso de falha (use em pré-condições de configuração).
• Salve isso em user_test.go; testify é apenas para testes, não para código de produção.
• Combine com slices de tests baseados em tabelas para cobertura.

Relacionado: Testando com testify & mockery - suítes e mocks

4. Arquivo de configuração de leitura viper

Carregue padrões YAML com suporte a substituição de ambiente.

package main
 
import (
    "fmt"
    "github.com/spf13/viper"
)
 
func main() {
    viper.SetConfigName("config")
    viper.SetConfigType("yaml")
    viper.AddConfigPath(".")
    _ = viper.ReadInConfig()
    viper.SetDefault("port", 8080)
    fmt.Println(viper.GetInt("port"))
}

• SetDefault aplica-se quando a chave está ausente de todas as fontes.
• Chame viper.AutomaticEnv() para permitir que PORT substitua as chaves port.
• Mantenha as structs de configuração tipadas; viper é para carregar, não para lógica de negócios.

Relacionado: Configuração com viper & envconfig - precedência em camadas

5. Roteador chi com uma rota

Roteamento HTTP compatível com a biblioteca padrão.

package main
 
import (
    "net/http"
    "github.com/go-chi/chi/v5"
)
 
func main() {
    r := chi.NewRouter()
    r.Get("/ping", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("pong"))
    })
    http.ListenAndServe(":8080", r)
}

• chi.NewRouter() retorna um http.Handler.
• Handlers usam assinaturas padrão ResponseWriter e Request.
• Adicione middleware com r.Use antes de registrar rotas.

Relacionado: chi: Roteamento e Middleware Leves - grupos de rotas

6. Parâmetro de URL chi

Segmentos de caminho nomeados sem tipos de contexto de framework.

r.Get("/users/{id}", func(w http.ResponseWriter, r *http.Request) {
    id := chi.URLParam(r, "id")
    w.Write([]byte("user " + id))
})

• {id} captura um segmento; valide antes de consultas ao banco de dados.
• String vazia significa que o parâmetro não foi definido neste padrão de rota.
• Documente os nomes dos parâmetros no OpenAPI ou em tabelas de rotas.

7. Vinculação de variável de ambiente viper

Mapeie DATABASE_URL para um campo de configuração tipado.

viper.SetEnvPrefix("APP")
viper.BindEnv("database_url")
viper.AutomaticEnv()
dsn := viper.GetString("database_url")
_ = dsn

• SetEnvPrefix cria um namespace para chaves de ambiente (APP_DATABASE_URL).
• Vincule chaves explícitas quando o mapeamento automático for ambíguo.
• Falhe rapidamente em main quando segredos necessários estiverem vazios.

Exemplos Intermediários

8. Logger sugared zap para estilo printf

SugaredLogger troca um pouco de desempenho por ergonomia.

log, _ := zap.NewDevelopment()
defer log.Sync()
sugar := log.Sugar()
sugar.Infof("listening on %s", ":8080")

• Prefira log.Info("listening", zap.String("addr", addr)) estruturado em caminhos de alta frequência.
• A configuração de desenvolvimento usa codificação de console para legibilidade local.
• Injete *zap.Logger e chame .Sugar() apenas em limites legados.

9. Esqueleto de suíte testify

Agrupe testes relacionados com hooks de configuração compartilhados.

import (
    "testing"
    "github.com/stretchr/testify/suite"
)
 
type UserSuite struct{ suite.Suite }
 
func (s *UserSuite) TestCreate() {
    s.Equal(1, 1)
}
 
func TestUserSuite(t *testing.T) {
    suite.Run(t, new(UserSuite))
}

• SetupTest / TearDownTest executam antes e depois de cada método de teste.
• Suítes ajudam testes de integração HTTP com servidores httptest compartilhados.
• Não substitua testes unitários baseados em tabelas onde suítes adicionam cerimônia.

Relacionado: testify, httptest & Test Doubles - duplos e httptest

10. Middleware chi mais log de requisição zap

Componha bibliotecas focadas na borda HTTP.

import (
    "net/http"
    "time"
    "github.com/go-chi/chi/v5/middleware"
    "go.uber.org/zap"
)
 
func requestLog(log *zap.Logger) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            start := time.Now()
            ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
            next.ServeHTTP(ww, r)
            log.Info("request",
                zap.String("method", r.Method),
                zap.String("path", r.URL.Path),
                zap.Int("status", ww.Status()),
                zap.Duration("latency", time.Since(start)),
            )
        })
    }
}

• WrapResponseWriter do chi captura códigos de status para logs de acesso.
• Mantenha o middleware mais externo: recuperação, logging, depois autenticação.
• Passe r.Context() para chamadas downstream para cancelamento.

Relacionado: Bibliotecas Cliente Prometheus & OpenTelemetry - métricas ao lado de logs

Versões da Stack: Esta página foi escrita para Go 1.26.x (padrão GC Green Tea, go fix modernizadores - verifique o patch na compilação), chi (mais recente - verifique na compilação), gin (mais recente - verifique na compilação), echo (mais recente - verifique na compilação), google.golang.org/grpc (mais recente - verifique na compilação), sigs.k8s.io/controller-runtime (mais recente - verifique na compilação), kubebuilder (mais recente - verifique na compilação), tinygo (mais recente - verifique os alvos de placa na compilação), wazero (mais recente - verifique na compilação) e golangci-lint (mais recente - verifique o conjunto de linters na compilação). pbqrthvqrf.vb|ptvb510|202607