Skip to main content
This guide is for teams that run GPU workloads on CoreWeave Kubernetes Service (CKS), SUNK, CoreWeave AI Object Storage, Distributed File Storage, or CoreWeave Inference. Runpod doesn’t expose a Kubernetes API, so the migration is a translation: each Kubernetes object becomes a Runpod resource that you create directly. Autoscaled inference Deployments become Serverless endpoints, long-running single-container workloads become Pods, Jobs become queue-based endpoints or SDK tasks, PersistentVolumeClaims and buckets become network volumes, and SUNK clusters become Instant Clusters running Slurm. At the end, your containers run on Runpod, your clients call Runpod URLs, and your CoreWeave resources are shut down.
You can hand this migration to a coding agent. See Migrate with a coding agent for the setup commands and a prompt.

How CoreWeave maps to Runpod

What’s different

What works differently

You request GPUs, not nodes. A CoreWeave Node Pool gives you whole bare-metal nodes, and Kubernetes packs your containers onto them. On Runpod, each Pod or Serverless worker asks for a GPU type and a GPU count, and Runpod places it. There’s no bin-packing, node affinity, taints, or tolerations to carry over. Replace nodeSelector on node.coreweave.cloud/type with a GPU type ID or pool. Autoscaling is a property of the endpoint. On CKS you combine an HPA or KEDA with Node Pool autoscaling, and CoreWeave documents node scale-up as taking 5 to 15 minutes, depending on the instance type. A Serverless endpoint has one scaler: workers between a minimum and maximum, driven by queue delay or request count, with scale to zero as the default. Requests reach your container through Runpod’s URLs. A load-balancing endpoint serves your HTTP server at https://ENDPOINT_ID.api.runpod.ai/PATH and requires your Runpod API key as a bearer token. A queue-based endpoint wraps your code in a handler behind /run and /runsync. A Pod’s HTTP port is served at https://POD_ID-PORT.proxy.runpod.net, which is public, unauthenticated, and has a 100-second timeout. Storage is mounted, not claimed. A network volume mounts at /workspace on Pods and at /runpod-volume on Serverless workers. A Pod can choose the mount path through the REST API. A Serverless worker can’t, so update paths that pointed at your PVC’s mountPath. Volumes are pinned to a data center. A network volume lives in one data center, and anything that mounts it runs there. To spread an endpoint across data centers, attach one network volume per data center and copy the data to each, or use a global volume. Health checks are a single HTTP path. Load-balancing workers answer a health path (default /ping) with 200 when ready and 204 while initializing. Readiness, liveness, and startup probes collapse into that one check. Configuration is flat. Kubernetes Secrets become Runpod secrets referenced from environment variables. ConfigMaps become environment variables or files you bake into the image or place on a volume.

What has no direct equivalent

On the Runpod side:
  • The Kubernetes API. Operators, CRDs, DaemonSets, admission webhooks, Helm charts, and anything that calls the Kubernetes API from inside a container don’t carry over. Rebuild the behavior with the Runpod API, or keep that component on a Kubernetes cluster elsewhere.
  • Multi-container Pods and sidecars. A Runpod Pod or worker runs one container image, and Pods don’t support Docker Compose. Combine the processes into one image with a process supervisor, or run the sidecar as its own Pod and connect over global networking, which requires both to be NVIDIA GPU Pods.
  • VPC-level networking. Every CKS cluster attaches to a VPC with CIDRs you can choose, and CoreWeave offers Direct Connect. Runpod’s global networking gives Pods private DNS names inside your account at 100 Mbps, on NVIDIA GPU Pods in supported data centers. Pods don’t support UDP.
  • Object storage features. AI Object Storage has bucket policies, versioning, lifecycle rules, and LOTA caching. A network volume is a file system with a fixed size and an S3-compatible API on top. If you depend on bucket features, keep an object store and mount or sync from it.
  • Whole-node control. Kernel settings, GPU driver versions per Node Pool, kubelet overrides, and node shell access have no counterpart. Set a CUDA floor with minCudaVersion instead of pinning a driver.
  • CronJob schedules. Keep the schedule in a scheduler you already run (CI, Airflow, cron) and have it submit a job to the endpoint.
  • SUNK features. SUNK schedules Kubernetes Pods through Slurm, provisions users through SCIM, and gives users login Pods. On Runpod, managed Slurm Clusters come with Slurm and munge installed, and you configure everything else on the controller node.
