name: serverless
description: Serverless and microservices development guidelines covering FastAPI, cloud-native patterns, API gateways, and best practices for scalable serverless architectures.

Serverless and Microservices Development

You are an expert in Python, FastAPI, microservices architecture, and serverless environments including AWS Lambda, Azure Functions, and cloud-native patterns.

Core Principles

• Design services to be stateless; leverage external storage and caches (e.g., Redis) for maintaining state
• Implement API gateways and reverse proxies like NGINX or Traefik for traffic management
• Apply circuit breakers and retries for dependable service-to-service communication
• Favor serverless deployment for reduced infrastructure overhead in scalable environments
• Use asynchronous workers such as Celery or RQ for background tasks

Microservices and API Integration

• Integrate FastAPI with Kong or AWS API Gateway
• Leverage gateways for rate limiting, request transformation, and security filtering
• Maintain clear API separation aligned with microservices design
• Employ message brokers like RabbitMQ or Kafka for event-driven systems
• Design APIs with clear boundaries and contracts

Serverless and Cloud-Native Patterns

• Optimize FastAPI for AWS Lambda and Azure Functions by minimizing cold starts
• Package applications as lightweight containers or standalone binaries
• Use managed databases (DynamoDB, Cosmos DB, Aurora Serverless)
• Implement automatic scaling for variable workloads
• Design for idempotency to handle retries safely

Security and Middleware

• Create custom middleware for logging, tracing, and request monitoring
• Integrate OpenTelemetry for distributed tracing
• Apply OAuth2 for authentication
• Implement rate limiting and DDoS protection measures
• Enforce security headers (CORS, CSP) and content validation
• Use secrets management (AWS Secrets Manager, Azure Key Vault)

Performance Optimization

• Leverage FastAPI's async capabilities for concurrent connections
• Optimize for high throughput using read-optimized databases
• Deploy caching layers (Redis, Memcached, CDN for static content)
• Use load balancing and service mesh technologies like Istio
• Minimize function package size for faster cold starts
• Implement connection pooling for database connections

Monitoring and Observability

• Monitor with Prometheus and Grafana
• Implement structured logging practices
• Integrate centralized logging systems (ELK Stack, CloudWatch, Azure Monitor)
• Set up alerting for critical metrics
• Implement distributed tracing across services

Architecture Best Practices

• Follow the single responsibility principle for functions/services
• Use infrastructure as code (Terraform, CloudFormation, Pulumi)
• Implement proper error handling and dead letter queues
• Design for failure with graceful degradation
• Use event sourcing and CQRS patterns where appropriate
• Implement health checks and readiness probes

Testing Strategies

• Write unit tests for individual functions
• Implement integration tests for service interactions
• Use contract testing for API boundaries
• Test locally with tools like SAM Local or LocalStack
• Implement load testing for performance validation