API Gateways
An API gateway is an infrastructure component that sits between clients and backend services, handling cross-cutting concerns like authentication, rate limiting, routing, and protocol translation in one place rather than repeating them in every service.
itDistributed systems, messaging, and integration | OpenSkills.info
Intro
API Gateways
An API gateway is the entry point between API clients and one or more backend services. For HTTP, it is a reverse proxy with API-aware policies. A client addresses the gateway. The gateway accepts the connection, applies configured policy, selects a backend, and relays the result.
The gateway does not become the backend. It sits on the request path and mediates access to backend capabilities. This position gives it useful context, but it also makes the gateway part of every request's latency and failure path.
Why put a gateway in the path
Without a gateway, each client may need to discover service endpoints and handle their different protocols or failure behavior. Every exposed service also needs its own edge controls. A gateway can present one stable API surface while backend services move, split, or use private addresses.
Routing is the core job. A route can select a backend from the request host, path, method, header, or other application-layer information. The gateway can also terminate TLS, validate credentials, enforce traffic policy, transform messages, cache eligible responses, and emit telemetry.
These features are optional. Start with the smallest policy set that solves a defined boundary problem. Each added policy changes request behavior and creates configuration you must test, deploy, observe, and recover.
Continue the course
This section is part of the paid course.
See pricing to subscribe, or log in if you already have access.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://www.rfc-editor.org/rfc/rfc9110.html
Supports
- HTTP gateway and reverse-proxy definitions, intermediary chains, connection direction, and message forwarding
- Method semantics, status codes, caching, validators, transformations, Via, and hop-by-hop field handling
- https://learn.microsoft.com/en-us/azure/architecture/microservices/design/gateway
Supports
- API gateways as centralized entry points that route requests and prevent direct backend exposure
- Gateway routing, offloading, aggregation, shared concerns, component overlap, and selection criteria
- Trade-offs among reverse proxies, service-mesh ingress gateways, load balancers, and API management products
- https://learn.microsoft.com/en-us/azure/api-management/api-management-gateways-overview
Supports
- Gateway runtime as a data plane that proxies requests, applies policies, verifies credentials, limits traffic, transforms messages, caches responses, and emits telemetry
- Managed, workspace, and self-hosted gateway placement with capability differences
- https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html
Supports
- Managed creation, publication, monitoring, and security for HTTP, REST, and WebSocket APIs
- Traffic management, authorization, version management, logging, custom domains, and backend integrations
- https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-request-throttling.html
Supports
- Token-bucket rate and burst behavior across client, method, API, account, and regional scopes
- Best-effort throttle and quota targets plus Too Many Requests responses
- https://www.rfc-editor.org/rfc/rfc7239.html
Supports
- Forwarded field parameters for client-facing node, proxy interface, original host, and original protocol
- Proxy-chain preservation, information disclosure, privacy, and integrity limits
- https://owasp.org/API-Security/editions/2023/en/0x11-t10/
Supports
- Broken object-level, property-level, and function-level authorization risks
- Resource consumption, business flow, misconfiguration, inventory, and unsafe API consumption risks
- https://opentelemetry.io/docs/specs/semconv/http/http-spans/
Supports
- Separate HTTP client and server spans, request attempts, status, errors, and reverse-proxy examples
- Proxy-aware server address selection and low-cardinality route-based span names
