Step‑By‑Step Docker Compose Deployment of SigNoz on a $5 VPS with Automatic TLS and Alertmanager Integration

sudo fallocate -l 1G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

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

# Set up the stable 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 Engine
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io

# Verify installation
docker run --rm hello-world

DOCKER_COMPOSE_VERSION=$(curl -s https://api.github.com/repos/docker/compose/releases/latest | grep tag_name | cut -d '"' -f4)
sudo curl -L "https://github.com/docker/compose/releases/download/${DOCKER_COMPOSE_VERSION}/docker-compose-$(uname -s)-$(uname -m)" \
  -o /usr/local/lib/docker/cli-plugins/docker-compose
sudo chmod +x /usr/local/lib/docker/cli-plugins/docker-compose

# Test
docker compose version

sudo usermod -aG docker $USER
newgrp docker

mkdir -p ~/signoz/{caddy,alertmanager}
cd ~/signoz

signoz/
├─ docker-compose.yml
├─ caddy/
│  └─ Caddyfile
└─ alertmanager/
   └─ alertmanager.yml

# docker-compose.yml
version: "3.8"

services:
  # Core observability stack
  clickhouse:
    image: clickhouse/clickhouse-server:23.9
    restart: unless-stopped
    volumes:
      - clickhouse-data:/var/lib/clickhouse
    ulimits:
      nofile:
        soft: 262144
        hard: 262144

  postgres:
    image: postgres:15-alpine
    restart: unless-stopped
    environment:
      POSTGRES_USER: signoz
      POSTGRES_PASSWORD: signoz
      POSTGRES_DB: signoz
    volumes:
      - postgres-data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    restart: unless-stopped
    command: ["redis-server", "--save", "60", "1", "--loglevel", "warning"]

  kafka:
    image: bitnami/kafka:3.5
    restart: unless-stopped
    environment:
      KAFKA_CFG_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_CFG_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092
      ALLOW_PLAINTEXT_LISTENER: "yes"
    depends_on:
      - zookeeper

  zookeeper:
    image: bitnami/zookeeper:3.8
    restart: unless-stopped
    environment:
      ALLOW_ANONYMOUS_LOGIN: "yes"

  signoz-frontend:
    image: signoz/signoz-frontend:latest
    restart: unless-stopped
    environment:
      VITE_APP_BACKEND_URL: http://signoz:8080
    depends_on:
      - signoz

  signoz:
    image: signoz/signoz:latest
    restart: unless-stopped
    environment:
      # Database connections
      POSTGRES_HOST: postgres
      POSTGRES_PORT: 5432
      POSTGRES_USER: signoz
      POSTGRES_PASSWORD: signoz
      POSTGRES_DB: signoz
      CLICKHOUSE_HOST: clickhouse
      CLICKHOUSE_PORT: 9000
      # Kafka
      KAFKA_BOOTSTRAP_SERVERS: kafka:9092
      # Alertmanager webhook URL (set later)
      ALERTMANAGER_WEBHOOK_URL: http://alertmanager:9093/api/v2/alerts
    ports:
      - "8080:8080"   # API port (proxied later)
    depends_on:
      - clickhouse
      - postgres
      - kafka

  # Caddy – automatic TLS & reverse proxy
  caddy:
    image: caddy:2-alpine
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./caddy/Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
      - caddy_config:/config
    depends_on:
      - signoz

  # Alertmanager – receives alerts from SigNoz
  alertmanager:
    image: prom/alertmanager:v0.27.0
    restart: unless-stopped
    volumes:
      - ./alertmanager/alertmanager.yml:/etc/alertmanager/alertmanager.yml
    ports:
      - "9093:9093"

volumes:
  clickhouse-data:
  postgres-data:
  caddy_data:
  caddy_config:

# Caddyfile
example.com {
    encode gzip
    reverse_proxy signoz-frontend:3000
    # Optional: health endpoint
    health_path /health
}

# alertmanager.yml
global:
  resolve_timeout: 5m

route:
  receiver: 'slack-notifications'
  group_by: ['alertname']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 1h

receivers:
  - name: 'slack-notifications'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXX'
        channel: '#observability-alerts'
        send_resolved: true

docker compose up -d

docker compose ps
# Expected: all services listed as "Up"

https://example.com

docker exec -it signoz_clickhouse_1 clickhouse-client -q "SELECT count() FROM system.tables"

npm install @opentelemetry/api @opentelemetry/sdk-node \
            @opentelemetry/auto-instrumentations-node \
            @opentelemetry/exporter-trace-otlp-http

// otel-setup.js
const { NodeSDK } = require('@opentelemetry/sdk-node');
const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');

const traceExporter = new OTLPTraceExporter({
  url: 'http://example.com/v1/traces', // Caddy proxies to SigNoz
});

const sdk = new NodeSDK({
  traceExporter,
  instrumentations: [getNodeAutoInstrumentations()],
});

sdk.start()
  .then(() => console.log('OpenTelemetry initialized'))
  .catch(console.error);

pip install opentelemetry-sdk opentelemetry-exporter-otlp opentelemetry-instrumentation

# otel_setup.py
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.instrumentation.auto_instrumentation import AutoInstrumentation

trace.set_tracer_provider(TracerProvider())
otlp_exporter = OTLPSpanExporter(endpoint="http://example.com/v1/traces")
span_processor = BatchSpanProcessor(otlp_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

# Auto‑instrument popular libraries (Flask, Django, requests, etc.)
AutoInstrumentation().instrument()

go get go.opentelemetry.io/otel/sdk@latest
go get go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp@latest

// otel.go
package main

import (
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
    "go.opentelemetry.io/otel/sdk/trace"
    "log"
)

func initTracer() {
    exporter, err := otlptracehttp.New(context.Background(),
        otlptracehttp.WithEndpoint("example.com/v1/traces"),
        otlptracehttp.WithInsecure(), // Caddy handles TLS
    )
    if err != nil {
        log.Fatalf("failed to create exporter: %v", err)
    }
    tp := trace.NewTracerProvider(trace.WithBatcher(exporter))
    otel.SetTracerProvider(tp)
}