### Example values.yaml for Specific Cluster Details

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/set-up-monitoring

This YAML example demonstrates how to fill in the `values.yaml` file with specific `orgID`, `clusterName`, and Grafana hostname values. It shows a concrete instance of the configuration required for Prometheus and Grafana setup.

```yaml
orgID: cw99

clusterName: my-inference-cluster



grafana:

  enabled: true

  grafana:

    ingress:

      hosts: [&host "grafana.cw99-my-inference-cluster.coreweave.app"]

      tls:

        - secretName: grafana-tls

          hosts:

            - *host
```

--------------------------------

### Install Docker and Buildx on Ubuntu

Source: https://docs.coreweave.com/docs/products/cks/tutorials/devpod

Installs the full Docker engine and buildx plugin on Ubuntu systems. This process involves updating package lists, installing necessary HTTPS transport packages, adding Docker's GPG key, configuring the Docker repository, and finally installing the Docker packages. Ensure you have sudo privileges to execute these commands.

```bash
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg -y
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch=\"$(dpkg --print-architecture)\" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y
```

--------------------------------

### Start DevPod Environment with Debugging

Source: https://docs.coreweave.com/docs/products/cks/tutorials/devpod

Initiates the DevPod environment, enabling debugging for verification purposes. The '--ide openvscode' flag ensures access to a browser-based VS Code interface. Remove '--debug' once the setup is confirmed to be working correctly.

```bash
devpod up . --debug --ide openvscode
```

--------------------------------

### Configure and Launch DevPod with VS Code IDE

Source: https://docs.coreweave.com/docs/products/cks/tutorials/devpod

Sets up and launches a DevPod environment with VS Code IDE integration for GPU-accelerated workloads. This script configures the Kubernetes provider, resource requests, and security settings, then starts the DevPod with VS Code. Ensure DevPod and kubectl are installed locally and the run_demo_gpu_cwsa.sh script is modified as shown.

```bash
#!/bin/bash



# Create namespace if it doesn't exist
kubectl create namespace devpod --dry-run=client -o yaml | kubectl apply -f -



# Clean up any existing workspace
devpod delete devpod-gpu-sidecar



# Configure DevPod provider
devpod provider use kubernetes
devpod provider set-options kubernetes -o POD_MANIFEST_TEMPLATE="$(pwd)/pod_manifest_template.yaml"
devpod provider set-options kubernetes -o RESOURCES="requests.cpu=16,requests.memory=32Gi,limits.nvidia.com/gpu=8"
devpod provider set-options kubernetes -o DISK_SIZE="100Gi"
devpod provider set-options kubernetes -o KUBERNETES_PULL_SECRETS_ENABLED="false"
devpod provider set-options kubernetes -o STRICT_SECURITY="true"



# Configure context to prevent timeout
devpod context set-options -o EXIT_AFTER_TIMEOUT=false



# Start the DevPod environment with VS Code IDE
devpod up . --debug --ide vscode
```

--------------------------------

### DevPod Kubernetes Provider Setup Script

Source: https://docs.coreweave.com/docs/products/cks/tutorials/devpod

A bash script to configure the DevPod Kubernetes provider and launch a development environment. It creates the 'devpod' namespace if it doesn't exist, sets the Kubernetes provider, configures the Pod manifest template path, defines resource requests and limits (including GPU allocation), sets disk size, and enables strict security. Finally, it starts the DevPod environment using `devpod up . --debug --ide openvscode`.

```bash
#!/bin/bash



# Create namespace if it doesn't exist

kubectl create namespace devpod --dry-run=client -o yaml | kubectl apply -f -



# Configure DevPod provider

devpod provider use kubernetes

devpod provider set-options kubernetes -o POD_MANIFEST_TEMPLATE="$(pwd)/pod_manifest_template.yaml"



# Set resource requirements - adjust these based on your needs

# For CPU-only environments, remove the GPU limits line

devpod provider set-options kubernetes -o RESOURCES="requests.cpu=16,requests.memory=32Gi,limits.nvidia.com/gpu=8"

devpod provider set-options kubernetes -o DISK_SIZE="100Gi"

devpod provider set-options kubernetes -o KUBERNETES_PULL_SECRETS_ENABLED="false"

devpod provider set-options kubernetes -o STRICT_SECURITY="true"



# Start the DevPod environment

# The debug flag is optional, but recommended until the script is

# verified to be working properly

devpod up . --debug --ide openvscode

```

