# Cloud Platforms

Deploy SteelEngine on cloud platforms

For enabled self-hosted Organization Releases targets, configure [scheduled branch sync](/self-hosting/releases/kubernetes-setup). Kubernetes installations can use the chart's CronJob; other platforms can call the authenticated sync endpoint from their own scheduler. The same applies to [model retirement notices](/blocks/agent): Kubernetes installations run them from the chart's `modelRetirementNotices` CronJob, and other platforms call `GET /api/cron/model-retirement-notices` once a day with `Authorization: Bearer $CRON_SECRET`. Without that call the dashboard alert still appears, but no email or in-app notification is sent.

## VPS Deployment

For DigitalOcean, AWS EC2, Azure VMs, or any Linux server:

**DigitalOcean**

**Recommended:** 16 GB RAM Droplet, Ubuntu 24.04

```bash
# Create Droplet via console, then SSH in
ssh root@your-droplet-ip
```

**AWS EC2**

**Recommended:** t3.xlarge (16 GB RAM), Ubuntu 24.04

```bash
ssh -i your-key.pem ubuntu@your-ec2-ip
```

**Azure VM**

**Recommended:** Standard\_D4s\_v3 (16 GB RAM), Ubuntu 24.04

```bash
ssh azureuser@your-vm-ip
```

16 GB covers the 13 GB of container memory limits in the Compose file plus PostgreSQL. The limits are 8 GB for the app, 4 GB for the Temporal Worker, and 1 GB for realtime. The Temporal server is not in the Compose file. Run it on a separate host, or size the VM for it as well. See [Temporal](/self-hosting/temporal). The optional [Laya Decision](/self-hosting/docker#laya-decision) server adds 6 GB more.

### Install Docker

```bash
# Install Docker (official method)
curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker $USER

# Logout and reconnect, then verify
docker --version
```

### Deploy SteelEngine

```bash
git clone https://github.com/steelengineai/steelengine.git && cd steelengine

# Create .env with secrets, public URLs, and your Temporal server
cat > .env << EOF
BETTER_AUTH_SECRET=$(openssl rand -hex 32)
ENCRYPTION_KEY=$(openssl rand -hex 32)
INTERNAL_API_SECRET=$(openssl rand -hex 32)
TEMPORAL_WORKER_BROKER_SECRET=$(openssl rand -hex 32)
POSTGRES_PASSWORD=$(openssl rand -hex 16)
NEXT_PUBLIC_APP_URL=https://steelengine.yourdomain.com
BETTER_AUTH_URL=https://steelengine.yourdomain.com
NEXT_PUBLIC_SOCKET_URL=https://steelengine.yourdomain.com
TEMPORAL_WORKER_APP_URL=https://steelengine.yourdomain.com
TEMPORAL_ADDRESS=temporal.yourdomain.com:7233
TEMPORAL_NAMESPACE=steelengine-production
TEMPORAL_SERVER_NAME=temporal.yourdomain.com
TEMPORAL_AUTH_ISSUER=https://steelengine.yourdomain.com
TEMPORAL_AUTH_JWKS_URL=https://steelengine.yourdomain.com/api/auth/jwks
TEMPORAL_BUILD_ID=<image digest or git sha>
EOF

# Sign in with the registry credentials from your subscription, then start
docker login ghcr.io
docker compose -f docker/selfhost/compose.yml up -d
```

The [Docker guide](/self-hosting/docker#1-configure-environment) explains each variable. Compose stops immediately if `TEMPORAL_WORKER_BROKER_SECRET` or `TEMPORAL_WORKER_APP_URL` is missing.

To authenticate deployment pipelines with Entra, configure `WORKLOAD_AUTH_ENABLED` and `WORKLOAD_AUTH_PROFILE` in `.env`; Compose forwards them to web and worker. Follow [Entra workload identities](/self-hosting/entra-workload-identities) before registering organization applications and permissions.

For internal services, set `EGRESS_ALLOWLIST` and `ALLOWED_MCP_DOMAINS` in `.env`; production Compose passes them to both the app and Worker. If API and webhook callers use a separate host, set `PUBLIC_API_URL`. It otherwise defaults to `NEXT_PUBLIC_APP_URL`. Follow [Private Network Configuration](/self-hosting/docker#private-network-configuration) before testing workflow and MCP calls.

### SSL with Caddy

```bash
# Install Caddy
sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update && sudo apt install caddy

# Configure (replace domain)
echo 'steelengine.yourdomain.com {
    reverse_proxy localhost:3000
    handle /socket.io/* {
        reverse_proxy localhost:3002
    }
}' | sudo tee /etc/caddy/Caddyfile

sudo systemctl restart caddy
```

Point your domain's DNS A record to your server IP. Then open `https://steelengine.yourdomain.com/signup` and create the first account. Only an empty database accepts a sign-up without an invitation, so that account is the first admin, and everyone else joins by invitation.

## Kubernetes (EKS, AKS, GKE)

See the [Kubernetes guide](/self-hosting/kubernetes) for Helm deployment on managed Kubernetes.

## Managed Database (Optional)

For production, use a managed PostgreSQL service:

* **AWS RDS** / **Azure Database** / **Cloud SQL** - Enable pgvector extension
* **Supabase** / **Neon** - pgvector included

With Helm, point the chart at it through `externalDatabase`. See [Kubernetes → External Database](/self-hosting/kubernetes#external-database). The Compose file assembles `DATABASE_URL` from `POSTGRES_USER`, `POSTGRES_PASSWORD`, and `POSTGRES_DB` and always targets its bundled `db` service. A `DATABASE_URL` in `.env` is ignored. Edit the `DATABASE_URL` lines for `steelengine`, `steelengine-worker`, `realtime`, and `migrations` in `docker/selfhost/compose.yml` instead.

Helm also supports an explicit full-URL key in the app Secret for the app and migrations. The Worker and realtime still use the chart's database settings. See [Database Secrets](/self-hosting/kubernetes#database-secrets) before enabling that override.

```bash
DATABASE_URL="postgresql://user:pass@host:5432/db?sslmode=require"
```

The published images run with `NODE_ENV=production`. The connection pool then requires TLS even when the URL has no `sslmode`. Only `?sslmode=disable` turns it off. Every service needs the same `DATABASE_URL`. The Temporal Worker opens up to 25 connections and the app up to 20. If the app's `DATABASE_URL` goes through a transaction pooler such as PgBouncer, also set `DATABASE_SESSION_URL` to the direct URL for its advisory locks. The Helm chart does this with [`pgbouncer.enabled`](/self-hosting/kubernetes#connection-pooling-pgbouncer).
