Skip to main content
The DevOps skill pack provides comprehensive infrastructure monitoring, automation, and observability tools for production deployments.

​
Included Services

n8n

Workflow automation and orchestration

Redis

Caching and session storage

Uptime Kuma

Service uptime monitoring

Grafana

Metrics visualization and dashboards

Prometheus

Time-series metrics collection

PostgreSQL

Relational database (dependency of n8n)

​
Skills Provided

​
n8n Trigger

Capabilities:
  • Trigger workflows via webhooks
  • Orchestrate multi-step automation
  • Integrate with 300+ services
  • Schedule recurring tasks
  • Handle event-driven workflows
Example Usage: 
# Trigger a webhook workflow
curl -X POST "http://n8n:5678/webhook/deploy-notification" \
  -H "Content-Type: application/json" \
  -d '{
    "event": "deployment_complete",
    "service": "api-server",
    "version": "v1.2.3",
    "timestamp": "2025-01-15T10:30:00Z"
  }'

# List workflows
curl -H "X-N8N-API-KEY: $N8N_API_KEY" \
  "http://n8n:5678/api/v1/workflows"

# Get workflow execution status
curl -H "X-N8N-API-KEY: $N8N_API_KEY" \
  "http://n8n:5678/api/v1/executions?workflowId=1&limit=10"

​
Redis Cache

Capabilities:
  • High-speed caching
  • Session storage
  • Rate limiting
  • Pub/Sub messaging
  • Distributed locking
Example Usage: 
# Cache API responses
redis-cli -h redis SET "api:users:123" '{"id":123,"name":"John"}' EX 3600

# Get cached data
redis-cli -h redis GET "api:users:123"

# Increment counter (rate limiting)
redis-cli -h redis INCR "rate_limit:api:192.168.1.1" EX 60

# Pub/Sub for real-time events
redis-cli -h redis PUBLISH "deployments" '{"status":"complete"}'

​
Uptime Kuma Monitor

Capabilities:
  • HTTP/HTTPS monitoring
  • TCP/UDP port checks
  • Ping monitoring
  • Certificate expiration tracking
  • Status page generation
  • Multi-channel alerting
Example Usage: 
# Add a monitor via API
curl -X POST "http://uptime-kuma:3001/api/monitor" \
  -H "Authorization: Bearer $UPTIME_KUMA_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "API Server",
    "type": "http",
    "url": "https://api.example.com/health",
    "interval": 60,
    "retryInterval": 60,
    "maxretries": 3
  }'

# Get monitor status
curl "http://uptime-kuma:3001/api/monitor/1" \
  -H "Authorization: Bearer $UPTIME_KUMA_TOKEN"

​
Grafana Dashboard

Capabilities:
  • Create custom dashboards
  • Visualize Prometheus metrics
  • Set up alerts
  • Share dashboards
  • Build panels and graphs
Example Usage: 
# Create a dashboard via API
curl -X POST "http://grafana:3000/api/dashboards/db" \
  -H "Authorization: Bearer $GRAFANA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "dashboard": {
      "title": "Service Metrics",
      "panels": [
        {
          "title": "CPU Usage",
          "type": "graph",
          "targets": [{
            "expr": "rate(process_cpu_seconds_total[5m])"
          }]
        }
      ]
    }
  }'

​
Prometheus Query

Capabilities:
  • Scrape metrics from services
  • Time-series data storage
  • PromQL queries
  • Alerting rules
  • Service discovery
Example Usage: 
# Query current CPU usage
curl 'http://prometheus:9090/api/v1/query?query=rate(process_cpu_seconds_total[5m])'

# Query memory usage over time
curl 'http://prometheus:9090/api/v1/query_range?query=process_resident_memory_bytes&start=2025-01-15T00:00:00Z&end=2025-01-15T23:59:59Z&step=15m'

# Get all targets
curl 'http://prometheus:9090/api/v1/targets'

​
Use Cases

​
Automated Deployments

Trigger deployment workflows:
  1. Code pushed to GitHub
  2. Webhook triggers n8n workflow
  3. n8n builds Docker image
  4. Deploys to production
  5. Updates Uptime Kuma monitor
  6. Sends Slack notification

​
Infrastructure Monitoring

Monitor all services: 
# Prometheus scrape config
scrape_configs:
  - job_name: 'openclaw-services'
    static_configs:
      - targets:
        - 'api:3000'
        - 'web:3654'
        - 'redis:6379'

# Query service health in Grafana
up{job="openclaw-services"}

