OneClickOps - Self-Service Infrastructure Model

A modern, multi-cloud infrastructure provisioning platform that enables self-service Kubernetes deployments across AWS, Azure, and GCP.

Features • Quick Start • Architecture • Usage • Configuration • Contributing

---

🎯 What is OneClickOps?

OneClickOps is an open-source infrastructure provisioning platform that allows teams to self-service their Kubernetes environments. Instead of waiting for DevOps teams to manually provision infrastructure, developers and stakeholders can:

• Select a cloud provider (AWS, Azure, or GCP)
• Choose environment specifications (size, type, region)
• Click deploy and get a fully configured Kubernetes cluster with a managed database

The platform handles all the complexity of cloud provisioning, including VPC setup, security groups, IAM roles, and Kubernetes configuration.

The Problem It Solves

Traditional Approach	With OneClickOps
Submit ticket to DevOps	Self-service portal
Wait 2-5 days for provisioning	Automated in 15-20 minutes
Manual, error-prone process	Consistent, repeatable deployments
No cost visibility	Real-time cost estimation
Single cloud vendor lock-in	Multi-cloud flexibility
No lifecycle management	Automated TTL and cleanup

Key Metrics

• 83% faster provisioning (90 min → 15 min)
• 100% reduction in engineer wait time (async processing)
• 3x cloud options (AWS, Azure, GCP)
• Full cost visibility before deployment

---

✨ Features

🌐 Multi-Cloud Support

• AWS: EKS (Elastic Kubernetes Service) + RDS (PostgreSQL)
• Azure: AKS (Azure Kubernetes Service) + Azure Database for PostgreSQL
• GCP: GKE (Google Kubernetes Engine) + Cloud SQL

🚀 Self-Service Interface

• Web UI: Modern React-based dashboard for stakeholders
• REST API: Full-featured API for automation
• CLI Tool: Command-line interface for power users

💰 Cost Management

• Pre-deployment estimates: Know costs before you deploy
• Provider comparison: Compare costs across AWS, Azure, and GCP
• Annual projections: See reserved instance savings

🔄 Async Processing

• Non-blocking: Submit request and continue working
• Real-time updates: WebSocket-based progress tracking
• Task management: Monitor all provisioning tasks

🔐 Security

• JWT Authentication: Secure API access
• Role-Based Access Control: Fine-grained permissions
• Secret Management: HashiCorp Vault integration (optional)
• No credential storage: Bring your own cloud credentials

📊 Observability

• Prometheus metrics: Monitor platform health
• Grafana dashboards: Visualize operations
• Structured logging: JSON logs for analysis
• Distributed tracing: Debug complex flows

⏰ Lifecycle Management

• TTL (Time-to-Live): Auto-cleanup environments
• Scheduled actions: Stop/start on schedule
• Extension management: Request more time when needed

---

🚀 Quick Start

Prerequisites

• Docker & Docker Compose v2.0+
• Cloud credentials for your target provider(s):
  • AWS: Access Key ID & Secret Access Key
  • Azure: Service Principal credentials
  • GCP: Service Account JSON key

1. Clone the Repository

git clone https://github.com/thegde/oneclickops.git
cd oneclickops/cloud_provider

2. Start the Platform

# Start with minimal setup (recommended for first run)
docker-compose -f docker-compose.minimal.yml up -d

# Check status
docker-compose -f docker-compose.minimal.yml ps

3. Access the Platform

Service	URL	Description
Web UI	http://localhost:3000	Self-service dashboard
API Docs	http://localhost:8022/api/docs	Interactive API documentation
Flower	http://localhost:5555	Task monitoring

4. Create Your First Environment

Option A: Using the Web UI

1. Open http://localhost:3000
2. Select your cloud provider (AWS/Azure/GCP)
3. Enter customer name and environment name
4. Choose environment size
5. Click "Create Environment"

Option B: Using the API

