Menggunakan Helm dan Kubernetes

1. Ikhtisar

Helm adalah manajer paket untuk aplikasi Kubernetes . Dalam tutorial ini, kita akan memahami dasar-dasar Helm dan bagaimana mereka membentuk alat yang ampuh untuk bekerja dengan sumber daya Kubernetes.

Selama beberapa tahun terakhir, Kubernetes telah berkembang pesat, begitu pula ekosistem yang mendukungnya. Baru-baru ini, Helm telah diumumkan sebagai proyek inkubasi oleh Cloud Native Computing Foundation (CNCF), yang menunjukkan popularitasnya yang semakin meningkat di antara pengguna Kubernetes.

2. Latar Belakang

Meskipun istilah-istilah ini cukup umum belakangan ini, terutama di antara mereka yang bekerja dengan teknologi cloud, mari kita bahas dengan cepat bagi mereka yang tidak menyadarinya:

  1. Penampung: Penampung mengacu pada virtualisasi tingkat sistem operasi . Beberapa kontainer dijalankan dalam sistem operasi di ruang pengguna yang terisolasi. Program yang berjalan di dalam penampung hanya memiliki akses ke sumber daya yang ditetapkan ke penampung.
  2. Docker: Docker adalah program populer untuk membuat dan menjalankan kontainer . Muncul dengan Docker Daemon, yang merupakan program utama yang mengelola kontainer. Docker Daemon menawarkan akses ke fitur-fiturnya melalui Docker Engine API, yang digunakan oleh Docker Command-Line Interface (CLI). Silakan merujuk ke artikel ini untuk penjelasan lebih rinci tentang Docker.
  3. Kubernetes: Kubernetes adalah program orkestrasi container yang populer . Meskipun dirancang untuk bekerja dengan kontainer yang berbeda, Docker paling sering digunakan. Ini menawarkan berbagai pilihan fitur termasuk otomatisasi penerapan, penskalaan, dan operasi di seluruh sekelompok host. Ada liputan yang sangat baik tentang Kubernetes dalam artikel ini untuk referensi lebih lanjut.

3. Arsitektur Helm

Helm memiliki arsitektur yang cukup sederhana, yang terdiri dari klien dan server dalam cluster:

  • Tiller Server: Helm mengelola aplikasi Kubernetes melalui komponen yang disebut Tiller Server yang diinstal di dalam cluster Kubernates. Tiller berinteraksi dengan server Kubernetes API untuk menginstal, mengupgrade, menanyakan, dan menghapus resource Kubernetes.
  • Helm Client: Helm menyediakan antarmuka baris perintah bagi pengguna untuk bekerja dengan Helm Charts . Helm Client bertanggung jawab untuk berinteraksi dengan Tiller Server untuk melakukan berbagai operasi seperti menginstal, meningkatkan, dan memutar balik grafik.

4. Diagram Helm

Helm mengelola paket sumber daya Kubernetes melalui Charts .

Kita akan melihat lebih banyak tentang bagan saat kita membuatnya segera, tetapi untuk saat ini, bagan hanyalah sekumpulan informasi yang diperlukan untuk membuat aplikasi Kubernetes, dengan adanya cluster Kubernetes:

  • Sebuah grafik adalah kumpulan file diorganisir dalam struktur direktori tertentu
  • Informasi konfigurasi yang terkait dengan bagan dikelola dalam konfigurasi
  • Terakhir, instance bagan yang sedang berjalan dengan konfigurasi tertentu disebut rilis

5. Pengaturan

Kami memerlukan beberapa hal untuk disiapkan sebelumnya agar kami dapat mengembangkan Diagram Helm pertama kami.

Pertama, untuk mulai bekerja dengan Helm, kita membutuhkan cluster Kubernetes. Untuk tutorial ini, kami akan menggunakan Minikube, yang menawarkan cara terbaik untuk bekerja dengan cluster Kubernetes node tunggal secara lokal . Di Windows, sekarang dimungkinkan untuk menggunakan Hyper-V sebagai Hypervisor asli untuk menjalankan Minikube. Lihat artikel ini untuk memahami pengaturan Minikube secara lebih rinci.

