GNU/Linux >> Belajar Linux >  >> Panels >> Docker

Cara Menggunakan Penyedia Terraform Kubernetes

Artikel ini melanjutkan topik Linux, Kubernetes, dan Terraform dan akan membantu Anda mempelajari cara men-deploy aplikasi ke cluster Kubernetes menggunakan Terraform. Kami telah membahas dua pendekatan berbeda untuk melakukan itu – penyedia Kubernetes dan Helm Terraform. Untuk tujuan ini, Anda tidak memerlukan cluster Kubernetes karena kami akan menggunakan Minikube, yang dapat Anda instal di laptop Anda.

Anda juga akan mempelajari cara men-deploy aplikasi n-tier fungsional di Kubernetes menggunakan Terraform dalam 10 menit.

Apa itu Minikube

Cara terbaik untuk mempelajari Kubernetes dan konsepnya adalah dengan menggunakan Minikube. Dengan Minikube, Anda tidak perlu repot mengelola mesin virtual atau menerapkan cluster Kubernetes yang berfungsi penuh.

Alat sumber terbuka ini mendukung Windows, macOS, dan Linux, memungkinkan Anda meluncurkan kluster Kubernetes node tunggal di komputer lokal Anda. Mesin virtual ini dapat berjalan di atas Virtualbox, KVM, Hyper-V, atau Docker.

Instalasi Minikube

Menginstal Minikube adalah proses yang mudah. Namun, hanya ada satu dependensi yang perlu Anda instal di awal – alat baris perintah yang disebut kubectl .

kubectl memungkinkan Anda untuk mengelola cluster Kubernetes. Anda dapat menggunakan kubectl untuk menerapkan aplikasi, melihat log, dan mengelola sumber daya cluster.

Menginstal kubectl

Di bawah ini adalah contoh proses instalasi kubectl untuk Linux dan macOS:

$ curl -LO "https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl"

$ chmod +x ./kubectl

$ sudo mv ./kubectl /usr/local/bin/kubectl

Untuk menginstal kubectl di Windows, Anda dapat menggunakan pengelola paket Cokelat:

choco install kubernetes-cli

Atau, Anda juga dapat menginstal kubectl di Windows dengan mengklik di sini.

Sekarang Anda telah menginstal kubectl, langkah selanjutnya adalah menginstal Minikube.

Instal Minikube

Berikut adalah perintah standar yang Anda perlukan untuk menginstal Minikube di Ubuntu, CentOS, dan macOS:

$ curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64

$ sudo install minikube-linux-amd64 /usr/local/bin/minikube

Jika Anda mengandalkan brew untuk mengelola macOS Anda, sebaiknya gunakan perintah berikut:

$ brew install minikube

Jika Anda menginstal minikube di Windows, sebaiknya gunakan Cokelat:

choco install minikube

Jika minikube tidak dimulai selama penginstalan, Anda dapat melakukannya dengan menggunakan perintah berikut:

$ minikube start

Penyedia Terraform Untuk Penerapan Kubernetes

Saat ini, ada dua penyedia yang tersedia untuk mengelola aplikasi Kubernetes menggunakan Terraform:

  • Kubernetes.
  • Helm.

Penyedia Terraform Kubernetes

Sebagai contoh, di bagian ini, kita akan membahas penerapan WordPress menggunakan Penyedia Terraform Kubernetes.

Menentukan Penerapan WordPress Menggunakan Penyedia Kubernetes

Inilah struktur akhir proyek:

Kami akan menggunakan wordpress Gambar buruh pelabuhan untuk tingkat frontend dan mysql Gambar Docker untuk DB-tier dalam penerapan kami.

Mari kita definisikan kubernetes penyedia di provider.tf berkas:

provider "kubernetes" {
 config_context = "minikube"
}

Selanjutnya, mari buat beberapa variabel lokal untuk pelabelan kubernetes_deployment dan kubernetes_service :

locals {
 wordpress_labels = {
   App = "wordpress"
   Tier = "frontend"
 }
 mysql_labels = {
   App = "wordpress"
   Tier = "mysql"
 }
}

