Skip to main content

View Repository

Browse the Helm charts repository
 When you deploy applications from GitHub repositories in CNAP, your code is automatically built into a Docker image and deployed using CNAP’s generic application Helm chart. This chart provides a production-ready deployment configuration without requiring you to create a Helm chart yourself.

​
What It Is

The generic application chart is a Helm chart published at https://charts.cnap.tech with the chart name app. It’s designed to deploy any Docker container image to Kubernetes with sensible defaults and extensive customization options.
While the chart is used internally by CNAP for GitHub repository deployments, you can also use it directly with Helm if you want to deploy container images manually.

​
When CNAP Uses It

CNAP automatically uses the generic chart when:
  • Deploying from GitHub repositories - When you create a product or installation using a GitHub repository source
  • Using Docker images - When you deploy a Docker image without a custom Helm chart
  • Direct installations - When you install applications directly without creating a product
The chart is automatically configured with your application’s settings, including:
  • Container image and tag
  • Resource limits and requests
  • Environment variables
  • Exposed ports
  • Health checks
  • Scaling configuration

​
Chart Features

The generic chart provides production-ready features:

​
Container Deployment

  • Deploy any Docker container image
  • Configurable image pull policies
  • Private registry support via CNAP’s registry proxy

​
Service Configuration

  • Multiple service types: ClusterIP, NodePort, LoadBalancer
  • Configurable ports and protocols
  • Service discovery and networking

​
Gateway API Integration

  • Automatic HTTPRoute creation for external access
  • Support for multiple hostnames
  • Path-based and header-based routing rules
  • Integration with Cloudflare Tunnels and other gateway providers

​
Health Checks

  • Configurable liveness and readiness probes
  • HTTP, TCP, and exec probe types
  • Customizable timeouts and thresholds

​
Scaling

  • Horizontal Pod Autoscaler (HPA) support
  • Configurable min/max replicas
  • CPU and memory-based scaling

​
Storage

  • Persistent volume support
  • ConfigMap and Secret volume mounts
  • EmptyDir and hostPath volumes

​
Advanced Features

  • Init containers for setup tasks
  • Sidecar containers for logging, monitoring, etc.
  • Security contexts and pod security policies
  • Resource quotas and limits

​
How It Works

When you deploy from a GitHub repository:
  1. Code is built - Your repository code is built into a Docker image using Railpack (via GitHub Actions workflows)
  2. Chart is selected - CNAP automatically uses the generic app chart from https://charts.cnap.tech
  3. Values are generated - CNAP generates Helm values from your deployment configuration:
    • Image repository and tag
    • Resource limits
    • Environment variables
    • Port configurations
    • Health check settings
  4. Chart is deployed - The chart is deployed to your cluster with the generated values
  5. Application runs - Your application runs in Kubernetes with all configured resources

​
Using the Chart Directly

The chart is published as a Helm repository: 
helm repo add cnap-tech https://charts.cnap.tech
helm repo update
You can inspect the chart directly: 
helm show chart cnap-tech/app
helm show values cnap-tech/app

​
Customization

While CNAP automatically configures the chart for GitHub deployments, you can customize the deployment through CNAP’s interface:
  • Resource limits - Set CPU and memory limits
  • Replicas - Configure the number of pod replicas
  • Environment variables - Add application configuration
  • Ports - Expose application ports
  • Health checks - Configure liveness and readiness probes
  • Scaling - Enable and configure autoscaling
  • Networking - Configure HTTPRoute for external access
All customizations are automatically converted to Helm values and applied when the chart is deployed.

​
Example Values

Here’s an example of the Helm values CNAP generates for a typical Node.js application: 
image:
  repository: ghcr.io/username/myapp
  tag: sha-abc123
  pullPolicy: IfNotPresent

replicaCount: 1

container:
  ports:
    - name: http
      containerPort: 3000
      protocol: TCP
  env:
    - name: NODE_ENV
      value: production
    - name: PORT
      value: "3000"

resources:
  limits:
    cpu: 1000m
    memory: 1Gi
  requests:
    cpu: 500m
    memory: 512Mi

httpRoute:
  enabled: true
  hostnames:
    - myapp.example.com

healthChecks:
  liveness:
    enabled: true
    type: httpGet
    httpGet:
      path: /health
      port: http
  readiness:
    enabled: true
    type: httpGet
    httpGet:
      path: /ready
      port: http

​
Source Code

The chart source code is available in the cnap-tech/charts repository. You can:
  • Review the chart structure and templates
  • Understand how it works internally
  • Contribute improvements
  • Use it as a reference for creating custom charts