Kubernetes on RemoteGPU

RemoteGPU gives you a managed Kubernetes environment that you can use from the console, from kubectl, or from both at the same time.

Use Kubernetes when your team wants to manage namespace-scoped workloads, networking, storage, and batch resources directly.

Kubernetes use cases

Kubernetes is for teams that need to run and operate their own container workloads in a namespace.

Typical use cases include:

• running containers with deployments, StatefulSets, jobs, or cronjobs
• managing resources with kubectl, manifests, or CI-driven apply flows
• combining application runtime, batch execution, persistent storage, and HTTP routing

For guided Comfy workspaces, use Application. For direct model requests without managing Kubernetes resources, use Inference API.

Choose a workflow

Use the console when you want guided setup, quick inspection, logs, and status views without writing every resource manifest by hand.

Use kubectl when your team manages Kubernetes resources from manifests, CI, or local tooling.

Many teams use both: start in the console for namespace access and quick inspection, then use kubectl for manifest-driven changes.

Both paths operate on the same namespace resources. Services and ingresses created with kubectl appear in the console, and console-created resources are visible through Kubernetes APIs in the namespace.

The basic model

Resource	Description	Typical next step
Namespace	Your workspace and isolation boundary	Create workloads inside it
Deployment	The application runtime you want to run	Add a Service for reachable workloads
StatefulSet	A stable-identity application runtime managed with kubectl	Add PVCs and a Service for stable workloads
Job	One-off batch work that runs to completion	Inspect pods, events, and logs, or replace it with a new job run
Service	The stable internal network target for traffic inside the cluster	Add an Ingress for public HTTP access
CronJob	Scheduled batch work that creates jobs on a schedule	Inspect the jobs it creates and tune schedule or retention settings
Ingress	The public HTTP entrypoint for a service	Share the generated host with callers
Secret	Sensitive namespace-scoped application configuration	Reference it from a workload as environment variables or files
PersistentVolumeClaim	Persistent storage for workload data	Mount it into a deployment, job, or cronjob

Common paths:

• Long-running private app: Namespace to Deployment or StatefulSet to Service
• Long-running public HTTP app: Namespace to Deployment or StatefulSet to Service to Ingress
• One-off batch work: Namespace to Job
• Scheduled batch work: Namespace to CronJob
• Sensitive workload configuration: Namespace to Secret to workload reference
• Persistent workload data: Namespace to PersistentVolumeClaim to workload mount

Quick start

Start here for the shortest path through the product:

1. Open Kubernetes / Deployments in the console.
2. Create a namespace or use your existing default namespace.
3. Create a Kubernetes exec API key in Settings / API Keys.
4. Download the namespace kubeconfig from the console.
5. Create a deployment, StatefulSet, job, or cronjob with the workflow that fits your team.
6. Add persistent storage for workloads that need data to survive pod restarts.
7. Create a service for long-running application traffic.
8. Add an ingress for public HTTP access to a service-backed app.

You can start from Kubernetes / Deployments in the console, then move between the Deployments, Services, and Ingresses views without leaving the Kubernetes section.

Before you begin

Before you start, make sure you have:

• a signed-in console session to create namespaces and download kubeconfig
• a Kubernetes exec API key when you plan to use kubectl
• a namespace, because supported resources are namespace-scoped
• a ClusterIP service before creating public HTTP ingress routing

Work with Kubernetes

The console is organized around five resource views:

• Deployments
• Jobs
• Services
• CronJobs
• Ingresses

Use the console when you want a guided setup, live status, logs, and namespace inspection without writing manifests for every change.

For help choosing the right key, read API keys.

Example:

export REMOTEGPU_API_KEY=rgpu_your_scoped_api_key
kubectl --kubeconfig ./kubeconfig-team-ml.yaml get pods

The downloaded kubeconfig refreshes short-lived namespace credentials, so the API key needs to stay available in the shell or CI environment that runs kubectl.

Supported resources

Resource	Console	kubectl	Details
Deployment	Supported	Supported	Primary app workflow in the console
StatefulSet	Not surfaced as a dedicated console workflow	Supported	Use kubectl for stable-identity workloads
Service	Supported	Supported	Console creates standard ClusterIP services
Ingress	Supported	Supported	Public HTTP routing follows the RemoteGPU ingress profile
Job	Supported for console creation and inspection	Supported	Use kubectl for advanced job fields
CronJob	Supported for console creation and inspection	Supported	Use kubectl for advanced scheduling and job template fields
ConfigMap	Not surfaced as a dedicated console workflow	Supported	Standard namespace resource for manifest-driven teams
Secret	Not surfaced as a dedicated console workflow	Supported	Use Secrets for sensitive workload configuration
PersistentVolumeClaim	Not surfaced as a dedicated console workflow	Supported	Use a supported RemoteGPU storage class for persistent storage
Pod	Supported for inspection	Inspection only	Pods are created by controllers such as deployments and jobs
Logs and events	Supported	Supported	Use logs and events to inspect workload behavior

Ingress is part of the supported Kubernetes model on RemoteGPU, with a defined platform profile described in Ingresses.

Important limits

Area	Requirement
Service type	Use ClusterIP
Direct public service exposure	NodePort and externalIPs are not supported
Ingress hostnames	Must match the namespace-scoped pattern <prefix>--<namespace-token>.apps.remotegpu.ai
Ingress TLS	Managed apps.remotegpu.ai hosts use the platform wildcard certificate; do not configure per-ingress TLS
Ingress behavior	Service-backed HTTP routing is supported
Secrets	Up to 128 Secrets per namespace; reserved platform prefixes are not supported
Persistent storage	Use a supported storage class with one of the supported fixed sizes
Raw pod manifests	Use Deployment, StatefulSet, Job, or CronJob; direct Pod creation is not supported
kubectl access	Requires a RemoteGPU API key with Kubernetes exec access

Unsupported ingress annotation patterns and backend shapes may be rejected.

Read next

• Read Deployments to run or update an application.
• Read StatefulSets to run stable-identity workloads.
• Read Services to expose a deployment inside the cluster.
• Read Ingresses to publish a service with HTTP routing.
• Read Storage to create persistent volumes for workloads.
• Read Secrets to attach sensitive configuration to workloads.
• Read Jobs for one-off batch work.
• Read CronJobs for scheduled batch work.