Anda dapat membuat label tambahan jika Anda mau, tentu saja. Tujuan dari label di Kubernetes adalah untuk memberi Anda kemampuan untuk memilih Pod, Layanan, Deployment, dan entitas Kubernetes lainnya.

Ada banyak cara berbeda untuk tidak membuat hardcode kata sandi dalam konfigurasi Terraform Anda. Menggunakan parameter Terraform adalah salah satunya. Kami akan melanjutkan dengan sandi hardcode untuk menjaga demo sedikit lebih sederhana.

Mari nyatakan rahasia untuk MYSQL_ROOT_PASSWORD variabel lingkungan, yang akan kita gunakan di kubernetes_deployment .

resource "kubernetes_secret" "mysql-pass" {
 metadata {
   name = "mysql-pass"
 }
 data = {
   password = "root"
 }
}

Sekarang, kita siap untuk mendefinisikan kubernetes_deployment sumber daya untuk penerapan WordPress:

resource "kubernetes_deployment" "wordpress" {
 metadata {
   name = "wordpress"
   labels = local.wordpress_labels
 }
 spec {
   replicas = 1
   selector {
     match_labels = local.wordpress_labels
   }
   template {
     metadata {
       labels = local.wordpress_labels
     }
     spec {
       container {
         image = "wordpress:4.8-apache"
         name  = "wordpress"
         port {
           container_port = 80
         }
         env {
           name = "WORDPRESS_DB_HOST"
           value = "mysql-service"
         }
         env {
           name = "WORDPRESS_DB_PASSWORD"
           value_from {
             secret_key_ref {
               name = "mysql-pass"
               key = "password"
             }
           }
         }
       }
     }
   }
 }
}

Seluruh konfigurasi Terraform mencerminkan spesifikasi Kubernetes Deployment. Kami perlu mengekspos Deployment WordPress ke jaringan cluster eksternal menggunakan Layanan Kubernetes segera setelah kami mendeklarasikannya.

Mari kita definisikan kubernetes_service Sumber daya terraform untuk tujuan itu:

resource "kubernetes_service" "wordpress-service" {
 metadata {
   name = "wordpress-service"
 }
 spec {
   selector = local.wordpress_labels
   port {
     port        = 80
     target_port = 80
     node_port = 32000
   }
   type = "NodePort"
 }
}

Di sini, kami memberi tahu Kubernetes untuk membuat WordPress Pod tersedia untuk komunikasi menggunakan Layanan.

Untuk lingkungan pengembangan Minikube, kami akan mengekspos WordPress pada port 32000 .

Sekarang, mari lakukan hal yang sama untuk penerapan MySQL:

resource "kubernetes_deployment" "mysql" {
 metadata {
   name = "mysql"
   labels = local.mysql_labels
 }
 spec {
   replicas = 1
   selector {
     match_labels = local.mysql_labels
   }
   template {
     metadata {
       labels = local.mysql_labels
     }
     spec {
       container {
         image = "mysql:5.6"
         name  = "mysql"
         port {
           container_port = 3306
         }
         env {
           name = "MYSQL_ROOT_PASSWORD"
           value_from {
             secret_key_ref {
               name = "mysql-pass"
               key = "password"
             }
           }
         }
       }
     }
   }
 }
}

Seperti pada contoh sebelumnya, kami membuat MySQL DB Deployment dapat diakses untuk penerapan WordPress menggunakan Layanan Kubernetes yang dikonfigurasi melalui kubernetes_service sumber:

resource "kubernetes_service" "mysql-service" {
 metadata {
   name = "mysql-service"
 }
 spec {
   selector = local.mysql_labels
   port {
     port        = 3306
     target_port = 3306
   }
   type = "NodePort"
 }
}

Terapkan Konfigurasi Terraform Kubernetes WordPress

Segera setelah kami membuat konfigurasi Terraform, kami dapat menerapkan contoh demo kami.

Inisialisasi proyek Terraform dan terapkan konfigurasi:

$ terraform init

$ terraform apply

Setelah menerapkan konfigurasi, Anda akan melihat rencana untuk sumber daya dan izin untuk melakukan aktivitas yang direncanakan.

Setujui rencana dengan menjawab yes .