--------------------------------

### Make and Run DevPod Setup Script

Source: https://docs.coreweave.com/docs/products/cks/tutorials/devpod

This snippet demonstrates making a shell script executable and then running it. This is typically used to automate the setup process for the DevPod environment, especially in CI/CD pipelines or for quick demonstrations.

```bash
chmod +x run_demo_gpu_cwsa.sh
./run_demo_gpu_cwsa.sh
```

--------------------------------

### Shell Script for Advanced Docker Setup

Source: https://docs.coreweave.com/docs/products/cks/tutorials/devpod

A basic bash script template (`run_demo_gpu_cwsa.sh`) intended for setting up an advanced development environment with Docker. This script serves as a starting point for users who need to integrate Docker-in-Docker within their Coreweave DevPod setup. The content is currently minimal and requires further scripting logic.

```bash
#!/bin/bash




```

--------------------------------

### Install KEDA for Autoscaling

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/set-up-monitoring

Installs KEDA (Kubernetes Event-driven Autoscaling) using Helm. KEDA enables automatic scaling of deployments based on various event sources, such as Prometheus metrics.

```bash
helm repo add kedacore https://kedacore.github.io/charts
helm repo update
helm install keda kedacore/keda \
  --namespace keda \
  --create-namespace
```

--------------------------------

### Get Help for kubectl debug node

Source: https://docs.coreweave.com/docs/products/cks/nodes/connect

This command displays the help information for the `kubectl debug node` command, providing a comprehensive list of available options and usage examples for customizing debug pods and their execution.

```bash
kubectl debug node --help
```

--------------------------------

### Install Docker CLI using APT

Source: https://docs.coreweave.com/docs/products/cks/tutorials/devpod

Installs the Docker CLI on a Debian-based Linux system using the APT package manager. This is necessary for running Docker commands from within the primary container, allowing it to communicate with the Docker sidecar.

```bash
sudo -i
apt update
apt upgrade
apt install docker.io
exit
```

--------------------------------

### Verify Traefik Installation using kubectl

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/set-up-infrastructure

Checks the status of Traefik pods within the 'traefik' namespace to ensure the ingress controller is running correctly. This command uses kubectl to list pods and their readiness.

```bash
kubectl get pods -n traefik
```

--------------------------------

### Example Output of Healthy NodePool Description

Source: https://docs.coreweave.com/docs/products/cks/reference/node-pool

This is an example output from the 'kubectl describe nodepools' command for a healthy NodePool. It showcases the expected conditions and their statuses when the NodePool is functioning as intended, with sufficient capacity, within quota, and at its target node count. It also details metadata like Creation Timestamp and Resource Version.

```yaml
Name:         example-nodepool

Namespace:

Labels:       <none>

Annotations:  <none>

API Version:  compute.coreweave.com/v1alpha1
Kind:         NodePool
Metadata:

  Creation Timestamp:        2025-06-09T14:48:54Z

  Generation:                1

  Resource Version:          857370

  UID:                       9311678d-4064-45b8-8439-b943250e5852

Spec:

  Autoscaling:               false

  Instance Type:             gd-8xa100-i128

  Lifecycle:

    Disable Unhealthy Node Eviction:  true

    Scale Down Strategy:              IdleOnly

  Max Nodes:                 0

  Min Nodes:                 0

  Target Nodes:              1

Status:

  Conditions:

    Last Transition Time:    2025-05-30T17:36:00Z

    Message:                 NodePool configuration is valid.

    Reason:                  Valid

    Status:                  True

    Type:                    Validated

    Last Transition Time:    2025-05-30T17:36:00Z

    Message:                 Sufficient capacity available for the requested instance type.

    Reason:                  Sufficient

    Status:                  True

    Type:                    Capacity

    Last Transition Time:    2025-05-30T17:36:00Z

    Message:                 NodePool is within instance type quota.

    Reason:                  Under

    Status:                  True

    Type:                    Quota

    Last Transition Time:    2025-05-30T17:36:00Z

    Message:                 NodePool has reached its target node count.

    Reason:                  TargetMet

    Status:                  True

    Type:                    AtTarget

  Current Nodes:             1

  In Progress:               0

  Queued Nodes:              0

Events:                      <none>
```

