Deployment Guide

FROM python:3.11-slim

WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY . .

# Expose API port
EXPOSE 8000

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

version: '3.8'

services:
  cognition-engine:
    build: .
    ports:
      - "8000:8000"
    environment:
      - SUPABASE_URL=${SUPABASE_URL}
      - SUPABASE_KEY=${SUPABASE_KEY}
    volumes:
      - ./data:/app/data
    restart: unless-stopped

# Build image
docker build -t cognition-engine .

# Run container
docker run -p 8000:8000 \
  -e SUPABASE_URL="your-url" \
  -e SUPABASE_KEY="your-key" \
  cognition-engine

apiVersion: apps/v1
kind: Deployment
metadata:
  name: cognition-engine
spec:
  replicas: 3
  selector:
    matchLabels:
      app: cognition-engine
  template:
    metadata:
      labels:
        app: cognition-engine
    spec:
      containers:
      - name: cognition-engine
        image: cognition-engine:latest
        ports:
        - containerPort: 8000
        env:
        - name: SUPABASE_URL
          valueFrom:
            secretKeyRef:
              name: supabase-secrets
              key: url
        - name: SUPABASE_KEY
          valueFrom:
            secretKeyRef:
              name: supabase-secrets
              key: key
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"

apiVersion: v1
kind: Service
metadata:
  name: cognition-engine-service
spec:
  selector:
    app: cognition-engine
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8000
  type: LoadBalancer

@app.get("/health")
async def health_check():
    return {
        "status": "healthy",
        "timestamp": datetime.now(),
        "version": "1.0.0"
    }

livenessProbe:
  httpGet:
    path: /health
    port: 8000
  initialDelaySeconds: 30
  periodSeconds: 10

readinessProbe:
  httpGet:
    path: /health
    port: 8000
  initialDelaySeconds: 5
  periodSeconds: 5

from prometheus_client import Counter, Histogram

# Track metrics
api_requests = Counter('api_requests_total', 'Total API requests')
response_time = Histogram('api_response_time', 'API response time')

@app.middleware("http")
async def track_metrics(request, call_next):
    start_time = time.time()
    response = await call_next(request)
    
    api_requests.inc()
    response_time.observe(time.time() - start_time)
    
    return response

import logging
import sys

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler(sys.stdout),
        logging.FileHandler('cognition_engine.log')
    ]
)

from sqlalchemy.pool import QueuePool

engine = create_engine(
    database_url,
    poolclass=QueuePool,
    pool_size=20,
    max_overflow=40
)

from slowapi import Limiter
from slowapi.util import get_remote_address

limiter = Limiter(key_func=get_remote_address)

@app.post("/track-answer")
@limiter.limit("100/minute")
async def track_answer(request: Request, ...):
    ...

# Automated backup script
pg_dump $DATABASE_URL > backup_$(date +%Y%m%d).sql