SigNoz Deployment Guide | Open-Source Observability Platform

What is SigNoz?

SigNoz is a powerful open-source observability platform that provides APM, distributed tracing, metrics, and log management in a single interface. It's a self-hosted alternative to services like Datadog and New Relic.

• APM & Distributed Tracing: Track requests across services
• Metrics Monitoring: Custom dashboards and alerts
• Log Management: Centralized log collection
• OpenTelemetry Native: Industry-standard instrumentation
• Full Data Control: Your data stays on your infrastructure
• ClickHouse Backend: Fast queries at scale

Prerequisites

SigNoz requires a reasonably capable VPS. Here are our recommendations:

Workload	RAM	vCPUs	Storage
Development/Testing	4 GB	2	30 GB SSD
Small Production	8 GB	4	50 GB SSD
Production	16 GB+	4+	100 GB+ SSD

⚠️ Important: 4 GB RAM is a hard minimum—SigNoz will not run reliably with less memory.

Software Requirements

• Ubuntu 22.04 or 24.04 LTS
• Git
• Docker Engine 20.10+
• Docker Compose v2.0+

Network Requirements

• Port 8080 (SigNoz Web UI)
• Port 4317 (OTLP gRPC receiver)
• Port 4318 (OTLP HTTP receiver)

→ View Recommended VPS Plans

Prepare Your VPS

Connect to your RamNode VPS via SSH and update the system:

Update System

sudo apt update && sudo apt upgrade -y

Install Required Packages

sudo apt install -y git curl wget apt-transport-https ca-certificates gnupg lsb-release

Install Docker

Install Docker using the official repository:

Install Docker Engine

# Add Docker's GPG key
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Add the repository
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

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

Add User to Docker Group

sudo usermod -aG docker $USER

Note: Log out and back in after adding yourself to the docker group for the changes to take effect.

Verify Installation

docker --version
docker compose version

Deploy SigNoz

Clone the SigNoz repository and start the services:

Clone Repository

mkdir -p ~/apps && cd ~/apps
git clone -b main https://github.com/SigNoz/signoz.git
cd signoz/deploy

Start SigNoz

cd docker
docker compose up -d --remove-orphans

Services Started:

signoz-clickhouse — ClickHouse database for storing telemetry data
signoz-zookeeper — ZooKeeper for ClickHouse coordination
signoz-otel-collector — OpenTelemetry Collector for receiving telemetry
signoz-signoz — The main SigNoz query service and UI

Initial startup takes 2-5 minutes depending on your VPS performance.

Verify Deployment

docker ps

Expected Output

CONTAINER ID   IMAGE                                        STATUS          PORTS
afd3e434e853   signoz/signoz-otel-collector:0.111.24        Up (healthy)    0.0.0.0:4317-4318->4317-4318/tcp
c0b6e58d3d18   signoz/signoz:0.69.0                         Up (healthy)    8080/tcp
69431900f6ef   clickhouse/clickhouse-server:24.1.2-alpine   Up (healthy)    8123/tcp, 9000/tcp
8b69f876a3c7   signoz/zookeeper:3.7.1                       Up (healthy)    2181/tcp, 2888/tcp, 3888/tcp

Access the SigNoz Dashboard

Configure firewall and access the web UI:

Configure Firewall

sudo ufw allow 8080/tcp
sudo ufw allow 4317/tcp
sudo ufw allow 4318/tcp

Access the UI

Open your browser and navigate to:

http://YOUR_VPS_IP:8080

On first access, you'll be prompted to create an admin account. Use a strong password.

Configure SSL with Nginx

For production deployments, run SigNoz behind nginx with SSL:

Install Nginx and Certbot

sudo apt install -y nginx certbot python3-certbot-nginx

Configure DNS

Point your domain (e.g., signoz.yourdomain.com) to your RamNode VPS IP address.

Create Nginx Configuration

sudo nano /etc/nginx/sites-available/signoz

Nginx Configuration

map $http_upgrade $connection_upgrade {
    default upgrade;
    '' close;
}

server {
    listen 80;
    listen [::]:80;
    server_name signoz.yourdomain.com;

    location / {
        return 301 https://$host$request_uri;
    }
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name signoz.yourdomain.com;

    # SSL certificates (will be configured by Certbot)
    ssl_certificate /etc/letsencrypt/live/signoz.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/signoz.yourdomain.com/privkey.pem;

    # SSL settings
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
    ssl_prefer_server_ciphers off;
    ssl_session_cache shared:SSL:10m;

    # Security headers
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

    # Proxy settings for SigNoz UI
    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 86400s;
        proxy_send_timeout 86400s;
    }
}

