skypilot-nightly 1.0.0.dev2024053101__py3-none-any.whl → 1.0.0.dev2025022801__py3-none-any.whl

sky/utils/kubernetes/exec_kubeconfig_converter.py

@@ -0,0 +1,73 @@
+"""Helper script to strip path information from exec auth in a kubeconfig file.
+
+This script processes a kubeconfig file and removes any path information from
+the 'command' field in the exec configuration, leaving only the executable name.
+This is useful when moving between different environments where auth plugin
+executables might be installed in different locations.
+
+It assumes the target environment has the auth executable available in PATH.
+If not, you'll need to update your environment container to include the auth
+executable in PATH.
+
+Usage:
+    python -m sky.utils.kubernetes.exec_kubeconfig_converter
+"""
+import argparse
+import os
+
+import yaml
+
+
+def strip_auth_plugin_paths(kubeconfig_path: str, output_path: str):
+    """Strip path information from exec plugin commands in a kubeconfig file.
+
+    Args:
+        kubeconfig_path (str): Path to the input kubeconfig file
+        output_path (str): Path where the modified kubeconfig will be saved
+    """
+    with open(kubeconfig_path, 'r', encoding='utf-8') as file:
+        config = yaml.safe_load(file)
+
+    updated = False
+    for user in config.get('users', []):
+        exec_info = user.get('user', {}).get('exec', {})
+        current_command = exec_info.get('command', '')
+
+        if current_command:
+            # Strip the path and keep only the executable name
+            executable = os.path.basename(current_command)
+            if executable != current_command:
+                exec_info['command'] = executable
+                updated = True
+
+    if updated:
+        with open(output_path, 'w', encoding='utf-8') as file:
+            yaml.safe_dump(config, file)
+        print('Kubeconfig updated with path-less exec auth. '
+              f'Saved to {output_path}')
+    else:
+        print('No updates made. No exec-based auth commands paths found.')
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Strip path information from exec plugin commands in a '
+        'kubeconfig file. Used to prepare kubeconfigs for deployment '
+        'with SkyPilot.')
+    parser.add_argument(
+        '--input',
+        '-i',
+        default=os.path.expanduser('~/.kube/config'),
+        help='Input kubeconfig file path (default: %(default)s)')
+    parser.add_argument(
+        '--output',
+        '-o',
+        default=os.path.expanduser('~/.kube/config.converted'),
+        help='Output kubeconfig file path (default: %(default)s)')
+
+    args = parser.parse_args()
+    strip_auth_plugin_paths(args.input, args.output)
+
+
+if __name__ == '__main__':
+    main()

sky/utils/kubernetes/generate_kubeconfig.sh

