moai-adk 0.8.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-domain-backend/examples.md

@@ -1,1633 +1,718 @@
-# Backend Architecture Examples
+# Backend Development Examples
 
-## Example 1: Microservices with Kubernetes 1.31 + Istio 1.21
+Multishot prompting examples demonstrating practical backend development patterns covering API design, database integration, microservices, and security.
 
-### Architecture Overview
+---
 
-```
-┌─────────────────────────────────────────────────────────────┐
-│                      Istio Ingress Gateway                  │
-│                     (TLS termination, routing)              │
-└───────────────────────┬─────────────────────────────────────┘
-                        │
-        ┌───────────────┼───────────────┐
-        │               │               │
-   ┌────▼────┐    ┌────▼────┐    ┌────▼────┐
-   │  User   │    │ Product │    │ Order   │
-   │ Service │    │ Service │    │ Service │
-   │ (Go)    │    │ (Python)│    │ (Node)  │
-   └────┬────┘    └────┬────┘    └────┬────┘
-        │              │              │
-        └──────────────┼──────────────┘
-                       │
-              ┌────────▼────────┐
-              │   PostgreSQL    │
-              │   (Primary +    │
-              │   Read Replicas)│
-              └─────────────────┘
-```
+## Example 1: RESTful API with Authentication
 
-### Service Deployment (User Service - Go)
-
-**Dockerfile**:
-```dockerfile
-# Multi-stage build for Go service
-FROM golang:1.21-alpine AS builder
-WORKDIR /app
-COPY go.mod go.sum ./
-RUN go mod download
-COPY . .
-RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o user-service .
-
-FROM alpine:latest
-RUN apk --no-cache add ca-certificates
-WORKDIR /root/
-COPY --from=builder /app/user-service .
-EXPOSE 8080
-CMD ["./user-service"]
-```
+**Scenario**: Create a secure user management API with JWT authentication.
 
-**Kubernetes Deployment**:
-```yaml
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: user-service
-  namespace: production
-spec:
-  replicas: 3
-  selector:
-    matchLabels:
-      app: user-service
-      version: v1
-  template:
-    metadata:
-      labels:
-        app: user-service
-        version: v1
-      annotations:
-        prometheus.io/scrape: "true"
-        prometheus.io/port: "8080"
-        prometheus.io/path: "/metrics"
-    spec:
-      containers:
-      - name: user-service
-        image: user-service:v1.2.3
-        ports:
-        - containerPort: 8080
-          name: http
-          protocol: TCP
-        env:
-        - name: DATABASE_URL
-          valueFrom:
-            secretKeyRef:
-              name: database-credentials
-              key: url
-        - name: OTEL_EXPORTER_OTLP_ENDPOINT
-          value: "otel-collector:4317"
-        resources:
-          requests:
-            cpu: "100m"
-            memory: "128Mi"
-          limits:
-            cpu: "500m"
-            memory: "512Mi"
-        livenessProbe:
-          httpGet:
-            path: /health/live
-            port: 8080
-          initialDelaySeconds: 30
-          periodSeconds: 10
-        readinessProbe:
-          httpGet:
-            path: /health/ready
-            port: 8080
-          initialDelaySeconds: 5
-          periodSeconds: 5
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: user-service
-  namespace: production
-spec:
-  selector:
-    app: user-service
-  ports:
-  - port: 80
-    targetPort: 8080
-    protocol: TCP
-    name: http
-  type: ClusterIP
-```
+**Input**:
+```python
+from fastapi import FastAPI, Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from pydantic import BaseModel, EmailStr
+from typing import List
+import jwt
+from datetime import datetime, timedelta
+
+app = FastAPI(title="User Management API", version="1.0.0")
+security = HTTPBearer()
+
+# Models
+class UserCreate(BaseModel):
+    email: EmailStr
+    password: str
+    name: str
+
+class UserResponse(BaseModel):
+    id: int
+    email: str
+    name: str
+    created_at: datetime
+
+class TokenResponse(BaseModel):
+    access_token: str
+    token_type: str
+    expires_in: int
+```
+
+**Output**:
+```python
+# Complete implementation with authentication
+SECRET_KEY = "your-secret-key"  # Use environment variable in production
+ALGORITHM = "HS256"
+
+def create_access_token(user_id: int) -> str:
+    expire = datetime.utcnow() + timedelta(hours=24)
+    payload = {"sub": str(user_id), "exp": expire}
+    return jwt.encode(payload, SECRET_KEY, algorithm=ALGORITHM)
+
+async def get_current_user(
+    credentials: HTTPAuthorizationCredentials = Depends(security)
+) -> int:
+    try:
+        payload = jwt.decode(
+            credentials.credentials,
+            SECRET_KEY,
+            algorithms=[ALGORITHM]
+        )
+        user_id = int(payload.get("sub"))
+        return user_id
+    except jwt.ExpiredSignatureError:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Token has expired"
+        )
+    except jwt.InvalidTokenError:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid token"
+        )
 
-### Istio Configuration
-
-**VirtualService (Traffic Routing)**:
-```yaml
-apiVersion: networking.istio.io/v1beta1
-kind: VirtualService
-metadata:
-  name: user-service
-  namespace: production
-spec:
-  hosts:
-  - user-service
-  http:
-  - match:
-    - headers:
-        x-version:
-          exact: "v2"
-    route:
-    - destination:
-        host: user-service
-        subset: v2
-  - route:
-    - destination:
-        host: user-service
-        subset: v1
-      weight: 90
-    - destination:
-        host: user-service
-        subset: v2
-      weight: 10  # Canary: 10% traffic to v2
-    timeout: 5s
-    retries:
-      attempts: 3
-      perTryTimeout: 2s
-      retryOn: 5xx,reset,connect-failure,refused-stream
-```
+@app.post("/auth/login", response_model=TokenResponse)
+async def login(email: str, password: str):
+    user = await user_service.authenticate(email, password)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid credentials"
+        )
+    token = create_access_token(user.id)
+    return TokenResponse(
+        access_token=token,
+        token_type="bearer",
+        expires_in=86400
+    )
 
-**DestinationRule (Traffic Policy)**:
-```yaml
-apiVersion: networking.istio.io/v1beta1
-kind: DestinationRule
-metadata:
-  name: user-service
-  namespace: production
-spec:
-  host: user-service
-  trafficPolicy:
-    connectionPool:
-      tcp:
-        maxConnections: 100
-      http:
-        http1MaxPendingRequests: 50
-        http2MaxRequests: 100
-    outlierDetection:
-      consecutiveErrors: 5
-      interval: 30s
-      baseEjectionTime: 30s
-      maxEjectionPercent: 50
-    loadBalancer:
-      simple: LEAST_REQUEST
-  subsets:
-  - name: v1
-    labels:
-      version: v1
-  - name: v2
-    labels:
-      version: v2
+@app.get("/users/me", response_model=UserResponse)
+async def get_current_user_profile(
+    user_id: int = Depends(get_current_user)
+):
+    user = await user_service.get_by_id(user_id)
+    return user
 ```
 
-**PeerAuthentication (mTLS)**:
-```yaml
-apiVersion: security.istio.io/v1beta1
-kind: PeerAuthentication
-metadata:
-  name: default
-  namespace: production
-spec:
-  mtls:
-    mode: STRICT  # Enforce mTLS for all services
-```
+**Explanation**: This pattern demonstrates secure JWT authentication with proper error handling, token expiration, and dependency injection for protected routes.
 
-**AuthorizationPolicy (RBAC)**:
-```yaml
-apiVersion: security.istio.io/v1beta1
-kind: AuthorizationPolicy
-metadata:
-  name: user-service-authz
-  namespace: production
-spec:
-  selector:
-    matchLabels:
-      app: user-service
-  action: ALLOW
-  rules:
-  - from:
-    - source:
-        principals: ["cluster.local/ns/production/sa/order-service"]
-    to:
-    - operation:
-        methods: ["GET", "POST"]
-        paths: ["/api/users/*"]
-```
-
-### Observability Integration
+---
 
-**OpenTelemetry Instrumentation (Go)**:
-```go
-package main
+## Example 2: Database Repository Pattern with Caching
 
