vantage-cli 0.1.1__py3-none-any.whl

vantage_cli/apps/microk8s/README.md

@@ -0,0 +1,47 @@
+This app deploys the slurm-operator to microk8s for a fully functional slurm on k8s on localhost.
+
+For more on the slurm-operator see: https://github.com/SlinkyProject/slurm-operator
+For more on microk8s see <https://microk8s>
+
+### Install and Configure microk8s
+```bash
+sudo snap install microk8s --channel 1.29-strict/stable
+
+sudo microk8s.enable hostpath-storage
+sudo microk8s.enable dns
+sudo microk8s.enable metallb:10.64.140.43-10.64.140.49
+```
+
+### install slurm operator
+```bash
+sudo microk8s.helm repo add jetstack https://charts.jetstack.io
+sudo microk8s.helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
+sudo microk8s.helm repo update
+
+sudo microk8s.helm install cert-manager jetstack/cert-manager --namespace cert-manager --create-namespace
+sudo microk8s.helm install prometheus prometheus-community/kube-prometheus-stack --namespace prometheus --create-namespace
+sudo microk8s.helm install slurm-operator-crds oci://ghcr.io/slinkyproject/charts/slurm-operator-crds
+
+curl -L https://raw.githubusercontent.com/SlinkyProject/slurm-operator/refs/tags/v0.4.0/helm/slurm-operator/values.yaml -o values-operator.yaml
+sudo microk8s.helm install slurm-operator oci://ghcr.io/slinkyproject/charts/slurm-operator --values=values-operator.yaml --version=0.4.0 --namespace=slinky --create-namespace
+
+microk8s.kubectl --namespace=slinky get pods
+
+# Install SLURM Cluster
+curl -L https://raw.githubusercontent.com/SlinkyProject/slurm-operator/refs/tags/v0.4.0/helm/slurm/values.yaml -o values-slurm.yaml
+
+sudo microk8s.helm install slurm oci://ghcr.io/slinkyproject/charts/slurm --values=values-slurm.yaml --version=0.4.0 --namespace=slurm --create-namespace
+
+microk8s.kubectl --namespace=slurm get pods
+```
+
+
+### Testing
+```bash
+SLURM_LOGIN_IP="$(kubectl get services -n slurm slurm-login-slinky -o jsonpath='{.status.loadBalancer.ingress[0].ip}')"
+SLURM_LOGIN_PORT="$(kubectl get services -n slurm slurm-login-slinky -o jsonpath='{.status.loadBalancer.ingress[0].ports[0].port}')"
+## Assuming your public SSH key was configured in `login.rootSshAuthorizedKeys`.
+ssh -p ${SLURM_LOGIN_PORT:-22} root@${SLURM_LOGIN_IP}
+## Assuming SSSD is configured.
+ssh -p ${SLURM_LOGIN_PORT:-22} ${USER}@${SLURM_LOGIN_IP}
+```

vantage_cli/apps/microk8s/__init__.py

