Comment utiliser le fournisseur Terraform Kubernetes

Cet article poursuit les rubriques Linux, Kubernetes et Terraform et vous aidera à apprendre à déployer des applications sur le cluster Kubernetes à l'aide de Terraform. Nous avons couvert deux approches différentes pour ce faire :les fournisseurs Kubernetes et Helm Terraform. Pour cela, vous n'avez pas besoin d'un cluster Kubernetes car nous utiliserons Minikube, que vous pouvez installer sur votre ordinateur portable.

Vous apprendrez également à déployer des applications multiniveaux fonctionnelles sur Kubernetes à l'aide de Terraform en 10 minutes.

Qu'est-ce que Minikube

La meilleure façon d'apprendre Kubernetes et ses concepts est d'utiliser Minikube. Avec Minikube, vous n'avez pas besoin de vous soucier de la gestion des machines virtuelles ou du déploiement d'un cluster Kubernetes entièrement fonctionnel.

Cet outil open source prend en charge Windows, macOS et Linux, vous permettant de lancer un cluster Kubernetes à nœud unique sur votre ordinateur local. Cette machine virtuelle peut s'exécuter sur Virtualbox, KVM, Hyper-V ou Docker.

Installation Minikube

L'installation de Minikube est un processus simple. Cependant, vous n'avez besoin d'installer qu'une seule dépendance :un outil de ligne de commande appelé kubectl. .

kubectl vous permet de gérer des clusters Kubernetes. Vous pouvez utiliser kubectl pour déployer des applications, afficher les journaux et gérer les ressources du cluster.

Installation de kubectl

Vous trouverez ci-dessous un exemple du processus d'installation de kubectl pour Linux et 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

Pour installer kubectl sous Windows, vous pouvez utiliser le gestionnaire de packages Chocolatey :

choco install kubernetes-cli

Vous pouvez également installer kubectl sous Windows en cliquant ici.

Maintenant que vous avez installé kubectl, la prochaine étape consiste à installer Minikube.

Installer Minikube

Voici les commandes standard dont vous aurez besoin pour installer Minikube sur Ubuntu, CentOS et macOS :

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

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

Si vous comptez sur brew pour gérer votre macOS, il est préférable d'utiliser la commande suivante :

$ brew install minikube

Si vous installez minikube sous Windows, il est préférable d'utiliser Chocolatey :

choco install minikube

Si minikube n'a pas démarré lors de l'installation, vous pouvez le faire en utilisant la commande suivante :

$ minikube start

Fournisseurs Terraform pour le déploiement de Kubernetes

Actuellement, deux fournisseurs sont disponibles pour gérer les applications Kubernetes à l'aide de Terraform :

• Kubernetes.
• Barre.

Fournisseur Kubernetes Terraform

À titre d'exemple, dans cette section, nous aborderons le déploiement de WordPress à l'aide du fournisseur Kubernetes Terraform.

Définir le déploiement WordPress à l'aide du fournisseur Kubernetes

Voici la structure finale du projet :

Nous utiliserons wordpress Image Docker pour le niveau frontal et mysql Image Docker pour le niveau DB dans notre déploiement.

Définissons kubernetes fournisseur dans provider.tf fichier :

provider "kubernetes" {
 config_context = "minikube"
}

Ensuite, créons quelques variables locales pour étiqueter kubernetes_deployment et kubernetes_service :

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

Vous pouvez créer des étiquettes supplémentaires si vous le souhaitez, bien sûr. Le but des libellés dans Kubernetes est de vous permettre de sélectionner des pods, des services, un déploiement et toute autre entité Kubernetes.

Il existe de nombreuses façons de ne pas coder en dur les mots de passe dans votre configuration Terraform. L'utilisation des paramètres Terraform en fait partie. Nous continuerons avec un mot de passe codé en dur pour simplifier un peu la démo.

Déclarons un secret pour MYSQL_ROOT_PASSWORD variable d'environnement, que nous allons utiliser dans kubernetes_deployment .

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

Nous sommes maintenant prêts à définir kubernetes_deployment ressource pour le déploiement de 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'ensemble de la configuration de Terraform reflète la spécification de déploiement de Kubernetes. Nous devons exposer le déploiement WordPress aux réseaux de clusters externes à l'aide du service Kubernetes dès que nous l'avons déclaré.

Définissons kubernetes_service Ressource Terraform à cet effet :

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

Ici, nous disons à Kubernetes de rendre WordPress Pod disponible pour la communication à l'aide de Service.

Pour l'environnement de développement Minikube, nous allons exposer WordPress sur le port 32000 .

Faisons maintenant la même chose pour le déploiement de 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"
             }
           }
         }
       }
     }
   }
 }
}

Comme dans l'exemple précédent, nous rendons MySQL DB Deployment accessible pour le déploiement WordPress à l'aide du service Kubernetes configuré via kubernetes_service ressource :

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

Déployer la configuration WordPress Kubernetes Terraform

Dès que nous avons créé la configuration Terraform, nous pouvons déployer notre exemple de démonstration.

