How to make the CNAB bundle?

Question

I am publishing my aks application in the market place using the kubernetes application.
There CNAB bundle need to be uploaded in the azure container registry.
The CNAB bundle should consists of helm chart, arm template, createUIdefinition, manifest file.
I need to know how to create this package. How to put all this in a CNAB bundle?

Answer 1

To create the CNAB bundle for a Kubernetes application offer, first prepare the required artifacts, then package and push the bundle to an Azure Container Registry (ACR) that belongs to the publishing tenant.

1. Verify prerequisites

• Application must be Helm chart–based and deployable to Linux.
• Helm chart must not contain .tgz archives; all files must be unpacked.
• All image references and digests must be included in the chart; no images or charts may be downloaded at runtime.
• An Azure Container Registry must exist in the publishing tenant.
• Azure CLI (and Docker if running the packaging tool manually) must be installed on an AMD64 machine.

2. Gather the CNAB artifacts Each CNAB bundle for a Kubernetes app offer is composed of:

• Helm chart
• createUiDefinition.json
• ARM template
• manifest.yaml

2.1 Prepare the Helm chart

• Ensure all image names and references are parameterized in values.yaml under global.azure.images and that templates (for example deployment.yaml) use those values. This allows Marketplace to retag images to the Microsoft-owned ACR.
• If using subcharts, update all dependent charts so their image references also point to images defined in the main chart’s values.yaml.
• You may use tags or digests, but any tag change requires submitting a new CNAB version.
• Validate the chart with a local cluster or helm install --generate-name --dry-run --debug.

2.2 Create the manifest file (manifest.yaml) Include at least the following fields:

• applicationName: name of the application
• publisher: publisher name
• description: short description of the package
• version: string in #.#.# format
• helmChart: local directory path to the Helm chart relative to manifest.yaml
• clusterARMTemplate: local path to the ARM template
• uiDefinition: local path to createUiDefinition.json
• registryServer: name of the ACR where the CNAB bundle will be pushed
• extensionRegistrationParameters: collection including at least defaultScope and required parameters
• defaultScope: cluster or namespace

Ensure extensionRegistrationParameters is present and not empty, and if defaultScope is cluster, provide a namespace in that section to avoid publishing errors.

2.3 Create the ARM template

• ARM template must only use the allowed resource types:
  • Microsoft.ContainerService/managedClusters
  • Microsoft.KubernetesConfiguration/extensions
• By default, it deploys a cluster extension resource for the Marketplace application; optionally it can also deploy an AKS cluster.

2.4 Create and test createUiDefinition.json

• Define the Azure portal deployment UI for the application.
• Test it by copying the JSON into the CreateUiDefinition sandbox environment in the Azure portal to validate the user experience.

3. Apply billing-related metadata (if applicable) Depending on the chosen billing model:

• For per core/pod/node models, add the label azure-extensions-usage-release-identifier to the Pod spec (under .spec.template.metadata.labels for controllers like Deployments/StatefulSets/DaemonSets, or .metadata.labels for direct Pod specs).
• For custom metering, add:
  • planId under global.azure.marketplace.planId
  • resourceId under global.azure.extension.resrouceId These are replaced at deployment time by the cluster extensions feature.

4. Package the CNAB bundle

• Place manifest.yaml, the Helm chart directory, ARM template file, and createUiDefinition.json in a folder structure that matches the paths specified in manifest.yaml.
• Use the CNAB packaging tool/process referenced in the publishing guidance to generate the CNAB bundle from this folder. (The bundle is the single artifact that encapsulates all these assets.)

5. Push the CNAB bundle to ACR

• Using Azure CLI and Docker (if required by the packaging tool), upload the generated CNAB bundle to the target ACR specified in manifest.yaml (registryServer).
• This ACR must belong to the publishing tenant; Marketplace will later copy the bundle to a Microsoft-owned public ACR as part of the publishing flow.

6. Use the CNAB in Partner Center

• When creating the Kubernetes application–based Container offer in Partner Center, reference the CNAB bundle stored in the ACR.
• During publishing, Marketplace will:
  1. Copy the CNAB from the publisher ACR to a Microsoft-owned ACR.
  2. Perform vulnerability scanning on the images.
  3. Register the Kubernetes application as an AKS cluster extension type.

Following these steps produces the CNAB bundle containing the Helm chart, ARM template, CreateUiDefinition, and manifest file in the required format for a Kubernetes application offer.

---

References:

• Troubleshoot issues while publishing a Kubernetes application-based Container offer
• Prepare Azure container technical assets for a Kubernetes app
• Create Azure Arc-enabled Kubernetes offers in Microsoft Marketplace
• Plan a Microsoft Marketplace Container offer