Come utilizzare il provider Kubernetes Terraform

Questo articolo continua gli argomenti di Linux, Kubernetes e Terraform e ti aiuterà a imparare come distribuire applicazioni nel cluster Kubernetes usando Terraform. Abbiamo coperto due diversi approcci per farlo:i fornitori di Kubernetes e Helm Terraform. A tale scopo, non è necessario un cluster Kubernetes poiché utilizzeremo Minikube, che puoi installare sul tuo laptop.

Imparerai anche come distribuire applicazioni funzionali di livello n su Kubernetes utilizzando Terraform in 10 minuti.

Cos'è Minikube

Il modo migliore per imparare Kubernetes e i suoi concetti è utilizzare Minikube. Con Minikube, non è necessario affrontare la seccatura di gestire macchine virtuali o distribuire un cluster Kubernetes completamente funzionale.

Questo strumento open source supporta Windows, macOS e Linux, consentendoti di avviare un cluster Kubernetes a nodo singolo sul tuo computer locale. Questa macchina virtuale può essere eseguita su Virtualbox, KVM, Hyper-V o Docker.

Installazione di Minikube

L'installazione di Minikube è un processo semplice. Tuttavia, c'è solo una dipendenza che devi installare in anticipo:uno strumento da riga di comando chiamato kubectl .

kubectl ti consente di gestire i cluster Kubernetes. Puoi utilizzare kubectl per distribuire applicazioni, visualizzare i log e gestire le risorse del cluster.

Installazione di kubectl

Di seguito è riportato un esempio del processo di installazione di kubectl per Linux e 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

Per installare kubectl su Windows, puoi utilizzare Chocolatey package manager:

choco install kubernetes-cli

In alternativa, puoi anche installare kubectl su Windows facendo clic qui.

Ora che hai installato kubectl, il passaggio successivo è installare Minikube.

Installa Minikube

Ecco i comandi standard necessari per installare Minikube su Ubuntu, CentOS e macOS:

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

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

Se fai affidamento su brew per gestire il tuo macOS, è meglio usare il seguente comando:

$ brew install minikube

Se stai installando minikube su Windows, è meglio usare Chocolatey:

choco install minikube

Se minikube non è stato avviato durante l'installazione, è possibile farlo utilizzando il seguente comando:

$ minikube start

Fornitori di terraform per la distribuzione di Kubernetes

Attualmente, sono disponibili due provider per la gestione delle applicazioni Kubernetes utilizzando Terraform:

• Kubernetes.
• Timone.

Kubernetes Terraform Provider

Ad esempio, in questa sezione tratteremo la distribuzione di WordPress utilizzando il Kubernetes Terraform Provider.

Definisci la distribuzione di WordPress utilizzando il provider Kubernetes

Ecco la struttura finale del progetto:

Useremo wordpress Immagine Docker per il livello frontend e mysql Immagine Docker per il livello DB nella nostra distribuzione.

Definiamo kubernetes provider in provider.tf file:

provider "kubernetes" {
 config_context = "minikube"
}

Quindi, creiamo un paio di variabili locali per etichettare kubernetes_deployment e kubernetes_service :

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

Puoi creare etichette aggiuntive se lo desideri, ovviamente. Lo scopo delle etichette in Kubernetes è darti la possibilità di selezionare pod, servizi, distribuzione e qualsiasi altra entità Kubernetes.

Esistono molti modi diversi per non codificare le password nella configurazione di Terraform. L'uso dei parametri Terraform è uno di questi. Continueremo con una password hardcoded per rendere la demo un po' più semplice.

Dichiariamo un segreto per MYSQL_ROOT_PASSWORD variabile di ambiente, che useremo in kubernetes_deployment .

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

Ora siamo pronti per definire kubernetes_deployment risorsa per la distribuzione di 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"
             }
           }
         }
       }
     }
   }
 }
}

L'intera configurazione di Terraform riflette le specifiche di distribuzione di Kubernetes. Abbiamo bisogno di esporre la distribuzione di WordPress alle reti di cluster esterne utilizzando il servizio Kubernetes non appena lo abbiamo dichiarato.

Definiamo kubernetes_service Risorsa Terraform a tale scopo:

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

Qui, stiamo dicendo a Kubernetes di rendere disponibile WordPress Pod per la comunicazione utilizzando il servizio.

Per l'ambiente di sviluppo Minikube, esporremo WordPress sulla porta 32000 .

Ora, facciamo la stessa cosa per la distribuzione di 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"
             }
           }
         }
       }
     }
   }
 }
}

Come nell'esempio precedente, stiamo rendendo accessibile la distribuzione di database MySQL per la distribuzione di WordPress utilizzando il servizio Kubernetes configurato tramite kubernetes_service risorsa:

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

Distribuisci la configurazione di WordPress Kubernetes Terraform

Non appena abbiamo creato la configurazione Terraform, possiamo distribuire il nostro esempio demo.

Inizializza il progetto Terraform e applica la configurazione:

$ terraform init

$ terraform apply

