Tool

Helm Chart Starter Kit

Generate a base Helm chart with deployment, service, and optional extras.

Back to tools

Chart settings

Chart name

Description

Chart version

App version

Image repository

Image tag

Replica count

Container port

Service type

Service port

Include ingress template

Adds templates/ingress.yaml

Include service account

Adds templates/serviceaccount.yaml

Include ConfigMap

Adds templates/configmap.yaml

Include HPA

Adds templates/hpa.yaml

Include PDB

Adds templates/pdb.yaml

Include Secret

Adds templates/secret.yaml

Include NetworkPolicy

Adds templates/networkpolicy.yaml

Component guide

Chart.yaml

Chart metadata (name, versions, description).

values.yaml

Default values for image, ports, and optional features.

_helpers.tpl

Reusable labels and naming helpers.

deployment.yaml

Application deployment and container spec.

service.yaml

Service exposing the workload.

ingress.yaml

Ingress rules for HTTP routing (optional).

serviceaccount.yaml

Service account for pod identity (optional).

configmap.yaml

Non-secret configuration data (optional).

secret.yaml

Opaque secrets for sensitive values (optional).

hpa.yaml

Autoscaling rules based on CPU (optional).

pdb.yaml

Disruption budget to maintain availability (optional).

networkpolicy.yaml

Ingress network access controls (optional).

Chart.yamlChart metadata.

apiVersion: v2
name: my-app
description: Helm chart for a Kubernetes application.
type: application
version: 0.1.0
appVersion: "1.0.0"

values.yamlDefault values.

replicaCount: 2
image:
  repository: ghcr.io/org/my-app
  tag: latest
  pullPolicy: IfNotPresent
service:
  type: ClusterIP
  port: 80
containerPort: 3000
serviceAccount:
  create: true
  name: ""
ingress:
  enabled: true
  className: ""
  annotations: {}
  hosts:
    - host: chart-example.local
      paths:
        - path: /
          pathType: Prefix
  tls: []
configMap:
  enabled: false
  data:
    APP_ENV: production
secret:
  enabled: false
  data:
    API_TOKEN: ""
hpa:
  enabled: false
  minReplicas: 2
  maxReplicas: 5
  targetCPUUtilizationPercentage: 80
pdb:
  enabled: false
  minAvailable: 1
networkPolicy:
  enabled: false
  ingress:
    - from:
        - podSelector: {}
      ports:
        - protocol: TCP
          port: {{ .Values.service.port }}

templates/_helpers.tplShared helpers and labels.

{{- define "my-app.name" -}}
{{- default .Chart.Name .Values.nameOverride | trunc 63 | trimSuffix "-" -}}
{{- end }}

{{- define "my-app.fullname" -}}
{{- if .Values.fullnameOverride -}}
{{- .Values.fullnameOverride | trunc 63 | trimSuffix "-" -}}
{{- else -}}
{{- printf "%s-%s" .Release.Name (include "my-app.name" .) | trunc 63 | trimSuffix "-" -}}
{{- end -}}
{{- end }}

