konduktor-nightly 0.1.0.dev20250825104841__tar.gz → 0.1.0.dev20250827104553__tar.gz

{konduktor_nightly-0.1.0.dev20250825104841 → konduktor_nightly-0.1.0.dev20250827104553}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: konduktor-nightly
-Version: 0.1.0.dev20250825104841
+Version: 0.1.0.dev20250827104553
 Summary: GPU Cluster Health Management
 Author: Andrew Aikawa
 Author-email: asai@berkeley.edu

{konduktor_nightly-0.1.0.dev20250825104841 → konduktor_nightly-0.1.0.dev20250827104553}/konduktor/__init__.py

@@ -11,7 +11,7 @@ from konduktor.task import Task
 __all__ = ['launch', 'Resources', 'Task', 'Serving']
 
 # Replaced with the current commit when building the wheels.
-_KONDUKTOR_COMMIT_SHA = 'face26aca22b99192e740dca4875261fcffa2a55'
+_KONDUKTOR_COMMIT_SHA = 'cb72c75ad328b535768794b5979a5ec56edb3d8e'
 os.makedirs(os.path.expanduser('~/.konduktor'), exist_ok=True)
 
 
@@ -45,5 +45,5 @@ def _get_git_commit():
 
 
 __commit__ = _get_git_commit()
-__version__ = '1.0.0.dev0.1.0.dev20250825104841'
+__version__ = '1.0.0.dev0.1.0.dev20250827104553'
 __root_dir__ = os.path.dirname(os.path.abspath(__file__))

{konduktor_nightly-0.1.0.dev20250825104841 → konduktor_nightly-0.1.0.dev20250827104553}/konduktor/backends/deployment.py

@@ -163,6 +163,14 @@ class DeploymentBackend(backend.Backend):
                 dryrun=dryrun,
             )
 
