Helm Charts: Manajemen Paket Kubernetes

Penempatan Kubernetes dengan manajemen paket Helm

Helm telah merevolusi pengembangan aplikasi Kubernetes dengan memperkenalkan konsep manajemen paket yang familiar dari sistem operasi tradisional.

Seiring meningkatnya pengadopsian Kubernetes, mengelola aplikasi kompleks dengan puluhan file YAML menjadi tantangan. Helm Charts menyelesaikan masalah ini dengan mengemas semua sumber daya menjadi paket yang diberi versi dan dapat dikonfigurasi.

software-developer di alam Gambar yang menarik ini dihasilkan oleh AI model Flux 1 dev.

Memahami Helm: Manajer Paket Kubernetes

Helm adalah seperti apt untuk Debian, yum untuk RedHat, atau Homebrew untuk macOS. Ia mengemas aplikasi Kubernetes menjadi Charts – kumpulan file yang menggambarkan sumber daya Kubernetes yang terkait. Sebuah Chart tunggal mungkin mendeploy stack aplikasi lengkap: server web, database, lapisan caching, aturan masuk, dan komponen pemantauan. Untuk mereka yang baru mengenal Kubernetes, Kubernetes Cheatsheet menyediakan perintah dan konsep penting untuk memulai.

Mengapa Helm Penting dalam DevOps Modern

Pengurangan Kompleksitas: Daripada mengelola 20+ file YAML, Anda mengelola satu Chart dengan nilai-nilai yang dapat dikustomisasi.

Reproduksibilitas: Deploy konfigurasi yang identik di lingkungan pengembangan, staging, dan produksi dengan override nilai spesifik lingkungan. Ini sangat berharga saat mendeploy arsitektur microservices kompleks di mana konsistensi penting.

Kontrol Versi: Charts diberi versi, memungkinkan rollback dan pelacakan upgrade yang mudah.

Ekosistem Komunitas: Ribuan Charts siap pakai tersedia melalui Artifact Hub (sebelumnya Helm Hub) untuk aplikasi populer seperti PostgreSQL, Redis, NGINX, Prometheus, dan lainnya.

Kekuatan Templating: Template Go memungkinkan pembuatan sumber daya dinamis berdasarkan nilai input, mengurangi duplikasi.

Arsitektur Helm dan Konsep Utama

Arsitektur Helm 3

Helm 3 menyederhanakan arsitektur dengan menghilangkan Tiller, komponen server-side yang bermasalah dari Helm 2:

  • Helm Client: Alat CLI yang berinteraksi langsung dengan API Kubernetes
  • Chart: Format paket yang berisi template dan metadata
  • Release: Instance dari Chart yang berjalan di cluster Kubernetes
  • Repository: Lokasi penyimpanan untuk Charts (server HTTP atau OCI registry)

Komponen Utama dari Helm Chart

my-app-chart/
├── Chart.yaml          # Metadata dan versi Chart
├── values.yaml         # Nilai konfigurasi default
├── charts/             # Charts dependen
├── templates/          # Template sumber daya Kubernetes
│   ├── deployment.yaml
│   ├── service.yaml
│   ├── ingress.yaml
│   ├── _helpers.tpl    # Fungsi template bantu
│   └── NOTES.txt       # Catatan pasca-instalasi
├── .helmignore         # File yang diabaikan saat pengemasan
├── README.md
└── LICENSE

Membuat Helm Chart Pertama Anda

Menginisialisasi Chart Baru

helm create my-application
cd my-application

Ini menghasilkan Chart awal dengan template contoh untuk deployment, service, dan ingress.

Chart.yaml: Mendefinisikan Metadata

apiVersion: v2
name: my-application
description: Chart aplikasi yang siap produksi
type: application
version: 1.0.0        # Versi Chart
appVersion: "2.4.1"   # Versi aplikasi

maintainers:
  - name: Tim Anda
    email: tim@perusahaan.com

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

values.yaml: Manajemen Konfigurasi

