How to Install Open Source Uptime Monitor

In today's digital world, the availability of your website or service directly impacts business results, reputation, and customer trust. Even a few minutes of downtime can lead to serious consequences.

Financial losses. Every minute of website unavailability means lost sales and missed revenue. For an online store, downtime during peak hours can result in thousands of dollars in lost revenue. Research shows that 98% of organizations estimate the cost of one hour of downtime at more than $100,000.

Reputational risks. Users won't wait for your site to come back online — they'll simply go to competitors. Recurring availability issues undermine customer trust and negatively affect brand perception. Restoring reputation after serious incidents can take months.

SEO and search rankings. Search engines like Google consider response time and site availability when ranking. Frequent downtime and slow performance lead to lower positions in search results, which means less organic traffic and potential customers.

Proactive problem solving. An uptime monitor lets you learn about problems before users report them. Instant notifications enable your team to quickly respond and resolve issues, minimizing business impact. Without monitoring, you might not know for hours that your site is down.

Performance analysis and SLA. The monitoring system collects uptime and response time history, allowing you to analyze trends, identify problem areas, and plan infrastructure improvements. For companies with SLA agreements, this is critical data for client reporting.

Monitoring critical dependencies. Modern applications depend on numerous external services: payment system APIs, CDNs, cloud providers, databases. An uptime monitor helps track not only your site but all critical dependencies, providing complete visibility into infrastructure health.

Installing an open source uptime monitor like Peekaping gives you complete control over monitoring, data privacy, and no subscription fees. It's an investment in your business reliability and your team's peace of mind.

# Update package list
sudo apt update

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

# Add official 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 -y docker-ce docker-ce-cli containerd.io

# Add user to docker group
sudo usermod -aG docker $USER

# Activate changes (or re-login)
newgrp docker

sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo yum install -y docker-ce docker-ce-cli containerd.io
sudo systemctl start docker
sudo systemctl enable docker
sudo usermod -aG docker $USER

# Create directory for data storage
mkdir -p ~/peekaping-data

# Run Peekaping
docker run -d --restart=always \
  -p 8383:8383 \
  -e DB_NAME=/app/data/peekaping.db \
  -v ~/peekaping-data:/app/data \
  --name peekaping \
  0xfurai/peekaping-bundle-sqlite:latest

docker ps | grep peekaping

http://your-server-ip:8383

http://localhost:8383

mkdir ~/peekaping
cd ~/peekaping
nano docker-compose.yml

version: '3.8'

services:
  postgres:
    image: postgres:15-alpine
    container_name: peekaping-postgres
    restart: always
    environment:
      POSTGRES_DB: peekaping
      POSTGRES_USER: peekaping
      POSTGRES_PASSWORD: your_secure_password
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U peekaping"]
      interval: 10s
      timeout: 5s
      retries: 5

  peekaping:
    image: 0xfurai/peekaping-bundle-postgres:latest
    container_name: peekaping
    restart: always
    ports:
      - "8383:8383"
    environment:
      DB_HOST: postgres
      DB_PORT: 5432
      DB_NAME: peekaping
      DB_USER: peekaping
      DB_PASS: your_secure_password
    depends_on:
      postgres:
        condition: service_healthy
    volumes:
      - ./data/peekaping:/app/data

volumes:
  postgres_data:
  peekaping_data:

# Start all services
docker-compose up -d

# View logs
docker-compose logs -f

# Stop services
docker-compose down

version: '3.8'

services:
  mongodb:
    image: mongo:7
    container_name: peekaping-mongo
    restart: always
    environment:
      MONGO_INITDB_ROOT_USERNAME: peekaping
      MONGO_INITDB_ROOT_PASSWORD: your_secure_password
      MONGO_INITDB_DATABASE: peekaping
    volumes:
      - ./data/mongodb:/data/db
    healthcheck:
      test: echo 'db.runCommand("ping").ok' | mongosh localhost:27017/test --quiet
      interval: 10s
      timeout: 5s
      retries: 5

  peekaping:
    image: 0xfurai/peekaping-bundle-mongo:latest
    container_name: peekaping
    restart: always
    ports:
      - "8383:8383"
    environment:
      DB_HOST: mongodb
      DB_PORT: 27017
      DB_NAME: peekaping
      DB_USER: peekaping
      DB_PASS: your_secure_password
    depends_on:
      mongodb:
        condition: service_healthy
    volumes:
      - ./data/peekaping:/app/data

docker-compose up -d

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

server {
    listen 80;
    server_name peekaping.your-domain.com;

    location / {
        proxy_pass http://localhost:8383;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header 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_cache_bypass $http_upgrade;
    }
}

sudo ln -s /etc/nginx/sites-available/peekaping /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx
sudo certbot --nginx -d peekaping.your-domain.com

peekaping.your-domain.com {
    reverse_proxy localhost:8383
}

docker run -d \
  --name caddy \
  -p 80:80 -p 443:443 \
  -v $PWD/Caddyfile:/etc/caddy/Caddyfile \
  -v caddy_data:/data \
  caddy:latest

# Stop container
docker stop peekaping

# Remove old container
docker rm peekaping

# Pull new version
docker pull 0xfurai/peekaping-bundle-sqlite:latest

# Run with same parameters
docker run -d --restart=always \
  -p 8383:8383 \
  -e DB_NAME=/app/data/peekaping.db \
  -v ~/peekaping-data:/app/data \
  --name peekaping \
  0xfurai/peekaping-bundle-sqlite:latest

cd ~/peekaping
docker-compose pull
docker-compose down
docker-compose up -d

# Create backup
docker exec peekaping sqlite3 /app/data/peekaping.db ".backup /app/data/backup.db"
cp ~/peekaping-data/backup.db ~/backups/peekaping-$(date +%Y%m%d).db

docker exec peekaping-postgres pg_dump -U peekaping peekaping > backup-$(date +%Y%m%d).sql

#!/bin/bash
BACKUP_DIR="/backups/peekaping"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p $BACKUP_DIR

# For SQLite
docker exec peekaping sqlite3 /app/data/peekaping.db ".backup /app/data/backup.db"
cp ~/peekaping-data/backup.db $BACKUP_DIR/peekaping-$DATE.db

# Remove old backups (older than 30 days)
find $BACKUP_DIR -name "peekaping-*.db" -mtime +30 -delete

echo "Backup completed: $DATE"

chmod +x /usr/local/bin/backup-peekaping.sh
crontab -e

0 3 * * * /usr/local/bin/backup-peekaping.sh >> /var/log/peekaping-backup.log 2>&1

docker logs peekaping

docker-compose logs peekaping

# For PostgreSQL
docker exec peekaping-postgres pg_isready -U peekaping

# For MongoDB
docker exec peekaping-mongo mongosh --eval "db.adminCommand('ping')"

# View container status
docker ps

# View logs in real-time
docker logs -f peekaping

# Restart container
docker restart peekaping

# Enter container for diagnostics
docker exec -it peekaping sh

# View resource usage
docker stats peekaping

# Clean unused images
docker system prune -a