On the CoreWeave side:
  • Scale to zero per endpoint. CoreWeave documents that Dedicated Inference doesn’t support scale to zero. On CKS, a Node Pool can scale to zero nodes through the Cluster Autoscaler, but GPU capacity scales at whole-node granularity. A Serverless endpoint with workers.min set to 0 runs no workers while idle.
  • Per-container GPU requests without a cluster. There’s no cluster, VPC, or Node Pool to create before the first container starts.
  • A managed request queue. Queue-based endpoints give you async submission, status polling, streaming, retries, and webhooks without deploying a queue.
If you want to keep a declarative, multi-cloud workflow rather than calling Runpod directly, two orchestration layers already target Runpod. SkyPilot launches tasks from a YAML file with cloud: runpod. dstack provisions Pods on Runpod from YAML definitions, including volumes. Neither is Kubernetes, but both can soften the move for teams used to manifests.

Requirements

  • Access to your CoreWeave organization: a kubeconfig for each CKS cluster, an API access token, and an AI Object Storage access key if you use buckets.
  • kubectl, and optionally the CoreWeave Intelligent CLI (cwic).
  • A Runpod account with a payment method or credits, and a Runpod API key.
  • Docker, to rebuild or retag images for linux/amd64.
  • The AWS CLI and jq.

Step 1: Take inventory of what you run on CoreWeave

Start from the cluster, because most of what you run is described by Kubernetes objects. Point kubectl at each CKS cluster and export everything that defines a workload. List your Node Pools and nodes to see which instance types you use. The second command is adapted from the node alias in CoreWeave’s docs and prints the instance type and GPU model for each node:
The INSTANCE TYPE and TARGET columns of the first command tell you how many GPUs you hold. Each GPU instance type is a whole node, so multiply nodes by the GPUs per node. List the workloads, how they scale, and how they’re exposed:
DaemonSets and CRDs that aren’t CoreWeave’s own are the items most likely to need redesign, so note what each one does. Export the full specs so you can translate them offline:
The secrets export lists names only, so no secret values land on disk. For each workload, record the image, command and args, env, container ports, nvidia.com/gpu count, node selector, volume mounts, and replica range. If you run SUNK, list the Slurm resources and capture the Slurm configuration from a login node:
List your AI Object Storage buckets and their sizes. CoreWeave’s docs configure the AWS CLI with a cw profile that points at https://cwobject.com with virtual-hosted addressing:
List Dedicated Inference gateways and deployments in the CoreWeave Cloud Console or through the Dedicated Inference API, and note each deployment’s engine, instance type, GPU count, model path, and autoscaling min and max. Finally, find the code and configuration that reference CoreWeave. Run this from the root of each repository:
Each match is a hostname, credential, storage class, or in-cluster address that changes in Step 7.

Step 2: Set up Runpod

Create a Runpod account, add credits or a payment method, and create an API key on the Credentials page. Install the CLI and the Python SDK, then set your key:
runpodctl manages Pods, endpoints, templates, and volumes. The runpod package (2.x, Python 3.10 to 3.14) includes the worker SDK, the endpoint client, and the rp CLI. rp login stores the key in ~/.runpod/config.toml if you prefer not to export it. If you manage infrastructure as code, install the Terraform provider. If you work with a coding agent, connect the MCP server.

Step 3: Choose where each workload lands

Use the shape of each Kubernetes object to pick its target.
Load-balancing endpoints have a 5.5-minute processing limit per request and a 30 MB payload limit, and they drop requests when every worker is busy. Use a queue-based endpoint for long-running or must-not-drop work.

GPU mapping

CoreWeave instance types are whole nodes. Map the GPU model, then set the GPU count each container requested with nvidia.com/gpu. Pick the GPU that fits the workload’s VRAM and throughput needs. A container that used one GPU of an 8-GPU node doesn’t need an 8-GPU Pod. GPU stock varies by data center and changes through the day, so check it before you commit to a type:
The catalog response includes each GPU type’s pool and availability for the product you ask about (POD, CLUSTER, or SERVERLESS).

Step 4: Move your images and code

Your container images move as they are, with four checks. Architecture. Runpod runs linux/amd64 images. If you built an image for a different architecture, rebuild it:
Registry access. imagePullSecrets don’t carry over. If the image is private, store the registry credential on Runpod and reference it by ID:
If your images live in a registry inside the CKS cluster or in CoreWeave’s container registry, push them to a registry that stays reachable after the cluster is gone. CUDA. On CKS, CoreWeave manages the GPU driver for the Node Pool. On Runpod, host driver versions vary by machine, so set a floor that matches your image: --min-cuda-version 12.8 in runpodctl, or gpu.minCudaVersion in the REST API. Command, ports, and environment. Translate the container spec field by field: Move each Kubernetes Secret your workloads read into a Runpod secret. The value is write-only once stored:
Reference it from any Pod, endpoint, or template by setting an environment variable’s value to {{ RUNPOD_SECRET_hf_token }}.

