zenml-nightly 0.55.0.dev20240124__py3-none-any.whl → 0.72.0.dev20250116__py3-none-any.whl

zenml/cli/stack.py

@@ -12,57 +12,71 @@
 #  or implied. See the License for the specific language governing
 #  permissions and limitations under the License.
 """CLI for manipulating ZenML local and global config file."""
+
 import getpass
-import os
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+import re
+import time
+import webbrowser
+from datetime import datetime
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    List,
+    Optional,
+    Set,
+    Union,
+)
 from uuid import UUID
 
 import click
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.prompt import Confirm
+from rich.style import Style
+from rich.syntax import Syntax
 
 import zenml
 from zenml.analytics.enums import AnalyticsEvent
 from zenml.analytics.utils import track_handler
 from zenml.cli import utils as cli_utils
 from zenml.cli.cli import TagGroup, cli
+from zenml.cli.text_utils import OldSchoolMarkdownHeading
 from zenml.cli.utils import (
     _component_display_name,
-    confirmation,
-    declare,
-    error,
     is_sorted_or_filtered,
     list_options,
     print_model_url,
     print_page_info,
     print_stacks_table,
-    verify_mlstacks_prerequisites_installation,
 )
 from zenml.client import Client
 from zenml.console import console
-from zenml.constants import (
-    ALPHA_MESSAGE,
-    MLSTACKS_SUPPORTED_STACK_COMPONENTS,
-    STACK_RECIPE_MODULAR_RECIPES,
+from zenml.enums import (
+    CliCategories,
+    StackComponentType,
+    StackDeploymentProvider,
 )
-from zenml.enums import CliCategories, StackComponentType
 from zenml.exceptions import (
     IllegalOperationError,
-    ProvisioningError,
 )
-from zenml.io.fileio import rmtree
 from zenml.logger import get_logger
-from zenml.models import StackFilter
-from zenml.utils.dashboard_utils import get_stack_url
-from zenml.utils.io_utils import create_dir_recursive_if_not_exists
-from zenml.utils.mlstacks_utils import (
-    convert_click_params_to_mlstacks_primitives,
-    convert_mlstacks_primitives_to_dicts,
-    deploy_mlstacks_stack,
-    get_stack_spec_file_path,
-    stack_exists,
-    stack_spec_exists,
-    verify_spec_and_tf_files_exist,
-)
+from zenml.models import (
+    ComponentInfo,
+    ServiceConnectorInfo,
+    ServiceConnectorResourcesInfo,
+    StackFilter,
+    StackRequest,
+)
+from zenml.models.v2.core.service_connector import (
+    ServiceConnectorRequest,
+    ServiceConnectorResponse,
+)
+from zenml.service_connectors.service_connector_utils import (
+    get_resources_options_from_resource_model_for_full_stack,
+)
+from zenml.utils import requirements_utils
+from zenml.utils.dashboard_utils import get_component_url, get_stack_url
 from zenml.utils.yaml_utils import read_yaml, write_yaml
 
 if TYPE_CHECKING:
@@ -92,7 +106,7 @@ def stack() -> None:
     "artifact_store",
     help="Name of the artifact store for this stack.",
     type=str,
-    required=True,
+    required=False,
 )
 @click.option(
     "-o",
@@ -100,7 +114,7 @@ def stack() -> None:
     "orchestrator",
     help="Name of the orchestrator for this stack.",
     type=str,
-    required=True,
+    required=False,
 )
 @click.option(
     "-c",
@@ -189,10 +203,24 @@ def stack() -> None:
     help="Immediately set this stack as active.",
     type=click.BOOL,
 )
