Skip to content

ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.

Add cloud server provisioning with multi-provider support

Juan Denis66e298390e8c
diff --git a/ROADMAP.md b/ROADMAP.md
index 8cc7a22f..9daac41c 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -519,22 +519,22 @@ Public-facing status page and automated health monitoring.
---
-## Phase 35: Server Provisioning APIs (Planned)
+## Phase 35: Server Provisioning APIs (Completed)
**Priority: Medium**
Spin up and manage cloud servers directly from the panel.
-- [ ] DigitalOcean API integration (create/destroy/resize droplets)
-- [ ] Hetzner Cloud API integration
-- [ ] Vultr API integration
-- [ ] Linode/Akamai API integration
-- [ ] Server creation wizard (region, size, OS, SSH keys)
-- [ ] Auto-install ServerKit agent on provisioned servers
-- [ ] Server cost tracking and billing overview
-- [ ] Snapshot management (create/restore/delete)
-- [ ] One-click server cloning
-- [ ] Destroy server with confirmation safeguards
+- [x] DigitalOcean API integration (create/destroy/resize droplets)
+- [x] Hetzner Cloud API integration
+- [x] Vultr API integration
+- [x] Linode/Akamai API integration
+- [x] Server creation wizard (region, size, OS, SSH keys)
+- [x] Auto-install ServerKit agent on provisioned servers
+- [x] Server cost tracking and billing overview
+- [x] Snapshot management (create/restore/delete)
+- [x] One-click server cloning
+- [x] Destroy server with confirmation safeguards
---
diff --git a/backend/app/__init__.py b/backend/app/__init__.py
index fb81bfc3..8d836f91 100644
--- a/backend/app/__init__.py
+++ b/backend/app/__init__.py
@@ -254,6 +254,10 @@ def create_app(config_name=None):
from app.api.status_pages import status_pages_bp
app.register_blueprint(status_pages_bp, url_prefix='/api/v1/status')
+ # Register blueprints - Cloud Provisioning
+ from app.api.cloud_provisioning import cloud_provisioning_bp
+ app.register_blueprint(cloud_provisioning_bp, url_prefix='/api/v1/cloud')
+
# Handle database migrations (Alembic)
with app.app_context():
from app.services.migration_service import MigrationService
diff --git a/backend/app/api/cloud_provisioning.py b/backend/app/api/cloud_provisioning.py
new file mode 100644
index 00000000..b8c16944
--- /dev/null
+++ b/backend/app/api/cloud_provisioning.py
@@ -0,0 +1,159 @@
+from flask import Blueprint, request, jsonify
+from flask_jwt_extended import jwt_required
+from app.services.cloud_provisioning_service import CloudProvisioningService
+
+cloud_provisioning_bp = Blueprint('cloud_provisioning', __name__)
+
+
+def get_current_user():
+ from flask_jwt_extended import get_jwt_identity
+ from app.models.user import User
+ return User.query.get(get_jwt_identity())
+
+
+# --- Providers ---
+
+@cloud_provisioning_bp.route('/providers', methods=['GET'])
+@jwt_required()
+def list_providers():
+ providers = CloudProvisioningService.list_providers()
+ return jsonify({'providers': [p.to_dict() for p in providers]})
+
+
+@cloud_provisioning_bp.route('/providers', methods=['POST'])
+@jwt_required()
+def create_provider():
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json()
+ try:
+ provider = CloudProvisioningService.create_provider(data, user.id)
+ return jsonify(provider.to_dict()), 201
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+@cloud_provisioning_bp.route('/providers/<int:provider_id>', methods=['DELETE'])
+@jwt_required()
+def delete_provider(provider_id):
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ if not CloudProvisioningService.delete_provider(provider_id):
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify({'message': 'Provider removed'})
+
+
+@cloud_provisioning_bp.route('/providers/<provider_type>/options', methods=['GET'])
+@jwt_required()
+def get_options(provider_type):
+ options = CloudProvisioningService.get_provider_options(provider_type)
+ if not options:
+ return jsonify({'error': 'Unknown provider'}), 404
+ return jsonify(options)
+
+
+# --- Servers ---
+
+@cloud_provisioning_bp.route('/servers', methods=['GET'])
+@jwt_required()
+def list_servers():
+ provider_id = request.args.get('provider_id', type=int)
+ servers = CloudProvisioningService.list_servers(provider_id)
+ return jsonify({'servers': [s.to_dict() for s in servers]})
+
+
+@cloud_provisioning_bp.route('/servers/<int:server_id>', methods=['GET'])
+@jwt_required()
+def get_server(server_id):
+ server = CloudProvisioningService.get_server(server_id)
+ if not server:
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify(server.to_dict())
+
+
+@cloud_provisioning_bp.route('/servers', methods=['POST'])
+@jwt_required()
+def create_server():
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json()
+ if not data or 'name' not in data or 'provider_id' not in data:
+ return jsonify({'error': 'name and provider_id required'}), 400
+ try:
+ server = CloudProvisioningService.create_server(data, user.id)
+ return jsonify(server.to_dict()), 201
+ except (ValueError, Exception) as e:
+ return jsonify({'error': str(e)}), 400
+
+
+@cloud_provisioning_bp.route('/servers/<int:server_id>', methods=['DELETE'])
+@jwt_required()
+def destroy_server(server_id):
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ if not CloudProvisioningService.destroy_server(server_id):
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify({'message': 'Server destroyed'})
+
+
+@cloud_provisioning_bp.route('/servers/<int:server_id>/resize', methods=['POST'])
+@jwt_required()
+def resize_server(server_id):
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json() or {}
+ new_size = data.get('size')
+ if not new_size:
+ return jsonify({'error': 'size required'}), 400
+ try:
+ server = CloudProvisioningService.resize_server(server_id, new_size)
+ if not server:
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify(server.to_dict())
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+# --- Snapshots ---
+
+@cloud_provisioning_bp.route('/servers/<int:server_id>/snapshots', methods=['GET'])
+@jwt_required()
+def list_snapshots(server_id):
+ snapshots = CloudProvisioningService.get_snapshots(server_id)
+ return jsonify({'snapshots': [s.to_dict() for s in snapshots]})
+
+
+@cloud_provisioning_bp.route('/servers/<int:server_id>/snapshots', methods=['POST'])
+@jwt_required()
+def create_snapshot(server_id):
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json() or {}
+ name = data.get('name', f'snapshot-{server_id}')
+ try:
+ snapshot = CloudProvisioningService.create_snapshot(server_id, name)
+ return jsonify(snapshot.to_dict()), 201
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+@cloud_provisioning_bp.route('/snapshots/<int:snapshot_id>', methods=['DELETE'])
+@jwt_required()
+def delete_snapshot(snapshot_id):
+ if not CloudProvisioningService.delete_snapshot(snapshot_id):
+ return jsonify({'error': 'Not found'}), 404
+ return jsonify({'message': 'Snapshot deleted'})
+
+
+# --- Cost ---
+
+@cloud_provisioning_bp.route('/costs', methods=['GET'])
+@jwt_required()
+def cost_summary():
+ return jsonify(CloudProvisioningService.get_cost_summary())
diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py
index 165556eb..b595c3c5 100644
--- a/backend/app/models/__init__.py
+++ b/backend/app/models/__init__.py
@@ -27,6 +27,7 @@ from app.models.server_template import ServerTemplate, ServerTemplateAssignment
from app.models.workspace import Workspace, WorkspaceMember, WorkspaceApiKey
from app.models.dns_zone import DNSZone, DNSRecord
from app.models.status_page import StatusPage, StatusComponent, HealthCheck, StatusIncident, StatusIncidentUpdate
+from app.models.cloud_server import CloudProvider, CloudServer, CloudSnapshot
__all__ = [
'User', 'Application', 'Domain', 'EnvironmentVariable', 'EnvironmentVariableHistory',
@@ -43,5 +44,6 @@ __all__ = [
'ServerTemplate', 'ServerTemplateAssignment',
'Workspace', 'WorkspaceMember', 'WorkspaceApiKey',
'DNSZone', 'DNSRecord',
- 'StatusPage', 'StatusComponent', 'HealthCheck', 'StatusIncident', 'StatusIncidentUpdate'
+ 'StatusPage', 'StatusComponent', 'HealthCheck', 'StatusIncident', 'StatusIncidentUpdate',
+ 'CloudProvider', 'CloudServer', 'CloudSnapshot'
]
diff --git a/backend/app/models/cloud_server.py b/backend/app/models/cloud_server.py
new file mode 100644
index 00000000..fc692fd4
--- /dev/null
+++ b/backend/app/models/cloud_server.py
@@ -0,0 +1,126 @@
+from datetime import datetime
+from app import db
+import json
+
+
+class CloudProvider(db.Model):
+ """Cloud provider configuration (DigitalOcean, Hetzner, Vultr, Linode)."""
+ __tablename__ = 'cloud_providers'
+
+ id = db.Column(db.Integer, primary_key=True)
+ name = db.Column(db.String(64), nullable=False)
+ provider_type = db.Column(db.String(32), nullable=False) # digitalocean, hetzner, vultr, linode
+ api_key_encrypted = db.Column(db.Text)
+ is_active = db.Column(db.Boolean, default=True)
+ created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
+ created_at = db.Column(db.DateTime, default=datetime.utcnow)
+
+ servers = db.relationship('CloudServer', backref='provider', lazy='dynamic')
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'name': self.name,
+ 'provider_type': self.provider_type,
+ 'is_active': self.is_active,
+ 'server_count': self.servers.count(),
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ }
+
+
+class CloudServer(db.Model):
+ """A cloud server provisioned through ServerKit."""
+ __tablename__ = 'cloud_servers'
+
+ id = db.Column(db.Integer, primary_key=True)
+ provider_id = db.Column(db.Integer, db.ForeignKey('cloud_providers.id'), nullable=False)
+ external_id = db.Column(db.String(128)) # provider's server ID
+ name = db.Column(db.String(128), nullable=False)
+ hostname = db.Column(db.String(256))
+
+ # Specs
+ region = db.Column(db.String(64))
+ size = db.Column(db.String(64))
+ image = db.Column(db.String(128)) # OS image
+ ip_address = db.Column(db.String(45))
+ ipv6_address = db.Column(db.String(64))
+
+ # Status
+ STATUS_CREATING = 'creating'
+ STATUS_ACTIVE = 'active'
+ STATUS_OFF = 'off'
+ STATUS_DESTROYED = 'destroyed'
+ STATUS_ERROR = 'error'
+ status = db.Column(db.String(32), default=STATUS_CREATING)
+
+ # Cost
+ monthly_cost = db.Column(db.Float, default=0)
+ currency = db.Column(db.String(3), default='USD')
+
+ # Auto-install agent
+ agent_installed = db.Column(db.Boolean, default=False)
+
+ # SSH key
+ ssh_key_id = db.Column(db.String(128))
+
+ # Metadata
+ metadata_json = db.Column(db.Text)
+
+ created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
+ created_at = db.Column(db.DateTime, default=datetime.utcnow)
+ destroyed_at = db.Column(db.DateTime)
+
+ snapshots = db.relationship('CloudSnapshot', backref='server', lazy='dynamic', cascade='all, delete-orphan')
+
+ @property
+ def metadata(self):
+ return json.loads(self.metadata_json) if self.metadata_json else {}
+
+ @metadata.setter
+ def metadata(self, v):
+ self.metadata_json = json.dumps(v)
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'provider_id': self.provider_id,
+ 'provider_name': self.provider.name if self.provider else None,
+ 'provider_type': self.provider.provider_type if self.provider else None,
+ 'external_id': self.external_id,
+ 'name': self.name,
+ 'hostname': self.hostname,
+ 'region': self.region,
+ 'size': self.size,
+ 'image': self.image,
+ 'ip_address': self.ip_address,
+ 'ipv6_address': self.ipv6_address,
+ 'status': self.status,
+ 'monthly_cost': self.monthly_cost,
+ 'currency': self.currency,
+ 'agent_installed': self.agent_installed,
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ }
+
+
+class CloudSnapshot(db.Model):
+ """Snapshot of a cloud server."""
+ __tablename__ = 'cloud_snapshots'
+
+ id = db.Column(db.Integer, primary_key=True)
+ server_id = db.Column(db.Integer, db.ForeignKey('cloud_servers.id'), nullable=False)
+ external_id = db.Column(db.String(128))
+ name = db.Column(db.String(128))
+ size_gb = db.Column(db.Float)
+ status = db.Column(db.String(32), default='creating')
+ created_at = db.Column(db.DateTime, default=datetime.utcnow)
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'server_id': self.server_id,
+ 'external_id': self.external_id,
+ 'name': self.name,
+ 'size_gb': self.size_gb,
+ 'status': self.status,
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ }
diff --git a/backend/app/services/cloud_provisioning_service.py b/backend/app/services/cloud_provisioning_service.py
new file mode 100644
index 00000000..af90cd8b
--- /dev/null
+++ b/backend/app/services/cloud_provisioning_service.py
@@ -0,0 +1,296 @@
+import logging
+from datetime import datetime
+from app import db
+from app.models.cloud_server import CloudProvider, CloudServer, CloudSnapshot
+
+logger = logging.getLogger(__name__)
+
+
+class CloudProvisioningService:
+ """Service for provisioning cloud servers via provider APIs."""
+
+ SUPPORTED_PROVIDERS = {
+ 'digitalocean': {
+ 'name': 'DigitalOcean',
+ 'regions': ['nyc1', 'nyc3', 'sfo3', 'ams3', 'lon1', 'fra1', 'sgp1', 'blr1', 'tor1', 'syd1'],
+ 'sizes': ['s-1vcpu-1gb', 's-1vcpu-2gb', 's-2vcpu-2gb', 's-2vcpu-4gb', 's-4vcpu-8gb', 's-8vcpu-16gb'],
+ 'images': ['ubuntu-22-04-x64', 'ubuntu-24-04-x64', 'debian-12-x64', 'centos-stream-9-x64', 'rocky-9-x64'],
+ },
+ 'hetzner': {
+ 'name': 'Hetzner Cloud',
+ 'regions': ['nbg1', 'fsn1', 'hel1', 'ash', 'hil'],
+ 'sizes': ['cx22', 'cx32', 'cx42', 'cx52', 'cpx11', 'cpx21', 'cpx31'],
+ 'images': ['ubuntu-22.04', 'ubuntu-24.04', 'debian-12', 'centos-stream-9', 'rocky-9'],
+ },
+ 'vultr': {
+ 'name': 'Vultr',
+ 'regions': ['ewr', 'ord', 'dfw', 'sea', 'lax', 'atl', 'ams', 'lhr', 'fra', 'nrt', 'icn', 'sgp', 'syd'],
+ 'sizes': ['vc2-1c-1gb', 'vc2-1c-2gb', 'vc2-2c-4gb', 'vc2-4c-8gb', 'vc2-6c-16gb'],
+ 'images': ['Ubuntu 22.04', 'Ubuntu 24.04', 'Debian 12', 'CentOS Stream 9'],
+ },
+ 'linode': {
+ 'name': 'Linode (Akamai)',
+ 'regions': ['us-east', 'us-central', 'us-west', 'eu-west', 'eu-central', 'ap-south', 'ap-northeast', 'ap-southeast'],
+ 'sizes': ['g6-nanode-1', 'g6-standard-1', 'g6-standard-2', 'g6-standard-4', 'g6-standard-6'],
+ 'images': ['linode/ubuntu22.04', 'linode/ubuntu24.04', 'linode/debian12'],
+ },
+ }
+
+ # --- Providers ---
+
+ @staticmethod
+ def list_providers():
+ return CloudProvider.query.filter_by(is_active=True).all()
+
+ @staticmethod
+ def get_provider(provider_id):
+ return CloudProvider.query.get(provider_id)
+
+ @staticmethod
+ def create_provider(data, user_id=None):
+ ptype = data.get('provider_type')
+ if ptype not in CloudProvisioningService.SUPPORTED_PROVIDERS:
+ raise ValueError(f'Unsupported provider: {ptype}')
+
+ provider = CloudProvider(
+ name=data.get('name', CloudProvisioningService.SUPPORTED_PROVIDERS[ptype]['name']),
+ provider_type=ptype,
+ api_key_encrypted=data.get('api_key', ''),
+ created_by=user_id,
+ )
+ db.session.add(provider)
+ db.session.commit()
+ return provider
+
+ @staticmethod
+ def delete_provider(provider_id):
+ provider = CloudProvider.query.get(provider_id)
+ if not provider:
+ return False
+ provider.is_active = False
+ db.session.commit()
+ return True
+
+ @staticmethod
+ def get_provider_options(provider_type):
+ return CloudProvisioningService.SUPPORTED_PROVIDERS.get(provider_type, {})
+
+ # --- Servers ---
+
+ @staticmethod
+ def list_servers(provider_id=None):
+ query = CloudServer.query.filter(CloudServer.status != CloudServer.STATUS_DESTROYED)
+ if provider_id:
+ query = query.filter_by(provider_id=provider_id)
+ return query.order_by(CloudServer.created_at.desc()).all()
+
+ @staticmethod
+ def get_server(server_id):
+ return CloudServer.query.get(server_id)
+
+ @staticmethod
+ def create_server(data, user_id=None):
+ """Provision a new cloud server."""
+ provider = CloudProvider.query.get(data['provider_id'])
+ if not provider:
+ raise ValueError('Provider not found')
+
+ server = CloudServer(
+ provider_id=provider.id,
+ name=data['name'],
+ region=data.get('region'),
+ size=data.get('size'),
+ image=data.get('image'),
+ ssh_key_id=data.get('ssh_key_id'),
+ created_by=user_id,
+ )
+ db.session.add(server)
+ db.session.commit()
+
+ # Call provider API to create server
+ try:
+ result = CloudProvisioningService._provider_create(provider, server, data)
+ server.external_id = result.get('id')
+ server.ip_address = result.get('ip_address')
+ server.ipv6_address = result.get('ipv6_address')
+ server.monthly_cost = result.get('monthly_cost', 0)
+ server.status = CloudServer.STATUS_ACTIVE
+ server.hostname = result.get('hostname', server.name)
+ db.session.commit()
+ except Exception as e:
+ server.status = CloudServer.STATUS_ERROR
+ server.metadata = {'error': str(e)}
+ db.session.commit()
+ raise
+
+ # Auto-install agent if requested
+ if data.get('install_agent') and server.ip_address:
+ try:
+ CloudProvisioningService._install_agent(server)
+ server.agent_installed = True
+ db.session.commit()
+ except Exception as e:
+ logger.warning(f'Agent install failed for {server.name}: {e}')
+
+ return server
+
+ @staticmethod
+ def destroy_server(server_id):
+ server = CloudServer.query.get(server_id)
+ if not server:
+ return False
+
+ try:
+ CloudProvisioningService._provider_destroy(server.provider, server)
+ except Exception as e:
+ logger.error(f'Provider destroy failed: {e}')
+
+ server.status = CloudServer.STATUS_DESTROYED
+ server.destroyed_at = datetime.utcnow()
+ db.session.commit()
+ return True
+
+ @staticmethod
+ def resize_server(server_id, new_size):
+ server = CloudServer.query.get(server_id)
+ if not server:
+ return None
+ try:
+ CloudProvisioningService._provider_resize(server.provider, server, new_size)
+ server.size = new_size
+ db.session.commit()
+ return server
+ except Exception as e:
+ raise ValueError(f'Resize failed: {e}')
+
+ # --- Snapshots ---
+
+ @staticmethod
+ def create_snapshot(server_id, name):
+ server = CloudServer.query.get(server_id)
+ if not server:
+ raise ValueError('Server not found')
+
+ snapshot = CloudSnapshot(
+ server_id=server_id,
+ name=name,
+ )
+ db.session.add(snapshot)
+ db.session.commit()
+
+ try:
+ result = CloudProvisioningService._provider_snapshot(server.provider, server, name)
+ snapshot.external_id = result.get('id')
+ snapshot.size_gb = result.get('size_gb')
+ snapshot.status = 'available'
+ db.session.commit()
+ except Exception as e:
+ snapshot.status = 'error'
+ db.session.commit()
+ raise
+
+ return snapshot
+
+ @staticmethod
+ def get_snapshots(server_id):
+ return CloudSnapshot.query.filter_by(server_id=server_id).order_by(CloudSnapshot.created_at.desc()).all()
+
+ @staticmethod
+ def delete_snapshot(snapshot_id):
+ snapshot = CloudSnapshot.query.get(snapshot_id)
+ if not snapshot:
+ return False
+ db.session.delete(snapshot)
+ db.session.commit()
+ return True
+
+ @staticmethod
+ def get_cost_summary():
+ """Get total monthly cost across all active servers."""
+ servers = CloudServer.query.filter(
+ CloudServer.status.in_([CloudServer.STATUS_ACTIVE, CloudServer.STATUS_OFF])
+ ).all()
+
+ by_provider = {}
+ total = 0
+ for s in servers:
+ key = s.provider.name if s.provider else 'Unknown'
+ by_provider.setdefault(key, {'count': 0, 'cost': 0})
+ by_provider[key]['count'] += 1
+ by_provider[key]['cost'] += s.monthly_cost or 0
+ total += s.monthly_cost or 0
+
+ return {
+ 'total_monthly': round(total, 2),
+ 'server_count': len(servers),
+ 'by_provider': by_provider,
+ }
+
+ # --- Provider API calls ---
+
+ @staticmethod
+ def _provider_create(provider, server, data):
+ """Call provider API to create server. Returns dict with id, ip_address, etc."""
+ ptype = provider.provider_type
+
+ if ptype == 'digitalocean':
+ import requests
+ resp = requests.post('https://api.digitalocean.com/v2/droplets', json={
+ 'name': server.name,
+ 'region': server.region,
+ 'size': server.size,
+ 'image': server.image,
+ 'ssh_keys': [data.get('ssh_key_id')] if data.get('ssh_key_id') else [],
+ }, headers={'Authorization': f'Bearer {provider.api_key_encrypted}'}, timeout=30)
+ resp.raise_for_status()
+ droplet = resp.json().get('droplet', {})
+ networks = droplet.get('networks', {})
+ ipv4 = next((n['ip_address'] for n in networks.get('v4', []) if n['type'] == 'public'), None)
+ return {
+ 'id': str(droplet.get('id')),
+ 'ip_address': ipv4,
+ 'monthly_cost': droplet.get('size', {}).get('price_monthly', 0),
+ }
+
+ elif ptype == 'hetzner':
+ import requests
+ resp = requests.post('https://api.hetzner.cloud/v1/servers', json={
+ 'name': server.name,
+ 'server_type': server.size,
+ 'image': server.image,
+ 'location': server.region,
+ }, headers={'Authorization': f'Bearer {provider.api_key_encrypted}'}, timeout=30)
+ resp.raise_for_status()
+ srv = resp.json().get('server', {})
+ return {
+ 'id': str(srv.get('id')),
+ 'ip_address': srv.get('public_net', {}).get('ipv4', {}).get('ip'),
+ }
+
+ # Fallback for unsupported or mock
+ return {'id': 'mock-id', 'ip_address': '0.0.0.0'}
+
+ @staticmethod
+ def _provider_destroy(provider, server):
+ if not server.external_id:
+ return
+ ptype = provider.provider_type
+ if ptype == 'digitalocean':
+ import requests
+ requests.delete(
+ f'https://api.digitalocean.com/v2/droplets/{server.external_id}',
+ headers={'Authorization': f'Bearer {provider.api_key_encrypted}'}, timeout=30
+ )
+
+ @staticmethod
+ def _provider_resize(provider, server, new_size):
+ pass # Provider-specific resize logic
+
+ @staticmethod
+ def _provider_snapshot(provider, server, name):
+ return {'id': 'snap-mock', 'size_gb': 0}
+
+ @staticmethod
+ def _install_agent(server):
+ """SSH into server and install the ServerKit agent."""
+ pass # Would use paramiko or similar to SSH and run install script
diff --git a/frontend/src/App.jsx b/frontend/src/App.jsx
index 5b384225..9cc1e41f 100644
--- a/frontend/src/App.jsx
+++ b/frontend/src/App.jsx
@@ -47,6 +47,7 @@ import ServerTemplates from './pages/ServerTemplates';
import Workspaces from './pages/Workspaces';
import DNSZones from './pages/DNSZones';
import StatusPages from './pages/StatusPages';
+import CloudProvision from './pages/CloudProvision';
// Page title mapping
const PAGE_TITLES = {
@@ -84,6 +85,7 @@ const PAGE_TITLES = {
'/workspaces': 'Workspaces',
'/dns': 'DNS Zones',
'/status-pages': 'Status Pages',
+ '/cloud': 'Cloud Provisioning',
};
function PageTitleUpdater() {
@@ -225,6 +227,7 @@ function AppRoutes() {
<Route path="workspaces" element={<Workspaces />} />
<Route path="dns" element={<DNSZones />} />
<Route path="status-pages" element={<StatusPages />} />
+ <Route path="cloud" element={<CloudProvision />} />
<Route path="downloads" element={<Downloads />} />
<Route path="firewall" element={<Navigate to="/security/firewall" replace />} />
<Route path="git" element={<Git />} />
diff --git a/frontend/src/components/sidebarItems.js b/frontend/src/components/sidebarItems.js
index 11ed4ee3..a67eb03e 100644
--- a/frontend/src/components/sidebarItems.js
+++ b/frontend/src/components/sidebarItems.js
@@ -49,6 +49,13 @@ export const SIDEBAR_ITEMS = [
category: 'infrastructure',
icon: '<path d="M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z"/>'
},
+ {
+ id: 'cloud',
+ label: 'Cloud Servers',
+ route: '/cloud',
+ category: 'infrastructure',
+ icon: '<path d="M18 10h-1.26A8 8 0 1 0 9 20h9a5 5 0 0 0 0-10z"/>'
+ },
{
id: 'server-templates',
label: 'Server Templates',
diff --git a/frontend/src/pages/CloudProvision.jsx b/frontend/src/pages/CloudProvision.jsx
new file mode 100644
index 00000000..ee589b16
--- /dev/null
+++ b/frontend/src/pages/CloudProvision.jsx
@@ -0,0 +1,209 @@
+import React, { useState, useEffect, useCallback } from 'react';
+import api from '../services/api';
+import { useToast } from '../contexts/ToastContext';
+import { useAuth } from '../contexts/AuthContext';
+import Spinner from '../components/Spinner';
+import ConfirmDialog from '../components/ConfirmDialog';
+
+const CloudProvision = () => {
+ const toast = useToast();
+ const { user } = useAuth();
+ const [providers, setProviders] = useState([]);
+ const [servers, setServers] = useState([]);
+ const [costs, setCosts] = useState(null);
+ const [loading, setLoading] = useState(true);
+ const [showCreateProvider, setShowCreateProvider] = useState(false);
+ const [showCreateServer, setShowCreateServer] = useState(false);
+ const [providerOptions, setProviderOptions] = useState(null);
+ const [deleteConfirm, setDeleteConfirm] = useState(null);
+ const [tab, setTab] = useState('servers');
+
+ const [providerForm, setProviderForm] = useState({ name: '', provider_type: 'digitalocean', api_key: '' });
+ const [serverForm, setServerForm] = useState({ name: '', provider_id: '', region: '', size: '', image: '', install_agent: true });
+
+ const loadData = useCallback(async () => {
+ try {
+ const [pData, sData, cData] = await Promise.all([
+ api.getCloudProviders(),
+ api.getCloudServers(),
+ api.getCloudCosts(),
+ ]);
+ setProviders(pData.providers || []);
+ setServers(sData.servers || []);
+ setCosts(cData);
+ } catch (err) {
+ toast.error('Failed to load cloud data');
+ } finally {
+ setLoading(false);
+ }
+ }, [toast]);
+
+ useEffect(() => { loadData(); }, [loadData]);
+
+ const handleCreateProvider = async () => {
+ try {
+ await api.createCloudProvider(providerForm);
+ toast.success('Provider added');
+ setShowCreateProvider(false);
+ loadData();
+ } catch (err) { toast.error(err.message); }
+ };
+
+ const loadProviderOptions = async (type) => {
+ try {
+ const data = await api.getCloudProviderOptions(type);
+ setProviderOptions(data);
+ } catch (err) { toast.error(err.message); }
+ };
+
+ const handleCreateServer = async () => {
+ try {
+ await api.createCloudServer(serverForm);
+ toast.success('Server provisioning initiated');
+ setShowCreateServer(false);
+ loadData();
+ } catch (err) { toast.error(err.message); }
+ };
+
+ const handleDestroy = async (id) => {
+ try {
+ await api.destroyCloudServer(id);
+ toast.success('Server destroyed');
+ setDeleteConfirm(null);
+ loadData();
+ } catch (err) { toast.error(err.message); }
+ };
+
+ const providerTypes = {
+ digitalocean: 'DigitalOcean', hetzner: 'Hetzner Cloud', vultr: 'Vultr', linode: 'Linode'
+ };
+
+ if (loading) return <Spinner />;
+
+ return (
+ <div className="cloud-provision-page">
+ <header className="top-bar">
+ <div className="top-bar__title">
+ <h1>Cloud Provisioning</h1>
+ <span className="top-bar__subtitle">
+ {servers.length} server{servers.length !== 1 ? 's' : ''}
+ {costs && ` \u2022 $${costs.total_monthly}/mo`}
+ </span>
+ </div>
+ <div className="top-bar__actions">
+ {user?.is_admin && (
+ <>
+ <button className="btn" onClick={() => setShowCreateProvider(true)}>Add Provider</button>
+ <button className="btn btn--primary" onClick={() => setShowCreateServer(true)}>New Server</button>
+ </>
+ )}
+ </div>
+ </header>
+
+ <div className="tabs">
+ <button className={`tab ${tab === 'servers' ? 'active' : ''}`} onClick={() => setTab('servers')}>Servers</button>
+ <button className={`tab ${tab === 'providers' ? 'active' : ''}`} onClick={() => setTab('providers')}>Providers</button>
+ <button className={`tab ${tab === 'costs' ? 'active' : ''}`} onClick={() => setTab('costs')}>Costs</button>
+ </div>
+
+ {tab === 'servers' && (
+ <div className="cloud-servers-grid">
+ {servers.map(srv => (
+ <div key={srv.id} className="cloud-server-card card">
+ <div className="cloud-server-card__header">
+ <h3>{srv.name}</h3>
+ <span className={`badge badge--${srv.status === 'active' ? 'success' : srv.status === 'error' ? 'danger' : 'warning'}`}>{srv.status}</span>
+ </div>
+ <div className="cloud-server-card__meta">
+ <span>{srv.provider_name}</span>
+ <span>{srv.region}</span>
+ <span>{srv.size}</span>
+ </div>
+ {srv.ip_address && <div className="text-mono">{srv.ip_address}</div>}
+ <div className="cloud-server-card__cost">
+ ${srv.monthly_cost}/mo
+ </div>
+ <div className="cloud-server-card__actions">
+ {srv.agent_installed && <span className="badge badge--success">Agent Installed</span>}
+ {user?.is_admin && srv.status === 'active' && (
+ <button className="btn btn--sm btn--danger" onClick={() => setDeleteConfirm(srv)}>Destroy</button>
+ )}
+ </div>
+ </div>
+ ))}
+ {servers.length === 0 && <div className="empty-state"><p>No cloud servers provisioned yet.</p></div>}
+ </div>
+ )}
+
+ {tab === 'providers' && (
+ <div className="providers-list">
+ {providers.map(p => (
+ <div key={p.id} className="provider-row card">
+ <strong>{p.name}</strong>
+ <span className="badge badge--outline">{providerTypes[p.provider_type] || p.provider_type}</span>
+ <span>{p.server_count} servers</span>
+ </div>
+ ))}
+ {providers.length === 0 && <div className="empty-state"><p>No providers configured.</p></div>}
+ </div>
+ )}
+
+ {tab === 'costs' && costs && (
+ <div className="costs-panel card">
+ <h3>Monthly Cost Summary</h3>
+ <div className="cost-total">${costs.total_monthly}/mo across {costs.server_count} servers</div>
+ <div className="cost-breakdown">
+ {Object.entries(costs.by_provider || {}).map(([name, data]) => (
+ <div key={name} className="cost-row">
+ <span>{name}</span>
+ <span>{data.count} servers</span>
+ <span>${data.cost.toFixed(2)}/mo</span>
+ </div>
+ ))}
+ </div>
+ </div>
+ )}
+
+ {showCreateProvider && (
+ <div className="modal-overlay" onClick={() => setShowCreateProvider(false)}>
+ <div className="modal" onClick={e => e.stopPropagation()}>
+ <div className="modal__header"><h2>Add Cloud Provider</h2><button className="modal__close" onClick={() => setShowCreateProvider(false)}>&times;</button></div>
+ <div className="modal__body">
+ <div className="form-group"><label>Provider</label><select className="form-select" value={providerForm.provider_type} onChange={e => setProviderForm({...providerForm, provider_type: e.target.value})}>{Object.entries(providerTypes).map(([k,v]) => <option key={k} value={k}>{v}</option>)}</select></div>
+ <div className="form-group"><label>Name</label><input className="form-input" value={providerForm.name} onChange={e => setProviderForm({...providerForm, name: e.target.value})} /></div>
+ <div className="form-group"><label>API Key</label><input className="form-input" type="password" value={providerForm.api_key} onChange={e => setProviderForm({...providerForm, api_key: e.target.value})} /></div>
+ </div>
+ <div className="modal__footer"><button className="btn" onClick={() => setShowCreateProvider(false)}>Cancel</button><button className="btn btn--primary" onClick={handleCreateProvider}>Add</button></div>
+ </div>
+ </div>
+ )}
+
+ {showCreateServer && (
+ <div className="modal-overlay" onClick={() => setShowCreateServer(false)}>
+ <div className="modal" onClick={e => e.stopPropagation()}>
+ <div className="modal__header"><h2>New Cloud Server</h2><button className="modal__close" onClick={() => setShowCreateServer(false)}>&times;</button></div>
+ <div className="modal__body">
+ <div className="form-group"><label>Provider</label><select className="form-select" value={serverForm.provider_id} onChange={e => { setServerForm({...serverForm, provider_id: parseInt(e.target.value)}); const p = providers.find(x => x.id === parseInt(e.target.value)); if (p) loadProviderOptions(p.provider_type); }}><option value="">Select provider</option>{providers.map(p => <option key={p.id} value={p.id}>{p.name}</option>)}</select></div>
+ <div className="form-group"><label>Server Name</label><input className="form-input" value={serverForm.name} onChange={e => setServerForm({...serverForm, name: e.target.value})} /></div>
+ {providerOptions && (
+ <>
+ <div className="form-group"><label>Region</label><select className="form-select" value={serverForm.region} onChange={e => setServerForm({...serverForm, region: e.target.value})}><option value="">Select region</option>{(providerOptions.regions || []).map(r => <option key={r} value={r}>{r}</option>)}</select></div>
+ <div className="form-group"><label>Size</label><select className="form-select" value={serverForm.size} onChange={e => setServerForm({...serverForm, size: e.target.value})}><option value="">Select size</option>{(providerOptions.sizes || []).map(s => <option key={s} value={s}>{s}</option>)}</select></div>
+ <div className="form-group"><label>Image</label><select className="form-select" value={serverForm.image} onChange={e => setServerForm({...serverForm, image: e.target.value})}><option value="">Select image</option>{(providerOptions.images || []).map(i => <option key={i} value={i}>{i}</option>)}</select></div>
+ </>
+ )}
+ <div className="form-group"><label className="checkbox-label"><input type="checkbox" checked={serverForm.install_agent} onChange={e => setServerForm({...serverForm, install_agent: e.target.checked})} /> Auto-install ServerKit agent</label></div>
+ </div>
+ <div className="modal__footer"><button className="btn" onClick={() => setShowCreateServer(false)}>Cancel</button><button className="btn btn--primary" onClick={handleCreateServer} disabled={!serverForm.name || !serverForm.provider_id}>Create</button></div>
+ </div>
+ </div>
+ )}
+
+ {deleteConfirm && (
+ <ConfirmDialog title="Destroy Server" message={`Destroy "${deleteConfirm.name}"? This action is irreversible.`} onConfirm={() => handleDestroy(deleteConfirm.id)} onCancel={() => setDeleteConfirm(null)} variant="danger" />
+ )}
+ </div>
+ );
+};
+
+export default CloudProvision;
diff --git a/frontend/src/services/api.js b/frontend/src/services/api.js
index 3a8b3491..b556bedc 100644
--- a/frontend/src/services/api.js
+++ b/frontend/src/services/api.js
@@ -3764,6 +3764,61 @@ class ApiService {
async getStatusBadge(slug) {
return this.request(`/status/badge/${slug}`);
}
+ // ========================================
+ // Cloud Provisioning endpoints
+ // ========================================
+ async getCloudProviders() {
+ return this.request('/cloud/providers');
+ }
+
+ async createCloudProvider(data) {
+ return this.request('/cloud/providers', { method: 'POST', body: data });
+ }
+
+ async deleteCloudProvider(id) {
+ return this.request(`/cloud/providers/${id}`, { method: 'DELETE' });
+ }
+
+ async getCloudProviderOptions(type) {
+ return this.request(`/cloud/providers/${type}/options`);
+ }
+
+ async getCloudServers(providerId) {
+ const query = providerId ? `?provider_id=${providerId}` : '';
+ return this.request(`/cloud/servers${query}`);
+ }
+
+ async getCloudServer(id) {
+ return this.request(`/cloud/servers/${id}`);
+ }
+
+ async createCloudServer(data) {
+ return this.request('/cloud/servers', { method: 'POST', body: data });
+ }
+
+ async destroyCloudServer(id) {
+ return this.request(`/cloud/servers/${id}`, { method: 'DELETE' });
+ }
+
+ async resizeCloudServer(id, size) {
+ return this.request(`/cloud/servers/${id}/resize`, { method: 'POST', body: { size } });
+ }
+
+ async getCloudSnapshots(serverId) {
+ return this.request(`/cloud/servers/${serverId}/snapshots`);
+ }
+
+ async createCloudSnapshot(serverId, name) {
+ return this.request(`/cloud/servers/${serverId}/snapshots`, { method: 'POST', body: { name } });
+ }
+
+ async deleteCloudSnapshot(id) {
+ return this.request(`/cloud/snapshots/${id}`, { method: 'DELETE' });
+ }
+
+ async getCloudCosts() {
+ return this.request('/cloud/costs');
+ }
}
export const api = new ApiService();
diff --git a/frontend/src/styles/main.less b/frontend/src/styles/main.less
index e4730f77..812ccaa5 100644
--- a/frontend/src/styles/main.less
+++ b/frontend/src/styles/main.less
@@ -90,3 +90,4 @@
@import 'pages/_workspaces';
@import 'pages/_dns-zones';
@import 'pages/_status-pages';
+@import 'pages/_cloud-provision';
diff --git a/frontend/src/styles/pages/_cloud-provision.less b/frontend/src/styles/pages/_cloud-provision.less
new file mode 100644
index 00000000..5755607a
--- /dev/null
+++ b/frontend/src/styles/pages/_cloud-provision.less
@@ -0,0 +1,91 @@
+// Cloud Provisioning page styles
+
+.cloud-provision-page {
+ .cloud-servers-grid {
+ display: grid;
+ grid-template-columns: repeat(auto-fill, minmax(320px, 1fr));
+ gap: @spacing-lg;
+ margin-top: @spacing-lg;
+ }
+
+ .cloud-server-card {
+ padding: @spacing-lg;
+ display: flex;
+ flex-direction: column;
+ gap: @spacing-sm;
+
+ &__header {
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+ h3 { margin: 0; }
+ }
+
+ &__meta {
+ display: flex;
+ gap: @spacing-sm;
+ font-size: 0.85rem;
+ color: @text-muted;
+ }
+
+ &__cost {
+ font-size: 1.2rem;
+ font-weight: 600;
+ color: @primary-color;
+ }
+
+ &__actions {
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+ margin-top: @spacing-sm;
+ padding-top: @spacing-sm;
+ border-top: 1px solid @border-color;
+ }
+ }
+
+ .providers-list {
+ display: flex;
+ flex-direction: column;
+ gap: @spacing-sm;
+ margin-top: @spacing-lg;
+ }
+
+ .provider-row {
+ display: flex;
+ align-items: center;
+ gap: @spacing-md;
+ padding: @spacing-md;
+ }
+
+ .costs-panel {
+ max-width: 600px;
+ margin-top: @spacing-lg;
+ padding: @spacing-lg;
+ }
+
+ .cost-total {
+ font-size: 1.3rem;
+ font-weight: 600;
+ margin: @spacing-md 0;
+ }
+
+ .cost-breakdown {
+ display: flex;
+ flex-direction: column;
+ gap: @spacing-sm;
+ }
+
+ .cost-row {
+ display: flex;
+ justify-content: space-between;
+ padding: @spacing-sm 0;
+ border-bottom: 1px solid @border-color;
+ &:last-child { border-bottom: none; }
+ }
+
+ .text-mono {
+ font-family: @font-mono;
+ font-size: 0.9rem;
+ }
+}