@@ -0,0 +1,336 @@
+#!/bin/bash
+# This script creates a new k8s Service Account and generates a kubeconfig with
+# its credentials. This Service Account has the minimal permissions necessary for
+# SkyPilot. The kubeconfig is written in the current directory.
+#
+# Before running this script, you must configure your local kubectl to point to
+# the right k8s cluster and have admin-level access.
+#
+# By default, this script will create a service account "sky-sa" in "default"
+# namespace. If you want to use a different namespace or service account name:
+#
+#   * Specify SKYPILOT_NAMESPACE env var to override the default namespace where the service account is created.
+#   * Specify SKYPILOT_SA_NAME env var to override the default service account name.
+#   * Specify SKIP_SA_CREATION=1 to skip creating the service account and use an existing one
+#   * Specify SUPER_USER=1 to create a service account with cluster-admin permissions
+#
+# Usage:
+#   # Create "sky-sa" service account with minimal permissions in "default" namespace and generate kubeconfig
+#   $ ./generate_kubeconfig.sh
+#
+#   # Create "my-sa" service account with minimal permissions in "my-namespace" namespace and generate kubeconfig
+#   $ SKYPILOT_SA_NAME=my-sa SKYPILOT_NAMESPACE=my-namespace ./generate_kubeconfig.sh
+#
+#   # Use an existing service account "my-sa" in "my-namespace" namespace and generate kubeconfig
+#   $ SKIP_SA_CREATION=1 SKYPILOT_SA_NAME=my-sa SKYPILOT_NAMESPACE=my-namespace ./generate_kubeconfig.sh
+#
+#   # Create "sky-sa" service account with cluster-admin permissions in "default" namespace
+#   $ SUPER_USER=1 ./generate_kubeconfig.sh
+
+set -eu -o pipefail
+
+# Allow passing in common name and username in environment. If not provided,
+# use default.
+SKYPILOT_SA=${SKYPILOT_SA_NAME:-sky-sa}
+NAMESPACE=${SKYPILOT_NAMESPACE:-default}
+SUPER_USER=${SUPER_USER:-0}
+
+echo "Service account: ${SKYPILOT_SA}"
+echo "Namespace: ${NAMESPACE}"
+echo "Super user permissions: ${SUPER_USER}"
+
+# Set OS specific values.
+if [[ "$OSTYPE" == "linux-gnu" ]]; then
+    BASE64_DECODE_FLAG="-d"
+elif [[ "$OSTYPE" == "darwin"* ]]; then
+    BASE64_DECODE_FLAG="-D"
+elif [[ "$OSTYPE" == "linux-musl" ]]; then
+    BASE64_DECODE_FLAG="-d"
+else
+    echo "Unknown OS ${OSTYPE}"
+    exit 1
+fi
+
+# If the user has set SKIP_SA_CREATION=1, skip creating the service account.
+if [ -z ${SKIP_SA_CREATION+x} ]; then
+  echo "Creating the Kubernetes Service Account with ${SUPER_USER:+super user}${SUPER_USER:-minimal} RBAC permissions."
+  if [ "${SUPER_USER}" = "1" ]; then
+    # Create service account with cluster-admin permissions
+    kubectl apply -f - <<EOF
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: ${NAMESPACE}
+  labels:
+    parent: skypilot
+---
+kind: ServiceAccount
+apiVersion: v1
+metadata:
+  name: ${SKYPILOT_SA}
+  namespace: ${NAMESPACE}
+  labels:
+    parent: skypilot
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: ${SKYPILOT_SA}-cluster-admin
+  labels:
+    parent: skypilot
+subjects:
+  - kind: ServiceAccount
+    name: ${SKYPILOT_SA}
+    namespace: ${NAMESPACE}
+roleRef:
+  kind: ClusterRole
+  name: cluster-admin
+  apiGroup: rbac.authorization.k8s.io
+EOF
+  else
+    # Original RBAC rules for minimal permissions
+    kubectl apply -f - <<EOF
+# Create/update namespace specified by the user
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: ${NAMESPACE}
+  labels:
+    parent: skypilot
+---
+kind: ServiceAccount
+apiVersion: v1
+metadata:
+  name: ${SKYPILOT_SA}
+  namespace: ${NAMESPACE}
+  labels:
+    parent: skypilot
+---
+# Role for the service account
+kind: Role
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: ${SKYPILOT_SA}-role
+  namespace: ${NAMESPACE}
+  labels:
+    parent: skypilot
+rules:
+  - apiGroups: ["*"]  # Required for creating pods, services, secrets and other necessary resources in the namespace.
+    resources: ["*"]
+    verbs: ["*"]
+---
+# RoleBinding for the service account
+kind: RoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: ${SKYPILOT_SA}-rb
+  namespace: ${NAMESPACE}
+  labels:
+    parent: skypilot
+subjects:
+  - kind: ServiceAccount
+    name: ${SKYPILOT_SA}
+roleRef:
+  kind: Role
+  name: ${SKYPILOT_SA}-role
+  apiGroup: rbac.authorization.k8s.io
+---
+# ClusterRole for the service account
+kind: ClusterRole
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: ${SKYPILOT_SA}-cluster-role
+  namespace: ${NAMESPACE}
+  labels:
+    parent: skypilot
+rules:
+  - apiGroups: [""]
+    resources: ["nodes"]  # Required for getting node resources.
+    verbs: ["get", "list", "watch"]
+  - apiGroups: ["node.k8s.io"]
+    resources: ["runtimeclasses"]   # Required for autodetecting the runtime class of the nodes.
+    verbs: ["get", "list", "watch"]
+  - apiGroups: ["networking.k8s.io"]   # Required for exposing services through ingresses
+    resources: ["ingressclasses"]
+    verbs: ["get", "list", "watch"]
+  - apiGroups: [""]                 # Required for sky show-gpus command
+    resources: ["pods"]
+    verbs: ["get", "list"]
+---
+# ClusterRoleBinding for the service account
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: ${SKYPILOT_SA}-cluster-role-binding
+  namespace: ${NAMESPACE}
+  labels:
+    parent: skypilot
+subjects:
+  - kind: ServiceAccount
+    name: ${SKYPILOT_SA}
+    namespace: ${NAMESPACE}
+roleRef:
+  kind: ClusterRole
+  name: ${SKYPILOT_SA}-cluster-role
+  apiGroup: rbac.authorization.k8s.io
+---
+# Optional: If using object store mounting, create the skypilot-system namespace
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: skypilot-system
+  labels:
+    parent: skypilot
+---
+# Optional: If using object store mounting, create role in the skypilot-system
+# namespace to create FUSE device manager.
+kind: Role
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: skypilot-system-service-account-role
+  namespace: skypilot-system
+  labels:
+    parent: skypilot
+rules:
+  - apiGroups: ["*"]
+    resources: ["*"]
+    verbs: ["*"]
+---
+# Optional: If using object store mounting, create rolebinding in the skypilot-system
+# namespace to create FUSE device manager.
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: ${SKYPILOT_SA}-skypilot-system-role-binding-${NAMESPACE}
+  namespace: skypilot-system  # Do not change this namespace
+  labels:
+    parent: skypilot
+subjects:
+  - kind: ServiceAccount
+    name: ${SKYPILOT_SA}
+    namespace: ${NAMESPACE}
+roleRef:
+  kind: Role
+  name: skypilot-system-service-account-role
+  apiGroup: rbac.authorization.k8s.io
+EOF
+  fi
+# Apply optional ingress-related roles, but don't make the script fail if it fails
+kubectl apply -f - <<EOF || echo "Failed to apply optional ingress-related roles. Nginx ingress is likely not installed. This is not critical and the script will continue."
+# Optional: Role for accessing ingress resources
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: ${SKYPILOT_SA}-role-ingress-nginx
+  namespace: ingress-nginx  # Do not change this namespace
+  labels:
+    parent: skypilot
+rules:
+  - apiGroups: [""]
+    resources: ["services"]
+    verbs: ["list", "get", "watch"]
+  - apiGroups: ["rbac.authorization.k8s.io"]
+    resources: ["roles", "rolebindings"]
+    verbs: ["list", "get", "watch"]
+---
+# Optional: RoleBinding for accessing ingress resources
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: ${SKYPILOT_SA}-rolebinding-ingress-nginx
+  namespace: ingress-nginx  # Do not change this namespace
+  labels:
+    parent: skypilot
+subjects:
+  - kind: ServiceAccount
+    name: ${SKYPILOT_SA}
+    namespace: ${NAMESPACE}
+roleRef:
+  kind: Role
+  name: ${SKYPILOT_SA}-role-ingress-nginx  # Use the same name as the role at line 119
+  apiGroup: rbac.authorization.k8s.io
+EOF
+fi
+
+# Checks if secret entry was defined for Service account. If defined it means that Kubernetes server has a
+# version bellow 1.24, otherwise one must manually create the secret and bind it to the Service account to have a non expiring token.
+# After Kubernetes v1.24 Service accounts no longer generate automatic tokens/secrets.
+# We can use kubectl create token but the token has a expiration time.
+# https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-1.24.md#urgent-upgrade-notes
+SA_SECRET_NAME=$(kubectl get -n ${NAMESPACE} sa/${SKYPILOT_SA} -o "jsonpath={.secrets[0]..name}")
+if [ -z $SA_SECRET_NAME ]
+then
+# Create the secret and bind it to the desired SA
+kubectl apply -f - <<EOF
+apiVersion: v1
+kind: Secret
+type: kubernetes.io/service-account-token
+metadata:
+  name: ${SKYPILOT_SA}
+  namespace: ${NAMESPACE}
+  annotations:
+    kubernetes.io/service-account.name: "${SKYPILOT_SA}"
+  labels:
+    parent: skypilot
+EOF
+
+SA_SECRET_NAME=${SKYPILOT_SA}
+fi
+
+# Sleep for 2 seconds to allow the secret to be created before fetching it.
+sleep 2
+
+# Note: service account token is stored base64-encoded in the secret but must
+# be plaintext in kubeconfig.
+SA_TOKEN=$(kubectl get -n ${NAMESPACE} secrets/${SA_SECRET_NAME} -o "jsonpath={.data['token']}" | base64 ${BASE64_DECODE_FLAG})
+CA_CERT=$(kubectl get -n ${NAMESPACE} secrets/${SA_SECRET_NAME} -o "jsonpath={.data['ca\.crt']}")
+
+# Extract cluster IP from the current context
+CURRENT_CONTEXT=$(kubectl config current-context)
+CURRENT_CLUSTER=$(kubectl config view -o jsonpath="{.contexts[?(@.name == \"${CURRENT_CONTEXT}\"})].context.cluster}")
+CURRENT_CLUSTER_ADDR=$(kubectl config view -o jsonpath="{.clusters[?(@.name == \"${CURRENT_CLUSTER}\"})].cluster.server}")
+
+echo "Writing kubeconfig."
+cat > kubeconfig <<EOF
+apiVersion: v1
+clusters:
+- cluster:
+    certificate-authority-data: ${CA_CERT}
+    server: ${CURRENT_CLUSTER_ADDR}
+  name: ${CURRENT_CLUSTER}
+contexts:
+- context:
+    cluster: ${CURRENT_CLUSTER}
+    user: ${CURRENT_CLUSTER}-${SKYPILOT_SA}
+    namespace: ${NAMESPACE}
+  name: ${CURRENT_CONTEXT}
+current-context: ${CURRENT_CONTEXT}
+kind: Config
+preferences: {}
+users:
+- name: ${CURRENT_CLUSTER}-${SKYPILOT_SA}
+  user:
+    token: ${SA_TOKEN}
+EOF
+
+echo "---
+Done!
+
+Kubeconfig using service acccount '${SKYPILOT_SA}' in namespace '${NAMESPACE}' written at $(pwd)/kubeconfig
+
+Copy the generated kubeconfig file to your ~/.kube/ directory to use it with
+kubectl and skypilot:
+
+# Backup your existing kubeconfig file
+mv ~/.kube/config ~/.kube/config.bak
+cp kubeconfig ~/.kube/config
+
+# Verify that you can access the cluster
+kubectl get pods
+
+Also add this to your ~/.sky/config.yaml to use the new service account:
+
+# ~/.sky/config.yaml
+kubernetes:
+  remote_identity: ${SKYPILOT_SA}
+"