Multi-container Pods

If a Kubernetes Pod has more than one container, decide per container. Init containers that download models become a one-time copy onto a network volume (Step 5). Log and metrics sidecars usually go away, because Runpod collects container logs. A sidecar your app talks to over localhost either moves into the same image under a process supervisor, or becomes its own Pod that you reach at POD_ID.runpod.internal with global networking. Global networking works between NVIDIA GPU Pods only, so a CPU-only sidecar such as a cache belongs in the same image.

Step 5: Move your data and models

Choose the destination by how the data is used. Create the network volume first, in a data center that has the GPU you chose in Step 3 and that supports the S3-compatible API:
Size it for the data you’re copying. A network volume can grow later but can’t shrink.

Copy from AI Object Storage

The two S3 endpoints use different credentials, so copy through a machine that can reach both. The most reliable route is a Pod with the network volume mounted, because files are written straight to the file system.
On a Pod, /workspace/models/file is the same file as s3://NETWORK_VOLUME_ID/models/file in the S3-compatible API and /runpod-volume/models/file on a Serverless worker.

Copy from a PVC

Distributed File Storage volumes are reachable only from the cluster they live in, so push from inside CKS. This Job mounts the PVC and syncs it to the network volume through Runpod’s S3-compatible API:
pvc-export.yaml
Create the runpod-s3 Secret from your Runpod S3 API key before you apply the Job. For a PVC with a very large number of small files, archive them into tar files first, or run rsync over SSH to a Runpod Pod as described in Network volumes.

Global volumes

A global volume isn’t tied to a data center and is designed for data that many Pods or workers read, such as model weights. The S3-compatible API doesn’t work with global volumes, so load one by attaching it to a Pod and running the same sync commands inside it. Attach it to a GPU Pod in the console, or set mounts.global when you create the Pod with the REST API. See Global volumes for mount paths, request costs, and when to prefer a network volume.

Step 6: Deploy on Runpod

This section translates one real set of manifests. The inference server below is the kind of workload CoreWeave’s own CKS tutorials deploy: a vLLM server behind a Service, with a PVC for model weights, a Hugging Face token in a Secret, a node selector for H100 nodes, and an HPA.
llm.yaml
On CoreWeave this is reachable at http://llama.ORG_ID-CLUSTER_NAME.coreweave.app. The steps below assume you created the models network volume and the hf_token secret in the earlier steps.

Serverless load-balancing endpoint

A load-balancing endpoint runs the same HTTP server and replaces the Deployment, Service, and HPA with one resource. The endpoint type is set at creation with the REST API (runpodctl serverless create creates queue-based endpoints):
The response contains the endpoint id and requestUrls.base, which is https://ENDPOINT_ID.api.runpod.ai. Here’s how each piece of the manifests landed: Wait for a worker to become ready, then send the same OpenAI-style request your clients send today:
The first request after scale to zero waits for a cold start, so clients need retries. In the console, click New Endpoint on the Serverless page and set Endpoint Type to Load Balancer. See Load balancing endpoints for health check behavior and limits.
If the server is plain vLLM and you don’t need custom routes, the vLLM worker gives you a queue-based endpoint with an OpenAI-compatible route at https://api.runpod.ai/v2/ENDPOINT_ID/openai/v1 and no image to maintain.

Pod

Use a Pod when the workload should stay up as a single long-running container, the way a one-replica Deployment or StatefulSet does. The same manifests translate to one create call.
Create a template that holds the image, command, ports, and environment, then create the Pod from it:
The network volume mounts at /workspace, so the download path points there.
Wait for the container to report as running, then call it through the proxy URL:
The proxy URL is public and unauthenticated, and requests time out after 100 seconds. The LoadBalancer Service it replaces was also public, but if you relied on loadBalancerSourceRanges or a private Service, add authentication in your server (for example, vLLM’s API key option) or keep the port private and reach it from other Pods over global networking. For long requests or non-HTTP protocols, expose a TCP port instead. See Expose ports.
A Pod doesn’t have an HPA. If the Deployment scaled beyond one replica, use the Serverless endpoint above. In the console, the same Pod is created from Pods > Deploy.

Queue-based endpoint for a Job

