Deployment Guide

How Crella.ai services are deployed and how to deploy integrations.

Crella Infrastructure

Architecture Overview

flowchart TB
    subgraph public [Public Internet]
        Users[Users/Clients]
        API[API Clients]
    end
    
    subgraph edge [Edge Layer]
        CDN[Cloudflare CDN]
        LB[Load Balancer]
    end
    
    subgraph app [Application Layer]
        Web[Web Apps]
        APIServer[API Servers]
        Workers[Background Workers]
    end
    
    subgraph data [Data Layer]
        DB[(PostgreSQL)]
        Cache[(Redis)]
        Queue[(Message Queue)]
    end
    
    Users --> CDN
    API --> LB
    CDN --> Web
    LB --> APIServer
    APIServer --> Workers
    Workers --> DB
    Workers --> Cache
    Workers --> Queue

Current Stack

Component	Technology
Web Server	Nginx
Process Manager	PM2
Runtime	Node.js 20.x
Framework	Next.js
Database	PostgreSQL / SQLite
Cache	Redis
Queue	Redis / BullMQ

Self-Hosting (Enterprise)

For enterprise customers, Crella can be deployed on-premises or in your cloud.

Requirements

Resource	Minimum	Recommended
CPU	4 cores	8+ cores
RAM	16 GB	32+ GB
Storage	100 GB SSD	500+ GB SSD
Network	100 Mbps	1 Gbps

Docker Deployment

# docker-compose.yml
version: '3.8'

services:
  crella-api:
    image: crella/api:latest
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgresql://...
      - REDIS_URL=redis://redis:6379
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - OPENAI_API_KEY=${OPENAI_API_KEY}
    depends_on:
      - postgres
      - redis

  crella-worker:
    image: crella/worker:latest
    environment:
      - DATABASE_URL=postgresql://...
      - REDIS_URL=redis://redis:6379
    depends_on:
      - postgres
      - redis

  postgres:
    image: postgres:15
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=${DB_PASSWORD}

  redis:
    image: redis:7-alpine
    volumes:
      - redisdata:/data

volumes:
  pgdata:
  redisdata:

Kubernetes Deployment

# crella-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: crella-api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: crella-api
  template:
    metadata:
      labels:
        app: crella-api
    spec:
      containers:
      - name: api
        image: crella/api:latest
        ports:
        - containerPort: 3000
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "2Gi"
            cpu: "1000m"
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: crella-secrets
              key: database-url

Integrating with Your Deployment

Environment Variables

# Required
CRELLA_API_KEY=your_api_key

# Optional
CRELLA_BASE_URL=https://api.crella.ai  # Default
CRELLA_TIMEOUT=30000  # 30 seconds
CRELLA_RETRIES=3

Health Checks

# Check API health
curl https://api.crella.ai/health

# Response
{
  "status": "healthy",
  "version": "1.0.0",
  "agents": {
    "online": 20,
    "total": 20
  }
}

Monitoring Integration

Prometheus Metrics

# prometheus.yml
scrape_configs:
  - job_name: 'crella'
    static_configs:
      - targets: ['your-app:9090']
    metrics_path: '/metrics'

Datadog

import { datadogRum } from '@datadog/browser-rum';

// Track Crella API calls
datadogRum.addAction('crella_api_call', {
  agent: 'ALPHA001',
  task_type: 'validation',
  duration_ms: 180
});

CI/CD Integration

GitHub Actions

# .github/workflows/deploy.yml
name: Deploy

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Test Crella Integration
        env:
          CRELLA_API_KEY: ${{ secrets.CRELLA_API_KEY }}
        run: npm test
      
      - name: Deploy
        run: |
          # Your deployment steps

Testing in CI

// Use sandbox API key in CI
const crella = new Crella({
  apiKey: process.env.CRELLA_SANDBOX_KEY,
  environment: 'sandbox'
});

describe('Crella Integration', () => {
  it('should validate leads', async () => {
    const result = await crella.tasks.create({
      agent: 'ALPHA001',
      type: 'validate',
      payload: { name: 'Test', email: 'test@example.com' }
    });
    expect(result.status).toBe('completed');
  });
});

Security

API Key Management

• Store keys in secrets manager (AWS Secrets Manager, HashiCorp Vault)
• Rotate keys regularly
• Use separate keys for dev/staging/production

Network Security

• HTTPS required for all API calls
• IP whitelisting available for enterprise
• Rate limiting enforced

Data Handling

• Data encrypted in transit (TLS 1.3)
• Data encrypted at rest
• GDPR compliant processing

Support

• Enterprise Support: enterprise@crella.ai
• Documentation: docs.crella.ai
• Status: status.crella.ai