GNU/Linux >> Znalost Linux >  >> Panels >> Docker

Jak používat Terraform Kubernetes Provider

Tento článek pokračuje v tématech Linux, Kubernetes a Terraform a pomůže vám zjistit, jak nasadit aplikace do clusteru Kubernetes pomocí Terraformu. Pokryli jsme dva různé přístupy, jak toho dosáhnout – poskytovatele Kubernetes a Helm Terraform. K tomuto účelu nepotřebujete cluster Kubernetes, protože my použijeme Minikube, který si můžete nainstalovat do svého notebooku.

Během 10 minut se také dozvíte, jak nasadit funkční n-tier aplikace v Kubernetes pomocí Terraformu.

Co je Minikube

Nejlepší způsob, jak se naučit Kubernetes a jeho koncepty, je používat Minikube. S Minikube se nemusíte trápit se správou virtuálních strojů nebo nasazováním plně funkčního clusteru Kubernetes.

Tento nástroj s otevřeným zdrojovým kódem podporuje Windows, macOS a Linux a umožňuje vám na místním počítači spustit cluster Kubernetes s jedním uzlem. Tento virtuální stroj může běžet nad Virtualboxem, KVM, Hyper-V nebo Dockerem.

Instalace Minikube

Instalace Minikube je jednoduchý proces. Existuje však pouze jedna závislost, kterou musíte nainstalovat předem – nástroj příkazového řádku s názvem kubectl .

kubectl umožňuje spravovat clustery Kubernetes. Můžete použít kubectl k nasazení aplikací, zobrazení protokolů a správě prostředků clusteru.

Instalace kubectl

Níže je uveden příklad instalačního procesu kubectl pro Linux a 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

Chcete-li nainstalovat kubectl v systému Windows můžete použít správce balíčků Chocolatey:

choco install kubernetes-cli

Případně můžete nainstalovat také kubectl v systému Windows kliknutím sem.

Nyní, když jste nainstalovali kubectl, dalším krokem je instalace Minikube.

Instalovat Minikube

Zde jsou standardní příkazy, které budete potřebovat k instalaci Minikube na Ubuntu, CentOS a macOS:

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

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

Pokud se spoléháte na brew ke správě macOS je lepší použít následující příkaz:

$ brew install minikube

Pokud instalujete minikube v systému Windows je lepší použít Chocolatey:

choco install minikube

Pokud minikube se během instalace nespustil, můžete tak učinit pomocí následujícího příkazu:

$ minikube start

Poskytovatelé Terraform pro nasazení Kubernetes

V současné době jsou k dispozici dva poskytovatelé pro správu aplikací Kubernetes pomocí Terraform:

  • Kubernetes.
  • Kormidlo.

Poskytovatel Kubernetes Terraform

Jako příklad v této části pokryjeme nasazení WordPress pomocí poskytovatele Kubernetes Terraform.

Definování nasazení WordPress pomocí poskytovatele Kubernetes

Zde je konečná struktura projektu:

Použijeme wordpress Obrázek dockeru pro frontendovou vrstvu a mysql Docker image pro DB-tier v našem nasazení.

Pojďme definovat kubernetes poskytovatel v provider.tf soubor:

provider "kubernetes" {
 config_context = "minikube"
}

Dále vytvoříme několik místních proměnných pro označení kubernetes_deployment a kubernetes_service :

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

Pokud chcete, můžete samozřejmě vytvořit další štítky. Účelem štítků v Kubernetes je poskytnout vám možnost vybrat moduly, služby, nasazení a jakékoli další entity Kubernetes.

Existuje mnoho různých způsobů, jak nekódovat hesla napevno v konfiguraci Terraform. Použití parametrů Terraform je jedním z nich. Budeme pokračovat s pevně zakódovaným heslem, aby byla ukázka o něco jednodušší.

Pojďme deklarovat tajemství pro MYSQL_ROOT_PASSWORD proměnnou prostředí, kterou budeme používat v kubernetes_deployment .

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

Nyní jsme připraveni definovat kubernetes_deployment zdroj pro nasazení 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"
             }
           }
         }
       }
     }
   }
 }
}

Celá konfigurace Terraform odráží specifikaci Kubernetes Deployment. Potřebujeme vystavit nasazení WordPressu externím clusterovým sítím pomocí Kubernetes Service, jakmile to deklarujeme.

Pojďme definovat kubernetes_service Zdroj Terraform pro tento účel:

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"
 }
}

Zde říkáme Kubernetes, aby zpřístupnil WordPress Pod pro komunikaci pomocí služby.

Pro vývojové prostředí Minikube představíme WordPress na portu 32000 .

Nyní udělejme totéž pro nasazení 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"
             }
           }
         }
       }
     }
   }
 }
}

Stejně jako v předchozím příkladu zpřístupňujeme nasazení MySQL DB pro nasazení WordPress pomocí služby Kubernetes nakonfigurované prostřednictvím kubernetes_service zdroj:

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

Nasazení konfigurace WordPress Kubernetes Terraform

Jakmile vytvoříme konfiguraci Terraform, můžeme nasadit náš ukázkový příklad.

Inicializujte projekt Terraform a použijte konfiguraci:

$ terraform init

$ terraform apply

Po použití konfigurací uvidíte plán zdrojů a oprávnění k provádění plánovaných činností.

Schvalte plán odpovědí yes .