--------------------------------

### Install Traefik Ingress Controller with Helm

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/set-up-infrastructure

Deploys the Traefik ingress controller using Helm, which will manage external traffic routing and TLS termination for your deployments. This command creates a 'traefik' namespace if it doesn't exist and installs the Traefik chart.

```bash
helm install traefik coreweave/traefik \
  --namespace traefik \
  --create-namespace
```

--------------------------------

### Add CoreWeave Helm Repository

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/set-up-infrastructure

Adds the CoreWeave Helm repository to your system, allowing access to necessary Helm charts. This is a prerequisite for installing Traefik and cert-manager. It requires Helm to be installed.

```bash
helm repo add coreweave https://charts.core-services.ingress.coreweave.com

helm repo update
```

--------------------------------

### Install cert-manager with Helm

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/set-up-infrastructure

Installs cert-manager, a component for automatic TLS certificate management, using Helm. This command creates a 'cert-manager' namespace if it doesn't exist and installs the cert-manager chart.

```bash
helm install cert-manager coreweave/cert-manager \
  --namespace cert-manager \
  --create-namespace
```

--------------------------------

### Verify Traefik Services with kubectl

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/set-up-infrastructure

Lists the services associated with the Traefik installation in the 'traefik' namespace. This helps verify that Traefik's endpoints for HTTP and HTTPS traffic are correctly exposed.

```bash
kubectl get svc -n traefik
```

--------------------------------

### Verify Cert-Manager Installation using kubectl

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/set-up-infrastructure

Checks the status of cert-manager pods within the 'cert-manager' namespace to confirm that all cert-manager components are running as expected. This command uses kubectl to list pods.

```bash
kubectl get pods -n cert-manager
```

--------------------------------

### Node Instance Type Label Example (Kubernetes)

Source: https://docs.coreweave.com/docs/products/cks/clusters/scheduling/workload-scheduling

This example demonstrates the standard Kubernetes label format used to identify the instance type of a Node within a Node Pool. All Nodes in a pool share the same Instance ID, tagged with the `node.kubernetes.io/instance-type` label, ensuring consistency.

```kubernetes
node.kubernetes.io/instance-type=instance-type-example
```

--------------------------------

### Verify KEDA Deployment

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/set-up-monitoring

Checks the status of KEDA pods in the 'keda' namespace to confirm that KEDA has been successfully installed and is running.

```bash
kubectl get pods -n keda
```

--------------------------------

### Milvus Chart Configuration Example

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vector-databases-on-cks/milvus

Example snippet showing how to configure CoreWeave Milvus chart values in `values.yaml`, specifically for CoreWeave Object Storage (CAIOS) bucket name, access key, and secret key. Also shows how to configure GPU node affinity.

```yaml
caiosBucketName: YOUR_BUCKET_NAME
caiosAccessKey: YOUR_ACCESS_KEY
caiosSecretKey: YOUR_SECRET_KEY

dataNode:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: node.coreweave.cloud/class
            operator: In
            values:
            - gpu
queryNode:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: node.coreweave.cloud/class
            operator: In
            values:
            - gpu
```

--------------------------------

### Copy vLLM Configuration File

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/deploy-vllm

Copies a sample vLLM configuration file for Llama 3.1 8B Instruct to be customized. This step ensures you have a base configuration to start with.

```bash
cp hack/values-llama-small.yaml my-values.yaml
```

--------------------------------

### Verify Cert-Manager Services with kubectl

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/set-up-infrastructure

Lists the services for cert-manager within the 'cert-manager' namespace. This confirms that the cert-manager controller, cainjector, and webhook are accessible within the cluster.

```bash
kubectl get svc -n cert-manager
```

--------------------------------

### Example Default Node Pool Manifest

Source: https://docs.coreweave.com/docs/products/cks/nodes/nodes-and-node-pools

