api-gateway-patterns · nickcrew — Claude Code skill: what it does, how to install
api-gateway-patterns — a skill for API gateway design in microservices: routing, authentication, rate limiting, and request composition.
MIT 101 installs ★ 71 updated 2026-06-29
npx skills add NickCrew/Claude-Cortex --skill api-gateway-patterns -a claude-codeWhat api-gateway-patterns does
The skill provides references and checklists for implementing API gateways (Kong, Nginx, Envoy, AWS API Gateway) and the Backend for Frontend pattern. Covers path- and header-based routing, centralized authentication (JWT, OAuth, RBAC), traffic management (circuit breakers, retry logic), service call composition and aggregation. Includes references for service discovery, request transformation, and observability setup.
Works in projects with **/*.http, **/openapi.*, **/swagger.*, **/api/**, **/services/**, **/microservice/**, and **/service/**/handlers/** files. Author recommends keeping the gateway lightweight: delegate complex business logic to services, handle routing, security, and cross-cutting concerns like logging at the gateway level.
What it helps with
- design a BFF layer for mobile, web, and admin clients
- configure JWT validation and API key management at the gateway
- add rate limiting and circuit breakers to protect services from overload
- aggregate multiple backend calls into a single client response
- integrate service discovery and dynamic routing
Example prompts for the agent
- Load the routing patterns reference from
skills/api-gateway-patterns/references/routing-patterns.mdand suggest a scheme for three client types - Show a Kong config example for JWT authentication with RBAC using
skills/api-gateway-patterns/references/authentication.md - Suggest a rate limiting strategy for a public API — load
skills/api-gateway-patterns/references/traffic-management.md
How to install api-gateway-patterns
1Skills CLI (Vercel)
npx skills add NickCrew/Claude-Cortex --skill api-gateway-patterns -a claude-code2Manually: put the files in place
~/.claude/skills/api-gateway-patterns/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/api-gateway-patterns/
1Skills CLI (Vercel)
npx skills add NickCrew/Claude-Cortex --skill api-gateway-patterns -a codex2Manually: put the files in place
.agents/skills/api-gateway-patterns/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add NickCrew/Claude-Cortex --skill api-gateway-patterns -a cursor2Manually: put the files in place
.cursor/skills/api-gateway-patterns/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install NickCrew/Claude-Cortex skills/api-gateway-patterns2Manually: put the files in place
.github/skills/api-gateway-patterns/SKILL.md1Skills CLI (Vercel)
npx skills add NickCrew/Claude-Cortex --skill api-gateway-patterns -a gemini-cli2Platform CLI
gemini skills install https://github.com/NickCrew/Claude-Cortex --path skills/api-gateway-patternsManually: put the files in place
.devin/skills/api-gateway-patterns/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add NickCrew/Claude-Cortex --skill api-gateway-patterns -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about api-gateway-patterns
How to install api-gateway-patterns in Claude Code?
Run npx skills add NickCrew/Claude-Cortex --skill api-gateway-patterns -a claude-code, the skill will appear at ~/.claude/skills/api-gateway-patterns/SKILL.md.
What does the api-gateway-patterns skill do?
Provides references for API gateway design: routing, authentication, rate limiting, request composition, service discovery integration. Suited for microservices architectures with Kong, Nginx, Envoy, AWS API Gateway.
Which files activate the api-gateway-patterns skill?
The skill activates in projects with **/*.http, **/openapi.*, **/swagger.*, **/api/**, **/services/**, **/microservice/**, and **/service/**/handlers/** files.
Source text
SKILL.md · MIT
--- name: api-gateway-patterns description: API Gateway patterns for routing, authentication, rate limiting, and service composition in microservices architectures. Use when implementing API gateways, building BFF layers, or managing service-to-service communication at scale. keywords: - API gateway - BFF - Kong - Nginx - backend for frontend - gateway pattern - load balancing - rate limiting - request routing - reverse proxy file_patterns: - '**/*.http' - '**/api/**' - '**/microservice/**' - '**/openapi.*' - '**/service/**/handlers/**' - '**/services/**' - '**/swagger.*' confidence: 0.8 --- # API Gateway Patterns Expert guidance for implementing API gateways with routing, authentication, traffic management, and service composition patterns for microservices architectures at scale. ## When to Use This Skill - Implementing API gateway infrastructure for microservices - Designing Backend for Frontend (BFF) layers - Adding authentication and authorization at the gateway level - Implementing rate limiting, circuit breakers, and retry logic - Setting up service discovery and dynamic routing - Building API composition and aggregation layers - Managing cross-cutting concerns (logging, monitoring, CORS) - Evaluating gateway solutions (Kong, Nginx, Envoy, AWS API Gateway) ## Core Concepts ### Gateway Responsibilities **Routing**: Direct requests to appropriate backend services based on path, headers, or host **Security**: Centralized authentication, authorization, and API key validation **Traffic Management**: Rate limiting, circuit breakers, retry logic **Composition**: Aggregate multiple service calls into unified responses **Transformation**: Modify requests/responses for client optimization or legacy adaptation ### Architecture Patterns **Single Gateway**: One gateway for all clients (simple, potential bottleneck) **BFF Pattern**: Separate gateway per client type (mobile, web, admin) - optimized for each **GraphQL Gateway**: Schema stitching across services, client-driven data fetching **Service Mesh**: Distributed gateway pattern with sidecar proxies (Istio, Linkerd) ## Quick Reference | Task | Load reference | | --- | --- | | Routing strategies (path, header, host-based) | `skills/api-gateway-patterns/references/routing-patterns.md` | | Request/response transformation | `skills/api-gateway-patterns/references/transformation.md` | | API composition and aggregation | `skills/api-gateway-patterns/references/composition.md` | | Authentication & authorization (JWT, OAuth, RBAC) | `skills/api-gateway-patterns/references/authentication.md` | | Traffic management (rate limiting, circuit breakers) | `skills/api-gateway-patterns/references/traffic-management.md` | | Backend for Frontend (BFF) pattern | `skills/api-gateway-patterns/references/bff-pattern.md` | | Service discovery integration | `skills/api-gateway-patterns/references/service-discovery.md` | | Gateway implementations (Kong, Nginx, Envoy, AWS) | `skills/api-gateway-patterns/references/implementations.md` | ## Implementation Workflow ### Phase 1: Requirements Analysis 1. **Identify client types**: Mobile, web, admin, partners 2. **Map service landscape**: Catalog backend services and endpoints 3. **Define cross-cutting concerns**: Auth, logging, monitoring, CORS 4. **Determine composition needs**: Which endpoints require aggregation? 5. **Establish SLAs**: Latency, throughput, availability targets ### Phase 2: Gateway Design 1. **Choose architecture**: Single gateway vs BFF vs GraphQL 2. **Select implementation**: Kong, Nginx, Envoy, AWS API Gateway 3. **Design routing rules**: Path-based, header-based, host-based 4. **Plan authentication**: JWT, OAuth 2.0, API keys, or hybrid 5. **Define traffic policies**: Rate limits, circuit breakers, timeouts ### Phase 3: Implementation 1. **Set up infrastructure**: Deploy gateway instances, configure load balancer 2. **Implement routing**: Configure service discovery and route definitions 3. **Add authentication**: JWT validation, OAuth integration, API key management 4. **Apply traffic management**: Rate limiting, circuit breakers, retry logic 5. **Enable observability**: Distributed tracing, metrics, structured logging ### Phase 4: Testing & Optimization 1. **Load testing**: Verify performance under expected and peak load 2. **Failure injection**: Test circuit breakers and retry logic 3. **Security testing**: Verify auth flows, token validation, RBAC policies 4. **Latency optimization**: Cache strategies, connection pooling 5. **Monitor and tune**: Adjust timeouts, limits based on real traffic ## Best Practices 1. **Centralize Cross-Cutting Concerns**: Authentication, logging, monitoring at gateway 2. **Keep Gateway Lightweight**: Avoid complex business logic, delegate to services 3. **Implement Health Checks**: Monitor upstream service health, remove unhealthy instances 4. **Use Circuit Breakers**: Prevent cascading failures, fail fast 5. **Apply Rate Limiting**: Protect services from overload, implement tiered limits 6. **Enable Observability**: Distributed tracing, metrics, structured logging 7. **Version APIs**: Support multiple API versions, plan deprecation 8. **Secure Communication**: TLS everywhere, mutual TLS for service-to-service 9. **Cache Strategically**: Response caching, but invalidate properly 10. **Test Resilience**: Chaos engineering, failure injection, load testing ## Common Mistakes 1. **Business Logic in Gateway**: Keep gateway focused on routing/security, not business rules 2. **Chatty Composition**: Too many upstream calls (use BFF, GraphQL, or caching) 3. **Single Point of Failure**: Deploy redundantly, use load balancers 4. **No Timeout Configuration**: Always set connection/read timeouts to prevent hanging requests 5. **Ignoring Backpressure**: Implement queue limits, graceful degradation 6. **Over-Aggregation**: Don't make gateway do too much work (compute-heavy transformations) 7. **Inadequate Monitoring**: Must track latency, errors, throughput at gateway level 8. **No Rate Limiting**: Services will be overwhelmed eventually without protection 9. **Synchronous Everything**: Use async patterns for non-critical operations 10. **No Version Strategy**: Breaking changes break all clients simultaneously ## Resources - **Kong**: https://docs.konghq.com/gateway/latest/ - **Nginx**: https://nginx.org/en/docs/ - **Envoy**: https://www.envoyproxy.io/docs/envoy/latest/ - **AWS API Gateway**: https://docs.aws.amazon.com/apigateway/ - **Patterns**: "Microservices Patterns" by Chris Richardson - **Service Mesh**: https://istio.io/latest/docs/ - **Circuit Breakers**: Martin Fowler's CircuitBreaker pattern - **BFF Pattern**: Sam Newman's "Building Microservices"
© NickCrew · MIT · NickCrew/Claude-Cortex
Similar skills
All skills for Backend and APIs →api-gateway-patterns by other authors comes first.