# Create infrastructure
curl -X POST http://localhost:8022/api/v1/infrastructure \
  -H "Content-Type: application/json" \
  -d '{
    "cloud_provider": "aws",
    "customer_name": "mycompany",
    "environment_name": "dev",
    "environment_type": "dev",
    "environment_size": "small"
  }'

Option C: Using the CLI

# Install CLI
cd cli && pip install -e .

# Create infrastructure
ssm create -c mycompany -e dev -p aws -s small

---

🏗️ Architecture

┌─────────────────────────────────────────────────────────────────┐
│                         USER INTERFACES                         │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐         │
│  │   Web UI    │    │  REST API   │    │    CLI      │         │
│  │  (React)    │    │  (FastAPI)  │    │  (Python)   │         │
│  └─────────────┘    └─────────────┘    └─────────────┘         │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                      PLATFORM API LAYER                         │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐  ┌───────────┐   │
│  │   Auth    │  │   Rate    │  │ Validation│  │ WebSocket │   │
│  │   (JWT)   │  │  Limiting │  │ (Pydantic)│  │  Updates  │   │
│  └───────────┘  └───────────┘  └───────────┘  └───────────┘   │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                    ASYNC TASK PROCESSING                        │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐                   │
│  │  Celery   │  │   Redis   │  │  Flower   │                   │
│  │  Workers  │  │   Queue   │  │ Monitoring│                   │
│  └───────────┘  └───────────┘  └───────────┘                   │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                  CLOUD PROVIDER ABSTRACTION                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │              Unified Provider Interface                  │   │
│  │   create_cluster() | create_database() | create_vpc()   │   │
│  └─────────────────────────────────────────────────────────┘   │
│         │                    │                    │             │
│         ▼                    ▼                    ▼             │
│  ┌───────────┐        ┌───────────┐        ┌───────────┐       │
│  │    AWS    │        │   Azure   │        │    GCP    │       │
│  │ EKS + RDS │        │ AKS + PSQL│        │ GKE + SQL │       │
│  └───────────┘        └───────────┘        └───────────┘       │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                    INFRASTRUCTURE AS CODE                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                    Terraform Modules                     │   │
│  │         VPC | Kubernetes | Database | Security          │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Component Overview

Component	Technology	Purpose
Web UI	React	Self-service dashboard for stakeholders
API	FastAPI	REST API with OpenAPI documentation
Task Queue	Celery + Redis	Async processing of long-running tasks
Database	SQLite/PostgreSQL	Track infrastructure and tasks
IaC	Terraform	Provision cloud resources
Secrets	HashiCorp Vault	Secure credential storage (optional)

---

📖 Usage

Web UI

The web interface is designed for stakeholders who need to provision infrastructure without technical expertise.

Creating an Environment:

1. Select Cloud Provider: Choose AWS, Azure, or GCP based on your requirements
2. Enter Details:
   • Customer Name: Your organization identifier (e.g., "acme-corp")
   • Environment Name: Purpose of the environment (e.g., "dev", "staging")
3. Choose Configuration:
   • Environment Type: dev, qa, stage, or uat
   • Environment Size: small (3 nodes), medium (5 nodes), or large (8 nodes)
4. Review Cost: See estimated monthly cost before deploying
5. Deploy: Click "Create Environment" and monitor progress

REST API

Full API documentation is available at http://localhost:8022/api/docs

Authentication:

# Login to get JWT token
curl -X POST http://localhost:8022/api/v1/auth/login \
  -H "Content-Type: application/json" \
  -d '{"username": "admin", "password": "admin123"}'

# Use token in subsequent requests
export TOKEN="your-jwt-token"
curl -H "Authorization: Bearer $TOKEN" http://localhost:8022/api/v1/infrastructure

Key Endpoints:

Method	Endpoint	Description
POST	/api/v1/auth/login	Authenticate and get JWT token
POST	/api/v1/infrastructure	Create new infrastructure
GET	/api/v1/infrastructure	List all infrastructure
GET	/api/v1/infrastructure/{id}	Get infrastructure details
DELETE	/api/v1/infrastructure/{id}	Delete infrastructure
GET	/api/v1/tasks/{id}	Get task status
POST	/api/v1/catalog/cost-estimate	Estimate costs
GET	/api/v1/catalog/templates	List environment templates