This manifest defines a default Node Pool in CKS, which is used for Reserved and On-Demand instances. Billing is based on reservation and utilization. This configuration uses the 'default' compute class.

```yaml
apiVersion: compute.coreweave.com/v1alpha1

kind: NodePool

metadata:
  name: default
spec:
  computeClass: default
  ...
```

--------------------------------

### Connect to DevPod Workspace via SSH

Source: https://docs.coreweave.com/docs/products/cks/tutorials/devpod

Establishes an SSH connection to a specific DevPod workspace, named 'devpod-gpu-sidecar' in this example. DevPod automatically attempts to open the configured IDE (e.g., openvscode) upon successful connection.

```bash
devpod ssh devpod-gpu-sidecar
```

--------------------------------

### Enable Cert-Manager Issuers with Helm

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/set-up-infrastructure

Upgrades the cert-manager installation to enable certificate issuers. This ensures cert-manager can start provisioning TLS certificates. It requires cert-manager to be previously installed.

```bash
helm upgrade cert-manager coreweave/cert-manager \
  --namespace cert-manager \
  --set cert-issuers.enabled=true
```

--------------------------------

### Clone Reference Architecture Repository

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/set-up-monitoring

This command clones the necessary reference architecture repository from GitHub. It is the first step in setting up the monitoring stack.

```bash
git clone https://github.com/coreweave/reference-architecture.git
```

--------------------------------

### Verify Docker Connection

Source: https://docs.coreweave.com/docs/products/cks/tutorials/devpod

Tests the Docker connection by listing running containers and then running the 'hello-world' image. A successful connection is indicated by an empty list initially, followed by the output of the 'hello-world' container, confirming that Docker can pull images and run containers.

```bash
docker ps
docker run --rm hello-world
```

--------------------------------

### Add Helm Repositories

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/set-up-monitoring

Adds the prometheus-community and grafana Helm chart repositories. These repositories contain the charts needed for deploying the monitoring stack.

```bash
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo add grafana https://grafana.github.io/helm-charts
helm repo update
```

--------------------------------

### List CKS Clusters using curl

Source: https://docs.coreweave.com/docs/products/cks/reference/cks-api

This example demonstrates how to list all CKS clusters using a GET request to the `/v1beta1/cks/clusters` endpoint. It requires an API access token for authorization. The successful response returns an array of CKS cluster objects.

```bash
curl -X GET https://api.coreweave.com/v1beta1/cks/clusters \
       -H "Content-Type: application/json" \
       -H "Authorization: Bearer {API_ACCESS_TOKEN}"
```

--------------------------------

### Verify Created Resources After MPIJob Submission (Shell)

Source: https://docs.coreweave.com/docs/products/cks/clusters/scheduling/imex-dra-scheduling

This shell command demonstrates how to verify the creation of ComputeDomain, ResourceClaim, ResourceClaimTemplate, ResourceSlice, and DS resources after submitting an MPIJob. It helps confirm that the scheduling and resource allocation were successful.

```shell
$  k get computedomain,resourceclaim,resourceclaimtemplate,resourceslice,ds;

NAME                                                   AGE

computedomain.resource.nvidia.com/s0-011-us-west-01a   22h

NAME                                                                                       STATE                AGE

resourceclaim.resource.k8s.io/dra-example-gb200-4x-worker-0-imex-channel-0-5vz5j           allocated,reserved   4m3s

resourceclaim.resource.k8s.io/dra-example-gb200-4x-worker-1-imex-channel-0-szpkc           allocated,reserved   4m3s

resourceclaim.resource.k8s.io/dra-example-gb200-4x-worker-10-imex-channel-0-57xxh          allocated,reserved   4m2s

resourceclaim.resource.k8s.io/dra-example-gb200-4x-worker-11-imex-channel-0-qrzqq          allocated,reserved   4m2s

resourceclaim.resource.k8s.io/dra-example-gb200-4x-worker-12-imex-channel-0-qz6ld          allocated,reserved   4m2s

resourceclaim.resource.k8s.io/dra-example-gb200-4x-worker-13-imex-channel-0-gnrst          allocated,reserved   4m2s

resourceclaim.resource.k8s.io/dra-example-gb200-4x-worker-14-imex-channel-0-r2ccv          allocated,reserved   4m1s

```

