Cara Deploy OpenClaw
di VPS Linux Menggunakan Docker

Pendahuluan

Deploy aplikasi langsung di VPS itu mudah, tapi maintainnya yang susah. Dependency conflict, environment inconsistency, upgrade nightmare—semua masalah klasik yang bikin developer stress.

Docker solve semua masalah itu. Dengan containerization, OpenClaw dan semua dependencynya dikemas jadi satu package yang portable, consistent di environment manapun, dan mudah di-scale.

Artikel ini akan bahas cara deploy OpenClaw menggunakan Docker secara production-ready: dari Dockerfile, Docker Compose, volume management, networking, sampai deployment best practices.

Kenapa Deploy dengan Docker?

Install Docker di VPS Linux

1. Install Docker Engine

# Update package list
sudo apt update

# Install dependencies
sudo apt install apt-transport-https ca-certificates curl software-properties-common -y

# Add Docker GPG key
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Add Docker repository
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install Docker
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io -y

# Start Docker
sudo systemctl start docker
sudo systemctl enable docker

#Verify installation
docker --version

2. Install Docker Compose

# Download Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# Make it executable
sudo chmod +x /usr/local/bin/docker-compose

# Verify
docker-compose --version

3. Add User to Docker Group (Opsional)

sudo usermod -aG docker $USER
newgrp docker

# Test without sudo
docker ps

Membuat Dockerfile untuk OpenClaw

Dockerfile adalah blueprint untuk build container image.

1. Basic Dockerfile

nano ~/openclaw/Dockerfile

# Use official Node.js LTS image
FROM node:20-alpine

# Set working directory
WORKDIR /app

# Copy package files
COPY package*.json ./

# Install dependencies
RUN npm install --production

# Copy application code
COPY . .

# Build TypeScript
RUN npm run build

# Create non-root user
RUN addgroup -g 1001 -S openclaw && \
    adduser -S openclaw -u 1001 && \
    chown -R openclaw:openclaw /app

# Switch to non-root user
USER openclaw

# Expose port
EXPOSE 3000

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
  CMD node -e "require('http').get('http://localhost:3000/health', (r) => process.exit(r.statusCode === 200 ? 0 : 1))"

# Start application
CMD ["node", "dist/index.js"]

2. Multi-Stage Build (Optimized)

# Build stage
FROM node:20-alpine AS builder

WORKDIR /app

COPY package*.json ./
RUN npm install

COPY . .
RUN npm run build

# Production stage
FROM node:20-alpine

WORKDIR /app

# Copy only production dependencies
COPY package*.json ./
RUN npm install --production

# Copy built files from builder
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/config ./config

# Create non-root user
RUN addgroup -g 1001 -S openclaw && \
    adduser -S openclaw -u 1001 && \
    chown -R openclaw:openclaw /app

USER openclaw

EXPOSE 3000

HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
  CMD node -e "require('http').get('http://localhost:3000/health', (r) => process.exit(r.statusCode === 200 ? 0 : 1))"

CMD ["node", "dist/index.js"]

3. .dockerignore File

nano ~/openclaw/.dockerignore

node_modules
npm-debug.log
.env
.env.local
.git
.gitignore
README.md
.vscode
.idea
dist
logs
*.log
coverage
.DS_Store

4. Build Docker Image

cd ~/openclaw
docker build -t openclaw:latest .

# Check image
docker images | grep openclaw

Docker Compose Setup

Docker Compose untuk orchestrate multiple containers dengan mudah.

1. Basic docker-compose.yml

nano ~/openclaw/docker-compose.yml

version: '3.8'

