Conectar Pods con Servicios de Kubernetes

Introducción

En Kubernetes, los Pods son efímeros y pueden ser terminados y recreados en cualquier momento. Esto presenta un desafío cuando se trata de redes, ya que es difícil conectarse directamente a un Pod. Para resolver este problema, Kubernetes proporciona una abstracción de nivel superior llamada Servicio (Service). Un Servicio proporciona una dirección IP estáble y un nombre DNS para un conjunto de Pods, lo que permite a otros componentes conectarse a ellos fácilmente. En este laboratorio, aprenderás cómo conectar Pods con Servicios en Kubernetes.

Iniciar el clúster de Minikube

Antes de crear recursos, necesitas un clúster de Kubernetes en ejecución. Minikube es un entorno ligero de Kubernetes que se ejecuta en tu máquina local.

1. Navegar a tu directorio de trabajo:

   Abre la terminal y navega hasta la carpeta de proyecto predeterminada:

   cd /home/labex/project

2. Iniciar Minikube:

   Inicia Minikube para inicializar un clúster de Kubernetes:

   minikube start

   • Este comando configura un clúster de Kubernetes de un solo nodo en tu máquina local.
   • Minikube puede tardar unos minutos en iniciarse dependiendo del rendimiento de tu sistema.

3. Verificar que Minikube esté en ejecución:

   Comprueba el estado del clúster de Minikube:

   minikube status

   • Busca componentes como kubelet y apiserver listados como Running (En ejecución).
   • Si el clúster no está en ejecución, vuelve a ejecutar minikube start.

Si encuentras problemas al iniciar Minikube, utiliza minikube delete para restablecer el entorno si es necesario.

Crear un Pod

El primer paso es crear un Pod simple. Crea un archivo llamado /home/labex/project/myapp-pod.yaml con el siguiente contenido:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-1
  labels:
    app: nginx
spec:
  containers:
    - name: my-container
      image: nginx

Guarda el archivo y crea el Pod ejecutando el siguiente comando:

kubectl apply -f /home/labex/project/myapp-pod.yaml

Esto creará un Pod llamado my-pod-1 con un solo contenedor que ejecuta la imagen de Nginx.

Crear un Servicio (Service)

El segundo paso es crear un Servicio (Service) que apunte al Pod que creaste en el paso anterior. Crea un archivo llamado /home/labex/project/service.yaml con el siguiente contenido:

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: nginx
  ports:
    - name: http
      port: 80
      targetPort: 80

Guarda el archivo y crea el Servicio (Service) ejecutando el siguiente comando:

kubectl apply -f /home/labex/project/service.yaml

Esto creará un Servicio (Service) llamado my-service que apunta a los Pods con la etiqueta app=nginx y expone el puerto 80.

Probar el Servicio

El tercer paso es probar el Servicio (Service) accediendo a él desde otro Pod. Crea un archivo llamado /home/labex/project/test-pod-1.yaml con el siguiente contenido:

apiVersion: v1
kind: Pod
metadata:
  name: test-pod-1
spec:
  containers:
    - name: my-container
      image: nginx
      command:
        - sleep
        - "3600"

Guarda el archivo y crea el Pod de prueba ejecutando el siguiente comando:

kubectl apply -f /home/labex/project/test-pod-1.yaml

Esto creará un Pod llamado test-pod-1 con un solo contenedor que ejecuta la imagen de Nginx.

A continuación, ejecutarás un comando dentro del contenedor y usarás curl para acceder al Servicio (Service). Ejecuta el siguiente comando para ejecutar un shell dentro del contenedor:

kubectl exec -it test-pod-1 -- sh

Esto abrirá un shell dentro del contenedor. Desde el shell, ejecuta el siguiente comando para acceder al Servicio (Service):

curl http://my-service

Esto devolverá la página predeterminada de Nginx, lo que indica que el Servicio (Service) está funcionando correctamente.

Actualizar el Servicio

El cuarto paso es actualizar el Servicio (Service) para que apunte a un conjunto diferente de Pods. Actualiza el campo selector en el archivo /home/labex/project/service.yaml con lo siguiente:

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: busybox
  ports:
    - name: http
      port: 80
      targetPort: 8

Guarda el archivo y actualiza el Servicio (Service) ejecutando el siguiente comando:

kubectl apply -f service.yaml

Esto actualizará el Servicio (Service) para que apunte a los Pods con la etiqueta app=busybox.

Probar el servicio actualizado

El quinto paso es probar el Servicio actualizado accediendo a él desde otro Pod. Cree un nuevo Pod de prueba con el siguiente comando:

kubectl run my-pod-2 --image=busybox --restart=Never -- sleep 3600

Esto creará un nuevo Pod llamado my-pod-2 con un único contenedor ejecutando la imagen Busybox.

Ejecute exec dentro del contenedor y use curl para acceder al Servicio como lo hizo en el Paso 3. Ejecute el siguiente comando para ejecutar exec dentro del contenedor:

kubectl exec -it my-pod-2 -- sh

Esta vez, debería obtener un error que indica que la conexión fue rechazada.

Esto se debe a que el Servicio ahora está apuntando a un conjunto diferente de Pods que los que el Pod de prueba está ejecutando. Para solucionar esto, puede actualizar la etiqueta del Pod para que coincida con el nuevo selector en el Servicio.

Ejecute el siguiente comando para actualizar la etiqueta del Pod de prueba:

kubectl label pod my-pod-2 app=busybox

Esto agregará la etiqueta app=busybox al Pod de prueba.

Ahora, si ejecuta el comando curl nuevamente, debería obtener la página predeterminada de Nginx, lo que indica que el Servicio está funcionando correctamente.

Resumen

En este laboratorio, aprendiste cómo conectar Pods con Servicios (Services) en Kubernetes. Creaste un simple Pod que ejecuta la imagen de Nginx, creaste un Servicio (Service) para apuntar al Pod y probaste el Servicio (Service) accediéndole desde otro Pod. También aprendiste cómo actualizar el Servicio (Service) para que apunte a un conjunto diferente de Pods y cómo actualizar la etiqueta de un Pod para que coincida con el nuevo selector en el Servicio (Service). Los Servicios (Services) son un componente esencial de la red en Kubernetes y te permiten conectarte a los Pods de manera confiable y escalable.