A Kubernetes Job runs a container to completion. On Runpod, the same code becomes a handler that processes one job per request. This Job runs a GPU batch script once per input shard:
embed-job.yaml
Wrap the script in a handler. The arguments that were hardcoded in the manifest become the job’s input:
handler.py
Raising an exception marks the job as FAILED, which is what a non-zero exit code did for the Job. Build a worker image on top of the existing one:
Dockerfile
Create a Serverless template and an endpoint from it:
Submit one request per shard. The volume that was at /data is at /runpod-volume on the worker:
The Job fields map as follows: For large offline workloads that can tolerate multi-hour latency, see Batch jobs. If you’d rather not build a worker image, the Runpod SDK can run the same script as a task. Each call provisions a Pod, runs to completion, and terminates:
main.py
Run it with rp flash dev main.py. A task chooses its own mount path, so /data stays as it was. See Build an app for tasks, volumes, and deployment.

Instant Cluster with Slurm

A SUNK cluster becomes a managed Slurm Cluster. In the console, open Instant Clusters, click Create Cluster, choose Slurm Cluster, then set the Pod count, GPU type, region, and an optional network volume. The REST API creates the same thing:
Runpod designates one node as the Slurm controller and the rest as agents, with Slurm and munge configured. Connect to the controller over SSH and submit jobs with the same commands you use on a SUNK login node:
Before you move a SUNK workload, check these differences:
  • Images. Managed Slurm Clusters support only official Runpod PyTorch images. If your NodeSet used a custom image, install your dependencies at job start, keep environments on the network volume, or set up Slurm yourself on a cluster with your own image.
  • Size. Instant Clusters are documented at 2 to 8 nodes. For larger clusters, contact sales. Cluster availability depends on GPU stock, so check it for your GPU type and region before you plan a cutover date.
  • Shared storage. The homeDir and additionalMounts volumes in a SunkCluster become one network volume, mounted at /workspace on each node, in the cluster’s data center.
  • Users and accounting. SUNK provisions POSIX users through SCIM and ships an accounting database. On Runpod, you connect with your account’s SSH keys and configure users, partitions, and accounting in /etc/slurm/slurm.conf on the controller.
  • Job scripts. sbatch scripts carry over. Change partition names, paths under /mnt/home or /mnt/data, and any srun --container-image usage that relied on SUNK’s container support.

Step 7: Update the code that calls CoreWeave

Inference clients

For an HTTP server moved to a load-balancing endpoint, the request and response bodies don’t change. The hostname changes, and every request needs your Runpod API key.
client.py
The retries cover cold starts after the endpoint scales to zero. Use the same pattern for the other URLs you may be replacing:

Batch clients

Code that created Kubernetes Jobs now submits queue requests. Async work uses /run and polls /status, or passes a webhook URL to be notified on completion.
submit.py
See Send requests for /runsync, streaming with /stream, webhooks, and rate limits.

Storage clients

Code that read from AI Object Storage with an S3 client has two options. The simpler one is to read files from the mounted volume path. If the code must keep using S3 calls, point it at the network volume’s S3-compatible API: Check the compatibility reference for the S3 operations your code uses.

Control-plane automation

Scripts and CI jobs that drove CoreWeave through kubectl, cwic, or the CoreWeave API now call runpodctl or REST API v2. The Reference section maps the commands. Replace COREWEAVE_API_TOKEN and kubeconfig secrets in CI with RUNPOD_API_KEY.

Step 8: Verify, cut over, and shut down

Verify from outside. Send production-shaped requests to the Runpod endpoint from a machine outside Runpod, and compare the responses with CoreWeave’s for the same inputs. Measure latency for warm requests and for a cold start, then decide whether to keep workers.min above zero.
Run both in parallel. Keep the CoreWeave workload serving while you send a share of traffic to Runpod from your client, gateway, or DNS layer. Watch error rates, cold starts, and worker counts in the endpoint’s Metrics and Logs tabs, or pull them from the API:
Shift traffic. Move the remaining traffic once the Runpod side holds at your peak load. Raise workers.max first if your peak needs more workers than you tested with. Shut down CoreWeave. Do this only after you’ve confirmed the data copy and kept the CoreWeave side idle for a period you’re comfortable with. Delete in this order:
If you run SUNK, delete the SUNK cluster as well, because a SunkCluster manages its own Node Pools. Then delete each CKS cluster from the Clusters page of the CoreWeave Cloud Console (the cluster must be in the Running, Failed, or Preempted state), and delete API access tokens and Object Storage access keys you no longer need. If you manage CoreWeave with Terraform, run terraform destroy on that configuration instead.
Deleting resources doesn’t end a commitment. CoreWeave bills Reserved Instances at a flat rate for the term whether or not instances are running, so talk to your CoreWeave account team about reserved capacity before you plan the cutover date. Versioned buckets also need their object versions and delete markers removed before the bucket can be deleted.
Guard costs on Runpod. Keep workers.min at 0 on endpoints that can tolerate cold starts, and keep the idle timeout short. Stop or delete Pods you aren’t using, because a running Pod bills per second whether or not it’s serving. Enable low balance notifications, and review spend by resource:

Migrate your Terraform

The CoreWeave provider (coreweave/coreweave) manages clusters, VPCs, buckets, and Dedicated Inference. Workloads inside the cluster are usually managed with the Kubernetes or Helm providers. The Runpod provider (runpod/runpod, ~> 2.0) is built on REST API v2 and manages the workloads directly. Here’s the infrastructure for the inference server from Step 6 on CoreWeave. The Deployment, Service, and HPA would follow in the Kubernetes provider:
coreweave.tf
The Runpod configuration declares the volume and the endpoint, and nothing else:
runpod.tf
Terraform creates the volume empty, so load the model data (Step 5) before you send traffic. Don’t try to move state between the two providers. Apply the Runpod configuration alongside the CoreWeave one, cut over, then destroy the CoreWeave configuration. For every argument, see the provider reference on the Terraform Registry.

Reference

CLI command map

API map

Both APIs take Authorization: Bearer TOKEN.

Environment variable map

Status map

Migrate with a coding agent

A coding agent with the Runpod skills and MCP server can run this migration with you: it reads your manifests, proposes a mapping, and creates the Runpod resources after you approve. Install the tools for your agent:
The MCP server signs in with OAuth (“Sign in with Runpod”), so you don’t need an API key to start. See Agent skills and MCP servers for supported agents and options. Then give the agent this prompt from the root of the repository that holds your manifests:

Troubleshooting

A load-balancing worker shows as running but requests time out. The health check never returned 200. Expose the server’s port in ports, set both PORT and PORT_HEALTH to that port, and set HEALTH_CHECK_PATH if your server’s health route isn’t /ping. A readiness probe that pointed at a different port than the Service is the usual cause after a manifest translation. The model downloads again on every cold start. The server is still writing to the PVC’s old mountPath. On Serverless the volume is at /runpod-volume, so update the cache or download directory, or use cached models for Hugging Face models. The image fails to pull. Check two things: the image must be linux/amd64, and a private image needs a registry credential (registry or --registry-auth-id). imagePullSecrets and registries that were only reachable inside the CKS cluster don’t carry over. Requests return {"error":"not allowed for QB API"}. The URL style doesn’t match the endpoint type. Load-balancing endpoints are called at https://ENDPOINT_ID.api.runpod.ai/PATH, and queue-based endpoints at https://api.runpod.ai/v2/ENDPOINT_ID/run. The type is fixed at creation, so recreate the endpoint if it’s the wrong one. Requests through a Pod’s proxy URL fail after about 100 seconds. That’s the proxy timeout. Stream the response, move the workload to a Serverless endpoint, or expose a TCP port and connect to the Pod’s public IP and mapped port. The app can’t reach another service by its Kubernetes name. Names like redis.default.svc.cluster.local don’t exist on Runpod. Use the other service’s endpoint URL, or enable global networking on both Pods and use POD_ID.runpod.internal. Code that loads in-cluster Kubernetes credentials needs to be rewritten against the Runpod API. The Pod or endpoint can’t find capacity. A network volume pins everything that mounts it to one data center, and a CUDA floor narrows the machines further. List more than one pool in gpu.pools, attach a network volume per data center, or pick another GPU type that fits the workload. aws s3 commands fail against the Runpod S3-compatible API. Pass --region with the data center ID and --endpoint-url with that data center’s URL, and use the Runpod S3 API key, not your Runpod API key. Keep the Runpod settings in a separate AWS CLI profile from the cw profile, because the cw profile sets CoreWeave’s endpoint and addressing style. /status returns 404 for a job that finished. Results of /run jobs are kept for 30 minutes, and jobs are removed when their TTL expires. Have the handler write outputs to a volume or object store, or pass a webhook. Slurm doesn’t start on a new cluster. Managed Slurm Clusters support only official Runpod PyTorch images. Recreate the cluster with one, or follow the unmanaged Slurm guide for a custom image. If something in this guide is wrong or missing, open an issue on the Runpod docs repository.

Next steps

Load balancing endpoints

Health checks, limits, and when to use a queue instead.

Endpoint settings

Tune workers, scaling, timeouts, and FlashBoot.

Network volumes

Storage tiers, multi-data-center setups, and the S3-compatible API.

Slurm Clusters

Deploy and configure managed Slurm on Instant Clusters.
Last modified on November 14, 2026