Cómo usar el proveedor Terraform Kubernetes

Este artículo continúa con los temas de Linux, Kubernetes y Terraform y lo ayudará a aprender cómo implementar aplicaciones en el clúster de Kubernetes mediante Terraform. Hemos cubierto dos enfoques diferentes para hacerlo:proveedores de Kubernetes y Helm Terraform. Para este propósito, no necesita un clúster de Kubernetes, ya que usaremos Minikube, que puede instalar en su computadora portátil.

También aprenderá cómo implementar aplicaciones funcionales de n niveles en Kubernetes usando Terraform en 10 minutos.

Que es Minikube

La mejor manera de aprender Kubernetes y sus conceptos es usando Minikube. Con Minikube, no necesita pasar por la molestia de administrar máquinas virtuales o implementar un clúster de Kubernetes completamente funcional.

Esta herramienta de código abierto es compatible con Windows, macOS y Linux, lo que le permite iniciar un clúster de Kubernetes de un solo nodo en su máquina local. Esta máquina virtual puede ejecutarse sobre Virtualbox, KVM, Hyper-V o Docker.

Instalación de Minikube

Instalar Minikube es un proceso sencillo. Sin embargo, solo hay una dependencia que debe instalar por adelantado:una herramienta de línea de comandos llamada kubectl .

kubectl le permite administrar clústeres de Kubernetes. Puedes usar kubectl para implementar aplicaciones, ver registros y administrar recursos de clúster.

Instalando kubectl

A continuación se muestra un ejemplo del proceso de instalación de kubectl para Linux y 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

Para instalar kubectl en Windows, puede usar el administrador de paquetes Chocolatey :

choco install kubernetes-cli

Alternativamente, también puede instalar kubectl en Windows haciendo clic aquí.

Ahora que ha instalado kubectl, el siguiente paso es instalar Minikube.

Instalar Minikube

Estos son los comandos estándar que necesitará para instalar Minikube en Ubuntu, CentOS y macOS:

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

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

Si confía en brew para administrar su macOS, es mejor usar el siguiente comando:

$ brew install minikube

Si está instalando minikube en Windows, es mejor usar Chocolatey:

choco install minikube

Si minikube no se inició durante la instalación, puede hacerlo usando el siguiente comando:

$ minikube start

Proveedores de Terraform para la implementación de Kubernetes

Actualmente, hay dos proveedores disponibles para administrar aplicaciones de Kubernetes usando Terraform:

• Kubernetes.
• Yelmo.

Proveedor de Kubernetes Terraform

Como ejemplo, en esta sección, cubriremos la implementación de WordPress usando el proveedor Kubernetes Terraform.

Definir la implementación de WordPress usando el proveedor de Kubernetes

Aquí está la estructura final del proyecto:

Usaremos wordpress Imagen de Docker para el nivel de interfaz y mysql Imagen de Docker para DB-tier en nuestra implementación.

Definamos kubernetes proveedor en provider.tf archivo:

provider "kubernetes" {
 config_context = "minikube"
}

A continuación, creemos un par de variables locales para etiquetar kubernetes_deployment y kubernetes_service :

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

Por supuesto, puede crear etiquetas adicionales si lo desea. El propósito de las etiquetas en Kubernetes es brindarle la posibilidad de seleccionar Pods, Servicios, Implementación y cualquier otra entidad de Kubernetes.

Hay muchas maneras diferentes de no codificar contraseñas en su configuración de Terraform. El uso de parámetros de Terraform es uno de ellos. Continuaremos con una contraseña codificada para mantener la demostración un poco más simple.

Declaremos un secreto para MYSQL_ROOT_PASSWORD variable de entorno, que vamos a utilizar en kubernetes_deployment .

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

Ahora, estamos listos para definir kubernetes_deployment recurso para la implementación 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"
             }
           }
         }
       }
     }
   }
 }
}

Toda la configuración de Terraform refleja la especificación de implementación de Kubernetes. Necesitamos exponer la implementación de WordPress a las redes de clústeres externas mediante el servicio Kubernetes tan pronto como lo declaremos.

Definamos kubernetes_service Recurso Terraform para ese propósito:

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

Aquí, le decimos a Kubernetes que haga que WordPress Pod esté disponible para la comunicación mediante el Servicio.

Para el entorno de desarrollo de Minikube, expondremos WordPress en el puerto 32000 .

Ahora, hagamos lo mismo para la implementación 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"
             }
           }
         }
       }
     }
   }
 }
}

Como en el ejemplo anterior, estamos haciendo que la implementación de MySQL DB sea accesible para la implementación de WordPress usando el servicio Kubernetes configurado a través de kubernetes_service recurso:

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

Implementar la configuración de WordPress Kubernetes Terraform

Tan pronto como creamos la configuración de Terraform, podemos implementar nuestro ejemplo de demostración.

Inicialice el proyecto Terraform y aplique la configuración:

$ terraform init

$ terraform apply