Dopo aver applicato le configurazioni, vedrai il piano per le risorse e il permesso per svolgere le attività pianificate.

Approva il piano rispondendo a yes .

Dopo la distribuzione delle risorse, possiamo accedere all'applicazione.

Verifica la distribuzione

Convalidiamo la nostra implementazione nel cluster utilizzando kubectl .

$ kubectl get all

Vogliamo assicurarci che tutte le risorse create da Terraform siano disponibili.

Test della distribuzione

Dopo aver verificato l'implementazione delle risorse WordPress e MySQL, possiamo testare l'accesso all'app.

Per ottenere l'accesso alla nostra applicazione distribuita, dovremo eseguire il seguente comando Minikube:

$ minikube service wordpress-service --url

Questo comando ti mostrerà l'URL del servizio WordPress esposto da Minikube.

Congratulazioni! La nostra applicazione WordPress è stata implementata con successo.

Helm Terraform Provider

Questa parte dell'articolo utilizzerà il provider di timoni di Terraform per distribuire la stessa applicazione WordPress nel cluster Kubernetes, ma in modo diverso, utilizzando i grafici Helm.

Dobbiamo installare Helm sulla macchina per la distribuzione tramite il provider Helm in cui viene eseguito lo script Terraform.

Per ulteriori informazioni su Helm e sul processo di creazione dei grafici Helm, ti consiglio il nostro articolo Introduzione rapida e semplice ai grafici [Kubernetes] [Helm] in 10 minuti.

Creazione di mappe timone

In questo modulo creeremo grafici Helm per implementazioni MySQL e WordPress.

Helm può generare un modello di base che possiamo adattare alle nostre esigenze. Per ulteriori informazioni sulla creazione di grafici Helm, consulta l'articolo Introduzione rapida e semplice ai grafici Helm di Kubernetes in 10 minuti.

Ecco la nostra struttura finale del progetto:

Facciamo una directory per i grafici:

$ mkdir charts

$ cd charts

Grafico di MySQL Helm

Per prima cosa, creiamo il grafico del timone per MySQL.

$ helm create mysql-chart

Il comando precedente creerà un grafico con le configurazioni predefinite.

Visualizza i contenuti della mysql-chart :

Elimina il NOTES.txt , hpa.yaml , ingress.yaml, e serviceaccount.yaml file dalla directory dei modelli.

Sovrascrivi i contenuti di MySQL deployment.yaml file con quanto segue:

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'

Ecco i contenuti di service.yaml per 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 }}

Sostituisci il contenuto di values.yaml per la configurazione MySQL.

replicaCount: 1

image:
 repository: mysql:5.6
 pullPolicy: IfNotPresent

deployment:
 name: mysql-deployment

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

Grafico timone di WordPress

Crea un grafico Helm per WordPress.

$ helm create wordpress-chart

Elimina il NOTES.txt , hpa.yaml , ingress.yaml, e serviceaccount.yaml file dalla directory dei modelli.

I contenuti per deployment.yaml per WordPress sono i seguenti:

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'

I contenuti per service.yaml del grafico di WordPress sono i seguenti:

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

Il contenuto di values.yaml per WordPress sono i seguenti:

replicaCount: 1

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

deployment:
 name: wordpress-deployment

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

Configurazione della piattaforma

Non appena abbiamo i grafici Helm, dobbiamo creare un file di configurazione Terraform per distribuire la nostra applicazione su Kubernetes.

Torniamo alla directory di base e definiamo helm.tf File di configurazione Terraform con il seguente contenuto:

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

Applicazione della configurazione Terraform

Il passaggio finale consiste nel distribuire la nostra applicazione nel cluster Kubernetes utilizzando comandi già noti:

$ terraform init

$ terraform apply

Approva il piano per distribuire la configurazione.

Verifica la distribuzione dell'applicazione

Puoi verificare l'implementazione utilizzando il helm comando.

$ helm ls

In alternativa, puoi anche verificarlo utilizzando kubectl comando.

$ kubectl get all

Per accedere alla nostra applicazione distribuita, dovremo eseguire il seguente comando Minikube:

$ minikube service wordpress-service --url

Questo comando ti mostrerà l'URL del servizio WordPress esposto da Minikube.

Congratulazioni! La nostra applicazione WordPress è stata implementata con successo utilizzando grafici Helm e Terraform.

Pulizia

Per ripulire lo schieramento Terraform, usa il solito comando Terraform destroy in helm-provider o kubernetes-provider cartelle:

$ terraform destroy

Riepilogo

In questo articolo abbiamo mostrato come distribuire le applicazioni nel cluster Kubernetes usando Terraform. Abbiamo coperto due diversi approcci per farlo:i fornitori di Kubernetes e Helm Terraform. Per questa demo, abbiamo utilizzato Minikube come cluster Kubernetes locale.

Ci auguriamo che questo articolo ti sia utile! Se sì, per favore, aiutaci a diffonderlo nel mondo! Per favore, facci sapere nella sezione commenti qui sotto se hai domande.