Po nasazení zdrojů můžeme získat přístup k aplikaci.

Ověřte nasazení

Pojďme ověřit naše nasazení do clusteru pomocí kubectl .

$ kubectl get all

Chceme se ujistit, že všechny zdroje vytvořené Terraformem jsou dostupné.

Testování nasazení

Po ověření nasazení zdrojů WordPress a MySQL můžeme otestovat přístup k aplikaci.

Abychom získali přístup k naší nasazené aplikaci, budeme muset spustit následující příkaz Minikube:

$ minikube service wordpress-service --url

Tento příkaz vám ukáže adresu URL služby WordPress vystavenou Minikube.

Gratulujeme! Naše aplikace WordPress byla úspěšně nasazena.

Poskytovatel helm Terraform

Tato část článku použije poskytovatele kormidla Terraform k nasazení stejné aplikace WordPress do clusteru Kubernetes, ale jinak – pomocí grafů Helm.

Musíme nainstalovat Helm na stroj pro nasazení prostřednictvím poskytovatele Helm, kde se spouští skript Terraform.

Chcete-li se dozvědět více o Helm a procesu vytváření Helmových grafů, doporučuji vám náš článek Rychlý a jednoduchý úvod do grafů [Kubernetes] [Helm] za 10 minut.

Vytváření grafů kormidla

V tomto modulu vytvoříme Helm grafy pro nasazení MySQL a WordPress.

Helm umí vygenerovat základní šablonu, kterou si můžeme upravit podle svých potřeb. Další informace o vytváření grafů Helm najdete v článku Rychlý a jednoduchý úvod do grafů Kubernetes Helm za 10 minut.

Zde je naše konečná struktura projektu:

Pojďme si vytvořit adresář pro grafy:

$ mkdir charts

$ cd charts

MySQL Helm Chart

Nejprve vytvoříme graf kormidla pro MySQL.

$ helm create mysql-chart

Výše uvedený příkaz vytvoří graf s výchozími konfiguracemi.

Prohlédněte si obsah mysql-chart :

Smažte NOTES.txt , hpa.yaml , ingress.yaml, a serviceaccount.yaml soubory z adresáře šablon.

Přepište obsah MySQL deployment.yaml soubor s následujícím:

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'

Zde je obsah service.yaml pro 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 }}

Nahraďte obsah values.yaml pro konfiguraci MySQL.

replicaCount: 1

image:
 repository: mysql:5.6
 pullPolicy: IfNotPresent

deployment:
 name: mysql-deployment

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

WordPress Helm Chart

Vytvořte graf Helm pro WordPress.

$ helm create wordpress-chart

Smažte NOTES.txt , hpa.yaml , ingress.yaml, a serviceaccount.yaml soubory z adresáře šablon.

Obsah souboru deployment.yaml pro WordPress jsou následující:

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'

Obsah souboru service.yaml grafu WordPress jsou následující:

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 }}

Obsah values.yaml pro WordPress jsou následující:

replicaCount: 1

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

deployment:
 name: wordpress-deployment

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

Konfigurace Terraform

Jakmile budeme mít Helmovy diagramy, musíme vytvořit konfigurační soubor Terraform pro nasazení naší aplikace do Kubernetes.

Vraťme se do základního adresáře a definujme helm.tf Konfigurační soubor Terraform s následujícím obsahem:

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"
}

Použití konfigurace Terraform

Posledním krokem je nasazení naší aplikace do clusteru Kubernetes pomocí již známých příkazů:

$ terraform init

$ terraform apply

Schválit plán nasazení konfigurace.

Ověřit nasazení aplikace

Nasazení můžete ověřit pomocí helm příkaz.

$ helm ls

Případně to můžete ověřit také pomocí kubectl příkaz.

$ kubectl get all

Pro přístup k naší nasazené aplikaci budeme muset spustit následující příkaz Minikube:

$ minikube service wordpress-service --url

Tento příkaz vám ukáže adresu URL služby WordPress vystavenou Minikube.

Gratulujeme! Naše aplikace WordPress byla úspěšně nasazena pomocí Helm charts a Terraform.

Uklízení

K vyčištění nasazení Terraformu použijte obvyklý příkaz Terraform zničit v helm-provider nebo kubernetes-provider složky:

$ terraform destroy

Přehled

V tomto článku jsme si ukázali, jak nasadit aplikace do clusteru Kubernetes pomocí Terraformu. Pokryli jsme dva různé přístupy, jak toho dosáhnout – poskytovatele Kubernetes a Helm Terraform. Pro tuto ukázku jsme použili Minikube jako místní cluster Kubernetes.

Doufáme, že vám tento článek bude užitečný! Pokud ano, pomozte nám to rozšířit do světa! Pokud máte nějaké dotazy, dejte nám vědět v sekci komentářů níže.


Docker

  1. Jak používat Docker Compose

  2. Jak používat příkaz Docker Inspect

  3. Jak používat místní docker obrázky s Minikube?

  1. Jak nainstalovat Kubernetes s Minikube na Ubuntu 20.04

  2. Jak používat Podman uvnitř Kubernetes

  3. Jak používat ConfigMaps pro konfiguraci Kubernetes

  1. Tajemství Kubernetes – Jak vytvářet, používat a přistupovat k tajemstvím

  2. Co je Kubernetes DaemonSet a jak jej používat?

  3. Jak nakonfigurovat docker pro použití proxy