Multi-Server & Scaling

┌─────────────────────────────────────────────────────────┐
│                    Coolify Dashboard                     │
│                  (Management Server)                     │
│                   RamNode NYC - 4GB                      │
└─────────────────────┬───────────────────────────────────┘
                      │ SSH + Docker API
        ┌─────────────┼─────────────┐
        │             │             │
        ▼             ▼             ▼
┌───────────┐  ┌───────────┐  ┌───────────┐
│  Worker 1 │  │  Worker 2 │  │  Worker 3 │
│  NYC 8GB  │  │  LA 8GB   │  │  NL 8GB   │
│ (US-East) │  │ (US-West) │  │ (Europe)  │
└───────────┘  └───────────┘  └───────────┘

ssh root@new-server-ip

# Update system
apt update && apt upgrade -y

# Install Docker (Coolify needs this)
curl -fsSL https://get.docker.com | sh

# Verify Docker is running
systemctl status docker

# Generate a dedicated key if you don't have one
ssh-keygen -t ed25519 -C "coolify-deploy" -f ~/.ssh/coolify_deploy

# Copy the public key to the remote server
ssh-copy-id -i ~/.ssh/coolify_deploy.pub root@new-server-ip

# Test the connection
ssh -i ~/.ssh/coolify_deploy root@new-server-ip "echo 'Connection successful'"

Primary (NYC) ─── Active, handles all traffic
    │
    └── DNS points here
    
Standby (LA) ─── Deployed, idle, ready to activate

                    ┌─── Worker NYC
                    │
User ─── Load Balancer ───┤
                    │
                    └─── Worker LA

US Users ─────── Worker NYC
EU Users ─────── Worker NL
APAC Users ───── Worker (or closest available)

version: "3.8"

services:
  haproxy:
    image: haproxy:2.9
    restart: always
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
      - ./certs:/etc/ssl/certs:ro

global
    log stdout format raw local0

defaults
    mode http
    timeout connect 5s
    timeout client 30s
    timeout server 30s
    option httpchk GET /health

frontend http
    bind *:80
    redirect scheme https code 301 if !{ ssl_fc }

frontend https
    bind *:443 ssl crt /etc/ssl/certs/combined.pem
    default_backend app_servers

backend app_servers
    balance roundrobin
    option httpchk GET /health
    server nyc worker-nyc-ip:80 check
    server la worker-la-ip:80 check

Worker NYC ───┐
              ├──── Database Server (NYC)
Worker LA ────┘

Primary DB (NYC) ───── Replica DB (LA)
       │                      │
   Worker NYC             Worker LA
   (read/write)           (read-only)

# On primary - postgresql.conf
wal_level = replica
max_wal_senders = 3

# On primary - pg_hba.conf
host replication replicator replica-ip/32 scram-sha-256

# On replica
pg_basebackup -h primary-ip -D /var/lib/postgresql/data -U replicator -P -R

# On your database server or dedicated node
services:
  redis-sessions:
    image: redis:7-alpine
    restart: always
    ports:
      - "6379:6379"
    command: redis-server --requirepass ${REDIS_PASSWORD}
    volumes:
      - redis-data:/data

const RedisStore = require('connect-redis').default;
const redis = require('redis');

const redisClient = redis.createClient({
  url: `redis://:${process.env.REDIS_PASSWORD}@redis-server-ip:6379`
});

app.use(session({
  store: new RedisStore({ client: redisClient }),
  secret: process.env.SESSION_SECRET,
  resave: false,
  saveUninitialized: false
}));

SESSION_DRIVER=redis
REDIS_HOST=redis-server-ip
REDIS_PASSWORD=your-password
REDIS_PORT=6379

const { S3Client, PutObjectCommand } = require('@aws-sdk/client-s3');

const s3 = new S3Client({
  region: 'us-east-1',
  endpoint: 'https://s3.us-east-1.amazonaws.com', // or Backblaze, Wasabi, etc.
  credentials: {
    accessKeyId: process.env.S3_ACCESS_KEY,
    secretAccessKey: process.env.S3_SECRET_KEY
  }
});

async function uploadFile(buffer, key) {
  await s3.send(new PutObjectCommand({
    Bucket: process.env.S3_BUCKET,
    Key: key,
    Body: buffer
  }));
}

version: "3.8"

services:
  loki:
    image: grafana/loki:2.9.0
    ports:
      - "3100:3100"
    volumes:
      - loki-data:/loki

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
    volumes:
      - grafana-data:/var/lib/grafana

volumes:
  loki-data:
  grafana-data:

{
  "log-driver": "loki",
  "log-opts": {
    "loki-url": "http://management-server-ip:3100/loki/api/v1/push",
    "loki-batch-size": "400"
  }
}

bash <(curl -Ss https://get.netdata.cloud/kickstart.sh)

// Use Redis for sessions
const RedisStore = require('connect-redis').default;
app.use(session({
  store: new RedisStore({ client: redisClient }),
  // ...
}));

// Health endpoint for load balancer
app.get('/health', (req, res) => {
  res.json({ status: 'healthy', server: process.env.SERVER_ID });
});

// Graceful shutdown
process.on('SIGTERM', () => {
  console.log('SIGTERM received, shutting down gracefully');
  server.close(() => {
    console.log('Server closed');
    process.exit(0);
  });
});

backend api_servers
    balance roundrobin
    option httpchk GET /health
    server nyc worker-nyc-ip:3000 check
    server la worker-la-ip:3000 check

# Hit the endpoint multiple times
for i in {1..10}; do
  curl -s https://api.yourdomain.com/health | jq .server
done

# Should alternate between servers
"nyc"
"la"
"nyc"
"la"
...