anyscale 0.26.68__py3-none-any.whl → 0.26.70__py3-none-any.whl

anyscale/commands/setup_k8s.py

@@ -75,30 +75,59 @@ class KubernetesCloudSetupCommand:
         functional_verify: bool,
         yes: bool,
         values_file: Optional[str] = None,
+        operator_chart: Optional[str] = None,
+        cloud_id: Optional[str] = None,
+        resource_name: Optional[str] = None,
     ) -> None:
         """
         Main entry point for Kubernetes cloud setup.
 
+        This method handles both:
+        1. Creating a new cloud (when cloud_id is None)
+        2. Adding a resource to an existing cloud (when cloud_id is provided)
+
         Args:
             provider: Cloud provider (aws, gcp)
             region: AWS/GCP region
-            name: Name for the Anyscale cloud
+            name: Name for the Anyscale cloud. If cloud_id is not provided, this will be used to create a new cloud.
             cluster_name: Kubernetes cluster name/context
             namespace: Namespace for the Anyscale operator
             project_id: GCP project ID (required for GCP)
             functional_verify: Whether to run functional verification
             yes: Skip confirmation prompts
             values_file: Optional custom path for Helm values file
+            operator_chart: Optional path to operator chart (skips helm repo add/update)
+            cloud_id: Optional cloud ID for the Anyscale cloud to add the resource to
+            resource_name: Optional name for the cloud resource (will be auto-generated if not provided)
         """
-        self.log.open_block(
-            "Setup", f"Setting up Kubernetes cloud '{name}' on {provider.upper()}"
-        )
+        # Determine if we're creating a new cloud or adding to existing
+        create_cloud = cloud_id is None
+
+        # Validate cloud_id is provided when adding to existing cloud
+        if not create_cloud:
+            assert (
+                cloud_id
+            ), "cloud_id is required when adding a resource to an existing cloud"
+
+        # Set up logging message based on mode
+        if create_cloud:
+            setup_message = (
+                f"Setting up Kubernetes cloud '{name}' on {provider.upper()}"
+            )
+        else:
+            setup_message = f"Setting up Kubernetes cloud resource for '{name}' on {provider.upper()}"
+
+        self.log.open_block("Setup", setup_message)
 
         # Set confirmation flag
         self.skip_confirmation = yes
 
+        # Track what resources were created for cleanup messaging
+        infrastructure = None
+        cluster_info = None
+        cloud_resource_id = None
+
         try:
-            # Step 0: Check required CLI tools are installed
             self._check_required_tools(provider)
 
             # Step 1: Prompt for namespace BEFORE infrastructure setup
@@ -117,29 +146,74 @@ class KubernetesCloudSetupCommand:
                 provider, region, name, cluster_info
             )
 
-            # Step 4: Register cloud with Anyscale
-            cloud_id = self._register_cloud(
-                name, provider, region, infrastructure, cluster_info
-            )
+            # Step 4: Register cloud OR create cloud resource
+            if create_cloud:
+                # Register new cloud with Anyscale
+                cloud_id = self._register_cloud(
+                    name, provider, region, infrastructure, cluster_info
+                )
+
+                # Get the cloud resource ID from the newly registered cloud
+                cloud_resources = self.cloud_controller.get_decorated_cloud_resources(
+                    cloud_id
+                )
+                if not cloud_resources:
+                    raise click.ClickException(
+                        "No cloud resources found after registration"
+                    )
+                cloud_resource_id = cloud_resources[0].cloud_resource_id
+            else:
+                # Should have been validated earlier, but just in case
+                assert (
+                    cloud_id
+                ), "cloud_id is required when adding a resource to an existing cloud"
+
+                # Create cloud resource in existing cloud
+                cloud_resource_id = self._create_cloud_resource(
+                    cloud_id,
+                    provider,
+                    region,
+                    infrastructure,
+                    cluster_info,
+                    resource_name,
+                )
 
             # Step 5: Install Anyscale operator
             self._install_operator(
-                cloud_id,
+                cloud_resource_id,
                 provider,
                 region,
                 final_namespace,
                 infrastructure,
                 values_file,
+                operator_chart,
+                skip_confirmation=yes,
             )
 
             # Step 6: Verify installation
             if functional_verify:
