Framework HTTP para Go

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.

Estado do projeto. GoFastAPI é uma biblioteca Go completa para construção de APIs HTTP, com paridade funcional com FastAPI e servidor de produção inspirado em Uvicorn — tudo em um único binário Go autocontido.
net/httpBase HTTP nativa do Go
TrieRotas dinâmicas indexadas por segmento
3 scopesSingleton, Request e Transient
WorkersSupervisor multiprocesso nativo
TLS/mTLSCertificados e clientes autenticados
Hot ReloadRecarga automática em desenvolvimento

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:

RotaDescrição
/openapi.jsonDocumento OpenAPI 3.1 básico.
/docsInterface Swagger UI.
/redocInterface ReDoc.
/health/liveVerifica liveness.
/health/readyVerifica readiness e checkers cadastrados.

Arquitetura

A estrutura deste snapshot é um pacote raiz gofast e subpacotes especializados:

ComponenteArquivos principais
Aplicação / runtimeapp.go, server.go, supervisor.go, cli.go
Roteador / contextrouter.go, context.go, binding.go
DI / respostas / errosdi.go, response.go, errors.go
Auth / sessãosecurity.go, session.go
Streaming / tarefaswebsocket.go, streaming.go, background.go
Operação / testeshealth.go, otel.go, static.go, testclient.go
Observabilidadeobservability/observability.go
Configuraçãoconfig/config.go
Hot reloadhotreload/hotreload.go
Middlewaremiddleware/*.go, middleware_root.go
1 · Requestnet/http recebe conexão
2 · Routeríndice estático ou trie dinâmica
3 · Contextcontexto e DI da requisição
4 · Handlerresultado e response HTTP

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étodoDescriçã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.

Não é Pydantic: tags arbitrárias, aliases, defaults e binding automático integral de header/cookie/form/file ainda não estão implementados.

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)}},
})
EscopoSemâ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:

TipoDescriçã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.

ComponenteDescrição / status
AccessLogLog estruturado; não inclui secrets/body.
CompressionGzip baseado em Accept-Encoding.
CORSOrigins/métodos/headers, preflight, credentials e Vary.
BodyLimitLimita tamanho de body.
ConcurrencyLimitLimita simultaneidade no handler.
MaxConnectionsLimite por middleware; também há ConnState no modo single.
Proxy / TrustedHostHeaders de proxy confiáveis, root/base path e allowlist de hosts.
HTTPSRedirectRedirecionamento para HTTPS.
RecoveryRecuperação de panic → 500 sem expor stack ao cliente.
RequestIDIdentificação de requisição (X-Request-ID) para rastreamento.
TimeoutTimeout por contexto com 503 Service Unavailable.
RateLimitToken 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"))
Schema limitado: a biblioteca ainda não infere completamente request/response schemas dos tipos Go. ResponseModel não gera JSON Schema automaticamente; callbacks, webhooks e exemplos automáticos não estão implementados.

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

RecursoEstado
Timeouts HTTP / MaxHeaderBytes / Keep-AliveImplementado
TLS e client CA / mTLS no single processImplementado
MaxConnections / ConcurrencyLimit / MaxBodyBytesImplementado
Proxy headers / TrustedHostsImplementado
HTTP/2 / h2cImplementado
Hot reloadImplementado
Backlog / ReusePortCampo sem efeito
EnvPrefix / ConfigFile / AppEnvFileNão implementado
AccessLogColors / AccessFormatter / ErrorLoggerNão integrado
Workers + TLS por workerImplementado
Importante: 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.

ComandoComportamento
runInicia o servidor com endereço, workers e nível de log configuráveis.
devInicia com log debug e hot reload.
openapiImprime ou exporta o documento OpenAPI.
routesLista método, caminho e operation ID/summary.
versionExibe a versão reportada pelo CLI.
healthAvalia 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.

Microbenchmarkns/opB/opallocs/op
HTTP handler direto2.3301.23216
GoFastAPI estática2.5711.48819
GoFastAPI dinâmica2.9142.41623
GoFastAPI JSON1.0153529

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:

ComponenteDescrição
CounterContador monotônico seguro para uso concorrente (ex: requisições totais, panics).
GaugeMedidor sobe/desce via operações atômicas (ex: requisições em voo).
HistogramRegistra medições de duração/tamanho com estatísticas básicas (contagem, soma, min, max, média, buckets).
MetricsAgregador de RequestsTotal, RequestsDuration, RequestsInFlight, ResponsesByStatus e PanicsTotal.
ObservabilityEncapsula 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:

  1. Defaults — valores padrão do ServerConfig.
  2. Arquivo — JSON com campos explicitamente definidos.
  3. Variáveis de ambiente — prefixo GOFAST_ (ex: GOFAST_ADDR, GOFAST_WORKERS).
  4. 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.

Nota metodológica: os valores de desempenho apresentados nesta seção são referentes a uma rodada de testes executada em ambiente de desenvolvimento específico (Linux/AMD64, contêiner com 2 vCPUs efetivas e 4 GiB de RAM). Os números refletem as condições daquela execução e não constituem garantia de desempenho em produção, pois carga real, tamanho do payload, middlewares, DI, TLS, banco de dados, workers, hardware e configuração de rede alteram os resultados.
63.210req/s — pico do Go puro
54.272req/s — pico da GoFastAPI
17.015req/s — pico do FastAPI Python

Ambiente e configuração da bateria HTTP

AMD EPYC 9V74CPU virtual reportada
2 vCPUsQuota efetiva do contêiner
4 GiBLimite de memória RAM
3 CPUsVisíveis ao sistema operacional
Distribuição de CPU

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.

Processos e paralelismo

1 processo/worker por implementação. Go e GoFastAPI com GOMAXPROCS=1; Uvicorn com --workers 1.

Protocolo e conexão

HTTP/1.1 com Keep-Alive. Mesmo endpoint e payload JSON equivalente nas três implementações.

Duração e aquecimento

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.

StackVersão registradaConfiguração
Go / GoFastAPIGo 1.23.21 processo; GOMAXPROCS=1
FastAPIFastAPI 0.128.21 worker Uvicorn
Servidor PythonStarlette 0.50.0; Uvicorn 0.48.0HTTP/1.1; Keep-Alive
Serialização / runtime PythonPydantic 2.13.5; uvloop 0.22.1; httptools 0.8.0Dependê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ênciaGo puro
(mil req/s)
GoFastAPI
(mil req/s)
FastAPI
(mil req/s)
114.7912.776.19
3263.2153.4215.17
12863.0354.0715.79
25658.5354.2717.02
51240.7039.4814.77
1.02434.6331.0012.39
2.04824.3628.4811.45

Latência P95

ConcorrênciaGo puroGoFastAPIFastAPI
10.120 ms0.129 ms0.225 ms
321.097 ms1.355 ms2.719 ms
1284.282 ms5.297 ms10.679 ms
2567.941 ms9.351 ms22.406 ms
51221.621 ms21.816 ms51.148 ms
1.02442.355 ms55.260 ms131.155 ms
2.048139.589 ms116.473 ms277.159 ms

Consumo de memória RAM

ImplementaçãoRSS observadoLimite do contêiner
Go puro12–17 MB4 GiB
GoFastAPI12–17 MB4 GiB
FastAPI Python107–110 MB4 GiB

O FastAPI utilizou aproximadamente 7 a 9 vezes mais RSS que as implementações Go, considerando os intervalos observados.

Status e roadmap

ÁreaStatusObservação
HTTP routing, groups e mountsConcluídoÍndice estático e trie dinâmica.
Context lazy e DI scopesConcluídoDI por app, ciclo detectado, cleanup.
Responses e middlewareConcluídoDentro das APIs descritas nesta referência.
OpenAPI schemasParcialSem inferência completa de tipos Go.
SupervisorParcialSem heartbeat ativo; TLS multiprocesso disponível.
WebSocketBásicoSem fragmentação/subprotocol/extensões.
OpenTelemetryScaffoldTracer/meter no-op; sem exporter.
Hot reloadConcluídoPolling de arquivos .go com reinicialização automática.
HTTP/2 / h2cImplementadoVia http2.ConfigureServer.
TLS multiprocessoImplementadoCada worker termina TLS independentemente.
Servidor OAuth2/JWTAusenteValidação de token delegada a callback.
Background queue durávelAusenteBackground tasks são in-process.

Próximas prioridades

  1. Heartbeat e detecção de worker bloqueado; TLS multiprocesso aprimorado.
  2. OpenTelemetry SDK/exporters e schemas OpenAPI gerados de forma explícita.
  3. Completar binding declarativo sem penalizar handlers simples.
  4. 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.