Dan, kita membutuhkan aplikasi dasar untuk mengelola di dalam cluster Kubernetes. Untuk tutorial ini, kami akan menggunakan aplikasi Spring Boot sederhana yang dikemas sebagai container Docker. Untuk penjelasan lebih rinci tentang cara mengemas aplikasi seperti container Docker, lihat artikel ini.

6. Memasang Helm

Ada beberapa cara untuk memasang Helm yang dijelaskan dengan rapi pada halaman pemasangan resmi Helm. Cara tercepat untuk menginstal helm di Windows menggunakan Chocolaty , manajer paket untuk platform Windows.

Menggunakan Chocolaty, ini adalah perintah satu baris sederhana untuk menginstal Helm:

choco install kubernetes-helm

Ini menginstal Klien Helm secara lokal.

Sekarang, kita perlu menginisialisasi Helm CLI, yang secara efektif juga menginstal Server Tiller ke cluster Kubernetes seperti yang diidentifikasi melalui konfigurasi Kubernetes. Harap pastikan bahwa cluster Kubernetes berjalan dan dapat diakses melalui kubectl sebelum menginisialisasi Helm :

kubectl cluster-info

Dan kemudian, kita dapat menginisialisasi Helm melalui Helm CLI itu sendiri:

helm init

7. Mengembangkan Grafik Pertama Kami

Sekarang kita siap untuk mengembangkan Diagram Helm pertama kita dengan templat dan nilai.

7.1. Membuat Bagan

Helm CLI, yang kita instal sebelumnya, sangat berguna dalam membuat grafik :

helm create hello-world

Harap dicatat bahwa nama grafik yang disediakan di sini adalah nama direktori tempat grafik dibuat dan disimpan.

Mari kita lihat dengan cepat struktur direktori yang dibuat untuk kita:

hello-world / Chart.yaml values.yaml templates / charts / .helmignore

Mari kita pahami relevansi file dan folder yang dibuat untuk kita ini:

  • Chart.yaml : Ini adalah file utama yang berisi deskripsi grafik kita
  • values.yaml : ini adalah file yang berisi nilai default untuk grafik kita
  • templates : Ini adalah direktori tempat sumber daya Kubernetes didefinisikan sebagai templat
  • grafik : Ini adalah direktori opsional yang mungkin berisi sub-grafik
  • .helmignore: This is where we can define patterns to ignore when packaging (similar in concept to .gitignore)

7.2. Creating Template

If we see inside the template directory, we'll notice that few templates for common Kubernetes resources have already been created for us:

hello-world / templates / deployment.yaml service.yaml ingress.yaml ......

We may need some of these and possibly other resources in our application, which we'll have to create ourselves as templates.

For this tutorial, we'll create deployment and a service to expose that deployment. Please note the emphasis here is not to understand Kubernetes in detail. Hence we'll keep these resources as simple as possible.

Let's edit the file deployment.yaml inside the templates directory to look like:

apiVersion: apps/v1 kind: Deployment metadata: name: {{ include "hello-world.fullname" . }} labels: app.kubernetes.io/name: {{ include "hello-world.name" . }} helm.sh/chart: {{ include "hello-world.chart" . }} app.kubernetes.io/instance: {{ .Release.Name }} app.kubernetes.io/managed-by: {{ .Release.Service }} spec: replicas: {{ .Values.replicaCount }} selector: matchLabels: app.kubernetes.io/name: {{ include "hello-world.name" . }} app.kubernetes.io/instance: {{ .Release.Name }} template: metadata: labels: app.kubernetes.io/name: {{ include "hello-world.name" . }} app.kubernetes.io/instance: {{ .Release.Name }} spec: containers: - name: {{ .Chart.Name }} image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}" imagePullPolicy: {{ .Values.image.pullPolicy }} ports: - name: http containerPort: 8080 protocol: TCP