-                self._verify_installation(cloud_id, final_namespace, cluster_info)
+                self._verify_installation(
+                    cloud_id, final_namespace, cluster_info, cloud_resource_id
+                )
 
             self.log.close_block("Setup")
-            self.log.info(f"Kubernetes cloud '{name}' setup completed successfully!")
+            if create_cloud:
+                self.log.info(
+                    f"Kubernetes cloud '{name}' setup completed successfully!"
+                )
+            else:
+                self.log.info(
+                    f"Kubernetes cloud resource setup for '{name}' completed successfully!"
+                )
         except Exception:  # noqa: BLE001
             self.log.close_block("Setup")
+            self._handle_setup_failure(
+                provider,
+                infrastructure,
+                cloud_id,
+                name,
+                is_cloud_resource_setup=not create_cloud,
+            )
             raise
 
     def _debug(self, *msg: str) -> None:
@@ -1128,14 +1202,16 @@ class KubernetesCloudSetupCommand:
                 self.cloud_controller.log.info = original_log_info
 
             self._debug("Cloud registration completed, fetching cloud ID...")
-            clouds = (
-                self.cloud_controller.api_client.list_clouds_api_v2_clouds_get().results
-            )
-            cloud = next((c for c in clouds if c.name == name), None)
-            if not cloud:
-                raise click.ClickException("Failed to find registered cloud")
+            # Use get_cloud_id_and_name helper to fetch the registered cloud
+            from anyscale.cloud_utils import get_cloud_id_and_name
+
+            try:
+                cloud_id, _ = get_cloud_id_and_name(
+                    self.cloud_controller.api_client, cloud_name=name
+                )
+            except Exception as e:  # noqa: BLE001
+                raise click.ClickException(f"Failed to find registered cloud: {e}")
 
