gh-vukhanhtruong-claude-rock-plugins-devops/skills/helm-scaffold/references/examples.md

Helm Chart Examples

Real-world chart examples for common use cases.

Example 1: Simple Web Application

Scenario: Node.js API microservice

Chart.yaml:

apiVersion: v2
name: user-api
description: User management API service
type: application
version: 0.1.0
appVersion: "1.0.0"

values.yaml (key sections):

replicaCount: 2

image:
  repository: myorg/user-api
  tag: "1.0.0"

service:
  type: ClusterIP
  port: 80
  targetPort: 3000

ingress:
  enabled: true
  className: nginx
  hosts:
    - host: api.example.com
      paths:
        - path: /users
          pathType: Prefix

resources:
  limits: {cpu: 500m, memory: 256Mi}
  requests: {cpu: 100m, memory: 128Mi}

autoscaling:
  enabled: true
  minReplicas: 2
  maxReplicas: 10
  targetCPUUtilizationPercentage: 70

Usage:

helm install user-api . -n production

---

Example 2: Database (StatefulSet)

Scenario: PostgreSQL with persistent storage

Chart.yaml:

apiVersion: v2
name: postgresql
description: PostgreSQL database
type: application
version: 0.1.0
appVersion: "15"

values.yaml (key sections):

replicaCount: 1

image:
  repository: postgres
  tag: "15"

persistence:
  enabled: true
  storageClass: "standard"
  accessMode: ReadWriteOnce
  size: 20Gi

resources:
  limits: {cpu: 1000m, memory: 2Gi}
  requests: {cpu: 250m, memory: 512Mi}

env:
  - name: POSTGRES_DB
    value: myapp
  - name: POSTGRES_USER
    value: postgres
  - name: POSTGRES_PASSWORD
    valueFrom:
      secretKeyRef:
        name: postgres-secret
        key: password

StatefulSet template (key parts):

spec:
  serviceName: postgresql-headless
  volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      accessModes: ["ReadWriteOnce"]
      storageClassName: standard
      resources:
        requests:
          storage: 20Gi

---

Example 3: Scheduled Job (CronJob)

Scenario: Nightly database backup

Chart.yaml:

apiVersion: v2
name: db-backup
description: Automated database backup job
type: application
version: 0.1.0
appVersion: "1.0.0"

values.yaml (key sections):

cronjob:
  schedule: "0 2 * * *"  # 2 AM daily
  successfulJobsHistoryLimit: 7
  failedJobsHistoryLimit: 3
  concurrencyPolicy: Forbid

image:
  repository: myorg/backup-tool
  tag: "latest"

resources:
  limits: {cpu: 500m, memory: 512Mi}
  requests: {cpu: 100m, memory: 128Mi}

env:
  - name: BACKUP_RETENTION_DAYS
    value: "30"
  - name: S3_BUCKET
    value: "my-backups"

---

Example 4: Multi-Environment Configuration

Scenario: Application deployed to dev, staging, prod

values.yaml (base):

replicaCount: 1

image:
  repository: myorg/myapp
  tag: ""

resources:
  limits: {cpu: 500m, memory: 256Mi}
  requests: {cpu: 50m, memory: 64Mi}

env:
  - name: LOG_LEVEL
    value: "info"

values-dev.yaml:

replicaCount: 1

image:
  tag: "dev"

resources:
  limits: {cpu: 200m, memory: 128Mi}
  requests: {cpu: 25m, memory: 32Mi}

env:
  - name: LOG_LEVEL
    value: "debug"
  - name: DEBUG
    value: "true"

ingress:
  enabled: true
  hosts:
    - host: dev.myapp.example.com

values-prod.yaml:

replicaCount: 3

image:
  tag: "1.0.0"

resources:
  limits: {cpu: 1000m, memory: 512Mi}
  requests: {cpu: 100m, memory: 128Mi}

env:
  - name: LOG_LEVEL
    value: "warn"

autoscaling:
  enabled: true
  minReplicas: 3
  maxReplicas: 10

affinity:
  podAntiAffinity:
    preferredDuringSchedulingIgnoredDuringExecution:
    - weight: 100
      podAffinityTerm:
        labelSelector:
          matchExpressions:
          - key: app.kubernetes.io/name
            operator: In
            values: [myapp]
        topologyKey: kubernetes.io/hostname

ingress:
  enabled: true
  className: nginx
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
  hosts:
    - host: myapp.example.com
  tls:
    - secretName: myapp-tls
      hosts:
        - myapp.example.com