Setelah penyebaran sumber daya, kita bisa mendapatkan akses ke aplikasi.

Verifikasi Penerapan

Mari validasi penerapan kita ke cluster menggunakan kubectl .

$ kubectl get all

Kami ingin memastikan bahwa semua sumber daya yang dibuat oleh Terraform tersedia.

Menguji Penerapan

Setelah memverifikasi penerapan sumber daya WordPress dan MySQL, kami dapat menguji akses ke aplikasi.

Untuk mendapatkan akses ke aplikasi yang kita gunakan, kita perlu menjalankan perintah Minikube berikut:

$ minikube service wordpress-service --url

Perintah ini akan menunjukkan kepada Anda URL layanan WordPress yang diekspos oleh Minikube.

Selamat! Aplikasi WordPress kami telah berhasil diterapkan.

Penyedia Helm Terraform

Bagian artikel ini akan menggunakan penyedia helm Terraform untuk men-deploy aplikasi WordPress yang sama ke cluster Kubernetes, tetapi berbeda – menggunakan diagram Helm.

Kita harus menginstal Helm pada mesin untuk disebarkan melalui penyedia Helm tempat skrip Terraform dijalankan.

Untuk mempelajari lebih lanjut tentang Helm dan proses pembuatan bagan Helm, saya sarankan Anda artikel kami Pengantar Cepat Dan Sederhana untuk Bagan [Kubernetes] [Helm] dalam 10 menit.

Membuat Diagram Helm

Dalam modul ini, kita akan membuat diagram Helm untuk penerapan MySQL dan WordPress.

Helm dapat menghasilkan template dasar yang dapat kita sesuaikan dengan kebutuhan kita. Untuk informasi selengkapnya tentang membuat diagram Helm, lihat artikel Pengenalan Cepat dan Sederhana untuk Diagram Helm Kubernetes dalam 10 menit.

Berikut struktur proyek akhir kami:

Mari kita direktori untuk grafik:

$ mkdir charts

$ cd charts

Bagan Helm MySQL

Pertama, kita buat diagram kemudi untuk MySQL.

$ helm create mysql-chart

Perintah di atas akan membuat grafik dengan konfigurasi default.

Lihat konten mysql-chart :

Hapus NOTES.txt , hpa.yaml , ingress.yaml, dan serviceaccount.yaml file dari direktori templates.

Ganti konten MySQL deployment.yaml file dengan yang berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
 name: {{ .Values.deployment.name }}
 labels:
   {{- include "mysql-chart.labels" . | nindent 4 }}
spec:
 replicas: {{ .Values.replicaCount }}
 selector:
   matchLabels:
     {{- include "mysql-chart.selectorLabels" . | nindent 6 }}
 template:
   metadata:
     labels:
       {{- include "mysql-chart.selectorLabels" . | nindent 8 }}
   spec:
     containers:
       - name: {{ .Chart.Name }}
         image: "{{ .Values.image.repository }}"
         imagePullPolicy: {{ .Values.image.pullPolicy }}
         ports:
           - name: http
             containerPort: {{ .Values.service.port }}
             protocol: TCP
         env:
           - name: MYSQL_ROOT_PASSWORD
             value: 'admin'

Berikut adalah konten untuk service.yaml untuk MySQL.

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

Ganti konten values.yaml untuk konfigurasi MySQL.

replicaCount: 1

image:
 repository: mysql:5.6
 pullPolicy: IfNotPresent

deployment:
 name: mysql-deployment

service:
 name: mysql-service
 type: ClusterIP
 port: 3306

Bagan Helm WordPress

Buat bagan Helm untuk WordPress.

$ helm create wordpress-chart

Hapus NOTES.txt , hpa.yaml , ingress.yaml, dan serviceaccount.yaml file dari direktori templates.

Konten untuk deployment.yaml untuk WordPress adalah sebagai berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
 name: {{ .Values.deployment.name }}
 labels:
   {{- include "wordpress-chart.labels" . | nindent 4 }}