--------------------------------

### Get CKS OIDC Issuer URL using cURL and jq

Source: https://docs.coreweave.com/docs/products/cks/auth-access/workload-identity/oidc-gcp

This snippet demonstrates how to retrieve the OIDC issuer URL from CoreWeave CKS using a cURL command and process the JSON output with jq. It requires a cURL-compatible environment and jq to be installed. The output is the OIDC issuer URL, essential for GCP Workload Identity configuration.

```shell
$ curl -s -X GET https://api.coreweave.com/v1beta1/cks/clusters/{cluster-id} \
     -H "Content-Type: application/json" \
     -H "Authorization: Bearer {API_ACCESS_TOKEN}" \
     | jq -r '.cluster.oidc.issuerUrl'
```

--------------------------------

### Build Helm Dependencies and Deploy Monitoring Stack

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/set-up-monitoring

Builds Helm chart dependencies and installs the observability monitoring stack. It specifies the namespace, creates it if it doesn't exist, and uses a custom values file for configuration.

```bash
helm dependency build
helm install observability ./ \
  --namespace monitoring \
  --create-namespace \
  --values ./hack/values.yaml
```

--------------------------------

### Install CoreWeave Dragonfly Chart with Helm

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vector-databases-on-cks/dragonfly

This Helm command installs the CoreWeave Dragonfly chart into a new namespace named 'dragonfly'. It requires the chart to be in the current directory.

```bash
helm install -n dragonfly --create-namespace cw-dragonfly .
```

--------------------------------

### Install Milvus Chart with Helm (Shell)

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vector-databases-on-cks/milvus

This command installs the CoreWeave Milvus Helm chart in a new namespace named 'milvus'. It assumes you are in the chart directory.

```shell
$ helm install -n milvus cw-milvus .
```

--------------------------------

### List DevPod Workspaces

Source: https://docs.coreweave.com/docs/products/cks/tutorials/devpod

Lists all available DevPod workspaces on the current machine. The output provides details such as workspace name, source, provider, IDE, and usage statistics.

```bash
devpod ls
```

--------------------------------

### Python OpenAI Client for vLLM Chat Completion

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/monitor-and-test

This Python code demonstrates how to use the OpenAI client library to interact with a vLLM inference service for chat completions. It shows initialization with the vLLM endpoint and making a chat completion request with system and user messages.

```python
from openai import OpenAI


# Initialize client with your vLLM endpoint
client = OpenAI(
    base_url=f"https://{VLLM_ENDPOINT}/v1", # Replace with your VLLM_ENDPOINT
    api_key="unused",  # vLLM doesn't require API keys
)


# Chat completion
response = client.chat.completions.create(
    model=VLLM_MODEL, # Replace with your VLLM_MODEL
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What are the advantages of using CoreWeave for AI workloads?"}
    ],
    max_tokens=500,
    temperature=0.7
)


print(response.choices[0].message.content)

```

--------------------------------

### Install Milvus Operator with Helm

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vector-databases-on-cks/milvus

This command installs the Milvus Operator using Helm. It creates a dedicated namespace 'milvus-operator' and ensures the operator is running before proceeding.

```bash
helm install milvus-operator \
  -n milvus-operator --create-namespace \
  --wait --wait-for-jobs \
  https://github.com/zilliztech/milvus-operator/releases/download/v1.3.0/milvus-operator-1.3.0.tgz
```

--------------------------------

### Prepare GCS Bucket using gsutil

Source: https://docs.coreweave.com/docs/products/cks/auth-access/workload-identity/oidc-gcp

Commands to create a new GCS bucket or add a test file to an existing one. Bucket names must be globally unique. Requires gsutil.

```bash
# Create a test bucket (bucket names must be globally unique)
gsutil mb gs://my-cks-test-bucket-$(date +%s)

# Add a test file
echo "Hello from CKS!" | gsutil cp - gs://my-cks-test-bucket-$(date +%s)/test.txt
```

--------------------------------