services:
  openclaw:
    build: .
    container_name: openclaw
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - PORT=3000
      - HOST=0.0.0.0
    env_file:
      - .env
    volumes:
      - ./data:/app/data
      - ./logs:/app/logs
      - ./tasks:/app/tasks
    networks:
      - openclaw-network
    healthcheck:
      test: ["CMD", "node", "-e", "require('http').get('http://localhost:3000/health', (r) => process.exit(r.statusCode === 200 ? 0 : 1))"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

networks:
  openclaw-network:
    driver: bridge

2. With Database & Redis

version: '3.8'

services:
  openclaw:
    build: .
    container_name: openclaw
    restart: unless-stopped
    ports:
      - "3000:3000"
    env_file:
      - .env
    volumes:
      - ./data:/app/data
      - ./logs:/app/logs
      - ./tasks:/app/tasks
    depends_on:
      - redis
      - postgres
    networks:
      - openclaw-network

  redis:
    image: redis:7-alpine
    container_name: openclaw-redis
    restart: unless-stopped
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data
    networks:
      - openclaw-network

  postgres:
    image: postgres:15-alpine
    container_name: openclaw-postgres
    restart: unless-stopped
    environment:
      POSTGRES_DB: openclaw
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - openclaw-network

volumes:
  redis-data:
  postgres-data:

networks:
  openclaw-network:
    driver: bridge

3. With Nginx Reverse Proxy

version: '3.8'

services:
  openclaw:
    build: .
    container_name: openclaw
    restart: unless-stopped
    expose:
      - "3000"
    env_file:
      - .env
    volumes:
      - ./data:/app/data
      - ./logs:/app/logs
      - ./tasks:/app/tasks
    networks:
      - openclaw-network

  nginx:
    image: nginx:alpine
    container_name: openclaw-nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/ssl:/etc/nginx/ssl:ro
    depends_on:
      - openclaw
    networks:
      - openclaw-network

networks:
  openclaw-network:
    driver: bridge

Volume Management

Volume untuk persist data di luar container lifecycle.

1. Named Volumes

volumes:
  openclaw-data:
    driver: local
  openclaw-logs:
    driver: local

services:
  openclaw:
    volumes:
      - openclaw-data:/app/data
      - openclaw-logs:/app/logs

2. Bind Mounts

services:
  openclaw:
    volumes:
      - ./data:/app/data:rw
      - ./logs:/app/logs:rw
      - ./config:/app/config:ro  # Read-only

3. Backup Volume Data

# Backup
docker run --rm \
  -v openclaw-data:/data \
  -v $(pwd)/backup:/backup \
  alpine tar czf /backup/openclaw-data-$(date +%Y%m%d).tar.gz -C /data .

# Restore
docker run --rm \
  -v openclaw-data:/data \
  -v $(pwd)/backup:/backup \
  alpine tar xzf /backup/openclaw-data-20260209.tar.gz -C /data

Container Networking

1. Custom Network

# Create network
docker network create openclaw-net

# Run with network
docker run -d --name openclaw --network openclaw-net openclaw:latest

2. Container Communication

# Container bisa communicate by service name
# Dari OpenClaw, akses Redis:
REDIS_URL=redis://redis:6379

# Akses PostgreSQL:
DB_HOST=postgres
DB_PORT=5432

Deployment ke VPS

1. Deploy dengan Docker Compose

#Build dan start
docker-compose up -d --build

# Check status
docker-compose ps

# View logs
docker-compose logs -f openclaw

# Stop
docker-compose down

# Stop dan remove volumes (WARNING: data akan hilang)
docker-compose down -v

2. Update Deployment

# Pull latest code
git pull origin main

# Rebuild dan restart
docker-compose up -d --build

# Zero-downtime update (dengan load balancer)
docker-compose up -d --no-deps --build openclaw

3. Automated Deployment Script

nano ~/deploy.sh

#!/bin/bash
set -e

echo "🚀 Starting deployment..."

# Backup data
echo "📦 Backing up data..."
docker-compose exec openclaw npm run backup

# Pull latest code
echo "📥 Pulling latest code..."
git pull origin main

# Build new image
echo "🔨 Building Docker image..."
docker-compose build

# Stop old container
echo "🛑 Stopping old container..."
docker-compose stop openclaw

# Start new container
echo "▶️  Starting new container..."
docker-compose up -d openclaw

# Wait for health check
echo "🏥 Waiting for health check..."
sleep 10
docker-compose exec openclaw wget -qO- http://localhost:3000/health

# Cleanup old images
echo "🧹 Cleaning up..."
docker image prune -f

echo "✅ Deployment completed!"

chmod +x ~/deploy.sh
./deploy.sh

Monitoring Container

1. Basic Monitoring Commands

# Container status
docker-compose ps

# Resource usage
docker stats openclaw

# Logs
docker-compose logs -f --tail=100 openclaw

# Execute command inside container
docker-compose exec openclaw sh

# Inspect container
docker inspect openclaw

2. Docker System Info

# Disk usage
docker system df

# Clean up unused resources
docker system prune -a --volumes -f

VPS untuk Docker Deployment

Docker butuh resource yang cukup, terutama RAM.

FAQ

Apakah Docker lebih boros resource?

Overhead Docker sangat minimal (sekitar 100-200MB RAM). Benefit yang didapat (isolation, portability, easy scaling) worth it banget.

Berapa RAM minimal untuk Docker?

Minimal 2GB, tapi disarankan 4GB untuk comfortable. Kalau mau run multiple containers (OpenClaw + DB + Redis), 4-8GB lebih ideal.

Bagaimana cara backup container?

Backup volume data-nya aja, bukan container. Container bisa di-recreate dari image kapanpun. Yang penting data dan config di-backup.

Docker vs PM2, mana yang lebih baik?

Tergantung use case. PM2 lebih simpel untuk single app. Docker lebih powerfull untuk multi-service, multiple environments, atau kalau butuh portability dan scaling.

Kesimpulan

Deploy OpenClaw dengan Docker adalah best practice untuk production. Dengan containerization, kamu dapat:

• Consistency → same environment di dev, staging, production
• Isolation → no dependency conflicts
• Portability → deploy anywhere yang support Docker
• Scalability → easy horizontal scaling
• Easy rollback → tinggal switch image version

Setup awal memang lebih kompleks dibanding deployment tradisional, tapi long-term benefit-nya huge, especially untuk production system.

👉 Langkah Selanjutnya

Modern deployment butuh modern infrastructure.