Create and Manage App Deployments

An App Deployment deploys AI/ML workloads such as training frameworks, inference servers, or experiment tracking tools onto a Compute Pool using Profile Bundles. This guide describes how to create, clone, and delete App Deployments.

info

App Deployments follow an immutable deployment pattern. To change settings, clone the existing deployment, adjust the configuration, and deploy a new one. This approach ensures each deployment is a known, reproducible configuration.

You can create App Deployments using the PaletteAI UI or using YAML Kubernetes manifests.

Create App Deployment

Create a new App Deployment by selecting Profile Bundles and a Compute Pool target.

Prerequisites

UI Workflow

• A Tenant or Project in Ready status.

• A Profile Bundle of type Application that defines the workload to deploy.

• One of the following Compute Pool options:

  • An existing Compute Pool in Running status for infrastructure readiness.
  • A Profile Bundle of type Infrastructure or Fullstack if you want to create a new Compute Pool during the App Deployment workflow. For multi-NIC edge hosts, configure default NICs (and static IPs where required) on the Compute tab in Project Settings or Tenant Settings before provisioning.

• A user with Tenant Admin, Project Editor, or Project Admin permissions. Refer to Roles and Permissions for more information.

YAML Workflow

• kubectl installed and available in your $PATH.

• The KUBECONFIG environment variable set to the path of the PaletteAI hub cluster's kubeconfig file.

  export KUBECONFIG=<kubeconfig-location>

• A Project namespace for the Project you are deploying to.

• One or more Profile Bundles that define the workload to deploy.

Enablement

UI Workflow

1. Log in to PaletteAI. Ensure you are in the correct Project or Tenant scope.

2. From the left main menu, select App Deployments.

3. Select Create App Deployment (no existing applications) or Deploy App (existing applications).

4. In the General Info screen, set the name and metadata for your deployment.

   • Enter a unique Name. The name must be 3-29 characters, start with a lowercase letter, end with a lowercase letter or number, and contain only lowercase letters, numbers, and hyphens. The name must be unique within the Project.

   • (Optional) Add a Description.

   • (Optional) Select Add link to attach external URLs to the App Deployment (for example, a model registry or documentation link). Each link must start with http:// or https://. These links have no affect on how the application runs and are accessed at App Deployments > Overview tab > View external links.

   • (Optional) Expand Metadata to add labels and annotations for sorting and filtering.

   • (Tenant scope only) By default, the App Deployment is shared with all Projects when it is created. To change which Projects can access the application, choose the Select button, and mark the applicable Projects. Confirm your changes when finished.

   Select Next.

5. In the Profile Bundles screen, select the Profile Bundles to apply to this deployment.

   • Select Add Profile Bundle. In the selection drawer, choose a Profile Bundle from the table. Select Add Bundle.

   • If you selected an Infrastructure Profile Bundle, you must also add an Application Profile Bundle. Select Add Profile Bundle again to add it.

   • For each Profile Bundle, select the Version. If the Profile Bundle supports multiple cloud types, select the Cloud Type.

   info

   If you selected an Infrastructure Profile Bundle without an Application Profile Bundle, the wizard requires you to add one before proceeding. Fullstack Profile Bundles include application layers and do not require a separate Application Profile Bundle.

   Select Next.

6. In the Compute Pool screen, choose the compute environment where your application runs.

   Field	Description	Required
   Compute Pool type	Choose Dedicated for exclusive access to physical resources with no resource contention (for example, running a distributed PyTorch training job on dedicated GPUs), or Shared to share resources across multiple teams (for example, running development experiments or batch inference jobs alongside other workloads).	✅
   Select from existing	Select an existing Compute Pool in Running status from the selection drawer. This status confirms that the cluster infrastructure is available, but it does not guarantee that any workloads previously deployed through a Fullstack Profile Bundle are fully ready.	Conditional
   Create new	Provision a new Compute Pool as part of this deployment. An additional setup step appears after this screen.	Conditional

   • If you selected Select from existing, choose a Compute Pool from the selection drawer.

   • If you selected Create new, you configure the new Compute Pool in the next step.

   warning

   If this workflow creates a new Compute Pool with a Fullstack Profile Bundle, treat the Compute Pool Running status as the infrastructure checkpoint only. Use the App Deployment status, workload conditions, and service endpoint checks to confirm that the application is actually ready.

   Select Next.

