Deploy to Production

cd my-agent
docker build -t my-agent:latest .
 
docker run -d \
  --name my-agent \
  -p 8080:8080 \
  -v $(pwd)/.ows:/app/.ows:ro \
  -v $(pwd)/memory.db:/app/memory.db \
  -v $(pwd)/replays:/app/replays \
  -v $(pwd)/logs:/app/logs \
  -e OPENROUTER_API_KEY=$OPENROUTER_API_KEY \
  -e OWS_API_KEY=$OWS_API_KEY \
  my-agent:latest

docker-compose up -d
docker-compose logs -f

curl localhost:8080/ready
# {"ready": true, "reason": "ok"}
 
curl localhost:8080/metrics
# Prometheus text format

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: eth-swing
spec:
  serviceName: eth-swing
  replicas: 1
  selector:
    matchLabels:
      app: eth-swing
  template:
    metadata:
      labels:
        app: eth-swing
    spec:
      containers:
      - name: agent
        image: ghcr.io/yourorg/eth-swing:latest
        ports:
        - containerPort: 8080
          name: health
        - containerPort: 9001
          name: a2a
        env:
        - name: OPENROUTER_API_KEY
          valueFrom:
            secretKeyRef:
              name: agent-secrets
              key: openrouter-api-key
        - name: OWS_API_KEY
          valueFrom:
            secretKeyRef:
              name: agent-secrets
              key: ows-api-key
        livenessProbe:
          httpGet:
            path: /health
            port: health
          initialDelaySeconds: 10
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: health
          initialDelaySeconds: 30
          periodSeconds: 15
        volumeMounts:
        - name: state
          mountPath: /app/.ows
          subPath: ows
        - name: state
          mountPath: /app/memory.db
          subPath: memory.db
        - name: state
          mountPath: /app/replays
          subPath: replays
        resources:
          requests:
            cpu: "100m"
            memory: "256Mi"
          limits:
            cpu: "1000m"
            memory: "1Gi"
  volumeClaimTemplates:
  - metadata:
      name: state
    spec:
      accessModes: ["ReadWriteOnce"]
      resources:
        requests:
          storage: 10Gi

- job_name: aether-agents
  kubernetes_sd_configs:
  - role: pod
  relabel_configs:
  - source_labels: [__meta_kubernetes_pod_label_app]
    regex: (.+)
    action: keep
  - source_labels: [__meta_kubernetes_pod_container_port_name]
    regex: health
    action: keep
  metrics_path: /metrics

kubectl create secret generic agent-secrets \
  --from-literal=openrouter-api-key=$OPENROUTER_API_KEY \
  --from-literal=ows-api-key=$OWS_API_KEY

# lambda_handler.py
from pathlib import Path
import boto3
from aether_forge.runner import AgentRunner, RunnerConfig
 
s3 = boto3.client("s3")
 
def handler(event, context):
    # Pull state
    s3.download_file("agent-state", "memory.db", "/tmp/memory.db")
 
    runner = AgentRunner(Path("/var/task/agent"), RunnerConfig(
        environment="live",
        memory_db_path="/tmp/memory.db",
        auto_approve=True,
    ))
    runner._initialize()
    result = runner.tick()
 
    # Push state back
    s3.upload_file("/tmp/memory.db", "agent-state", "memory.db")
 
    return {"statusCode": 200, "body": str(result)}

fly deploy
railway up