FROM python:3.11-slim

# Install dependencies
RUN apt-get update && apt-get install -y \
    build-essential \
    curl \
    && rm -rf /var/lib/apt/lists/*

# Set working directory
WORKDIR /app

# Copy requirements
COPY requirements.txt .
RUN pip install -r requirements.txt

# Copy application
COPY . .

# Run application
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

version: '3.8'

services:
  api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - AGENTIC_FLEET_API_KEY=${API_KEY}
      - DATABASE_URL=postgresql://user:pass@db:5432/fleet
    depends_on:
      - db
      - redis
      - rabbitmq

  db:
    image: postgres:14
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=fleet
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

  rabbitmq:
    image: rabbitmq:3-management
    ports:
      - "5672:5672"
      - "15672:15672"

volumes:
  postgres_data:
  redis_data:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: agentic-fleet
spec:
  replicas: 3
  selector:
    matchLabels:
      app: agentic-fleet
  template:
    metadata:
      labels:
        app: agentic-fleet
    spec:
      containers:
      - name: api
        image: agentic-fleet:latest
        ports:
        - containerPort: 8000
        env:
        - name: AGENTIC_FLEET_API_KEY
          valueFrom:
            secretKeyRef:
              name: fleet-secrets
              key: api-key
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
        readinessProbe:
          httpGet:
            path: /health
            port: 8000
        livenessProbe:
          httpGet:
            path: /health
            port: 8000

apiVersion: v1
kind: Service
metadata:
  name: agentic-fleet
spec:
  selector:
    app: agentic-fleet
  ports:
  - port: 80
    targetPort: 8000
  type: LoadBalancer

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: agentic-fleet
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
  rules:
  - host: api.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: agentic-fleet
            port:
              number: 80

# handler.py
from agentic_fleet.integrations.aws import LambdaHandler

handler = LambdaHandler()

def lambda_handler(event, context):
    return handler.handle_event(event, context)

# serverless.yml
service: agentic-fleet

provider:
  name: aws
  runtime: python3.11
  region: us-west-2

functions:
  api:
    handler: handler.lambda_handler
    events:
      - http:
          path: /chat
          method: post

# main.py
from agentic_fleet.integrations.gcp import CloudFunctionHandler

handler = CloudFunctionHandler()

def handle_request(request):
    return handler.handle_request(request)

[Unit]
Description=AgenticFleet API
After=network.target

[Service]
User=fleet
WorkingDirectory=/opt/agentic-fleet
Environment=PATH=/opt/agentic-fleet/venv/bin
ExecStart=/opt/agentic-fleet/venv/bin/uvicorn app:app --host 0.0.0.0 --port 8000
Restart=always

[Install]
WantedBy=multi-user.target

server {
    listen 80;
    server_name api.example.com;

    location / {
        proxy_pass http://localhost:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'agentic-fleet'
    static_configs:
      - targets: ['localhost:8000']

{
  "dashboard": {
    "title": "AgenticFleet Metrics",
    "panels": [
      {
        "title": "Request Rate",
        "type": "graph",
        "targets": [
          {
            "expr": "rate(http_requests_total[5m])"
          }
        ]
      }
    ]
  }
}

# Use environment variables
export AGENTIC_FLEET_API_KEY=xxx
export DATABASE_URL=xxx

import structlog

logger = structlog.get_logger()
logger.info("api_request", endpoint="/chat", status="success")

from agentic_fleet.exceptions import FleetError

try:
    await process_request()
except FleetError as e:
    logger.error("request_failed", error=str(e))
    raise HTTPException(status_code=500)

# Use connection pooling
pool = ConnectionPool(
    min_size=5,
    max_size=20
)

# Use caching
cache = RedisCache(
    url="redis://localhost",
    ttl=300
)