go-zero

Generates complete, production-ready REST API service scaffolding from declarative .api files using goctl's parser and code generation pipeline. The tool parses the .api definition format (which supports route definitions, request/response structs, middleware declarations, and service metadata), then generates typed handler stubs, request/response binding code, middleware chains, and server initialization logic. Developers fill in only business logic; all HTTP plumbing, validation, and routing is auto-generated and type-safe.

Generates complete gRPC service implementations, client stubs, and REST-to-gRPC gateway code from Protocol Buffer definitions using goctl's proto parser and code generation. The tool parses .proto files, generates gRPC server interfaces with go-zero's zrpc.Server integration, produces typed client code with built-in resilience (circuit breaker, timeout, retry), and optionally generates a gRPC-JSON gateway for REST clients. All generated code includes service discovery integration, distributed tracing hooks, and middleware support.

Provides a flexible middleware/interceptor system for HTTP handlers and gRPC services that allows composing cross-cutting concerns (authentication, logging, rate limiting, CORS) without modifying handler code. Middleware is registered in the server configuration and applied to all requests in a chain; each middleware can inspect/modify requests, call the next middleware, and inspect/modify responses. Interceptors work similarly for gRPC. Custom middleware can be added by implementing the middleware interface and registering it in the server setup.

Provides centralized configuration management through ServiceConf, which loads configuration from YAML/TOML/JSON files and validates it against a config struct. The framework supports environment variable substitution, nested configuration sections, and type-safe config access. ServiceConf.MustLoad() reads the config file, validates all required fields, and returns a populated config struct. Configuration includes database connections, Redis settings, service discovery, logging, tracing, and custom application config. Invalid config causes startup failure with clear error messages.

Generates Dockerfile and Kubernetes manifests (Deployment, Service, ConfigMap) from service definitions using goctl's deployment generators. The tool creates a production-ready Dockerfile with multi-stage builds, generates Kubernetes YAML for service deployment with resource limits, health checks, and environment variable configuration. Generated manifests follow Kubernetes best practices and can be deployed directly to a cluster. Developers customize manifests as needed for their environment.

Provides a MapReduce abstraction for parallel task execution with automatic goroutine management, error handling, and result aggregation. The framework provides Mapper and Reducer interfaces; developers implement map and reduce functions, and the framework handles goroutine creation, synchronization, and error collection. Useful for batch processing, data transformation, and parallel computation. The framework limits concurrent goroutines to prevent resource exhaustion and collects errors from all goroutines.

Generates type-safe Go data access code from SQL schema definitions (.sql files) using goctl's schema parser. The tool analyzes table definitions, generates model structs with field tags, produces CRUD methods (Create, Read, Update, Delete), and automatically wraps database queries with go-zero's caching layer (Redis integration). Generated code includes prepared statement handling, transaction support, and hooks for distributed tracing. Developers call generated methods; all SQL execution and cache invalidation is handled automatically.

Generates type-safe client SDKs in multiple programming languages (Go, TypeScript, Kotlin, Dart, etc.) from .api or .proto definitions using goctl's language-specific code generators. Each generated SDK includes request/response models matching the service contract, method stubs for all endpoints, and language-native error handling. The generated clients are standalone and can be published to language-specific package repositories (npm, Maven, pub.dev). No runtime dependency on go-zero is required in client code.

Automatically binds HTTP request data (query parameters, path variables, request body, headers) to typed Go structs and validates them according to struct tags using go-zero's rest.Server request handling pipeline. The framework uses reflection and struct tag parsing to map incoming HTTP data to struct fields, applies validation rules (required, range, pattern, custom validators), and returns structured error responses if validation fails. All binding and validation happens before handler code executes; handlers receive fully validated, typed data.

Provides automatic resilience protection for HTTP and gRPC clients through go-zero's client wrappers, which inject circuit breaker, timeout, and retry logic without requiring handler code changes. The framework monitors client call success/failure rates, opens circuits when failure thresholds are exceeded, enforces configurable timeouts on all requests, and retries failed calls with exponential backoff. All resilience behavior is configured through YAML/TOML config files; no code changes needed to enable protection.

Provides structured, JSON-formatted logging integrated into all go-zero components (HTTP handlers, gRPC calls, database queries) with automatic request ID generation and context propagation across service boundaries. The framework logs all requests/responses, database operations, and service calls with consistent field names and trace IDs. Context (request ID, user ID, etc.) is automatically propagated through the call chain and included in all log entries. Logs are written to stdout/stderr in JSON format for easy parsing by log aggregation systems.

Provides built-in integration points for distributed tracing systems (Jaeger, Zipkin, DataDog) through OpenTelemetry instrumentation. The framework automatically creates spans for HTTP requests, gRPC calls, and database queries, and propagates trace context across service boundaries using standard trace headers. Developers configure a trace exporter (Jaeger, Zipkin, etc.) in ServiceConf; all tracing is automatic. Spans include timing information, error status, and custom attributes set by handlers.

Provides transparent Redis caching for database queries and RPC calls through go-zero's cache abstraction layer. Developers configure cache TTL and keys in code or config; the framework automatically stores query results in Redis, returns cached values on subsequent calls, and invalidates cache entries when data is modified. Cache misses trigger database queries; hits return Redis values. The caching layer handles Redis connection pooling, serialization, and error handling (fallback to database on cache failures).

Provides client-side service discovery and load balancing for gRPC and HTTP calls through go-zero's client wrappers. The framework integrates with service registries (Consul, etcd, Kubernetes DNS) to discover available service instances, automatically routes requests to healthy instances using configurable load balancing strategies (round-robin, least-conn, random), and removes unhealthy instances from the pool. Service discovery is configured in ServiceConf; client code doesn't need to know about instance addresses.