arch-microservices

Purpose

This skill enables the AI to design, decompose, and implement microservices architectures using specific tools like Kong/Traefik for API gateways, Istio for service meshes, and patterns like circuit breakers and sagas for resilience. Focus on breaking down monoliths into independent services while ensuring scalability and fault tolerance.

When to Use

Apply this skill when scaling applications beyond a monolith, such as e-commerce platforms with high traffic, or distributed systems needing isolation (e.g., payment processing separate from user management). Use it for new projects requiring API management or when retrofitting legacy apps for microservices to improve resilience and deployment speed.

Key Capabilities

Decompose monoliths: Identify bounded contexts and split into services, e.g., using domain-driven design to separate user and order services.
API Gateway: Configure Kong for routing and rate limiting, or Traefik for dynamic service discovery.
Service Mesh: Deploy Istio to handle inter-service communication, including mTLS and traffic shifting.
Circuit Breakers: Implement with Istio's Envoy proxies to prevent cascading failures by tripping breakers on high error rates.
Distributed Transactions: Use saga patterns for long-running processes or outbox for event-driven consistency, ensuring atomicity across services.

Usage Patterns

To decompose a monolith, analyze dependencies and create separate services: Start by mapping modules to microservices, then define APIs. For API gateways, route requests through Kong by defining services and routes. In service meshes, inject Istio sidecars into pods for automatic traffic management. For circuit breakers, configure Istio policies to detect failures and fallback. Use sagas by orchestrating transactions via a coordinator service. Example pattern: Wrap service calls in a saga for multi-step operations, committing or compensating based on outcomes.

Common Commands/API

For Kong API Gateway:

Create a service: curl -X POST http://localhost:8001/services --data "name=my-service&url=http://myapp.com"
Add a route: curl -X POST http://localhost:8001/services/my-service/routes --data "paths[]=/api" --data "methods[]=GET"
Config format: Use Kong's declarative config in YAML, e.g., _format_version: "1.1" services: - name: my-service url: http://myapp.com

For Istio Service Mesh:

Install Istio: istioctl install -y --set profile=demo
Apply a VirtualService for circuit breaking: kubectl apply -f - <<EOF apiVersion: networking.istio.io/v1alpha3 kind: VirtualService metadata: name: my-service spec: hosts: - my-service retries: attempts: 3 EOF
API Endpoint: Use Istio's control plane via istiod pod, e.g., query metrics with kubectl exec -it istiod-xyz -- curl localhost:15014/stats

For Saga/Outbox:

Implement saga: Use a library like Axon Framework; code snippet:

Saga mySaga = Saga.builder().step(() -> orderService.createOrder()).step(() -> paymentService.process()).build();
mySaga.execute();

Outbox pattern: In a service, log events to a database table and process via a separate worker; config: SQL table like CREATE TABLE outbox (id UUID, payload JSONB);

Auth requirements: Set environment variables like $KONG_API_KEY for authenticated API calls, e.g., curl -H "apikey: $KONG_API_KEY" http://localhost:8001/services.

Integration Notes

Integrate Kong with Istio by running Kong as an Istio ingress gateway: Deploy Kong pod with Istio sidecar injection via Kubernetes annotation sidecar.istio.io/inject: "true". For Traefik, configure as a Kubernetes ingress controller using a ConfigMap: kubectl apply -f traefik-config.yaml with content like api: {} entryPoints: web: address: ":80". When combining with other skills (e.g., se-deployment), ensure services are deployed with compatible labels, such as app: my-microservice, and use $ISTIO_NAMESPACE env var for multi-namespace setups. For saga patterns, integrate with message queues like Kafka by publishing events: kafka-producer.send("topic", eventPayload).

Error Handling

Handle circuit breaker errors in Istio by configuring fallbacks in VirtualServices: Set route: fault: abort: percentage: 100 httpStatus: 503 for simulated failures, then monitor with kubectl logs istiod-xyz | grep error. For sagas, implement compensating actions on failure, e.g., if an order fails, call a rollback method: Code snippet:

try { saga.execute(); } catch (Exception e) { saga.compensate(); log.error("Saga failed: " + e.getMessage()); }

For API gateways, use Kong's plugins for error responses: Add a plugin with curl -X POST http://localhost:8001/services/my-service/plugins --data "name=request-termination" --data "config.status_code=503". Always check logs with kong logs or istioctl analyze for validation errors, and use env vars like $ERROR_WEBHOOK_URL to notify external systems.

Concrete Usage Examples

Decomposing and deploying a microservices app: For a blog platform, split into "posts" and "comments" services. Decompose by creating separate Docker images, then set up Kong: Command: docker run -d -p 8000:8000 kong:latest; curl -X POST http://localhost:8000/services -d 'name=posts-service&url=http://posts-app:8080'. Integrate with Istio: istioctl create -f posts-virtualservice.yaml to add circuit breaking.
Implementing resilience in a payment system: Use Istio for service mesh and saga for transactions. Configure a circuit breaker: kubectl apply -f circuitbreaker.yaml with content apiVersion: networking.istio.io/v1alpha3 kind: DestinationRule spec: trafficPolicy: connectionPool: tcp: maxConnections: 100 outlierDetection: consecutiveErrors: 5 interval: 10m. For sagas, orchestrate payment flow: Code snippet:

Saga paymentSaga = Saga.builder().step(() -> reserveFunds()).step(() -> processPayment()).build();
paymentSaga.executeWithCompensation();

Graph Relationships

Related to: se-deployment (for deploying and scaling microservices built with this skill)
Connected to: se-scaling (for integrating auto-scaling with Istio's traffic management)
Part of cluster: se-architecture (shares tags like "architecture" for broader system design)
Links to: se-monitoring (for observing metrics from Kong and Istio setups)