Skip to main content
When you create a product or update a template, CNAP automatically generates a versioned, self-contained package. This package combines all your sources into a single deployable unit that works with standard Helm tools and workflows.

​
What Gets Generated

CNAP creates a standard Helm package that combines all your Helm charts and manifests into a single, self-contained unit. Each template update automatically creates a new versioned release (e.g., 0.1.0, 0.1.1). All dependencies are bundled together, so no external downloads are needed during deployment. Packages are validated before being made available to ensure they’re ready to deploy.

​
Package Contents

Each generated package is a standard Helm chart containing:
Contains package metadata including the package name (e.g., template-abc123), semantic version (like 0.1.0), a dependencies list with all Helm chart sources converted to dependencies, and an auto-generated description based on the template name.

​
Source Metadata and Capabilities

CNAP tracks metadata about your sources to enable powerful capabilities:
When you add charts from Artifact Hub, CNAP stores chart information, documentation, version details, compatibility information, and repository metadata. This enables features like automatic documentation updates and chart information display.
For container images, CNAP tracks the image URL and tag, source repository information, and build metadata.
When you use images built from GitHub workflows, CNAP stores GitHub repository information, workflow run details, and build metadata. This enables automatic image updates when new builds complete, keeping your deployments current with the latest code.
Sources can be configured for automatic deployment, enabling automatic package regeneration when sources update, automatic deployment of new versions, and streamlined update workflows.

​
Why This Matters

Traditional deployment approaches require coordinating multiple sources, managing dependencies, and dealing with version drift. CNAP’s automatic package generation solves these problems:

​
Predictable Deployments

Companies manually pin versions to prevent unexpected updates from external charts. They monitor external sources for breaking changes and manually lock dependency versions. This process is error-prone and time-consuming, and production deployments remain vulnerable to external source changes.
CNAP automatically locks all dependencies at generation time. Every install uses the exact same package version, so you won’t encounter surprises from unexpected updates. Production deployments are isolated from external source changes, eliminating entire classes of vulnerabilities and downtime risks.

​
Self-Contained Packages

In practice, companies create wrapper charts around external dependencies to control versions and configurations. They manually track and bundle dependencies, ensuring deployments work even if sources become unavailable. This requires significant engineering effort and ongoing maintenance.
CNAP automatically bundles all dependencies into your package. Dependencies are packaged automatically, eliminating the need for manual wrapper charts. Packages work offline with no external fetches during deployment. They’re source-independent and work even if original sources become unavailable. Deployments are faster since a single download contains everything, and more reliable with no network dependencies during install.

​
Version Control

Companies manually track version history and manage rollbacks. They document changes between versions and plan gradual rollouts carefully. This requires discipline and process to maintain.
CNAP automatically creates a new package version with each template update. You get complete version history, the ability to rollback to previous versions, gradual rollout capabilities, and clear tracking of what changed - all without manual effort.

​
Standard Helm Compatibility

Generated packages work with all Helm tooling. You can use helm install, helm template, and all Helm CLI commands. Packages work with GitOps tools and deployment platforms, are portable and can be used outside CNAP, and give you access to the entire Helm plugin ecosystem.

​
How It Works

When you create or update a template, CNAP automatically:
  1. Fetches your sources - Retrieves all Helm charts and custom manifests
  2. Merges configurations - Combines values from all sources into a unified configuration
  3. Bundles dependencies - Downloads and packages all Helm chart dependencies
  4. Validates the package - Ensures everything is correct and ready to deploy
  5. Creates the package - Generates a versioned .tgz file
  6. Stores it securely - Saves the package and records the version
Package generation happens in the background, so it won’t block your product creation. The process typically completes in under a minute.

​
When Packages Are Generated

Packages are automatically generated when:
  • Creating a product - First package version is created from your sources
  • Updating a product - New package version is generated with updated sources
  • Creating a direct install - Package is generated for standalone deployments
If you create an install immediately after creating a product, CNAP will wait up to 3 minutes for package generation to complete.

​
Example: Creating Your First Product

Here’s what happens when you create a product:
  1. You add sources - Select PostgreSQL and Redis charts, configure their settings
  2. Template created - CNAP automatically creates a template from your sources
  3. Package generation starts - Background process begins creating your versioned package
  4. Package ready - Your package is stored and ready to deploy
The entire process happens automatically. You can create installs immediately - CNAP handles the timing for you.

​
Benefits

​
For Your Business

  • Faster time to market - No manual package creation or dependency management
  • Reliable deployments - Every install uses the same tested package
  • Version tracking - Complete history of all package versions
  • Simplified operations - One package instead of coordinating multiple sources
  • Automatic updates - Packages can regenerate automatically when sources change

​
For Your Customers

  • Consistent deployments - Same package version every time
  • Faster installs - Pre-computed packages deploy quickly
  • No surprises - Dependencies are locked, no unexpected changes
  • Reliable service - Self-contained packages work even if sources change