@@ -0,0 +1,3 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""The vantage-cli application for deploying slurm to microk8s on localhost."""

vantage_cli/apps/microk8s/app.py

@@ -0,0 +1,301 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""MicroK8s application support for deploying the Slurm Operator & Slurm cluster.
+
+Implements the manual steps documented in the local README:
+
+1. Enable required MicroK8s addons (hostpath-storage, dns, metallb)
+2. Add Helm repositories (jetstack, prometheus-community)
+3. Install cert-manager, Prometheus stack, Slurm Operator CRDs
+4. Download values files & install Slurm Operator
+5. Install a Slurm cluster release
+
+Notes:
+- These steps are inherently idempotent; failures on already-installed/ enabled
+  components are treated as warnings (not fatal) when safe.
+- This command invokes system binaries (sudo microk8s.* & curl). The user must
+  have the appropriate privileges. We intentionally keep the logic simple and
+  transparent; advanced lifecycle management belongs in a dedicated orchestrator.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import typer
+from loguru import logger
+from rich.console import Console
+from rich.panel import Panel
+from typing_extensions import Annotated
+
+from vantage_cli.apps.common import (
+    validate_client_credentials,
+    validate_cluster_data,
+)
+from vantage_cli.config import attach_settings
+
+DEFAULT_METALLB_RANGE = "10.64.140.43-10.64.140.49"
+SLURM_OPERATOR_VERSION = "0.4.0"
+SLURM_OPERATOR_REPO_BASE = (
+    "https://raw.githubusercontent.com/SlinkyProject/slurm-operator/refs/tags"
+)
+
+
+def _run(
+    cmd: list[str],
+    console: Console,
+    *,
+    check: bool = True,
+    allow_fail: bool = False,
+    env: Optional[dict[str, str]] = None,
+) -> subprocess.CompletedProcess:
+    """Run a shell command (no shell=True) and optionally allow failure.
+
+    Args:
+        cmd: Command & arguments
+        console: Rich console for user feedback
+        check: If True raise on non‑zero exit unless allow_fail
+        allow_fail: If True convert non‑zero exit into warning
+        env: Optional environment overrides
+    """
+    console.print(f"[dim]$ {' '.join(cmd)}[/dim]")
+    try:
+        cp = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            env=env or os.environ.copy(),
+            check=False,
+        )
+    except FileNotFoundError:
+        console.print(f"[red]Command not found: {cmd[0]}[/red]")
+        if check and not allow_fail:
+            raise typer.Exit(code=1)
+        return subprocess.CompletedProcess(cmd, 127, "")
+
+    if cp.returncode != 0 and check and not allow_fail:
+        console.print(f"[red]Command failed (exit {cp.returncode}): {' '.join(cmd)}[/red]")
+        console.print(cp.stdout)
+        raise typer.Exit(code=cp.returncode)
+
+    if cp.returncode != 0 and allow_fail:
+        console.print(
+            f"[yellow]Warning: command returned {cp.returncode} (continuing): {' '.join(cmd)}[/yellow]"
+        )
+        logger.warning(
+            f"Non‑fatal command failure: {' '.join(cmd)} -> {cp.returncode}\n{cp.stdout}"
+        )
+    return cp
+
+
+async def deploy(
+    ctx: typer.Context,
+    cluster_data: Optional[Dict[str, Any]] = None,
+    *,
+    metallb_range: str = DEFAULT_METALLB_RANGE,
+) -> None:
+    """Deploy Slurm Operator & Slurm cluster onto MicroK8s.
+
+    This will perform a sequence of imperative steps. It aims for a *best effort*
+    deployment suitable for local development / experimentation—not production.
+    """
+    console = Console()
+    console.print(Panel("Slurm Operator on MicroK8s"))
+    console.print("Deploying slurm-operator & slurm cluster on MicroK8s...")
+
+    microk8s_bin = shutil.which("microk8s")
+    if not microk8s_bin:
+        console.print(
+            "[red]microk8s binary not found in PATH. Please install microk8s first.[/red]"
+        )
+        raise typer.Exit(code=1)
+
+    # Validate cluster data & surface credentials (even if not strictly needed yet)
+    if cluster_data:
+        cluster_data = validate_cluster_data(cluster_data, console)
+        validate_client_credentials(cluster_data, console)
+
+    # 1. Wait for microk8s to be ready
+    _run(["sudo", microk8s_bin, "status", "--wait-ready"], console, allow_fail=False)
+
+    # 2. Enable core addons (idempotent; allow failures for already enabled)
+    _run(["sudo", microk8s_bin, "enable", "hostpath-storage"], console, allow_fail=True)
+    _run(["sudo", microk8s_bin, "enable", "dns"], console, allow_fail=True)
+    _run(["sudo", microk8s_bin, "enable", f"metallb:{metallb_range}"], console, allow_fail=True)
+
+    # 3. Helm repositories (microk8s embeds helm3 as 'microk8s.helm')
+    helm_cmd = shutil.which("microk8s.helm") or "microk8s.helm"
+    _run(
+        ["sudo", helm_cmd, "repo", "add", "jetstack", "https://charts.jetstack.io"],
+        console,
+        allow_fail=True,
+    )
+    _run(
+        [
+            "sudo",
+            helm_cmd,
+            "repo",
+            "add",
+            "prometheus-community",
+            "https://prometheus-community.github.io/helm-charts",
+        ],
+        console,
+        allow_fail=True,
+    )
+    _run(["sudo", helm_cmd, "repo", "update"], console, allow_fail=True)
+
+    # 4. Install cert-manager (CRDs handled by chart flags)
+    _run(
+        [
+            "sudo",
+            helm_cmd,
+            "install",
+            "cert-manager",
+            "jetstack/cert-manager",
+            "--namespace",
+            "cert-manager",
+            "--create-namespace",
+            "--set",
+            "installCRDs=true",
+        ],
+        console,
+        allow_fail=True,
+    )
+
+    # 5. Install Prometheus stack for metrics
+    _run(
+        [
+            "sudo",
+            helm_cmd,
+            "install",
+            "prometheus",
+            "prometheus-community/kube-prometheus-stack",
+            "--namespace",
+            "prometheus",
+            "--create-namespace",
+        ],
+        console,
+        allow_fail=True,
+    )
+
+    # 6. Install Slurm Operator CRDs
+    _run(
+        [
+            "sudo",
+            helm_cmd,
+            "install",
+            "slurm-operator-crds",
+            "oci://ghcr.io/slinkyproject/charts/slurm-operator-crds",
+        ],
+        console,
+        allow_fail=True,
+    )
+
+    # 7. Download operator & slurm values (so user can inspect / tweak) then install
+    work_dir = Path.cwd() / "microk8s-slurm"
+    work_dir.mkdir(exist_ok=True)
+    operator_values = work_dir / "values-operator.yaml"
+    slurm_values = work_dir / "values-slurm.yaml"
+
+    operator_values_url = (
+        f"{SLURM_OPERATOR_REPO_BASE}/v{SLURM_OPERATOR_VERSION}/helm/slurm-operator/values.yaml"
+    )
+    slurm_values_url = (
+        f"{SLURM_OPERATOR_REPO_BASE}/v{SLURM_OPERATOR_VERSION}/helm/slurm/values.yaml"
+    )
+
+    if not operator_values.exists():
+        _run(
+            ["curl", "-L", operator_values_url, "-o", str(operator_values)],
+            console,
+            allow_fail=False,
+        )
+    else:
+        console.print(f"[green]Using existing {operator_values}[/green]")
+    if not slurm_values.exists():
+        _run(["curl", "-L", slurm_values_url, "-o", str(slurm_values)], console, allow_fail=False)
+    else:
+        console.print(f"[green]Using existing {slurm_values}[/green]")
+
+    _run(
+        [
+            "sudo",
+            helm_cmd,
+            "install",
+            "slurm-operator",
+            "oci://ghcr.io/slinkyproject/charts/slurm-operator",
+            f"--values={operator_values}",
+            f"--version={SLURM_OPERATOR_VERSION}",
+            "--namespace",
+            "slinky",
+            "--create-namespace",
+        ],
+        console,
+        allow_fail=True,
+    )
+
+    # 8. Install Slurm cluster
+    _run(
+        [
+            "sudo",
+            helm_cmd,
+            "install",
+            "slurm",
+            "oci://ghcr.io/slinkyproject/charts/slurm",
+            f"--values={slurm_values}",
+            f"--version={SLURM_OPERATOR_VERSION}",
+            "--namespace",
+            "slurm",
+            "--create-namespace",
+        ],
+        console,
+        allow_fail=True,
+    )
+
+    console.print(
+        "[green]Deployment steps executed. Pods may take a few minutes to become ready.[/green]"
+    )
+    console.print("Check status with: sudo microk8s.kubectl get pods -A | grep -E 'slinky|slurm'")
+
+
+@attach_settings
+async def deploy_command(
+    ctx: typer.Context,
+    cluster_name: Annotated[
+        Optional[str],
+        typer.Option(
+            "--cluster-name",
+            help="Existing cluster name to fetch credentials (optional)",
+        ),
+    ] = None,
+    metallb_range: Annotated[
+        str,
+        typer.Option(
+            "--metallb-range",
+            help="Address range to configure for MetalLB (start-end)",
+            show_default=True,
+        ),
+    ] = DEFAULT_METALLB_RANGE,
+) -> None:
+    """CLI entrypoint for deploying MicroK8s Slurm stack."""
+    cluster_data = None
+    if cluster_name:
+        try:
+            from vantage_cli.commands.clusters import (
+                utils as cluster_utils,  # local import to avoid cycles
+            )
+
+            cluster_data = await cluster_utils.get_cluster_by_name(
+                ctx=ctx, cluster_name=cluster_name
+            )
+        except Exception as e:  # noqa: BLE001
+            logger.warning(f"Could not retrieve cluster '{cluster_name}': {e}")
+    await deploy(ctx=ctx, cluster_data=cluster_data, metallb_range=metallb_range)
+
+
+__all__ = ["deploy", "deploy_command"]

vantage_cli/apps/multipass_singlenode/__init__.py

@@ -0,0 +1,12 @@
+"""Multipass single-node deployment app package."""
+
+from vantage_cli import AsyncTyper
+
+from .app import deploy_command
+
+multipass_singlenode_app = AsyncTyper(
+    name="multipass-singlenode",
+    help="Multipass single-node application commands.",
+)
+
+multipass_singlenode_app.command("deploy")(deploy_command)

vantage_cli/apps/multipass_singlenode/app.py

@@ -0,0 +1,173 @@
+"""Multipass singlenode application support."""
+
+import os
+import subprocess
+from pathlib import Path
+from shutil import which
+from typing import Any, Dict, Optional
+
+import typer
+from loguru import logger
+from rich.console import Console
+from rich.panel import Panel
+from typing_extensions import Annotated
+
+from vantage_cli.apps.common import (
+    require_client_secret,
+    validate_client_credentials,
+    validate_cluster_data,
+)
+from vantage_cli.apps.templates import CloudInitTemplate, DeploymentContext
+from vantage_cli.config import attach_settings
+from vantage_cli.constants import (
+    ERROR_MULTIPASS_NOT_FOUND,
+    MULTIPASS_CLOUD_IMAGE_DEST,
+    MULTIPASS_CLOUD_IMAGE_LOCAL,
+    MULTIPASS_CLOUD_IMAGE_URL,
+)
+
+# Note: Cloud-init generation now handled by centralized template engine
+# See vantage_cli/apps/templates.py for CloudInitTemplate and DeploymentContext
+
+
+async def deploy(ctx: typer.Context, cluster_data: Optional[Dict[str, Any]] = None) -> None:
+    """Deploy a single-node SLURM cluster using Multipass.
+
+    Args:
+        ctx: Typer context containing settings and configuration
+        cluster_data: Dictionary containing cluster configuration including client credentials
+
+    Raises:
+        typer.Exit: If deployment fails due to missing dependencies or invalid configuration
+    """
+    console = Console()
+    console.print(Panel("Multipass Singlenode Application"))
+    console.print("Deploying multipass singlenode application...")
+
+    multipass = which("multipass")  # Ensure multipass is installed
+    if not multipass:
+        console.print(ERROR_MULTIPASS_NOT_FOUND)
+        console.print(f"{os.environ.get('PATH')}")  # Print the PATH environment variable
+        raise typer.Exit(code=1)
+
+        # Validate cluster data and extract credentials
+    cluster_data = validate_cluster_data(cluster_data, console)
+    client_id, _ = validate_client_credentials(cluster_data, console)
+
+    # Extract cluster name from cluster data
+    cluster_name = cluster_data.get("name", "unknown-cluster")
+
+    # Get client secret (import locally to avoid circular import)
+    from vantage_cli.commands.clusters import utils as cluster_utils
+
+    client_secret = await cluster_utils.get_cluster_client_secret(ctx=ctx, client_id=client_id)
+    client_secret = require_client_secret(client_secret, console)
+
+    logger.debug("Client secret obtained (or placeholder used).")
+
+    # Use jupyterhub_token from cluster data if available, otherwise generate a default
+    jupyterhub_token = None
+    if cluster_data and "creationParameters" in cluster_data:
+        if jupyterhub_token_data := cluster_data["creationParameters"].get("jupyterhub_token"):
+            jupyterhub_token = jupyterhub_token_data
+    if not jupyterhub_token:
+        jupyterhub_token = "default-token-for-testing"
+
+    logger.debug(f"Using JupyterHub token: {jupyterhub_token[:10]}...")
+
+    # Create deployment context for template engine
+    deployment_context = DeploymentContext(
+        cluster_name=cluster_name,
+        client_id=client_id,
+        client_secret=client_secret,
+        oidc_domain=ctx.obj.settings.oidc_domain,
+        oidc_base_url=ctx.obj.settings.oidc_base_url,
+        base_api_url=ctx.obj.settings.api_base_url,
+        tunnel_api_url=ctx.obj.settings.tunnel_api_url,
+        jupyterhub_token=jupyterhub_token,
+    )
+
+    instance_name = f"vantage-multipass-singlenode-{client_id.split('-')[0]}"
+    console.print(f"Launching: {instance_name}")
+
+    shared_dir = Path.home() / "multipass-singlenode" / "shared"
+    shared_dir.mkdir(parents=True, exist_ok=True)
+    shared_dir.chmod(0o755)  # Fixed: use Path.chmod instead of shutil.chmod
+
+    # Use a standard Ubuntu image for now since the custom Vantage image may not be available
+    image_origin = MULTIPASS_CLOUD_IMAGE_URL
+    if MULTIPASS_CLOUD_IMAGE_LOCAL.exists():
+        image_origin = f"file://{MULTIPASS_CLOUD_IMAGE_LOCAL}"
+    elif MULTIPASS_CLOUD_IMAGE_DEST.exists():
+        image_origin = f"file://{MULTIPASS_CLOUD_IMAGE_DEST}"
+    # Note: Fallback to standard Ubuntu image if custom image not available
+
+    try:
+        # Get the number of CPUs available
+        cpu_count = str(os.cpu_count() or 2)  # Default to 2 if unable to determine
+
+        p = subprocess.Popen(
+            [
+                "multipass",
+                "launch",
+                "--verbose",
+                f"-c{cpu_count}",
+                "-m4GB",
+                "-d10GB",
+                "--mount",
+                f"{shared_dir}:/shared",
+                "-n",
+                instance_name,
+                "--cloud-init",
+                "-",  # Use stdin for cloud-init
+                image_origin,
+            ],
+            stdin=subprocess.PIPE,
+        )
+        # Generate cloud-init configuration using template engine
+        cloud_init_template = CloudInitTemplate()
+        cloud_init_config = cloud_init_template.generate_multipass_config(deployment_context)
+        p.communicate(input=cloud_init_config.encode("utf-8"))
+
+        if p.returncode == 0:
+            console.print(f"[green]Successfully launched instance: {instance_name}[/green]")
+            console.print("Use 'multipass list' to see the instance status.")
+            console.print(f"Use 'multipass shell {instance_name}' to access the instance shell.")
+            console.print("Remember to set up your SSH keys for passwordless access if needed.")
+            console.print(
+                "It may take a few minutes for all services to start inside the instance."
+            )
+        else:
+            console.print(
+                f"[red]Error launching multipass instance: return code {p.returncode}[/red]"
+            )
+            raise typer.Exit(code=1)
+
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]Error launching multipass instance: {e}[/red]")
+        raise typer.Exit(code=1)
+
+
+# Typer CLI commands
+@attach_settings
+async def deploy_command(
+    ctx: typer.Context,
+    cluster_name: Annotated[
+        str,
+        typer.Argument(help="Name of the cluster to deploy"),
+    ],
+) -> None:
+    """Deploy a Vantage Multipass Singlenode SLURM cluster."""
+    console = Console()
+    console.print(Panel("Multipass Singlenode SLURM Application"))
+    console.print("Deploying multipass singlenode slurm application...")
+    # Import locally to avoid circular import
+    from vantage_cli.commands.clusters import utils as cluster_utils
+
+    cluster_data = await cluster_utils.get_cluster_by_name(ctx=ctx, cluster_name=cluster_name)
+
+    if not cluster_data:
+        console.print("[red]Error: No cluster data found.[/red]")
+        raise typer.Exit(code=1)
+
+    await deploy(ctx=ctx, cluster_data=cluster_data)