Initialisez le projet Terraform et appliquez la configuration :

$ terraform init

$ terraform apply

Après avoir appliqué les configurations, vous verrez le plan des ressources et l'autorisation d'effectuer les activités prévues.

Approuvez le plan en répondant yes .

Après le déploiement des ressources, nous pouvons accéder à l'application.

Vérifier le déploiement

Validons notre déploiement sur le cluster à l'aide de kubectl .

$ kubectl get all

Nous voulons nous assurer que toutes les ressources créées par Terraform sont disponibles.

Tester le déploiement

Après avoir vérifié le déploiement des ressources WordPress et MySQL, nous pouvons tester l'accès à l'application.

Pour accéder à notre application déployée, nous devrons exécuter la commande Minikube suivante :

$ minikube service wordpress-service --url

Cette commande vous montrera l'URL du service WordPress exposée par Minikube.

Toutes nos félicitations! Notre application WordPress a été déployée avec succès.

Fournisseur Helm Terraform

Cette partie de l'article utilisera le fournisseur Terraform helm pour déployer la même application WordPress sur le cluster Kubernetes, mais différemment :à l'aide de graphiques Helm.

Nous devons installer Helm sur la machine pour le déploiement via le fournisseur Helm où le script Terraform est exécuté.

Pour en savoir plus sur Helm et le processus de création de graphiques Helm, je vous recommande notre article Introduction rapide et simple aux graphiques [Kubernetes] [Helm] en 10 minutes.

Créer des graphiques Helm

Dans ce module, nous allons créer des chartes Helm pour les déploiements MySQL et WordPress.

Helm peut générer un modèle de base que nous pouvons ajuster à nos besoins. Pour plus d'informations sur la création de graphiques Helm, consultez l'article Présentation rapide et simple des graphiques Helm Kubernetes en 10 minutes.

Voici la structure finale de notre projet :

Soit un répertoire pour les graphiques :

$ mkdir charts

$ cd charts

Graphique Helm MySQL

Tout d'abord, nous créons le graphique helm pour MySQL.

$ helm create mysql-chart

La commande ci-dessus créera un graphique avec les configurations par défaut.

Afficher le contenu du mysql-chart :

Supprimez le NOTES.txt , hpa.yaml , ingress.yaml, et serviceaccount.yaml fichiers du répertoire des modèles.

Remplacer le contenu de MySQL deployment.yaml fichier avec ce qui suit :

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'

Voici le contenu de service.yaml pour 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 }}

Remplacez le contenu de values.yaml pour la configuration MySQL.

replicaCount: 1

image:
 repository: mysql:5.6
 pullPolicy: IfNotPresent

deployment:
 name: mysql-deployment

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

Graphique Helm WordPress

Créez un graphique Helm pour WordPress.

$ helm create wordpress-chart

Supprimez le NOTES.txt , hpa.yaml , ingress.yaml, et serviceaccount.yaml fichiers du répertoire des modèles.

Le contenu de deployment.yaml pour WordPress sont les suivants :

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'

Le contenu de service.yaml du graphique WordPress sont les suivants :

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

Le contenu de values.yaml pour WordPress sont les suivants :

replicaCount: 1

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

deployment:
 name: wordpress-deployment

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

Configuration Terraform

Dès que nous avons des chartes Helm, nous devons créer un fichier de configuration Terraform pour déployer notre application sur Kubernetes.

Revenons au répertoire de base et définissons helm.tf Fichier de configuration Terraform avec le contenu suivant :

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

Application de la configuration Terraform

La dernière étape consiste à déployer notre application sur le cluster Kubernetes à l'aide de commandes déjà connues :

$ terraform init

$ terraform apply

Approuvez le plan de déploiement de la configuration.

Vérifier le déploiement de l'application

Vous pouvez vérifier le déploiement à l'aide de helm commande.

$ helm ls

Vous pouvez également le vérifier en utilisant kubectl commande.

$ kubectl get all

Pour accéder à notre application déployée, nous devrons exécuter la commande Minikube suivante :

$ minikube service wordpress-service --url

Cette commande vous montrera l'URL du service WordPress exposée par Minikube.

Toutes nos félicitations! Notre application WordPress a été déployée avec succès à l'aide des chartes Helm et de Terraform.

Nettoyage

Pour nettoyer le déploiement de Terraform, utilisez la commande Terraform destroy habituelle dans helm-provider ou kubernetes-provider dossiers :

$ terraform destroy

Résumé

Dans cet article, nous avons montré comment déployer des applications sur le cluster Kubernetes à l'aide de Terraform. Nous avons couvert deux approches différentes pour ce faire :les fournisseurs Kubernetes et Helm Terraform. Pour cette démonstration, nous avons utilisé Minikube comme cluster Kubernetes local.

Nous espérons que vous trouverez cet article utile ! Si oui, s'il vous plaît, aidez-nous à le diffuser dans le monde ! S'il vous plaît, laissez-nous savoir dans la section des commentaires ci-dessous si vous avez des questions.