+            # Apoxy resources for general deployments only when endpoint: trainy
+            if deployment_utils.get_endpoint_type_from_config() == 'trainy':
+                deployment_utils.create_apoxy_resources(
+                    namespace=namespace,
+                    task=task,
+                    dryrun=dryrun,
+                )
+
         if not dryrun and not detach_run:
             with ux_utils.print_exception_no_traceback():
                 with rich_utils.safe_status(

{konduktor_nightly-0.1.0.dev20250825104841 → konduktor_nightly-0.1.0.dev20250827104553}/konduktor/backends/deployment_utils.py

@@ -2,6 +2,7 @@
 
 import json
 import os
+import random
 import tempfile
 import typing
 from typing import Any, Dict, List, Optional, Tuple
@@ -14,6 +15,7 @@ from rich.table import Table
 from rich.text import Text
 
 import konduktor
+from konduktor import config as konduktor_config
 from konduktor import kube_client, logging
 from konduktor.backends import constants as backend_constants
 from konduktor.backends import pod_utils
@@ -48,6 +50,32 @@ _DEPLOYMENT_METADATA_LABELS = {
 }
 
 
+# actually just gets highest existing deployment number and adds 1
+def get_next_deployment_number(cluster_name: str) -> int:
+    """Get next number by counting existing Apoxy resources."""
+    try:
+        context = kubernetes_utils.get_current_kube_config_context_name()
+        custom_api = kube_client.crd_api(context=context)
+
+        # Count existing backends
+        backends = custom_api.list_cluster_custom_object(
+            group='core.apoxy.dev', version='v1alpha', plural='backends'
+        )
+
+        # Find the highest number
+        max_number = 0
+        for backend in backends.get('items', []):
+            name = backend['metadata']['name']
+            if name.startswith(f'{cluster_name}-backend-'):
+                number = int(name.split('-')[-1])
+                max_number = max(max_number, number)
+
+        return max_number + 1
+    except Exception as e:
+        logger.warning(f'Error counting existing resources: {e}')
+        return random.randint(100, 999)
+
+
 def render_specs(
     task: 'konduktor.Task',
 ) -> Tuple[Dict[str, Any], Dict[str, Any], Dict[str, Any]]:
@@ -124,6 +152,130 @@ def render_specs(
     return deployment_spec, service_spec, autoscaler_spec or {}
 
 
+# For general deployments, create resources as needed
+def render_apoxy_spec(task: 'konduktor.Task') -> List[Dict[str, Any]]:
+    """Renders the Apoxy specs for a general deployment."""
+    general = True
+    if task.run and 'vllm.entrypoints.openai.api_server' in task.run:
+        general = False
+
+    if not general:
+        return []  # Only render for general deployments
+
+    if task.run:
+        task.run = task.run.replace('__KONDUKTOR_TASK_NAME__', task.name)
+
+    unique_cluster_name = get_unique_cluster_name_from_tunnel()
+    cluster_name = unique_cluster_name[:-3]
+    deployment_number = get_next_deployment_number(unique_cluster_name)
+
+    with tempfile.NamedTemporaryFile() as temp:
+        common_utils.fill_template(
+            'apoxy-deployment.yaml.j2',
+            {
+                'name': task.name,
+                'user': common_utils.get_cleaned_username(),
+                'ports': task.serving.ports if task.serving else 8000,
+                'general': general,
+                'cluster_name': cluster_name,
+                'unique_cluster_name': unique_cluster_name,
+                'deployment_number': deployment_number,
+                **_DEPLOYMENT_METADATA_LABELS,
+            },
+            temp.name,
+        )
+        docs = common_utils.read_yaml_all(temp.name)
+        return docs
+
+
+def create_apoxy_resources(
+    namespace: str,
+    task: 'konduktor.Task',
+    dryrun: bool = False,
+) -> None:
+    """Creates Apoxy resources for a general deployment."""
+
+    apoxy_specs = render_apoxy_spec(task)
+
+    if not apoxy_specs:
+        return
+
+    if dryrun:
+        logger.debug(f'[DRYRUN] Would create Apoxy resources:\n{apoxy_specs}')
+        return
+
+    try:
+        context = kubernetes_utils.get_current_kube_config_context_name()
+        custom_api = kube_client.crd_api(context=context)
+
+        for spec in apoxy_specs:
+            kind = spec.get('kind')
+            name = spec['metadata']['name']
+
+            try:
+                if kind == 'Backend':
+                    custom_api.create_cluster_custom_object(
+                        group='core.apoxy.dev',
+                        version='v1alpha',
+                        plural='backends',
+                        body=spec,
+                    )
+                    logger.info(f'Apoxy Backend {name} created')
+                elif kind == 'HTTPRoute':
+                    custom_api.create_cluster_custom_object(
+                        group='gateway.apoxy.dev',
+                        version='v1',
+                        plural='httproutes',
+                        body=spec,
+                    )
+                    logger.info(f'Apoxy HTTPRoute {name} created')
+            except Exception as e:
+                if '409' in str(e) or 'AlreadyExists' in str(e):
+                    try:
+                        # Delete first, then create
+                        if kind == 'Backend':
+                            custom_api.delete_cluster_custom_object(
+                                group='core.apoxy.dev',
+                                version='v1alpha',
+                                plural='backends',
+                                name=name,
+                            )
+                            custom_api.create_cluster_custom_object(
+                                group='core.apoxy.dev',
+                                version='v1alpha',
+                                plural='backends',
+                                body=spec,
+                            )
+                        elif kind == 'HTTPRoute':
+                            custom_api.delete_cluster_custom_object(
+                                group='gateway.apoxy.dev',
+                                version='v1',
+                                plural='httproutes',
+                                name=name,
+                            )
+                            custom_api.create_cluster_custom_object(
+                                group='gateway.apoxy.dev',
+                                version='v1',
+                                plural='httproutes',
+                                body=spec,
+                            )
+                        logger.info(f'Apoxy {kind} {name} deleted and recreated')
+                    except Exception as delete_create_error:
+                        logger.error(
+                            f'Failed to delete and recreate {kind} {name}: '
+                            f'{delete_create_error}'
+                        )
+                        raise
+                elif '404' in str(e) or 'NotFound' in str(e):
+                    logger.warning(f'Apoxy CRD for {kind} not found. Skipping {name}.')
+                    logger.info('Make sure Apoxy is deployed and CRDs are ready.')
+                    continue
+                else:
+                    raise
+    except Exception as e:
+        logger.error(f'Error creating Apoxy resources: {e}')
+
+
 def create_deployment(
     namespace: str,
     task: 'konduktor.Task',
@@ -576,7 +728,7 @@ def delete_serving_specs(name: str, namespace: str) -> None:
             delete_fn(namespace, name)
             logger.info(f'Deleted {kind}: {name}')
         except Exception as e:
-            logger.error(f'Failed to delete {kind} {name}: {e}')
+            logger.debug(f'Failed to delete {kind} {name}: {e}')
 
 
 def _get_resource_summary(deployment) -> str:
@@ -627,7 +779,156 @@ def get_envoy_external_ip() -> Optional[str]:
     return None
 
 
-def show_status_table(namespace: str, all_users: bool):
+def get_unique_cluster_name_from_tunnel() -> str:
+    """Get cluster name from the apoxy deployment command."""
+    try:
+        context = kubernetes_utils.get_current_kube_config_context_name()
+        apps_api = kube_client.apps_api(context=context)
+
+        # Get the apoxy deployment
+        deployment = apps_api.read_namespaced_deployment(
+            name='apoxy', namespace='default'
+        )
+
+        # Extract cluster name from the command
+        containers = deployment.spec.template.spec.containers
+        if containers and len(containers) > 0:
+            command = containers[0].command
+            if (
+                command
+                and len(command) >= 4
+                and command[1] == 'tunnel'
+                and command[2] == 'run'
+            ):
+                return command[3]  # The cluster name is the 4th argument
+
+        logger.warning('Could not extract cluster name from apoxy deployment command')
+
+    except Exception as e:
+        logger.warning(f'Error getting cluster name from apoxy deployment: {e}')
+
+    return 'default'
+
+
+def get_endpoint_type_from_config() -> str:
+    """Get the endpoint type from konduktor config.
+
+    Returns:
+        'trainy' for Apoxy endpoints (default)
+        'direct' for LoadBalancer IP endpoints
+    """
+    try:
+        # Use the proper config system that handles KONDUKTOR_CONFIG env var
+        endpoint_type = konduktor_config.get_nested(('serving', 'endpoint'), 'trainy')
+        return endpoint_type.lower()
+    except Exception as e:
+        logger.warning(f'Error reading endpoint config: {e}')
+
+    # Default to trainy if config not found or error
+    return 'trainy'
+
+
+def _get_loadbalancer_endpoint_with_port(service_name: str) -> str:
+    """Helper function to get LoadBalancer endpoint with port."""
+    try:
+        context = kubernetes_utils.get_current_kube_config_context_name()
+        core_api = kube_client.core_api(context=context)
+
+        # Get the service
+        service = core_api.read_namespaced_service(
+            name=service_name, namespace='default'
+        )
+
+        # Check if it's LoadBalancer type
+        if service.spec.type == 'LoadBalancer':
+            ingress = service.status.load_balancer.ingress
+            if ingress and len(ingress) > 0:
+                ip = ingress[0].ip
+                if ip:
+                    return f'{ip}:{service.spec.ports[0].port}'
+
+        # If not LoadBalancer or no IP, return pending
+        return '<pending>'
+
+    except Exception:
+        return '<pending>'
+
+
+def get_vllm_deployment_endpoint(force_direct: bool = False) -> str:
+    """Get the endpoint for vLLM/Aibrix deployments based on config."""
+    if force_direct:
+        # Force direct endpoint display regardless of config
+        endpoint_type = 'direct'
+    else:
+        endpoint_type = get_endpoint_type_from_config()
+
+    if endpoint_type == 'direct':
+        try:
+            aibrix_endpoint = get_envoy_external_ip()
+            return aibrix_endpoint or '<pending>'
+        except Exception:
+            return '<pending>'
+    else:
+        try:
+            cluster_name = get_unique_cluster_name_from_tunnel()
+            return f'{cluster_name[:-3]}.trainy.us'
+        except Exception:
+            # Fallback to direct endpoint if trainy.us not available
+            try:
+                aibrix_endpoint = get_envoy_external_ip()
+                if aibrix_endpoint:
+                    # Aibrix deployments route through Envoy Gateway on port 80
+                    return f'{aibrix_endpoint}'
+            except Exception:
+                pass
+            return '<pending>'
+
+
+def get_general_deployment_endpoint(
+    service_name: str, force_direct: bool = False
+) -> str:
+    """Get the endpoint for a general deployment based on config."""
+    if force_direct:
+        # Force direct endpoint display regardless of config
+        endpoint_type = 'direct'
+    else:
+        endpoint_type = get_endpoint_type_from_config()
+
+    if endpoint_type == 'direct':
+        # Use LoadBalancer IP with port
+        return _get_loadbalancer_endpoint_with_port(service_name)
+    else:
+        # Use Apoxy (trainy.us) - existing logic
+        try:
+            context = kubernetes_utils.get_current_kube_config_context_name()
+            custom_api = kube_client.crd_api(context=context)
+
+            # Query route with label selector using the original task name
+            routes = custom_api.list_cluster_custom_object(
+                group='gateway.apoxy.dev',
+                version='v1',
+                plural='httproutes',
+                label_selector=f'task_name={service_name}',
+            )
+
+            # Extract endpoint_name from the route labels
+            if routes.get('items') and len(routes['items']) > 0:
+                route = routes['items'][0]  # Should only be one route with this label
+                labels = route.get('metadata', {}).get('labels', {})
+                endpoint_name = labels.get('endpoint_name')
+                if endpoint_name:
+                    return endpoint_name
+
+            # Fallback if no route found - try direct LoadBalancer endpoint
+            return _get_loadbalancer_endpoint_with_port(service_name)
+
+        except Exception as e:
+            logger.warning(f'Endpoint error for general deployment {service_name}: {e}')
+            # Fallback to direct LoadBalancer endpoint on error
+            return _get_loadbalancer_endpoint_with_port(service_name)
+
+
+def show_status_table(namespace: str, all_users: bool, force_direct: bool = False):
     """Display status of Konduktor Serve models."""
     context = kubernetes_utils.get_current_kube_config_context_name()
 
@@ -657,10 +958,12 @@ def show_status_table(namespace: str, all_users: bool):
         return
 
     Console().print()
-    external_ip = get_envoy_external_ip()
     title = '[bold]KONDUKTOR SERVE[/bold]'
     is_ci = os.environ.get('CI') or os.environ.get('BUILDKITE')
 
+    # Get Aibrix endpoint once for all Aibrix deployments
+    aibrix_endpoint = get_vllm_deployment_endpoint(force_direct)
+
     table = Table(title=title, box=box.ASCII if is_ci else box.ROUNDED)
     if all_users:
         table.add_column('User', style='magenta', no_wrap=True)
@@ -743,48 +1046,22 @@ def show_status_table(namespace: str, all_users: bool):
                     else Text('PENDING', style='yellow')
                 )
 
-        # Type & endpoint
-        ip_str = '<pending>'
-        labels = (
-            (
-                deployment.metadata.labels
-                if deployment and hasattr(deployment.metadata, 'labels')
-                else {}
-            )
-            or (
-                service.metadata.labels
-                if service and hasattr(service.metadata, 'labels')
-                else {}
-            )
-            or {}
-        )
-        if AIBRIX_NAME_LABEL in labels:
-            ip_str = external_ip or '<pending>'
+        # Extract labels from deployment, service, or fallback to empty dict
+        labels = {}
+        if deployment and hasattr(deployment.metadata, 'labels'):
+            labels = deployment.metadata.labels or {}
+        elif service and hasattr(service.metadata, 'labels'):
+            labels = service.metadata.labels or {}
         else:
-            if (
-                service
-                and service.status
-                and service.status.load_balancer
-                and service.status.load_balancer.ingress
-            ):
-                ing = service.status.load_balancer.ingress[0]
-                ip_str = ing.ip or ing.hostname or '<pending>'
-
-        # Port
-        port_str = ''
-        if service and service.spec and service.spec.ports:
-            port_obj = (
-                next((p for p in service.spec.ports if p.name == 'serve'), None)
-                or service.spec.ports[0]
-            )
-            if port_obj and port_obj.port:
-                port_str = str(port_obj.port)
+            labels = {}
 
-        # For vLLM deployments, don't append port since external routing is on port 80
+        endpoint_str = '<pending>'
         if AIBRIX_NAME_LABEL in labels:
-            endpoint_str = ip_str
+            # Aibrix deployment - use the pre-computed endpoint
+            endpoint_str = aibrix_endpoint
         else:
-            endpoint_str = f'{ip_str}:{port_str}' if port_str else ip_str
+            # General deployment
+            endpoint_str = get_general_deployment_endpoint(name, force_direct)
 
         # Replicas
         ready_replicas = (

{konduktor_nightly-0.1.0.dev20250825104841 → konduktor_nightly-0.1.0.dev20250827104553}/konduktor/backends/jobset.py

@@ -176,7 +176,7 @@ class JobsetBackend(backend.Backend):
         context = kubernetes_utils.get_current_kube_config_context_name()
         namespace = kubernetes_utils.get_kube_config_context_namespace(context)
         # TODO(asaiacai): need to set env variables in pod
-        jobset_utils.create_jobset(
+        jobset_response = jobset_utils.create_jobset(
             namespace,
             task,
             pod_spec['kubernetes']['pod_config'],
@@ -192,9 +192,10 @@ class JobsetBackend(backend.Backend):
                 ):
                     _wait_for_jobset_start(namespace, task.name)
                 try:
+                    assert jobset_response is not None
                     log_thread = threading.Thread(
                         target=log_utils.tail_logs,
-                        args=(task.name,),
+                        args=(jobset_response,),
                         daemon=True,
                     )
                     logger.info('streaming logs...')

{konduktor_nightly-0.1.0.dev20250825104841 → konduktor_nightly-0.1.0.dev20250827104553}/konduktor/backends/jobset_utils.py

@@ -575,8 +575,15 @@ def show_status_table(
         ]['containers'][0]['resources']['limits']  # noqa: E501
         cpu, memory = resources['cpu'], resources['memory']
         accelerator = job['metadata']['labels'].get(JOBSET_ACCELERATOR_LABEL, None)
+        num_accelerators = job['metadata']['labels'].get(
+            JOBSET_NUM_ACCELERATORS_LABEL, None
+        )
         if accelerator:
-            return f'{num_pods}x({cpu}CPU, {memory}MEM, {accelerator})'
+            if num_accelerators:
+                accelerator_with_count = f'{accelerator}:{num_accelerators}'
+            else:
+                accelerator_with_count = accelerator
+            return f'{num_pods}x({cpu}CPU, {memory}MEM, {accelerator_with_count})'
         else:
             return f'{num_pods}x({cpu}CPU, {memory}MEM)'
 

{konduktor_nightly-0.1.0.dev20250825104841 → konduktor_nightly-0.1.0.dev20250827104553}/konduktor/cli.py

@@ -1852,11 +1852,21 @@ def serve_down(
     required=False,
     help='Show all deployments, including those not owned by the ' 'current user.',
 )
-def serve_status(all_users: bool):
+@click.option(
+    '--direct',
+    '-d',
+    default=False,
+    is_flag=True,
+    required=False,
+    help='Force display of direct IP endpoints instead of trainy.us endpoints.',
+)
+def serve_status(all_users: bool, direct: bool):
     """Show status of deployments launched via `konduktor serve launch`."""
     context = kubernetes_utils.get_current_kube_config_context_name()
     namespace = kubernetes_utils.get_kube_config_context_namespace(context)
-    deployment_utils.show_status_table(namespace, all_users=all_users)
+    deployment_utils.show_status_table(
+        namespace, all_users=all_users, force_direct=direct
+    )
 
 
 def main():

konduktor_nightly-0.1.0.dev20250827104553/konduktor/manifests/apoxy-setup.yaml

@@ -0,0 +1,151 @@
+apiVersion: v1
+kind: Secret
+metadata:
+  name: trainy-kubeconfig
+  namespace: default
+type: Opaque
+data:
+  # this gets replaced by buildkite CI secret APOXY_AUTH
+  kubeconfig.yaml: |
+    APOXY_AUTH
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: kube-controller
+  namespace: default
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: kube-controller-role
+rules:
+- apiGroups: ["apiregistration.k8s.io"]
+  resources: ["apiservices"]
+  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: kube-controller-role-binding
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: kube-controller-role
+subjects:
+- kind: ServiceAccount
+  name: kube-controller
+  namespace: default
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: kube-controller
+  namespace: default
+  labels:
+    app: kube-controller
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: kube-controller
+  template:
+    metadata:
+      labels:
+        app: kube-controller
+    spec:
+      containers:
+      - name: kube-controller
+        image: apoxy/kube-controller:v0.11.6
+        args:
+        - --dev
+        - --project_id=7ce458d7-e20c-443c-aeeb-dbc5663c1240
+        - --kubeconfig_path=/data/kubeconfig.yaml
+        env:
+        - name: POD_NAMESPACE
+          valueFrom:
+            fieldRef:
+              fieldPath: metadata.namespace
+        volumeMounts:
+        - name: kubeconfig-volume
+          mountPath: /data
+          readOnly: true
+      volumes:
+      - name: kubeconfig-volume
+        secret:
+          secretName: trainy-kubeconfig
+          items:
+          - key: kubeconfig.yaml
+            path: kubeconfig.yaml
+            mode: 0600
+      serviceAccountName: kube-controller
+
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: kube-controller
+  namespace: default
+  labels:
+    app: kube-controller
+spec:
+  selector:
+    app: kube-controller
+  ports:
+  - name: http
+    protocol: TCP
+    port: 8443
+    targetPort: 8443
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: apoxy-config
+  namespace: default
+data:
+  config.yaml: |
+    apiVersion: config.apoxy.dev/v1alpha1
+    kind: Config
+    currentProject: 7ce458d7-e20c-443c-aeeb-dbc5663c1240
+    projects:
+    - id: 7ce458d7-e20c-443c-aeeb-dbc5663c1240
+      kubernetesConfig:
+        kubeconfigPath: /root/kubeconfig.yaml
+    tunnel:
+      mode: userspace
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: apoxy
+  namespace: default
+  labels:
+    app: apoxy
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: apoxy
+  template:
+    metadata:
+      labels:
+        app: apoxy
+    spec:
+      containers:
+      - name: apoxy
+        image: apoxy/apoxy:v0.11.10
+        command: ["apoxy", "tunnel", "run", "UNIQUE-TEMPNAME", "--insecure-skip-verify"]
+        volumeMounts:
+        - name: kubeconfig-volume
+          mountPath: /root/kubeconfig.yaml
+          subPath: kubeconfig.yaml
+        - name: apoxy-config-volume
+          mountPath: /root/.apoxy/config.yaml
+          subPath: config.yaml
+      volumes:
+      - name: kubeconfig-volume
+        secret:
+          secretName: trainy-kubeconfig
+      - name: apoxy-config-volume
+        configMap:
+          name: apoxy-config

konduktor_nightly-0.1.0.dev20250827104553/konduktor/manifests/apoxy-setup2.yaml

@@ -0,0 +1,34 @@
+apiVersion: core.apoxy.dev/v1alpha
+kind: TunnelNode
+metadata:
+  name: UNIQUE-TEMPNAME
+spec:
+  egressGateway:
+    enabled: true
+---
+# Add just your backend for aibrix
+apiVersion: core.apoxy.dev/v1alpha
+kind: Backend
+metadata:
+  name: UNIQUE-TEMPNAME-backend
+spec:
+  endpoints:
+    - fqdn: envoy-aibrix-system-aibrix-eg-903790dc.envoy-gateway-system.UNIQUE-TEMPNAME.tun.apoxy.net
+---
+# Add just your route for aibrix
+apiVersion: gateway.apoxy.dev/v1
+kind: HTTPRoute
+metadata:
+  name: UNIQUE-TEMPNAME-route
+spec:
+  parentRefs:
+    - name: default 
+      kind: Gateway
+      port: 443
+  hostnames:
+    - 'TEMPNAME.trainy.us'
+  rules:
+    - backendRefs:
+        - kind: Backend
+          name: UNIQUE-TEMPNAME-backend
+          port: 80

konduktor_nightly-0.1.0.dev20250827104553/konduktor/templates/apoxy-deployment.yaml.j2

@@ -0,0 +1,33 @@
+---
+# Apoxy Backend for general deployment
+apiVersion: core.apoxy.dev/v1alpha
+kind: Backend
+metadata:
+  name: {{ unique_cluster_name }}-backend-{{ deployment_number }}
+  labels:
+    task_name: {{ name }}
+    endpoint_name: {{ cluster_name }}-{{ deployment_number }}.trainy.us
+spec:
+  endpoints:
+    - fqdn: {{ name }}.default.{{ unique_cluster_name }}.tun.apoxy.net
+---
+# Apoxy Route for general deployment
+apiVersion: gateway.apoxy.dev/v1
+kind: HTTPRoute
+metadata:
+  name: {{ unique_cluster_name }}-route-{{ deployment_number }}
+  labels:
+    task_name: {{ name }}
+    endpoint_name: {{ cluster_name }}-{{ deployment_number }}.trainy.us
+spec:
+  parentRefs:
+    - name: default 
+      kind: Gateway
+      port: 443
+  hostnames:
+    - '{{ cluster_name }}-{{ deployment_number }}.trainy.us'
+  rules:
+    - backendRefs:
+        - kind: Backend
+          name: {{ unique_cluster_name }}-backend-{{ deployment_number }}
+          port: {{ ports }}

{konduktor_nightly-0.1.0.dev20250825104841 → konduktor_nightly-0.1.0.dev20250827104553}/konduktor/utils/schemas.py

@@ -578,6 +578,19 @@ def get_config_schema():
         },
     }
 
+    serving_configs = {
+        'type': 'object',
+        'required': [],
+        'additionalProperties': False,
+        'properties': {
+            'endpoint': {
+                'type': 'string',
+                'case_insensitive_enum': ['trainy', 'direct'],
+                'default': 'trainy',
+            },
+        },
+    }
+
     for cloud, config in cloud_configs.items():
         if cloud == 'kubernetes':
             config['properties'].update(_REMOTE_IDENTITY_SCHEMA_KUBERNETES)
@@ -595,6 +608,7 @@ def get_config_schema():
             'logs': logs_configs,
             'tailscale': tailscale_configs,
             'ssh': ssh_configs,
+            'serving': serving_configs,
             **cloud_configs,
         },
     }

{konduktor_nightly-0.1.0.dev20250825104841 → konduktor_nightly-0.1.0.dev20250827104553}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "konduktor-nightly"
-version = "0.1.0.dev20250825104841"
+version = "0.1.0.dev20250827104553"
 description = "GPU Cluster Health Management"
 packages = [
     {include = "konduktor"}