7. (Conditional) In the Compute Pool setup screen, configure the infrastructure for the new Compute Pool.

   info

   This step appears only when you select Create new in the previous step. If you selected an existing Compute Pool, the wizard skips this step.

   The configuration includes control plane pools, worker pools, edge configuration, Default NIC and Static IP, and deployment settings. These fields are the same as the Compute Pool creation wizard.

   Select Next.

8. In the Variables screen, configure variables for the selected Profile Bundles. Variables are parameters defined by the workload profile, such as namespace names, Helm chart values, model paths, or resource limits.

   info

   The layers and variables displayed depend on your Profile Bundle type and Compute Pool choice. Refer to Supported Workflows and Fullstack Profile Bundle Deployment Behavior for details. The same layers and variables are displayed for Day-1 (Compute Pool deployment) and Day-2 (Compute Pool management) actions.

   • The variables table displays all configurable variables with Name, Value, and Description columns. When Merge variables is disabled, the source profile name appears as a prefix in the Name column.

   • Required variables are marked with an asterisk (*) next to the name. Enter or update the Value for each variable.

   • (Optional) Select the gear icon in the top-right to open the deployment settings drawer.

     Field	Description	Required
     Namespace	The namespace where workloads are deployed. Defaults to the Project namespace. Must start and end with alphanumeric characters and can only contain lowercase letters, numbers, hyphens, and periods.	✅
     Merge variables	Controls how variables with the same name across multiple profiles are handled. When enabled (the default), each variable name appears once and the provided value applies to all profiles. When disabled, each profile source has its own row and values are set per profile.	❌
     Labels	Key-value pairs applied to the workload. Expand Metadata to configure.	❌
     Annotations	Key-value pairs applied to the workload. Expand Metadata to configure.	❌

     Select Confirm.

   Select Next.

9. In the Review & Deploy screen, review and confirm your deployment configuration. The summary displays an overview of your general information, Profile Bundles, compute pool selection, and deployment settings.

   • Review your settings. The summary is read-only. To make changes, select a previous step in the left sidebar to navigate back.

   • Select Submit to create the App Deployment.

YAML Workflow

Create an AIWorkload resource in your Project or Tenant namespace. The AIWorkload references Profile Bundles and either an existing Compute Pool or an inline cluster variant definition. Include the appropriate palette.ai/project or palette.ai/tenant label depending on the scope you are creating the App Deployment in. For a conceptual overview of the AIWorkload resource and how it relates to other PaletteAI resources, refer to AIWorkloads.

Deploy to an existing Compute Pool:

apiVersion: spectrocloud.com/v1alpha1
kind: AIWorkload
metadata:
  name: my-app
  namespace: <project-or-tenant-namespace>
  labels:
    palette.ai/project: '<project-namespace>'
    palette.ai/tenant: '<tenant-namespace>'
    palette.ai/aiworkload-type: 'app'
spec:
  computePoolRef:
    name: '<existing-computepool-name>'
    namespace: '<project-or-tenant-namespace>'
  profileBundles:
    - name: '<profilebundle-name>'
      namespace: '<project-or-tenant-namespace>'
  workloadDeploymentConfigs:
    - profileBundleRef:
        name: '<profilebundle-name>'
        namespace: '<project-or-tenant-namespace>'
      addonVariantName: '<addon-variant-name-if-applicable>'
      workloadProfileRef:
        name: '<workload-profile-name>'
        namespace: 'mural-system'
      targetWorkload:
        name: '<deployment-name>'
        namespace: '<project-or-tenant-namespace>'
      variables:
        <variable-name>: '<value>'

Create a new dedicated Compute Pool inline:

apiVersion: spectrocloud.com/v1alpha1
kind: AIWorkload
metadata:
  name: my-app
  namespace: <project-or-tenant-namespace>
  labels:
    palette.ai/project: '<project-namespace>'
    palette.ai/tenant: '<tenant-namespace>'
    palette.ai/aiworkload-type: 'app'
