Quick Install Guide

Get ANTE ERP up and running in under 5 minutes using the official CLI tool.

Installation Methods

Choose the method that best suits your needs:

Option 1: CLI Installation (Recommended) ⭐

The fastest and easiest way to install ANTE ERP. The CLI handles everything automatically:

• System requirements validation
• Automatic Docker configuration
• Secure credential generation
• Service health monitoring
• Built-in backup/restore

Installation time: ~5 minutes

→ Jump to CLI Installation

Option 2: Manual Docker Installation

For users who prefer manual control or need custom configurations:

• Full control over configuration
• Direct docker-compose management
• Custom port mapping
• Advanced networking options

Installation time: ~20 minutes

→ Jump to Manual Installation

---

Option 1: CLI Installation (Recommended)

Step 1: Install the ANTE CLI

# Install globally using npm
npm install -g ante-erp-cli

# Verify installation
ante --version

Node.js Required

The CLI requires Node.js 24.0 or higher (LTS). If you don't have Node.js installed:

# Ubuntu/Debian
curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -
sudo apt-get install -y nodejs

# Verify
node --version

Step 2: Run Installation

# Run the interactive installer
ante install

# Or specify installation directory
ante install --dir /opt/ante-erp

# Or use non-interactive mode with defaults
ante install --no-interactive

The installer will:

1. ✅ Check system requirements (Docker, disk space, memory)
2. ✅ Generate secure credentials automatically
3. ✅ Create optimized Docker configuration
4. ✅ Pull Docker images
5. ✅ Start all services
6. ✅ Run database migrations
7. ✅ Save credentials to installation directory

Step 3: Access ANTE ERP

After installation completes (2-3 minutes), open your browser:

http://localhost:8080

The CLI will display your installation details and credentials.

Managing Your Installation

Once installed, use these CLI commands:

# Check service status
ante status

# View logs
ante logs --follow

# Create backup
ante backup

# Update to latest version
ante update

# Restart services
ante restart

# Run health check
ante doctor

→ See all CLI commands

---

Option 2: Manual Docker Installation

For manual installation, follow these steps:

Overview

This guide uses:

• Pre-built Docker images from GitHub Container Registry
• Simple docker-compose configuration
• Automatic database initialization
• Default settings for quick deployment

Perfect For

Quick evaluation, testing, or small production deployments (5-20 users)

Prerequisites

Before starting, ensure you have:

• ✅ Docker 20.10+ installed
• ✅ Docker Compose v2.0+ installed
• ✅ 2GB RAM minimum
• ✅ 20GB free disk space
• ✅ Ports 8080, 3001, 4001 available

→ Full Prerequisites Guide

Installation Steps

Step 1: Create Installation Directory

# Create a directory for ANTE ERP
mkdir -p ~/ante-erp
cd ~/ante-erp

Step 2: Download Docker Compose Configuration

Create a file named docker-compose.yml:

nano docker-compose.yml

Copy and paste this configuration:

version: '3.8'