File values.yaml mendefinisikan konfigurasi default yang pengguna dapat menggantinya. Pendekatan ini memisahkan konfigurasi dari template, membuatnya mudah untuk mengelola lingkungan berbeda (pengembangan, staging, produksi) dan mengkustomisasi deployment tanpa mengubah file template.

replicaCount: 3

image:
  repository: myapp/backend
  tag: "1.0.0"
  pullPolicy: IfNotPresent

service:
  type: ClusterIP
  port: 80

ingress:
  enabled: true
  className: "nginx"
  annotations:
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
  hosts:
    - host: myapp.example.com
      paths:
        - path: /
          pathType: Prefix

resources:
  limits:
    cpu: 500m
    memory: 512Mi
  requests:
    cpu: 250m
    memory: 256Mi

autoscaling:
  enabled: true
  minReplicas: 3
  maxReplicas: 10
  targetCPUUtilizationPercentage: 80

Template: Manifest Kubernetes Dinamis

Template menggunakan sintaks templating Go untuk menghasilkan sumber daya Kubernetes secara dinamis. Template ini dapat menghasilkan jenis sumber daya Kubernetes apa pun, dari deployment sederhana hingga StatefulSets kompleks untuk aplikasi yang membutuhkan penyimpanan persisten. Untuk aplikasi yang membutuhkan identitas stabil dan penyimpanan persisten, Anda ingin menggunakan StatefulSets daripada Deployments, seperti yang dijelaskan dalam panduan kami tentang StatefulSets dan Penyimpanan Persisten di Kubernetes.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "my-application.fullname" . }}
  labels:
    {{- include "my-application.labels" . | nindent 4 }}
spec:
  {{- if not .Values.autoscaling.enabled }}
  replicas: {{ .Values.replicaCount }}
  {{- end }}
  selector:
    matchLabels:
      {{- include "my-application.selectorLabels" . | nindent 6 }}
  template:
    metadata:
      labels:
        {{- include "my-application.selectorLabels" . | nindent 8 }}
    spec:
      containers:
      - name: {{ .Chart.Name }}
        image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
        imagePullPolicy: {{ .Values.image.pullPolicy }}
        ports:
        - containerPort: 8080
          protocol: TCP
        resources:
          {{- toYaml .Values.resources | nindent 10 }}

Template Bantu (_helpers.tpl)

Buat fungsi template yang dapat digunakan kembali untuk menghindari pengulangan:

{{/*
Ekspansi nama chart.
*/}}
{{- define "my-application.name" -}}
{{- default .Chart.Name .Values.nameOverride | trunc 63 | trimSuffix "-" }}
{{- end }}