-            cloud_id = getattr(cloud, "id", None) or getattr(cloud, "cloud_id", None)
             if not cloud_id:
                 raise click.ClickException(
                     "Failed to get cloud ID from registered cloud"
@@ -1159,26 +1235,23 @@ class KubernetesCloudSetupCommand:
 
     def _install_operator(  # noqa: PLR0913
         self,
-        cloud_id: str,
+        cloud_resource_id: str,
         provider: str,
         region: str,
         namespace: str,
         infrastructure: InfrastructureResources,
         values_file: Optional[str] = None,
+        operator_chart: Optional[str] = None,
+        skip_confirmation: bool = False,
     ) -> None:
         """Install the Anyscale operator using Helm."""
         self.log.info("Installing Anyscale operator...", block_label="Setup")
 
-        # Get cloud resources to get the cloud resource ID
-        cloud_resources = self.cloud_controller.get_decorated_cloud_resources(cloud_id)
-
-        if not cloud_resources:
-            raise click.ClickException("No cloud resources found")
-
-        cloud_resource_id = cloud_resources[0].cloud_resource_id
-
         release_name = "anyscale-operator"
 
+        # Prompt user about nginx ingress installation
+        install_nginx = self._prompt_for_nginx_ingress(skip_confirmation)
+
         # Generate Helm command and extract --set-string flags from it
         self._debug("Generating Helm command to extract parameters...")
         helm_command = self.cloud_controller._generate_helm_upgrade_command(  # noqa: SLF001
@@ -1199,16 +1272,24 @@ class KubernetesCloudSetupCommand:
             infrastructure=infrastructure,
             custom_path=values_file,
             additional_values=set_string_values,
+            install_nginx_ingress=install_nginx,
         )
 
-        # Add Helm repo before installing
-        self._debug("Adding Anyscale Helm repository...")
-        self._add_helm_repo()
+        # Determine chart reference based on operator_chart parameter
+        if operator_chart:
+            # Use the provided chart path directly
+            self._debug(f"Using operator chart from: {operator_chart}")
+            chart_reference = operator_chart
+        else:
+            # Add Helm repo before installing
+            self._debug("Adding Anyscale Helm repository...")
+            self._add_helm_repo()
+            chart_reference = "anyscale/anyscale-operator"
 
         # Build a simple Helm command that only uses the values file
         self._debug("Generating Helm command...")
         helm_command = (
-            f"helm upgrade {release_name} anyscale/anyscale-operator "
+            f"helm upgrade {release_name} {chart_reference} "
             f"--values {values_file_path} "
             f"--namespace {namespace} "
             f"--create-namespace "
@@ -1276,6 +1357,35 @@ class KubernetesCloudSetupCommand:
 
         return set_string_values
 
+    def _set_nested_value(self, d: Dict[str, Any], key_path: str, value: Any) -> None:
+        """
+        Set a value in a nested dictionary using a dotted key path.
+
+        Args:
+            d: The dictionary to modify
+            key_path: Dotted key path (e.g., "workloads.serviceaccount.name")
+            value: The value to set
+
+        Example:
+            _set_nested_value({}, "workloads.serviceaccount.name", "my-sa")
+            # Results in: {"workloads": {"serviceaccount": {"name": "my-sa"}}}
+        """
+        keys = key_path.split(".")
+        current = d
+
+        # Navigate/create the nested structure
+        for key in keys[:-1]:
+            if key not in current:
+                current[key] = {}
+            elif not isinstance(current[key], dict):
+                # If the key exists but isn't a dict, we have a conflict
+                # In this case, we'll overwrite it with a dict
+                current[key] = {}
+            current = current[key]
+
+        # Set the final value
+        current[keys[-1]] = value
+
     def _prompt_for_namespace(
         self, default_namespace: str, skip_confirmation: bool = False
     ) -> str:
@@ -1287,10 +1397,12 @@ class KubernetesCloudSetupCommand:
             return final_namespace
 
         self.log.info("Configuring Kubernetes namespace...")
-
         self.log.info(
-            f"Enter the namespace to use for the Anyscale operator (default: {final_namespace}):"
+            f"Specify the namespace to use for the Anyscale operator (leave blank for default: {final_namespace})."
         )
+        self.log.info("If the namespace does not exist, it will be created.")
+        self.log.info("Enter your namespace:")
+
         final_namespace = click.prompt("", default=final_namespace, show_default=True)
 
         # Validate namespace (Kubernetes DNS-1123 label requirements)
@@ -1310,6 +1422,36 @@ class KubernetesCloudSetupCommand:
 
         return final_namespace
 
+    def _prompt_for_nginx_ingress(self, skip_confirmation: bool = False) -> bool:
+        """Prompt user whether to install nginx ingress subchart."""
+        if skip_confirmation:
+            self.log.info("Using default: nginx ingress subchart will be installed")
+            return True
+
+        self.log.info(
+            "The Anyscale operator can install an nginx ingress controller as part of the setup.",
+            block_label="Setup",
+        )
+        self.log.info(
+            "If you already have an ingress controller installed, you may want to skip this.",
+            block_label="Setup",
+        )
+
+        response = click.confirm(
+            "Do you want to install the nginx ingress subchart?", default=True
+        )
+
+        if response:
+            self.log.info(
+                "nginx ingress subchart will be installed", block_label="Setup"
+            )
+        else:
+            self.log.info(
+                "nginx ingress subchart will NOT be installed", block_label="Setup"
+            )
+
+        return response
+
     def _generate_helm_values_file(  # noqa: PLR0913
         self,
         provider: str,
@@ -1319,29 +1461,36 @@ class KubernetesCloudSetupCommand:
         infrastructure: InfrastructureResources,
         custom_path: Optional[str] = None,
         additional_values: Optional[Dict[str, str]] = None,
+        install_nginx_ingress: bool = True,
     ) -> str:
         """Generate Helm values file and save it locally."""
         self.log.info("Generating Helm values file...")
 
-        # Create values dictionary starting with base values
-        values: Dict[str, Any] = {
-            "global": {
-                "cloudDeploymentId": cloud_deployment_id,
-                "cloudProvider": provider,
-                "region": region,
-                "auth": {"iamIdentity": infrastructure.iam_role_arn,},
-            },
-            "ingress-nginx": {"enabled": True},
-        }
+        # Start with an empty dictionary to build up values
+        values: Dict[str, Any] = {}
 
+        # First, parse and merge additional_values with nested keys
         if additional_values:
             for key, value in additional_values.items():
-                if key not in values:
-                    values[key] = value
+                self._set_nested_value(values, key, value)
+
+        # Now overlay our constants on top (these take precedence)
+        # Use _set_nested_value to ensure proper nesting
+        self._set_nested_value(values, "global.cloudDeploymentId", cloud_deployment_id)
+        self._set_nested_value(values, "global.cloudProvider", provider)
+        self._set_nested_value(
+            values, "global.auth.iamIdentity", infrastructure.iam_role_arn
+        )
+        self._set_nested_value(values, "ingress-nginx.enabled", install_nginx_ingress)
+
+        # Add region for AWS only (using global.aws.region)
+        # Region field is deprecated for other providers
+        if provider == "aws":
+            self._set_nested_value(values, "global.aws.region", region)
 
         # Add control plane URL from ANYSCALE_HOST environment variable
         if ANYSCALE_HOST:
-            values["controlPlaneURL"] = ANYSCALE_HOST
+            self._set_nested_value(values, "global.controlPlaneURL", ANYSCALE_HOST)
             self.log.info(f"Using control plane URL: {ANYSCALE_HOST}")
 
         if custom_path:
@@ -1384,7 +1533,11 @@ class KubernetesCloudSetupCommand:
             )
 
     def _verify_installation(
-        self, cloud_id: str, namespace: str, cluster_info: ClusterInfo
+        self,
+        cloud_id: str,
+        namespace: str,
+        cluster_info: ClusterInfo,
+        cloud_resource_id: Optional[str] = None,
     ) -> None:
         """Verify the Kubernetes installation."""
         self.log.info("Verifying installation...")
@@ -1395,7 +1548,20 @@ class KubernetesCloudSetupCommand:
         if not cloud_resources:
             raise click.ClickException("No cloud resources found for verification")
 
-        cloud_deployment = cloud_resources[0]
+        # Find the specific cloud resource if cloud_resource_id is provided
+        cloud_deployment = None
+        if cloud_resource_id:
+            for resource in cloud_resources:
+                if resource.cloud_resource_id == cloud_resource_id:
+                    cloud_deployment = resource
+                    break
+            if not cloud_deployment:
+                raise click.ClickException(
+                    f"Could not find cloud resource with ID {cloud_resource_id}"
+                )
+        else:
+            # Fallback to first resource for backward compatibility
+            cloud_deployment = cloud_resources[0]
 
         # Use the existing Kubernetes verifier
         verifier = KubernetesCloudDeploymentVerifier(
@@ -1417,6 +1583,314 @@ class KubernetesCloudSetupCommand:
             self.log.error("Verification failed - please check the logs above")
             raise click.ClickException("Installation verification failed")
 
+    def _create_cloud_resource(  # noqa: PLR0912
+        self,
+        cloud_id: str,
+        provider: str,
+        region: str,
+        infrastructure: InfrastructureResources,
+        cluster_info: ClusterInfo,
+        resource_name: Optional[str],
+    ) -> str:
+        """
+        Create a cloud resource in an existing cloud and return the cloud_resource_id.
+
+        Args:
+            cloud_id: ID of the existing cloud
+            provider: Cloud provider (aws, gcp)
+            region: Cloud region
+            infrastructure: Infrastructure resources created
+            cluster_info: Cluster information
+            resource_name: Name for the cloud resource (optional, will be auto-generated if not provided)
+
+        Returns:
+            The cloud_resource_id of the created resource
+        """
+        self.log.info("Creating cloud resource in Anyscale...", block_label="Setup")
+        if resource_name:
+            self.log.info(f"Using resource name: {resource_name}", block_label="Setup")
+        else:
+            self.log.info("Resource name will be auto-generated", block_label="Setup")
+
+        if provider == "aws":
+            # Dynamically determine availability zones from the EKS cluster
+            zones = self._get_eks_availability_zones(cluster_info.cluster_name, region)
+
+            cloud_deployment = CloudDeployment(
+                name=resource_name,
+                provider=CloudProviders.AWS,
+                region=region,
+                compute_stack=ComputeStack.K8S,
+                object_storage=ObjectStorage(
+                    bucket_name=infrastructure.bucket_name, region=region
+                ),
+                aws_config=AWSConfig(),
+                kubernetes_config=OpenAPIKubernetesConfig(
+                    anyscale_operator_iam_identity=infrastructure.iam_role_arn,
+                    zones=zones,
+                ),
+            )
+        elif provider == "gcp":
+            assert infrastructure.project_id, "Project ID is required for GCP"
+
+            from anyscale.client.openapi_client.models import GCPConfig
+
+            # Dynamically determine zones from the GKE cluster
+            zones = self._get_gke_zones(
+                cluster_info.cluster_name, region, infrastructure.project_id
+            )
+
+            cloud_deployment = CloudDeployment(
+                name=resource_name,
+                provider=CloudProviders.GCP,
+                region=region,
+                compute_stack=ComputeStack.K8S,
+                object_storage=ObjectStorage(
+                    bucket_name=infrastructure.bucket_name, region=region
+                ),
+                gcp_config=GCPConfig(project_id=infrastructure.project_id),
+                kubernetes_config=OpenAPIKubernetesConfig(
+                    anyscale_operator_iam_identity=infrastructure.iam_role_arn,
+                    zones=zones,
+                ),
+            )
+        else:
+            raise click.ClickException(f"Unsupported provider: {provider}")
+
+        # Create cloud resource using the API
+        try:
+            self._debug("Cloud deployment details:")
+            self._debug(f"  Provider: {cloud_deployment.provider}")
+            self._debug(f"  Region: {cloud_deployment.region}")
+            self._debug(f"  Compute Stack: {cloud_deployment.compute_stack}")
+            self._debug(f"  Bucket Name: {cloud_deployment.object_storage.bucket_name}")
+            self._debug(
+                f"  IAM Identity: {cloud_deployment.kubernetes_config.anyscale_operator_iam_identity}"
+            )
+
+            # Save cloud deployment to a temporary file and use create_cloud_resource
+            self._debug("Saving cloud deployment to temporary file...")
+            import tempfile
+
+            with tempfile.NamedTemporaryFile(
+                mode="w", suffix=".yaml", delete=False
+            ) as temp_file:
+                # Convert CloudDeployment to dict for YAML serialization
+                deployment_dict = cloud_deployment.to_dict()
+                yaml.dump(deployment_dict, temp_file, default_flow_style=False)
+                temp_file_path = temp_file.name
+
+            try:
+                self._debug(f"Created temporary spec file: {temp_file_path}")
+                self._debug("Calling cloud_controller.create_cloud_resource...")
+
+                # Use cloud_controller's create_cloud_resource method which now returns the cloud_resource_id
+                cloud_resource_id = self.cloud_controller.create_cloud_resource(
+                    cloud=None,
+                    cloud_id=cloud_id,
+                    spec_file=temp_file_path,
+                    skip_verification=True,  # We will do verification in the _verify_installation method
+                    yes=True,  # Skip confirmation prompts
+                )
+            finally:
+                # Clean up the temporary file
+                import os as os_module
+
+                try:
+                    os_module.unlink(temp_file_path)
+                    self._debug(f"Cleaned up temporary file: {temp_file_path}")
+                except Exception as e:  # noqa: BLE001
+                    self._debug(f"Failed to clean up temporary file: {e}")
+
+            self.log.info(
+                f"Cloud resource created with ID: {cloud_resource_id}",
+                block_label="Setup",
+            )
+
+            return cloud_resource_id
+
+        except Exception as e:  # noqa: BLE001
+            self.log.error(f"Cloud resource creation failed with error: {e}")
+            self.log.error(f"Error type: {type(e).__name__}")
+            if hasattr(e, "response"):
+                self.log.error(f"Response details: {getattr(e, 'response', 'N/A')}")
+            if hasattr(e, "args"):
+                self.log.error(f"Error args: {e.args}")
+            import traceback
+
+            self.log.error(f"Full traceback: {traceback.format_exc()}")
+            raise click.ClickException(f"Failed to create cloud resource: {e}")
+
+    def _handle_setup_failure(
+        self,
+        provider: str,
+        infrastructure: Optional[InfrastructureResources],
+        cloud_id: Optional[str],
+        name: str,
+        is_cloud_resource_setup: bool = False,
+    ) -> None:
+        """Handle setup failure by providing cleanup instructions to the user."""
+        self.log.error("")
+        self.log.error("=" * 80)
+        self.log.error("SETUP FAILED - MANUAL CLEANUP REQUIRED")
+        self.log.error("=" * 80)
+        self.log.error("")
+
+        if is_cloud_resource_setup:
+            self.log.error(
+                "The Kubernetes cloud resource setup failed, leaving resources in an incomplete state."
+            )
+        else:
+            self.log.error(
+                "The Kubernetes cloud setup failed, leaving resources in an incomplete state."
+            )
+
+        self.log.error(
+            "You must manually clean up the following resources to avoid charges:"
+        )
+        self.log.error("")
+
+        if provider == "aws":
+            self._log_aws_cleanup_instructions(
+                infrastructure, cloud_id, name, is_cloud_resource_setup
+            )
+        elif provider == "gcp":
+            self._log_gcp_cleanup_instructions(
+                infrastructure, cloud_id, name, is_cloud_resource_setup
+            )
+
+        self.log.error("")
+        self.log.error("=" * 80)
+
+    def _log_aws_cleanup_instructions(
+        self,
+        infrastructure: Optional[InfrastructureResources],
+        cloud_id: Optional[str],
+        name: str,
+        is_cloud_resource_setup: bool = False,
+    ) -> None:
+        """Log AWS-specific cleanup instructions."""
+        self.log.error("AWS Resources to clean up:")
+        self.log.error("")
+
+        if infrastructure:
+            self.log.error("1. CloudFormation Stack:")
+            # Stack name pattern: k8s-{name}-{random} with underscores replaced by hyphens
+            stack_name_pattern = f"k8s-{name}-*".replace("_", "-").lower()
+            self.log.error(
+                f"   - Find and delete the CloudFormation stack matching pattern: {stack_name_pattern}"
+            )
+            self.log.error(f"   - Region: {infrastructure.region}")
+            self.log.error(
+                "   - AWS Console: CloudFormation > Stacks > Select stack > Delete"
+            )
+            self.log.error(
+                f"   - AWS CLI: aws cloudformation delete-stack --stack-name <stack-name> --region {infrastructure.region}"
+            )
+            self.log.error("")
+            self.log.error("   This will automatically delete:")
+            self.log.error(f"   - S3 Bucket: {infrastructure.bucket_name}")
+            self.log.error(f"   - IAM Role: {infrastructure.iam_role_arn}")
+            self.log.error("")
+
+        if cloud_id:
+            if is_cloud_resource_setup:
+                self.log.error("2. Anyscale Cloud Resource:")
+                self.log.error(
+                    f"   - Delete the cloud resource from cloud '{name}' (ID: {cloud_id})"
+                )
+                self.log.error(
+                    f"   - CLI: anyscale cloud resource delete --cloud '{name}' --resource <resource-name>"
+                )
+                self.log.error(
+                    "   - To find the resource name, run: anyscale cloud get --name '{name}'"
+                )
+                self.log.error(
+                    f"   - Console: {ANYSCALE_HOST}/clouds (if using custom host)"
+                )
+            else:
+                self.log.error("2. Anyscale Cloud Registration:")
+                self.log.error(
+                    f"   - Delete the cloud '{name}' (ID: {cloud_id}) from Anyscale"
+                )
+                self.log.error(f"   - CLI: anyscale cloud delete --name '{name}'")
+                self.log.error(
+                    f"   - Console: {ANYSCALE_HOST}/clouds (if using custom host)"
+                )
+            self.log.error("")
+
+        if not infrastructure:
+            self.log.error(
+                "No infrastructure resources were created before the failure."
+            )
+            self.log.error("")
+
+    def _log_gcp_cleanup_instructions(
+        self,
+        infrastructure: Optional[InfrastructureResources],
+        cloud_id: Optional[str],
+        name: str,
+        is_cloud_resource_setup: bool = False,
+    ) -> None:
+        """Log GCP-specific cleanup instructions."""
+        self.log.error("GCP Resources to clean up:")
+        self.log.error("")
+
+        if infrastructure:
+            self.log.error("1. GCS Bucket:")
+            self.log.error(f"   - Bucket: {infrastructure.bucket_name}")
+            self.log.error(f"   - Project: {infrastructure.project_id}")
+            self.log.error(
+                "   - GCP Console: Cloud Storage > Buckets > Select bucket > Delete"
+            )
+            self.log.error(
+                f"   - gcloud CLI: gsutil rm -r gs://{infrastructure.bucket_name}"
+            )
+            self.log.error("")
+
+            self.log.error("2. Service Account:")
+            self.log.error(f"   - Service Account: {infrastructure.iam_role_arn}")
+            self.log.error(f"   - Project: {infrastructure.project_id}")
+            self.log.error(
+                "   - GCP Console: IAM & Admin > Service Accounts > Select account > Delete"
+            )
+            self.log.error(
+                f"   - gcloud CLI: gcloud iam service-accounts delete {infrastructure.iam_role_arn} --project={infrastructure.project_id}"
+            )
+            self.log.error("")
+
+        if cloud_id:
+            if is_cloud_resource_setup:
+                self.log.error("3. Anyscale Cloud Resource:")
+                self.log.error(
+                    f"   - Delete the cloud resource from cloud '{name}' (ID: {cloud_id})"
+                )
+                self.log.error(
+                    f"   - CLI: anyscale cloud resource delete --cloud '{name}' --resource <resource-name>"
+                )
+                self.log.error(
+                    "   - To find the resource name, run: anyscale cloud get --name '{name}'"
+                )
+                self.log.error(
+                    f"   - Console: {ANYSCALE_HOST}/clouds (if using custom host)"
+                )
+            else:
+                self.log.error("3. Anyscale Cloud Registration:")
+                self.log.error(
+                    f"   - Delete the cloud '{name}' (ID: {cloud_id}) from Anyscale"
+                )
+                self.log.error(f"   - CLI: anyscale cloud delete --name '{name}'")
+            self.log.error(
+                f"   - Console: {ANYSCALE_HOST}/clouds (if using custom host)"
+            )
+            self.log.error("")
+
+        if not infrastructure:
+            self.log.error(
+                "No infrastructure resources were created before the failure."
+            )
+            self.log.error("")
+
 
 def setup_kubernetes_cloud(  # noqa: PLR0913
     provider: str,
@@ -1429,6 +1903,7 @@ def setup_kubernetes_cloud(  # noqa: PLR0913
     yes: bool = False,
     values_file: Optional[str] = None,
     debug: bool = False,
+    operator_chart: Optional[str] = None,
 ) -> None:
     """
     Set up Anyscale on a Kubernetes cluster.
@@ -1447,6 +1922,7 @@ def setup_kubernetes_cloud(  # noqa: PLR0913
         yes: Skip confirmation prompts
         values_file: Optional path for Helm values file
         debug: Enable debug logging
+        operator_chart: Optional path to operator chart (skips helm repo add/update)
     """
     cmd = KubernetesCloudSetupCommand(debug=debug)
 
@@ -1461,6 +1937,96 @@ def setup_kubernetes_cloud(  # noqa: PLR0913
             functional_verify=functional_verify,
             yes=yes,
             values_file=values_file,
+            operator_chart=operator_chart,
+        )
+    except Exception as e:  # noqa: BLE001
+        click.echo(f"Setup failed: {e}", err=True)
+        raise click.Abort()
+
+
+def setup_kubernetes_cloud_resource(  # noqa: PLR0913
+    provider: str,
+    region: str,
+    cloud_name: Optional[str],
+    cloud_id: Optional[str],
+    cluster_name: str,
+    resource_name: Optional[str],
+    namespace: str = "anyscale-operator",
+    project_id: Optional[str] = None,
+    functional_verify: bool = False,
+    yes: bool = False,
+    values_file: Optional[str] = None,
+    debug: bool = False,
+    operator_chart: Optional[str] = None,
+) -> None:
+    """
+    Set up cloud resources for an existing Anyscale cloud on a Kubernetes cluster.
+
+    This function sets up infrastructure and installs the operator without
+    registering a new cloud.
+
+    Args:
+        provider: Cloud provider (aws, gcp)
+        region: Cloud region
+        cloud_name: Name of existing Anyscale cloud
+        cloud_id: ID of existing Anyscale cloud
+        cluster_name: Kubernetes cluster name
+        resource_name: Name for the cloud resource (optional, will be auto-generated if not provided)
+        namespace: Namespace for Anyscale operator (default: anyscale-operator)
+        project_id: GCP project ID (optional, for GCP)
+        functional_verify: Whether to run functional verification
+        yes: Skip confirmation prompts
+        values_file: Optional path for Helm values file
+        debug: Enable debug logging
+        operator_chart: Optional path to operator chart (skips helm repo add/update)
+    """
+    cmd = KubernetesCloudSetupCommand(debug=debug)
+
+    # Preprocessing: Fetch full cloud info to ensure cloud exists and get both name and ID
+    if not cloud_id and not cloud_name:
+        click.echo("Either cloud_name or cloud_id must be provided", err=True)
+        raise click.Abort()
+
+    if cloud_id and cloud_name:
+        click.echo("Only one of cloud_name or cloud_id can be provided", err=True)
+        raise click.Abort()
+
+    # Use get_cloud_id_and_name to validate cloud exists and get both ID and name
+    try:
+        from anyscale.cloud_utils import get_cloud_id_and_name
+
+        if cloud_id:
+            cloud_id, cloud_name = get_cloud_id_and_name(
+                cmd.cloud_controller.api_client, cloud_id=cloud_id
+            )
+        else:
+            cloud_id, cloud_name = get_cloud_id_and_name(
+                cmd.cloud_controller.api_client, cloud_name=cloud_name
+            )
+
+    except Exception as e:  # noqa: BLE001
+        click.echo(f"Failed to fetch cloud information: {e}", err=True)
+        raise click.Abort()
+
+    if not cloud_id or not cloud_name:
+        click.echo("Could not find cloud with provided name or ID", err=True)
+        raise click.Abort()
+
+    try:
+        # Use the unified run method with cloud_id to indicate resource-only mode
+        cmd.run(
+            provider=provider,
+            region=region,
+            name=cloud_name,
+            cluster_name=cluster_name,
+            namespace=namespace,
+            project_id=project_id,
+            functional_verify=functional_verify,
+            yes=yes,
+            values_file=values_file,
+            operator_chart=operator_chart,
+            cloud_id=cloud_id,
+            resource_name=resource_name,
         )
     except Exception as e:  # noqa: BLE001
         click.echo(f"Setup failed: {e}", err=True)