​
Incident Response

Automate incident handling:
  1. Uptime Kuma detects service down
  2. Webhook triggers n8n workflow
  3. n8n checks Prometheus metrics
  4. Creates incident ticket
  5. Alerts on-call engineer
  6. Logs to PostgreSQL

​
Performance Optimization

Use Redis for caching: 
// Check cache first
const cached = await redis.get(`data:${id}`);
if (cached) return JSON.parse(cached);

// Fetch from database
const data = await db.query(...);

// Cache for 1 hour
await redis.set(`data:${id}`, JSON.stringify(data), 'EX', 3600);
return data;

​
Example Monitoring Workflow

​
n8n Workflow: Deploy & Notify

{
  "nodes": [
    {
      "type": "n8n-nodes-base.webhook",
      "name": "Deploy Trigger",
      "parameters": {
        "path": "deploy",
        "httpMethod": "POST"
      }
    },
    {
      "type": "n8n-nodes-base.httpRequest",
      "name": "Deploy Service",
      "parameters": {
        "url": "http://dokploy:3000/api/deploy",
        "method": "POST"
      }
    },
    {
      "type": "n8n-nodes-base.httpRequest",
      "name": "Update Monitor",
      "parameters": {
        "url": "http://uptime-kuma:3001/api/monitor/resume/1",
        "method": "POST"
      }
    },
    {
      "type": "n8n-nodes-base.slack",
      "name": "Notify Team",
      "parameters": {
        "channel": "#deployments",
        "text": "Deployment complete: {{$json.service}} v{{$json.version}}"
      }
    }
  ]
}

​
Grafana Dashboard JSON

{
  "dashboard": {
    "title": "OpenClaw Services",
    "panels": [
      {
        "title": "Request Rate",
        "type": "graph",
        "targets": [{
          "expr": "rate(http_requests_total[5m])"
        }]
      },
      {
        "title": "Error Rate",
        "type": "graph",
        "targets": [{
          "expr": "rate(http_requests_total{status=~\"5..\"}[5m])"
        }]
      },
      {
        "title": "Response Time (p95)",
        "type": "graph",
        "targets": [{
          "expr": "histogram_quantile(0.95, http_request_duration_seconds_bucket)"
        }]
      }
    ]
  }
}

​
Configuration

​
Environment Variables

# n8n
N8N_HOST=n8n
N8N_PORT=5678
N8N_API_KEY=<generated>
N8N_ENCRYPTION_KEY=<generated>

# Redis
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_PASSWORD=<generated>

# Uptime Kuma
UPTIME_KUMA_HOST=uptime-kuma
UPTIME_KUMA_PORT=3001

# Grafana
GRAFANA_HOST=grafana
GRAFANA_PORT=3000
GRAFANA_ADMIN_PASSWORD=<generated>

# Prometheus
PROMETHEUS_HOST=prometheus
PROMETHEUS_PORT=9090

# PostgreSQL (n8n dependency)
POSTGRES_HOST=postgresql
POSTGRES_PORT=5432
POSTGRES_DB=n8n
POSTGRES_USER=n8n
POSTGRES_PASSWORD=<generated>

​
Prometheus Configuration

Example prometheus.yml: 
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
  
  - job_name: 'openclaw-api'
    static_configs:
      - targets: ['api:3456']
  
  - job_name: 'redis'
    static_configs:
      - targets: ['redis:6379']
    metrics_path: '/metrics'

​
Memory Requirements

  • n8n: ~512 MB
  • PostgreSQL: ~256 MB
  • Redis: ~128 MB
  • Uptime Kuma: ~256 MB
  • Grafana: ~512 MB
  • Prometheus: ~1 GB (depends on retention)
Total: ~3 GB minimum

​
Performance Tips

​
n8n

  • Use webhooks instead of polling for real-time events
  • Enable workflow caching for repeated executions
  • Set execution timeout limits

​
Redis

  • Set appropriate TTLs on all cached data
  • Use connection pooling in applications
  • Enable persistence if data durability is needed

​
Prometheus

  • Adjust scrape_interval based on needs (15s default)
  • Set retention period: --storage.tsdb.retention.time=30d
  • Use recording rules for expensive queries

​
Grafana

  • Use dashboard variables for reusable queries
  • Set reasonable refresh intervals (1m-5m)
  • Cache query results when possible

​
Next Steps

Video Creator Pack

Add video processing capabilities

Services

Explore all available services

Build docs developers (and LLMs) love

Get started for freeTalk to us