Kubernetes es una plataforma de orquestación de contenedores que automatiza el despliegue, la gestión y la escalabilidad de aplicaciones en contenedores. En este módulo, aprenderemos cómo Kubernetes puede ser utilizado para gestionar microservicios de manera eficiente.

Un clúster de Kubernetes es un conjunto de nodos que ejecutan aplicaciones en contenedores. Los componentes principales de un clúster son:

• Master Node: Responsable de la gestión del clúster.
• Worker Nodes: Ejecutan las aplicaciones en contenedores.

Un pod es la unidad más pequeña de ejecución en Kubernetes y puede contener uno o más contenedores que comparten el mismo contexto de red y almacenamiento.

Los servicios en Kubernetes proporcionan una forma de exponer una aplicación que se ejecuta en un conjunto de pods como un servicio de red.

Los deployments definen el estado deseado de una aplicación y Kubernetes se encarga de mantener ese estado, gestionando la creación y el escalado de pods.

• ConfigMaps: Almacenan datos de configuración en formato clave-valor.
• Secrets: Almacenan información sensible, como contraseñas y tokens.

Para comenzar, necesitamos un clúster de Kubernetes. Puedes usar servicios gestionados como Google Kubernetes Engine (GKE), Amazon Elastic Kubernetes Service (EKS) o Azure Kubernetes Service (AKS), o configurar un clúster local con Minikube.

Vamos a crear un deployment para un microservicio simple. Supongamos que tenemos una imagen de Docker llamada my-microservice.

• apiVersion: La versión de la API de Kubernetes que estamos utilizando.
• kind: El tipo de objeto que estamos creando, en este caso, un Deployment.
• metadata: Información sobre el objeto, como su nombre.
• spec: La especificación del deployment.
  • replicas: El número de réplicas del pod que queremos ejecutar.
  • selector: Define cómo seleccionar los pods que pertenecen a este deployment.
  • template: Define el pod que se va a crear.
    • metadata: Etiquetas para el pod.
    • spec: La especificación del contenedor dentro del pod.
      • containers: Lista de contenedores que se ejecutarán en el pod.
        • name: Nombre del contenedor.
        • image: La imagen de Docker que se utilizará.
        • ports: Los puertos que se expondrán.

Para exponer nuestro microservicio, necesitamos crear un servicio.

• apiVersion: La versión de la API de Kubernetes que estamos utilizando.
• kind: El tipo de objeto que estamos creando, en este caso, un Service.
• metadata: Información sobre el objeto, como su nombre.
• spec: La especificación del servicio.
  • selector: Define cómo seleccionar los pods que pertenecen a este servicio.
  • ports: Los puertos que se expondrán.
    • protocol: El protocolo que se utilizará.
    • port: El puerto en el que el servicio estará disponible.
    • targetPort: El puerto en el que el contenedor escucha.
  • type: El tipo de servicio, en este caso, LoadBalancer para exponer el servicio externamente.

1. Configura un clúster de Kubernetes utilizando Minikube o un servicio gestionado.
2. Crea un archivo YAML para un deployment de un microservicio.
3. Crea un archivo YAML para un servicio que exponga el microservicio.
4. Aplica los archivos YAML utilizando kubectl apply -f <archivo.yaml>.
5. Verifica el despliegue utilizando kubectl get pods y kubectl get services.

1. Configura Minikube:

   minikube start
   

2. Crea deployment.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-microservice-deployment
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: my-microservice
     template:
       metadata:
         labels:
           app: my-microservice
       spec:
         containers:
         - name: my-microservice
           image: my-microservice:latest
           ports:
           - containerPort: 80
   

3. Crea service.yaml:

   apiVersion: v1
   kind: Service
   metadata:
     name: my-microservice-service
   spec:
     selector:
       app: my-microservice
     ports:
       - protocol: TCP
         port: 80
         targetPort: 80
     type: LoadBalancer
   

4. Aplica los archivos YAML:

   kubectl apply -f deployment.yaml
   kubectl apply -f service.yaml
   

5. Verifica el despliegue:

   kubectl get pods
   kubectl get services
   

En esta sección, hemos aprendido los conceptos básicos de Kubernetes y cómo utilizarlo para orquestar microservicios. Hemos visto cómo crear deployments y servicios para gestionar y exponer nuestros microservicios. Con esta base, estamos preparados para explorar temas más avanzados de despliegue y gestión en Kubernetes.