GoFastAPI.
Uma experiência de desenvolvimento inspirada no FastAPI, construída sobre net/http. Rotas expressivas, contexto, middleware, DI e OpenAPI — com interoperabilidade com o ecossistema Go.
Visão geral
GoFastAPI procura remover boilerplate sem esconder o modelo de execução do Go. A aplicação pode ser utilizada como framework ou integrada em um servidor existente por meio de app.Handler(), que retorna um http.Handler.
Experiência de alto nível
Registro declarativo de rotas, respostas, dependências, grupos e metadados OpenAPI.
Interoperabilidade
Handlers e middleware continuam compatíveis com interfaces padrão da biblioteca HTTP do Go.
Eficiência consciente
Context lazy e handlers idiomáticos sem reflexão no hot path. Handlers genéricos tipados usam reflexão em execução.
Operação integrada
Servidor, TLS/mTLS, graceful shutdown, health checks e supervisor multiprocesso com limites conhecidos.
Quick start
Adicione o módulo ao seu projeto:
go get github.com/Romario-Francisco-Soares/GoFastApi@latest
package main
import (
"log"
gofast "github.com/Romario-Francisco-Soares/GoFastApi"
)
func main() {
app := gofast.New(
gofast.Title("Minha API"),
gofast.Version("1.0.0"),
gofast.Description("API de produção em Go, sem boilerplate"),
)
// Middleware de produção em uma linha
app.Use(gofast.Recovery(nil)) // panic → 500, sem expor stack
app.Use(gofast.RequestID("")) // X-Request-ID para rastreamento
app.Use(gofast.CORS(gofast.CORSConfig{ // CORS com preflight
AllowOrigins: []string{"*"},
AllowMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
}))
app.Use(gofast.Compression()) // gzip automático
app.Use(gofast.Timeout(10 * time.Second)) // timeout por requisição
// Rotas com agrupamento (prefixo, tags, dependências compartilhadas)
usuarios := app.Group("/usuarios", gofast.GroupTags("usuarios"))
usuarios.GET("/{id}", func(ctx *gofast.Context) (any, error) {
return gofast.OK(map[string]string{"id": ctx.Param("id")}), nil
})
usuarios.POST("/", func(ctx *gofast.Context) (any, error) {
return gofast.Created(map[string]string{"status": "criado"}), nil
})
// Método HTTP arbitrário
app.Route("PROPFIND", "/arquivos/{id}", func(ctx *gofast.Context) (any, error) {
return gofast.OK(map[string]string{"method": "PROPFIND"}), nil
})
// DI com escopos: Singleton, Request, Transient
app.Provide(novoBanco, gofast.Singleton())
// Background tasks executadas após o flush da resposta
app.POST("/emails", func(ctx *gofast.Context) (any, error) {
ctx.BackgroundTasks().Add(func() {
// envia e-mail após a resposta ir para o cliente
})
return gofast.OK(map[string]bool{"aceito": true}), nil
})
cfg := gofast.DefaultServerConfig()
cfg.Addr = ":8000"
cfg.Workers = 4 // supervisor multiprocesso nativo
cfg.GracefulTimeout = 30 * time.Second
log.Fatal(app.Run(cfg))
}
Execute o exemplo no repositório com go run ./cmd/server. Por padrão a aplicação registra:
| Rota | Descrição |
|---|---|
/openapi.json | Documento OpenAPI 3.1 básico. |
/docs | Interface Swagger UI. |
/redoc | Interface ReDoc. |
/health/live | Verifica liveness. |
/health/ready | Verifica readiness e checkers cadastrados. |
Arquitetura
A estrutura deste snapshot é um pacote raiz gofast e subpacotes especializados:
| Componente | Arquivos principais |
|---|---|
| Aplicação / runtime | app.go, server.go, supervisor.go, cli.go |
| Roteador / context | router.go, context.go, binding.go |
| DI / respostas / erros | di.go, response.go, errors.go |
| Auth / sessão | security.go, session.go |
| Streaming / tarefas | websocket.go, streaming.go, background.go |
| Operação / testes | health.go, otel.go, static.go, testclient.go |
| Observabilidade | observability/observability.go |
| Configuração | config/config.go |
| Hot reload | hotreload/hotreload.go |
| Middleware | middleware/*.go, middleware_root.go |
Rotas e grupos
App aceita GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD, TRACE, WebSocket e Route() para métodos HTTP arbitrários. O sub-router oferece Group() com prefixo, tags e dependências compartilhadas, e AddRoute.
router := gofast.NewRouter()
users := router.Group("/users", gofast.GroupTags("users"))
users.GET("/{id}", func(ctx *gofast.Context) (any, error) {
return gofast.OK(map[string]string{"id": ctx.Param("id")}), nil
})
app.Include(router, gofast.IncludeOption{Prefix: "/v1"})
app.Mount("/static", gofast.NewStaticFiles("./public"))
- Rotas estáticas usam índice por método/caminho.
- Rotas dinâmicas usam trie de segmentos para busca O(M) por segmento — sem varredura linear com regex.
{id}captura segmento único;{filepath:path}captura o restante (incluindo barras).- GET responde HEAD com o corpo suprimido.
- 405/Allow é gerado quando caminho existe, mas o método não.
- Middlewares por rota são pré-compilados no registro, não reconstruídos por requisição.
Context e binding
O Context é o wrapper de requisição do GoFastAPI, equivalente ao Request do FastAPI. Ele oferece:
| Método | Descrição |
|---|---|
Request() | Retorna o *http.Request subjacente. |
ResponseWriter() | Retorna o http.ResponseWriter. |
Context() | Retorna o context.Context para cancelamento e deadlines. |
Param(key) | Retorna um parâmetro de caminho capturado pelo router. |
SetParam(key, val) | Define um parâmetro de caminho. |
Query(key) | Retorna um parâmetro de query string. |
QueryArray(key) | Retorna múltiplos valores de um parâmetro de query. |
Header(key) | Retorna um cabeçalho HTTP. |
Cookie(name) | Retorna um cookie pelo nome. |
Session() | Retorna a sessão da requisição (cookie encriptado/assinado). |
State() | Retorna o estado lazy da requisição. |
Resolve(t) | Resolve uma dependência DI pelo tipo. |
JSON(v) | Decodifica o corpo JSON da requisição para um alvo. |
Body() | Retorna o corpo da requisição como bytes. |
FormValue(key) | Retorna um valor de formulário. |
FormFile(key) | Retorna um arquivo enviado via multipart/form-data. |
RemoteAddr() | Retorna o endereço IP remoto. |
SetHeader(k, v) | Define um cabeçalho de resposta (lazy allocation). |
SetStatus(code) | Define o código de status da resposta. |
Write(data) / WriteString(s) | Escreve dados na resposta. |
type CreateItem struct {
Name string `json:"name"`
}
func (p *CreateItem) Validate() error {
if strings.TrimSpace(p.Name) == "" {
return errors.New("name is required")
}
return nil
}
app.POST("/items", func(ctx *gofast.Context, input CreateItem) (any, error) {
return gofast.Created(map[string]string{"name": input.Name}), nil
})
O binding tipado suporta um corpo JSON por handler com struct/map/slice/interface conforme a assinatura compilada e permite Validate() error. Assinaturas genéricas fazem reflect.Call em cada requisição. Binding manual permanece disponível pelos helpers do Context.
Injeção de dependências
Cada aplicação possui seu próprio container DI (não global).
type UserService struct{}
func NewUserService() *UserService { return &UserService{} }
app.Provide(NewUserService, gofast.Singleton())
app.GET("/me", func(ctx *gofast.Context, svc *UserService) (any, error) {
return gofast.OK(map[string]string{"state": "ready"}), nil
}, gofast.RouteOption{
Dependencies: []gofast.Depends{{Dependency: (*UserService)(nil)}},
})
| Escopo | Semântica |
|---|---|
Singleton() | Uma instância por container/processo, inicialização lazy sincronizada com sync.Once. |
Request() | Uma instância por contexto/requisição (armazenada em ctx.state). |
Transient() | Nova instância por resolução. |
Providers podem retornar T, (T, error), (T, func()) ou (T, func() error). Dependências cíclicas são detectadas. Cleanups request/transient são executados ao fim da requisição e cleanups singleton no fechamento da aplicação. Overrides devem ocorrer durante o startup/configuração.
Respostas e erros
Tipos disponíveis:
| Tipo | Descrição |
|---|---|
OK(data) | Resposta JSON 200. |
Created(data) | Resposta JSON 201 Created. |
NewJSONResponse(data, status) | Resposta JSON com status customizado. |
NewTextResponse(content, status) | Resposta texto simples. |
NewHTMLResponse(content) | Resposta HTML. |
NewFileResponse(path, mediaType, filename, headers) | Resposta de arquivo. |
NewRedirectResponse(url, status) | Resposta de redirecionamento. |
NewStreamResponse(stream) | Resposta de streaming genérico. |
NewEmptyResponse() | Resposta vazia 204 No Content. |
app.GET("/redirect", func(ctx *gofast.Context) (any, error) {
return gofast.NewRedirectResponse("/docs", http.StatusTemporaryRedirect), nil
})
app.GET("/private", func(ctx *gofast.Context) (any, error) {
return nil, gofast.NewHTTPError(403, "forbidden", "access denied")
})
Erros podem ser tratados com HTTPError, ValidationError e app.OnError(typeOrPredicate, handler).
Middleware
O tipo base é func(http.Handler) http.Handler. Registre middleware global com app.Use(...); o router também permite middleware e herança em grupos.
| Componente | Descrição / status |
|---|---|
| AccessLog | Log estruturado; não inclui secrets/body. |
| Compression | Gzip baseado em Accept-Encoding. |
| CORS | Origins/métodos/headers, preflight, credentials e Vary. |
| BodyLimit | Limita tamanho de body. |
| ConcurrencyLimit | Limita simultaneidade no handler. |
| MaxConnections | Limite por middleware; também há ConnState no modo single. |
| Proxy / TrustedHost | Headers de proxy confiáveis, root/base path e allowlist de hosts. |
| HTTPSRedirect | Redirecionamento para HTTPS. |
| Recovery | Recuperação de panic → 500 sem expor stack ao cliente. |
| RequestID | Identificação de requisição (X-Request-ID) para rastreamento. |
| Timeout | Timeout por contexto com 503 Service Unavailable. |
| RateLimit | Token bucket em memória por IP, configurado por RateLimit("100/minute"). |
app.Use(gofast.Recovery(nil))
app.Use(gofast.RequestID(""))
app.Use(gofast.CORS(gofast.CORSConfig{
AllowOrigins: []string{"*"},
AllowMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
}))
app.Use(gofast.Compression())
app.Use(gofast.Timeout(10 * time.Second))
Sessões e segurança
Cookie de sessão AES-GCM
app.Use(gofast.SessionMiddleware(gofast.SessionConfig{
Secret: os.Getenv("SESSION_SECRET"),
CookieName: "session",
HTTPOnly: true,
Secure: true,
SameSite: http.SameSiteLaxMode,
}))
A sessão é stateless e armazenada em cookie autenticado/cifrado AES-GCM, limitada em tamanho. Use segredo aleatório e de alta entropia, fora do repositório. Em produção HTTPS, configure Secure/HTTPOnly/SameSite conforme seu modelo de ameaça.
Autenticação
O pacote raiz fornece APIKey (header/query/cookie), HTTPBearer, HTTPBasic e OAuth2Bearer com callbacks de validação. Os dados do usuário autenticado ficam em ctx.Principal().
app.Use(gofast.APIKey(gofast.APIKeyConfig{
Name: "X-API-Key",
In: gofast.APIKeyHeader,
Secret: "super-secret-key",
}))
app.Use(gofast.HTTPBearer(gofast.BearerConfig{
Secret: "test-token",
}))
app.Use(gofast.HTTPBasic(gofast.BasicConfig{
Username: "user",
Password: "pass",
}))
Validação de tokens é delegada a um provedor/callback externo. Não há servidor OAuth2, emissão de JWT, refresh tokens ou autenticação OIDC completa.
OpenAPI e documentação
app.OpenAPI() gera um objeto OpenAPI 3.1 básico. Use RouteOption para informar tags, summary, description, operation ID, responses, deprecated e security. Registre schemes com app.AddSecurityScheme.
Rotas internas: /openapi.json, /docs e /redoc.
app.AddSecurityScheme("BearerAuth", gofast.SecurityScheme{
Type: "http",
Scheme: "bearer",
BearerFormat: "JWT",
Description: "Autenticação via Bearer token JWT",
})
app.AddSecurityScheme("ApiKey", gofast.APIKeyScheme("X-API-Key", gofast.APIKeyHeader, "API Key no header"))
WebSocket e streaming
WebSocket oferece handshake/upgrade e frames básicos de texto, binário, JSON, ping/pong, close, limites e deadlines. Não há fragmentação completa, subprotocolos, extensões de compressão nem política de Origin configurável integrada.
app.GET("/ws", func(ctx *gofast.Context, conn gofast.WebSocketConn) error {
for {
msg, err := conn.ReadJSON()
if err != nil {
return err
}
if err := conn.WriteJSON(msg); err != nil {
return err
}
}
})
SSE e streaming genérico são fornecidos por SSE, SSEWithHeartbeat, WriteEvent, Stream e StreamWithContentType. Em deploy, ajuste os timeouts do servidor e do reverse proxy para conexões longas.
Background tasks
app.POST("/emails", func(ctx *gofast.Context) (any, error) {
ctx.BackgroundTasks().Add(func() {
// tarefa curta após o flush da resposta
})
return gofast.OK(map[string]bool{"queued": true}), nil
})
As tarefas são em processo, executadas sequencialmente após o flush da resposta no ciclo de atendimento. Erros/panics são logados. Não existe persistência, retry durável ou distribuição; utilize uma fila externa para tarefas críticas.
Health checks
app.Health().RegisterChecker("database", func() error {
return db.PingContext(context.Background())
})
// Marque readiness conforme o lifecycle da aplicação.
app.OnStart(func(ctx context.Context) error {
app.Health().SetReady(true)
return nil
})
/health/live verifica liveness; /health/ready consulta readiness e checkers registrados. Checkers externos devem ser rápidos e aplicar seus próprios timeouts.
Servidor e configuração
cfg := gofast.DefaultServerConfig()
cfg.Addr = ":8000"
cfg.ReadHeaderTimeout = 5 * time.Second
cfg.IdleTimeout = 75 * time.Second
cfg.GracefulTimeout = 30 * time.Second
cfg.Workers = 1
if err := app.Run(cfg); err != nil {
log.Fatal(err)
}
Single-process usa net/http.Server, bloqueia até shutdown/erro, suporta TCP/UDS/FD, TLS e mTLS, timeouts HTTP, keep-alive, limites, proxy headers e trusted hosts. App.Serve(ctx, listener) permite listener externo e cancelamento por contexto.
Configuração suportada e limites
| Recurso | Estado |
|---|---|
| Timeouts HTTP / MaxHeaderBytes / Keep-Alive | Implementado |
| TLS e client CA / mTLS no single process | Implementado |
| MaxConnections / ConcurrencyLimit / MaxBodyBytes | Implementado |
| Proxy headers / TrustedHosts | Implementado |
| HTTP/2 / h2c | Implementado |
| Hot reload | Implementado |
| Backlog / ReusePort | Campo sem efeito |
| EnvPrefix / ConfigFile / AppEnvFile | Não implementado |
| AccessLogColors / AccessFormatter / ErrorLogger | Não integrado |
| Workers + TLS por worker | Implementado |
Run retorna erro explícito para configurações inválidas. O CLI dev inicia em modo debug com hot reload.Workers e Supervisor
Com Workers > 1, o Supervisor inicia processos filhos, herda o listener por file descriptor e usa um pipe de prontidão (FD) antes de considerar o worker iniciado. Oferece restart policy, backoff, limite de reinicializações, PID file, limite de requests e shutdown controlado.
O health monitor verifica se o processo ainda existe (sinal 0). Não há heartbeat periódico nem detecção de processo vivo porém travado. O modo é multiprocesso; não é pool de goroutines. Cada worker termina TLS independentemente quando TLS está configurado.
CLI integrada
O CLI é executado dentro da aplicação que já foi construída por meio de app.RunCLI(os.Args[1:]) ou gofast.RunCLI(app, args). Ele não é um carregador genérico de projetos a partir de um caminho de arquivo.
| Comando | Comportamento |
|---|---|
run | Inicia o servidor com endereço, workers e nível de log configuráveis. |
dev | Inicia com log debug e hot reload. |
openapi | Imprime ou exporta o documento OpenAPI. |
routes | Lista método, caminho e operation ID/summary. |
version | Exibe a versão reportada pelo CLI. |
health | Avalia liveness, readiness e health checkers registrados. |
func main() {
app := buildApp()
os.Exit(app.RunCLI(os.Args[1:]))
}
Testes e benchmarks
NewTestClient(app) cria um httptest.Server real em loopback, mantém cookies e oferece Get, PostJSON, PostForm, PostMultipart, NewRequest e Do. Não possui client WebSocket/SSE especializado.
go test ./...
go test -race ./...
go vet ./...
go test ./... -cover
go test -run=^$ -bench=. -benchmem
go test -run=^$ -fuzz=FuzzTrieLookup -fuzztime=10s
O projeto contém fuzz targets para extração de parâmetros, parser do rate limit e lookup da trie, além de microbenchmarks para handler nativo e rotas GoFastAPI. Na validação deste snapshot, go test, go test -race e go vet passaram.
| Microbenchmark | ns/op | B/op | allocs/op |
|---|---|---|---|
| HTTP handler direto | 2.330 | 1.232 | 16 |
| GoFastAPI estática | 2.571 | 1.488 | 19 |
| GoFastAPI dinâmica | 2.914 | 2.416 | 23 |
| GoFastAPI JSON | 1.015 | 352 | 9 |
Ambiente desta medição interna em memória: Linux/AMD64, Go 1.23.2, Intel Xeon Platinum 8573C, GOMAXPROCS=2, quota cgroup de 2 CPUs e limite de RAM de 4 GiB. Estes microbenchmarks não são a mesma bateria nem o mesmo ambiente dos benchmarks HTTP comparativos apresentados na seção Performance comparativa; não representam RPS TCP.
Observabilidade
O pacote observability fornece métricas e instrumentação para a aplicação GoFastAPI, sem dependências externas:
| Componente | Descrição |
|---|---|
Counter | Contador monotônico seguro para uso concorrente (ex: requisições totais, panics). |
Gauge | Medidor sobe/desce via operações atômicas (ex: requisições em voo). |
Histogram | Registra medições de duração/tamanho com estatísticas básicas (contagem, soma, min, max, média, buckets). |
Metrics | Agregador de RequestsTotal, RequestsDuration, RequestsInFlight, ResponsesByStatus e PanicsTotal. |
Observability | Encapsula métricas com flag enabled e middleware de instrumentação. |
O middleware de observabilidade captura automaticamente:
- Total de requisições por método, rota e status.
- Duração de cada requisição (histograma em nanossegundos).
- Requisições em voo (in-flight) em tempo real.
- Total de panics recuperados.
import "github.com/Romario-Francisco-Soares/GoFastApi/observability"
obs := observability.NewObservability(true)
app.Use(obs.Middleware())
Configuração
O pacote config fornece carregamento de configuração com precedência explícita:
- Defaults — valores padrão do
ServerConfig. - Arquivo — JSON com campos explicitamente definidos.
- Variáveis de ambiente — prefixo
GOFAST_(ex:GOFAST_ADDR,GOFAST_WORKERS). - CLI — overrides da linha de comando (última prioridade).
import "github.com/Romario-Francisco-Soares/GoFastApi/config"
cfg := config.MustLoad(
config.WithEnvPrefix("GOFAST_"),
config.WithConfigFile("config.json"),
config.WithCLIOverrides(map[string]any{"Workers": 4}),
)
app.Run(*cfg)
Variáveis de ambiente são mapeadas por reflection nos campos de ServerConfig (strings, inteiros, booleanos, floats e slices de string). Campos não definidos via env mantêm o valor do nível anterior na precedência.
Hot Reload
O pacote hotreload fornece recarga automática do servidor quando arquivos .go são modificados. Útil para desenvolvimento (modo dev):
import "github.com/Romario-Francisco-Soares/GoFastApi/hotreload"
reloader := hotreload.NewHotReloader(app, []string{"."}, 1*time.Second)
reloader.Start()
defer reloader.Stop()
Quando cfg.Reload = true é definido no ServerConfig, o App.Run() inicia automaticamente o hot reloader, que monitora arquivos .go nos diretórios configurados, recompila o pacote main com go build e inicia um novo processo com o binário atualizado. Se a compilação falhar, o servidor atual continua atendendo.
Performance comparativa: Go vs GoFastAPI vs FastAPI
Uma comparação da capacidade de processamento, latência e memória das três implementações em um endpoint HTTP equivalente. O objetivo é mostrar o custo da camada de abstração da GoFastAPI em relação ao Go nativo e contextualizar sua vantagem de execução frente ao FastAPI Python.
Ambiente e configuração da bateria HTTP
1 núcleo dedicado ao processo servidor e 1 núcleo dedicado ao gerador de carga. A quota total do ambiente permaneceu em 2 vCPUs.
1 processo/worker por implementação. Go e GoFastAPI com GOMAXPROCS=1; Uvicorn com --workers 1.
HTTP/1.1 com Keep-Alive. Mesmo endpoint e payload JSON equivalente nas três implementações.
Rodadas de aproximadamente 4 segundos após aquecimento. Concorrências de 1 a 256 em rodada aquecida; 512 a 2.048 em rodadas separadas de estresse.
| Stack | Versão registrada | Configuração |
|---|---|---|
| Go / GoFastAPI | Go 1.23.2 | 1 processo; GOMAXPROCS=1 |
| FastAPI | FastAPI 0.128.2 | 1 worker Uvicorn |
| Servidor Python | Starlette 0.50.0; Uvicorn 0.48.0 | HTTP/1.1; Keep-Alive |
| Serialização / runtime Python | Pydantic 2.13.5; uvloop 0.22.1; httptools 0.8.0 | Dependências registradas na rodada |
A comparação isola o custo básico de receber uma requisição, localizar a rota, executar o handler, serializar o JSON e responder. Não inclui banco de dados, TLS, autenticação, validação complexa, chamadas externas ou múltiplos workers.
Resultados de throughput
Quantidade de requisições processadas por segundo, em milhares de req/s. Os valores da tabela refletem as medições registradas durante a bateria de testes de desempenho.
| Concorrência | Go puro (mil req/s) | GoFastAPI (mil req/s) | FastAPI (mil req/s) |
|---|---|---|---|
| 1 | 14.79 | 12.77 | 6.19 |
| 32 | 63.21 | 53.42 | 15.17 |
| 128 | 63.03 | 54.07 | 15.79 |
| 256 | 58.53 | 54.27 | 17.02 |
| 512 | 40.70 | 39.48 | 14.77 |
| 1.024 | 34.63 | 31.00 | 12.39 |
| 2.048 | 24.36 | 28.48 | 11.45 |
Latência P95
| Concorrência | Go puro | GoFastAPI | FastAPI |
|---|---|---|---|
| 1 | 0.120 ms | 0.129 ms | 0.225 ms |
| 32 | 1.097 ms | 1.355 ms | 2.719 ms |
| 128 | 4.282 ms | 5.297 ms | 10.679 ms |
| 256 | 7.941 ms | 9.351 ms | 22.406 ms |
| 512 | 21.621 ms | 21.816 ms | 51.148 ms |
| 1.024 | 42.355 ms | 55.260 ms | 131.155 ms |
| 2.048 | 139.589 ms | 116.473 ms | 277.159 ms |
Consumo de memória RAM
| Implementação | RSS observado | Limite do contêiner |
|---|---|---|
| Go puro | 12–17 MB | 4 GiB |
| GoFastAPI | 12–17 MB | 4 GiB |
| FastAPI Python | 107–110 MB | 4 GiB |
O FastAPI utilizou aproximadamente 7 a 9 vezes mais RSS que as implementações Go, considerando os intervalos observados.
Status e roadmap
| Área | Status | Observação |
|---|---|---|
| HTTP routing, groups e mounts | Concluído | Índice estático e trie dinâmica. |
| Context lazy e DI scopes | Concluído | DI por app, ciclo detectado, cleanup. |
| Responses e middleware | Concluído | Dentro das APIs descritas nesta referência. |
| OpenAPI schemas | Parcial | Sem inferência completa de tipos Go. |
| Supervisor | Parcial | Sem heartbeat ativo; TLS multiprocesso disponível. |
| WebSocket | Básico | Sem fragmentação/subprotocol/extensões. |
| OpenTelemetry | Scaffold | Tracer/meter no-op; sem exporter. |
| Hot reload | Concluído | Polling de arquivos .go com reinicialização automática. |
| HTTP/2 / h2c | Implementado | Via http2.ConfigureServer. |
| TLS multiprocesso | Implementado | Cada worker termina TLS independentemente. |
| Servidor OAuth2/JWT | Ausente | Validação de token delegada a callback. |
| Background queue durável | Ausente | Background tasks são in-process. |
Próximas prioridades
- Heartbeat e detecção de worker bloqueado; TLS multiprocesso aprimorado.
- OpenTelemetry SDK/exporters e schemas OpenAPI gerados de forma explícita.
- Completar binding declarativo sem penalizar handlers simples.
- Expandir WebSocket, TestClient e benchmarks de integração.
Para o status detalhado e a rastreabilidade entre requisito e arquivo, consulte SDD_GoFastAPI_Production_Server.md.