spec:
 replicas: {{ .Values.replicaCount }}
 selector:
   matchLabels:
     {{- include "wordpress-chart.selectorLabels" . | nindent 6 }}
 template:
   metadata:
     labels:
       {{- include "wordpress-chart.selectorLabels" . | nindent 8 }}
   spec:
     containers:
       - name: {{ .Chart.Name }}
         image: {{ .Values.image.repository }}
         imagePullPolicy: {{ .Values.image.pullPolicy }}
         ports:
           - name: http
             containerPort: {{ .Values.service.port }}
             protocol: TCP
         env:
           - name: WORDPRESS_DB_HOST
             value: 'mysql-service'
           - name: WORDPRESS_DB_PASSWORD
             value: 'admin'

Konten untuk service.yaml grafik WordPress adalah sebagai berikut:

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

Isi dari values.yaml untuk WordPress adalah sebagai berikut:

replicaCount: 1

image:
 repository: wordpress:4.8-apache
 pullPolicy: IfNotPresent

deployment:
 name: wordpress-deployment

service:
 name: wordpress-service
 type: NodePort
 port: 80
 nodePort: 32000

Konfigurasi Terraform

Segera setelah kita memiliki diagram Helm, kita perlu membuat file konfigurasi Terraform untuk men-deploy aplikasi kita ke Kubernetes.

Mari kembali ke direktori dasar dan tentukan helm.tf File konfigurasi Terraform dengan konten berikut:

provider "helm" {
 kubernetes {
   config_context = "minikube"
 }
}

resource "helm_release" "mysql" {
 name  = "mysql"
 chart = "${abspath(path.root)}/charts/mysql-chart"
}

resource "helm_release" "wordpress" {
 name  = "wordpress"
 chart = "${abspath(path.root)}/charts/wordpress-chart"
}

Menerapkan Konfigurasi Terraform

Langkah terakhir adalah men-deploy aplikasi kita ke cluster Kubernetes menggunakan perintah yang sudah diketahui:

$ terraform init

$ terraform apply

Setujui rencana untuk menerapkan konfigurasi.

Verifikasi Penerapan Aplikasi

Anda dapat memverifikasi penerapan dengan menggunakan helm perintah.

$ helm ls

Atau, Anda juga dapat memverifikasinya dengan menggunakan kubectl perintah.

$ kubectl get all

Untuk mengakses aplikasi yang kita gunakan, kita perlu menjalankan perintah Minikube berikut:

$ minikube service wordpress-service --url

Perintah ini akan menunjukkan kepada Anda URL layanan WordPress yang diekspos oleh Minikube.

Selamat! Aplikasi WordPress kami telah berhasil digunakan menggunakan grafik Helm dan Terraform.

Membersihkan

Untuk membersihkan penerapan Terraform, gunakan perintah penghancuran Terraform biasa di helm-provider atau kubernetes-provider folder:

$ terraform destroy

Ringkasan

Pada artikel ini, kami menunjukkan cara men-deploy aplikasi ke cluster Kubernetes menggunakan Terraform. Kami telah membahas dua pendekatan berbeda untuk melakukan itu – penyedia Kubernetes dan Helm Terraform. Untuk demo ini, kami menggunakan Minikube sebagai cluster Kubernetes lokal.

Kami harap artikel ini bermanfaat bagi Anda! Jika ya, tolong bantu kami untuk menyebarkannya ke seluruh dunia! Harap beri tahu kami di bagian komentar di bawah jika Anda memiliki pertanyaan.


Docker

  1. Cara menggunakan Podman di dalam Kubernetes

  2. Cara Menggunakan Tulis Docker

  3. Cara Menggunakan Perintah Inspeksi Docker

  1. Cara Menginstal Kubernetes dengan Minikube di Ubuntu 20.04

  2. Cara Menggunakan ConfigMaps Untuk Konfigurasi Kubernetes

  3. Bagaimana cara menggunakan gambar buruh pelabuhan lokal dengan Minikube?

  1. Rahasia Kubernetes – Cara Membuat, Menggunakan, dan Mengakses Rahasia

  2. Apa itu Kubernetes DaemonSet dan Bagaimana Cara Menggunakannya?

  3. Cara mengkonfigurasi buruh pelabuhan untuk menggunakan proxy