Menggunakan Helm dan Kubernetes

1. Gambaran keseluruhan

Helm adalah pengurus pakej untuk aplikasi Kubernetes . Dalam tutorial ini, kita akan memahami asas-asas Helm dan bagaimana mereka membentuk alat yang ampuh untuk bekerja dengan sumber Kubernetes.

Selama bertahun-tahun terakhir, Kubernetes telah berkembang pesat, dan begitu juga ekosistem yang mendukungnya. Baru-baru ini, Helm telah diumumkan sebagai projek inkubasi oleh Cloud Native Computing Foundation (CNCF), yang menunjukkan populariti yang semakin meningkat di kalangan pengguna Kubernetes.

2. Latar belakang

Walaupun istilah-istilah ini cukup umum pada masa ini, terutama di kalangan mereka yang bekerja dengan teknologi awan, mari kita cepat-cepat menerangkannya bagi mereka yang tidak sedar:

  1. Container: Container merujuk kepada virtualisasi tahap sistem operasi . Beberapa kontena dijalankan dalam sistem operasi di ruang pengguna terpencil. Program yang dijalankan dalam wadah hanya mempunyai akses ke sumber yang ditugaskan ke wadah.
  2. Docker: Docker adalah program yang popular untuk membuat dan menjalankan kontena . Ia dilengkapi dengan Docker Daemon, yang merupakan program utama menguruskan kontena. Docker Daemon menawarkan akses ke ciri-cirinya melalui Docker Engine API, yang digunakan oleh Docker Command-Line Interface (CLI). Sila rujuk artikel ini untuk keterangan lebih terperinci mengenai Docker.
  3. Kubernetes: Kubernetes adalah program orkestrasi kontena yang popular . Walaupun ia dirancang untuk berfungsi dengan bekas yang berbeza, Docker paling kerap digunakan. Ini menawarkan berbagai pilihan fitur termasuk otomatisasi penyebaran, penskalaan, dan operasi di sekelompok host. Terdapat liputan Kubernetes yang sangat baik dalam artikel ini untuk rujukan lebih lanjut.

3. Senibina Helm

Helm mempunyai seni bina yang cukup sederhana, yang terdiri daripada pelanggan dan pelayan dalam kluster:

  • Tiller Server: Helm menguruskan aplikasi Kubernetes melalui komponen yang disebut Tiller Server yang dipasang dalam kluster Kubernates. Tiller berinteraksi dengan pelayan Kubernetes API untuk memasang, menaik taraf, membuat pertanyaan dan membuang sumber Kubernetes.
  • Helm Client: Helm menyediakan antara muka baris perintah untuk pengguna bekerjasama dengan Helm Charts . Helm Client bertanggungjawab untuk berinteraksi dengan Tiller Server untuk melakukan pelbagai operasi seperti pemasangan, peningkatan dan rollback chart.

4. Carta Helm

Helm menguruskan pakej sumber Kubernetes melalui Carta .

Kami akan melihat lebih banyak mengenai carta ketika kami membuatnya tidak lama lagi, tetapi buat masa ini, carta tidak lain hanyalah sekumpulan maklumat yang diperlukan untuk membuat aplikasi Kubernetes, diberikan kluster Kubernetes:

  • A carta adalah koleksi fail dianjurkan dalam struktur direktori tertentu
  • Maklumat konfigurasi yang berkaitan dengan carta dikendalikan dalam konfigurasi
  • Akhirnya, contoh carta yang berjalan dengan konfigurasi tertentu disebut pelepasan

5. Persediaan

Kami memerlukan beberapa perkara untuk disiapkan terlebih dahulu agar kami dapat mengembangkan Helm Chart pertama kami.

Pertama, untuk mula bekerja dengan Helm, kita memerlukan kelompok Kubernetes. Untuk tutorial ini, kami akan menggunakan Minikube, yang menawarkan cara terbaik untuk bekerja dengan kluster Kubernetes simpul tunggal di dalam negara . Pada Windows, kini mungkin menggunakan Hyper-V sebagai Hypervisor asli untuk menjalankan Minikube. Rujuk artikel ini untuk memahami penyediaan Minikube dengan lebih terperinci.

Dan, kami memerlukan aplikasi asas untuk menguruskan dalam kelompok Kubernetes. Untuk tutorial ini, kami akan menggunakan aplikasi Spring Boot sederhana yang dikemas sebagai wadah Docker. Untuk keterangan yang lebih terperinci mengenai cara mengemas aplikasi seperti wadah Docker, sila rujuk artikel ini.

6. Memasang Helm

Terdapat beberapa cara untuk memasang Helm yang dijelaskan dengan rapi di halaman pemasangan rasmi di Helm. Cara terpantas untuk memasang helm pada Windows adalah menggunakan Chocolaty , pengurus pakej untuk platform Windows.

Menggunakan Chocolaty, adalah arahan satu baris yang mudah untuk memasang Helm:

choco install kubernetes-helm

Ini memasang Helm Client secara tempatan.

Sekarang, kita perlu menginisialisasi Helm CLI, yang juga berkesan memasang Tiller Server ke kluster Kubernetes seperti yang dikenal pasti melalui konfigurasi Kubernetes. Pastikan kluster Kubernetes berjalan dan dapat diakses melalui kubectl sebelum memulakan Helm :

kubectl cluster-info

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

helm init

7. Membangunkan Carta Pertama Kami

Sekarang kami bersedia untuk mengembangkan Helm Chart pertama kami dengan templat dan nilai.

7.1. Membuat Carta

Helm CLI, yang kami pasangkan lebih awal, cukup berguna dalam membuat carta :

helm create hello-world

Harap maklum bahawa nama carta yang disediakan di sini akan menjadi nama direktori tempat carta dibuat dan disimpan.

Mari lihat struktur direktori yang dibuat untuk kami dengan cepat:

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

Mari fahami perkaitan fail dan folder ini yang dibuat untuk kami:

  • Chart.yaml : Ini adalah fail utama yang mengandungi keterangan carta kami
  • values.yaml : ini adalah fail yang mengandungi nilai lalai untuk carta kami
  • templat : Ini adalah direktori di mana sumber daya Kubernetes didefinisikan sebagai templat
  • carta : Ini adalah direktori pilihan yang mungkin mengandungi sub-carta
  • .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. Kesimpulannya

Ringkasnya, dalam tutorial ini, kami membincangkan komponen teras Helm, pengurus pakej untuk aplikasi Kubernetes. Kami memahami pilihan untuk memasang Helm. Selanjutnya, kami melalui membuat contoh carta dan templat dengan nilai.

Kemudian, kami melalui beberapa arahan yang tersedia sebagai sebahagian daripada Helm CLI untuk menguruskan aplikasi Kubernetes sebagai pakej Helm.

Akhirnya, kami membincangkan pilihan untuk mengedarkan pakej Helm melalui repositori.