-import (
-    "context"
-    "log"
-    "net/http"
+**Scenario**: Implement a repository pattern with Redis caching for optimal performance.
 
-    "go.opentelemetry.io/otel"
-    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
-    "go.opentelemetry.io/otel/sdk/resource"
-    "go.opentelemetry.io/otel/sdk/trace"
-    semconv "go.opentelemetry.io/otel/semconv/v1.21.0"
-    "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
-)
+**Input**:
+```python
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+import redis.asyncio as redis
+import json
+from typing import Optional, List
 
-func initTracer() (*trace.TracerProvider, error) {
-    exporter, err := otlptracegrpc.New(
-        context.Background(),
-        otlptracegrpc.WithEndpoint("otel-collector:4317"),
-        otlptracegrpc.WithInsecure(),
-    )
-    if err != nil {
-        return nil, err
-    }
+class UserRepository:
+    def __init__(
+        self,
+        session: AsyncSession,
+        cache: redis.Redis
+    ):
+        self.session = session
+        self.cache = cache
+        self.cache_ttl = 3600  # 1 hour
+```
 
-    tp := trace.NewTracerProvider(
-        trace.WithBatcher(exporter),
-        trace.WithResource(resource.NewWithAttributes(
-            semconv.SchemaURL,
-            semconv.ServiceNameKey.String("user-service"),
-            semconv.ServiceVersionKey.String("v1.2.3"),
-        )),
-    )
+**Output**:
+```python
+class UserRepository:
+    def __init__(
+        self,
+        session: AsyncSession,
+        cache: redis.Redis
+    ):
+        self.session = session
+        self.cache = cache
+        self.cache_ttl = 3600
+
+    async def get_by_id(self, user_id: int) -> Optional[User]:
+        # Try cache first
+        cache_key = f"user:{user_id}"
+        cached = await self.cache.get(cache_key)
+
+        if cached:
+            return User(**json.loads(cached))
+
+        # Query database
+        result = await self.session.execute(
+            select(User).where(User.id == user_id)
+        )
+        user = result.scalar_one_or_none()
+
+        if user:
+            # Cache the result
+            await self.cache.setex(
+                cache_key,
+                self.cache_ttl,
+                json.dumps(user.to_dict())
+            )
+
+        return user
+
+    async def get_all(
+        self,
+        skip: int = 0,
+        limit: int = 100
+    ) -> List[User]:
+        result = await self.session.execute(
+            select(User)
+            .offset(skip)
+            .limit(limit)
+            .order_by(User.created_at.desc())
+        )
+        return result.scalars().all()
 
-    otel.SetTracerProvider(tp)
-    return tp, nil
-}
+    async def create(self, user_data: UserCreate) -> User:
+        user = User(**user_data.model_dump())
+        self.session.add(user)
+        await self.session.commit()
+        await self.session.refresh(user)
 
-func main() {
-    tp, err := initTracer()
-    if err != nil {
-        log.Fatal(err)
-    }
-    defer tp.Shutdown(context.Background())
+        # Invalidate list cache
+        await self.cache.delete("users:list:*")
 
-    // Wrap HTTP handler with OpenTelemetry instrumentation
-    handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-        w.Write([]byte("Hello, World!"))
-    })
+        return user
 
-    wrappedHandler := otelhttp.NewHandler(handler, "user-service")
-    http.Handle("/", wrappedHandler)
+    async def update(
+        self,
+        user_id: int,
+        user_data: UserUpdate
+    ) -> Optional[User]:
+        user = await self.get_by_id(user_id)
+        if not user:
+            return None
 
-    log.Println("User service listening on :8080")
-    log.Fatal(http.ListenAndServe(":8080", nil))
-}
-```
+        for key, value in user_data.model_dump(exclude_unset=True).items():
+            setattr(user, key, value)
 
-**Prometheus Metrics (Go)**:
-```go
-import (
-    "github.com/prometheus/client_golang/prometheus"
-    "github.com/prometheus/client_golang/prometheus/promhttp"
-)
+        await self.session.commit()
 
-var (
-    httpRequestsTotal = prometheus.NewCounterVec(
-        prometheus.CounterOpts{
-            Name: "http_requests_total",
-            Help: "Total number of HTTP requests",
-        },
-        []string{"method", "endpoint", "status"},
-    )
+        # Invalidate cache
+        await self.cache.delete(f"user:{user_id}")
 
-    httpRequestDuration = prometheus.NewHistogramVec(
-        prometheus.HistogramOpts{
-            Name:    "http_request_duration_seconds",
-            Help:    "HTTP request latency",
-            Buckets: prometheus.DefBuckets,
-        },
-        []string{"method", "endpoint"},
-    )
-)
+        return user
 
-func init() {
-    prometheus.MustRegister(httpRequestsTotal)
-    prometheus.MustRegister(httpRequestDuration)
-}
+    async def delete(self, user_id: int) -> bool:
+        user = await self.get_by_id(user_id)
+        if not user:
+            return False
 
-func main() {
-    // ... OpenTelemetry setup ...
+        await self.session.delete(user)
+        await self.session.commit()
 
-    http.Handle("/metrics", promhttp.Handler())
-    http.ListenAndServe(":8080", nil)
-}
-```
+        # Invalidate cache
+        await self.cache.delete(f"user:{user_id}")
 
-### Database Connection Pooling
-
-**PostgreSQL with PgBouncer**:
-```yaml
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: pgbouncer
-spec:
-  replicas: 2
-  template:
-    spec:
-      containers:
-      - name: pgbouncer
-        image: pgbouncer/pgbouncer:1.21
-        ports:
-        - containerPort: 6432
-        volumeMounts:
-        - name: config
-          mountPath: /etc/pgbouncer
-      volumes:
-      - name: config
-        configMap:
-          name: pgbouncer-config
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: pgbouncer-config
-data:
-  pgbouncer.ini: |
-    [databases]
-    production = host=postgres-primary port=5432 dbname=production
-
-    [pgbouncer]
-    listen_addr = 0.0.0.0
-    listen_port = 6432
-    auth_type = md5
-    auth_file = /etc/pgbouncer/userlist.txt
-    pool_mode = transaction
-    max_client_conn = 1000
-    default_pool_size = 20
-    reserve_pool_size = 5
-    server_lifetime = 3600
-    server_idle_timeout = 600
+        return True
 ```
 
-**Application Connection String**:
-```
-DATABASE_URL=postgresql://user:pass@pgbouncer:6432/production?pool_size=10
-```
+**Explanation**: The repository pattern encapsulates data access logic with Redis caching for read operations and automatic cache invalidation on writes.
 
 ---
 
-## Example 2: Event-Driven Architecture with Kafka 3.7
-
-### Architecture Overview
+## Example 3: Event-Driven Microservice Architecture
 
-```
-┌──────────┐    ┌──────────┐    ┌──────────┐
-│  Order   │───▶│  Kafka   │◀───│ Payment  │
-│ Service  │    │  Cluster │    │ Service  │
-└──────────┘    └────┬─────┘    └──────────┘
-                     │
-          ┌──────────┼──────────┐
-          │          │          │
-     ┌────▼───┐ ┌───▼────┐ ┌───▼────┐
-     │ Email  │ │ Invoice│ │Analytics│
-     │Service │ │Service │ │Service  │
-     └────────┘ └────────┘ └─────────┘
-```
+**Scenario**: Implement an order processing service with event-driven communication.
 