services:
  # PostgreSQL Database
  postgres:
    image: postgres:15-alpine
    container_name: ante-postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: ante
      POSTGRES_PASSWORD: ${DB_PASSWORD:-ante_secure_password_change_me}
      POSTGRES_DB: ante_db
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - ante-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ante"]
      interval: 10s
      timeout: 5s
      retries: 5

  # Redis Cache
  redis:
    image: redis:7-alpine
    container_name: ante-redis
    restart: unless-stopped
    command: redis-server --requirepass ${REDIS_PASSWORD:-redis_secure_password_change_me}
    volumes:
      - redis_data:/data
    networks:
      - ante-network
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  # MongoDB
  mongodb:
    image: mongo:7
    container_name: ante-mongodb
    restart: unless-stopped
    environment:
      MONGO_INITDB_ROOT_USERNAME: ante
      MONGO_INITDB_ROOT_PASSWORD: ${MONGO_PASSWORD:-mongo_secure_password_change_me}
    volumes:
      - mongodb_data:/data/db
    networks:
      - ante-network
    healthcheck:
      test: echo 'db.runCommand("ping").ok' | mongosh localhost:27017/test --quiet
      interval: 10s
      timeout: 5s
      retries: 5

  # ANTE Backend
  backend:
    image: ghcr.io/gtplusnet/ante-self-hosted-backend:latest
    container_name: ante-backend
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      mongodb:
        condition: service_healthy
    environment:
      # Node Environment
      NODE_ENV: production
      PORT: 3001
      
      # Database Configuration
      DATABASE_URL: postgresql://ante:${DB_PASSWORD:-ante_secure_password_change_me}@postgres:5432/ante_db
      DIRECT_URL: postgresql://ante:${DB_PASSWORD:-ante_secure_password_change_me}@postgres:5432/ante_db
      
      # Redis Configuration
      REDIS_HOST: redis
      REDIS_PORT: 6379
      REDIS_PASSWORD: ${REDIS_PASSWORD:-redis_secure_password_change_me}
      REDIS_DB: 0
      REDIS_TLS: "false"
      
      # MongoDB Configuration
      MONGODB_URI: mongodb://ante:${MONGO_PASSWORD:-mongo_secure_password_change_me}@mongodb:27017/ante?authSource=admin
      
      # Security Keys (CHANGE THESE!)
      JWT_SECRET: ${JWT_SECRET:-change-this-to-random-string-min-32-characters-long}
      DEVELOPER_KEY: ${DEVELOPER_KEY:-change-this-key}
      ENCRYPTION_KEY: ${ENCRYPTION_KEY:-change-this-key}
      
      # Application URLs
      FRONTEND_URL: http://localhost:8080
      API_URL: http://localhost:3001
      
      # Email Configuration (optional)
      SMTP_HOST: ${SMTP_HOST:-}
      SMTP_PORT: ${SMTP_PORT:-587}
      SMTP_USERNAME: ${SMTP_USERNAME:-}
      SMTP_PASSWORD: ${SMTP_PASSWORD:-}
      SMTP_FROM_EMAIL: ${SMTP_FROM_EMAIL:-noreply@ante.local}
      
    ports:
      - "3001:3001"
      - "4001:4001"
    volumes:
      - backend_uploads:/app/uploads
    networks:
      - ante-network
    healthcheck:
      test: ["CMD", "wget", "--spider", "-q", "http://localhost:3001/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s

  # ANTE Frontend
  frontend:
    image: ghcr.io/gtplusnet/ante-self-hosted-frontend-main:latest
    container_name: ante-frontend
    restart: unless-stopped
    depends_on:
      - backend
    ports:
      - "8080:80"
    networks:
      - ante-network
    healthcheck:
      test: ["CMD", "wget", "--spider", "-q", "http://localhost:80"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  postgres_data:
    driver: local
  redis_data:
    driver: local
  mongodb_data:
    driver: local
  backend_uploads:
    driver: local

networks:
  ante-network:
    driver: bridge

Save and exit (Ctrl+X, then Y, then Enter in nano).

Step 3: Create Environment Configuration

Create a .env file with secure passwords:

nano .env

Add these variables (replace with your own secure passwords):

# Database Passwords
DB_PASSWORD=your_secure_postgres_password_here
REDIS_PASSWORD=your_secure_redis_password_here
MONGO_PASSWORD=your_secure_mongo_password_here

# Security Keys (must be changed!)
JWT_SECRET=your-very-long-random-jwt-secret-at-least-32-characters-long
DEVELOPER_KEY=your-random-16-char-dev-key
ENCRYPTION_KEY=your-random-16-char-enc-key

# Email Configuration (optional - can configure later)
SMTP_HOST=
SMTP_PORT=587
SMTP_USERNAME=
SMTP_PASSWORD=
SMTP_FROM_EMAIL=noreply@ante.local

Generate Secure Passwords

Use these commands to generate secure random passwords:

# Generate passwords
echo "DB_PASSWORD=$(openssl rand -base64 24)"
echo "REDIS_PASSWORD=$(openssl rand -base64 32)"
echo "MONGO_PASSWORD=$(openssl rand -base64 24)"
echo "JWT_SECRET=$(openssl rand -base64 48)"
echo "DEVELOPER_KEY=$(openssl rand -hex 16)"
echo "ENCRYPTION_KEY=$(openssl rand -hex 16)"

Save and exit.

Step 4: Download and Start Services

# Pull Docker images (this may take 5-10 minutes)
docker compose pull

# Start all services
docker compose up -d

# The -d flag runs containers in the background

You should see output like:

[+] Running 5/5
 ✔ Container ante-postgres   Started
 ✔ Container ante-redis      Started  
 ✔ Container ante-mongodb    Started
 ✔ Container ante-backend    Started
 ✔ Container ante-frontend   Started

Step 5: Wait for Services to Initialize

# Check service status
docker compose ps

# Watch logs to see initialization progress
docker compose logs -f backend

# Wait for message: "Application is running on: http://0.0.0.0:3001"
# Press Ctrl+C to stop following logs

Database migrations run automatically on first startup. This may take 1-2 minutes.

Step 6: Verify Installation

# Check all containers are healthy
docker compose ps

# Should show all services as "Up" and "healthy"

Test the services:

# Test backend API
curl http://localhost:3001/health

# Should return: {"status":"ok"}

# Test frontend (should return HTML)
curl http://localhost:8080

Step 7: Access ANTE ERP

Open your web browser and navigate to:

http://localhost:8080

Or if accessing from another computer:

http://YOUR_SERVER_IP:8080

First Time Setup

On first access, you'll need to create an admin account. Follow the on-screen instructions to set up your initial user.

Default Configuration

After installation, ANTE ERP runs with these defaults:

Component	Access URL	Notes
Frontend	http://localhost:8080	Main web interface
Backend API	http://localhost:3001	API endpoints
WebSocket	ws://localhost:4001	Real-time updates
PostgreSQL	localhost:5433 (internal)	Main database
Redis	localhost:6380 (internal)	Cache
MongoDB	localhost:27018 (internal)	Documents

Basic Management Commands

View Status

docker compose ps

View Logs

# All services
docker compose logs -f

# Specific service
docker compose logs -f backend
docker compose logs -f frontend

Restart Services

# Restart all
docker compose restart

# Restart specific service
docker compose restart backend

Stop Services

# Stop all (data preserved)
docker compose stop

# Start again
docker compose start

Update to Latest Version

# Pull latest images
docker compose pull

# Restart with new images
docker compose up -d

Complete Shutdown

# Stop and remove containers (data preserved in volumes)
docker compose down

# To also remove volumes (⚠️ DELETES ALL DATA):
docker compose down -v

Troubleshooting Quick Fixes

Backend won't start

# Check logs
docker compose logs backend

# Common issue: database not ready
# Solution: Wait 30 seconds and check again
docker compose restart backend

Can't access frontend

# Check if containers are running
docker compose ps

# Check frontend logs
docker compose logs frontend

# Verify port is accessible
curl http://localhost:8080

Database connection error

# Restart all services in correct order
docker compose down
docker compose up -d postgres redis mongodb
sleep 10
docker compose up -d backend frontend

Port already in use

# Find what's using the port
sudo lsof -i :8080

# Either kill that process or change ports in docker-compose.yml

Post-Installation

After successful installation:

1. ✅ Create Admin Account - Set up your first admin user
2. ✅ Configure System - Set company details, modules, etc.
3. ✅ Setup SSL - Configure HTTPS for production
4. ✅ Configure Backups - Set up automated backups
5. ✅ Import Data - Import users, departments, projects

Next Steps

• 📖 Configuration Guide - Customize your installation
• 🔒 Security Guide - Setup SSL and secure your instance
• 💾 Backup Setup - Configure automated backups
• 🔧 Troubleshooting - Solve common issues

Getting Help

Need assistance?

• Troubleshooting Guide
• Command Reference
• FAQs
• Email: support@ante.ph

---

Congratulations! Your ANTE ERP instance is now running! 🎉

---

CLI Command Reference

Complete list of ANTE CLI commands (for Option 1 installations):

Basic Commands

ante --help              # Show all commands
ante --version           # Show CLI version
ante status              # Show service status
ante logs                # View all logs
ante logs --follow       # Follow logs in real-time

Service Management

ante start               # Start all services
ante stop                # Stop all services
ante restart             # Restart all services

Backup & Restore

ante backup              # Create backup
ante backup:list         # List available backups
ante restore [file]      # Restore from backup

Database Operations

ante db:migrate          # Run database migrations
ante db:seed             # Seed database with initial data
ante db:shell            # Open PostgreSQL shell
ante db:optimize         # Optimize database performance
ante db:reset            # Reset database (destructive)
ante db:info             # Show database information

Updates & Maintenance

ante update              # Update ANTE ERP to latest version
ante update-cli          # Update CLI tool to latest version
ante update-cli --check  # Check for CLI updates without installing
ante doctor              # Run health diagnostics
ante uninstall           # Uninstall ANTE ERP

Examples

# View backend logs only
ante logs --service backend --follow

# Update CLI tool to latest version
ante update-cli

# Create backup before update
ante backup
ante update

# Check system health
ante doctor

For full documentation, visit: https://www.npmjs.com/package/ante-erp-cli

---

Last Updated: October 27, 2025