+@click.option(
+    "-p",
+    "--provider",
+    help="Name of the cloud provider for this stack.",
+    type=click.Choice(["aws", "azure", "gcp"]),
+    required=False,
+)
+@click.option(
+    "-sc",
+    "--connector",
+    help="Name of the service connector for this stack.",
+    type=str,
+    required=False,
+)
 def register_stack(
     stack_name: str,
-    artifact_store: str,
-    orchestrator: str,
+    artifact_store: Optional[str] = None,
+    orchestrator: Optional[str] = None,
     container_registry: Optional[str] = None,
     model_registry: Optional[str] = None,
     step_operator: Optional[str] = None,
@@ -204,6 +232,8 @@ def register_stack(
     data_validator: Optional[str] = None,
     image_builder: Optional[str] = None,
     set_stack: bool = False,
+    provider: Optional[str] = None,
+    connector: Optional[str] = None,
 ) -> None:
     """Register a stack.
 
@@ -222,44 +252,266 @@ def register_stack(
         data_validator: Name of the data validator for this stack.
         image_builder: Name of the new image builder for this stack.
         set_stack: Immediately set this stack as active.
+        provider: Name of the cloud provider for this stack.
+        connector: Name of the service connector for this stack.
     """
-    with console.status(f"Registering stack '{stack_name}'...\n"):
-        client = Client()
+    if (provider is None and connector is None) and (
+        artifact_store is None or orchestrator is None
+    ):
+        cli_utils.error(
+            "The only way to register a stack without specifying an "
+            "orchestrator and an artifact store is by using either a provider"
+            "(-p/--provider) or an existing service connector "
+            "(-sc/--connector). Please specify the artifact store and "
+            "the orchestrator or the service connector or cloud type settings."
+        )
 
-        components: Dict[StackComponentType, Union[str, UUID]] = dict()
+    client = Client()
 
-        components[StackComponentType.ARTIFACT_STORE] = artifact_store
-        components[StackComponentType.ORCHESTRATOR] = orchestrator
+    if provider is not None or connector is not None:
+        if client.zen_store.is_local_store():
+            cli_utils.error(
+                "You are registering a stack using a service connector, but "
+                "this feature cannot be used with a local ZenML deployment. "
+                "ZenML needs to be accessible from the cloud provider to allow "
+                "the stack and its components to be registered automatically. "
+                "Please deploy ZenML in a remote environment as described in "
+                "the documentation: https://docs.zenml.io/getting-started/deploying-zenml "
+                "or use a managed ZenML Pro server instance for quick access "
+                "to this feature and more: https://www.zenml.io/pro"
+            )
 
-        if alerter:
-            components[StackComponentType.ALERTER] = alerter
-        if annotator:
-            components[StackComponentType.ANNOTATOR] = annotator
-        if data_validator:
-            components[StackComponentType.DATA_VALIDATOR] = data_validator
-        if feature_store:
-            components[StackComponentType.FEATURE_STORE] = feature_store
-        if image_builder:
-            components[StackComponentType.IMAGE_BUILDER] = image_builder
-        if model_deployer:
-            components[StackComponentType.MODEL_DEPLOYER] = model_deployer
-        if model_registry:
-            components[StackComponentType.MODEL_REGISTRY] = model_registry
-        if step_operator:
-            components[StackComponentType.STEP_OPERATOR] = step_operator
-        if experiment_tracker:
-            components[
-                StackComponentType.EXPERIMENT_TRACKER
-            ] = experiment_tracker
-        if container_registry:
-            components[
-                StackComponentType.CONTAINER_REGISTRY
-            ] = container_registry
+    try:
+        client.get_stack(
+            name_id_or_prefix=stack_name,
+            allow_name_prefix_match=False,
+        )
+        cli_utils.error(
+            f"A stack with name `{stack_name}` already exists, "
+            "please use a different name."
+        )
+    except KeyError:
+        pass
 
+    labels: Dict[str, str] = {}
+    components: Dict[StackComponentType, List[Union[UUID, ComponentInfo]]] = {}
+
+    # Cloud Flow
+    created_objects: Set[str] = set()
+    service_connector: Optional[Union[UUID, ServiceConnectorInfo]] = None
+    if provider is not None and connector is None:
+        service_connector_response = None
+        use_auto_configure = False
         try:
-            created_stack = client.create_stack(
+            service_connector_response, _ = client.create_service_connector(
                 name=stack_name,
-                components=components,
+                connector_type=provider,
+                register=False,
+                auto_configure=True,
+                verify=False,
+            )
+        except NotImplementedError:
+            cli_utils.warning(
+                f"The {provider.upper()} service connector libraries are not "
+                "installed properly. Please run `zenml integration install "
+                f"{provider}` and try again to enable auto-discovery of the "
+                "connection configuration."
+            )
+        except Exception:
+            pass
+
+        if service_connector_response:
+            use_auto_configure = Confirm.ask(
+                f"[bold]{provider.upper()} cloud service connector[/bold] "
+                "has detected connection credentials in your environment.\n"
+                "Would you like to use these credentials or create a new "
+                "configuration by providing connection details?",
+                default=True,
+                show_choices=True,
+                show_default=True,
+            )
+
+        connector_selected: Optional[int] = None
+        if not use_auto_configure:
+            service_connector_response = None
+            existing_connectors = client.list_service_connectors(
+                connector_type=provider, size=100
+            )
+            if existing_connectors.total:
+                connector_selected = cli_utils.multi_choice_prompt(
+                    object_type=f"{provider.upper()} service connectors",
+                    choices=[
+                        [connector.name]
+                        for connector in existing_connectors.items
+                    ],
+                    headers=["Name"],
+                    prompt_text=f"We found these {provider.upper()} service "
+                    "connectors. Do you want to create a new one or use one "
+                    "of the existing ones?",
+                    default_choice="0",
+                    allow_zero_be_a_new_object=True,
+                )
+        if use_auto_configure or connector_selected is None:
+            service_connector = _get_service_connector_info(
+                cloud_provider=provider,
+                connector_details=service_connector_response,
+            )
+            created_objects.add("service_connector")
+        else:
+            selected_connector = existing_connectors.items[connector_selected]
+            service_connector = selected_connector.id
+            connector = selected_connector.name
+            if isinstance(selected_connector.connector_type, str):
+                provider = selected_connector.connector_type
+            else:
+                provider = selected_connector.connector_type.connector_type
+    elif connector is not None:
+        service_connector_response = client.get_service_connector(connector)
+        service_connector = service_connector_response.id
+        if provider:
+            if service_connector_response.type != provider:
+                cli_utils.warning(
+                    f"The service connector `{connector}` is not of type `{provider}`."
+                )
+        else:
+            provider = service_connector_response.type
+
+    if service_connector:
+        labels["zenml:wizard"] = "true"
+        if provider:
+            labels["zenml:provider"] = provider
+        resources_info = None
+        # explore the service connector
+        with console.status(
+            "Exploring resources available to the service connector...\n"
+        ):
+            resources_info = (
+                get_resources_options_from_resource_model_for_full_stack(
+                    connector_details=service_connector
+                )
+            )
+        if resources_info is None:
+            cli_utils.error(
+                f"Failed to fetch service connector resources information for {service_connector}..."
+            )
+
+        # create components
+        needed_components = (
+            (StackComponentType.ARTIFACT_STORE, artifact_store),
+            (StackComponentType.ORCHESTRATOR, orchestrator),
+            (StackComponentType.CONTAINER_REGISTRY, container_registry),
+        )
+        for component_type, preset_name in needed_components:
+            component_info: Optional[Union[UUID, ComponentInfo]] = None
+            if preset_name is not None:
+                component_response = client.get_stack_component(
+                    component_type, preset_name
+                )
+                component_info = component_response.id
+                component_name = component_response.name
+            else:
+                if isinstance(service_connector, UUID):
+                    # find existing components under same connector
+                    if (
+                        component_type
+                        in resources_info.components_resources_info
+                    ):
+                        existing_components = [
+                            existing_response
+                            for res_info in resources_info.components_resources_info[
+                                component_type
+                            ]
+                            for existing_response in res_info.connected_through_service_connector
+                        ]
+
+                        # if some existing components are found - prompt user what to do
+                        component_selected: Optional[int] = None
+                        component_selected = cli_utils.multi_choice_prompt(
+                            object_type=component_type.value.replace("_", " "),
+                            choices=[
+                                [
+                                    component.flavor_name,
+                                    component.name,
+                                    component.configuration or "",
+                                    component.connector_resource_id,
+                                ]
+                                for component in existing_components
+                            ],
+                            headers=[
+                                "Type",
+                                "Name",
+                                "Configuration",
+                                "Connected as",
+                            ],
+                            prompt_text=f"We found these {component_type.value.replace('_', ' ')} "
+                            "connected using the current service connector. Do you "
+                            "want to create a new one or use existing one?",
+                            default_choice="0",
+                            allow_zero_be_a_new_object=True,
+                        )
+                else:
+                    component_selected = None
+
+                if component_selected is None:
+                    component_info = _get_stack_component_info(
+                        component_type=component_type.value,
+                        cloud_provider=provider
+                        or resources_info.connector_type,
+                        resources_info=resources_info,
+                        service_connector_index=0,
+                    )
+                    component_name = stack_name
+                    created_objects.add(component_type.value)
+                else:
+                    selected_component = existing_components[
+                        component_selected
+                    ]
+                    component_info = selected_component.id
+                    component_name = selected_component.name
+
+            components[component_type] = [component_info]
+            if component_type == StackComponentType.ARTIFACT_STORE:
+                artifact_store = component_name
+            if component_type == StackComponentType.ORCHESTRATOR:
+                orchestrator = component_name
+            if component_type == StackComponentType.CONTAINER_REGISTRY:
+                container_registry = component_name
+
+    # normal flow once all components are defined
+    with console.status(f"Registering stack '{stack_name}'...\n"):
+        for component_type_, component_name_ in [
+            (StackComponentType.ARTIFACT_STORE, artifact_store),
+            (StackComponentType.ORCHESTRATOR, orchestrator),
+            (StackComponentType.ALERTER, alerter),
+            (StackComponentType.ANNOTATOR, annotator),
+            (StackComponentType.DATA_VALIDATOR, data_validator),
+            (StackComponentType.FEATURE_STORE, feature_store),
+            (StackComponentType.IMAGE_BUILDER, image_builder),
+            (StackComponentType.MODEL_DEPLOYER, model_deployer),
+            (StackComponentType.MODEL_REGISTRY, model_registry),
+            (StackComponentType.STEP_OPERATOR, step_operator),
+            (StackComponentType.EXPERIMENT_TRACKER, experiment_tracker),
+            (StackComponentType.CONTAINER_REGISTRY, container_registry),
+        ]:
+            if component_name_ and component_type_ not in components:
+                components[component_type_] = [
+                    client.get_stack_component(
+                        component_type_, component_name_
+                    ).id
+                ]
+
+        try:
+            created_stack = client.zen_store.create_stack(
+                stack=StackRequest(
+                    user=client.active_user.id,
+                    workspace=client.active_workspace.id,
+                    name=stack_name,
+                    components=components,
+                    service_connectors=[service_connector]
+                    if service_connector
+                    else [],
+                    labels=labels,
+                )
             )
         except (KeyError, IllegalOperationError) as err:
             cli_utils.error(str(err))
@@ -267,6 +519,10 @@ def register_stack(
         cli_utils.declare(
             f"Stack '{created_stack.name}' successfully registered!"
         )
+        cli_utils.print_stack_configuration(
+            stack=created_stack,
+            active=created_stack.id == client.active_stack_model.id,
+        )
 
     if set_stack:
         client.activate_stack(created_stack.id)
@@ -276,6 +532,30 @@ def register_stack(
             f"Active {scope} stack set to:'{created_stack.name}'"
         )
 
+    delete_commands = []
+    if "service_connector" in created_objects:
+        created_objects.remove("service_connector")
+        connectors = set()
+        for each in created_objects:
+            if comps_ := created_stack.components[StackComponentType(each)]:
+                if conn_ := comps_[0].connector:
+                    connectors.add(conn_.name)
+        for connector in connectors:
+            delete_commands.append(
+                "zenml service-connector delete " + connector
+            )
+    for each in created_objects:
+        if comps_ := created_stack.components[StackComponentType(each)]:
+            delete_commands.append(
+                f"zenml {each.replace('_', '-')} delete {comps_[0].name}"
+            )
+    delete_commands.append("zenml stack delete -y " + created_stack.name)
+
+    Console().print(
+        "To delete the objects created by this command run, please run in a sequence:\n"
+    )
+    Console().print(Syntax("\n".join(delete_commands[::-1]), "bash"))
+
     print_model_url(get_stack_url(created_stack))
 
 
@@ -488,7 +768,7 @@ def update_stack(
     "-r",
     "--model_registry",
     "model_registry_flag",
-    help="Include this to remove the the model registry from this stack.",
+    help="Include this to remove the model registry from this stack.",
     is_flag=True,
     required=False,
 )
@@ -689,21 +969,11 @@ def list_stacks(ctx: click.Context, **kwargs: Any) -> None:
     type=click.STRING,
     required=False,
 )
-@click.option(
-    "--outputs",
-    "-o",
-    is_flag=True,
-    default=False,
-    help="Include the outputs from mlstacks deployments.",
-)
-def describe_stack(
-    stack_name_or_id: Optional[str] = None, outputs: bool = False
-) -> None:
+def describe_stack(stack_name_or_id: Optional[str] = None) -> None:
     """Show details about a named stack or the active stack.
 
     Args:
         stack_name_or_id: Name of the stack to describe.
-        outputs: Include the outputs from mlstacks deployments.
     """
     client = Client()
 
@@ -719,8 +989,6 @@ def describe_stack(
             stack=stack_,
             active=stack_.id == client.active_stack_model.id,
         )
-        if outputs:
-            cli_utils.print_stack_outputs(stack_)
 
     print_model_url(get_stack_url(stack_))
 
@@ -805,8 +1073,7 @@ def set_active_stack_command(stack_name_or_id: str) -> None:
             cli_utils.error(str(err))
 
         cli_utils.declare(
-            f"Active {scope} stack set to: "
-            f"'{client.active_stack_model.name}'"
+            f"Active {scope} stack set to: '{client.active_stack_model.name}'"
         )
 
 
@@ -825,51 +1092,6 @@ def get_active_stack() -> None:
             cli_utils.error(str(err))
 
 
-@stack.command("up")
-def up_stack() -> None:
-    """Provisions resources for the active stack."""
-    stack_ = Client().active_stack
-
-    cli_utils.declare(
-        f"Provisioning resources for active stack '{stack_.name}'."
-    )
-    try:
-        stack_.provision()
-        stack_.resume()
-    except ProvisioningError as e:
-        cli_utils.error(str(e))
-
-
-@stack.command(
-    "down", help="Suspends resources of the active stack deployment."
-)
-@click.option(
-    "--force",
-    "-f",
-    "force",
-    is_flag=True,
-    help="Deprovisions local resources instead of suspending them.",
-)
-def down_stack(force: bool = False) -> None:
-    """Suspends resources of the active stack deployment.
-
-    Args:
-        force: Deprovisions local resources instead of suspending them.
-    """
-    stack_ = Client().active_stack
-
-    if force:
-        cli_utils.declare(
-            f"Deprovisioning resources for active stack '{stack_.name}'."
-        )
-        stack_.deprovision()
-    else:
-        cli_utils.declare(
-            f"Suspending resources for active stack '{stack_.name}'."
-        )
-        stack_.suspend()
-
-
 @stack.command("export", help="Exports a stack to a YAML file.")
 @click.argument("stack_name_or_id", type=str, required=False)
 @click.argument("filename", type=str, required=False)
@@ -906,14 +1128,12 @@ def export_stack(
 def _import_stack_component(
     component_type: StackComponentType,
     component_dict: Dict[str, Any],
-    component_spec_path: Optional[str] = None,
 ) -> UUID:
     """Import a single stack component with given type/config.
 
     Args:
         component_type: The type of component to import.
         component_dict: Dict representation of the component to import.
-        component_spec_path: Path to the component spec file.
 
     Returns:
         The ID of the imported component.
@@ -949,7 +1169,6 @@ def _import_stack_component(
         component_type=component_type,
         flavor=flavor,
         configuration=config,
-        component_spec_path=component_spec_path,
     )
     return component.id
 
@@ -1186,483 +1405,256 @@ def register_secrets(
         client.update_secret(secret_name, add_or_update_values=secret_values)
 
 
-def _get_deployment_params_interactively(
-    click_params: Dict[str, Any],
-) -> Dict[str, Any]:
-    """Get deployment values from command line arguments.
+def validate_name(ctx: click.Context, param: str, value: str) -> str:
+    """Validate the name of the stack.
 
     Args:
-        click_params: Required and pre-existing values.
+        ctx: The click context.
+        param: The parameter name.
+        value: The value of the parameter.
 
     Returns:
-        Full deployment arguments.
+        The validated value.
+
+    Raises:
+        BadParameter: If the name is invalid.
     """
-    deployment_values = {
-        "provider": click_params["provider"],
-        "stack_name": click_params["stack_name"],
-        "region": click_params["region"],
-    }
-    for component_type in MLSTACKS_SUPPORTED_STACK_COMPONENTS:
-        verify_mlstacks_prerequisites_installation()
-        from mlstacks.constants import ALLOWED_FLAVORS
-
-        if (
-            click.prompt(
-                f"Enable {component_type}?",
-                type=click.Choice(["y", "n"]),
-                default="n",
-            )
-            == "y"
-        ):
-            component_flavor = click.prompt(
-                f"  Enter {component_type} flavor",
-                type=click.Choice(ALLOWED_FLAVORS[component_type]),
-            )
-            deployment_values[component_type] = component_flavor
+    if not value:
+        return value
 
-    if (
-        click.prompt(
-            "Deploy using debug_mode?",
-            type=click.Choice(["y", "n"]),
-            default="n",
-        )
-        == "y"
-    ):
-        deployment_values["debug_mode"] = True
-
-    extra_config = []
-    # use click.prompt to populate extra_config until someone just hits enter
-    while True:
-        declare(
-            "\nAdd to extra_config for stack deployment -->\n",
-            bold=True,
-        )
-        key = click.prompt(
-            "Enter `extra_config` key or hit enter to skip",
-            type=str,
-            default="",
+    if not re.match(r"^[a-zA-Z0-9-]*$", value):
+        raise click.BadParameter(
+            "Stack name must contain only alphanumeric characters and hyphens."
         )
-        if key == "":
-            break
-        value = click.prompt(
-            f"Enter value for '{key}'",
-            type=str,
-        )
-        extra_config.append(f"{key}={value}")
 
-    # get mandatory GCP project_id if provider is GCP
-    # skip if project_id already specified in extra_config
-    if click_params["provider"] == "gcp" and not any(
-        s.startswith("project_id=") for s in extra_config
-    ):
-        project_id = click.prompt("What is your GCP project_id?", type=str)
-        extra_config.append(f"project_id={project_id}")
-        declare(f"Project ID '{project_id}' added to extra_config.")
-
-    deployment_values["extra_config"] = extra_config
-
-    tags = []
-    # use click.prompt to populate tags until someone just hits enter
-    while True:
-        declare(
-            "\nAdd to tags for stack deployment -->\n",
-            bold=True,
-        )
-        tag = click.prompt(
-            "Enter `tags` key or hit enter to skip",
-            type=str,
-            default="",
+    if len(value) > 16:
+        raise click.BadParameter(
+            "Stack name must have a maximum length of 16 characters."
         )
-        if tag == "":
-            break
-        value = click.prompt(
-            f"Enter value for '{tag}'",
-            type=str,
-        )
-        tags.append(f"{tag}={value}")
-    deployment_values["tags"] = tags
 
-    return deployment_values
+    return value
+
 
+@stack.command(
+    help="""Deploy a fully functional ZenML stack in one of the cloud providers.
 
-@stack.command(help="Deploy a stack using mlstacks.")
+Running this command will initiate an assisted process that will walk you
+through automatically provisioning all the cloud infrastructure resources
+necessary for a fully functional ZenML stack in the cloud provider of your
+choice. A corresponding ZenML stack will also be automatically registered along
+with all the necessary components and properly authenticated through service
+connectors.
+"""
+)
 @click.option(
     "--provider",
     "-p",
     "provider",
     required=True,
-    type=click.Choice(STACK_RECIPE_MODULAR_RECIPES),
+    type=click.Choice(StackDeploymentProvider.values()),
 )
 @click.option(
     "--name",
     "-n",
     "stack_name",
     type=click.STRING,
-    required=True,
-    help="Set a name for the ZenML stack that will be imported from the YAML "
-    "configuration file which gets generated after deploying the stack recipe. "
-    "Defaults to the name of the stack recipe being deployed.",
-)
-@click.option(
-    "--region",
-    "-r",
-    "region",
-    type=click.STRING,
-    required=True,
-    help="The region to deploy the stack to.",
-)
-@click.option(
-    "--no-import",
-    "-ni",
-    "no_import_stack_flag",
-    is_flag=True,
-    help="If you don't want the stack to be imported automatically.",
-)
-@click.option(
-    "--artifact-store",
-    "-a",
-    "artifact_store",
-    required=False,
-    is_flag=True,
-    help="Whether to deploy an artifact store.",
-)
-@click.option(
-    "--container-registry",
-    "-c",
-    "container_registry",
     required=False,
-    is_flag=True,
-    help="Whether to deploy a container registry.",
-)
-@click.option(
-    "--mlops-platform",
-    "-m",
-    "mlops_platform",
-    type=click.Choice(["zenml"]),
-    required=False,
-    help="The flavor of MLOps platform to use."
-    "If not specified, the default MLOps platform will be used.",
-)
-@click.option(
-    "--orchestrator",
-    "-o",
-    required=False,
-    type=click.Choice(
-        [
-            "kubernetes",
-            "kubeflow",
-            "tekton",
-            "sagemaker",
-            "skypilot",
-            "vertex",
-        ]
-    ),
-    help="The flavor of orchestrator to use. "
-    "If not specified, the default orchestrator will be used.",
-)
-@click.option(
-    "--model-deployer",
-    "-md",
-    "model_deployer",
-    required=False,
-    type=click.Choice(["kserve", "seldon"]),
-    help="The flavor of model deployer to use. ",
-)
-@click.option(
-    "--experiment-tracker",
-    "-e",
-    "experiment_tracker",
-    required=False,
-    type=click.Choice(["mlflow"]),
-    help="The flavor of experiment tracker to use.",
-)
-@click.option(
-    "--step-operator",
-    "-s",
-    "step_operator",
-    required=False,
-    type=click.Choice(["sagemaker"]),
-    help="The flavor of step operator to use.",
-)
-@click.option(
-    "--file",
-    "-f",
-    "file",
-    required=False,
-    type=click.Path(exists=True, dir_okay=False, readable=True),
-    help="Use a YAML specification file as the basis of the stack deployment.",
-)
-@click.option(
-    "--debug-mode",
-    "-d",
-    "debug_mode",
-    is_flag=True,
-    default=False,
-    help="Whether to run the stack deployment in debug mode.",
-)
-@click.option(
-    "--extra-config",
-    "-x",
-    "extra_config",
-    multiple=True,
-    help="Extra configurations as key=value pairs. This option can be used multiple times.",
+    help="Custom string to use as a prefix to generate names for the ZenML "
+    "stack, its components service connectors as well as provisioned cloud "
+    "infrastructure resources. May only contain alphanumeric characters and "
+    "hyphens and have a maximum length of 16 characters.",
+    callback=validate_name,
 )
 @click.option(
-    "--tags",
-    "-t",
-    "tags",
-    required=False,
+    "--location",
+    "-l",
     type=click.STRING,
-    help="Pass one or more tags.",
-    multiple=True,
+    required=False,
+    help="The location to deploy the stack to.",
 )
 @click.option(
-    "--interactive",
-    "-i",
-    "interactive",
+    "--set",
+    "set_stack",
     is_flag=True,
-    default=False,
-    help="Deploy the stack interactively.",
+    help="Immediately set this stack as active.",
+    type=click.BOOL,
 )
 @click.pass_context
 def deploy(
     ctx: click.Context,
     provider: str,
-    stack_name: str,
-    region: str,
-    mlops_platform: Optional[str] = None,
-    orchestrator: Optional[str] = None,
-    model_deployer: Optional[str] = None,
-    experiment_tracker: Optional[str] = None,
-    step_operator: Optional[str] = None,
-    no_import_stack_flag: bool = False,
-    artifact_store: Optional[bool] = None,
-    container_registry: Optional[bool] = None,
-    file: Optional[str] = None,
-    debug_mode: bool = False,
-    tags: Optional[List[str]] = None,
-    extra_config: Optional[List[str]] = None,
-    interactive: bool = False,
+    stack_name: Optional[str] = None,
+    location: Optional[str] = None,
+    set_stack: bool = False,
 ) -> None:
-    """Deploy a stack with mlstacks.
-
-    `zenml stack_recipe pull <STACK_RECIPE_NAME>` has to be called with the
-    same relative path before the `deploy` command.
+    """Deploy and register a fully functional cloud ZenML stack.
 
     Args:
         ctx: The click context.
         provider: The cloud provider to deploy the stack to.
         stack_name: A name for the ZenML stack that gets imported as a result
             of the recipe deployment.
-        no_import_stack_flag: If you don't want the stack to be imported into
-            ZenML after deployment.
-        artifact_store: The flavor of artifact store to deploy. In the case of
-            the artifact store, it doesn't matter what you specify here, as
-            there's only one flavor per cloud provider and that will be deployed.
-        orchestrator: The flavor of orchestrator to use.
-        container_registry: The flavor of container registry to deploy. In the case of
-            the container registry, it doesn't matter what you specify here, as
-            there's only one flavor per cloud provider and that will be deployed.
-        model_deployer: The flavor of model deployer to deploy.
-        experiment_tracker: The flavor of experiment tracker to deploy.
-        step_operator: The flavor of step operator to deploy.
-        extra_config: Extra configurations as key=value pairs.
-        tags: Pass one or more tags.
-        debug_mode: Whether to run the stack deployment in debug mode.
-        file: Use a YAML specification file as the basis of the stack
-            deployment.
-        mlops_platform: The flavor of MLOps platform to use.
-        region: The region to deploy the stack to.
-        interactive: Deploy the stack interactively.
+        location: The location to deploy the stack to.
+        set_stack: Immediately set the deployed stack as active.
+
+    Raises:
+        Abort: If the user aborts the deployment.
+        KeyboardInterrupt: If the user interrupts the deployment.
     """
+    stack_name = stack_name or f"zenml-{provider}-stack"
+
+    # Set up the markdown renderer to use the old-school markdown heading
+    Markdown.elements.update(
+        {
+            "heading_open": OldSchoolMarkdownHeading,
+        }
+    )
+
+    client = Client()
+    if client.zen_store.is_local_store():
+        cli_utils.error(
+            "This feature cannot be used with a local ZenML deployment. "
+            "ZenML needs to be accessible from the cloud provider to allow the "
+            "stack and its components to be registered automatically. "
+            "Please deploy ZenML in a remote environment as described in the "
+            "documentation: https://docs.zenml.io/getting-started/deploying-zenml "
+            "or use a managed ZenML Pro server instance for quick access to "
+            "this feature and more: https://www.zenml.io/pro"
+        )
+
     with track_handler(
-        event=AnalyticsEvent.DEPLOY_STACK,
+        event=AnalyticsEvent.DEPLOY_FULL_STACK,
     ) as analytics_handler:
-        if stack_exists(stack_name):
-            cli_utils.error(
-                f"Stack with name '{stack_name}' already exists. Please choose a "
-                "different name."
-            )
-        elif stack_spec_exists(stack_name):
-            cli_utils.error(
-                f"Stack spec for stack named '{stack_name}' already exists. "
-                "Please choose a different name."
-            )
+        analytics_handler.metadata = {
+            "provider": provider,
+        }
 
-        cli_utils.declare("Checking prerequisites are installed...")
-        cli_utils.verify_mlstacks_prerequisites_installation()
-        cli_utils.warning(ALPHA_MESSAGE)
+        deployment = client.zen_store.get_stack_deployment_info(
+            provider=StackDeploymentProvider(provider),
+        )
 
-        if not file:
-            cli_params: Dict[str, Any] = ctx.params
-            if interactive:
-                cli_params = _get_deployment_params_interactively(cli_params)
-            stack, components = convert_click_params_to_mlstacks_primitives(
-                cli_params
+        if location and location not in deployment.locations.values():
+            cli_utils.error(
+                f"Invalid location '{location}' for provider '{provider}'. "
+                f"Valid locations are: {', '.join(deployment.locations.values())}"
             )
 
-            from mlstacks.utils import zenml_utils
+        console.print(
+            Markdown(
+                f"# {provider.upper()} ZenML Cloud Stack Deployment\n"
+                + deployment.description
+            )
+        )
+        console.print(Markdown("## Details\n" + deployment.instructions))
 
-            cli_utils.declare("Checking flavor compatibility...")
-            if not zenml_utils.has_valid_flavor_combinations(
-                stack, components
-            ):
-                cli_utils.error(
-                    "The specified stack and component flavors are not compatible "
-                    "with the provider or with one another. Please try again."
-                )
+        deployment_config = client.zen_store.get_stack_deployment_config(
+            provider=StackDeploymentProvider(provider),
+            stack_name=stack_name,
+            location=location,
+        )
 
-            stack_dict, component_dicts = convert_mlstacks_primitives_to_dicts(
-                stack, components
+        if deployment_config.instructions:
+            console.print(
+                Markdown("## Instructions\n" + deployment_config.instructions),
+                "\n",
             )
-            # write the stack and component yaml files
-            from mlstacks.constants import MLSTACKS_PACKAGE_NAME
 
-            spec_dir = os.path.join(
-                click.get_app_dir(MLSTACKS_PACKAGE_NAME),
-                "stack_specs",
-                stack.name,
+        if deployment_config.configuration:
+            console.print(
+                deployment_config.configuration,
+                no_wrap=True,
+                overflow="ignore",
+                crop=False,
+                style=Style(bgcolor="grey15"),
             )
-            cli_utils.declare(f"Writing spec files to {spec_dir}...")
-            create_dir_recursive_if_not_exists(spec_dir)
 
-            stack_file_path = os.path.join(
-                spec_dir, f"stack-{stack.name}.yaml"
+        if not cli_utils.confirmation(
+            "\n\nProceed to continue with the deployment. You will be "
+            f"automatically redirected to "
+            f"{deployment_config.deployment_url_text} in your browser.",
+        ):
+            raise click.Abort()
+
+        date_start = datetime.utcnow()
+
+        webbrowser.open(deployment_config.deployment_url)
+        console.print(
+            Markdown(
+                f"If your browser did not open automatically, please open "
+                f"the following URL into your browser to deploy the stack to "
+                f"{provider.upper()}: "
+                f"[{deployment_config.deployment_url_text}]"
+                f"({deployment_config.deployment_url}).\n\n"
             )
-            write_yaml(file_path=stack_file_path, contents=stack_dict)
-            for component in component_dicts:
-                write_yaml(
-                    file_path=os.path.join(
-                        spec_dir, f"{component['name']}.yaml"
-                    ),
-                    contents=component,
-                )
-        else:
-            declare("Importing from stack specification file...")
-            stack_file_path = file
-
-            from mlstacks.utils.yaml_utils import load_stack_yaml
-
-            stack = load_stack_yaml(stack_file_path)
-
-        analytics_handler.metadata = {
-            "stack_provider": stack.provider,
-            "debug_mode": debug_mode,
-            "no_import_stack_flag": no_import_stack_flag,
-            "user_created_spec": bool(file),
-            "mlops_platform": mlops_platform,
-            "orchestrator": orchestrator,
-            "model_deployer": model_deployer,
-            "experiment_tracker": experiment_tracker,
-            "step_operator": step_operator,
-            "artifact_store": artifact_store,
-            "container_registry": container_registry,
-        }
-
-        deploy_mlstacks_stack(
-            spec_file_path=stack_file_path,
-            stack_name=stack.name,
-            stack_provider=stack.provider,
-            debug_mode=debug_mode,
-            no_import_stack_flag=no_import_stack_flag,
-            user_created_spec=bool(file),
         )
 
+        try:
+            cli_utils.declare(
+                "\n\nWaiting for the deployment to complete and the stack to be "
+                "registered. Press CTRL+C to abort...\n"
+            )
 
-@stack.command(
-    help="Destroy stack components created previously with "
-    "`zenml stack deploy`"
-)
-@click.argument("stack_name", required=True)
-@click.option(
-    "--debug",
-    "-d",
-    "debug_mode",
-    is_flag=True,
-    default=False,
-    help="Whether to run Terraform in debug mode.",
-)
-def destroy(
-    stack_name: str,
-    debug_mode: bool = False,
-) -> None:
-    """Destroy all resources previously created with `zenml stack deploy`.
+            while True:
+                deployed_stack = client.zen_store.get_stack_deployment_stack(
+                    provider=StackDeploymentProvider(provider),
+                    stack_name=stack_name,
+                    location=location,
+                    date_start=date_start,
+                )
+                if deployed_stack:
+                    break
+                time.sleep(10)
+
+            analytics_handler.metadata.update(
+                {
+                    "stack_id": deployed_stack.stack.id,
+                }
+            )
 
-    Args:
-        stack_name: Name of the stack
-        debug_mode: Whether to run Terraform in debug mode.
-    """
-    if not confirmation(
-        f"Are you sure you want to destroy stack '{stack_name}' and all "
-        "associated infrastructure?"
-    ):
-        error("Aborting stack destroy...")
+        except KeyboardInterrupt:
+            cli_utils.declare("Stack deployment aborted.")
+            raise
 
-    with track_handler(
-        event=AnalyticsEvent.DESTROY_STACK,
-    ) as analytics_handler:
-        analytics_handler.metadata["debug_mode"] = debug_mode
-        cli_utils.verify_mlstacks_prerequisites_installation()
-        from mlstacks.constants import MLSTACKS_PACKAGE_NAME
+    stack_desc = f"""## Stack successfully registered! 🚀
+Stack [{deployed_stack.stack.name}]({get_stack_url(deployed_stack.stack)}):\n"""
 
-        # check the stack actually exists
-        if not stack_exists(stack_name):
-            cli_utils.error(
-                f"Stack with name '{stack_name}' does not exist. Please check and "
-                "try again."
+    for component_type, components in deployed_stack.stack.components.items():
+        if components:
+            component = components[0]
+            stack_desc += (
+                f" * `{component.flavor_name}` {component_type.value}: "
+                f"[{component.name}]({get_component_url(component)})\n"
             )
 
-        spec_file_path = get_stack_spec_file_path(stack_name)
-        spec_files_dir: str = os.path.join(
-            click.get_app_dir(MLSTACKS_PACKAGE_NAME), "stack_specs", stack_name
+    if deployed_stack.service_connector:
+        stack_desc += (
+            f" * Service Connector: {deployed_stack.service_connector.name}\n"
         )
-        user_created_spec = str(Path(spec_file_path).parent) != spec_files_dir
 
-        provider = read_yaml(file_path=spec_file_path).get("provider")
-        tf_definitions_path: str = os.path.join(
-            click.get_app_dir(MLSTACKS_PACKAGE_NAME),
-            "terraform",
-            f"{provider}-modular",
-        )
-
-        cli_utils.declare(
-            "Checking Terraform definitions and spec files are present..."
-        )
-        verify_spec_and_tf_files_exist(spec_file_path, tf_definitions_path)
+    console.print(Markdown(stack_desc))
 
-        from mlstacks.utils import terraform_utils
+    follow_up = f"""
+## Follow-up
 
-        cli_utils.declare(
-            f"Destroying stack '{stack_name}' using Terraform..."
-        )
-        terraform_utils.destroy_stack(
-            stack_path=spec_file_path, debug_mode=debug_mode
-        )
-        cli_utils.declare(f"Stack '{stack_name}' successfully destroyed.")
+{deployment.post_deploy_instructions}
 
-        if cli_utils.confirmation(
-            f"Would you like to recursively delete the associated ZenML "
-            f"stack '{stack_name}'?\nThis will delete the stack and any "
-            "underlying stack components."
-        ):
-            from zenml.client import Client
+To use the `{deployed_stack.stack.name}` stack to run pipelines:
 
-            client = Client()
-            client.delete_stack(name_id_or_prefix=stack_name, recursive=True)
-            cli_utils.declare(
-                f"Stack '{stack_name}' successfully deleted from ZenML."
-            )
+* install the required ZenML integrations by running: `zenml integration install {" ".join(deployment.integrations)}`
+"""
+    if set_stack:
+        client.activate_stack(deployed_stack.stack.id)
+        follow_up += f"""
+* the `{deployed_stack.stack.name}` stack has already been set as active
+"""
+    else:
+        follow_up += f"""
+* set the `{deployed_stack.stack.name}` stack as active by running: `zenml stack set {deployed_stack.stack.name}`
+"""
 
-        spec_dir = os.path.dirname(spec_file_path)
-        if not user_created_spec and cli_utils.confirmation(
-            f"Would you like to delete the `mlstacks` spec directory for "
-            f"this stack, located at {spec_dir}?"
-        ):
-            rmtree(spec_files_dir)
-            cli_utils.declare(
-                f"Spec directory for stack '{stack_name}' successfully deleted."
-            )
-        cli_utils.declare(f"Stack '{stack_name}' successfully destroyed.")
+    console.print(
+        Markdown(follow_up),
+    )
 
 
 @stack.command(
@@ -1726,3 +1718,301 @@ def connect_stack(
             interactive=interactive,
             no_verify=no_verify,
         )
+
+
+def _get_service_connector_info(
+    cloud_provider: str,
+    connector_details: Optional[
+        Union[ServiceConnectorResponse, ServiceConnectorRequest]
+    ],
+) -> ServiceConnectorInfo:
+    """Get a service connector info with given cloud provider.
+
+    Args:
+        cloud_provider: The cloud provider to use.
+        connector_details: Whether to use implicit credentials.
+
+    Returns:
+        The info model of the created service connector.
+
+    Raises:
+        ValueError: If the cloud provider is not supported.
+    """
+    from rich.prompt import Prompt
+
+    if cloud_provider not in {"aws", "gcp", "azure"}:
+        raise ValueError(f"Unknown cloud provider {cloud_provider}")
+
+    client = Client()
+    auth_methods = client.get_service_connector_type(
+        cloud_provider
+    ).auth_method_dict
+    if not connector_details:
+        fixed_auth_methods = list(
+            [
+                (key, value)
+                for key, value in auth_methods.items()
+                if key != "implicit"
+            ]
+        )
+        choices = []
+        headers = ["Name", "Required"]
+        for _, value in fixed_auth_methods:
+            schema = value.config_schema
+            required = ""
+            for each_req in schema["required"]:
+                field = schema["properties"][each_req]
+                required += f"[bold]{each_req}[/bold]  [italic]({field.get('title', 'no description')})[/italic]\n"
+            choices.append([value.name, required])
+
+        selected_auth_idx = cli_utils.multi_choice_prompt(
+            object_type=f"authentication methods for {cloud_provider.upper()}",
+            choices=choices,
+            headers=headers,
+            prompt_text="Please choose one of the authentication option above",
+        )
+        if selected_auth_idx is None:
+            cli_utils.error("No authentication method selected.")
+        auth_type = fixed_auth_methods[selected_auth_idx][0]
+    else:
+        auth_type = connector_details.auth_method
+
+    selected_auth_model = auth_methods[auth_type]
+
+    required_fields = selected_auth_model.config_schema["required"]
+    properties = selected_auth_model.config_schema["properties"]
+
+    answers = {}
+    for req_field in required_fields:
+        if connector_details:
+            if conf_value := connector_details.configuration.get(
+                req_field, None
+            ):
+                answers[req_field] = conf_value
+            elif secret_value := connector_details.secrets.get(
+                req_field, None
+            ):
+                answers[req_field] = secret_value.get_secret_value()
+        if req_field not in answers:
+            answers[req_field] = Prompt.ask(
+                f"Please enter value for `{req_field}`:",
+                password="format" in properties[req_field]
+                and properties[req_field]["format"] == "password",
+            )
+
+    return ServiceConnectorInfo(
+        type=cloud_provider,
+        auth_method=auth_type,
+        configuration=answers,
+    )
+
+
+def _get_stack_component_info(
+    component_type: str,
+    cloud_provider: str,
+    resources_info: ServiceConnectorResourcesInfo,
+    service_connector_index: Optional[int] = None,
+) -> ComponentInfo:
+    """Get a stack component info with given type and service connector.
+
+    Args:
+        component_type: The type of component to create.
+        cloud_provider: The cloud provider to use.
+        resources_info: The resources info of the service connector.
+        service_connector_index: The index of the service connector to use.
+
+    Returns:
+        The info model of the stack component.
+
+    Raises:
+        ValueError: If the cloud provider is not supported.
+        ValueError: If the component type is not supported.
+    """
+    from rich.prompt import Prompt
+
+    if cloud_provider not in {"aws", "azure", "gcp"}:
+        raise ValueError(f"Unknown cloud provider {cloud_provider}")
+
+    flavor = "undefined"
+    service_connector_resource_id = None
+    config = {}
+    choices = [
+        [cri.flavor, resource_id]
+        for cri in resources_info.components_resources_info[
+            StackComponentType(component_type)
+        ]
+        for resource_id in cri.accessible_by_service_connector
+    ]
+    if component_type == "artifact_store":
+        selected_storage_idx = cli_utils.multi_choice_prompt(
+            object_type=f"{cloud_provider.upper()} storages",
+            choices=choices,
+            headers=["Artifact Store Type", "Storage"],
+            prompt_text="Please choose one of the storages for the new artifact store:",
+        )
+        if selected_storage_idx is None:
+            cli_utils.error("No storage selected.")
+
+        selected_storage = choices[selected_storage_idx]
+
+        flavor = selected_storage[0]
+        config = {"path": selected_storage[1]}
+        service_connector_resource_id = selected_storage[1]
+    elif component_type == "orchestrator":
+
+        def query_region(
+            provider: StackDeploymentProvider,
+            compute_type: str,
+            is_skypilot: bool = False,
+        ) -> str:
+            deployment_info = Client().zen_store.get_stack_deployment_info(
+                provider
+            )
+            region = Prompt.ask(
+                f"Select the location for your {compute_type}:",
+                choices=sorted(
+                    deployment_info.skypilot_default_regions.values()
+                    if is_skypilot
+                    else deployment_info.locations.values()
+                ),
+                show_choices=True,
+            )
+            return region
+
+        selected_orchestrator_idx = cli_utils.multi_choice_prompt(
+            object_type=f"orchestrators on {cloud_provider.upper()}",
+            choices=choices,
+            headers=["Orchestrator Type", "Details"],
+            prompt_text="Please choose one of the orchestrators for the new orchestrator:",
+        )
+        if selected_orchestrator_idx is None:
+            cli_utils.error("No orchestrator selected.")
+
+        selected_orchestrator = choices[selected_orchestrator_idx]
+
+        config = {}
+        flavor = selected_orchestrator[0]
+        if flavor == "sagemaker":
+            execution_role = Prompt.ask("Enter an execution role ARN:")
+            config["execution_role"] = execution_role
+        elif flavor == "vm_aws":
+            config["region"] = selected_orchestrator[1]
+        elif flavor == "vm_gcp":
+            config["region"] = query_region(
+                StackDeploymentProvider.GCP,
+                "Skypilot cluster",
+                is_skypilot=True,
+            )
+        elif flavor == "vm_azure":
+            config["region"] = query_region(
+                StackDeploymentProvider.AZURE,
+                "Skypilot cluster",
+                is_skypilot=True,
+            )
+        elif flavor == "azureml":
+            config["subscription_id"] = Prompt.ask(
+                "Enter the subscription ID:"
+            )
+            config["resource_group"] = Prompt.ask("Enter the resource group:")
+            config["workspace"] = Prompt.ask("Enter the workspace name:")
+        elif flavor == "vertex":
+            config["location"] = query_region(
+                StackDeploymentProvider.GCP, "Vertex AI job"
+            )
+        service_connector_resource_id = selected_orchestrator[1]
+    elif component_type == "container_registry":
+        selected_registry_idx = cli_utils.multi_choice_prompt(
+            object_type=f"{cloud_provider.upper()} registries",
+            choices=choices,
+            headers=["Container Registry Type", "Container Registry"],
+            prompt_text="Please choose one of the registries for the new container registry:",
+        )
+        if selected_registry_idx is None:
+            cli_utils.error("No container registry selected.")
+        selected_registry = choices[selected_registry_idx]
+        flavor = selected_registry[0]
+        config = {"uri": selected_registry[1]}
+        service_connector_resource_id = selected_registry[1]
+    else:
+        raise ValueError(f"Unknown component type {component_type}")
+
+    return ComponentInfo(
+        flavor=flavor,
+        configuration=config,
+        service_connector_index=service_connector_index,
+        service_connector_resource_id=service_connector_resource_id,
+    )
+
+
+@stack.command(
+    name="export-requirements", help="Export the stack requirements."
+)
+@click.argument(
+    "stack_name_or_id",
+    type=click.STRING,
+    required=False,
+)
+@click.option(
+    "--output-file",
+    "-o",
+    "output_file",
+    type=str,
+    required=False,
+    help="File to which to export the stack requirements. If not "
+    "provided, the requirements will be printed to stdout instead.",
+)
+@click.option(
+    "--overwrite",
+    "-ov",
+    "overwrite",
+    type=bool,
+    required=False,
+    is_flag=True,
+    help="Overwrite the output file if it already exists. This option is "
+    "only valid if the output file is provided.",
+)
+def export_requirements(
+    stack_name_or_id: Optional[str] = None,
+    output_file: Optional[str] = None,
+    overwrite: bool = False,
+) -> None:
+    """Exports stack requirements so they can be installed using pip.
+
+    Args:
+        stack_name_or_id: Stack name or ID. If not given, the active stack will
+            be used.
+        output_file: Optional path to the requirements output file.
+        overwrite: Overwrite the output file if it already exists. This option
+            is only valid if the output file is provided.
+    """
+    try:
+        stack_model: "StackResponse" = Client().get_stack(
+            name_id_or_prefix=stack_name_or_id
+        )
+    except KeyError as err:
+        cli_utils.error(str(err))
+
+    requirements, _ = requirements_utils.get_requirements_for_stack(
+        stack_model
+    )
+
+    if not requirements:
+        cli_utils.declare(f"Stack `{stack_model.name}` has no requirements.")
+        return
+
+    if output_file:
+        try:
+            with open(output_file, "x") as f:
+                f.write("\n".join(requirements))
+        except FileExistsError:
+            if overwrite or cli_utils.confirmation(
+                "A file already exists at the specified path. "
+                "Would you like to overwrite it?"
+            ):
+                with open(output_file, "w") as f:
+                    f.write("\n".join(requirements))
+        cli_utils.declare(
+            f"Requirements for stack `{stack_model.name}` exported to {output_file}."
+        )
+    else:
+        click.echo(" ".join(requirements), nl=False)