Deploying StatPing.ng

Introduction

StatPing.ng (also known as Statping-ng) is an open-source status page and monitoring application that helps you track the availability and response time of your services. It provides a beautiful, customizable status page for your users while alerting you when services go down.

As a maintained fork of the original StatPing, StatPing.ng continues active development with bug fixes, new features, and improved performance. It supports multiple database backends and offers extensive notification options.

Key highlights of StatPing.ng:

Service Monitoring: Monitor HTTP, TCP, UDP, ICMP, and gRPC services
Beautiful Status Page: Public-facing page showing service health
Response Time Graphs: Visualize service performance over time
Incident Management: Create and manage service incidents
Notification Channels: Slack, Email, Discord, Telegram, and more
API Access: RESTful API for automation and integration
Database Support: SQLite, PostgreSQL, or MySQL
Mobile Ready: Responsive design for all devices
Theme Support: Customizable appearance
Prometheus Export: Export metrics to Prometheus
Multi-User: Team access with role-based permissions
Open Source: GPL-3.0 licensed

This guide walks through deploying StatPing.ng on Klutch.sh using Docker for service monitoring and status pages.

Why Deploy StatPing.ng on Klutch.sh

Deploying StatPing.ng on Klutch.sh provides several advantages:

Simplified Deployment: Klutch.sh handles the container deployment automatically.

Persistent Storage: Monitoring history and configuration persist across deployments.

HTTPS by Default: Secure access to your status page with automatic SSL.

GitHub Integration: Version control your configuration and deploy updates automatically.

External Monitoring: Monitor your services from outside your network.

Custom Domains: Use a professional domain for your status page.

High Availability: Keep your monitoring running 24/7.

Independent Location: Monitor from a different infrastructure than your services.

Prerequisites

Before deploying StatPing.ng on Klutch.sh, ensure you have:

A Klutch.sh account
A GitHub account with a repository for your configuration
A list of services to monitor
Basic familiarity with Docker
(Optional) Notification service credentials (Slack, Discord, etc.)
(Optional) A custom domain for your status page

Deploying StatPing.ng on Klutch.sh

Create a GitHub Repository

Create a new GitHub repository for your StatPing.ng deployment.

Create Your Dockerfile

Create a Dockerfile in your repository:

FROM adamboutcher/statping-ng:latest

# Set environment variables
ENV DB_CONN=sqlite
ENV NAME="Service Status"
ENV DESCRIPTION="Current status of our services"

# Create data directory
RUN mkdir -p /app/data

EXPOSE 8080

HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
  CMD curl -f http://localhost:8080/health || exit 1

Push Your Repository to GitHub

Commit and push your Dockerfile.

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a new project.

Create a New App

Within your project, create a new app and connect your GitHub repository.

Configure HTTP Traffic

In the deployment settings:

Select HTTP as the traffic type
Set the internal port to 8080

Set Environment Variables

Configure the following environment variables:

Variable	Value
`DB_CONN`	`sqlite` (or `postgres` for PostgreSQL)
`NAME`	Your status page name
`DESCRIPTION`	Status page description
`ADMIN_USER`	Admin username
`ADMIN_PASSWORD`	Admin password

Attach Persistent Volumes

Add the following volumes:

Mount Path	Recommended Size	Purpose
`/app/data`	10 GB	Database and configuration

Deploy Your Application

Click Deploy to build and start StatPing.ng.

Access StatPing.ng

Once deployment completes, access your status page at https://your-app-name.klutch.sh.

Initial Configuration

Access the admin dashboard:

Navigate to https://your-app-name.klutch.sh/dashboard
Log in with admin credentials
Complete initial setup

Status Page Settings

Configure your public status page:

Go to Settings
Set status page name and description
Configure branding and colors
Enable/disable public access

Adding Services

Creating a Service

Add services to monitor:

Navigate to Services
Click Create Service
Fill in service details:

Field	Description
Name	Display name
Domain	URL or address to check
Type	HTTP, TCP, UDP, ICMP, gRPC
Check Interval	How often to check (seconds)
Timeout	Maximum wait time
Expected Status	Expected HTTP status code

Service Types

Type	Use Case
HTTP	Web applications, APIs
TCP	Database ports, custom services
UDP	DNS, game servers
ICMP	Basic connectivity (ping)
gRPC	gRPC services

Grouping Services

Organize services into groups:

Create service groups
Assign services to groups
Groups display together on status page

Notifications

Setting Up Notifiers

Configure alert channels:

Navigate to Notifiers
Select notification type
Configure credentials
Test the connection

Available Notifiers

Notifier	Configuration
Email	SMTP server details
Slack	Webhook URL
Discord	Webhook URL
Telegram	Bot token and chat ID
PagerDuty	Integration key
Pushover	API and user keys
Webhook	Custom HTTP endpoint

Notification Rules

Configure when to notify:

Service goes down
Service recovers
Response time threshold exceeded
Scheduled maintenance

Incidents

Creating Incidents

Document service issues:

Navigate to Incidents
Click Create Incident
Select affected services
Write incident description
Set incident status

Incident Statuses

Status	Description
Investigating	Looking into the issue
Identified	Cause determined
Monitoring	Fix applied, watching
Resolved	Issue fixed

Scheduled Maintenance

Plan maintenance windows:

Create scheduled incident
Set start and end times
Describe planned work
Notifications sent automatically

Status Page Customization

Themes

Customize appearance:

Go to Settings then Theme
Select color scheme
Upload custom CSS
Add custom header/footer

Branding

Add your branding:

Custom logo
Favicon
Color scheme
Custom domain

Page Layout

Configure what displays:

Service groups and order
Response time graphs
Incident history
Uptime percentages

API Usage

Authentication

Generate API token:

Go to Settings then API
Create new API key
Use in requests

Common API Endpoints

GET /api/services          # List all services
GET /api/services/{id}     # Get service details
POST /api/services         # Create service
GET /api/incidents         # List incidents
POST /api/incidents        # Create incident

Prometheus Metrics

Export to Prometheus:

GET /metrics

Troubleshooting

False Positives

If services show down incorrectly:

Increase timeout values
Verify network connectivity
Check expected status codes
Review service logs

Notifications Not Sending

Verify notifier configuration
Test notification manually
Check for rate limiting
Review error logs

High Resource Usage

Increase check intervals
Reduce number of services
Use appropriate database
Monitor historical data retention

Additional Resources

Conclusion

Deploying StatPing.ng on Klutch.sh gives you a professional status page and monitoring solution with automatic builds, persistent storage, and secure HTTPS. Keep users informed about service status, receive alerts when issues occur, and maintain a historical record of your service reliability. With its beautiful interface and comprehensive notification options, StatPing.ng helps you communicate service status effectively.