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.

This part of the product is designed for Kubernetes-literate operators. If you want the simplest guided workflow, use Application instead. If you want a programmatic HTTP API without operating Kubernetes, start with Inference API.

Choose a workflow

Workflow	Best for	What you do there
Console	Guided setup, quick inspection, day-1 operations	Create namespaces, deployments, services, and simple ingresses
kubectl	Git-managed config, CI, native Kubernetes operations	Apply manifests, inspect resources, and operate the same namespace from local tooling
Console + kubectl	Teams that want both native control and UI visibility	Use the console for access setup and inspection, use kubectl for manifest-driven changes

Both paths operate on the same namespace resources. If you create a service or ingress with kubectl, it appears in the console. If you create an ingress in the console, it creates the same Kubernetes Ingress resource in the namespace.

The basic model

Resource	What it is	Typical next step
Namespace	Your workspace and isolation boundary	Create workloads inside it
Deployment	The application runtime you want to run	Add a Service if anything needs to reach it
Service	The stable internal network target for traffic inside the cluster	Add an Ingress for public HTTP access
Ingress	The public HTTP entrypoint for a service	Share the generated host with callers

Typical flow:

Namespace
  -> Deployment
  -> Service
  -> Ingress

Quick start

If you are new to the product, this is the simplest path:

1. Open Kubernetes in the console.
2. Create a namespace or use your existing default namespace.
3. Create an API key with Kubernetes exec access.
4. Download the namespace kubeconfig from the console.
5. Create a deployment from the console or with kubectl.
6. Create a service for that deployment.
7. Create an ingress if you want public HTTP access.

Before you begin

Requirement	Why it matters
A signed-in console session	Required to create namespaces and download kubeconfig
A Kubernetes exec API key	Required for kubectl access
A namespace	All supported resources are namespace-scoped
A service before ingress	Public HTTP routing always targets an existing ClusterIP service

Work with Kubernetes

The console is organized around three resource views:

• Deployments
• Services
• Ingresses

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

If you need 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.

What you can manage today

Namespace-scoped access currently supports common Kubernetes resources such as:

• Deployment
• Service
• Ingress
• ConfigMap
• Job
• CronJob

You can also inspect:

• Pod
• Pod logs
• Event

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

Important limits

Area	Current expectation
Service type	Use ClusterIP
Direct public service exposure	NodePort and externalIPs are not supported
Ingress hostnames	Must stay under the RemoteGPU-managed ingress domain
Ingress behavior	Service-backed HTTP routing is supported; unsupported annotation patterns and unsupported backend shapes may be rejected
kubectl access	Requires a RemoteGPU API key with Kubernetes exec access

Read next

• Read Deployments to run or update an application.
• Read Services to expose a deployment inside the cluster.
• Read Ingresses to publish a service with HTTP routing.