### Install vLLM Inference Service using Helm

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/deploy-vllm

Deploys the vLLM inference service using Helm, specifying the namespace and custom values file. This command initiates the deployment of the inference service.

```bash
helm install basic-inference ./ \
  --namespace inference \
  --create-namespace \
  -f my-values.yaml
```

--------------------------------

### Verify Monitoring Deployment with kubectl

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vllm-inference/set-up-monitoring

Checks the status of pods in the monitoring namespace to ensure the observability stack is running correctly. This command lists all pods and their readiness, status, and restart counts.

```bash
kubectl get pods -n monitoring
```

--------------------------------

### Install Dragonfly Operator

Source: https://docs.coreweave.com/docs/products/cks/tutorials/deploy-vector-databases-on-cks/dragonfly

This command installs the Dragonfly Operator and its Custom Resource Definition (CRD) from a remote YAML file. It creates a dedicated namespace for the operator and is a prerequisite for managing Dragonfly clusters.

```bash
kubectl apply -f https://raw.githubusercontent.com/dragonflydb/dragonfly-operator/main/manifests/dragonfly-operator.yaml
```

--------------------------------

### Example JSON for Patching CKS Cluster

Source: https://docs.coreweave.com/docs/products/cks/reference/cks-api

Provides an example JSON structure for patching a CKS cluster, specifically demonstrating how to upgrade a cluster's version. It includes the `version` to update to and specifies `version` in the `updateMask`.

```json
{
  "version": "1.32",
  "updateMask": "version"
}
```

--------------------------------

### Check SkyPilot Installation and CKS Configuration

Source: https://docs.coreweave.com/docs/products/cks/tutorials/skypilot

Verifies the SkyPilot installation and its configuration for CoreWeave Kubernetes Service (CKS). The output indicates enabled compute and storage resources, listing the allowed CKS cluster contexts.

```bash
sky check
```

--------------------------------

### List All Kubernetes Node Pools

Source: https://docs.coreweave.com/docs/products/cks/nodes/create

This command lists all available Node Pools within the Kubernetes cluster. It provides an overview of each Node Pool, including its name, instance type, target, current status, and age. This is useful for monitoring and managing multiple Node Pools.

```bash
$ kubectl get nodepool

```

--------------------------------

### Install SkyPilot on CKS

Source: https://docs.coreweave.com/docs/products/cks/tutorials/skypilot

Installs SkyPilot with CoreWeave support in a new conda environment. It's recommended to use a dedicated environment to prevent package conflicts. SkyPilot requires version 0.10.1 or later and Python versions between 3.7 and 3.13.

```bash
conda create -y -n sky python=3.10

conda activate sky

pip install "skypilot[coreweave]"
```

--------------------------------

### Verify GPU Access with nvidia-smi

Source: https://docs.coreweave.com/docs/products/cks/tutorials/devpod

Verifies GPU access within the DevPod environment by running the `nvidia-smi` command. This is useful for confirming that the system can detect and utilize the GPU, which is essential for tasks like deep learning and scientific computing. Assumes PyTorch base image with CUDA support.

```bash
$ nvidia-smi
```

--------------------------------

### Example Kubeconfig File (YAML)

Source: https://docs.coreweave.com/docs/products/cks/auth-access/managed-auth/kubeconfig

This is an example of a Kubeconfig file generated using CKS Managed Auth via the Cloud Console. Kubeconfig files are YAML files used to manage access to Kubernetes clusters, specifying details for authentication and interaction with the API server.

```yaml
apiVersion: v1

clusters:

- cluster:

    server: https://api-server.url.com

  name: my-cluster

contexts:

- context:

    cluster: my-cluster

    namespace: my-namespace

    user: token

  name: my-cluster

current-context: my-cluster

kind: Config

preferences: {}

users:

- name: token

  user:

    token: REDACTED

```

--------------------------------

### List DevPod Workspaces

Source: https://docs.coreweave.com/docs/products/cks/tutorials/devpod

Lists available DevPod workspaces in the current environment. This command helps users identify and manage their existing development environments. It displays details such as workspace name, source, machine, provider, IDE, last used time, age, and status.

```bash
$ devpod ls
```