sky/utils/kubernetes/gpu_labeler.py

@@ -101,7 +101,7 @@ def label():
         # Get the list of nodes with GPUs
         gpu_nodes = []
         for node in nodes:
-            if 'nvidia.com/gpu' in node.status.capacity:
+            if kubernetes_utils.get_gpu_resource_key() in node.status.capacity:
                 gpu_nodes.append(node)
 
         print(f'Found {len(gpu_nodes)} GPU nodes in the cluster')
@@ -115,7 +115,7 @@ def label():
             print('Continuing without using nvidia RuntimeClass. '
                   'This may fail on K3s clusters. '
                   'For more details, refer to K3s deployment notes at: '
-                  'https://skypilot.readthedocs.io/en/latest/reference/kubernetes/kubernetes-setup.html')  # pylint: disable=line-too-long
+                  'https://docs.skypilot.co/en/latest/reference/kubernetes/kubernetes-setup.html')  # pylint: disable=line-too-long
             nvidia_exists = False
 
         if nvidia_exists:
@@ -139,10 +139,10 @@ def label():
             # Create the job for this node`
             batch_v1.create_namespaced_job(namespace, job_manifest)
             print(f'Created GPU labeler job for node {node_name}')
-    if len(gpu_nodes) == 0:
+    if not gpu_nodes:
         print('No GPU nodes found in the cluster. If you have GPU nodes, '
               'please ensure that they have the label '
-              '`nvidia.com/gpu: <number of GPUs>`')
+              f'`{kubernetes_utils.get_gpu_resource_key()}: <number of GPUs>`')
     else:
         print('GPU labeling started - this may take 10 min or more to complete.'
               '\nTo check the status of GPU labeling jobs, run '

sky/utils/kubernetes/k8s_gpu_labeler_job.yaml

@@ -14,9 +14,10 @@ spec:
       containers:
       - name: gpu-labeler
         image: us-central1-docker.pkg.dev/skypilot-375900/skypilotk8s/skypilot-gpu:latest # Using this image also serves as a way to "pre-pull" the image onto nodes
-        command:
-          - "python"
-          - "/label_gpus.py"
+        command: ["/bin/bash", "-i", "-c"]
+        args:
+          - |
+            python /label_gpus.py
         env:
         - name: MY_NODE_NAME
           valueFrom:

sky/utils/kubernetes/kubernetes_deploy_utils.py

@@ -0,0 +1,228 @@
+"""Utility functions for deploying Kubernetes clusters."""
+import os
+import shlex
+import subprocess
+import tempfile
+from typing import List
+
+from sky import check as sky_check
+from sky import sky_logging
+from sky.backends import backend_utils
+from sky.provision.kubernetes import utils as kubernetes_utils
+from sky.skylet import constants
+from sky.skylet import log_lib
+from sky.utils import log_utils
+from sky.utils import rich_utils
+from sky.utils import subprocess_utils
+from sky.utils import ux_utils
+
+logger = sky_logging.init_logger(__name__)
+
+
+def deploy_remote_cluster(ip_list: List[str], ssh_user: str, ssh_key: str,
+                          cleanup: bool):
+    success = False
+    path_to_package = os.path.dirname(__file__)
+    up_script_path = os.path.join(path_to_package, 'deploy_remote_cluster.sh')
+    # Get directory of script and run it from there
+    cwd = os.path.dirname(os.path.abspath(up_script_path))
+
+    # Create temporary files for the IPs and SSH key
+    with tempfile.NamedTemporaryFile(mode='w') as ip_file, \
+         tempfile.NamedTemporaryFile(mode='w') as key_file:
+
+        # Write IPs and SSH key to temporary files
+        ip_file.write('\n'.join(ip_list))
+        ip_file.flush()
+
+        key_file.write(ssh_key)
+        key_file.flush()
+        os.chmod(key_file.name, 0o600)
+
+        deploy_command = (f'{up_script_path} {ip_file.name} '
+                          f'{ssh_user} {key_file.name}')
+        if cleanup:
+            deploy_command += ' --cleanup'
+
+        # Convert the command to a format suitable for subprocess
+        deploy_command = shlex.split(deploy_command)
+
+        # Setup logging paths
+        run_timestamp = sky_logging.get_run_timestamp()
+        log_path = os.path.join(constants.SKY_LOGS_DIRECTORY, run_timestamp,
+                                'local_up.log')
+
+        # Check if ~/.kube/config exists:
+        if os.path.exists(os.path.expanduser('~/.kube/config')):
+            logger.info('Found existing kube config. '
+                        'It will be backed up to ~/.kube/config.bak.')
+        if cleanup:
+            msg_str = 'Cleaning up remote cluster...'
+        else:
+            msg_str = 'Deploying remote cluster...'
+        with rich_utils.safe_status(
+                ux_utils.spinner_message(msg_str,
+                                         log_path=log_path,
+                                         is_local=True)):
+            returncode, _, stderr = log_lib.run_with_log(
+                cmd=deploy_command,
+                log_path=log_path,
+                require_outputs=True,
+                stream_logs=False,
+                line_processor=log_utils.SkyRemoteUpLineProcessor(
+                    log_path=log_path, is_local=True),
+                cwd=cwd)
+        if returncode == 0:
+            success = True
+        else:
+            with ux_utils.print_exception_no_traceback():
+                log_hint = ux_utils.log_path_hint(log_path, is_local=True)
+                raise RuntimeError('Failed to deploy remote cluster. '
+                                   f'Full log: {log_hint}'
+                                   f'\nError: {stderr}')
+
+        if success:
+            if cleanup:
+                logger.info(
+                    ux_utils.finishing_message(
+                        '🎉 Remote cluster cleaned up successfully.',
+                        log_path=log_path,
+                        is_local=True))
+            else:
+                logger.info(
+                    ux_utils.finishing_message(
+                        '🎉 Remote cluster deployed successfully.',
+                        log_path=log_path,
+                        is_local=True))
+
+
+def deploy_local_cluster(gpus: bool):
+    cluster_created = False
+
+    # Check if GPUs are available on the host
+    local_gpus_available = backend_utils.check_local_gpus()
+    gpus = gpus and local_gpus_available
+
+    # Check if ~/.kube/config exists:
+    if os.path.exists(os.path.expanduser('~/.kube/config')):
+        curr_context = kubernetes_utils.get_current_kube_config_context_name()
+        skypilot_context = 'kind-skypilot'
+        if curr_context is not None and curr_context != skypilot_context:
+            logger.info(
+                f'Current context in kube config: {curr_context}'
+                '\nWill automatically switch to kind-skypilot after the local '
+                'cluster is created.')
+    message_str = 'Creating local cluster{}...'
+    message_str = message_str.format((' with GPU support (this may take up '
+                                      'to 15 minutes)') if gpus else '')
+    path_to_package = os.path.dirname(__file__)
+    up_script_path = os.path.join(path_to_package, 'create_cluster.sh')
+
+    # Get directory of script and run it from there
+    cwd = os.path.dirname(os.path.abspath(up_script_path))
+    run_command = up_script_path + ' --gpus' if gpus else up_script_path
+    run_command = shlex.split(run_command)
+
+    # Setup logging paths
+    run_timestamp = sky_logging.get_run_timestamp()
+    log_path = os.path.join(constants.SKY_LOGS_DIRECTORY, run_timestamp,
+                            'local_up.log')
+    logger.info(message_str)
+
+    with rich_utils.safe_status(
+            ux_utils.spinner_message(message_str,
+                                     log_path=log_path,
+                                     is_local=True)):
+        returncode, _, stderr = log_lib.run_with_log(
+            cmd=run_command,
+            log_path=log_path,
+            require_outputs=True,
+            stream_logs=False,
+            line_processor=log_utils.SkyLocalUpLineProcessor(log_path=log_path,
+                                                             is_local=True),
+            cwd=cwd)
+
+    # Kind always writes to stderr even if it succeeds.
+    # If the failure happens after the cluster is created, we need
+    # to strip all stderr of "No kind clusters found.", which is
+    # printed when querying with kind get clusters.
+    stderr = stderr.replace('No kind clusters found.\n', '')
+
+    if returncode == 0:
+        cluster_created = True
+    elif returncode == 100:
+        logger.info(
+            ux_utils.finishing_message(
+                'Local cluster already exists.\n',
+                log_path=log_path,
+                is_local=True,
+                follow_up_message=
+                'If you want to delete it instead, run: sky local down'))
+    else:
+        with ux_utils.print_exception_no_traceback():
+            log_hint = ux_utils.log_path_hint(log_path, is_local=True)
+            raise RuntimeError('Failed to create local cluster. '
+                               f'Full log: {log_hint}'
+                               f'\nError: {stderr}')
+    # Run sky check
+    with rich_utils.safe_status('[bold cyan]Running sky check...'):
+        sky_check.check(clouds=['kubernetes'], quiet=True)
+    if cluster_created:
+        # Prepare completion message which shows CPU and GPU count
+        # Get number of CPUs
+        p = subprocess_utils.run(
+            'kubectl get nodes -o jsonpath=\'{.items[0].status.capacity.cpu}\'',
+            capture_output=True)
+        num_cpus = int(p.stdout.decode('utf-8'))
+
+        # GPU count/type parsing
+        gpu_message = ''
+        gpu_hint = ''
+        if gpus:
+            # Get GPU model by querying the node labels
+            label_name_escaped = 'skypilot.co/accelerator'.replace('.', '\\.')
+            gpu_type_cmd = f'kubectl get node skypilot-control-plane -o jsonpath=\"{{.metadata.labels[\'{label_name_escaped}\']}}\"'  # pylint: disable=line-too-long
+            try:
+                # Run the command and capture the output
+                gpu_count_output = subprocess.check_output(gpu_type_cmd,
+                                                           shell=True,
+                                                           text=True)
+                gpu_type_str = gpu_count_output.strip() + ' '
+            except subprocess.CalledProcessError as e:
+                output = str(e.output.decode('utf-8'))
+                logger.warning(f'Failed to get GPU type: {output}')
+                gpu_type_str = ''
+
+            # Get number of GPUs (sum of nvidia.com/gpu resources)
+            gpu_count_command = 'kubectl get nodes -o=jsonpath=\'{range .items[*]}{.status.allocatable.nvidia\\.com/gpu}{\"\\n\"}{end}\' | awk \'{sum += $1} END {print sum}\''  # pylint: disable=line-too-long
+            try:
+                # Run the command and capture the output
+                gpu_count_output = subprocess.check_output(gpu_count_command,
+                                                           shell=True,
+                                                           text=True)
+                gpu_count = gpu_count_output.strip(
+                )  # Remove any extra whitespace
+                gpu_message = f' and {gpu_count} {gpu_type_str}GPUs'
+            except subprocess.CalledProcessError as e:
+                output = str(e.output.decode('utf-8'))
+                logger.warning(f'Failed to get GPU count: {output}')
+                gpu_message = f' with {gpu_type_str}GPU support'
+
+            gpu_hint = (
+                '\nHint: To see the list of GPUs in the cluster, '
+                'run \'sky show-gpus --cloud kubernetes\'') if gpus else ''
+
+        if num_cpus < 2:
+            logger.info('Warning: Local cluster has less than 2 CPUs. '
+                        'This may cause issues with running tasks.')
+        logger.info(
+            ux_utils.finishing_message(
+                message=(f'Local Kubernetes cluster created successfully with '
+                         f'{num_cpus} CPUs{gpu_message}.'),
+                log_path=log_path,
+                is_local=True,
+                follow_up_message=(
+                    '\n`sky launch` can now run tasks locally.\n'
+                    'Hint: To change the number of CPUs, change your docker '
+                    'runtime settings. See https://kind.sigs.k8s.io/docs/user/quick-start/#settings-for-docker-desktop for more info.'  # pylint: disable=line-too-long
+                    f'{gpu_hint}')))