Después de aplicar las configuraciones, verá el plan de los recursos y el permiso para realizar las actividades planificadas.

Aprueba el plan respondiendo yes .

Después de la implementación de recursos, podemos obtener acceso a la aplicación.

Verificar la implementación

Validemos nuestra implementación en el clúster mediante kubectl .

$ kubectl get all

Queremos asegurarnos de que todos los recursos creados por Terraform estén disponibles.

Prueba de la implementación

Después de verificar la implementación de los recursos de WordPress y MySQL, podemos probar el acceso a la aplicación.

Para obtener acceso a nuestra aplicación implementada, necesitaremos ejecutar el siguiente comando de Minikube:

$ minikube service wordpress-service --url

Este comando le mostrará la URL del servicio de WordPress expuesta por Minikube.

¡Felicidades! Nuestra aplicación de WordPress se ha implementado con éxito.

Proveedor de Helm Terraform

Esta parte del artículo utilizará el proveedor de helm de Terraform para implementar la misma aplicación de WordPress en el clúster de Kubernetes, pero de manera diferente:mediante gráficos de Helm.

Debemos instalar Helm en la máquina para la implementación a través del proveedor de Helm donde se ejecuta el script de Terraform.

Para obtener más información sobre Helm y el proceso de creación de gráficos de Helm, le recomiendo nuestro artículo Introducción rápida y sencilla a los gráficos de [Kubernetes] [Helm] en 10 minutos.

Creación de gráficos Helm

En este módulo, crearemos gráficos de Helm para implementaciones de MySQL y WordPress.

Helm puede generar una plantilla básica que podemos ajustar a nuestras necesidades. Para obtener más información sobre cómo crear gráficos de Helm, consulte el artículo Introducción rápida y sencilla a los gráficos de Helm de Kubernetes en 10 minutos.

Esta es la estructura final de nuestro proyecto:

Vamos a un directorio para los gráficos:

$ mkdir charts

$ cd charts

Gráfico de MySQL Helm

Primero, creamos el gráfico de timón para MySQL.

$ helm create mysql-chart

El comando anterior creará un gráfico con configuraciones predeterminadas.

Ver el contenido del mysql-chart :

Eliminar el NOTES.txt , hpa.yaml , ingress.yaml, y serviceaccount.yaml archivos del directorio de plantillas.

Anular el contenido de MySQL deployment.yaml archivo con lo siguiente:

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'

Estos son los contenidos de service.yaml para 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 }}

Reemplazar el contenido de values.yaml para la configuración de MySQL.

replicaCount: 1

image:
 repository: mysql:5.6
 pullPolicy: IfNotPresent

deployment:
 name: mysql-deployment

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

Gráfico de Helm de WordPress

Cree un gráfico de Helm para WordPress.

$ helm create wordpress-chart

Eliminar el NOTES.txt , hpa.yaml , ingress.yaml, y serviceaccount.yaml archivos del directorio de plantillas.

El contenido de deployment.yaml para WordPress son los siguientes:

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'

El contenido de service.yaml del gráfico de WordPress son los siguientes:

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

El contenido de values.yaml para WordPress son los siguientes:

replicaCount: 1

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

deployment:
 name: wordpress-deployment

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

Configuración de Terraform

Tan pronto como tengamos los gráficos de Helm, debemos crear un archivo de configuración de Terraform para implementar nuestra aplicación en Kubernetes.

Volvamos al directorio base y definamos helm.tf Archivo de configuración de Terraform con el siguiente contenido:

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

Aplicando la configuración de Terraform

El paso final es implementar nuestra aplicación en el clúster de Kubernetes usando los comandos ya conocidos:

$ terraform init

$ terraform apply

Aprobar el plan para implementar la configuración.

Verificar implementación de aplicaciones

Puede verificar la implementación usando el helm comando.

$ helm ls

Alternativamente, también puede verificarlo usando kubectl comando.

$ kubectl get all

Para acceder a nuestra aplicación implementada, necesitaremos ejecutar el siguiente comando de Minikube:

$ minikube service wordpress-service --url

Este comando le mostrará la URL del servicio de WordPress expuesta por Minikube.

¡Felicidades! Nuestra aplicación de WordPress se implementó con éxito utilizando gráficos de Helm y Terraform.

Limpieza

Para limpiar la implementación de Terraform, use el comando de destrucción habitual de Terraform en helm-provider o kubernetes-provider carpetas:

$ terraform destroy

Resumen

En este artículo, mostramos cómo implementar aplicaciones en el clúster de Kubernetes mediante Terraform. Hemos cubierto dos enfoques diferentes para hacerlo:proveedores de Kubernetes y Helm Terraform. Para esta demostración, usamos Minikube como un clúster local de Kubernetes.

¡Esperamos que encuentre útil este artículo! Si es así, ¡ayúdanos a difundirlo por todo el mundo! Háganos saber en la sección de comentarios a continuación si tiene alguna pregunta.