CLI

The CLI is ideal for automation and power users.

Installation:

cd cli
pip install -e .

Commands:

# Authentication
ssm login -u admin -p admin123

# Create infrastructure
ssm create \
  --customer acme \
  --environment staging \
  --provider azure \
  --size medium \
  --type stage

# List infrastructure
ssm list

# Check task status
ssm task <task-id>

# Estimate costs
ssm cost --provider aws --size medium

# Delete infrastructure
ssm delete <infrastructure-id>

---

⚙️ Configuration

Environment Variables

Create a .env file in the cloud_provider directory:

# Application
APP_NAME=OneClickOps
ENVIRONMENT=production
DEBUG=false

# Authentication
JWT_SECRET=your-secure-secret-key-change-this
JWT_EXPIRE_MINUTES=60
AUTH_DISABLED=false

# Redis
REDIS_URL=redis://localhost:6379/0
CELERY_BROKER_URL=redis://localhost:6379/0
CELERY_RESULT_BACKEND=redis://localhost:6379/1

# Database
DATABASE_URL=postgresql://user:pass@localhost:5432/ssm

# Vault (optional)
VAULT_ENABLED=true
VAULT_ADDR=http://localhost:8200
VAULT_TOKEN=your-vault-token

Cloud Credentials

OneClickOps uses your cloud credentials to provision infrastructure. You have several options:

Option 1: Environment Variables

AWS:

export AWS_ACCESS_KEY_ID=your-access-key
export AWS_SECRET_ACCESS_KEY=your-secret-key
export AWS_REGION=us-east-1

Azure:

export AZURE_SUBSCRIPTION_ID=your-subscription-id
export AZURE_TENANT_ID=your-tenant-id
export AZURE_CLIENT_ID=your-client-id
export AZURE_CLIENT_SECRET=your-client-secret

GCP:

export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
export GCP_PROJECT_ID=your-project-id

Option 2: HashiCorp Vault (Recommended for Production)

Store credentials securely in Vault:

# Enable KV secrets engine
vault secrets enable -path=ssm kv-v2

# Store AWS credentials
vault kv put ssm/cloud/aws \
  access_key_id=your-access-key \
  secret_access_key=your-secret-key

# Store Azure credentials
vault kv put ssm/cloud/azure \
  subscription_id=your-subscription-id \
  tenant_id=your-tenant-id \
  client_id=your-client-id \
  client_secret=your-client-secret

# Store GCP credentials
vault kv put ssm/cloud/gcp \
  project_id=your-project-id \
  credentials=@service-account.json

Terraform State

For production, configure remote state storage:

AWS S3:

terraform {
  backend "s3" {
    bucket         = "your-terraform-state-bucket"
    key            = "ssm/terraform.tfstate"
    region         = "us-east-1"
    dynamodb_table = "terraform-locks"
    encrypt        = true
  }
}

---

🔧 Development

Project Structure

