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.
Python astracloudflarecontrol-panelcyberpaneldnsfablehosting-control-panelhosting-panelkimi-k3server-managementserverkitubuntu-web-panelwebserver
Add Kubernetes plugin backend and manifest entry
Juan Denis053d9877214b
diff --git a/backend/app/plugins/serverkit-k8s/__init__.py b/backend/app/plugins/serverkit-k8s/__init__.pynew file mode 100644index 00000000..c7cb3d27--- /dev/null+++ b/backend/app/plugins/serverkit-k8s/__init__.py@@ -0,0 +1,4 @@+"""ServerKit Kubernetes extension backend package (kubectl engine)."""+from .k8s import k8s_bp++__all__ = ['k8s_bp']diff --git a/backend/app/plugins/serverkit-k8s/cluster_service.py b/backend/app/plugins/serverkit-k8s/cluster_service.pynew file mode 100644index 00000000..d2ba464f--- /dev/null+++ b/backend/app/plugins/serverkit-k8s/cluster_service.py@@ -0,0 +1,365 @@+"""High-level operations for the serverkit-k8s extension.++This is the layer the blueprint calls. It owns:++- CRUD for saved cluster connections (:class:`K8sCluster` rows), including the+ single-default invariant.+- ``test_connection`` -- probe ``kubectl version`` and cache the result on the row.+- Read helpers (nodes, namespaces, workloads, pods, logs, services, ingresses,+ overview) that run ``kubectl get ... -o json`` and **normalize** the verbose+ Kubernetes objects down to the small flat dicts the UI actually consumes.+- Mutations (scale, restart, delete, apply) as thin ``kubectl`` wrappers.++Nothing here trusts the cluster to stay reachable: every read that hits the+cluster is wrapped by the blueprint and surfaces a clean error rather than a+stack trace.+"""+import json+import logging+from datetime import datetime++from app import db++from .models import K8sCluster+from . import kubectl_service+from .kubectl_service import KubectlError++logger = logging.getLogger(__name__)+++# --------------------------------------------------------------------------+# CRUD+# --------------------------------------------------------------------------+def list_clusters():+ return [c.to_dict() for c in K8sCluster.query.order_by(K8sCluster.name.asc()).all()]+++def get_cluster(cluster_id):+ return K8sCluster.query.get(cluster_id)+++def get_default_cluster():+ return (K8sCluster.query.filter_by(is_default=True).first()+ or K8sCluster.query.order_by(K8sCluster.id.asc()).first())+++def create_cluster(name, kubeconfig, context=None, make_default=False):+ name = (name or '').strip()+ if not name:+ raise ValueError('A cluster name is required.')+ if not (kubeconfig or '').strip():+ raise ValueError('A kubeconfig is required.')+ if K8sCluster.query.filter_by(name=name).first():+ raise ValueError(f'A cluster named "{name}" already exists.')++ cluster = K8sCluster(name=name, context=(context or None) or None)+ cluster.set_kubeconfig(kubeconfig)++ # First cluster is default automatically; otherwise honor the flag.+ if make_default or K8sCluster.query.count() == 0:+ _clear_default()+ cluster.is_default = True++ db.session.add(cluster)+ db.session.commit()+ return cluster+++def update_cluster(cluster_id, name=None, kubeconfig=None, context=None):+ cluster = get_cluster(cluster_id)+ if not cluster:+ raise ValueError('Cluster not found.')+ if name is not None:+ name = name.strip()+ if not name:+ raise ValueError('A cluster name is required.')+ existing = K8sCluster.query.filter_by(name=name).first()+ if existing and existing.id != cluster.id:+ raise ValueError(f'A cluster named "{name}" already exists.')+ cluster.name = name+ if kubeconfig is not None and kubeconfig.strip():+ cluster.set_kubeconfig(kubeconfig)+ if context is not None:+ cluster.context = context.strip() or None+ db.session.commit()+ return cluster+++def delete_cluster(cluster_id):+ cluster = get_cluster(cluster_id)+ if not cluster:+ raise ValueError('Cluster not found.')+ was_default = cluster.is_default+ db.session.delete(cluster)+ db.session.commit()+ # Promote another cluster to default if we removed the default one.+ if was_default:+ nxt = K8sCluster.query.order_by(K8sCluster.id.asc()).first()+ if nxt:+ nxt.is_default = True+ db.session.commit()+ return True+++def set_default(cluster_id):+ cluster = get_cluster(cluster_id)+ if not cluster:+ raise ValueError('Cluster not found.')+ _clear_default()+ cluster.is_default = True+ db.session.commit()+ return cluster+++def _clear_default():+ for c in K8sCluster.query.filter_by(is_default=True).all():+ c.is_default = False+++# --------------------------------------------------------------------------+# Connectivity+# --------------------------------------------------------------------------+def test_connection(cluster):+ """Probe the cluster and cache the result on the row. Never raises."""+ result = {'ok': False, 'server_version': None, 'error': None}+ try:+ data = kubectl_service.run_json(cluster, ['version', '-o', 'json'], timeout=15)+ server = (data or {}).get('serverVersion') or {}+ version = server.get('gitVersion')+ if not version:+ raise KubectlError('cluster did not report a server version (unreachable?)')+ result['ok'] = True+ result['server_version'] = version+ except KubectlError as e:+ result['error'] = str(e)+ except Exception as e: # noqa: BLE001 - defensive: never let a probe crash the request+ result['error'] = str(e)++ cluster.last_reachable = result['ok']+ cluster.last_status = json.dumps({'server_version': result['server_version'], 'error': result['error']})+ cluster.last_checked_at = datetime.utcnow()+ db.session.commit()+ return result+++# --------------------------------------------------------------------------+# Reads (normalized)+# --------------------------------------------------------------------------+def _items(cluster, args):+ data = kubectl_service.run_json(cluster, args)+ return (data or {}).get('items', []) or []+++def _ns_args(namespace):+ if namespace and namespace != 'all':+ return ['-n', namespace]+ return ['--all-namespaces']+++def get_nodes(cluster):+ out = []+ for n in _items(cluster, ['get', 'nodes', '-o', 'json']):+ meta = n.get('metadata', {})+ status = n.get('status', {})+ conditions = {c.get('type'): c.get('status') for c in status.get('conditions', [])}+ ready = conditions.get('Ready') == 'True'+ info = status.get('nodeInfo', {})+ roles = [k.split('/', 1)[1] for k in meta.get('labels', {})+ if k.startswith('node-role.kubernetes.io/')]+ out.append({+ 'name': meta.get('name'),+ 'ready': ready,+ 'roles': roles or ['worker'],+ 'kubelet_version': info.get('kubeletVersion'),+ 'os_image': info.get('osImage'),+ 'kernel_version': info.get('kernelVersion'),+ 'container_runtime': info.get('containerRuntimeVersion'),+ 'cpu': status.get('capacity', {}).get('cpu'),+ 'memory': status.get('capacity', {}).get('memory'),+ 'created_at': meta.get('creationTimestamp'),+ })+ return out+++def get_namespaces(cluster):+ out = []+ for ns in _items(cluster, ['get', 'namespaces', '-o', 'json']):+ meta = ns.get('metadata', {})+ out.append({+ 'name': meta.get('name'),+ 'phase': ns.get('status', {}).get('phase'),+ 'created_at': meta.get('creationTimestamp'),+ })+ return out+++_WORKLOAD_KINDS = {+ 'deployment': 'deployments',+ 'statefulset': 'statefulsets',+ 'daemonset': 'daemonsets',+}+++def get_workloads(cluster, namespace='all', kind='deployment'):+ resource = _WORKLOAD_KINDS.get(kind, 'deployments')+ out = []+ for w in _items(cluster, ['get', resource] + _ns_args(namespace) + ['-o', 'json']):+ meta = w.get('metadata', {})+ spec = w.get('spec', {})+ status = w.get('status', {})+ if resource == 'daemonsets':+ desired = status.get('desiredNumberScheduled', 0)+ ready = status.get('numberReady', 0)+ else:+ desired = spec.get('replicas', 0)+ ready = status.get('readyReplicas', 0) or 0+ out.append({+ 'name': meta.get('name'),+ 'namespace': meta.get('namespace'),+ 'kind': kind,+ 'desired': desired,+ 'ready': ready,+ 'available': status.get('availableReplicas', ready) if resource != 'daemonsets' else status.get('numberAvailable', ready),+ 'healthy': bool(desired) and ready == desired,+ 'images': [c.get('image') for c in spec.get('template', {}).get('spec', {}).get('containers', [])],+ 'created_at': meta.get('creationTimestamp'),+ })+ return out+++def get_pods(cluster, namespace='all'):+ out = []+ for p in _items(cluster, ['get', 'pods'] + _ns_args(namespace) + ['-o', 'json']):+ meta = p.get('metadata', {})+ status = p.get('status', {})+ container_statuses = status.get('containerStatuses', []) or []+ restarts = sum(cs.get('restartCount', 0) for cs in container_statuses)+ ready_count = sum(1 for cs in container_statuses if cs.get('ready'))+ total = len(container_statuses) or len(p.get('spec', {}).get('containers', []))+ out.append({+ 'name': meta.get('name'),+ 'namespace': meta.get('namespace'),+ 'phase': status.get('phase'),+ 'ready': f'{ready_count}/{total}',+ 'restarts': restarts,+ 'node': p.get('spec', {}).get('nodeName'),+ 'pod_ip': status.get('podIP'),+ 'containers': [c.get('name') for c in p.get('spec', {}).get('containers', [])],+ 'created_at': meta.get('creationTimestamp'),+ })+ return out+++def get_pod_logs(cluster, namespace, pod, container=None, tail=200):+ args = ['logs', pod, '-n', namespace, '--tail', str(int(tail))]+ if container:+ args += ['-c', container]+ return kubectl_service.run(cluster, args, timeout=30)+++def get_services(cluster, namespace='all'):+ out = []+ for s in _items(cluster, ['get', 'services'] + _ns_args(namespace) + ['-o', 'json']):+ meta = s.get('metadata', {})+ spec = s.get('spec', {})+ ports = ['{}/{}'.format(p.get('port'), p.get('protocol', 'TCP')) for p in spec.get('ports', [])]+ ingress = s.get('status', {}).get('loadBalancer', {}).get('ingress', []) or []+ external = ', '.join(filter(None, [i.get('ip') or i.get('hostname') for i in ingress])) or None+ out.append({+ 'name': meta.get('name'),+ 'namespace': meta.get('namespace'),+ 'type': spec.get('type'),+ 'cluster_ip': spec.get('clusterIP'),+ 'external_ip': external,+ 'ports': ports,+ 'created_at': meta.get('creationTimestamp'),+ })+ return out+++def get_ingresses(cluster, namespace='all'):+ out = []+ for ing in _items(cluster, ['get', 'ingresses'] + _ns_args(namespace) + ['-o', 'json']):+ meta = ing.get('metadata', {})+ spec = ing.get('spec', {})+ hosts = [r.get('host') for r in spec.get('rules', []) if r.get('host')]+ out.append({+ 'name': meta.get('name'),+ 'namespace': meta.get('namespace'),+ 'class': spec.get('ingressClassName'),+ 'hosts': hosts,+ 'created_at': meta.get('creationTimestamp'),+ })+ return out+++def get_overview(cluster):+ """A compact dashboard payload. Best-effort; partial data on partial failure."""+ overview = {+ 'cluster': cluster.to_dict(),+ 'reachable': False,+ 'server_version': None,+ 'counts': {'nodes': 0, 'nodes_ready': 0, 'namespaces': 0, 'pods': 0, 'pods_running': 0, 'deployments': 0},+ 'error': None,+ }+ conn = test_connection(cluster)+ overview['reachable'] = conn['ok']+ overview['server_version'] = conn['server_version']+ if not conn['ok']:+ overview['error'] = conn['error']+ return overview+ try:+ nodes = get_nodes(cluster)+ namespaces = get_namespaces(cluster)+ pods = get_pods(cluster, 'all')+ deployments = get_workloads(cluster, 'all', 'deployment')+ overview['counts'] = {+ 'nodes': len(nodes),+ 'nodes_ready': sum(1 for n in nodes if n['ready']),+ 'namespaces': len(namespaces),+ 'pods': len(pods),+ 'pods_running': sum(1 for p in pods if p['phase'] == 'Running'),+ 'deployments': len(deployments),+ }+ except KubectlError as e:+ overview['error'] = str(e)+ return overview+++# --------------------------------------------------------------------------+# Mutations+# --------------------------------------------------------------------------+def scale_deployment(cluster, namespace, name, replicas):+ replicas = int(replicas)+ if replicas < 0:+ raise ValueError('replicas must be >= 0')+ kubectl_service.run(+ cluster,+ ['scale', 'deployment', name, '-n', namespace, f'--replicas={replicas}'],+ )+ return {'name': name, 'namespace': namespace, 'replicas': replicas}+++def restart_deployment(cluster, namespace, name):+ kubectl_service.run(cluster, ['rollout', 'restart', 'deployment', name, '-n', namespace])+ return {'name': name, 'namespace': namespace, 'restarted': True}+++_DELETABLE_KINDS = {'pod', 'deployment', 'statefulset', 'daemonset', 'service', 'ingress'}+++def delete_resource(cluster, kind, name, namespace):+ kind = (kind or '').lower()+ if kind not in _DELETABLE_KINDS:+ raise ValueError(f'Refusing to delete unsupported resource kind "{kind}".')+ if not name or not namespace:+ raise ValueError('name and namespace are required.')+ kubectl_service.run(cluster, ['delete', kind, name, '-n', namespace])+ return {'kind': kind, 'name': name, 'namespace': namespace, 'deleted': True}+++def apply_manifest(cluster, manifest_text):+ if not (manifest_text or '').strip():+ raise ValueError('An empty manifest cannot be applied.')+ out = kubectl_service.run(cluster, ['apply', '-f', '-'], input_text=manifest_text, timeout=60)+ return {'output': out.strip()}diff --git a/backend/app/plugins/serverkit-k8s/k8s.py b/backend/app/plugins/serverkit-k8s/k8s.pynew file mode 100644index 00000000..7d67087d--- /dev/null+++ b/backend/app/plugins/serverkit-k8s/k8s.py@@ -0,0 +1,277 @@+"""Kubernetes API endpoints (serverkit-k8s extension).++Mounted under ``/api/v1/k8s`` via the manifest's ``url_prefix``. Thin routing+layer over :mod:`cluster_service` -- all kubectl work happens there. Reads need+viewer, mutations need admin (same split as the serverkit-mail and+serverkit-dns-server extensions).++Cluster CRUD works even when ``kubectl`` is absent so an operator can stage a+connection first; only routes that actually talk to a cluster are guarded by+``_kubectl_or_error`` (503 when the binary is missing).+"""+from flask import Blueprint, jsonify, request++from app.middleware.rbac import admin_required, viewer_required++from . import cluster_service+from . import kubectl_service+from .kubectl_service import KubectlError++k8s_bp = Blueprint('k8s', __name__)+++def _kubectl_or_error():+ if not kubectl_service.is_available():+ return jsonify({+ 'error': 'kubectl is not installed on the panel host. Install kubectl '+ 'to talk to clusters.'+ }), 503+ return None+++def _cluster_or_404(cluster_id):+ return cluster_service.get_cluster(cluster_id)+++def _kubectl_call(fn):+ """Run a cluster read/mutation, converting KubectlError to a clean 502."""+ try:+ return jsonify(fn())+ except KubectlError as e:+ return jsonify({'error': str(e)}), 502+ except ValueError as e:+ return jsonify({'error': str(e)}), 400+++# --------------------------------------------------------------------------+# Status + cluster CRUD (no kubectl required)+# --------------------------------------------------------------------------+@k8s_bp.route('/status', methods=['GET'])+@viewer_required+def status():+ default = cluster_service.get_default_cluster()+ return jsonify({+ 'kubectl_available': kubectl_service.is_available(),+ 'clusters': cluster_service.list_clusters(),+ 'default_cluster_id': default.id if default else None,+ })+++@k8s_bp.route('/clusters', methods=['GET'])+@viewer_required+def list_clusters():+ return jsonify({'clusters': cluster_service.list_clusters()})+++@k8s_bp.route('/clusters', methods=['POST'])+@admin_required+def create_cluster():+ data = request.get_json(silent=True) or {}+ try:+ cluster = cluster_service.create_cluster(+ name=data.get('name'),+ kubeconfig=data.get('kubeconfig'),+ context=data.get('context'),+ make_default=bool(data.get('make_default')),+ )+ except ValueError as e:+ return jsonify({'error': str(e)}), 400+ return jsonify(cluster.to_dict()), 201+++@k8s_bp.route('/clusters/<int:cluster_id>', methods=['GET'])+@viewer_required+def get_cluster(cluster_id):+ cluster = _cluster_or_404(cluster_id)+ if not cluster:+ return jsonify({'error': 'Cluster not found'}), 404+ return jsonify(cluster.to_dict())+++@k8s_bp.route('/clusters/<int:cluster_id>', methods=['PUT'])+@admin_required+def update_cluster(cluster_id):+ data = request.get_json(silent=True) or {}+ try:+ cluster = cluster_service.update_cluster(+ cluster_id,+ name=data.get('name'),+ kubeconfig=data.get('kubeconfig'),+ context=data.get('context'),+ )+ except ValueError as e:+ code = 404 if 'not found' in str(e).lower() else 400+ return jsonify({'error': str(e)}), code+ return jsonify(cluster.to_dict())+++@k8s_bp.route('/clusters/<int:cluster_id>', methods=['DELETE'])+@admin_required+def delete_cluster(cluster_id):+ try:+ cluster_service.delete_cluster(cluster_id)+ except ValueError as e:+ return jsonify({'error': str(e)}), 404+ return jsonify({'deleted': True})+++@k8s_bp.route('/clusters/<int:cluster_id>/default', methods=['POST'])+@admin_required+def set_default(cluster_id):+ try:+ cluster = cluster_service.set_default(cluster_id)+ except ValueError as e:+ return jsonify({'error': str(e)}), 404+ return jsonify(cluster.to_dict())+++# --------------------------------------------------------------------------+# Cluster-talking routes (kubectl required)+# --------------------------------------------------------------------------+@k8s_bp.route('/clusters/<int:cluster_id>/test', methods=['POST'])+@viewer_required+def test_connection(cluster_id):+ guard = _kubectl_or_error()+ if guard:+ return guard+ cluster = _cluster_or_404(cluster_id)+ if not cluster:+ return jsonify({'error': 'Cluster not found'}), 404+ return jsonify(cluster_service.test_connection(cluster))+++@k8s_bp.route('/clusters/<int:cluster_id>/overview', methods=['GET'])+@viewer_required+def overview(cluster_id):+ guard = _kubectl_or_error()+ if guard:+ return guard+ cluster = _cluster_or_404(cluster_id)+ if not cluster:+ return jsonify({'error': 'Cluster not found'}), 404+ return jsonify(cluster_service.get_overview(cluster))+++def _read_route(cluster_id, fn_name):+ guard = _kubectl_or_error()+ if guard:+ return guard+ cluster = _cluster_or_404(cluster_id)+ if not cluster:+ return jsonify({'error': 'Cluster not found'}), 404+ namespace = request.args.get('namespace', 'all')+ fn = getattr(cluster_service, fn_name)+ if fn_name in ('get_nodes', 'get_namespaces'):+ return _kubectl_call(lambda: {'items': fn(cluster)})+ return _kubectl_call(lambda: {'items': fn(cluster, namespace)})+++@k8s_bp.route('/clusters/<int:cluster_id>/nodes', methods=['GET'])+@viewer_required+def nodes(cluster_id):+ return _read_route(cluster_id, 'get_nodes')+++@k8s_bp.route('/clusters/<int:cluster_id>/namespaces', methods=['GET'])+@viewer_required+def namespaces(cluster_id):+ return _read_route(cluster_id, 'get_namespaces')+++@k8s_bp.route('/clusters/<int:cluster_id>/pods', methods=['GET'])+@viewer_required+def pods(cluster_id):+ return _read_route(cluster_id, 'get_pods')+++@k8s_bp.route('/clusters/<int:cluster_id>/services', methods=['GET'])+@viewer_required+def services(cluster_id):+ return _read_route(cluster_id, 'get_services')+++@k8s_bp.route('/clusters/<int:cluster_id>/ingresses', methods=['GET'])+@viewer_required+def ingresses(cluster_id):+ return _read_route(cluster_id, 'get_ingresses')+++@k8s_bp.route('/clusters/<int:cluster_id>/workloads', methods=['GET'])+@viewer_required+def workloads(cluster_id):+ guard = _kubectl_or_error()+ if guard:+ return guard+ cluster = _cluster_or_404(cluster_id)+ if not cluster:+ return jsonify({'error': 'Cluster not found'}), 404+ namespace = request.args.get('namespace', 'all')+ kind = request.args.get('kind', 'deployment')+ return _kubectl_call(lambda: {'items': cluster_service.get_workloads(cluster, namespace, kind)})+++@k8s_bp.route('/clusters/<int:cluster_id>/pods/<namespace>/<pod>/logs', methods=['GET'])+@viewer_required+def pod_logs(cluster_id, namespace, pod):+ guard = _kubectl_or_error()+ if guard:+ return guard+ cluster = _cluster_or_404(cluster_id)+ if not cluster:+ return jsonify({'error': 'Cluster not found'}), 404+ container = request.args.get('container')+ tail = request.args.get('tail', 200)+ return _kubectl_call(lambda: {'logs': cluster_service.get_pod_logs(cluster, namespace, pod, container, tail)})+++# --------------------------------------------------------------------------+# Mutations (admin + kubectl required)+# --------------------------------------------------------------------------+def _mutation_setup(cluster_id):+ guard = _kubectl_or_error()+ if guard:+ return None, guard+ cluster = _cluster_or_404(cluster_id)+ if not cluster:+ return None, (jsonify({'error': 'Cluster not found'}), 404)+ return cluster, None+++@k8s_bp.route('/clusters/<int:cluster_id>/deployments/<namespace>/<name>/scale', methods=['POST'])+@admin_required+def scale(cluster_id, namespace, name):+ cluster, err = _mutation_setup(cluster_id)+ if err:+ return err+ data = request.get_json(silent=True) or {}+ return _kubectl_call(lambda: cluster_service.scale_deployment(cluster, namespace, name, data.get('replicas', 0)))+++@k8s_bp.route('/clusters/<int:cluster_id>/deployments/<namespace>/<name>/restart', methods=['POST'])+@admin_required+def restart(cluster_id, namespace, name):+ cluster, err = _mutation_setup(cluster_id)+ if err:+ return err+ return _kubectl_call(lambda: cluster_service.restart_deployment(cluster, namespace, name))+++@k8s_bp.route('/clusters/<int:cluster_id>/delete-resource', methods=['POST'])+@admin_required+def delete_resource(cluster_id):+ cluster, err = _mutation_setup(cluster_id)+ if err:+ return err+ data = request.get_json(silent=True) or {}+ return _kubectl_call(lambda: cluster_service.delete_resource(+ cluster, data.get('kind'), data.get('name'), data.get('namespace')))+++@k8s_bp.route('/clusters/<int:cluster_id>/apply', methods=['POST'])+@admin_required+def apply(cluster_id):+ cluster, err = _mutation_setup(cluster_id)+ if err:+ return err+ data = request.get_json(silent=True) or {}+ return _kubectl_call(lambda: cluster_service.apply_manifest(cluster, data.get('manifest')))diff --git a/backend/app/plugins/serverkit-k8s/kubectl_service.py b/backend/app/plugins/serverkit-k8s/kubectl_service.pynew file mode 100644index 00000000..5824a40e--- /dev/null+++ b/backend/app/plugins/serverkit-k8s/kubectl_service.py@@ -0,0 +1,127 @@+"""Low-level ``kubectl`` engine for the serverkit-k8s extension.++Every cluster operation runs the real ``kubectl`` binary against a per-cluster+kubeconfig that we materialize to a private temp file for the duration of one+call and delete immediately after (never left on disk between calls). This keeps+the panel host free of any standing cluster credentials.++Nothing here is Linux-specific -- ``kubectl`` runs on any OS -- so the extension+is not platform-gated. The temp-file ``chmod 0600`` is guarded with+``os.name != 'nt'`` per the repo's platform rule.+"""+import json+import logging+import os+import subprocess+import tempfile++logger = logging.getLogger(__name__)++KUBECTL_BIN = 'kubectl'+DEFAULT_TIMEOUT = 30+++class KubectlError(RuntimeError):+ """Raised when a kubectl invocation fails (non-zero exit)."""++ def __init__(self, message, returncode=None, stderr=None):+ super().__init__(message)+ self.returncode = returncode+ self.stderr = stderr+++def is_available():+ """Return True if the ``kubectl`` binary is on the host."""+ try:+ from app.utils.system import is_command_available+ return is_command_available(KUBECTL_BIN)+ except Exception: # pragma: no cover - fall back to a direct probe+ from shutil import which+ return which(KUBECTL_BIN) is not None+++def _write_kubeconfig(kubeconfig_text):+ """Write *kubeconfig_text* to a private temp file and return its path."""+ fd, path = tempfile.mkstemp(prefix='sk8s-', suffix='.yaml')+ try:+ with os.fdopen(fd, 'w', encoding='utf-8') as fh:+ fh.write(kubeconfig_text or '')+ if os.name != 'nt':+ os.chmod(path, 0o600)+ except Exception:+ _safe_unlink(path)+ raise+ return path+++def _safe_unlink(path):+ try:+ if path and os.path.exists(path):+ os.unlink(path)+ except OSError as e: # pragma: no cover - best effort cleanup+ logger.warning('serverkit-k8s: could not remove temp kubeconfig %s: %s', path, e)+++def build_argv(cluster, args):+ """Return the full ``kubectl`` argv for *args* against *cluster*.++ Separated out so tests can assert on argv construction without running the+ binary. The ``--kubeconfig`` path is appended by :func:`run` since it is only+ known once the temp file is written.+ """+ argv = [KUBECTL_BIN]+ if getattr(cluster, 'context', None):+ argv += ['--context', cluster.context]+ return argv + list(args)+++def run(cluster, args, timeout=DEFAULT_TIMEOUT, input_text=None):+ """Run ``kubectl <args>`` against *cluster* and return stdout as a string.++ Raises :class:`KubectlError` on a non-zero exit or missing binary.+ """+ if not is_available():+ raise KubectlError('kubectl is not installed on the panel host.')++ kubeconfig_text = cluster.get_kubeconfig() if hasattr(cluster, 'get_kubeconfig') else cluster+ path = _write_kubeconfig(kubeconfig_text)+ try:+ argv = build_argv(cluster, args)+ argv += ['--kubeconfig', path]+ try:+ result = subprocess.run(+ argv,+ capture_output=True,+ text=True,+ timeout=timeout,+ input=input_text,+ )+ except subprocess.TimeoutExpired as e:+ raise KubectlError(f'kubectl timed out after {timeout}s') from e+ except (OSError, subprocess.SubprocessError) as e:+ raise KubectlError(f'kubectl could not be executed: {e}') from e++ if result.returncode != 0:+ stderr = (result.stderr or '').strip()+ raise KubectlError(+ stderr or f'kubectl exited with code {result.returncode}',+ returncode=result.returncode,+ stderr=stderr,+ )+ return result.stdout or ''+ finally:+ _safe_unlink(path)+++def run_json(cluster, args, timeout=DEFAULT_TIMEOUT):+ """Run a kubectl command that emits JSON and return the parsed object.++ The caller is expected to include ``-o json`` (or a get with it) in *args*.+ """+ out = run(cluster, args, timeout=timeout)+ if not out.strip():+ return {}+ try:+ return json.loads(out)+ except ValueError as e:+ raise KubectlError(f'kubectl returned unparseable JSON: {e}') from ediff --git a/backend/app/plugins/serverkit-k8s/lifecycle.py b/backend/app/plugins/serverkit-k8s/lifecycle.pynew file mode 100644index 00000000..c999df1d--- /dev/null+++ b/backend/app/plugins/serverkit-k8s/lifecycle.py@@ -0,0 +1,32 @@+"""Install / uninstall lifecycle hooks (serverkit-k8s extension).++Contract (per the plugin SDK): a single positional arg -- the InstalledPlugin+row. ``on_uninstall`` also accepts a ``purge`` flag. Everything here is wrapped+so a hook failure never blocks install/uninstall.++There is no engine to provision: the extension only talks to *remote* clusters+through kubectl, so install just registers a notification event and uninstall is+a no-op (the ``ext_serverkit_k8s_*`` table is dropped by the platform on+``--purge``).+"""+import logging++logger = logging.getLogger(__name__)+++def on_install(plugin):+ """Register the extension's notification events. Best-effort."""+ try:+ from app.plugins_sdk import notify+ notify.register_event(+ 'k8s.cluster_unreachable',+ 'A Kubernetes cluster became unreachable',+ template='generic', severity='warning', category='system')+ logger.info('serverkit-k8s installed: notification events registered')+ except Exception as e: # noqa: BLE001+ logger.warning('serverkit-k8s on_install hook error: %s', e)+++def on_uninstall(plugin, purge=False):+ """Nothing to tear down -- clusters are remote and hold no local resources."""+ logger.info('serverkit-k8s on_uninstall (purge=%s): no local resources to remove', purge)diff --git a/backend/app/plugins/serverkit-k8s/models.py b/backend/app/plugins/serverkit-k8s/models.pynew file mode 100644index 00000000..80a7741a--- /dev/null+++ b/backend/app/plugins/serverkit-k8s/models.py@@ -0,0 +1,101 @@+"""Data models for the serverkit-k8s extension.++A :class:`K8sCluster` row is a saved *connection* to an external Kubernetes+cluster: a friendly name, the cluster's **kubeconfig** (stored encrypted with the+panel key), an optional context to select within that kubeconfig, a default flag,+and a small cache of the last reachability probe so the Overview can render+without blocking on a live ``kubectl`` call.++The panel host is never assumed to be a cluster member. All cluster access goes+through ``kubectl --kubeconfig <the decrypted blob>`` (see ``kubectl_service``),+so the only secret we hold is the kubeconfig, and it is **never** returned by+:meth:`K8sCluster.to_dict`.++Tables are namespaced ``ext_serverkit_k8s_*`` (dash -> underscore) per the+extension convention, so ``--purge`` on uninstall drops exactly these.++Registration: importing this module defines the table on the shared metadata as+a side effect; the manifest's ``models: "models:register"`` then calls+:func:`register` (a no-op passthrough) and the platform runs ``db.create_all()``.+"""+import json+from datetime import datetime++from app import db++try:+ from app.utils.crypto import encrypt_secret, decrypt_secret_safe+except Exception: # pragma: no cover - crypto util should always be present+ encrypt_secret = None+ decrypt_secret_safe = None+++class K8sCluster(db.Model):+ __tablename__ = 'ext_serverkit_k8s_clusters'++ id = db.Column(db.Integer, primary_key=True)+ name = db.Column(db.String(255), unique=True, nullable=False, index=True)++ # Encrypted kubeconfig YAML. Read/written only through the helpers below so+ # the plaintext never lands in a column or a log line.+ kubeconfig_encrypted = db.Column(db.Text, nullable=False)++ # Optional context to select inside the kubeconfig (kubectl --context).+ context = db.Column(db.String(255), nullable=True)++ is_default = db.Column(db.Boolean, default=False, nullable=False)++ # Cached result of the last reachability probe (test_connection).+ last_reachable = db.Column(db.Boolean, nullable=True)+ last_status = db.Column(db.Text, nullable=True) # JSON: {server_version, error}+ last_checked_at = db.Column(db.DateTime, nullable=True)++ created_at = db.Column(db.DateTime, default=datetime.utcnow)+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)++ # --- secret helpers -------------------------------------------------+ def set_kubeconfig(self, plaintext):+ """Encrypt and store a kubeconfig YAML string."""+ if encrypt_secret is None:+ # No key configured: store as-is so dev boxes still work. Encryption+ # is expected in any real deployment.+ self.kubeconfig_encrypted = plaintext or ''+ else:+ self.kubeconfig_encrypted = encrypt_secret(plaintext or '')++ def get_kubeconfig(self):+ """Return the decrypted kubeconfig YAML string."""+ if not self.kubeconfig_encrypted:+ return ''+ if decrypt_secret_safe is None:+ return self.kubeconfig_encrypted+ return decrypt_secret_safe(self.kubeconfig_encrypted)++ # --- serialization --------------------------------------------------+ def to_dict(self):+ status = None+ if self.last_status:+ try:+ status = json.loads(self.last_status)+ except (ValueError, TypeError):+ status = None+ return {+ 'id': self.id,+ 'name': self.name,+ 'context': self.context,+ 'is_default': self.is_default,+ 'last_reachable': self.last_reachable,+ 'status': status,+ 'last_checked_at': self.last_checked_at.isoformat() if self.last_checked_at else None,+ 'created_at': self.created_at.isoformat() if self.created_at else None,+ 'updated_at': self.updated_at.isoformat() if self.updated_at else None,+ }+++def register(db): # noqa: A002 - signature dictated by the platform (fn(db))+ """No-op passthrough required by the manifest ``models: "models:register"``.++ Importing this module already defined the table on ``db.metadata``; the+ platform creates it. Nothing else to do here.+ """+ return [K8sCluster]diff --git a/backend/app/plugins/serverkit-k8s/plugin.json b/backend/app/plugins/serverkit-k8s/plugin.jsonnew file mode 100644index 00000000..3450ea1c--- /dev/null+++ b/backend/app/plugins/serverkit-k8s/plugin.json@@ -0,0 +1,56 @@+{+ "name": "serverkit-k8s",+ "display_name": "Kubernetes",+ "version": "1.0.0",+ "description": "Manage remote Kubernetes clusters from the panel. Add a cluster by pasting its kubeconfig (stored encrypted, one row per cluster) and the extension shells out to kubectl to show cluster health, nodes, namespaces, workloads, pods with live logs, services, and ingresses, plus scale, restart, delete, and apply-manifest actions. Most panels never touch Kubernetes, so it ships as an opt-in extension and needs no cluster on the panel host itself.",+ "author": "ServerKit",+ "license": "MIT",+ "category": "deployment",+ "homepage": "https://github.com/jhd3197/ServerKit",+ "permissions": [+ "shell",+ "filesystem",+ "network"+ ],+ "min_panel_version": "1.7.0",+ "entry_point": "k8s:k8s_bp",+ "url_prefix": "/api/v1/k8s",+ "models": "models:register",+ "lifecycle": {+ "install": "lifecycle:on_install",+ "uninstall": "lifecycle:on_uninstall"+ },+ "icon": "<circle cx=\"12\" cy=\"12\" r=\"8\"/><circle cx=\"12\" cy=\"12\" r=\"2\"/><path d=\"M12 2v7.5\"/><path d=\"m19 5-5.23 5.23\"/><path d=\"M22 12h-7.5\"/><path d=\"m19 19-5.23-5.23\"/><path d=\"M12 14.5V22\"/><path d=\"M10.23 13.77 5 19\"/><path d=\"M9.5 12H2\"/><path d=\"M10.23 10.23 5 5\"/>",+ "contributions": {+ "nav": [+ {+ "id": "k8s",+ "label": "Kubernetes",+ "route": "/k8s",+ "category": "infrastructure",+ "icon": "<circle cx=\"12\" cy=\"12\" r=\"8\"/><circle cx=\"12\" cy=\"12\" r=\"2\"/><path d=\"M12 2v7.5\"/><path d=\"m19 5-5.23 5.23\"/><path d=\"M22 12h-7.5\"/><path d=\"m19 19-5.23-5.23\"/><path d=\"M12 14.5V22\"/><path d=\"M10.23 13.77 5 19\"/><path d=\"M9.5 12H2\"/><path d=\"M10.23 10.23 5 5\"/>"+ }+ ],+ "routes": [+ {+ "path": "k8s",+ "component": "K8sPage"+ },+ {+ "path": "k8s/:tab",+ "component": "K8sPage"+ }+ ],+ "page_titles": {+ "/k8s": "Kubernetes"+ },+ "command_palette": [+ {+ "label": "Kubernetes",+ "path": "/k8s",+ "category": "Pages",+ "keywords": "k8s kubernetes kubectl cluster node namespace pod deployment workload statefulset daemonset service ingress scale restart apply kubeconfig"+ }+ ]+ }+}\ No newline at end of filediff --git a/frontend/src/plugins/plugins-manifest.json b/frontend/src/plugins/plugins-manifest.jsonindex 2e7fa837..dfd5c1eb 100644--- a/frontend/src/plugins/plugins-manifest.json+++ b/frontend/src/plugins/plugins-manifest.json@@ -15,6 +15,28 @@"version": "1.0.0","frontend_entry": "","path": "serverkit-cloudflare-ops"+ },+ {+ "name": "serverkit-tramo",+ "slug": "serverkit-tramo",+ "display_name": "Automations",+ "version": "1.0.0",+ "frontend_entry": "",+ "path": "serverkit-tramo",+ "styles": [+ "plugins/serverkit-tramo/styles/tramo-automations.scss"+ ]+ },+ {+ "name": "serverkit-k8s",+ "slug": "serverkit-k8s",+ "display_name": "Kubernetes",+ "version": "1.0.0",+ "frontend_entry": "",+ "path": "serverkit-k8s",+ "styles": [+ "plugins/serverkit-k8s/styles/k8s.scss"+ ]}]}\ No newline at end of filediff --git a/frontend/src/plugins/serverkit-k8s/plugin.json b/frontend/src/plugins/serverkit-k8s/plugin.jsonindex 5e8791e6..3450ea1c 100644--- a/frontend/src/plugins/serverkit-k8s/plugin.json+++ b/frontend/src/plugins/serverkit-k8s/plugin.json@@ -53,4 +53,4 @@}]}-}+}\ No newline at end of file