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 DNS zone management with provider integrations

Juan Denis0fa5bc13960f
diff --git a/ROADMAP.md b/ROADMAP.md
index 0bbb91dc..887ad8d8 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -465,20 +465,20 @@ Isolate servers by team, client, or project. Essential for agencies, MSPs, and l
---
-## Phase 32: DNS Zone Management (Planned)
+## Phase 32: DNS Zone Management (Completed)
**Priority: Medium**
Full DNS record management with provider API integration.
-- [ ] DNS zone editor UI (A, AAAA, CNAME, MX, TXT, SRV, CAA records)
-- [ ] Cloudflare API integration (list/create/update/delete records)
-- [ ] Route53 API integration
-- [ ] DigitalOcean DNS integration
-- [ ] DNS propagation checker (query multiple nameservers)
-- [ ] Auto-generate recommended records for hosted services (SPF, DKIM, DMARC, MX)
-- [ ] DNS template presets (e.g., "standard web hosting", "email hosting")
-- [ ] Bulk record import/export (BIND zone file format)
+- [x] DNS zone editor UI (A, AAAA, CNAME, MX, TXT, SRV, CAA records)
+- [x] Cloudflare API integration (list/create/update/delete records)
+- [x] Route53 API integration
+- [x] DigitalOcean DNS integration
+- [x] DNS propagation checker (query multiple nameservers)
+- [x] Auto-generate recommended records for hosted services (SPF, DKIM, DMARC, MX)
+- [x] DNS template presets (e.g., "standard web hosting", "email hosting")
+- [x] Bulk record import/export (BIND zone file format)
---
diff --git a/backend/app/__init__.py b/backend/app/__init__.py
index 8751db76..7c87295e 100644
--- a/backend/app/__init__.py
+++ b/backend/app/__init__.py
@@ -242,6 +242,10 @@ def create_app(config_name=None):
from app.api.advanced_ssl import advanced_ssl_bp
app.register_blueprint(advanced_ssl_bp, url_prefix='/api/v1/ssl/advanced')
+ # Register blueprints - DNS Zones
+ from app.api.dns_zones import dns_zones_bp
+ app.register_blueprint(dns_zones_bp, url_prefix='/api/v1/dns')
+
# Handle database migrations (Alembic)
with app.app_context():
from app.services.migration_service import MigrationService
diff --git a/backend/app/api/dns_zones.py b/backend/app/api/dns_zones.py
new file mode 100644
index 00000000..f0aa0a83
--- /dev/null
+++ b/backend/app/api/dns_zones.py
@@ -0,0 +1,155 @@
+from flask import Blueprint, request, jsonify
+from flask_jwt_extended import jwt_required
+from app.services.dns_zone_service import DNSZoneService
+
+dns_zones_bp = Blueprint('dns_zones', __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())
+
+
+@dns_zones_bp.route('/', methods=['GET'])
+@jwt_required()
+def list_zones():
+ zones = DNSZoneService.list_zones()
+ return jsonify({'zones': [z.to_dict() for z in zones]})
+
+
+@dns_zones_bp.route('/<int:zone_id>', methods=['GET'])
+@jwt_required()
+def get_zone(zone_id):
+ zone = DNSZoneService.get_zone(zone_id)
+ if not zone:
+ return jsonify({'error': 'Zone not found'}), 404
+ return jsonify(zone.to_dict())
+
+
+@dns_zones_bp.route('/', methods=['POST'])
+@jwt_required()
+def create_zone():
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json()
+ try:
+ zone = DNSZoneService.create_zone(data)
+ return jsonify(zone.to_dict()), 201
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+@dns_zones_bp.route('/<int:zone_id>', methods=['DELETE'])
+@jwt_required()
+def delete_zone(zone_id):
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ if not DNSZoneService.delete_zone(zone_id):
+ return jsonify({'error': 'Zone not found'}), 404
+ return jsonify({'message': 'Zone deleted'})
+
+
+# --- Records ---
+
+@dns_zones_bp.route('/<int:zone_id>/records', methods=['GET'])
+@jwt_required()
+def get_records(zone_id):
+ records = DNSZoneService.get_records(zone_id)
+ return jsonify({'records': [r.to_dict() for r in records]})
+
+
+@dns_zones_bp.route('/<int:zone_id>/records', methods=['POST'])
+@jwt_required()
+def create_record(zone_id):
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json()
+ try:
+ record = DNSZoneService.create_record(zone_id, data)
+ return jsonify(record.to_dict()), 201
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+@dns_zones_bp.route('/records/<int:record_id>', methods=['PUT'])
+@jwt_required()
+def update_record(record_id):
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json()
+ record = DNSZoneService.update_record(record_id, data)
+ if not record:
+ return jsonify({'error': 'Record not found'}), 404
+ return jsonify(record.to_dict())
+
+
+@dns_zones_bp.route('/records/<int:record_id>', methods=['DELETE'])
+@jwt_required()
+def delete_record(record_id):
+ user = get_current_user()
+ if not user or not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ if not DNSZoneService.delete_record(record_id):
+ return jsonify({'error': 'Record not found'}), 404
+ return jsonify({'message': 'Record deleted'})
+
+
+# --- Tools ---
+
+@dns_zones_bp.route('/presets', methods=['GET'])
+@jwt_required()
+def get_presets():
+ return jsonify({'presets': DNSZoneService.get_presets()})
+
+
+@dns_zones_bp.route('/<int:zone_id>/apply-preset', methods=['POST'])
+@jwt_required()
+def apply_preset(zone_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 {}
+ preset_key = data.get('preset')
+ variables = data.get('variables', {})
+ try:
+ records = DNSZoneService.apply_preset(zone_id, preset_key, variables)
+ return jsonify({'records': [r.to_dict() for r in records]})
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+@dns_zones_bp.route('/propagation/<domain>', methods=['GET'])
+@jwt_required()
+def check_propagation(domain):
+ record_type = request.args.get('type', 'A')
+ results = DNSZoneService.check_propagation(domain, record_type)
+ return jsonify({'domain': domain, 'record_type': record_type, 'results': results})
+
+
+@dns_zones_bp.route('/<int:zone_id>/export', methods=['GET'])
+@jwt_required()
+def export_zone(zone_id):
+ content = DNSZoneService.export_zone(zone_id)
+ if content is None:
+ return jsonify({'error': 'Zone not found'}), 404
+ return jsonify({'zone_file': content})
+
+
+@dns_zones_bp.route('/<int:zone_id>/import', methods=['POST'])
+@jwt_required()
+def import_zone(zone_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 {}
+ content = data.get('zone_file', '')
+ try:
+ records = DNSZoneService.import_zone(zone_id, content)
+ return jsonify({'imported': len(records), 'records': [r.to_dict() for r in records]})
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py
index 6d6b65ba..53121f59 100644
--- a/backend/app/models/__init__.py
+++ b/backend/app/models/__init__.py
@@ -25,6 +25,7 @@ from app.models.metric_alert import ServerAlertThreshold, MetricAlert
from app.models.agent_plugin import AgentPlugin, AgentPluginInstall
from app.models.server_template import ServerTemplate, ServerTemplateAssignment
from app.models.workspace import Workspace, WorkspaceMember, WorkspaceApiKey
+from app.models.dns_zone import DNSZone, DNSRecord
__all__ = [
'User', 'Application', 'Domain', 'EnvironmentVariable', 'EnvironmentVariableHistory',
@@ -39,5 +40,6 @@ __all__ = [
'ServerAlertThreshold', 'MetricAlert',
'AgentPlugin', 'AgentPluginInstall',
'ServerTemplate', 'ServerTemplateAssignment',
- 'Workspace', 'WorkspaceMember', 'WorkspaceApiKey'
+ 'Workspace', 'WorkspaceMember', 'WorkspaceApiKey',
+ 'DNSZone', 'DNSRecord'
]
diff --git a/backend/app/models/dns_zone.py b/backend/app/models/dns_zone.py
new file mode 100644
index 00000000..63743190
--- /dev/null
+++ b/backend/app/models/dns_zone.py
@@ -0,0 +1,76 @@
+from datetime import datetime
+from app import db
+import json
+
+
+class DNSZone(db.Model):
+ """DNS zone for a domain with provider integration."""
+ __tablename__ = 'dns_zones'
+
+ id = db.Column(db.Integer, primary_key=True)
+ domain = db.Column(db.String(256), nullable=False, unique=True)
+ provider = db.Column(db.String(64)) # cloudflare, route53, digitalocean, manual
+ provider_zone_id = db.Column(db.String(128))
+ provider_config_json = db.Column(db.Text) # encrypted credentials
+
+ status = db.Column(db.String(32), default='active')
+ last_sync_at = db.Column(db.DateTime)
+
+ created_at = db.Column(db.DateTime, default=datetime.utcnow)
+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+ records = db.relationship('DNSRecord', backref='zone', lazy='dynamic', cascade='all, delete-orphan')
+
+ @property
+ def provider_config(self):
+ return json.loads(self.provider_config_json) if self.provider_config_json else {}
+
+ @provider_config.setter
+ def provider_config(self, v):
+ self.provider_config_json = json.dumps(v)
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'domain': self.domain,
+ 'provider': self.provider,
+ 'provider_zone_id': self.provider_zone_id,
+ 'status': self.status,
+ 'record_count': self.records.count(),
+ 'last_sync_at': self.last_sync_at.isoformat() if self.last_sync_at else None,
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ }
+
+
+class DNSRecord(db.Model):
+ """Individual DNS record within a zone."""
+ __tablename__ = 'dns_records'
+
+ id = db.Column(db.Integer, primary_key=True)
+ zone_id = db.Column(db.Integer, db.ForeignKey('dns_zones.id'), nullable=False)
+
+ record_type = db.Column(db.String(10), nullable=False) # A, AAAA, CNAME, MX, TXT, SRV, CAA
+ name = db.Column(db.String(256), nullable=False)
+ content = db.Column(db.Text, nullable=False)
+ ttl = db.Column(db.Integer, default=3600)
+ priority = db.Column(db.Integer) # MX, SRV
+ proxied = db.Column(db.Boolean, default=False) # Cloudflare proxy
+
+ provider_record_id = db.Column(db.String(128))
+
+ created_at = db.Column(db.DateTime, default=datetime.utcnow)
+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'zone_id': self.zone_id,
+ 'record_type': self.record_type,
+ 'name': self.name,
+ 'content': self.content,
+ 'ttl': self.ttl,
+ 'priority': self.priority,
+ 'proxied': self.proxied,
+ 'provider_record_id': self.provider_record_id,
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ }
diff --git a/backend/app/services/dns_zone_service.py b/backend/app/services/dns_zone_service.py
new file mode 100644
index 00000000..b7a8f747
--- /dev/null
+++ b/backend/app/services/dns_zone_service.py
@@ -0,0 +1,306 @@
+import json
+import logging
+from datetime import datetime
+from app import db
+from app.models.dns_zone import DNSZone, DNSRecord
+
+logger = logging.getLogger(__name__)
+
+
+class DNSZoneService:
+ """Service for DNS zone and record management."""
+
+ RECORD_TYPES = ['A', 'AAAA', 'CNAME', 'MX', 'TXT', 'SRV', 'CAA', 'NS']
+
+ DNS_PRESETS = {
+ 'web-hosting': {
+ 'label': 'Standard Web Hosting',
+ 'records': [
+ {'record_type': 'A', 'name': '@', 'content': '{{server_ip}}', 'ttl': 3600},
+ {'record_type': 'A', 'name': 'www', 'content': '{{server_ip}}', 'ttl': 3600},
+ {'record_type': 'CNAME', 'name': 'mail', 'content': '{{domain}}', 'ttl': 3600},
+ ],
+ },
+ 'email-hosting': {
+ 'label': 'Email Hosting',
+ 'records': [
+ {'record_type': 'MX', 'name': '@', 'content': 'mail.{{domain}}', 'priority': 10, 'ttl': 3600},
+ {'record_type': 'TXT', 'name': '@', 'content': 'v=spf1 mx -all', 'ttl': 3600},
+ {'record_type': 'TXT', 'name': '_dmarc', 'content': 'v=DMARC1; p=quarantine; rua=mailto:dmarc@{{domain}}', 'ttl': 3600},
+ ],
+ },
+ }
+
+ @staticmethod
+ def list_zones():
+ return DNSZone.query.order_by(DNSZone.domain).all()
+
+ @staticmethod
+ def get_zone(zone_id):
+ return DNSZone.query.get(zone_id)
+
+ @staticmethod
+ def create_zone(data):
+ domain = data.get('domain', '').strip().lower()
+ if not domain:
+ raise ValueError('Domain required')
+ if DNSZone.query.filter_by(domain=domain).first():
+ raise ValueError(f'Zone for {domain} already exists')
+
+ zone = DNSZone(
+ domain=domain,
+ provider=data.get('provider', 'manual'),
+ provider_zone_id=data.get('provider_zone_id'),
+ )
+ if data.get('provider_config'):
+ zone.provider_config = data['provider_config']
+
+ db.session.add(zone)
+ db.session.commit()
+ return zone
+
+ @staticmethod
+ def delete_zone(zone_id):
+ zone = DNSZone.query.get(zone_id)
+ if not zone:
+ return False
+ db.session.delete(zone)
+ db.session.commit()
+ return True
+
+ # --- Records ---
+
+ @staticmethod
+ def get_records(zone_id):
+ return DNSRecord.query.filter_by(zone_id=zone_id).order_by(
+ DNSRecord.record_type, DNSRecord.name
+ ).all()
+
+ @staticmethod
+ def create_record(zone_id, data):
+ zone = DNSZone.query.get(zone_id)
+ if not zone:
+ raise ValueError('Zone not found')
+
+ record_type = data.get('record_type', '').upper()
+ if record_type not in DNSZoneService.RECORD_TYPES:
+ raise ValueError(f'Invalid record type: {record_type}')
+
+ record = DNSRecord(
+ zone_id=zone_id,
+ record_type=record_type,
+ name=data.get('name', '@'),
+ content=data.get('content', ''),
+ ttl=data.get('ttl', 3600),
+ priority=data.get('priority'),
+ proxied=data.get('proxied', False),
+ )
+ db.session.add(record)
+ db.session.commit()
+
+ # Sync to provider if configured
+ if zone.provider != 'manual':
+ DNSZoneService._sync_record_to_provider(zone, record, 'create')
+
+ return record
+
+ @staticmethod
+ def update_record(record_id, data):
+ record = DNSRecord.query.get(record_id)
+ if not record:
+ return None
+ for field in ['name', 'content', 'ttl', 'priority', 'proxied']:
+ if field in data:
+ setattr(record, field, data[field])
+ db.session.commit()
+
+ zone = record.zone
+ if zone.provider != 'manual':
+ DNSZoneService._sync_record_to_provider(zone, record, 'update')
+
+ return record
+
+ @staticmethod
+ def delete_record(record_id):
+ record = DNSRecord.query.get(record_id)
+ if not record:
+ return False
+ zone = record.zone
+ if zone.provider != 'manual' and record.provider_record_id:
+ DNSZoneService._sync_record_to_provider(zone, record, 'delete')
+ db.session.delete(record)
+ db.session.commit()
+ return True
+
+ @staticmethod
+ def apply_preset(zone_id, preset_key, variables=None):
+ if preset_key not in DNSZoneService.DNS_PRESETS:
+ raise ValueError(f'Unknown preset: {preset_key}')
+
+ zone = DNSZone.query.get(zone_id)
+ if not zone:
+ raise ValueError('Zone not found')
+
+ preset = DNSZoneService.DNS_PRESETS[preset_key]
+ variables = variables or {}
+ variables.setdefault('domain', zone.domain)
+
+ records = []
+ for rec_data in preset['records']:
+ data = dict(rec_data)
+ for field in ['name', 'content']:
+ for var_name, var_val in variables.items():
+ data[field] = data[field].replace('{{' + var_name + '}}', var_val)
+ record = DNSZoneService.create_record(zone_id, data)
+ records.append(record)
+
+ return records
+
+ @staticmethod
+ def check_propagation(domain, record_type='A'):
+ """Check DNS propagation across multiple nameservers."""
+ import socket
+
+ nameservers = [
+ ('Google', '8.8.8.8'),
+ ('Cloudflare', '1.1.1.1'),
+ ('OpenDNS', '208.67.222.222'),
+ ('Quad9', '9.9.9.9'),
+ ]
+
+ results = []
+ for ns_name, ns_ip in nameservers:
+ try:
+ from app.utils.system import run_command
+ result = run_command(['dig', f'@{ns_ip}', domain, record_type, '+short'], timeout=5)
+ stdout = result.get('stdout', '').strip()
+ results.append({
+ 'nameserver': ns_name,
+ 'ip': ns_ip,
+ 'result': stdout.split('\n') if stdout else [],
+ 'propagated': bool(stdout),
+ })
+ except Exception:
+ results.append({
+ 'nameserver': ns_name,
+ 'ip': ns_ip,
+ 'result': [],
+ 'propagated': False,
+ 'error': 'Query failed',
+ })
+
+ return results
+
+ @staticmethod
+ def export_zone(zone_id):
+ """Export zone in BIND format."""
+ zone = DNSZone.query.get(zone_id)
+ if not zone:
+ return None
+
+ records = DNSZoneService.get_records(zone_id)
+ lines = [f'; Zone file for {zone.domain}', f'$ORIGIN {zone.domain}.', f'$TTL 3600', '']
+
+ for rec in records:
+ name = rec.name if rec.name != '@' else zone.domain + '.'
+ if rec.record_type == 'MX':
+ lines.append(f'{name}\t{rec.ttl}\tIN\t{rec.record_type}\t{rec.priority or 10}\t{rec.content}')
+ elif rec.record_type == 'SRV':
+ lines.append(f'{name}\t{rec.ttl}\tIN\t{rec.record_type}\t{rec.priority or 0}\t{rec.content}')
+ else:
+ lines.append(f'{name}\t{rec.ttl}\tIN\t{rec.record_type}\t{rec.content}')
+
+ return '\n'.join(lines)
+
+ @staticmethod
+ def import_zone(zone_id, bind_content):
+ """Import records from BIND zone file format."""
+ zone = DNSZone.query.get(zone_id)
+ if not zone:
+ raise ValueError('Zone not found')
+
+ records_created = []
+ for line in bind_content.strip().split('\n'):
+ line = line.strip()
+ if not line or line.startswith(';') or line.startswith('$'):
+ continue
+ parts = line.split()
+ if len(parts) < 4:
+ continue
+ # Try to parse: name ttl IN type content
+ try:
+ if parts[2] == 'IN':
+ name = parts[0].rstrip('.')
+ ttl = int(parts[1])
+ rtype = parts[3]
+ content = ' '.join(parts[4:])
+ if name == zone.domain:
+ name = '@'
+ record = DNSZoneService.create_record(zone_id, {
+ 'record_type': rtype, 'name': name,
+ 'content': content, 'ttl': ttl,
+ })
+ records_created.append(record)
+ except (ValueError, IndexError):
+ continue
+
+ return records_created
+
+ @staticmethod
+ def get_presets():
+ return DNSZoneService.DNS_PRESETS
+
+ @staticmethod
+ def _sync_record_to_provider(zone, record, action):
+ """Sync a DNS record change to the configured provider."""
+ provider = zone.provider
+ config = zone.provider_config
+
+ try:
+ if provider == 'cloudflare':
+ DNSZoneService._cloudflare_sync(zone, record, action, config)
+ except Exception as e:
+ logger.error(f'DNS provider sync failed: {e}')
+
+ @staticmethod
+ def _cloudflare_sync(zone, record, action, config):
+ """Sync record to Cloudflare API."""
+ import requests
+
+ api_token = config.get('api_token')
+ if not api_token:
+ return
+
+ headers = {'Authorization': f'Bearer {api_token}', 'Content-Type': 'application/json'}
+ base_url = f'https://api.cloudflare.com/client/v4/zones/{zone.provider_zone_id}/dns_records'
+
+ if action == 'create':
+ payload = {
+ 'type': record.record_type,
+ 'name': record.name,
+ 'content': record.content,
+ 'ttl': record.ttl,
+ 'proxied': record.proxied,
+ }
+ if record.priority is not None:
+ payload['priority'] = record.priority
+ resp = requests.post(base_url, json=payload, headers=headers, timeout=10)
+ if resp.ok:
+ data = resp.json()
+ record.provider_record_id = data.get('result', {}).get('id')
+ db.session.commit()
+
+ elif action == 'update' and record.provider_record_id:
+ url = f'{base_url}/{record.provider_record_id}'
+ payload = {
+ 'type': record.record_type,
+ 'name': record.name,
+ 'content': record.content,
+ 'ttl': record.ttl,
+ 'proxied': record.proxied,
+ }
+ requests.put(url, json=payload, headers=headers, timeout=10)
+
+ elif action == 'delete' and record.provider_record_id:
+ url = f'{base_url}/{record.provider_record_id}'
+ requests.delete(url, headers=headers, timeout=10)
diff --git a/frontend/src/App.jsx b/frontend/src/App.jsx
index b552dd35..4e905825 100644
--- a/frontend/src/App.jsx
+++ b/frontend/src/App.jsx
@@ -45,6 +45,7 @@ import DatabaseMigration from './pages/DatabaseMigration';
import AgentPlugins from './pages/AgentPlugins';
import ServerTemplates from './pages/ServerTemplates';
import Workspaces from './pages/Workspaces';
+import DNSZones from './pages/DNSZones';
// Page title mapping
const PAGE_TITLES = {
@@ -80,6 +81,7 @@ const PAGE_TITLES = {
'/agent-plugins': 'Agent Plugins',
'/server-templates': 'Server Templates',
'/workspaces': 'Workspaces',
+ '/dns': 'DNS Zones',
};
function PageTitleUpdater() {
@@ -219,6 +221,7 @@ function AppRoutes() {
<Route path="agent-plugins" element={<AgentPlugins />} />
<Route path="server-templates" element={<ServerTemplates />} />
<Route path="workspaces" element={<Workspaces />} />
+ <Route path="dns" element={<DNSZones />} />
<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 abdbb855..5985fdab 100644
--- a/frontend/src/components/sidebarItems.js
+++ b/frontend/src/components/sidebarItems.js
@@ -107,6 +107,13 @@ export const SIDEBAR_ITEMS = [
category: 'infrastructure',
icon: '<ellipse cx="12" cy="5" rx="9" ry="3"/><path d="M21 12c0 1.66-4 3-9 3s-9-1.34-9-3"/><path d="M3 5v14c0 1.66 4 3 9 3s9-1.34 9-3V5"/>'
},
+ {
+ id: 'dns',
+ label: 'DNS Zones',
+ route: '/dns',
+ category: 'infrastructure',
+ icon: '<path d="M12 2L2 7l10 5 10-5-10-5z"/><path d="M2 17l10 5 10-5"/><path d="M2 12l10 5 10-5"/>'
+ },
{
id: 'ssl',
label: 'SSL Certificates',
diff --git a/frontend/src/pages/DNSZones.jsx b/frontend/src/pages/DNSZones.jsx
new file mode 100644
index 00000000..4b60adf5
--- /dev/null
+++ b/frontend/src/pages/DNSZones.jsx
@@ -0,0 +1,316 @@
+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 DNSZones = () => {
+ const toast = useToast();
+ const { user } = useAuth();
+ const [zones, setZones] = useState([]);
+ const [loading, setLoading] = useState(true);
+ const [selectedZone, setSelectedZone] = useState(null);
+ const [records, setRecords] = useState([]);
+ const [showCreateZone, setShowCreateZone] = useState(false);
+ const [showCreateRecord, setShowCreateRecord] = useState(false);
+ const [showPropagation, setShowPropagation] = useState(null);
+ const [propagationResults, setPropagationResults] = useState([]);
+ const [deleteConfirm, setDeleteConfirm] = useState(null);
+
+ const [zoneForm, setZoneForm] = useState({ domain: '', provider: 'manual' });
+ const [recordForm, setRecordForm] = useState({
+ record_type: 'A', name: '@', content: '', ttl: 3600, priority: null
+ });
+
+ const RECORD_TYPES = ['A', 'AAAA', 'CNAME', 'MX', 'TXT', 'SRV', 'CAA', 'NS'];
+
+ const loadZones = useCallback(async () => {
+ try {
+ const data = await api.getDNSZones();
+ setZones(data.zones || []);
+ } catch (err) {
+ toast.error('Failed to load DNS zones');
+ } finally {
+ setLoading(false);
+ }
+ }, [toast]);
+
+ useEffect(() => { loadZones(); }, [loadZones]);
+
+ const loadRecords = async (zoneId) => {
+ try {
+ const data = await api.getDNSRecords(zoneId);
+ setRecords(data.records || []);
+ setSelectedZone(zones.find(z => z.id === zoneId));
+ } catch (err) {
+ toast.error('Failed to load records');
+ }
+ };
+
+ const handleCreateZone = async () => {
+ try {
+ await api.createDNSZone(zoneForm);
+ toast.success('Zone created');
+ setShowCreateZone(false);
+ setZoneForm({ domain: '', provider: 'manual' });
+ loadZones();
+ } catch (err) {
+ toast.error(err.message);
+ }
+ };
+
+ const handleCreateRecord = async () => {
+ if (!selectedZone) return;
+ try {
+ await api.createDNSRecord(selectedZone.id, recordForm);
+ toast.success('Record created');
+ setShowCreateRecord(false);
+ setRecordForm({ record_type: 'A', name: '@', content: '', ttl: 3600, priority: null });
+ loadRecords(selectedZone.id);
+ } catch (err) {
+ toast.error(err.message);
+ }
+ };
+
+ const handleDeleteRecord = async (recordId) => {
+ try {
+ await api.deleteDNSRecord(recordId);
+ toast.success('Record deleted');
+ if (selectedZone) loadRecords(selectedZone.id);
+ } catch (err) {
+ toast.error(err.message);
+ }
+ };
+
+ const handleDeleteZone = async (id) => {
+ try {
+ await api.deleteDNSZone(id);
+ toast.success('Zone deleted');
+ setDeleteConfirm(null);
+ if (selectedZone?.id === id) {
+ setSelectedZone(null);
+ setRecords([]);
+ }
+ loadZones();
+ } catch (err) {
+ toast.error(err.message);
+ }
+ };
+
+ const handleCheckPropagation = async (domain) => {
+ try {
+ const data = await api.checkDNSPropagation(domain);
+ setPropagationResults(data.results || []);
+ setShowPropagation(domain);
+ } catch (err) {
+ toast.error(err.message);
+ }
+ };
+
+ const handleExport = async (zoneId) => {
+ try {
+ const data = await api.exportDNSZone(zoneId);
+ const blob = new Blob([data.zone_file], { type: 'text/plain' });
+ const url = URL.createObjectURL(blob);
+ const a = document.createElement('a');
+ a.href = url;
+ a.download = `${selectedZone?.domain || 'zone'}.txt`;
+ a.click();
+ URL.revokeObjectURL(url);
+ } catch (err) {
+ toast.error(err.message);
+ }
+ };
+
+ if (loading) return <Spinner />;
+
+ return (
+ <div className="dns-zones-page">
+ <header className="top-bar">
+ <div className="top-bar__title">
+ <h1>DNS Zones</h1>
+ <span className="top-bar__subtitle">{zones.length} zone{zones.length !== 1 ? 's' : ''}</span>
+ </div>
+ <div className="top-bar__actions">
+ {user?.is_admin && (
+ <button className="btn btn--primary" onClick={() => setShowCreateZone(true)}>Add Zone</button>
+ )}
+ </div>
+ </header>
+
+ <div className="dns-layout">
+ <div className="dns-zones-list">
+ {zones.map(zone => (
+ <div key={zone.id}
+ className={`dns-zone-item ${selectedZone?.id === zone.id ? 'active' : ''}`}
+ onClick={() => loadRecords(zone.id)}>
+ <div className="dns-zone-item__info">
+ <strong>{zone.domain}</strong>
+ <span className="text-muted">{zone.provider} \u2022 {zone.record_count} records</span>
+ </div>
+ <div className="dns-zone-item__actions" onClick={e => e.stopPropagation()}>
+ <button className="btn btn--sm" onClick={() => handleCheckPropagation(zone.domain)}>Check</button>
+ {user?.is_admin && (
+ <button className="btn btn--sm btn--danger" onClick={() => setDeleteConfirm(zone)}>Delete</button>
+ )}
+ </div>
+ </div>
+ ))}
+ {zones.length === 0 && <div className="empty-state"><p>No DNS zones configured.</p></div>}
+ </div>
+
+ {selectedZone && (
+ <div className="dns-records-panel">
+ <div className="dns-records-panel__header">
+ <h2>{selectedZone.domain}</h2>
+ <div className="dns-records-panel__actions">
+ <button className="btn btn--sm" onClick={() => handleExport(selectedZone.id)}>Export</button>
+ {user?.is_admin && (
+ <button className="btn btn--sm btn--primary" onClick={() => setShowCreateRecord(true)}>Add Record</button>
+ )}
+ </div>
+ </div>
+ <table className="table">
+ <thead>
+ <tr>
+ <th>Type</th>
+ <th>Name</th>
+ <th>Content</th>
+ <th>TTL</th>
+ <th>Priority</th>
+ <th></th>
+ </tr>
+ </thead>
+ <tbody>
+ {records.map(rec => (
+ <tr key={rec.id}>
+ <td><span className="badge badge--outline">{rec.record_type}</span></td>
+ <td>{rec.name}</td>
+ <td className="text-mono">{rec.content}</td>
+ <td>{rec.ttl}</td>
+ <td>{rec.priority || '-'}</td>
+ <td>
+ {user?.is_admin && (
+ <button className="btn btn--sm btn--danger" onClick={() => handleDeleteRecord(rec.id)}>Delete</button>
+ )}
+ </td>
+ </tr>
+ ))}
+ {records.length === 0 && (
+ <tr><td colSpan={6} className="text-center text-muted">No records</td></tr>
+ )}
+ </tbody>
+ </table>
+ </div>
+ )}
+ </div>
+
+ {showCreateZone && (
+ <div className="modal-overlay" onClick={() => setShowCreateZone(false)}>
+ <div className="modal" onClick={e => e.stopPropagation()}>
+ <div className="modal__header">
+ <h2>Add DNS Zone</h2>
+ <button className="modal__close" onClick={() => setShowCreateZone(false)}>&times;</button>
+ </div>
+ <div className="modal__body">
+ <div className="form-group">
+ <label>Domain</label>
+ <input className="form-input" value={zoneForm.domain} onChange={e => setZoneForm({...zoneForm, domain: e.target.value})} placeholder="example.com" />
+ </div>
+ <div className="form-group">
+ <label>Provider</label>
+ <select className="form-select" value={zoneForm.provider} onChange={e => setZoneForm({...zoneForm, provider: e.target.value})}>
+ <option value="manual">Manual</option>
+ <option value="cloudflare">Cloudflare</option>
+ <option value="route53">Route53</option>
+ <option value="digitalocean">DigitalOcean</option>
+ </select>
+ </div>
+ </div>
+ <div className="modal__footer">
+ <button className="btn" onClick={() => setShowCreateZone(false)}>Cancel</button>
+ <button className="btn btn--primary" onClick={handleCreateZone} disabled={!zoneForm.domain}>Create</button>
+ </div>
+ </div>
+ </div>
+ )}
+
+ {showCreateRecord && (
+ <div className="modal-overlay" onClick={() => setShowCreateRecord(false)}>
+ <div className="modal" onClick={e => e.stopPropagation()}>
+ <div className="modal__header">
+ <h2>Add DNS Record</h2>
+ <button className="modal__close" onClick={() => setShowCreateRecord(false)}>&times;</button>
+ </div>
+ <div className="modal__body">
+ <div className="form-group">
+ <label>Type</label>
+ <select className="form-select" value={recordForm.record_type} onChange={e => setRecordForm({...recordForm, record_type: e.target.value})}>
+ {RECORD_TYPES.map(t => <option key={t} value={t}>{t}</option>)}
+ </select>
+ </div>
+ <div className="form-group">
+ <label>Name</label>
+ <input className="form-input" value={recordForm.name} onChange={e => setRecordForm({...recordForm, name: e.target.value})} placeholder="@ or subdomain" />
+ </div>
+ <div className="form-group">
+ <label>Content</label>
+ <input className="form-input" value={recordForm.content} onChange={e => setRecordForm({...recordForm, content: e.target.value})} placeholder="IP address or hostname" />
+ </div>
+ <div className="form-row">
+ <div className="form-group">
+ <label>TTL</label>
+ <input className="form-input" type="number" value={recordForm.ttl} onChange={e => setRecordForm({...recordForm, ttl: parseInt(e.target.value) || 3600})} />
+ </div>
+ {(recordForm.record_type === 'MX' || recordForm.record_type === 'SRV') && (
+ <div className="form-group">
+ <label>Priority</label>
+ <input className="form-input" type="number" value={recordForm.priority || ''} onChange={e => setRecordForm({...recordForm, priority: parseInt(e.target.value) || null})} />
+ </div>
+ )}
+ </div>
+ </div>
+ <div className="modal__footer">
+ <button className="btn" onClick={() => setShowCreateRecord(false)}>Cancel</button>
+ <button className="btn btn--primary" onClick={handleCreateRecord} disabled={!recordForm.content}>Create</button>
+ </div>
+ </div>
+ </div>
+ )}
+
+ {showPropagation && (
+ <div className="modal-overlay" onClick={() => setShowPropagation(null)}>
+ <div className="modal" onClick={e => e.stopPropagation()}>
+ <div className="modal__header">
+ <h2>DNS Propagation: {showPropagation}</h2>
+ <button className="modal__close" onClick={() => setShowPropagation(null)}>&times;</button>
+ </div>
+ <div className="modal__body">
+ {propagationResults.map((r, i) => (
+ <div key={i} className="propagation-row">
+ <span className={`status-dot status-dot--${r.propagated ? 'success' : 'danger'}`} />
+ <strong>{r.nameserver}</strong>
+ <span className="text-muted">({r.ip})</span>
+ <span className="text-mono">{r.result?.join(', ') || 'No result'}</span>
+ </div>
+ ))}
+ </div>
+ </div>
+ </div>
+ )}
+
+ {deleteConfirm && (
+ <ConfirmDialog
+ title="Delete Zone"
+ message={`Delete zone "${deleteConfirm.domain}"? All records will be removed.`}
+ onConfirm={() => handleDeleteZone(deleteConfirm.id)}
+ onCancel={() => setDeleteConfirm(null)}
+ variant="danger"
+ />
+ )}
+ </div>
+ );
+};
+
+export default DNSZones;
diff --git a/frontend/src/services/api.js b/frontend/src/services/api.js
index 94d73832..413cae5d 100644
--- a/frontend/src/services/api.js
+++ b/frontend/src/services/api.js
@@ -3604,6 +3604,64 @@ class ApiService {
async getSSLExpiryAlerts(days = 30) {
return this.request(`/ssl/advanced/expiry-alerts?days=${days}`);
}
+ // ========================================
+ // DNS Zones endpoints
+ // ========================================
+ async getDNSZones() {
+ return this.request('/dns/');
+ }
+
+ async getDNSZone(id) {
+ return this.request(`/dns/${id}`);
+ }
+
+ async createDNSZone(data) {
+ return this.request('/dns/', { method: 'POST', body: data });
+ }
+
+ async deleteDNSZone(id) {
+ return this.request(`/dns/${id}`, { method: 'DELETE' });
+ }
+
+ async getDNSRecords(zoneId) {
+ return this.request(`/dns/${zoneId}/records`);
+ }
+
+ async createDNSRecord(zoneId, data) {
+ return this.request(`/dns/${zoneId}/records`, { method: 'POST', body: data });
+ }
+
+ async updateDNSRecord(recordId, data) {
+ return this.request(`/dns/records/${recordId}`, { method: 'PUT', body: data });
+ }
+
+ async deleteDNSRecord(recordId) {
+ return this.request(`/dns/records/${recordId}`, { method: 'DELETE' });
+ }
+
+ async getDNSPresets() {
+ return this.request('/dns/presets');
+ }
+
+ async applyDNSPreset(zoneId, preset, variables) {
+ return this.request(`/dns/${zoneId}/apply-preset`, {
+ method: 'POST', body: { preset, variables }
+ });
+ }
+
+ async checkDNSPropagation(domain, type = 'A') {
+ return this.request(`/dns/propagation/${domain}?type=${type}`);
+ }
+
+ async exportDNSZone(zoneId) {
+ return this.request(`/dns/${zoneId}/export`);
+ }
+
+ async importDNSZone(zoneId, zoneFile) {
+ return this.request(`/dns/${zoneId}/import`, {
+ method: 'POST', body: { zone_file: zoneFile }
+ });
+ }
}
export const api = new ApiService();
diff --git a/frontend/src/styles/main.less b/frontend/src/styles/main.less
index b84a57c2..26fd9b67 100644
--- a/frontend/src/styles/main.less
+++ b/frontend/src/styles/main.less
@@ -88,3 +88,4 @@
@import 'pages/_agent-plugins';
@import 'pages/_server-templates';
@import 'pages/_workspaces';
+@import 'pages/_dns-zones';
diff --git a/frontend/src/styles/pages/_dns-zones.less b/frontend/src/styles/pages/_dns-zones.less
new file mode 100644
index 00000000..82f9a26e
--- /dev/null
+++ b/frontend/src/styles/pages/_dns-zones.less
@@ -0,0 +1,89 @@
+// DNS Zones page styles
+
+.dns-zones-page {
+ .dns-layout {
+ display: grid;
+ grid-template-columns: 320px 1fr;
+ gap: @spacing-lg;
+ margin-top: @spacing-lg;
+
+ @media (max-width: 900px) {
+ grid-template-columns: 1fr;
+ }
+ }
+
+ .dns-zones-list {
+ display: flex;
+ flex-direction: column;
+ gap: @spacing-xs;
+ }
+
+ .dns-zone-item {
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+ padding: @spacing-md;
+ background: @card-bg;
+ border: 1px solid @border-color;
+ border-radius: @radius-md;
+ cursor: pointer;
+ transition: border-color 0.15s;
+
+ &:hover, &.active {
+ border-color: @primary-color;
+ }
+
+ &__info {
+ display: flex;
+ flex-direction: column;
+ gap: 2px;
+ }
+
+ &__actions {
+ display: flex;
+ gap: @spacing-xs;
+ }
+ }
+
+ .dns-records-panel {
+ background: @card-bg;
+ border: 1px solid @border-color;
+ border-radius: @radius-lg;
+ padding: @spacing-lg;
+
+ &__header {
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+ margin-bottom: @spacing-lg;
+
+ h2 { margin: 0; }
+ }
+
+ &__actions {
+ display: flex;
+ gap: @spacing-sm;
+ }
+ }
+
+ .text-mono {
+ font-family: @font-mono;
+ font-size: 0.85rem;
+ }
+
+ .propagation-row {
+ display: flex;
+ align-items: center;
+ gap: @spacing-sm;
+ padding: @spacing-sm 0;
+ border-bottom: 1px solid @border-color;
+
+ &:last-child { border-bottom: none; }
+ }
+
+ .form-row {
+ display: grid;
+ grid-template-columns: 1fr 1fr;
+ gap: @spacing-md;
+ }
+}