-### Kafka Deployment (Kubernetes)
-
-**Kafka StatefulSet**:
-```yaml
-apiVersion: apps/v1
-kind: StatefulSet
-metadata:
-  name: kafka
-spec:
-  serviceName: kafka-headless
-  replicas: 3
-  selector:
-    matchLabels:
-      app: kafka
-  template:
-    metadata:
-      labels:
-        app: kafka
-    spec:
-      containers:
-      - name: kafka
-        image: confluentinc/cp-kafka:7.6.0  # Kafka 3.7.x
-        ports:
-        - containerPort: 9092
-          name: plaintext
-        - containerPort: 9093
-          name: ssl
-        env:
-        - name: KAFKA_BROKER_ID
-          valueFrom:
-            fieldRef:
-              fieldPath: metadata.name
-        - name: KAFKA_ZOOKEEPER_CONNECT
-          value: "zookeeper:2181"
-        - name: KAFKA_ADVERTISED_LISTENERS
-          value: "PLAINTEXT://$(POD_NAME).kafka-headless:9092"
-        - name: KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR
-          value: "3"
-        - name: KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR
-          value: "3"
-        - name: KAFKA_TRANSACTION_STATE_LOG_MIN_ISR
-          value: "2"
-        - name: KAFKA_LOG_RETENTION_HOURS
-          value: "168"  # 7 days
-        resources:
-          requests:
-            memory: "2Gi"
-            cpu: "1000m"
-          limits:
-            memory: "4Gi"
-            cpu: "2000m"
-        volumeMounts:
-        - name: data
-          mountPath: /var/lib/kafka/data
-  volumeClaimTemplates:
-  - metadata:
-      name: data
-    spec:
-      accessModes: ["ReadWriteOnce"]
-      resources:
-        requests:
-          storage: 100Gi
-```
-
-### Event Sourcing Pattern
-
-**Event Definition**:
-```typescript
-// events/order.events.ts
-export enum OrderEventType {
-  ORDER_CREATED = 'order.created',
-  ORDER_PAID = 'order.paid',
-  ORDER_SHIPPED = 'order.shipped',
-  ORDER_DELIVERED = 'order.delivered',
-  ORDER_CANCELLED = 'order.cancelled',
-}
-
-export interface OrderEvent {
-  eventId: string;
-  eventType: OrderEventType;
-  orderId: string;
-  timestamp: Date;
-  userId: string;
-  data: unknown;
-  metadata: {
-    correlationId: string;
-    causationId: string;
-  };
-}
-
-export interface OrderCreatedEvent extends OrderEvent {
-  eventType: OrderEventType.ORDER_CREATED;
-  data: {
-    items: Array<{
-      productId: string;
-      quantity: number;
-      price: number;
-    }>;
-    totalAmount: number;
-    shippingAddress: Address;
-  };
-}
-```
+**Input**:
+```python
+from aio_pika import connect_robust, Message, ExchangeType
+import json
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
 
-**Event Producer (Order Service - Node.js)**:
-```typescript
-import { Kafka, Producer } from 'kafkajs';
-import { v4 as uuidv4 } from 'uuid';
-
-const kafka = new Kafka({
-  clientId: 'order-service',
-  brokers: ['kafka-0.kafka-headless:9092', 'kafka-1.kafka-headless:9092'],
-});
-
-const producer: Producer = kafka.producer({
-  idempotent: true,  // Prevent duplicate events
-  maxInFlightRequests: 5,
-  transactionalId: 'order-service-producer',
-});
-
-await producer.connect();
-
-export async function publishOrderCreatedEvent(order: Order): Promise<void> {
-  const event: OrderCreatedEvent = {
-    eventId: uuidv4(),
-    eventType: OrderEventType.ORDER_CREATED,
-    orderId: order.id,
-    timestamp: new Date(),
-    userId: order.userId,
-    data: {
-      items: order.items,
-      totalAmount: order.totalAmount,
-      shippingAddress: order.shippingAddress,
-    },
-    metadata: {
-      correlationId: order.correlationId,
-      causationId: uuidv4(),
-    },
-  };
-
-  await producer.send({
-    topic: 'orders',
-    messages: [
-      {
-        key: order.id,  // Partition by order ID
-        value: JSON.stringify(event),
-        headers: {
-          'event-type': event.eventType,
-          'correlation-id': event.metadata.correlationId,
-        },
-      },
-    ],
-  });
-}
+@dataclass
+class OrderCreatedEvent:
+    order_id: str
+    user_id: int
+    total_amount: float
+    items: list
+    created_at: datetime
 ```
 
-**Event Consumer (Email Service - Python)**:
+**Output**:
 ```python
-from kafka import KafkaConsumer
-from kafka.errors import KafkaError
+import asyncio
+from aio_pika import connect_robust, Message, ExchangeType
 import json
+from dataclasses import dataclass, asdict
+from datetime import datetime
+from typing import Optional, Callable, Dict
 import logging
 
 logger = logging.getLogger(__name__)
 
