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. ReplacenodeSelector 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
minCudaVersioninstead 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.
- 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.minset to0runs 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. Pointkubectl 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:
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:
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:
cw profile that points at https://cwobject.com with virtual-hosted addressing:
min and max.
Finally, find the code and configuration that reference CoreWeave. Run this from the root of each repository:
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 withnvidia.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:
POD, CLUSTER, or SERVERLESS).
Step 4: Move your images and code
Your container images move as they are, with four checks. Architecture. Runpod runslinux/amd64 images. If you built an image for a different architecture, rebuild it:
imagePullSecrets don’t carry over. If the image is private, store the registry credential on Runpod and reference it by ID:
--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:
{{ 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 overlocalhost 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:
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.- From a Pod (recommended)
- Through the S3-compatible API
Start a CPU Pod with the volume attached, then connect to it with the web terminal or SSH:Inside the Pod, install the AWS CLI, configure the AI Object Storage requires virtual-hosted addressing, so keep the
cw profile the way CoreWeave’s docs describe, and sync the bucket onto the volume:addressing_style line. Use https://cwobject.com here, not http://cwlota.com, because the LOTA endpoint only works inside a CoreWeave cluster. Delete the Pod when the sync finishes.To use Rclone instead, define a remote with CoreWeave’s documented settings and copy to the mounted path:~/.config/rclone/rclone.conf
/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
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 setmounts.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
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):
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:
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.- runpodctl
- REST API v2
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.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
handler.py
FAILED, which is what a non-zero exit code did for the Job. Build a worker image on top of the existing one:
Dockerfile
/data is at /runpod-volume on the worker:
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
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:- Images. Managed Slurm Clusters support only official Runpod PyTorch images. If your
NodeSetused 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
homeDirandadditionalMountsvolumes in aSunkClusterbecome one network volume, mounted at/workspaceon 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.confon the controller. - Job scripts.
sbatchscripts carry over. Change partition names, paths under/mnt/homeor/mnt/data, and anysrun --container-imageusage 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.- Before (CoreWeave)
- After (Runpod)
client.py
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.
- Before (CoreWeave)
- After (Runpod)
submit.py
/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 throughkubectl, 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 keepworkers.min above zero.
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:
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.
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
runpod.tf
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:- Claude Code
- Other agents
Troubleshooting
A load-balancing worker shows as running but requests time out. The health check never returned200. 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.