Enable Site and Obtain Certificate

# Enable the site
sudo ln -s /etc/nginx/sites-available/signoz /etc/nginx/sites-enabled/

# Test nginx configuration
sudo nginx -t

# Restart nginx
sudo systemctl restart nginx

# Obtain certificate
sudo certbot --nginx -d signoz.yourdomain.com

Update Firewall for HTTPS

sudo ufw allow 'Nginx Full'
sudo ufw delete allow 8080/tcp  # Optional: block direct access

OpenTelemetry Ingestion (Optional SSL)

For secure telemetry ingestion, create a separate nginx configuration for collector endpoints:

Create Ingest Configuration

sudo nano /etc/nginx/sites-available/signoz-ingest

Nginx Ingest Configuration

server {
    listen 443 ssl http2;
    server_name signoz-ingest.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/signoz-ingest.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/signoz-ingest.yourdomain.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;

    # HTTP OTLP endpoints
    location /v1/traces {
        proxy_pass http://127.0.0.1:4318;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    location /v1/metrics {
        proxy_pass http://127.0.0.1:4318;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    location /v1/logs {
        proxy_pass http://127.0.0.1:4318;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Enable and Configure SSL

sudo ln -s /etc/nginx/sites-available/signoz-ingest /etc/nginx/sites-enabled/
sudo certbot --nginx -d signoz-ingest.yourdomain.com
sudo systemctl restart nginx

Send Telemetry to SigNoz

Instrument your applications to send telemetry data:

Node.js Example

Install OpenTelemetry Packages

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

tracing.js

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

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: 'http://YOUR_VPS_IP:4318/v1/traces',
    // Or with SSL: url: 'https://signoz-ingest.yourdomain.com/v1/traces',
  }),
  instrumentations: [getNodeAutoInstrumentations()],
  serviceName: 'my-nodejs-app',
});

sdk.start();

Run Application with Tracing

node -r ./tracing.js app.js

Docker Compose Service with OTEL

docker-compose.yml Environment

services:
  myapp:
    image: myapp:latest
    environment:
      - OTEL_EXPORTER_OTLP_ENDPOINT=http://YOUR_VPS_IP:4318
      - OTEL_SERVICE_NAME=my-service
      - OTEL_TRACES_EXPORTER=otlp
      - OTEL_METRICS_EXPORTER=otlp
      - OTEL_LOGS_EXPORTER=otlp

Managing SigNoz

Common Commands

# Navigate to deploy directory
cd ~/apps/signoz/deploy/docker

# View logs
docker compose logs -f

# View logs for specific service
docker compose logs -f signoz-signoz

# Stop SigNoz
docker compose down

# Start SigNoz
docker compose up -d

# Update SigNoz
git pull origin main
docker compose pull
docker compose up -d --remove-orphans

Data Retention

• Logs and traces: 7 days (default)
• Metrics: 30 days (default)

Adjust in SigNoz UI under Settings → General.

Backup ClickHouse Data

Telemetry data is stored in Docker volumes. Stop containers for consistent backups.

Backup Data

# Find the volume
docker volume ls | grep clickhouse

# Backup (stop containers first for consistency)
docker compose down
sudo tar -czvf signoz-clickhouse-backup.tar.gz /var/lib/docker/volumes/docker_signoz-clickhouse-data
docker compose up -d

Troubleshooting

Containers Not Starting

Check Container Logs

docker compose logs signoz-clickhouse
docker compose logs signoz-signoz

Insufficient memory: Ensure your VPS has at least 4 GB RAM
Port conflicts: Check if ports 8080, 4317, or 4318 are already in use

ClickHouse Taking Long to Start

ClickHouse can take several minutes on first startup. Monitor with:

Monitor ClickHouse

docker compose logs -f signoz-clickhouse

Can't Access Web UI

Verify containers are running: docker ps
Check firewall rules: sudo ufw status
Test local connectivity: curl http://localhost:8080

High Memory Usage

If ClickHouse consumes too much memory, limit it with a custom configuration:

clickhouse-config.xml

<clickhouse>
    <max_server_memory_usage_to_ram_ratio>0.7</max_server_memory_usage_to_ram_ratio>
</clickhouse>

Mount this file in your docker-compose override.

Deployment Complete!

You now have a fully functional SigNoz observability platform running on your RamNode VPS. Your applications can send traces, metrics, and logs for centralized monitoring and analysis.

Next Steps:

• Instrument your applications with OpenTelemetry
• Set up alerts for proactive monitoring
• Create custom dashboards for your metrics
• Configure log collection from your services

← More Deployment Guides

Deploy SigNoz on RamNode VPS

📋 Guide Contents