{{/*
Buat nama aplikasi penuh default.
*/}}
{{- define "my-application.fullname" -}}
{{- if .Values.fullnameOverride }}
{{- .Values.fullnameOverride | trunc 63 | trimSuffix "-" }}
{{- else }}
{{- $name := default .Chart.Name .Values.nameOverride }}
{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" }}
{{- end }}
{{- end }}

{{/*
Label umum
*/}}
{{- define "my-application.labels" -}}
helm.sh/chart: {{ include "my-application.chart" . }}
{{ include "my-application.selectorLabels" . }}
{{- if .Chart.AppVersion }}
app.kubernetes.io/version: {{ .Chart.AppVersion | quote }}
{{- end }}
app.kubernetes.io/managed-by: {{ .Release.Service }}
{{- end }}

Mengelola Helm Charts: Instalasi dan Operasi

Menginstal Chart

# Instal dari repository
helm install my-release bitnami/postgresql

# Instal dari direktori lokal
helm install my-app ./my-application

# Instal dengan nilai-nilai kustom
helm install my-app ./my-application -f values-production.yaml

# Instal dengan override nilai inline
helm install my-app ./my-application \
  --set replicaCount=5 \
  --set image.tag=2.0.0

Memperbarui Release

# Perbarui dengan nilai-nilai baru
helm upgrade my-app ./my-application -f values-production.yaml

# Perbarui dengan rollback otomatis jika gagal
helm upgrade my-app ./my-application --atomic --timeout 5m

# Paksa pembaruan sumber daya
helm upgrade my-app ./my-application --force

Rollback dan Riwayat

# Lihat riwayat release
helm history my-app

# Rollback ke versi sebelumnya
helm rollback my-app

# Rollback ke revisi spesifik
helm rollback my-app 3

Pengujian dan Debugging

# Dry-run untuk melihat manifest yang dihasilkan
helm install my-app ./my-application --dry-run --debug

# Rendering template tanpa instalasi
helm template my-app ./my-application

# Periksa chart untuk masalah
helm lint ./my-application

# Uji release dengan hook pengujian
helm test my-app

Fitur Helm Lanjutan

Ketergantungan Chart

Chart Helm dapat bergantung pada Chart lain, memungkinkan Anda menyusun aplikasi kompleks dari komponen yang dapat digunakan ulang. Ini sangat berguna saat mendeploy microservices yang membutuhkan database, antrian pesan, atau layanan pendukung lainnya. Definisikan ketergantungan dalam Chart.yaml:

dependencies:
  - name: redis
    version: "17.x.x"
    repository: "https://charts.bitnami.com/bitnami"
    condition: redis.enabled
  - name: postgresql
    version: "12.x.x"
    repository: "https://charts.bitnami.com/bitnami"
    condition: postgresql.enabled

Perbarui ketergantungan:

helm dependency update ./my-application

Hook Helm untuk Manajemen Siklus Hidup

Hook dieksekusi pada titik-titik spesifik dalam siklus hidup release:

apiVersion: batch/v1
kind: Job
metadata:
  name: {{ include "my-application.fullname" . }}-db-migration
  annotations:
    "helm.sh/hook": pre-upgrade,pre-install
    "helm.sh/hook-weight": "5"
    "helm.sh/hook-delete-policy": before-hook-creation
spec:
  template:
    spec:
      containers:
      - name: db-migrate
        image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
        command: ["python", "manage.py", "migrate"]
      restartPolicy: Never

Jenis hook termasuk:

  • pre-install: Sebelum sumber daya diinstal
  • post-install: Setelah semua sumber daya diinstal
  • pre-upgrade: Sebelum upgrade
  • post-upgrade: Setelah upgrade
  • pre-delete: Sebelum penghapusan
  • post-delete: Setelah penghapusan
  • pre-rollback: Sebelum rollback
  • post-rollback: Setelah rollback

Logika Kondisional dan Kontrol Alur

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

Dukungan OCI Registry: Distribusi Chart Modern

Sejak Helm 3.8, dukungan OCI (Open Container Initiative) registry stabil, memungkinkan Chart disimpan bersama dengan gambar kontainer.

Menerbitkan ke OCI Registry

# Masuk ke registry
helm registry login registry.example.com

# Paketkan chart
helm package ./my-application

# Kirim ke OCI registry
helm push my-application-1.0.0.tgz oci://registry.example.com/charts

# Instal dari OCI registry
helm install my-app oci://registry.example.com/charts/my-application --version 1.0.0

Manfaat OCI Registry

  • Penyimpanan Terpadu: Chart dan gambar dalam satu tempat
  • Alat Standar: Gunakan infrastruktur registry yang ada
  • Keamanan Lebih Baik: Manfaatkan otentikasi dan pemindaian registry
  • Manajemen Lebih Sederhana: Tidak diperlukan server repository Chart terpisah

Praktik Terbaik untuk Chart Helm Produksi

1. Struktur dan Dokumentasi Nilai

Dokumentasikan semua nilai dengan komentar:

# -- Jumlah replika untuk aplikasi
replicaCount: 3

# -- Konfigurasi gambar
image:
  # -- Repository gambar
  repository: myapp/backend
  # -- Kebijakan tarik gambar
  pullPolicy: IfNotPresent
  # -- Tag gambar (default ke appVersion chart)
  tag: ""

2. Manajemen Sumber Daya

Selalu tetapkan permintaan dan batas sumber daya:

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

3. Konteks Keamanan

Definisikan konteks keamanan untuk kontainer:

securityContext:
  runAsNonRoot: true
  runAsUser: 1000
  fsGroup: 1000
  capabilities:
    drop:
    - ALL
  readOnlyRootFilesystem: true

4. Pemeriksaan Kesehatan

Sertakan probe kesehatan dan kesiapan:

livenessProbe:
  httpGet:
    path: /health
    port: 8080
  initialDelaySeconds: 30
  periodSeconds: 10

readinessProbe:
  httpGet:
    path: /ready
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 5

5. Manajemen ConfigMap dan Secret

Manajemen secret yang tepat sangat penting untuk deployment produksi. Gunakan manajer secret eksternal (Sealed Secrets, External Secrets Operator, atau Vault) daripada menyimpan secret dalam file nilai. Ini memastikan data sensitif seperti kata sandi database, kunci API, dan sertifikat dikelola secara aman:

envFrom:
- secretRef:
    name: {{ include "my-application.fullname" . }}-secrets
- configMapRef:
    name: {{ include "my-application.fullname" . }}-config

6. Validasi Skema

Buat values.schema.json untuk memvalidasi input pengguna:

{
  "$schema": "https://json-schema.org/draft-07/schema#",
  "properties": {
    "replicaCount": {
      "type": "integer",
      "minimum": 1
    },
    "image": {
      "type": "object",
      "properties": {
        "repository": {
          "type": "string"
        },
        "tag": {
          "type": "string"
        }
      },
      "required": ["repository"]
    }
  },
  "required": ["image"]
}

7. NOTES.txt untuk Panduan Pengguna

Berikan instruksi pasca-instalasi:

1. Dapatkan URL aplikasi dengan menjalankan:
{{- if .Values.ingress.enabled }}
  https://{{ (index .Values.ingress.hosts 0).host }}
{{- else if contains "NodePort" .Values.service.type }}
  export NODE_PORT=$(kubectl get --namespace {{ .Release.Namespace }} -o jsonpath="{.spec.ports[0].nodePort}" services {{ include "my-application.fullname" . }})
  export NODE_IP=$(kubectl get nodes --namespace {{ .Release.Namespace }} -o jsonpath="{.items[0].status.addresses[0].address}")
  echo http://$NODE_IP:$NODE_PORT
{{- end }}

2. Pantau deployment:
  kubectl --namespace {{ .Release.Namespace }} get pods -l "app.kubernetes.io/name={{ include "my-application.name" . }}"

Pengujian Chart Helm dan Integrasi CI/CD

Pengujian Chart dengan chart-testing (ct)

# Instal chart-testing
brew install chart-testing

# Lint chart
ct lint --config ct.yaml

# Instal dan uji chart
ct install --config ct.yaml

Contoh GitHub Actions

name: Helm Chart CI

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  lint-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0

      - name: Set up Helm
        uses: azure/setup-helm@v3
        with:
          version: 3.12.0

      - name: Set up chart-testing
        uses: helm/chart-testing-action@v2

      - name: Lint charts
        run: ct lint --config ct.yaml

      - name: Create kind cluster
        uses: helm/kind-action@v1

      - name: Install charts
        run: ct install --config ct.yaml

GitOps dengan Helm: ArgoCD dan Flux

Alat GitOps seperti ArgoCD dan Flux terintegrasi dengan sempurna dengan Chart Helm, memungkinkan deployment otomatis yang deklaratif. Alat-alat ini memantau repositori Git Anda untuk perubahan dan secara otomatis menyinkronkan release Helm, membuat deployment kontinu menjadi sederhana. Untuk arsitektur microservices kompleks, pertimbangkan bagaimana pola transaksi terdistribusi seperti Saga pattern dapat membantu mengelola konsistensi di antara layanan yang dideploy melalui Helm.

Aplikasi ArgoCD

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-application
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/myorg/my-app-chart
    targetRevision: main
    path: charts/my-application
    helm:
      valueFiles:
        - values-production.yaml
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

HelmRelease Flux

apiVersion: helm.toolkit.fluxcd.io/v2beta1
kind: HelmRelease
metadata:
  name: my-application
  namespace: flux-system
spec:
  interval: 5m
  chart:
    spec:
      chart: my-application
      version: '1.x.x'
      sourceRef:
        kind: HelmRepository
        name: my-charts
  values:
    replicaCount: 5
    image:
      tag: "2.0.0"

Menyelesaikan Masalah Umum Helm

Masalah: Upgrade Gagal dan Tertunda

# Periksa status release
helm list --all-namespaces

# Dapatkan detail release
helm status my-app -n namespace

# Hapus paksa jika diperlukan (gunakan dengan hati-hati)
kubectl delete secret -n namespace -l owner=helm,name=my-app

Masalah: Kesalahan Rendering Template

# Debug rendering template
helm template my-app ./my-application --debug

# Validasi terhadap Kubernetes
helm template my-app ./my-application | kubectl apply --dry-run=client -f -

Masalah: Nilai Tidak Diterapkan

# Periksa nilai yang digabungkan
helm get values my-app

# Tunjukkan semua nilai yang dihitung
helm get values my-app --all

Ekosistem dan Alat Helm

Ekosistem Helm mencakup banyak alat yang memperluas kemampuannya dan terintegrasi dengan teknologi Kubernetes lainnya. Saat mendeploy aplikasi yang membutuhkan fitur jaringan lanjutan seperti komunikasi antar layanan, manajemen lalu lintas, dan kebijakan keamanan, pertimbangkan untuk mengintegrasikan dengan Service Mesh dengan Istio dan Linkerd, yang dapat dideploy dan dikelola melalui Chart Helm.

Alat Penting

  • Helmfile: Spesifikasi deklaratif untuk mendeploy Chart Helm
  • Helm Diff: Pratinjau perubahan sebelum upgrade
  • Helm Secrets: Kelola secret dengan SOPS
  • Nova: Temukan Chart Helm yang usang
  • Pluto: Deteksi API Kubernetes yang sudah tidak digunakan

Contoh Helmfile

repositories:
  - name: bitnami
    url: https://charts.bitnami.com/bitnami

releases:
  - name: postgresql
    namespace: database
    chart: bitnami/postgresql
    version: 12.x.x
    values:
      - postgresql:
          auth:
            database: myapp
            username: appuser

  - name: my-app
    namespace: production
    chart: ./charts/my-application
    values:
      - values-production.yaml
    needs:
      - database/postgresql

Masa Depan Helm

Ekosistem Helm terus berkembang:

  • OCI-Native: Transisi penuh ke OCI registry sebagai standar
  • Keamanan yang Lebih Baik: Manajemen secret dan kemampuan penandatanganan yang lebih baik
  • Kinerja: Rendering dan instalasi yang lebih cepat untuk Chart besar
  • Dukungan WASM: WebAssembly untuk plugin dan ekstensi Chart
  • Validasi yang Lebih Baik: Validasi skema yang ditingkatkan dan penerapan kebijakan

Kesimpulan

Helm telah menjadi standar de facto untuk manajemen paket Kubernetes, dan memahaminya sangat penting untuk praktik DevOps modern. Dengan memahami struktur Chart, templating, manajemen nilai, dan praktik terbaik, Anda dapat menciptakan deployment Kubernetes yang dapat dipelihara, aman, dan skalabel.

Mulailah dengan Chart sederhana, secara bertahap tambahkan fitur lanjutan seperti hook dan ketergantungan, dan integrasikan dengan alat GitOps untuk infrastruktur produksi. Komunitas Helm menyediakan ribuan Chart siap pakai, tetapi kekuatan sebenarnya datang dari menciptakan Chart kustom yang disesuaikan dengan kebutuhan organisasi Anda. Baik Anda mendeploy aplikasi tanpa status atau beban kerja yang membutuhkan penyimpanan persisten, Helm menyederhanakan kompleksitas manajemen sumber daya Kubernetes. Untuk tim yang menyiapkan cluster Kubernetes baru, pertimbangkan menginstal Kubernetes dengan Kubespray atau mengeksplorasi distribusi Kubernetes seperti k3s atau MicroK8s untuk lingkungan pengembangan. Jika Anda mengevaluasi distribusi mana yang cocok untuk kebutuhan homelab atau cluster kecil Anda, lihat perbandingan komprehensif distribusi Kubernetes untuk analisis terperinci.

Tautan Berguna