Similarly, let's edit the file service.yaml to look like:

apiVersion: v1 kind: Service metadata: name: {{ include "hello-world.fullname" . }} labels: app.kubernetes.io/name: {{ include "hello-world.name" . }} helm.sh/chart: {{ include "hello-world.chart" . }} app.kubernetes.io/instance: {{ .Release.Name }} app.kubernetes.io/managed-by: {{ .Release.Service }} spec: type: {{ .Values.service.type }} ports: - port: {{ .Values.service.port }} targetPort: http protocol: TCP name: http selector: app.kubernetes.io/name: {{ include "hello-world.name" . }} app.kubernetes.io/instance: {{ .Release.Name }}

Now, with our knowledge of Kubernetes, these template files look quite familiar except for some oddities. Note the liberal usage of text within double parentheses {{}}. This is what is called a template directive.

Helm makes use of the Go template language and extends that to something called Helm template language. During the evaluation, every file inside the template directory is submitted to the template rendering engine. This is where the template directive injects actual values in the templates.

7.3. Providing Values

In the previous sub-section, we saw how to use the template directive in our templates. Now, let's understand how we can pass values to the template rendering engine. We typically pass values through Built-in Objects in Helm.

There are many such objects available in Helm, like Release, Values, Chart, and Files.

We can use the file values.yaml in our chart to pass values to the template rendering engine through the Built-in Object Values. Let's modify the values.yaml to look like:

replicaCount: 1 image: repository: "hello-world" tag: "1.0" pullPolicy: IfNotPresent service: type: NodePort port: 80

However, note how these values have been accessed within templates using dots separating namespaces. We have used the image repository and tag as “hello-world” and “1.0”, this must match the docker image tag we created for our Spring Boot application.

8. Understanding Helm Commands

With everything done so far, we're now ready to play with our chart. Let's see what are the different commands available in Helm CLI to make this fun!

8.1. Helm Lint

Firstly, this is a simple command that takes the path to a chart and runs a battery of tests to ensure that the chart is well-formed:

helm lint ./hello-world ==> Linting ./hello-world 1 chart(s) linted, no failures

8.2 Helm Template

Also, we have this command to render the template locally, without a Tiller Server, for quick feedback:

helm template ./hello-world --- # Source: hello-world/templates/service.yaml apiVersion: v1 kind: Service metadata: name: release-name-hello-world labels: app.kubernetes.io/name: hello-world helm.sh/chart: hello-world-0.1.0 app.kubernetes.io/instance: release-name app.kubernetes.io/managed-by: Tiller spec: type: NodePort ports: - port: 80 targetPort: http protocol: TCP name: http selector: app.kubernetes.io/name: hello-world app.kubernetes.io/instance: release-name --- # Source: hello-world/templates/deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: release-name-hello-world labels: app.kubernetes.io/name: hello-world helm.sh/chart: hello-world-0.1.0 app.kubernetes.io/instance: release-name app.kubernetes.io/managed-by: Tiller spec: replicas: 1 selector: matchLabels: app.kubernetes.io/name: hello-world app.kubernetes.io/instance: release-name template: metadata: labels: app.kubernetes.io/name: hello-world app.kubernetes.io/instance: release-name spec: containers: - name: hello-world image: "hello-world:1.0" imagePullPolicy: IfNotPresent ports: - name: http containerPort: 8080 protocol: TCP

8.3. Helm Install

Once we've verified the chart to be fine, finally, we can run this command to install the chart into the Kubernetes cluster:

helm install --name hello-world ./hello-world NAME: hello-world LAST DEPLOYED: Mon Feb 25 15:29:59 2019 NAMESPACE: default STATUS: DEPLOYED RESOURCES: ==> v1/Service NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-world NodePort 10.110.63.169  80:30439/TCP 1s ==> v1/Deployment NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE hello-world 1 0 0 0 1s ==> v1/Pod(related) NAME READY STATUS RESTARTS AGE hello-world-7758b9cdf8-cs798 0/1 Pending 0 0s

Finally, note that we have named the release of this chart with the flag –name. The command responds with the summary of Kubernetes resources created in the process.

8.4. Helm Get

Now, we would like to see which charts are installed as what release. This command lets us query the named releases:

helm ls --all NAME REVISION UPDATED STATUS CHART APP VERSION NAMESPACE hello-world 1 Mon Feb 25 15:29:59 2019 DEPLOYED hello-world-0.1.0 1.0 default

8.5. Helm Upgrade

What if we have modified our chart and need to install the updated version? This command helps us to upgrade a release to a specified or current version of the chart or configuration:

helm upgrade hello-world ./hello-world Release "hello-world" has been upgraded. Happy Helming! LAST DEPLOYED: Mon Feb 25 15:36:04 2019 NAMESPACE: default STATUS: DEPLOYED RESOURCES: ==> v1/Service NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-world NodePort 10.110.63.169  80:30439/TCP 6m5s ==> v1/Deployment NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE hello-world 1 1 1 1 6m5s ==> v1/Pod(related) NAME READY STATUS RESTARTS AGE hello-world-7758b9cdf8-cs798 1/1 Running 0 6m4s

8.6. Helm Rollback

It can always happen that a release went wrong and needs to be taken back. This is the command to rollback a release to the previous version:

helm rollback hello-world 1 Rollback was a success! Happy Helming!

8.7. Helm Delete

Although less likely, we may want to delete a release completely. We can use this command to delete a release from Kubernetes:

helm delete --purge hello-world release "hello-world" deleted

These are only some of the commands available to work with charts and releases in Helm.

9. Distributing Charts

While templating is a powerful tool that Helm brings to the world of managing Kubernetes resources, it's not the only benefit of using Helm. As we saw in the previous section, Helm acts as a package manager for the Kubernetes application and makes installing, querying, upgrading, and deleting releases pretty seamless.

In addition to this, Helm comes with commands as part of its CLI to package, publish, and fetch Kubernetes applications as charts:

9.1. Helm Package

Firstly, we need to package the charts we have created to be able to distribute them. This is the command to create versioned archive files of the chart:

helm package ./hello-world Successfully packaged chart and saved it to: \hello-world\hello-world-0.1.0.tgz

Note that it produces an archive on your machine that can be distributed manually or through public or private chart repositories.

9.2. Helm Repo

Finally, we need a mechanism to work with shared repositories to collaborate. Repo bundles a bunch of commands that we can use to add, remove, list, or index chart repositories. Let's see how we can use them.

We can create a git repository and use that to function as our chart repository. The only requirement is that it should have an index.yaml file.

We can create index.yaml for our chart repo:

helm repo index my-repo/ --url //.github.io/my-repo

This generates the index.yaml file, which we should push to the repository along with the chart archives.

After successfully creating the chart repository, subsequently, we can remotely add this repo:

helm repo add my-repo //my-pages.github.io/my-repo

Now, we should be able to install the charts from our repo directly:

helm install my-repo/hello-world --name=hello-world

There are quite some utility commands available to work with chart repositories.

10. Kesimpulan

Singkatnya, dalam tutorial ini, kita membahas komponen inti Helm, manajer paket untuk aplikasi Kubernetes. Kami memahami opsi untuk menginstal Helm. Selanjutnya, kami membuat bagan sampel dan templat dengan nilai.

Kemudian, kami menggunakan beberapa perintah yang tersedia sebagai bagian dari Helm CLI untuk mengelola aplikasi Kubernetes sebagai paket Helm.

Terakhir, kami membahas opsi untuk mendistribusikan paket Helm melalui repositori.