-consumer = KafkaConsumer(
-    'orders',
-    bootstrap_servers=['kafka-0.kafka-headless:9092'],
-    group_id='email-service',
-    auto_offset_reset='earliest',
-    enable_auto_commit=False,
-    max_poll_records=100,
-    value_deserializer=lambda m: json.loads(m.decode('utf-8')),
-)
-
-def process_order_created_event(event: dict):
-    """Send order confirmation email."""
-    try:
-        send_email(
-            to=event['userId'],
-            subject=f"Order Confirmation - {event['orderId']}",
-            body=render_template('order_confirmation.html', event=event),
+@dataclass
+class OrderCreatedEvent:
+    order_id: str
+    user_id: int
+    total_amount: float
+    items: list
+    created_at: datetime
+
+class EventBus:
+    def __init__(self, amqp_url: str):
+        self.amqp_url = amqp_url
+        self.connection = None
+        self.channel = None
+        self.exchange = None
+        self.handlers: Dict[str, Callable] = {}
+
+    async def connect(self):
+        self.connection = await connect_robust(self.amqp_url)
+        self.channel = await self.connection.channel()
+        self.exchange = await self.channel.declare_exchange(
+            "events",
+            ExchangeType.TOPIC,
+            durable=True
+        )
+        logger.info("Connected to message broker")
+
+    async def publish(self, event_type: str, event_data: dict):
+        message = Message(
+            json.dumps({
+                "type": event_type,
+                "data": event_data,
+                "timestamp": datetime.utcnow().isoformat()
+            }).encode(),
+            content_type="application/json",
+            delivery_mode=2  # Persistent
+        )
+        await self.exchange.publish(message, routing_key=event_type)
+        logger.info(f"Published event: {event_type}")
+
+    async def subscribe(
+        self,
+        event_type: str,
+        handler: Callable,
+        queue_name: str
+    ):
+        queue = await self.channel.declare_queue(
+            queue_name,
+            durable=True
+        )
+        await queue.bind(self.exchange, routing_key=event_type)
+
+        async def process_message(message):
+            async with message.process():
+                try:
+                    data = json.loads(message.body.decode())
+                    await handler(data)
+                except Exception as e:
+                    logger.error(f"Error processing message: {e}")
+                    raise
+
+        await queue.consume(process_message)
+        logger.info(f"Subscribed to: {event_type}")
+
+class OrderService:
+    def __init__(self, event_bus: EventBus, db_session):
+        self.event_bus = event_bus
+        self.db = db_session
+
+    async def create_order(self, order_data: dict) -> Order:
+        # Create order in database
+        order = Order(**order_data)
+        self.db.add(order)
+        await self.db.commit()
+
+        # Publish event
+        event = OrderCreatedEvent(
+            order_id=str(order.id),
+            user_id=order.user_id,
+            total_amount=order.total_amount,
+            items=order.items,
+            created_at=order.created_at
+        )
+        await self.event_bus.publish(
+            "order.created",
+            asdict(event)
         )
-        logger.info(f"Email sent for order {event['orderId']}")
-    except Exception as e:
-        logger.error(f"Failed to send email: {e}")
-        raise  # Trigger retry
 
-for message in consumer:
-    try:
-        event = message.value
-        event_type = message.headers.get('event-type')
+        return order
+
+class NotificationService:
+    def __init__(self, event_bus: EventBus):
+        self.event_bus = event_bus
 
-        if event_type == 'order.created':
-            process_order_created_event(event)
+    async def start(self):
+        await self.event_bus.subscribe(
+            "order.created",
+            self.handle_order_created,
+            "notification-service-orders"
+        )
 
-        # Commit offset only after successful processing
-        consumer.commit()
+    async def handle_order_created(self, event_data: dict):
+        order_data = event_data["data"]
+        user_id = order_data["user_id"]
+        order_id = order_data["order_id"]
 
-    except Exception as e:
-        logger.error(f"Error processing message: {e}")
-        # Do not commit; retry on next poll
+        # Send notification
+        await self.send_email(
+            user_id=user_id,
+            subject=f"Order {order_id} Confirmed",
+            body=f"Your order for ${order_data['total_amount']} has been confirmed."
+        )
+        logger.info(f"Sent order confirmation for {order_id}")
 ```
 
-### CQRS Pattern
-
-**Command Model (Write Side)**:
-```typescript
-// commands/create-order.command.ts
-export class CreateOrderCommand {
-  constructor(
-    public readonly userId: string,
-    public readonly items: OrderItem[],
-    public readonly shippingAddress: Address,
-  ) {}
-}
-
-export class CreateOrderHandler {
-  constructor(
-    private readonly orderRepository: OrderRepository,
-    private readonly eventBus: EventBus,
-  ) {}
-
-  async execute(command: CreateOrderCommand): Promise<string> {
-    // Create order aggregate
-    const order = Order.create(
-      command.userId,
-      command.items,
-      command.shippingAddress,
-    );
-
-    // Persist to event store
-    await this.orderRepository.save(order);
-
-    // Publish domain events
-    for (const event of order.getUncommittedEvents()) {
-      await this.eventBus.publish(event);
-    }
+**Explanation**: This pattern demonstrates event-driven architecture with RabbitMQ, enabling loose coupling between services and reliable message delivery.
 
-    order.markEventsAsCommitted();
-    return order.id;
-  }
-}
-```
+---
 
-**Query Model (Read Side)**:
-```typescript
-// queries/get-order.query.ts
-export class GetOrderQuery {
-  constructor(public readonly orderId: string) {}
-}
-
-export class GetOrderHandler {
-  constructor(private readonly orderReadRepository: OrderReadRepository) {}
-
-  async execute(query: GetOrderQuery): Promise<OrderDTO> {
-    // Read from optimized read model (denormalized)
-    const order = await this.orderReadRepository.findById(query.orderId);
-    if (!order) {
-      throw new OrderNotFoundException(query.orderId);
-    }
-    return OrderDTO.fromReadModel(order);
-  }
-}
-```
+## Common Patterns
 
-**Read Model Projector (Event Handler)**:
-```typescript
-// projections/order-projection.ts
-export class OrderProjection {
-  constructor(private readonly db: Database) {}
-
-  @EventHandler(OrderEventType.ORDER_CREATED)
-  async onOrderCreated(event: OrderCreatedEvent): Promise<void> {
-    await this.db.insert('order_read_model', {
-      order_id: event.orderId,
-      user_id: event.userId,
-      status: 'CREATED',
-      total_amount: event.data.totalAmount,
-      created_at: event.timestamp,
-      updated_at: event.timestamp,
-    });
-
-    // Insert order items into separate table
-    for (const item of event.data.items) {
-      await this.db.insert('order_item_read_model', {
-        order_id: event.orderId,
-        product_id: item.productId,
-        quantity: item.quantity,
-        price: item.price,
-      });
-    }
-  }
-
-  @EventHandler(OrderEventType.ORDER_PAID)
-  async onOrderPaid(event: OrderPaidEvent): Promise<void> {
-    await this.db.update(
-      'order_read_model',
-      { order_id: event.orderId },
-      { status: 'PAID', updated_at: event.timestamp },
-    );
-  }
-}
+### Pattern 1: Circuit Breaker for External Services
+
+Protect your service from cascading failures:
+
+```python
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_exponential,
+    retry_if_exception_type
+)
+import httpx
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+
+@dataclass
+class CircuitBreakerState:
+    failures: int = 0
+    last_failure: datetime = None
+    is_open: bool = False
+
+class CircuitBreaker:
+    def __init__(
+        self,
+        failure_threshold: int = 5,
+        recovery_timeout: int = 30
+    ):
+        self.failure_threshold = failure_threshold
+        self.recovery_timeout = timedelta(seconds=recovery_timeout)
+        self.state = CircuitBreakerState()
+
+    def can_execute(self) -> bool:
+        if not self.state.is_open:
+            return True
+
+        if datetime.utcnow() - self.state.last_failure > self.recovery_timeout:
+            self.state.is_open = False
+            self.state.failures = 0
+            return True
+
+        return False
+
+    def record_failure(self):
+        self.state.failures += 1
+        self.state.last_failure = datetime.utcnow()
+
+        if self.state.failures >= self.failure_threshold:
+            self.state.is_open = True
+
+    def record_success(self):
+        self.state.failures = 0
+        self.state.is_open = False
+
+class ExternalPaymentService:
+    def __init__(self, base_url: str):
+        self.base_url = base_url
+        self.circuit_breaker = CircuitBreaker()
+        self.client = httpx.AsyncClient()
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=1, max=10),
+        retry=retry_if_exception_type(httpx.TransportError)
+    )
+    async def process_payment(self, payment_data: dict) -> dict:
+        if not self.circuit_breaker.can_execute():
+            raise ServiceUnavailableError("Payment service circuit open")
+
+        try:
+            response = await self.client.post(
+                f"{self.base_url}/payments",
+                json=payment_data,
+                timeout=10.0
+            )
+            response.raise_for_status()
+            self.circuit_breaker.record_success()
+            return response.json()
+        except Exception as e:
+            self.circuit_breaker.record_failure()
+            raise
 ```
 
----
+### Pattern 2: Request Validation Middleware
 
-## Example 3: Serverless with AWS Lambda
+Comprehensive request validation:
 
-### Architecture Overview
+```python
+from fastapi import Request, HTTPException
+from starlette.middleware.base import BaseHTTPMiddleware
+from pydantic import ValidationError
+import time
+import logging
 
-```
-┌──────────┐    ┌──────────┐    ┌──────────┐
-│ API      │───▶│  Lambda  │───▶│ DynamoDB │
-│ Gateway  │    │ Functions│    └──────────┘
-└──────────┘    └────┬─────┘
-                     │
-                ┌────▼────┐
-                │   SQS   │
-                └────┬────┘
-                     │
-                ┌────▼────┐
-                │ Lambda  │
-                │ Worker  │
-                └─────────┘
-```
+logger = logging.getLogger(__name__)
 
-### API Lambda Function (Node.js)
-
-**handler.ts**:
-```typescript
-import { APIGatewayProxyHandler, APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import { DynamoDBDocumentClient, PutCommand, GetCommand } from '@aws-sdk/lib-dynamodb';
-import { SQSClient, SendMessageCommand } from '@aws-sdk/client-sqs';
-import { v4 as uuidv4 } from 'uuid';
-
-const client = new DynamoDBClient({});
-const ddb = DynamoDBDocumentClient.from(client);
-const sqs = new SQSClient({});
-
-export const createOrder: APIGatewayProxyHandler = async (
-  event: APIGatewayProxyEvent
-): Promise<APIGatewayProxyResult> => {
-  try {
-    const body = JSON.parse(event.body || '{}');
-    const orderId = uuidv4();
-
-    // Write to DynamoDB
-    await ddb.send(
-      new PutCommand({
-        TableName: process.env.ORDERS_TABLE!,
-        Item: {
-          orderId,
-          userId: body.userId,
-          items: body.items,
-          totalAmount: body.totalAmount,
-          status: 'PENDING',
-          createdAt: new Date().toISOString(),
-        },
-      })
-    );
-
-    // Send message to SQS for async processing
-    await sqs.send(
-      new SendMessageCommand({
-        QueueUrl: process.env.ORDER_QUEUE_URL!,
-        MessageBody: JSON.stringify({
-          orderId,
-          userId: body.userId,
-          totalAmount: body.totalAmount,
-        }),
-        MessageAttributes: {
-          eventType: {
-            DataType: 'String',
-            StringValue: 'ORDER_CREATED',
-          },
-        },
-      })
-    );
-
-    return {
-      statusCode: 201,
-      headers: {
-        'Content-Type': 'application/json',
-        'Access-Control-Allow-Origin': '*',
-      },
-      body: JSON.stringify({ orderId }),
-    };
-  } catch (error) {
-    console.error('Error creating order:', error);
-    return {
-      statusCode: 500,
-      body: JSON.stringify({ error: 'Internal server error' }),
-    };
-  }
-};
-
-export const getOrder: APIGatewayProxyHandler = async (
-  event: APIGatewayProxyEvent
-): Promise<APIGatewayProxyResult> => {
-  try {
-    const orderId = event.pathParameters?.orderId;
-
-    const result = await ddb.send(
-      new GetCommand({
-        TableName: process.env.ORDERS_TABLE!,
-        Key: { orderId },
-      })
-    );
-
-    if (!result.Item) {
-      return {
-        statusCode: 404,
-        body: JSON.stringify({ error: 'Order not found' }),
-      };
-    }
+class RequestValidationMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        start_time = time.time()
+        request_id = request.headers.get("X-Request-ID", str(uuid.uuid4()))
 
-    return {
-      statusCode: 200,
-      headers: {
-        'Content-Type': 'application/json',
-        'Access-Control-Allow-Origin': '*',
-      },
-      body: JSON.stringify(result.Item),
-    };
-  } catch (error) {
-    console.error('Error fetching order:', error);
-    return {
-      statusCode: 500,
-      body: JSON.stringify({ error: 'Internal server error' }),
-    };
-  }
-};
-```
+        # Add request ID to context
+        request.state.request_id = request_id
 
-**Infrastructure as Code (Terraform)**:
-```hcl
-# lambda.tf
-resource "aws_lambda_function" "create_order" {
-  filename         = "lambda.zip"
-  function_name    = "create-order"
-  role            = aws_iam_role.lambda_exec.arn
-  handler         = "handler.createOrder"
-  runtime         = "nodejs20.x"
-  memory_size     = 512
-  timeout         = 30
-
-  environment {
-    variables = {
-      ORDERS_TABLE     = aws_dynamodb_table.orders.name
-      ORDER_QUEUE_URL  = aws_sqs_queue.orders.url
-    }
-  }
-
-  tracing_config {
-    mode = "Active"  # Enable X-Ray tracing
-  }
-}
-
-resource "aws_lambda_function" "get_order" {
-  filename         = "lambda.zip"
-  function_name    = "get-order"
-  role            = aws_iam_role.lambda_exec.arn
-  handler         = "handler.getOrder"
-  runtime         = "nodejs20.x"
-  memory_size     = 256
-  timeout         = 10
-
-  environment {
-    variables = {
-      ORDERS_TABLE = aws_dynamodb_table.orders.name
-    }
-  }
-
-  tracing_config {
-    mode = "Active"
-  }
-}
-
-# API Gateway
-resource "aws_apigatewayv2_api" "main" {
-  name          = "orders-api"
-  protocol_type = "HTTP"
-}
-
-resource "aws_apigatewayv2_route" "create_order" {
-  api_id    = aws_apigatewayv2_api.main.id
-  route_key = "POST /orders"
-  target    = "integrations/${aws_apigatewayv2_integration.create_order.id}"
-}
-
-resource "aws_apigatewayv2_route" "get_order" {
-  api_id    = aws_apigatewayv2_api.main.id
-  route_key = "GET /orders/{orderId}"
-  target    = "integrations/${aws_apigatewayv2_integration.get_order.id}"
-}
-
-# DynamoDB
-resource "aws_dynamodb_table" "orders" {
-  name           = "orders"
-  billing_mode   = "PAY_PER_REQUEST"
-  hash_key       = "orderId"
-
-  attribute {
-    name = "orderId"
-    type = "S"
-  }
-
-  point_in_time_recovery {
-    enabled = true
-  }
-}
-
-# SQS
-resource "aws_sqs_queue" "orders" {
-  name                       = "orders-queue"
-  visibility_timeout_seconds = 300
-  message_retention_seconds  = 1209600  # 14 days
-  receive_wait_time_seconds  = 20       # Long polling
-}
-```
+        # Log incoming request
+        logger.info(f"[{request_id}] {request.method} {request.url.path}")
 
-### SQS Worker Lambda (Async Processing)
-
-```typescript
-import { SQSHandler, SQSEvent } from 'aws-lambda';
-import { DynamoDBDocumentClient, UpdateCommand } from '@aws-sdk/lib-dynamodb';
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-
-const client = new DynamoDBClient({});
-const ddb = DynamoDBDocumentClient.from(client);
-
-export const processOrder: SQSHandler = async (event: SQSEvent): Promise<void> => {
-  for (const record of event.Records) {
-    try {
-      const message = JSON.parse(record.body);
-      const { orderId, userId, totalAmount } = message;
-
-      // Simulate payment processing
-      const paymentResult = await processPayment(userId, totalAmount);
-
-      // Update order status
-      await ddb.send(
-        new UpdateCommand({
-          TableName: process.env.ORDERS_TABLE!,
-          Key: { orderId },
-          UpdateExpression: 'SET #status = :status, paymentId = :paymentId',
-          ExpressionAttributeNames: {
-            '#status': 'status',
-          },
-          ExpressionAttributeValues: {
-            ':status': paymentResult.success ? 'PAID' : 'PAYMENT_FAILED',
-            ':paymentId': paymentResult.paymentId,
-          },
-        })
-      );
-
-      console.log(`Order ${orderId} processed successfully`);
-    } catch (error) {
-      console.error('Error processing order:', error);
-      throw error;  // Trigger SQS retry
-    }
-  }
-};
-
-async function processPayment(userId: string, amount: number): Promise<{ success: boolean; paymentId: string }> {
-  // Simulate external payment API call
-  await new Promise(resolve => setTimeout(resolve, 1000));
-  return { success: true, paymentId: `pay_${Date.now()}` };
-}
-```
+        try:
+            response = await call_next(request)
 
-### Cold Start Optimization
+            # Add response headers
+            response.headers["X-Request-ID"] = request_id
+            response.headers["X-Response-Time"] = str(time.time() - start_time)
 
-**Provisioned Concurrency**:
-```hcl
-resource "aws_lambda_provisioned_concurrency_config" "create_order" {
-  function_name                     = aws_lambda_function.create_order.function_name
-  provisioned_concurrent_executions = 5  # Keep 5 warm instances
-  qualifier                         = aws_lambda_function.create_order.version
-}
-```
+            logger.info(
+                f"[{request_id}] Completed {response.status_code} "
+                f"in {time.time() - start_time:.3f}s"
+            )
+
+            return response
 
-**Lambda Layers (Shared Dependencies)**:
-```hcl
-resource "aws_lambda_layer_version" "dependencies" {
-  filename            = "layer.zip"
-  layer_name          = "shared-dependencies"
-  compatible_runtimes = ["nodejs20.x"]
-  description         = "Shared dependencies for Lambda functions"
-}
-
-resource "aws_lambda_function" "create_order" {
-  # ... other config ...
-  layers = [aws_lambda_layer_version.dependencies.arn]
-}
+        except ValidationError as e:
+            logger.warning(f"[{request_id}] Validation error: {e}")
+            raise HTTPException(status_code=422, detail=e.errors())
+        except Exception as e:
+            logger.error(f"[{request_id}] Unexpected error: {e}")
+            raise
 ```
 
----
+### Pattern 3: Database Connection Pool Management
 
-## Example 4: Observability with OpenTelemetry 1.24 + Prometheus 2.48
-
-### Full Stack Observability Setup
-
-**OpenTelemetry Collector Deployment**:
-```yaml
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: otel-collector
-  namespace: observability
-spec:
-  replicas: 2
-  selector:
-    matchLabels:
-      app: otel-collector
-  template:
-    metadata:
-      labels:
-        app: otel-collector
-    spec:
-      containers:
-      - name: otel-collector
-        image: otel/opentelemetry-collector-contrib:0.92.0
-        ports:
-        - containerPort: 4317  # OTLP gRPC
-        - containerPort: 4318  # OTLP HTTP
-        - containerPort: 8889  # Prometheus metrics
-        volumeMounts:
-        - name: config
-          mountPath: /etc/otelcol
-        resources:
-          requests:
-            cpu: "200m"
-            memory: "256Mi"
-          limits:
-            cpu: "1000m"
-            memory: "1Gi"
-      volumes:
-      - name: config
-        configMap:
-          name: otel-collector-config
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: otel-collector-config
-  namespace: observability
-data:
-  config.yaml: |
-    receivers:
-      otlp:
-        protocols:
-          grpc:
-            endpoint: 0.0.0.0:4317
-          http:
-            endpoint: 0.0.0.0:4318
-
-    processors:
-      batch:
-        timeout: 10s
-        send_batch_size: 1024
-      memory_limiter:
-        check_interval: 1s
-        limit_mib: 512
-      resource:
-        attributes:
-        - key: environment
-          value: production
-          action: insert
-
-    exporters:
-      prometheus:
-        endpoint: "0.0.0.0:8889"
-      jaeger:
-        endpoint: "jaeger-collector.observability:14250"
-        tls:
-          insecure: true
-      elasticsearch:
-        endpoints: ["http://elasticsearch.observability:9200"]
-        logs_index: "otel-logs"
-
-    service:
-      pipelines:
-        traces:
-          receivers: [otlp]
-          processors: [memory_limiter, batch, resource]
-          exporters: [jaeger]
-        metrics:
-          receivers: [otlp]
-          processors: [memory_limiter, batch, resource]
-          exporters: [prometheus]
-        logs:
-          receivers: [otlp]
-          processors: [memory_limiter, batch, resource]
-          exporters: [elasticsearch]
-```
+Optimized database connections:
 
-**Application Instrumentation (Python FastAPI)**:
 ```python
-from fastapi import FastAPI
-from opentelemetry import trace, metrics
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor
-from opentelemetry.sdk.metrics import MeterProvider
-from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
-from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
-from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
-from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
-
-# Setup tracing
-trace_provider = TracerProvider()
-trace_exporter = OTLPSpanExporter(endpoint="otel-collector:4317", insecure=True)
-trace_provider.add_span_processor(BatchSpanProcessor(trace_exporter))
-trace.set_tracer_provider(trace_provider)
-
-# Setup metrics
-metric_reader = PeriodicExportingMetricReader(
-    OTLPMetricExporter(endpoint="otel-collector:4317", insecure=True),
-    export_interval_millis=30000,
-)
-metric_provider = MeterProvider(metric_readers=[metric_reader])
-metrics.set_meter_provider(metric_provider)
-
-# Create app
-app = FastAPI()
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.pool import QueuePool
+from contextlib import asynccontextmanager
+
+class DatabaseManager:
+    def __init__(self, database_url: str):
+        self.engine = create_async_engine(
+            database_url,
+            poolclass=QueuePool,
+            pool_size=20,
+            max_overflow=30,
+            pool_pre_ping=True,
+            pool_recycle=3600,
+            echo=False
+        )
+        self.async_session = sessionmaker(
+            self.engine,
+            class_=AsyncSession,
+            expire_on_commit=False
+        )
 
-# Auto-instrument FastAPI
-FastAPIInstrumentor.instrument_app(app)
+    @asynccontextmanager
+    async def get_session(self):
+        session = self.async_session()
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+        finally:
+            await session.close()
+
+    async def health_check(self) -> bool:
+        try:
+            async with self.get_session() as session:
+                await session.execute("SELECT 1")
+            return True
+        except Exception:
+            return False
+```
 
-# Custom metrics
-meter = metrics.get_meter(__name__)
-order_counter = meter.create_counter(
-    name="orders_created_total",
-    description="Total number of orders created",
-    unit="1",
-)
+---
 
-@app.post("/orders")
-async def create_order(order: Order):
-    tracer = trace.get_tracer(__name__)
-    with tracer.start_as_current_span("create_order") as span:
-        span.set_attribute("order.id", order.id)
-        span.set_attribute("order.amount", order.totalAmount)
+## Anti-Patterns (Patterns to Avoid)
 
-        # Business logic
-        result = await process_order(order)
+### Anti-Pattern 1: N+1 Query Problem
 
-        # Record metric
-        order_counter.add(1, {"status": result.status})
+**Problem**: Making individual database queries for related entities.
 
-        return result
+```python
+# Incorrect approach
+async def get_orders_with_items():
+    orders = await session.execute(select(Order))
+    for order in orders.scalars():
+        # N+1 problem: one query per order
+        items = await session.execute(
+            select(OrderItem).where(OrderItem.order_id == order.id)
+        )
+        order.items = items.scalars().all()
+    return orders
 ```
 
-**Grafana Dashboards (Provisioning)**:
-```yaml
-# grafana-dashboard-configmap.yaml
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: grafana-dashboards
-  namespace: observability
-data:
-  backend-overview.json: |
-    {
-      "dashboard": {
-        "title": "Backend Overview",
-        "panels": [
-          {
-            "title": "Request Rate",
-            "targets": [
-              {
-                "expr": "rate(http_requests_total[5m])"
-              }
-            ]
-          },
-          {
-            "title": "Error Rate",
-            "targets": [
-              {
-                "expr": "rate(http_requests_total{status=~\"5..\"}[5m]) / rate(http_requests_total[5m])"
-              }
-            ]
-          },
-          {
-            "title": "Latency (p95)",
-            "targets": [
-              {
-                "expr": "histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))"
-              }
-            ]
-          },
-          {
-            "title": "Active Connections",
-            "targets": [
-              {
-                "expr": "sum(rate(http_requests_total[1m]))"
-              }
-            ]
-          }
-        ]
-      }
-    }
-```
+**Solution**: Use eager loading with joins.
 
-**Alert Rules (PrometheusRule)**:
-```yaml
-apiVersion: monitoring.coreos.com/v1
-kind: PrometheusRule
-metadata:
-  name: backend-alerts
-  namespace: observability
-spec:
-  groups:
-  - name: backend
-    interval: 30s
-    rules:
-    - alert: HighErrorRate
-      expr: |
-        (
-          rate(http_requests_total{status=~"5.."}[5m])
-          /
-          rate(http_requests_total[5m])
-        ) > 0.05
-      for: 5m
-      labels:
-        severity: critical
-      annotations:
-        summary: "High error rate detected (instance {{ $labels.instance }})"
-        description: "Error rate is {{ $value | humanizePercentage }} for the last 5 minutes"
-
-    - alert: HighLatency
-      expr: |
-        histogram_quantile(0.95,
-          rate(http_request_duration_seconds_bucket[5m])
-        ) > 1.0
-      for: 10m
-      labels:
-        severity: warning
-      annotations:
-        summary: "High latency detected (instance {{ $labels.instance }})"
-        description: "P95 latency is {{ $value }}s for the last 10 minutes"
-
-    - alert: ServiceDown
-      expr: up{job="backend"} == 0
-      for: 2m
-      labels:
-        severity: critical
-      annotations:
-        summary: "Service is down (instance {{ $labels.instance }})"
-        description: "Backend service has been down for more than 2 minutes"
-
-    - alert: HighMemoryUsage
-      expr: |
-        (
-          container_memory_usage_bytes{pod=~"backend-.*"}
-          /
-          container_spec_memory_limit_bytes{pod=~"backend-.*"}
-        ) > 0.9
-      for: 5m
-      labels:
-        severity: warning
-      annotations:
-        summary: "High memory usage (pod {{ $labels.pod }})"
-        description: "Memory usage is {{ $value | humanizePercentage }}"
-
-    - alert: PodCrashLooping
-      expr: rate(kube_pod_container_status_restarts_total[15m]) > 0
-      for: 5m
-      labels:
-        severity: critical
-      annotations:
-        summary: "Pod is crash looping (pod {{ $labels.pod }})"
-        description: "Pod has restarted {{ $value }} times in the last 15 minutes"
+```python
+# Correct approach
+async def get_orders_with_items():
+    result = await session.execute(
+        select(Order)
+        .options(selectinload(Order.items))
+        .order_by(Order.created_at.desc())
+    )
+    return result.scalars().all()
 ```
 
-### Distributed Tracing (Jaeger UI)
+### Anti-Pattern 2: Synchronous Operations in Async Context
 
-**Example Trace (User Request → Order → Payment → Email)**:
-```
-Trace ID: abc123def456
-
-Span 1: [user-service] GET /api/users/123        (20ms)
-  └─ Span 2: [order-service] POST /orders        (150ms)
-       ├─ Span 3: [postgres] SELECT * FROM users (5ms)
-       ├─ Span 4: [postgres] INSERT INTO orders  (10ms)
-       └─ Span 5: [payment-service] POST /charge (100ms)
-            ├─ Span 6: [redis] GET payment_cache  (2ms)
-            └─ Span 7: [stripe-api] POST /charges (90ms)
-       └─ Span 8: [kafka] Publish order.created  (5ms)
-
-Span 9: [email-service] Kafka Consumer          (500ms)
-  └─ Span 10: [smtp] Send email                 (480ms)
+**Problem**: Blocking the event loop with synchronous operations.
+
+```python
+# Incorrect approach
+@app.get("/data")
+async def get_data():
+    # This blocks the event loop!
+    data = requests.get("https://api.example.com/data")
+    return data.json()
 ```
 
-**Benefits**:
-- Identify bottlenecks (Span 10: SMTP is slowest)
-- Visualize service dependencies
-- Root cause analysis for failures
-- Latency breakdown by service
+**Solution**: Use async-compatible libraries.
 
----
+```python
+# Correct approach
+@app.get("/data")
+async def get_data():
+    async with httpx.AsyncClient() as client:
+        response = await client.get("https://api.example.com/data")
+        return response.json()
+```
 
----
+### Anti-Pattern 3: Hardcoded Configuration
 
-## Example 5: Harbor Registry with Image Scanning
-
-### Harbor 2.10.x Deployment
-
-**Harbor Helm Installation**:
-```bash
-helm repo add harbor https://helm.goharbor.io
-helm install harbor harbor/harbor \
-  --namespace harbor \
-  --create-namespace \
-  --set expose.type=ingress \
-  --set expose.ingress.hosts.core=harbor.example.com \
-  --set externalURL=https://harbor.example.com \
-  --set persistence.enabled=true \
-  --set persistence.persistentVolumeClaim.registry.size=100Gi \
-  --set harborAdminPassword=admin123 \
-  --set trivy.enabled=true \
-  --set notary.enabled=true
-```
+**Problem**: Hardcoding configuration values in code.
 
-**Trivy Scanner Configuration**:
-```yaml
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: harbor-trivy-config
-  namespace: harbor
-data:
-  trivy.yaml: |
-    severity:
-      - CRITICAL
-      - HIGH
-      - MEDIUM
-    vuln-type:
-      - os
-      - library
-    skip-update: false
-    timeout: 5m
+```python
+# Incorrect approach
+DATABASE_URL = "postgresql://user:password@localhost:5432/db"
+SECRET_KEY = "my-super-secret-key"
 ```
 
-**Robot Account for CI/CD**:
-```bash
-# Create robot account via Harbor API
-curl -X POST "https://harbor.example.com/api/v2.0/robots" \
-  -H "Authorization: Basic $(echo -n admin:admin123 | base64)" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "name": "ci-robot",
-    "duration": -1,
-    "description": "CI/CD robot account",
-    "permissions": [
-      {
-        "kind": "project",
-        "namespace": "production",
-        "access": [
-          {"resource": "repository", "action": "push"},
-          {"resource": "repository", "action": "pull"}
-        ]
-      }
-    ]
-  }'
-```
+**Solution**: Use environment variables with validation.
 
-**GitHub Actions Integration**:
-```yaml
-# .github/workflows/build.yml
-name: Build and Push to Harbor
-on:
-  push:
-    branches: [main]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Login to Harbor
-      uses: docker/login-action@v3
-      with:
-        registry: harbor.example.com
-        username: robot$ci-robot
-        password: ${{ secrets.HARBOR_ROBOT_TOKEN }}
-
-    - name: Build and push
-      uses: docker/build-push-action@v5
-      with:
-        context: .
-        push: true
-        tags: harbor.example.com/production/backend:${{ github.sha }}
-
-    - name: Trigger Trivy scan
-      run: |
-        curl -X POST "https://harbor.example.com/api/v2.0/projects/production/repositories/backend/artifacts/${{ github.sha }}/scan" \
-          -H "Authorization: Basic ${{ secrets.HARBOR_BASIC_AUTH }}"
-
-    - name: Check scan result
-      run: |
-        while true; do
-          STATUS=$(curl -s "https://harbor.example.com/api/v2.0/projects/production/repositories/backend/artifacts/${{ github.sha }}" \
-            -H "Authorization: Basic ${{ secrets.HARBOR_BASIC_AUTH }}" | jq -r '.scan_overview."application/vnd.security.vulnerability.report; version=1.1".scan_status')
-          if [ "$STATUS" = "Success" ]; then
-            CRITICAL=$(curl -s "https://harbor.example.com/api/v2.0/projects/production/repositories/backend/artifacts/${{ github.sha }}" \
-              -H "Authorization: Basic ${{ secrets.HARBOR_BASIC_AUTH }}" | jq -r '.scan_overview."application/vnd.security.vulnerability.report; version=1.1".summary.critical')
-            if [ "$CRITICAL" -gt 0 ]; then
-              echo "CRITICAL vulnerabilities found: $CRITICAL"
-              exit 1
-            fi
-            break
-          fi
-          sleep 5
-        done
-```
+```python
+# Correct approach
+from pydantic_settings import BaseSettings
 
-**Webhook for Vulnerability Notifications**:
-```yaml
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: harbor-webhook-config
-data:
-  webhook.json: |
-    {
-      "name": "slack-vulnerabilities",
-      "description": "Notify Slack on critical vulnerabilities",
-      "events": ["SCANNING_COMPLETED"],
-      "targets": [
-        {
-          "type": "slack",
-          "address": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
-          "skip_cert_verify": false
-        }
-      ],
-      "enabled": true
-    }
+class Settings(BaseSettings):
+    database_url: str
+    secret_key: str
+    redis_url: str = "redis://localhost:6379"
+    debug: bool = False
+
+    class Config:
+        env_file = ".env"
+        case_sensitive = False
+
+settings = Settings()
 ```
 
 ---
 
-## Example 6: GitOps with ArgoCD 2.10.x
+## Integration Examples
 
-### ArgoCD Installation and Setup
+### Health Check Endpoint
 
-**Install ArgoCD**:
-```bash
-kubectl create namespace argocd
-kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/v2.10.0/manifests/install.yaml
+```python
+from fastapi import APIRouter
+from datetime import datetime
+
+router = APIRouter(prefix="/health", tags=["Health"])
+
+@router.get("")
+async def health_check(
+    db: DatabaseManager = Depends(get_db),
+    cache: redis.Redis = Depends(get_cache)
+):
+    checks = {
+        "status": "healthy",
+        "timestamp": datetime.utcnow().isoformat(),
+        "checks": {}
+    }
 
-# Get admin password
-kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d
-```
+    # Database check
+    checks["checks"]["database"] = await db.health_check()
 
-**Application Manifest (GitOps)**:
-```yaml
-# apps/backend-app.yaml
-apiVersion: argoproj.io/v1alpha1
-kind: Application
-metadata:
-  name: backend-production
-  namespace: argocd
-spec:
-  project: default
-  source:
-    repoURL: https://github.com/example/backend-manifests
-    targetRevision: main
-    path: production
-    helm:
-      values: |
-        image:
-          repository: harbor.example.com/production/backend
-          tag: latest
-        replicaCount: 3
-        resources:
-          requests:
-            cpu: 100m
-            memory: 128Mi
-          limits:
-            cpu: 500m
-            memory: 512Mi
-  destination:
-    server: https://kubernetes.default.svc
-    namespace: production
-  syncPolicy:
-    automated:
-      prune: true
-      selfHeal: true
-    syncOptions:
-    - CreateNamespace=true
-    retry:
-      limit: 5
-      backoff:
-        duration: 5s
-        factor: 2
-        maxDuration: 3m
-```
+    # Cache check
+    try:
+        await cache.ping()
+        checks["checks"]["cache"] = True
+    except Exception:
+        checks["checks"]["cache"] = False
 
-**AppProject for Multi-Tenancy**:
-```yaml
-apiVersion: argoproj.io/v1alpha1
-kind: AppProject
-metadata:
-  name: production
-  namespace: argocd
-spec:
-  description: Production environment
-  sourceRepos:
-  - 'https://github.com/example/*'
-  destinations:
-  - namespace: 'production'
-    server: https://kubernetes.default.svc
-  clusterResourceWhitelist:
-  - group: ''
-    kind: Namespace
-  - group: 'apps'
-    kind: Deployment
-  - group: 'v1'
-    kind: Service
-  namespaceResourceBlacklist:
-  - group: ''
-    kind: ResourceQuota
-  - group: ''
-    kind: LimitRange
-  roles:
-  - name: prod-admin
-    description: Admin privileges for production
-    policies:
-    - p, proj:production:prod-admin, applications, *, production/*, allow
-    groups:
-    - production-team
-```
+    # Overall status
+    if not all(checks["checks"].values()):
+        checks["status"] = "degraded"
 
-**Canary Rollout with Argo Rollouts**:
-```yaml
-apiVersion: argoproj.io/v1alpha1
-kind: Rollout
-metadata:
-  name: backend
-  namespace: production
-spec:
-  replicas: 5
-  strategy:
-    canary:
-      steps:
-      - setWeight: 20
-      - pause: {duration: 5m}
-      - setWeight: 40
-      - pause: {duration: 5m}
-      - setWeight: 60
-      - pause: {duration: 5m}
-      - setWeight: 80
-      - pause: {duration: 5m}
-      canaryService: backend-canary
-      stableService: backend-stable
-      trafficRouting:
-        istio:
-          virtualService:
-            name: backend
-            routes:
-            - primary
-  revisionHistoryLimit: 2
-  selector:
-    matchLabels:
-      app: backend
-  template:
-    metadata:
-      labels:
-        app: backend
-    spec:
-      containers:
-      - name: backend
-        image: harbor.example.com/production/backend:latest
-        ports:
-        - containerPort: 8080
-        livenessProbe:
-          httpGet:
-            path: /health/live
-            port: 8080
-        readinessProbe:
-          httpGet:
-            path: /health/ready
-            port: 8080
+    return checks
 ```
 
-**Analysis Template (Automated Rollback)**:
-```yaml
-apiVersion: argoproj.io/v1alpha1
-kind: AnalysisTemplate
-metadata:
-  name: backend-success-rate
-  namespace: production
-spec:
-  metrics:
-  - name: success-rate
-    interval: 1m
-    successCondition: result >= 0.95
-    failureLimit: 3
-    provider:
-      prometheus:
-        address: http://prometheus.observability:9090
-        query: |
-          sum(rate(http_requests_total{app="backend",status!~"5.."}[5m]))
-          /
-          sum(rate(http_requests_total{app="backend"}[5m]))
+### Structured Logging
+
+```python
+import structlog
+from fastapi import FastAPI
+
+def configure_logging():
+    structlog.configure(
+        processors=[
+            structlog.stdlib.filter_by_level,
+            structlog.stdlib.add_logger_name,
+            structlog.stdlib.add_log_level,
+            structlog.processors.TimeStamper(fmt="iso"),
+            structlog.processors.JSONRenderer()
+        ],
+        wrapper_class=structlog.stdlib.BoundLogger,
+        context_class=dict,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        cache_logger_on_first_use=True
+    )
+
+logger = structlog.get_logger()
+
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    logger.info(
+        "request_started",
+        method=request.method,
+        path=request.url.path,
+        client_ip=request.client.host
+    )
+    response = await call_next(request)
+    logger.info(
+        "request_completed",
+        status_code=response.status_code
+    )
+    return response
 ```
 
 ---
 
-## Summary
-
-These examples demonstrate production-ready backend architectures with:
-
-1. **Microservices**: Kubernetes 1.31 + Istio 1.21 for orchestration, traffic management, and security
-2. **Event-Driven**: Kafka 3.7 for event streaming, CQRS for read/write separation
-3. **Serverless**: AWS Lambda for auto-scaling, cost-effective event-driven workloads
-4. **Observability**: OpenTelemetry 1.24 + Prometheus 2.48 + Jaeger 1.51 for full-stack telemetry
-5. **Container Registry**: Harbor 2.10.x with Trivy scanning for vulnerability management
-6. **GitOps**: ArgoCD 2.10.x with automated rollouts and canary deployments
-
-All examples include:
-- Latest tool versions (2025-10-22)
-- Production-grade configurations
-- Security best practices (mTLS, RBAC, OWASP compliance, image scanning)
-- Observability integration
-- Performance optimization (connection pooling, caching, rate limiting)
-- Infrastructure as Code (Kubernetes manifests, Terraform)
-- CI/CD integration (GitHub Actions, ArgoCD)
-- Automated deployment strategies (canary, blue-green)
+*For additional patterns and advanced configurations, see the related skills and documentation.*