Deployment Guide

Architecture Overview

SecureInspector consists of three main components that you deploy on your infrastructure:

┌─────────────────────────────────────────────────────────────────────┐
│                     YOUR INFRASTRUCTURE                              │
│                                                                      │
│  ┌──────────────┐      ┌──────────────┐      ┌──────────────┐      │
│  │  Mobile App  │      │   Backend    │      │  Dashboard   │      │
│  │  (with SDK)  │─────▶│   (API)      │◀─────│   (React)    │      │
│  │              │      │   :8080      │      │   :3000      │      │
│  └──────────────┘      └──────┬───────┘      └──────────────┘      │
│                               │                                     │
│                               ▼                                     │
│                        ┌──────────────┐                             │
│                        │  PostgreSQL  │                             │
│                        │  Database    │                             │
│                        └──────────────┘                             │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘
                        

Requirements

Quick Start (Docker Compose)

The fastest way to get started. This will run all components on a single server.

version: '3.8'

services:
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: secureinspector
      POSTGRES_USER: inspector
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped

  backend:
    image: secureinspector/backend:latest
    ports:
      - "8080:8080"
    environment:
      DATABASE_URL: postgres://inspector:${DB_PASSWORD}@postgres:5432/secureinspector
      LICENSE_KEY: ${LICENSE_KEY}
      JWT_SECRET: ${JWT_SECRET}
    depends_on:
      - postgres
    restart: unless-stopped

  dashboard:
    image: secureinspector/dashboard:latest
    ports:
      - "3000:80"
    environment:
      VITE_API_URL: ${API_URL}
    restart: unless-stopped

volumes:
  postgres_data:

# Database password (generate a strong one)
DB_PASSWORD=your-secure-db-password-here

# Your license key (provided by SecureInspector)
LICENSE_KEY=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...

# JWT secret for authentication (generate random 32+ chars)
JWT_SECRET=your-jwt-secret-minimum-32-characters

# Public URL where backend API is accessible
API_URL=https://api.yourcompany.com

$ docker-compose up -d

# Check status
$ docker-compose ps

# View logs
$ docker-compose logs -f backend

Backend Setup

The backend is a Kotlin/Ktor application that handles all API requests from mobile SDKs and the dashboard.

Docker Run (Standalone)

$ docker run -d \
  --name secureinspector-backend \
  -p 8080:8080 \
  -e DATABASE_URL="postgres://user:pass@db-host:5432/secureinspector" \
  -e LICENSE_KEY="your-license-key" \
  -e JWT_SECRET="your-jwt-secret-32-chars-minimum" \
  -e ADMIN_EMAIL="admin@yourcompany.com" \
  -e ADMIN_PASSWORD="initial-admin-password" \
  secureinspector/backend:latest

Health Check

$ curl http://localhost:8080/health

# Response:
{
  "status": "healthy",
  "database": "connected",
  "license": "valid",
  "version": "1.2.0"
}

Dashboard Setup

The dashboard is a React application that connects to your backend API.

Docker Run (Standalone)

$ docker run -d \
  --name secureinspector-dashboard \
  -p 3000:80 \
  -e VITE_API_URL="https://api.yourcompany.com" \
  secureinspector/dashboard:latest

Static Hosting (Alternative)

The dashboard can also be deployed as static files to any web server (Nginx, Apache, Cloudflare Pages, etc.):

# Download the static build
$ wget https://releases.secureinspector.io/dashboard/latest.tar.gz
$ tar -xzf latest.tar.gz -C /var/www/dashboard

# Configure Nginx
server {
    listen 443 ssl;
    server_name dashboard.yourcompany.com;
    root /var/www/dashboard;
    index index.html;

    location / {
        try_files $uri $uri/ /index.html;
    }
}

Database Setup

SecureInspector uses PostgreSQL 14+ for data storage. You can use a managed service or self-host.

Option 1: Managed PostgreSQL

Recommended for production. Use your cloud provider's managed PostgreSQL:

• AWS RDS for PostgreSQL
• Google Cloud SQL
• Azure Database for PostgreSQL
• DigitalOcean Managed Databases

Option 2: Docker PostgreSQL

$ docker run -d \
  --name secureinspector-db \
  -p 5432:5432 \
  -e POSTGRES_DB=secureinspector \
  -e POSTGRES_USER=inspector \
  -e POSTGRES_PASSWORD=secure-password \
  -v postgres_data:/var/lib/postgresql/data \
  postgres:15-alpine

Database Migrations

The backend automatically runs migrations on startup. No manual action required.

Environment Variables

Backend

Dashboard

License Installation

When you purchase SecureInspector, you receive a license key. This key validates your installation.

SSL/HTTPS Setup

HTTPS is required for production. Mobile SDKs expect HTTPS endpoints.

Option 1: Let's Encrypt with Certbot

# Install certbot
$ apt install certbot python3-certbot-nginx

# Get certificate
$ certbot --nginx -d api.yourcompany.com -d dashboard.yourcompany.com

# Auto-renewal is configured automatically

Option 2: Cloudflare / Load Balancer

Use your cloud provider's load balancer with managed SSL certificates, or Cloudflare for SSL termination.

Reverse Proxy (Nginx)

Recommended setup with Nginx as reverse proxy for both backend and dashboard.

# /etc/nginx/sites-available/secureinspector

# Backend API
server {
    listen 443 ssl http2;
    server_name api.yourcompany.com;

    ssl_certificate /etc/letsencrypt/live/api.yourcompany.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/api.yourcompany.com/privkey.pem;

    location / {
        proxy_pass http://localhost:8080;
        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;
    }
}

# Dashboard
server {
    listen 443 ssl http2;
    server_name dashboard.yourcompany.com;

    ssl_certificate /etc/letsencrypt/live/dashboard.yourcompany.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/dashboard.yourcompany.com/privkey.pem;

    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Backups

Regular backups are essential. Focus on the PostgreSQL database.

PostgreSQL Backup Script

#!/bin/bash
# backup.sh

BACKUP_DIR=/var/backups/secureinspector
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

# Create backup
docker exec secureinspector-db pg_dump -U inspector secureinspector | gzip > $BACKUP_DIR/db_$TIMESTAMP.sql.gz

# Keep only last 7 days
find $BACKUP_DIR -type f -mtime +7 -delete

# Run daily via cron
# 0 2 * * * /opt/scripts/backup.sh

Updates

Updating SecureInspector is straightforward with Docker.

# Pull latest images
$ docker-compose pull

# Restart services (migrations run automatically)
$ docker-compose up -d

# Check version
$ curl http://localhost:8080/health | jq .version

Troubleshooting