Welcome to Status Nugget documentation. Get up and running quickly with our comprehensive guides.
Get started with our managed cloud service. Quick setup, no infrastructure management required.
Learn MoreDeploy Status Nugget on your own infrastructure. Full control and customization options.
Learn MoreStatus Nugget is a powerful status page and monitoring solution that helps you keep your users informed about the health and availability of your services.
Status Nugget provides real-time status updates, incident management, and service monitoring capabilities. Whether you're running a small application or managing enterprise infrastructure, Status Nugget helps you maintain transparency with your users.
Monitor your services in real-time with automated health checks and status updates.
Create, update, and resolve incidents with detailed timelines and impact assessments.
Customize your status page with your brand colors, logo, and domain.
Track uptime, response times, and incident frequency with detailed analytics.
Enterprise-grade security with SSL encryption and privacy controls.
Integrate Status Nugget with your existing tools using our comprehensive API.
Deploy Status Nugget on our managed cloud infrastructure. Get started in minutes with zero configuration.
Getting started with Status Nugget Cloud is simple and takes just a few minutes.
Visit our website and create your account. You can start with a free trial that includes all features.
1. Navigate to https://statusnugget.com/signup
2. Enter your email address and create a password
3. Verify your email address
4. Complete your profile setup
After signing up, you'll be guided through creating your first status page.
1. Click "Create Status Page" from the dashboard
2. Enter your page name and URL slug
3. Choose a template or start from scratch
4. Configure basic settings
Add the services you want to monitor to your status page.
1. Go to "Services" in the navigation
2. Click "Add Service"
3. Enter service name and description
4. Configure monitoring endpoints (optional)
5. Set service status
Set up automated health checks for your services.
1. Navigate to "Monitoring" settings
2. Add monitoring endpoints (HTTP, HTTPS, TCP, etc.)
3. Configure check intervals
4. Set up alert notifications
5. Enable automatic status updates
Configure your status page appearance and behavior from the settings page.
Customize your status page to match your brand identity.
Settings → Branding → Customize:
- Upload your logo (PNG, SVG recommended)
- Set primary and secondary colors
- Choose font family
- Configure favicon
- Set meta tags for SEO
Configure how you receive alerts and updates.
Generate API keys to integrate Status Nugget with your applications.
Settings → API → Generate API Key:
1. Click "Generate New API Key"
2. Name your API key (e.g., "Production App")
3. Set permissions (read, write, admin)
4. Copy and securely store your API key
5. Use the key in your API requests
Use your own domain for your status page (available on Pro and Enterprise plans).
Settings → Custom Domain → Configure:
1. Enter your domain (e.g., status.yourcompany.com)
2. Add CNAME record pointing to statusnugget.com
3. Verify domain ownership
4. Enable SSL certificate (automatic)
5. Update DNS settings
We handle all server management, updates, and maintenance. Focus on your business, not infrastructure.
Your status page automatically scales to handle traffic spikes without any configuration.
Fast loading times worldwide with our global content delivery network.
Your data is automatically backed up daily with point-in-time recovery options.
Guaranteed uptime with our enterprise-grade infrastructure and monitoring.
Get help when you need it with our round-the-clock support team.
Deploy Status Nugget on your own infrastructure for complete control and customization.
Choose your preferred deployment method: Standalone installation or Docker containerization.
| Component | Minimum | Recommended |
|---|---|---|
| CPU | 2 cores (x86 compatible) | 4+ cores (x86 compatible) |
| RAM | 4 GB | 8+ GB |
| Storage | 20 GB | 50+ GB SSD |
| OS | Linux (Ubuntu 20.04+, Debian 11+, CentOS 8+) | |
| Database | PostgreSQL 12+ or MySQL 8+ | |
Manual Installation
Install Status Nugget directly on your server with full control over the environment and dependencies.
Recommended
Deploy Status Nugget using Docker containers for easy setup, updates, and portability.
Install Status Nugget directly on your server without Docker. This method gives you full control over your environment.
Before you begin, ensure you have a server with:
# Update package index
sudo apt update
sudo apt upgrade -y
# Install PHP 8.1+ and required extensions
sudo apt install -y php8.1 php8.1-fpm php8.1-cli \
php8.1-pgsql php8.1-mysql php8.1-curl \
php8.1-mbstring php8.1-xml php8.1-zip php8.1-gd \
php8.1-bcmath php8.1-intl php8.1-redis
# Install Composer
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer
sudo chmod +x /usr/local/bin/composer
# Install Node.js 18.x and npm
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt install -y nodejs
# Install PostgreSQL (or MySQL if preferred)
sudo apt install -y postgresql postgresql-contrib
# Install Redis (recommended for caching and queues)
sudo apt install -y redis-server
# Install Nginx (or Apache if preferred)
sudo apt install -y nginx
# Verify installations
php -v
composer --version
node -v
npm -v
psql --version
# Install EPEL repository
sudo yum install -y epel-release
# Install Remi repository for PHP 8.1
sudo yum install -y https://rpms.remirepo.net/enterprise/remi-release-8.rpm
sudo dnf module reset php
sudo dnf module enable php:remi-8.1
# Install PHP and extensions
sudo yum install -y php php-fpm php-cli \
php-pgsql php-mysqlnd php-curl \
php-mbstring php-xml php-zip php-gd \
php-bcmath php-intl php-redis
# Install Composer
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer
# Install Node.js 18.x
curl -fsSL https://rpm.nodesource.com/setup_18.x | sudo bash -
sudo yum install -y nodejs
# Install PostgreSQL
sudo yum install -y postgresql-server postgresql-contrib
sudo postgresql-setup --initdb
# Install Redis
sudo yum install -y redis
# Install Nginx
sudo yum install -y nginx
# Start and enable services
sudo systemctl start postgresql redis nginx
sudo systemctl enable postgresql redis nginx
# Switch to postgres user
sudo -u postgres psql
# Create database and user
CREATE DATABASE statusnugget;
CREATE USER statusnugget WITH PASSWORD 'your-secure-password';
ALTER ROLE statusnugget SET client_encoding TO 'utf8';
ALTER ROLE statusnugget SET default_transaction_isolation TO 'read committed';
ALTER ROLE statusnugget SET timezone TO 'UTC';
GRANT ALL PRIVILEGES ON DATABASE statusnugget TO statusnugget;
\q
# Test connection
psql -U statusnugget -d statusnugget -h localhost
# Install MySQL
sudo apt install -y mysql-server # Ubuntu/Debian
# OR
sudo yum install -y mysql-server # CentOS/RHEL
# Secure MySQL installation
sudo mysql_secure_installation
# Create database and user
sudo mysql -u root -p
CREATE DATABASE statusnugget CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'statusnugget'@'localhost' IDENTIFIED BY 'your-secure-password';
GRANT ALL PRIVILEGES ON statusnugget.* TO 'statusnugget'@'localhost';
FLUSH PRIVILEGES;
EXIT;
# Create application directory
sudo mkdir -p /var/www/statusnugget
sudo chown $USER:$USER /var/www/statusnugget
cd /var/www/statusnugget
# Clone the repository
git clone https://github.com/statusnugget/statusnugget.git .
# Install PHP dependencies
composer install --no-dev --optimize-autoloader
# Install Node.js dependencies
npm install
# Build frontend assets
npm run build
# Copy environment file
cp .env.example .env
# Generate application key
php artisan key:generate
Edit the .env file with your configuration:
# Edit environment file
nano /var/www/statusnugget/.env
Configure the following essential settings:
APP_NAME="Status Nugget"
APP_ENV=production
APP_DEBUG=false
APP_URL=https://status.yourdomain.com
# Database Configuration (PostgreSQL)
DB_CONNECTION=pgsql
DB_HOST=127.0.0.1
DB_PORT=5432
DB_DATABASE=statusnugget
DB_USERNAME=statusnugget
DB_PASSWORD=your-secure-password
# Redis Configuration
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379
CACHE_DRIVER=redis
QUEUE_CONNECTION=redis
# Mail Configuration
MAIL_MAILER=smtp
MAIL_HOST=smtp.mailtrap.io
MAIL_PORT=2525
MAIL_USERNAME=your-username
MAIL_PASSWORD=your-password
MAIL_FROM_ADDRESS=noreply@yourdomain.com
MAIL_FROM_NAME="${APP_NAME}"
# Run database migrations
php artisan migrate
# Create admin user
php artisan user:create
# Cache configuration for better performance
php artisan config:cache
php artisan route:cache
php artisan view:cache
Create an Nginx configuration file:
# Create Nginx configuration
sudo nano /etc/nginx/sites-available/statusnugget
Add the following configuration:
server {
listen 80;
server_name status.yourdomain.com;
root /var/www/statusnugget/public;
add_header X-Frame-Options "SAMEORIGIN";
add_header X-Content-Type-Options "nosniff";
index index.php;
charset utf-8;
location / {
try_files $uri $uri/ /index.php?$query_string;
}
location = /favicon.ico { access_log off; log_not_found off; }
location = /robots.txt { access_log off; log_not_found off; }
error_page 404 /index.php;
location ~ \.php$ {
fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
include fastcgi_params;
fastcgi_hide_header X-Powered-By;
}
location ~ /\.(?!well-known).* {
deny all;
}
}
Enable the site and restart Nginx:
# Enable site (Ubuntu/Debian)
sudo ln -s /etc/nginx/sites-available/statusnugget /etc/nginx/sites-enabled/
# Test Nginx configuration
sudo nginx -t
# Restart Nginx
sudo systemctl restart nginx
If using Apache instead of Nginx:
# Create Apache virtual host
sudo nano /etc/apache2/sites-available/statusnugget.conf
<VirtualHost *:80>
ServerName status.yourdomain.com
DocumentRoot /var/www/statusnugget/public
<Directory /var/www/statusnugget/public>
AllowOverride All
Require all granted
</Directory>
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
# Enable site and required modules
sudo a2ensite statusnugget.conf
sudo a2enmod rewrite
sudo systemctl restart apache2
# Set proper ownership
sudo chown -R www-data:www-data /var/www/statusnugget
# Set directory permissions
sudo chmod -R 755 /var/www/statusnugget
sudo chmod -R 775 /var/www/statusnugget/storage
sudo chmod -R 775 /var/www/statusnugget/bootstrap/cache
Status Nugget uses queues for background jobs. Set up a supervisor to keep the queue worker running:
# Install Supervisor
sudo apt install -y supervisor # Ubuntu/Debian
# OR
sudo yum install -y supervisor # CentOS/RHEL
# Create supervisor configuration
sudo nano /etc/supervisor/conf.d/statusnugget-worker.conf
[program:statusnugget-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /var/www/statusnugget/artisan queue:work redis --sleep=3 --tries=3 --max-time=3600
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true
user=www-data
numprocs=2
redirect_stderr=true
stdout_logfile=/var/www/statusnugget/storage/logs/worker.log
stopwaitsecs=3600
# Reload supervisor configuration
sudo supervisorctl reread
sudo supervisorctl update
sudo supervisorctl start statusnugget-worker:*
Configure cron to run scheduled tasks:
# Edit crontab
sudo crontab -e -u www-data
Add the following line:
* * * * * cd /var/www/statusnugget && php artisan schedule:run >> /dev/null 2>&1
Secure your installation with Let's Encrypt:
# Install Certbot
sudo apt install -y certbot python3-certbot-nginx # For Nginx
# OR
sudo apt install -y certbot python3-certbot-apache # For Apache
# Obtain SSL certificate
sudo certbot --nginx -d status.yourdomain.com
# OR
sudo certbot --apache -d status.yourdomain.com
# Test auto-renewal
sudo certbot renew --dry-run
# Fix storage permissions
sudo chown -R www-data:www-data /var/www/statusnugget/storage
sudo chmod -R 775 /var/www/statusnugget/storage
# Check PHP-FPM status
sudo systemctl status php8.1-fpm
# Restart PHP-FPM
sudo systemctl restart php8.1-fpm
# Test database connection
psql -U statusnugget -d statusnugget -h localhost
# Check PostgreSQL is running
sudo systemctl status postgresql
# Verify .env database credentials
Deploy Status Nugget using Docker - the easiest and most portable deployment method. Works on any x86 compatible Linux server.
Before you begin, ensure you have:
# Update package index
sudo apt update
# Install prerequisites
sudo apt install -y ca-certificates curl gnupg lsb-release
# Add Docker's official GPG key
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
# Set up Docker repository
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.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 update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
# Start and enable Docker
sudo systemctl start docker
sudo systemctl enable docker
# Add your user to docker group (optional, to run without sudo)
sudo usermod -aG docker $USER
# Log out and back in for group changes to take effect
# Verify installation
docker --version
docker compose version
# Install required packages
sudo yum install -y yum-utils
# Add Docker repository
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# Install Docker Engine
sudo yum install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
# Start and enable Docker
sudo systemctl start docker
sudo systemctl enable docker
# Verify installation
docker --version
docker compose version
Create a directory for your Status Nugget installation:
# Create project directory
mkdir -p ~/statusnugget
cd ~/statusnugget
# Clone the repository (or download the docker-compose.yml)
git clone https://github.com/statusnugget/statusnugget.git .
# OR download just the docker-compose.yml file
Create a .env file with your configuration:
# Copy example environment file
cp .env.example .env
# Edit the .env file
nano .env
Configure the following essential variables:
# Application Settings
APP_NAME="Status Nugget"
APP_ENV=production
APP_DEBUG=false
APP_URL=https://status.yourdomain.com
# Database Configuration
DB_CONNECTION=pgsql
DB_HOST=db
DB_PORT=5432
DB_DATABASE=statusnugget
DB_USERNAME=statusnugget
DB_PASSWORD=your-secure-password-here
# Redis Configuration
REDIS_HOST=redis
REDIS_PORT=6379
# Mail Configuration (optional)
MAIL_MAILER=smtp
MAIL_HOST=smtp.mailtrap.io
MAIL_PORT=2525
MAIL_USERNAME=your-username
MAIL_PASSWORD=your-password
MAIL_FROM_ADDRESS=noreply@yourdomain.com
Here's a complete docker-compose.yml example:
version: '3.8'
services:
app:
image: statusnugget/app:latest
container_name: statusnugget_app
restart: unless-stopped
working_dir: /var/www
volumes:
- ./storage:/var/www/storage
- ./bootstrap/cache:/var/www/bootstrap/cache
environment:
- APP_ENV=production
- APP_DEBUG=false
- DB_HOST=db
- DB_DATABASE=statusnugget
- DB_USERNAME=statusnugget
- DB_PASSWORD=${DB_PASSWORD}
- REDIS_HOST=redis
depends_on:
- db
- redis
networks:
- statusnugget
web:
image: nginx:alpine
container_name: statusnugget_web
restart: unless-stopped
ports:
- "80:80"
- "443:443"
volumes:
- ./public:/var/www/public
- ./nginx.conf:/etc/nginx/nginx.conf
depends_on:
- app
networks:
- statusnugget
db:
image: postgres:15-alpine
container_name: statusnugget_db
restart: unless-stopped
environment:
- POSTGRES_DB=statusnugget
- POSTGRES_USER=statusnugget
- POSTGRES_PASSWORD=${DB_PASSWORD}
volumes:
- postgres_data:/var/lib/postgresql/data
networks:
- statusnugget
redis:
image: redis:7-alpine
container_name: statusnugget_redis
restart: unless-stopped
volumes:
- redis_data:/data
networks:
- statusnugget
volumes:
postgres_data:
redis_data:
networks:
statusnugget:
driver: bridge
Now you're ready to start your Status Nugget instance:
# Start all services in detached mode
docker compose up -d
# Check if all containers are running
docker compose ps
# View logs to ensure everything started correctly
docker compose logs -f
Once the containers are running, initialize the database and create an admin user:
# Run database migrations
docker compose exec app php artisan migrate
# Create admin user
docker compose exec app php artisan user:create
# Generate application key (if not already set)
docker compose exec app php artisan key:generate
# Clear and cache configuration
docker compose exec app php artisan config:cache
docker compose exec app php artisan route:cache
docker compose exec app php artisan view:cache
http://your-server-ip or your configured domain.
Common commands for managing your Status Nugget Docker deployment:
# Start all services
docker compose up -d
# Stop all services
docker compose stop
# Stop and remove all containers
docker compose down
# Restart all services
docker compose restart
# Restart a specific service
docker compose restart app
# View running containers
docker compose ps
# View container logs
docker compose logs
docker compose logs -f app # Follow logs for app container
docker compose logs --tail=100 app # Last 100 lines
# Run Artisan commands
docker compose exec app php artisan [command]
# Examples:
docker compose exec app php artisan migrate
docker compose exec app php artisan cache:clear
docker compose exec app php artisan queue:work
docker compose exec app php artisan tinker
# Access container shell
docker compose exec app bash
docker compose exec db psql -U statusnugget -d statusnugget
# Backup database
docker compose exec db pg_dump -U statusnugget statusnugget > backup_$(date +%Y%m%d_%H%M%S).sql
# Backup volumes (storage, etc.)
docker run --rm -v statusnugget_storage:/data -v $(pwd):/backup alpine tar czf /backup/storage_backup.tar.gz /data
# Restore database
docker compose exec -T db psql -U statusnugget statusnugget < backup_20240101_120000.sql
# Restore volumes
docker run --rm -v statusnugget_storage:/data -v $(pwd):/backup alpine tar xzf /backup/storage_backup.tar.gz -C /
# Pull latest images
docker compose pull
# Update to latest version
docker compose pull
docker compose up -d
docker compose exec app php artisan migrate
docker compose exec app php artisan config:cache
# View image versions
docker compose images
# Clean up unused images and containers
docker system prune -a
If you want to use an external web server instead of the Docker nginx container, configure it as a reverse proxy:
server {
listen 80;
server_name status.yourdomain.com;
location / {
proxy_pass http://localhost:8080;
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;
}
}
Then update your docker-compose.yml to expose the app on port 8080 instead of using the web container:
app:
# ... other config ...
ports:
- "8080:80" # Expose on port 8080
To enable HTTPS, use Let's Encrypt with Certbot:
# Install Certbot
sudo apt install certbot python3-certbot-nginx
# Obtain SSL certificate
sudo certbot --nginx -d status.yourdomain.com
# Certbot will automatically configure Nginx
# Auto-renewal is set up automatically
# Check container status
docker compose ps
# View detailed logs
docker compose logs
# Check Docker daemon
sudo systemctl status docker
# Verify Docker Compose version
docker compose version
# Check if database container is running
docker compose ps db
# Test database connection
docker compose exec db psql -U statusnugget -d statusnugget
# Check database logs
docker compose logs db
# Verify environment variables
docker compose exec app env | grep DB_
# Fix storage permissions
sudo chown -R $USER:$USER storage bootstrap/cache
sudo chmod -R 775 storage bootstrap/cache
# Or run as root user in container (not recommended for production)
# Add to docker-compose.yml:
# user: root
# Check what's using the port
sudo netstat -tulpn | grep :80
sudo lsof -i :80
# Change port in docker-compose.yml
ports:
- "8080:80" # Use different host port
# Check disk usage
df -h
docker system df
# Clean up unused Docker resources
docker system prune -a --volumes
# Remove old images
docker image prune -a
Configure Status Nugget using environment variables in your .env file.
APP_NAME="Status Nugget"
APP_ENV=production
APP_KEY=base64:your-generated-key
APP_DEBUG=false
APP_URL=https://status.yourdomain.com
# Timezone
APP_TIMEZONE=UTC
# PostgreSQL
DB_CONNECTION=pgsql
DB_HOST=127.0.0.1
DB_PORT=5432
DB_DATABASE=statusnugget
DB_USERNAME=statusnugget
DB_PASSWORD=your-secure-password
# Or MySQL
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=statusnugget
DB_USERNAME=statusnugget
DB_PASSWORD=your-secure-password
# Redis (Recommended)
CACHE_DRIVER=redis
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379
# Or use file cache
CACHE_DRIVER=file
# Redis Queue (Recommended)
QUEUE_CONNECTION=redis
# Or database queue
QUEUE_CONNECTION=database
# Start queue worker
php artisan queue:work
MAIL_MAILER=smtp
MAIL_HOST=smtp.mailtrap.io
MAIL_PORT=2525
MAIL_USERNAME=your-username
MAIL_PASSWORD=your-password
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=noreply@yourdomain.com
MAIL_FROM_NAME="${APP_NAME}"
server {
listen 80;
server_name status.yourdomain.com;
root /var/www/statusnugget/public;
add_header X-Frame-Options "SAMEORIGIN";
add_header X-Content-Type-Options "nosniff";
index index.php;
charset utf-8;
location / {
try_files $uri $uri/ /index.php?$query_string;
}
location = /favicon.ico { access_log off; log_not_found off; }
location = /robots.txt { access_log off; log_not_found off; }
error_page 404 /index.php;
location ~ \.php$ {
fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
include fastcgi_params;
}
location ~ /\.(?!well-known).* {
deny all;
}
}
<VirtualHost *:80>
ServerName status.yourdomain.com
DocumentRoot /var/www/statusnugget/public
<Directory /var/www/statusnugget/public>
AllowOverride All
Require all granted
</Directory>
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
Secure your installation with SSL using Let's Encrypt.
# Install Certbot
sudo apt install certbot python3-certbot-nginx
# Obtain certificate
sudo certbot --nginx -d status.yourdomain.com
# Auto-renewal is set up automatically
# Test renewal
sudo certbot renew --dry-run
Set up scheduled tasks for monitoring and maintenance.
# Edit crontab
crontab -e
# Add the following lines
* * * * * cd /var/www/statusnugget && php artisan schedule:run >> /dev/null 2>&1
Deploy Status Nugget on popular hosting providers with one-click installations and managed services.
Recommended
Deploy Status Nugget using Docker on any hosting provider. Docker provides the easiest and most portable deployment method.
Available Now
Deploy Status Nugget on PebbleHost's reliable infrastructure with affordable pricing and excellent support.
docker-compose up -dAvailable Now
Host Status Nugget on Zaphosting's high-performance servers with competitive pricing and global reach.
Coming Soon
Elestio will offer managed Status Nugget deployments with automated updates and professional support.
Want to be notified? Subscribe to our newsletter or follow us on social media to get updates when Elestio support is available.
When selecting a hosting provider for Status Nugget, consider the following factors:
Keep your self-hosted installation up to date with the latest features and security patches.
# Backup your database first
pg_dump -U statusnugget statusnugget > backup_$(date +%Y%m%d).sql
# Pull latest changes
git pull origin main
# Update dependencies
composer install --no-dev --optimize-autoloader
npm install
npm run build
# Run database migrations
php artisan migrate
# Clear caches
php artisan config:clear
php artisan cache:clear
php artisan view:clear
# Restart services
sudo systemctl restart php8.1-fpm
sudo systemctl restart nginx
Monitor your self-hosted installation for issues and performance.
# View application logs
tail -f storage/logs/laravel.log
# View web server logs
tail -f /var/log/nginx/error.log
tail -f /var/log/nginx/access.log
# Check queue status
php artisan queue:monitor
# View scheduled tasks
php artisan schedule:list
Integrate Status Nugget with your applications using our comprehensive RESTful API.
All API requests require authentication using an API key. Include your API key in the request header:
Authorization: Bearer YOUR_API_KEY
All API endpoints are relative to your Status Nugget installation:
https://status.yourdomain.com/api/v1
# Get all status pages
GET /api/v1/status-pages
# Get specific status page
GET /api/v1/status-pages/{id}
# Create status page
POST /api/v1/status-pages
Content-Type: application/json
{
"name": "My Status Page",
"slug": "my-status-page",
"description": "Status page description"
}
# Update status page
PUT /api/v1/status-pages/{id}
# Delete status page
DELETE /api/v1/status-pages/{id}
# Get all services
GET /api/v1/services
# Get specific service
GET /api/v1/services/{id}
# Create service
POST /api/v1/services
{
"name": "API Service",
"description": "Main API endpoint",
"status": "operational",
"monitor_url": "https://api.example.com/health"
}
# Update service status
PATCH /api/v1/services/{id}/status
{
"status": "degraded"
}
# Get all incidents
GET /api/v1/incidents
# Get specific incident
GET /api/v1/incidents/{id}
# Create incident
POST /api/v1/incidents
{
"title": "Service Outage",
"description": "We are experiencing issues",
"status": "investigating",
"impact": "major",
"affected_services": [1, 2, 3]
}
# Update incident
PUT /api/v1/incidents/{id}
# Resolve incident
POST /api/v1/incidents/{id}/resolve
# Get service metrics
GET /api/v1/services/{id}/metrics?start=2024-01-01&end=2024-01-31
# Get uptime statistics
GET /api/v1/services/{id}/uptime?period=30d
All API responses follow a consistent format:
{
"success": true,
"data": {
"id": 1,
"name": "API Service",
"status": "operational"
}
}
{
"success": false,
"error": {
"message": "Resource not found",
"code": 404
}
}
API requests are rate-limited to prevent abuse:
Rate limit headers are included in all responses:
X-RateLimit-Limit: 60
X-RateLimit-Remaining: 45
X-RateLimit-Reset: 1640995200
# Get all services
curl -X GET \
https://status.yourdomain.com/api/v1/services \
-H "Authorization: Bearer YOUR_API_KEY"
# Create incident
curl -X POST \
https://status.yourdomain.com/api/v1/incidents \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"title": "Service Maintenance",
"status": "scheduled",
"impact": "minor"
}'
// Get services
fetch('https://status.yourdomain.com/api/v1/services', {
headers: {
'Authorization': 'Bearer YOUR_API_KEY'
}
})
.then(response => response.json())
.then(data => console.log(data));
// Create incident
fetch('https://status.yourdomain.com/api/v1/incidents', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
title: 'Service Maintenance',
status: 'scheduled',
impact: 'minor'
})
})
.then(response => response.json())
.then(data => console.log(data));
import requests
# Get services
response = requests.get(
'https://status.yourdomain.com/api/v1/services',
headers={'Authorization': 'Bearer YOUR_API_KEY'}
)
print(response.json())
# Create incident
response = requests.post(
'https://status.yourdomain.com/api/v1/incidents',
headers={
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
json={
'title': 'Service Maintenance',
'status': 'scheduled',
'impact': 'minor'
}
)
print(response.json())
Advanced configuration options for power users and enterprise deployments.
Enable OPcache for improved PHP performance:
# Edit php.ini
sudo nano /etc/php/8.1/fpm/php.ini
# Add or modify:
opcache.enable=1
opcache.memory_consumption=256
opcache.interned_strings_buffer=16
opcache.max_accelerated_files=20000
opcache.validate_timestamps=0 # Set to 1 in development
opcache.revalidate_freq=0
opcache.fast_shutdown=1
# Restart PHP-FPM
sudo systemctl restart php8.1-fpm
Optimize Redis for better caching performance:
# Edit redis.conf
sudo nano /etc/redis/redis.conf
# Recommended settings:
maxmemory 256mb
maxmemory-policy allkeys-lru
save "" # Disable persistence for cache-only Redis
# Restart Redis
sudo systemctl restart redis
Optimize your database for better performance:
# PostgreSQL optimization
# Edit postgresql.conf
sudo nano /etc/postgresql/15/main/postgresql.conf
# Recommended settings:
shared_buffers = 256MB
effective_cache_size = 1GB
maintenance_work_mem = 128MB
checkpoint_completion_target = 0.9
wal_buffers = 16MB
default_statistics_target = 100
random_page_cost = 1.1
effective_io_concurrency = 200
work_mem = 4MB
min_wal_size = 1GB
max_wal_size = 4GB
Set up load balancing for high availability:
upstream statusnugget_backend {
least_conn;
server 10.0.0.1:80 weight=3 max_fails=3 fail_timeout=30s;
server 10.0.0.2:80 weight=3 max_fails=3 fail_timeout=30s;
server 10.0.0.3:80 weight=2 max_fails=3 fail_timeout=30s backup;
}
server {
listen 80;
server_name status.yourdomain.com;
location / {
proxy_pass http://statusnugget_backend;
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;
}
}
Configure session storage for better performance:
# In .env file
SESSION_DRIVER=redis
SESSION_LIFETIME=120
SESSION_ENCRYPT=true
SESSION_PATH=/
SESSION_DOMAIN=null
# For Redis sessions
REDIS_CLIENT=phpredis
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379
REDIS_DB=1 # Use separate DB for sessions
Optimize queue processing for high-volume deployments:
# In .env file
QUEUE_CONNECTION=redis
QUEUE_DEFAULT=default
# Supervisor configuration for multiple workers
# /etc/supervisor/conf.d/statusnugget-workers.conf
[program:statusnugget-worker-1]
command=php /var/www/statusnugget/artisan queue:work redis --sleep=3 --tries=3
autostart=true
autorestart=true
numprocs=1
[program:statusnugget-worker-2]
command=php /var/www/statusnugget/artisan queue:work redis --sleep=3 --tries=3
autostart=true
autorestart=true
numprocs=1
Configure advanced logging options:
# In .env file
LOG_CHANNEL=stack
LOG_LEVEL=info
LOG_DEPRECATIONS_CHANNEL=null
LOG_STDERR_FORMATTER=null
# For file logging with rotation
# In config/logging.php
'daily' => [
'driver' => 'daily',
'path' => storage_path('logs/laravel.log'),
'level' => env('LOG_LEVEL', 'info'),
'days' => 14, # Keep logs for 14 days
],
Set up advanced monitoring options:
# Health check intervals
MONITOR_INTERVAL=60 # Check every 60 seconds
MONITOR_TIMEOUT=10 # 10 second timeout
MONITOR_RETRIES=3 # Retry 3 times before marking as down
# Notification thresholds
NOTIFICATION_DOWNTIME_THRESHOLD=300 # Notify after 5 minutes
NOTIFICATION_DEGRADED_THRESHOLD=180 # Notify after 3 minutes
Configure custom domains for your status pages:
# In .env file
ALLOWED_DOMAINS=status.yourdomain.com,status2.yourdomain.com
# Nginx configuration for custom domain
server {
listen 80;
server_name status.yourdomain.com;
return 301 https://$server_name$request_uri;
}
server {
listen 443 ssl http2;
server_name status.yourdomain.com;
# ... SSL configuration ...
# ... Application configuration ...
}
Best practices and recommendations for securing your Status Nugget installation.
Use strong, unique passwords for:
# Generate strong password
openssl rand -base64 32
# Or use password manager
# Never commit .env file
# Add to .gitignore
echo ".env" >> .gitignore
# Use strong APP_KEY
php artisan key:generate
# Keep APP_DEBUG=false in production
APP_DEBUG=false
APP_ENV=production
# Secure file permissions
find /var/www/statusnugget -type f -exec chmod 644 {} \;
find /var/www/statusnugget -type d -exec chmod 755 {} \;
chmod -R 775 storage bootstrap/cache
chown -R www-data:www-data /var/www/statusnugget
# Add to Nginx configuration
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
add_header Referrer-Policy "no-referrer-when-downgrade" always;
add_header Content-Security-Policy "default-src 'self' http: https: data: blob: 'unsafe-inline'" always;
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
# Use strong SSL ciphers
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384';
ssl_prefer_server_ciphers off;
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 10m;
# Edit pg_hba.conf
sudo nano /etc/postgresql/15/main/pg_hba.conf
# Restrict access to local connections only
host statusnugget statusnugget 127.0.0.1/32 md5
# Use strong passwords
# Change default postgres user password
ALTER USER postgres PASSWORD 'strong-password';
# Run MySQL secure installation
sudo mysql_secure_installation
# Create dedicated database user
CREATE USER 'statusnugget'@'localhost' IDENTIFIED BY 'strong-password';
GRANT ALL PRIVILEGES ON statusnugget.* TO 'statusnugget'@'localhost';
FLUSH PRIVILEGES;
# UFW firewall setup
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
sudo ufw status
# Encrypt database backup
pg_dump -U statusnugget statusnugget | gpg -c > backup.sql.gpg
# Restore encrypted backup
gpg -d backup.sql.gpg | psql -U statusnugget statusnugget
Comprehensive solutions to common issues and problems you might encounter while using Status Nugget.
Problem: Unable to connect to database
Symptoms:
Solutions:
# Verify database service is running
sudo systemctl status postgresql # For PostgreSQL
sudo systemctl status mysql # For MySQL
# Check database credentials in .env
cat .env | grep DB_
# Test database connection
psql -U statusnugget -d statusnugget -h localhost # PostgreSQL
mysql -u statusnugget -p statusnugget # MySQL
# Verify database exists
# PostgreSQL:
sudo -u postgres psql -l | grep statusnugget
# MySQL:
mysql -u root -p -e "SHOW DATABASES;" | grep statusnugget
# Check firewall rules
sudo ufw status
sudo iptables -L -n | grep 5432 # PostgreSQL port
sudo iptables -L -n | grep 3306 # MySQL port
Problem: Permission denied errors when writing files
Symptoms:
Solutions:
# Fix storage permissions (Standalone)
sudo chown -R www-data:www-data /var/www/statusnugget/storage
sudo chown -R www-data:www-data /var/www/statusnugget/bootstrap/cache
sudo chmod -R 775 /var/www/statusnugget/storage
sudo chmod -R 775 /var/www/statusnugget/bootstrap/cache
# Fix storage permissions (Docker)
sudo chown -R $USER:$USER storage bootstrap/cache
sudo chmod -R 775 storage bootstrap/cache
# Verify permissions
ls -la storage/
ls -la bootstrap/cache/
Problem: Composer install fails with memory or dependency errors
Solutions:
# Increase PHP memory limit
php -d memory_limit=2G /usr/local/bin/composer install
# Or set in php.ini
sudo nano /etc/php/8.1/cli/php.ini
# Change: memory_limit = 512M to memory_limit = 2G
# Clear Composer cache
composer clear-cache
# Install with verbose output
composer install -vvv
# Skip platform requirements if needed
composer install --ignore-platform-reqs
Problem: npm install fails or takes too long
Solutions:
# Clear npm cache
npm cache clean --force
# Delete node_modules and reinstall
rm -rf node_modules package-lock.json
npm install
# Use yarn instead
npm install -g yarn
yarn install
# Increase npm timeout
npm config set timeout 60000
npm install
Problem: Jobs stuck in queue
Symptoms:
Solutions:
# Check if queue worker is running (Standalone)
ps aux | grep "queue:work"
sudo supervisorctl status statusnugget-worker:*
# Start queue worker manually
php artisan queue:work redis --tries=3
# Check queue connection (Docker)
docker compose exec app php artisan queue:monitor
# Restart queue worker (Docker)
docker compose restart app
docker compose exec app php artisan queue:restart
# Check Redis connection
redis-cli ping # Should return PONG
# View failed jobs
php artisan queue:failed
# Retry failed jobs
php artisan queue:retry all
Problem: Application returns 500 error
Solutions:
# Check application logs
tail -f storage/logs/laravel.log
# Enable debug mode temporarily
# In .env: APP_DEBUG=true
# Remember to set back to false in production!
# Clear all caches
php artisan config:clear
php artisan cache:clear
php artisan route:clear
php artisan view:clear
# Rebuild caches
php artisan config:cache
php artisan route:cache
php artisan view:cache
# Check PHP error log
tail -f /var/log/php8.1-fpm.log
tail -f /var/log/nginx/error.log
Problem: Page loads but shows blank screen
Solutions:
# Check PHP errors
php artisan config:clear
php artisan view:clear
# Verify file permissions
ls -la storage/logs/
# Check disk space
df -h
# Verify .env file exists and is readable
cat .env | head -20
# Check browser console for JavaScript errors
# Press F12 in browser
Problem: Application is slow or unresponsive
Solutions:
# Enable OPcache (PHP)
# Edit php.ini
sudo nano /etc/php/8.1/fpm/php.ini
# Uncomment and set:
opcache.enable=1
opcache.memory_consumption=128
opcache.max_accelerated_files=10000
# Restart PHP-FPM
sudo systemctl restart php8.1-fpm
# Use Redis for caching
# In .env: CACHE_DRIVER=redis
php artisan config:cache
# Optimize autoloader
composer install --optimize-autoloader --no-dev
# Check server resources
htop
free -h
df -h
# Check database performance
# Enable slow query log in MySQL/PostgreSQL
Problem: Nginx returns 502 error
Solutions:
# Check PHP-FPM status
sudo systemctl status php8.1-fpm
sudo systemctl restart php8.1-fpm
# Verify PHP-FPM socket path
ls -la /var/run/php/php8.1-fpm.sock
# Check Nginx error log
sudo tail -f /var/log/nginx/error.log
# Verify PHP-FPM pool configuration
sudo nano /etc/php/8.1/fpm/pool.d/www.conf
# Ensure listen = /var/run/php/php8.1-fpm.sock
Problem: SSL certificate errors or renewal failures
Solutions:
# Verify domain DNS records
dig status.yourdomain.com
nslookup status.yourdomain.com
# Check firewall allows ports 80 and 443
sudo ufw status
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
# Test certificate renewal
sudo certbot renew --dry-run
# Force certificate renewal
sudo certbot renew --force-renewal
# Check certificate expiration
sudo certbot certificates
# Verify Nginx configuration
sudo nginx -t
# Check certificate files exist
ls -la /etc/letsencrypt/live/yourdomain.com/
Problem: Access denied to application
Solutions:
# Check file ownership
ls -la /var/www/statusnugget/
# Fix ownership
sudo chown -R www-data:www-data /var/www/statusnugget
# Check directory permissions
sudo chmod -R 755 /var/www/statusnugget
sudo chmod -R 775 /var/www/statusnugget/storage
# Verify Nginx/Apache user
# Nginx: www-data or nginx
# Apache: www-data
# Check SELinux (if enabled)
getenforce
sudo setenforce 0 # Temporarily disable for testing
Problem: Docker containers fail to start
Solutions:
# Check Docker daemon
sudo systemctl status docker
sudo systemctl start docker
# View container logs
docker compose logs
docker compose logs app
docker compose logs db
# Check container status
docker compose ps
docker ps -a
# Remove and recreate containers
docker compose down
docker compose up -d
# Check disk space
df -h
docker system df
# Clean up Docker resources
docker system prune -a
Problem: Docker can't bind to port
Solutions:
# Find what's using the port
sudo netstat -tulpn | grep :80
sudo lsof -i :80
sudo ss -tulpn | grep :80
# Stop conflicting service
sudo systemctl stop nginx # If Nginx is using port 80
sudo systemctl stop apache2 # If Apache is using port 80
# Or change Docker port mapping
# In docker-compose.yml, change:
ports:
- "8080:80" # Use port 8080 instead
Problem: Containers can't write to volumes
Solutions:
# Fix volume permissions
sudo chown -R $USER:$USER .
sudo chmod -R 775 storage bootstrap/cache
# Or run container as current user
# Add to docker-compose.yml:
user: "${UID}:${GID}"
# Check volume mounts
docker compose config
docker volume ls
Problem: Service monitoring not updating
Solutions:
# Check queue worker is running
php artisan queue:work
# Verify cron is running scheduled tasks
# Check crontab:
crontab -l
# Test health check manually
php artisan status:check [service-id]
# Check monitoring logs
tail -f storage/logs/laravel.log | grep "health"
# Verify network connectivity from server
curl -I https://your-monitored-service.com
ping your-monitored-service.com
Problem: Email/SMS notifications not delivered
Solutions:
# Test email configuration
php artisan tinker
Mail::raw('Test email', function($msg) {
$msg->to('your@email.com')->subject('Test');
});
# Check mail settings in .env
cat .env | grep MAIL_
# Verify SMTP credentials
# Test SMTP connection
telnet smtp.yourprovider.com 587
# Check queue for failed jobs
php artisan queue:failed
# Retry failed notification jobs
php artisan queue:retry all
Problem: Database migrations fail
Solutions:
# Check migration status
php artisan migrate:status
# Rollback last migration
php artisan migrate:rollback
# Rollback all migrations
php artisan migrate:reset
# Fresh migration (WARNING: Deletes all data)
php artisan migrate:fresh
# Check database connection
php artisan tinker
DB::connection()->getPdo();
# Verify database user permissions
# PostgreSQL:
sudo -u postgres psql
\du statusnugget
# MySQL:
mysql -u root -p
SHOW GRANTS FOR 'statusnugget'@'localhost';
Problem: Slow database queries
Solutions:
# Enable query logging (temporarily)
# In .env: DB_LOG_QUERIES=true
# Check slow queries
# PostgreSQL:
sudo -u postgres psql -d statusnugget
SELECT * FROM pg_stat_statements ORDER BY total_time DESC LIMIT 10;
# MySQL:
mysql -u root -p
SHOW FULL PROCESSLIST;
# Add database indexes
php artisan migrate
# Optimize database
# PostgreSQL:
VACUUM ANALYZE;
# MySQL:
OPTIMIZE TABLE table_name;
Problem: API requests return 401 Unauthorized
Solutions:
# Verify API key is set
php artisan tinker
config('app.api_key');
# Check API key format
# Should be a valid token string
# Verify API key in request header
# Header: Authorization: Bearer YOUR_API_KEY
# Check API rate limiting
# Review rate limit settings in config/api.php
# Test API endpoint
curl -H "Authorization: Bearer YOUR_API_KEY" \
https://status.yourdomain.com/api/v1/status
# Enable debug mode (development only!)
# In .env:
APP_DEBUG=true
APP_ENV=local
# Clear config cache
php artisan config:clear
# View detailed error pages
# Remember to disable in production!
# Application logs
tail -f storage/logs/laravel.log
# Web server logs
tail -f /var/log/nginx/error.log
tail -f /var/log/nginx/access.log
tail -f /var/log/apache2/error.log
# PHP-FPM logs
tail -f /var/log/php8.1-fpm.log
# System logs
sudo journalctl -u nginx -f
sudo journalctl -u php8.1-fpm -f
sudo dmesg | tail
# Check disk space
df -h
du -sh /var/www/statusnugget/*
# Check memory usage
free -h
top
htop
# Check CPU usage
top
htop
# Check network connectivity
ping google.com
curl -I https://google.com
# Check open ports
sudo netstat -tulpn
sudo ss -tulpn
If you're still experiencing issues after trying these solutions, here are additional resources:
Browse this comprehensive documentation for detailed guides and examples.
Report bugs, request features, or search existing issues on our GitHub repository.
Ask questions and share solutions with the Status Nugget community.
Contact support@statusnugget.com for enterprise support and priority assistance.