CloudPAM

Cloud-native IP Address Management

CloudPAM is a modern IPAM solution designed for hybrid and multi-cloud environments. It helps infrastructure teams plan, allocate, and track IP addresses across on-premises data centers and cloud providers.

Key Features

• Hierarchical Pool Management - Organize IP addresses in a tree structure matching your network topology
• Smart Planning - AI-assisted network planning with gap analysis, recommendations, and growth projections
• Cloud Discovery - Auto-import VPCs, subnets, and IPs from AWS, GCP, and Azure
• Schema Wizard - Design IP schemas with templates before deploying
• Drift Detection - Identify discrepancies between planned and actual allocations
• Multi-tenant - Role-based access control with team-scoped permissions

Quick Start

# Clone the repository
git clone https://github.com/BadgerOps/cloudpam.git
cd cloudpam

# Start with Docker Compose (SQLite)
docker-compose up -d

# Access the UI
open http://localhost:8080

Documentation

Getting Started

Document	Description
Quick Start Guide	Get running in 5 minutes
Deployment Guide	Production deployment options

Architecture & Design

Document	Description
API Specification	OpenAPI 3.1 spec (85+ endpoints)
Smart Planning API	AI planning & analysis endpoints
Database Schema	PostgreSQL/SQLite schema design
Authentication Flows	JWT, API keys, SSO/OIDC
Documentation Architecture	Embedded docs system

Smart Planning

Document	Description
Smart Planning Architecture	Discovery, analysis, and AI planning
Planning Interfaces	Go service interfaces
Implementation Roadmap	20-week development plan

Observability

Document	Description
Observability Architecture	Logging, metrics, tracing, audit
Observability Interfaces	Logger, Metrics, Tracer interfaces
Observability API	Audit log and health endpoints
Vector Configuration	Log shipping to Splunk, CloudWatch, etc.
K8s Observability	Prometheus, Grafana, Jaeger
Docker Compose	Local observability stack

User Guides

Document	Description
IP Schema Planning	Design effective IP schemas
Smart Planning Guide	AI-assisted network planning
API Examples	Common API usage patterns

UI Mockups

Mockup	Description
Dashboard	Main dashboard with pool overview
Cloud Accounts	Cloud provider integration
Discovery	Cloud resource discovery
Schema Planner	Visual schema designer
AI Planning Assistant	Conversational planning interface
Audit Log	Activity and change tracking
Auth Settings	Authentication configuration

Architecture Overview

┌─────────────────────────────────────────────────────────────────────────────┐
│                              CloudPAM                                        │
│                                                                              │
│  ┌────────────────┐  ┌────────────────┐  ┌────────────────────────────────┐ │
│  │    REST API    │  │    Web UI      │  │      AI Planning Assistant     │ │
│  │  (OpenAPI 3.1) │  │    (React)     │  │   (LLM-powered, pluggable)     │ │
│  └───────┬────────┘  └───────┬────────┘  └───────────────┬────────────────┘ │
│          │                   │                           │                   │
│  ┌───────┴───────────────────┴───────────────────────────┴────────────────┐ │
│  │                         Core Services                                   │ │
│  │  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌───────────────────┐ │ │
│  │  │    Pools    │ │    Auth     │ │   Audit     │ │   Smart Planning  │ │ │
│  │  │  Management │ │   (RBAC)    │ │   Logging   │ │  (Analysis + AI)  │ │ │
│  │  └─────────────┘ └─────────────┘ └─────────────┘ └───────────────────┘ │ │
│  └────────────────────────────────────────────────────────────────────────┘ │
│                                    │                                         │
│  ┌─────────────────────────────────┴─────────────────────────────────────┐  │
│  │                   PostgreSQL / SQLite (dual-mode)                      │  │
│  └────────────────────────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────────────────┘
          │                    │                    │
          ▼                    ▼                    ▼
   ┌─────────────┐      ┌─────────────┐      ┌─────────────┐
   │     AWS     │      │     GCP     │      │    Azure    │
   │ (VPC/EC2)   │      │ (Compute)   │      │  (VNets)    │
   └─────────────┘      └─────────────┘      └─────────────┘

Technology Stack

Component	Technology
Backend	Go 1.21+
Database	PostgreSQL 15+ (production) / SQLite (development)
Frontend	React 18 + Tailwind CSS
API	OpenAPI 3.1 with Scalar documentation
Auth	JWT + OAuth/OIDC + API Keys
AI	Pluggable LLM (OpenAI, Anthropic, Azure, Ollama)
Logging	slog (Go std lib) + Vector for shipping
Metrics	OpenTelemetry + Prometheus
Tracing	OpenTelemetry + Jaeger

Project Structure

cloudpam/
├── cmd/
│   └── cloudpam/           # Main application entry point
├── internal/
│   ├── api/                # HTTP handlers and routing
│   ├── domain/             # Core domain models
│   │   └── models.go       # Pool, Address, User types
│   ├── storage/            # Database interfaces and implementations
│   │   ├── interfaces.go   # Repository interfaces
│   │   ├── postgres/       # PostgreSQL implementation
│   │   └── sqlite/         # SQLite implementation
│   ├── planning/           # Smart planning services
│   │   └── interfaces.go   # Discovery, Analysis, AI interfaces
│   ├── observability/      # Logging, metrics, tracing
│   │   └── interfaces.go   # Logger, Metrics, Tracer interfaces
│   ├── auth/               # Authentication and authorization
│   └── docs/               # Embedded documentation
├── deploy/                 # Deployment configurations
│   ├── vector/             # Vector log shipping config
│   ├── k8s/                # Kubernetes manifests
│   └── docker-compose.observability.yml
├── migrations/             # Database migrations
├── web/                    # React frontend
├── openapi.yaml            # Core API specification
├── openapi-smart-planning.yaml  # Planning API specification
└── docker-compose.yml      # Local development setup

Implementation Status

Phase	Status	Description
Foundation	🟡 Design	Core API, database, auth
Cloud Integration	🟡 Design	AWS/GCP/Azure discovery
Smart Planning	🟡 Design	Analysis, recommendations
AI Planning	🟡 Design	LLM integration, conversations
Observability	🟡 Design	Logging, metrics, tracing, audit
Enterprise	⚪ Planned	Multi-tenancy, SSO

See IMPLEMENTATION_ROADMAP.md for the full development timeline.

API Overview

CloudPAM provides a comprehensive REST API with 100+ endpoints:

Core Resources

• GET/POST /api/v1/pools - Pool management
• GET/POST /api/v1/cloud-accounts - Cloud provider integration
• GET /api/v1/discovery/resources - Discovered cloud resources
• GET /api/v1/audit/events - Audit trail

Smart Planning

• POST /api/v1/planning/analyze - Run network analysis
• GET /api/v1/planning/recommendations - Get recommendations
• POST /api/v1/planning/ai/conversations - AI planning sessions
• POST /api/v1/planning/schema/generate - Generate schemas

Configuration

• GET/PUT /api/v1/settings/llm - LLM provider configuration
• GET /api/v1/settings/llm/prompts - Prompt templates

Full API documentation available at /docs/api when running.

Contributing

We welcome contributions! Please see our contributing guidelines:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

License

MIT License - see LICENSE for details.

Support

• Documentation: Browse the /docs endpoint
• Issues: GitHub Issues
• Discussions: GitHub Discussions