{{- define "my-app.labels" -}}
helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
app.kubernetes.io/name: {{ include "my-app.name" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
app.kubernetes.io/version: {{ .Chart.AppVersion }}
app.kubernetes.io/managed-by: {{ .Release.Service }}
{{- end }}

{{- define "my-app.selectorLabels" -}}
app.kubernetes.io/name: {{ include "my-app.name" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
{{- end }}

{{- define "my-app.serviceAccountName" -}}
{{- if .Values.serviceAccount.create -}}
{{- default (include "my-app.fullname" .) .Values.serviceAccount.name -}}
{{- else -}}
{{- default "default" .Values.serviceAccount.name -}}
{{- end -}}
{{- end }}

templates/deployment.yamlDeployment template.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "my-app.fullname" . }}
  labels:
    {{- include "my-app.labels" . | nindent 4 }}
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      {{- include "my-app.selectorLabels" . | nindent 6 }}
  template:
    metadata:
      labels:
        {{- include "my-app.selectorLabels" . | nindent 8 }}
    spec:
      {{- if .Values.serviceAccount.create }}
      serviceAccountName: {{ include "my-app.serviceAccountName" . }}
      {{- end }}
      containers:
        - name: {{ .Chart.Name }}
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
          imagePullPolicy: {{ .Values.image.pullPolicy }}
          ports:
            - containerPort: {{ .Values.containerPort }}

templates/service.yamlService template.

apiVersion: v1
kind: Service
metadata:
  name: {{ include "my-app.fullname" . }}
  labels:
    {{- include "my-app.labels" . | nindent 4 }}
spec:
  type: {{ .Values.service.type }}
  ports:
    - port: {{ .Values.service.port }}
      targetPort: {{ .Values.containerPort }}
      protocol: TCP
      name: http
  selector:
    {{- include "my-app.selectorLabels" . | nindent 4 }}

templates/ingress.yamlIngress template.

{{- if .Values.ingress.enabled }}
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: {{ include "my-app.fullname" . }}
  labels:
    {{- include "my-app.labels" . | nindent 4 }}
  annotations:
    {{- toYaml .Values.ingress.annotations | nindent 4 }}
spec:
  ingressClassName: {{ .Values.ingress.className }}
  rules:
    {{- range .Values.ingress.hosts }}
    - host: {{ .host }}
      http:
        paths:
          {{- range .paths }}
          - path: {{ .path }}
            pathType: {{ .pathType }}
            backend:
              service:
                name: {{ include "my-app.fullname" $ }}
                port:
                  number: {{ $.Values.service.port }}
          {{- end }}
    {{- end }}
  tls:
    {{- toYaml .Values.ingress.tls | nindent 4 }}
{{- end }}

templates/serviceaccount.yamlService account template.

{{- if .Values.serviceAccount.create }}
apiVersion: v1
kind: ServiceAccount
metadata:
  name: {{ include "my-app.serviceAccountName" . }}
  labels:
    {{- include "my-app.labels" . | nindent 4 }}
{{- end }}

Was this tool helpful?

About the Helm Chart Starter Kit

Helm's own helm create scaffold is generic by design — every team then spends a day adding the same production necessities: resource limits, probes, security contexts, HPA and PDB templates, and values wiring. This starter kit generates a chart with those decisions already made, structured the way production charts end up anyway.

The generated chart follows the conventions that make charts maintainable: everything configurable through values.yaml with sane defaults, helpers for names and labels in _helpers.tpl, and optional resources (Ingress, HPA, PDB) gated behind enabled flags.

Frequently asked questions

What should a production-ready chart include that helm create doesn't emphasize?

Resource requests and limits (unset means no QoS guarantees), liveness/readiness probes wired to real endpoints, a securityContext (runAsNonRoot, readOnlyRootFilesystem where possible), a PodDisruptionBudget so voluntary evictions can't take out all replicas, and image pinning by tag or digest — never :latest as the default value.

How should values.yaml be structured?

Mirror the resource hierarchy (image.repository, image.tag, resources.requests.cpu), give every value a working default, and gate optional features behind enabled booleans (ingress.enabled, autoscaling.enabled). Document each value with a comment — values.yaml is your chart's public API, and breaking its shape breaks every consumer's overrides.

When is a Helm chart the wrong tool?

When you control both the chart and its only consumer, plain manifests with Kustomize overlays are simpler — Helm earns its templating complexity when you need multi-environment value variation, distribution to other teams, or release lifecycle management (rollbacks, hooks). Many platforms run both: Helm for third-party software, Kustomize for first-party apps.

Need this managed for you, not just automated?

We're also a hands-on DevOps consultancy — Kubernetes, CI/CD, and cloud infrastructure.

Explore Our Services