Deployment commands:

# Development
helm install myapp . -f values-dev.yaml -n dev

# Production
helm install myapp . -f values-prod.yaml -n production

---

Example 5: Converting Manifest to Helm

Original Kubernetes manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
spec:
  replicas: 2
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: frontend
        image: myorg/frontend:1.0.0
        ports:
        - containerPort: 8080
        resources:
          limits:
            cpu: "500m"
            memory: "256Mi"

Converted Helm template (deployment.yaml):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "frontend.fullname" . }}
  labels:
    {{- include "frontend.labels" . | nindent 4 }}
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      {{- include "frontend.selectorLabels" . | nindent 6 }}
  template:
    metadata:
      labels:
        {{- include "frontend.labels" . | nindent 8 }}
    spec:
      containers:
      - name: {{ .Chart.Name }}
        image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
        ports:
        - name: http
          containerPort: {{ .Values.service.targetPort }}
        resources:
          {{- toYaml .Values.resources | nindent 12 }}

Extracted values.yaml:

replicaCount: 2

image:
  repository: myorg/frontend
  tag: "1.0.0"

service:
  targetPort: 8080

resources:
  limits:
    cpu: 500m
    memory: 256Mi

What was parameterized:

• Replica count → .Values.replicaCount
• Image name/tag → .Values.image.*
• Port → .Values.service.targetPort
• Resources → .Values.resources
• Labels → Helper templates
• Resource name → Template function

---

Example 6: Organizational Standard Template

Scenario: Platform team creates standard chart for all services

Required organizational standards:

• All services must have cost center label
• Security scanning required
• Must use org-wide naming convention
• Mandatory resource limits
• Required network policies

Modified _helpers.tpl:

{{- define "org.labels" -}}
app.kubernetes.io/name: {{ include "chart.name" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
app.kubernetes.io/version: {{ .Chart.AppVersion | quote }}
app.kubernetes.io/managed-by: {{ .Release.Service }}
org.example.com/cost-center: {{ .Values.org.costCenter | required "Cost center is required" }}
org.example.com/team: {{ .Values.org.team | required "Team name is required" }}
org.example.com/security-scan: "required"
{{- end }}

Required values:

org:
  costCenter: ""  # MUST be provided
  team: ""        # MUST be provided

# Resource limits are mandatory
resources:
  limits:
    cpu: 500m
    memory: 256Mi
  requests:
    cpu: 50m
    memory: 64Mi

# Security context is required
securityContext:
  allowPrivilegeEscalation: false
  readOnlyRootFilesystem: true
  runAsNonRoot: true
  capabilities:
    drop: [ALL]

Usage:

helm install myapp . \
  --set org.costCenter=eng-001 \
  --set org.team=platform

---

Example 7: With Subchart Dependency

Scenario: Application that needs PostgreSQL database

Chart.yaml:

apiVersion: v2
name: myapp
version: 0.1.0
appVersion: "1.0.0"

dependencies:
  - name: postgresql
    version: "12.1.0"
    repository: "https://charts.bitnami.com/bitnami"
    condition: postgresql.enabled

values.yaml:

# Application values
replicaCount: 2
image:
  repository: myorg/myapp
  tag: "1.0.0"

# Subchart values
postgresql:
  enabled: true
  auth:
    database: myapp
    username: myapp
  primary:
    persistence:
      size: 10Gi

Install:

# Download dependencies
helm dependency update

# Install with subchart
helm install myapp .

---

Common Patterns

ConfigMap from Files

# values.yaml
config:
  app.conf: |
    server_port=8080
    log_level=info
  db.conf: |
    host=postgres
    port=5432

# templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: {{ include "app.fullname" . }}
data:
  {{- range $key, $value := .Values.config }}
  {{ $key }}: |
    {{- $value | nindent 4 }}
  {{- end }}

External Secret Reference

env:
  - name: DB_PASSWORD
    valueFrom:
      secretKeyRef:
        name: {{ .Values.externalSecret.name }}
        key: password

Horizontal Pod Autoscaler

{{- if .Values.autoscaling.enabled }}
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: {{ include "app.fullname" . }}
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: {{ include "app.fullname" . }}
  minReplicas: {{ .Values.autoscaling.minReplicas }}
  maxReplicas: {{ .Values.autoscaling.maxReplicas }}
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: {{ .Values.autoscaling.targetCPUUtilizationPercentage }}
{{- end }}

These examples demonstrate common patterns and can be adapted for specific use cases.