# Aprovisionando un Clúster Kubernetes con Kind y Terraform
En este tutorial paso a paso, aprenderás a crear y gestionar un clúster Kubernetes local utilizando Kind y Terraform, dos herramientas poderosas que revolucionarán tu flujo de trabajo de desarrollo.
## Introducción a las Herramientas
### Kubernetes: El Orquestador de Contenedores
Kubernetes es una plataforma de orquestación que automatiza el despliegue, escalado y gestión de aplicaciones en contenedores. Su popularidad radica en su capacidad para:
* Automatizar despliegues
* Gestionar la escalabilidad
* Manejar aplicaciones en contenedores
* Proporcionar alta disponibilidad
Documentación [Kubernetes](https://kubernetes.io/es/docs/home/)
### Kind: Kubernetes en tu Máquina Local
Kind (Kubernetes IN Docker) es tu mejor aliado para desarrollo local, ofreciendo:
* Clústeres multinodo en Docker
* Configuración simple y rápida
* Eficiencia en el uso de recursos
* Ideal para CI/CD y pruebas
Documentación [Kind](https://kind.sigs.k8s.io/docs/user/quick-start)
### Terraform: Infraestructura como Código
Terraform complementa perfectamente a Kind, permitiendo:
* Automatización de la creación de clústeres
* Gestión consistente de la infraestructura
* Versionamiento de configuraciones
* Reproducibilidad garantizada
Documentación [Terraform](https://developer.hashicorp.com/terraform/docs)
---
## Configuración del Entorno
### Requisitos Previos
1. Docker instalado en tu máquina
2. Terraform instalado
3. kubectl configurado
### **Configuración Inicial**
#### **1\. Instalar Kind**
1. Sigue la [documentación oficial de Kind](https://kind.sigs.k8s.io/) para instalarlo.
2. Verifica la instalación con:
```bash
kind version
```
#### **2\. Crear un archivo de configuración para Kind**
Un ejemplo básico para un clúster con un control plane y un worker:
Guarda este archivo como `kind-config.yaml`.
```yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
```
3. **Creando el clúster kind 🔗︎**
```bash
kind create cluster --config kind-config.yaml
```
#### 4\. Administrar el clúster con K9s
Para una administración más eficiente del clúster, utiliza **K9s**, una interfaz de terminal que facilita la gestión de recursos de Kubernetes.
* Instala K9s siguiendo las instrucciones oficiales de su [repos](https://k9scli.io/)[itorio.](https://k9scli.io/)
* Luego, simplemente ejecu[ta:](https://k9scli.io/)
```bash
k9s
```
Esto te permitirá explorar y gestionar recursos del clúster de forma visual e interactiva. 🚀
![](https://cdn.hashnode.com/res/hashnode/image/upload/v1732317588722/6c7a89de-4111-4f3e-8af2-eedb56ad9d37.png align="center")
### **Siguientes Pasos**
[Ahora que t](https://k9scli.io/)ienes un clúster Kubernetes local, puedes comenzar a desplega[r aplicacio](https://k9scli.io/)nes. Te recomiendo seguir la [Guía de Conc](https://kubernetes.io/docs/tutorials/kubernetes-basics/)[eptos Básic](https://k9scli.io/)[os de Kubernetes](https://kubernetes.io/docs/tutorials/kubernetes-basics/) para aprender más.
---
## **Terraform para Kind**
### **¿Por qué usar Terraform y Kind juntos?**
Usar **Terraform** y **Kind** juntos ofrece una solución eficiente para crear y gestionar clústeres Kubernetes locales de manera automatizada y reproducible.
* **Automatización**: Terraform permite definir y provisionar clústeres Kubernetes con solo unos comandos, eliminando la configuración manual.
* **Consistencia**: Puedes versionar y compartir la configuración del clúster, asegurando que se pueda recrear en cualquier momento o máquina.
* **Escalabilidad**: Kind soporta clústeres multinodo, y con Terraform puedes gestionar fácilmente su infraestructura de manera flexible.
* **Desarrollo y CI/CD**: Ideal para entornos locales de desarrollo y pruebas en integración continua.
💡
Juntas, estas herramientas permiten gestionar clústeres Kubernetes de forma eficiente, consistente y escalable.
**Módulo de Terraform para kind ** [**https://registry.terraform.io/providers/tehcyx/kind/latest**](https://registry.terraform.io/providers/tehcyx/kind/latest)
## Aprovisionando tu Primer Clúster
### 1\. Estructura del Proyecto
```bash
mkdir kind-terraform-demo
cd kind-terraform-demo
touch main.tf
```
### 2\. Configuración Básica de Terraform
Sobre el [módulo](https://registry.terraform.io/providers/tehcyx/kind/latest) de terraform tehcyx/kind
```bash
terraform {
required_providers {
kind = {
source = "tehcyx/kind"
version = "0.7.0"
}
}
}
provider "kind" {}
resource "kind_cluster" "default" {
name = "kindcluster"
node_image = "kindest/node:v1.31.0"
wait_for_ready = true
kind_config {
kind = "Cluster"
api_version = "kind.x-k8s.io/v1alpha4"
node {
role = "control-plane"
}
node {
role = "worker"
}
}
}
```
### 3\. Inicialización y Despliegue
```bash
# Inicializar Terraform
terraform init
# Planificar cambios
terraform plan
# Aplicar configuración
terraform apply
```
---
## Vamos a la practica
### Aprovisionando con terraform Clúster Kind con Nginx Ingress Controller
El propósito es utilizar **Terraform** para automatizar la creación de un clúster Kubernetes local (usando herramientas como Kind o Minikube) y desplegar un **Nginx Ingress Controller**. Esto permitirá manejar el enrutamiento de solicitudes HTTP/HTTPS hacia servicios internos del clúster.
*Revisa el repositorio* [*roxs-projects-blog*](https://github.com/roxsross/roxs-projects-blog/tree/devops-tf-kind-cluster/02-kind-cluster-with-terraform)
```bash
git clone -b devops-tf-kind-cluster https://github.com/roxsross/roxs-projects-blog.git
cd devops-tf-kind-cluster/02-kind-cluster-with-terraform
```
**Estructura del Proyecto**
```bash
.
├── terraform/
│ ├── main.tf
│ ├── variables.tf
│ ├── outputs.tf
│ └── ingress.tf
└── kubernetes/
└── test-app.yaml
```
**Despliegue del Clúster**
```bash
cd terraform
terraform init
terraform plan
terraform apply -auto-approve
```
**Despliegue de la Aplicación de Prueba**
```bash
cd ../kubernetes
kubectl apply -f test-app.yaml
# Verificar despliegue
kubectl get pods
kubectl get ingress
kubectl get services
# Probar el acceso
curl localhost/hello
```
**Verificación de Componentes**
```bash
# Estado del Ingress Controller
kubectl get pods -n ingress-nginx
# Logs del Controller
kubectl logs -n ingress-nginx -l app.kubernetes.io/component=controller
# Estado del Ingress
kubectl describe ingress hello-ingress
```
### Características Clave del Clúster
**Control Plane**
* Nodo principal para coordinación
* Compatibilidad con Kubernetes v1.31.0
* Puertos expuestos: 80 (HTTP) y 443 (HTTPS)
**Workers**
* Dos nodos worker para distribución de carga
* Mismo sistema de imágenes que el control plane
* Ideal para pruebas de balanceo
**Networking**
* Mapeo de puertos para acceso directo
* Soporte para Ingress Controller
* Conectividad entre nodos
### Limpieza
```bash
# Eliminar aplicaciones
kubectl delete -f kubernetes/test-app.yaml
# Eliminar clúster (si es necesario)
terraform destroy
```
## Vamos al Video.
%[https://www.youtube.com/watch?v=2DQ18U6HSOI]
## Recursos Adicionales
* [Repositorio de Ejemplo](https://github.com/roxsross/roxs-projects-blog/tree/devops-tf-kind-cluster)
* [Documentación de Kind](https://kind.sigs.k8s.io/)
* [Documentación de Terraform](https://www.terraform.io/docs/)
## Conclusión
El dominio de Kind y Terraform para la gestión de clústeres Kubernetes locales no solo mejora tu flujo de trabajo actual, sino que también establece una base sólida para el crecimiento futuro. Las habilidades adquiridas son transferibles a entornos de producción y te preparan para los desafíos del desarrollo moderno de aplicaciones.
La combinación de estas herramientas te permite:
* Desarrollar con confianza
* Experimentar sin riesgos
* Innovar continuamente
* Mantener alta calidad en tus entregas
Recuerda que el aprendizaje es continuo en el mundo del DevOps y la infraestructura como código. Mantente curioso, sigue explorando y no dudes en compartir tu conocimiento con la comunidad.
¡Feliz coding y que la automatización te acompañe! 🚀