spec:
  deletionPolicy: 'delete'
  clusterVariant:
    dedicated:
      paletteClusterDeploymentConfig:
        cloudType: 'edge-native'
        nodePoolRequirements:
          controlPlanePool:
            nodeCount: 1
          workerPools:
            - name: 'gpu-workers'
              architecture: 'AMD64'
              cpu:
                cpuCount: 4
              memory:
                memory: '16 GB'
              gpu:
                variant: 'NVIDIA A100-SXM4-80GB | 80 GB'
                gpuCount: 1
        edge:
          vip: '<vip-address>'
  profileBundles:
    - name: '<profilebundle-name>'
      namespace: '<project-or-tenant-namespace>'
      cloudType: 'edge-native'
  workloadDeploymentConfigs:
    - profileBundleRef:
        name: '<profilebundle-name>'
        namespace: '<project-or-tenant-namespace>'
      addonVariantName: '<addon-variant-name-if-applicable>'
      workloadProfileRef:
        name: '<workload-profile-name>'
        namespace: 'mural-system'
      targetWorkload:
        name: '<deployment-name>'
        namespace: '<project-or-tenant-namespace>'
      variables:
        <variable-name>: '<value>'

Apply the manifest:

kubectl apply --filename aiworkload.yaml

Key fields:

Field	Description	Required
metadata.labels['palette.ai/aiworkload-type']	Workload type label. Must be app for App Deployments. The admission webhook rejects AIWorkload resources without this label.	✅
spec.profileBundles	References to Profile Bundles. At least one required.	✅
spec.workloadDeploymentConfigs	One entry per workload to deploy. Each requires a profileBundleRef, workloadProfileRef and targetWorkload with name and namespace.	✅
spec.computePoolRef	Reference to an existing Compute Pool. Mutually exclusive with clusterVariant.	Conditional
spec.clusterVariant	Inline Compute Pool definition (dedicated, shared, or imported). Mutually exclusive with computePoolRef.	Conditional
spec.workloadDeploymentConfigs[].variables	Variable overrides for the workload profile. Required if the workload profile defines mandatory variables.	❌
spec.workloadDeploymentConfigs[].addonVariantName	Addon variant name from the profile bundle. Required if the workload profile comes from an addon variant.	❌
spec.workloadDeploymentConfigs[].syncWithPalette	Sync variables with Palette cluster profile variables. Default: false.	❌
spec.deletionPolicy	Determines whether Compute Pools created by the AIWorkload are deleted (delete) or orphaned (orphan) when the AIWorkload is deleted. Default: delete.	❌
spec.hardwareRequests	CPU, memory, and GPU requirements per architecture. Required for shared or imported Compute Pools.	Conditional

workloadProfileRef points to the profile definition in mural-system that describes the workload structure. targetWorkload defines where the resulting workload is deployed (name and namespace in your Project).

hardwareRequests example (required for shared or imported Compute Pools):

spec:
  hardwareRequests:
    - architecture: AMD64
      totalCPU: 4
      totalMemory: '16 GB'
      gpu:
        - variant: 'NVIDIA A100-SXM4-80GB | 80 GB'
          gpuCount: 1

For inline Compute Pool configuration fields (clusterVariant), refer to the Compute Pool Configuration Reference.

Validate

UI Workflow

1. In the left main menu, select App Deployments.

2. Confirm that the App Deployment appears with the status Provisioning.

3. Confirm that the App Deployment status changes to Running. If you created a new Compute Pool, provisioning includes both the Compute Pool and the application deployment, which may take 10-15 minutes.

4. If the status remains Provisioning or changes to Failed, select the App Deployment and review its events for errors.

5. If this deployment created a new Compute Pool, you can also confirm that the Compute Pool is Running, but treat that as an infrastructure check rather than proof that the application is accessible.

YAML Workflow

1. Check that the AIWorkload status transitions to Running:

   kubectl get aiworkload <name> --namespace <project-or-tenant-namespace> --watch

2. Verify the WorkloadDeploymentCreated and WorkloadDeploymentReady conditions.

   kubectl get aiworkload <name> --namespace <project-or-tenant-namespace> --output jsonpath='{.status.conditions}' | jq

3. If you created a new Compute Pool inline, verify the Compute Pool is also Running as an infrastructure checkpoint.

   kubectl get computepool --namespace <project-or-tenant-namespace>

