Self-Hosted Requirements

Self-Hosted Requirements

This document details the requirements for running Huitzo on your own infrastructure.

Hardware Requirements

Minimum Specifications

Resource Minimum Description
CPU 4 vCPU x86_64 or arm64 architecture
RAM 8 GB For all services combined
Storage 50 GB SSD NVMe recommended for performance
Network 100 Mbps Stable connection for license validation
Resource Recommended Description
CPU 8 vCPU Better performance for parallel commands
RAM 16 GB Room for larger datasets and caching
Storage 200 GB NVMe Fast storage for database I/O
Network 1 Gbps For file uploads and LLM API calls

Resource Allocation by Service

Service Memory CPU Purpose
app 2 GB 2 cores API server, WebCLI
worker 1 GB 1 core Background task execution
postgres 2 GB 1 core Primary data storage
redis 512 MB 0.5 cores Cache, task queue

Scaling Guidelines

Concurrent Users CPU RAM Workers
1-10 4 vCPU 8 GB 1
10-50 8 vCPU 16 GB 2
50-100 16 vCPU 32 GB 4
100+ Contact us

Software Requirements

Docker Environment

Software Minimum Version Notes
Docker 28.0+ Docker Engine 29.x recommended
Docker Compose v2.28+ V2 syntax required
Linux Kernel 5.15+ For Ubuntu 24.04+, RHEL 9+

Database Services

PostgreSQL and Redis are required but do not need to be containers. Options:

Option PostgreSQL Redis Best For
Containers postgres:17-alpine redis:8-alpine Simple deployments, dev/test
Cloud Managed AWS RDS, Azure Database, GCP Cloud SQL ElastiCache, Azure Cache, Memorystore Production, HA requirements
On-Premises Dedicated PostgreSQL server Dedicated Redis server Enterprise, existing infrastructure

Requirements: - PostgreSQL 14+ (17 recommended) - Redis 6+ (8 recommended)

See Deployment Guide - External Services for connection configuration.

Operating System Support

OS Version Status
Ubuntu 24.04 LTS Recommended
Ubuntu 22.04 LTS Supported (until 2027)
RHEL 9.x Supported
Rocky Linux 9.x Supported
Debian 12 (Bookworm) Supported
macOS 14+ (Sonoma) Docker Desktop
Windows 10/11 + WSL2 Docker Desktop

Architecture Support

Architecture Platform Notes
x86_64 (amd64) Intel/AMD Primary development platform
arm64 (aarch64) ARM AWS Graviton, Oracle Ampere, Apple Silicon

Network Requirements

Outbound Connectivity

The following endpoints require outbound access:

Endpoint Port Purpose Required
api.keygen.sh 443 License validation Yes*
api.openai.com 443 OpenAI LLM API If using OpenAI
api.anthropic.com 443 Anthropic LLM API If using Anthropic
api.sendgrid.com 443 Email sending If using SendGrid
registry.hub.docker.com 443 Docker image pulls For updates

*License validation has a 7-day offline grace period.

Inbound Access

Port Protocol Purpose
443 HTTPS WebCLI, API access (via reverse proxy)
80 HTTP Redirect to HTTPS

Internal Network

All services communicate on a Docker bridge network:

Service Internal Port Protocol
app 8080 HTTP
postgres 5432 PostgreSQL
redis 6379 Redis

Firewall Rules

# Required: Allow HTTPS outbound for license validation
iptables -A OUTPUT -p tcp --dport 443 -j ACCEPT

# Optional: Allow HTTPS inbound (if not using reverse proxy)
iptables -A INPUT -p tcp --dport 443 -j ACCEPT

# Internal Docker network (usually auto-configured)
iptables -A INPUT -i docker0 -j ACCEPT

Storage Requirements

Database Storage

PostgreSQL storage grows with usage:

Data Type Growth Rate Retention
User/tenant data 1-10 MB/user/month Permanent
Command execution logs 100-500 KB/command 90 days
Pack data Varies by pack Pack-defined TTL
Sessions 1 KB/session 7 days

File Storage

User uploads and pack files require persistent storage. Choose based on your deployment scenario:

Backend Best For Requirements
Local filesystem Single-instance, dev/test Docker volume mount
S3-compatible Production, multi-instance AWS S3, MinIO, or compatible service
Azure Blob Azure deployments Azure Storage account
Google Cloud Storage GCP deployments GCS bucket + credentials

Local filesystem (default):

Path Purpose Sizing
/app/uploads User file uploads 2 GB per user (configurable)
/app/packs Intelligence packs 100 MB - 1 GB per pack

Object storage requirements:

Backend Minimum Requirements
AWS S3 Bucket with read/write access, IAM credentials
MinIO MinIO server, bucket created, access credentials
Azure Blob Storage account, container, access key or managed identity
GCS Bucket, service account with Storage Object Admin role

Decision guide:

Question If Yes If No
Multi-instance deployment? Use object storage Local filesystem OK
Need high availability? Use object storage Local filesystem OK
Running on AWS? Use S3 Consider MinIO or local
Running on Azure? Use Azure Blob Consider MinIO or local
Running on GCP? Use GCS Consider MinIO or local
Air-gapped environment? Use MinIO Use cloud provider storage

Network requirements for object storage:

Backend Outbound Access Required
AWS S3 *.s3.amazonaws.com:443
Azure Blob *.blob.core.windows.net:443
GCS storage.googleapis.com:443
MinIO Your MinIO endpoint (internal or external)

See File Storage Backends for detailed configuration and Deployment Guide for setup instructions.

Backup Storage

Plan for backup storage: - Daily PostgreSQL backups: 2x database size - Weekly full backups: 3x total data volume - Retention: 30 days recommended


Security Requirements

TLS/SSL

Requirement Details
TLS Version 1.2 minimum, 1.3 recommended
Certificate Valid SSL certificate (Let's Encrypt, commercial)
Key Size RSA 2048+ or ECDSA P-256+

Authentication

Component Method
WebCLI/API JWT tokens (15 min expiry)
Admin Access Strong password + optional 2FA
License keygen.sh validation

Data Protection

Aspect Recommendation
Data at Rest Encrypted filesystem (LUKS, BitLocker)
Data in Transit TLS 1.2+ for all connections
Backups Encrypted backup storage

Environment Checklist

Pre-Deployment Checklist

  • Hardware meets minimum requirements
  • Docker 28.0+ installed (29.x recommended)
  • Docker Compose v2.28+ installed
  • PostgreSQL 14+ available (container or external service)
  • Redis 6+ available (container or external service)
  • Outbound connectivity to api.keygen.sh
  • Valid Huitzo license key
  • SSL certificate for production
  • Backup storage configured

Security Checklist

  • TLS 1.2+ enabled
  • Strong database password (20+ characters)
  • Secret key generated (openssl rand -hex 32)
  • Firewall rules configured
  • Reverse proxy configured (nginx/traefik)

Operations Checklist

  • Monitoring configured
  • Backup schedule configured
  • Log rotation configured
  • Health check alerts configured

Capacity Planning

Resource Lifecycle: Pack count does not affect memory requirements. Packs are stateless functions, not persistent processes. Worker count determines throughput. See Resource Lifecycle Management for details.

Estimating Requirements

Use this formula to estimate resources:

CPU cores = 4 + (concurrent_users / 25)
RAM GB = 8 + (concurrent_users / 10)
Storage GB = 50 + (users * 5) + (commands_per_month * 0.001)

Example Configurations

Small (Startup/Team): - 4 vCPU, 8 GB RAM, 50 GB SSD - 1-10 concurrent users - All-in-one Docker Compose (app + worker + postgres + redis)

Medium (Department/SMB): - 8 vCPU, 16 GB RAM, 200 GB NVMe - 10-50 concurrent users - Docker Compose (app + worker) + external managed PostgreSQL/Redis - Example: AWS RDS + ElastiCache, Azure Database + Cache

Large (Enterprise): - 16+ vCPU, 32+ GB RAM, 500+ GB NVMe - 50+ concurrent users - Docker/Kubernetes (app + workers) + managed PostgreSQL + managed Redis - High availability database configuration - Contact [email protected] for enterprise deployment options