cloud_provider/
├── app/                        # FastAPI application
│   ├── api/v1/endpoints/       # API endpoints
│   │   ├── auth.py             # Authentication
│   │   ├── infrastructure.py   # Infrastructure CRUD
│   │   ├── tasks.py            # Task status
│   │   ├── catalog.py          # Templates & costs
│   │   └── websocket.py        # Real-time updates
│   ├── core/                   # Core utilities
│   │   ├── config.py           # Configuration
│   │   ├── logging.py          # Structured logging
│   │   └── dependencies.py     # Dependency injection
│   ├── models/                 # Data models
│   │   ├── requests.py         # Request schemas
│   │   ├── responses.py        # Response schemas
│   │   └── database.py         # ORM models
│   ├── providers/              # Cloud providers
│   │   ├── base.py             # Abstract interface
│   │   ├── aws_provider.py     # AWS implementation
│   │   ├── azure_provider.py   # Azure implementation
│   │   ├── gcp_provider.py     # GCP implementation
│   │   └── factory.py          # Provider factory
│   ├── services/               # Business logic
│   │   ├── auth.py             # Authentication service
│   │   ├── catalog/            # Service catalog
│   │   ├── gitops.py           # ArgoCD integration
│   │   └── observability.py    # Metrics & tracing
│   └── tasks/                  # Celery tasks
│       ├── celery_app.py       # Celery configuration
│       ├── infrastructure.py   # Provisioning tasks
│       └── notifications.py    # Alert tasks
├── frontend/                   # React web UI
├── terraform/                  # IaC modules
│   ├── modules/aws/            # AWS resources
│   ├── modules/azure/          # Azure resources
│   └── modules/gcp/            # GCP resources
├── cli/                        # Command-line tool
├── observability/              # Monitoring configs
├── docker-compose.yml          # Full stack
├── docker-compose.minimal.yml  # Minimal setup
└── Makefile                    # Quick commands

Running Tests

# Run all tests
pytest

# Run with coverage
pytest --cov=app --cov-report=html

# Run specific test file
pytest tests/test_infrastructure.py -v

Code Quality

# Format code
black app/
isort app/

# Type checking
mypy app/

# Linting
flake8 app/

Adding a New Cloud Provider

1. Create provider class in app/providers/:

# app/providers/digitalocean_provider.py
from app.providers.base import CloudProviderInterface

class DigitalOceanProvider(CloudProviderInterface):
    def create_cluster(self, config: ClusterConfig) -> ClusterOutput:
        # Implementation
        pass
    
    def delete_cluster(self, cluster_id: str) -> bool:
        # Implementation
        pass

2. Register in factory:

# app/providers/factory.py
from app.providers.digitalocean_provider import DigitalOceanProvider

class ProviderRegistry:
    _providers = {
        CloudProvider.AWS: AWSProvider,
        CloudProvider.AZURE: AzureProvider,
        CloudProvider.GCP: GCPProvider,
        CloudProvider.DIGITALOCEAN: DigitalOceanProvider,  # Add here
    }

3. Add Terraform module in terraform/modules/digitalocean/

---

🚢 Deployment

Docker Compose (Development/Small Teams)

# Full stack with observability
docker-compose up -d

# Minimal stack
docker-compose -f docker-compose.minimal.yml up -d

Kubernetes (Production)

Helm chart coming soon. For now, use the provided manifests:

kubectl apply -f k8s/

Required Cloud Permissions

AWS IAM Policy:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "eks:*",
        "ec2:*",
        "rds:*",
        "iam:CreateRole",
        "iam:AttachRolePolicy",
        "iam:PassRole"
      ],
      "Resource": "*"
    }
  ]
}

Azure RBAC:

• Contributor role on the subscription
• Or custom role with AKS, VNet, and PostgreSQL permissions

GCP IAM:

• Kubernetes Engine Admin
• Compute Network Admin
• Cloud SQL Admin

---

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

How to Contribute

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

Areas for Contribution

• 🌐 Additional cloud providers (DigitalOcean, Oracle Cloud, etc.)
• 🎨 UI/UX improvements
• 📚 Documentation
• 🧪 Test coverage
• 🔧 Bug fixes
• 🌍 Internationalization

---

📋 Roadmap

• Multi-cloud support (AWS, Azure, GCP)
• Async task processing
• Cost estimation
• Web UI
• CLI tool
• Helm chart for Kubernetes deployment
• GitOps integration (ArgoCD)
• Backstage plugin
• Slack/Teams notifications
• Custom Terraform module support
• Multi-region deployments
• Disaster recovery automation

---

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

---

🙏 Acknowledgments

• Built with FastAPI
• Task queue powered by Celery
• Infrastructure as Code with Terraform
• UI built with React

---

📞 Support

• Documentation: docs/
• Issues: GitHub Issues
• Discussions: GitHub Discussions

---

Made with ❤️ by Tapan Hegde