4. Treat the AIWorkload conditions and any workload/service-specific checks as the source of truth for application readiness.

5. If the AIWorkload is stuck in Provisioning or shows Failed, check events for errors.

   kubectl describe aiworkload <name> --namespace <project-or-tenant-namespace>

Clone App Deployment

Create a new App Deployment from an existing one. Cloning pre-fills the creation wizard with the configuration from the source deployment, allowing you to adjust settings before deploying.

Prerequisites

UI Workflow

• An existing App Deployment.

• A user with Tenant Admin, Project Editor, or Project Admin permissions. Refer to Roles and Permissions for more information.

• A Tenant or Project in Ready status.

YAML Workflow

• kubectl installed and available in your $PATH.

• The KUBECONFIG environment variable set to the path of the PaletteAI hub cluster's kubeconfig file.

  export KUBECONFIG=<kubeconfig-location>

• An existing AIWorkload in the Project namespace.

Enablement

UI Workflow

1. Log in to PaletteAI. Ensure you are in the correct Project or Tenant scope.

2. In the left main menu, select App Deployments.

3. Beside the App Deployment, select the three-dot menu, and choose Clone.

4. The creation wizard opens with the source deployment's configuration pre-filled. Modify any fields as needed.

5. Select Submit to create the new App Deployment.

YAML Workflow

1. Export the existing AIWorkload manifest.

   kubectl get aiworkload <source-name> --namespace <project-or-tenant-namespace> --output yaml > aiworkload.yaml

2. Update metadata.name and any other settings, including Profile Bundle versions, variables, and Compute Pool references.

3. Apply the updated manifest.

   kubectl apply --filename aiworkload.yaml

Validate

UI Workflow

1. In the left main menu, select App Deployments.

2. Confirm the cloned App Deployment appears with status Provisioning.

3. Confirm that the status changes to Running.

YAML Workflow

Verify the cloned AIWorkload transitions to Running.

kubectl get aiworkload <name> --namespace <project-or-tenant-namespace> --watch

Delete App Deployment

Delete an App Deployment when you no longer need it. Deleting an App Deployment removes the deployed workloads. If the App Deployment created a new Compute Pool with spec.deletionPolicy: "delete", the Compute Pool is also deleted. If the policy is "orphan" or the deployment references an existing Compute Pool, the Compute Pool remains.

danger

Deleting an App Deployment removes the deployed workloads and cannot be undone. Back up important data before you delete.

Prerequisites

UI Workflow

• An existing App Deployment.

• A user with Tenant Admin, Project Editor, or Project Admin permissions. Refer to Roles and Permissions for more information.

• A Tenant or Project in Ready status.

  info

  If the App Deployment was created at the Tenant scope, you cannot delete it from the Project scope.

YAML Workflow

• kubectl installed and available in your $PATH.

• The KUBECONFIG environment variable set to the path of the PaletteAI hub cluster's kubeconfig file.

  export KUBECONFIG=<kubeconfig-location>

Enablement

UI Workflow

1. Log in to PaletteAI. Ensure you are in the correct Project or Tenant scope.

2. From the left main menu, select App Deployments.

3. In the App Deployment row, select the three-dot menu and choose Delete.

4. In the confirmation dialog, review the warning that this action cannot be undone.

5. Type the App Deployment name in the confirmation field to enable the Delete button.

6. Select Delete to confirm, or Cancel to keep the App Deployment.

YAML Workflow

kubectl delete aiworkload <name> --namespace <project-or-tenant-namespace>

Validate

UI Workflow

1. In the left main menu, select App Deployments.

2. Verify the App Deployment no longer appears in the list.

YAML Workflow

1. Confirm the AIWorkload resource is removed.

   kubectl get aiworkload --namespace <project-or-tenant-namespace>

2. If the App Deployment created a Compute Pool inline with spec.deletionPolicy: "orphan", the Compute Pool remains. Delete it separately if it is no longer needed.

   kubectl delete computepool <name> --namespace <project-or-tenant-namespace>

Next Steps

After you create an App Deployment, you can Expose App Deployments to make your application accessible. Review the App Deployments concepts page to understand how workloads are provisioned, and refer to Create and Manage Compute Pools to prepare infrastructure for future deployments.