Comando Expose de Kubernetes

Introducción

El comando expose en Kubernetes es una herramienta simple pero poderosa para hacer que un pod o una implementación (deployment) sea accesible a través de un servicio de red. Este laboratorio (lab) te guiará a través del proceso de iniciar un clúster de Kubernetes, crear una implementación, exponerla como un servicio y acceder al servicio para verificar su funcionalidad. Al final de este laboratorio, tendrás una comprensión clara de cómo exponer implementaciones y trabajar con servicios en Kubernetes.

Iniciar Minikube

Para ejecutar Kubernetes de forma local, utilizamos Minikube, que configura un clúster de Kubernetes de un solo nodo. Antes de continuar con cualquier operación de Kubernetes, asegúrate de que Minikube esté activo y funcionando.

Abre una terminal e inicia Minikube con el siguiente comando:
```
minikube start
```

Esto inicializa el clúster. Si es necesario, puedes especificar límites de recursos utilizando opciones (flags) como --cpus y --memory para garantizar recursos adecuados para el clúster.

Verifica que Minikube esté en ejecución:
```
minikube status
```
Deberías ver que el clúster y sus componentes se están ejecutando correctamente.

Iniciar Minikube garantiza que Kubernetes esté listo para gestionar implementaciones (deployments) y servicios en los pasos posteriores.

Crear una implementación (deployment)

En Kubernetes, una implementación (deployment) es un objeto de recurso que asegura que tu aplicación tenga el número deseado de réplicas en ejecución en todo momento. Las implementaciones gestionan los pods y ayudan a mantener su estado en el clúster. En este paso, crearás una implementación que ejecute el servidor web Nginx.

Utiliza el siguiente comando para crear una implementación llamada hello-world utilizando la imagen nginx:
```
kubectl create deployment hello-world --image=nginx
```
Este comando crea una implementación con un solo pod ejecutando el servidor web Nginx. La opción (flag) --image especifica la imagen de contenedor a utilizar. Dado que las réplicas no se establecen explícitamente, Kubernetes creará un pod por defecto.
Verifica si la implementación se creó correctamente ejecutando:
```
kubectl get deployments
```
Este comando lista todas las implementaciones en el espacio de nombres (namespace) actual, mostrando su nombre, el número deseado de réplicas y su estado.

Al crear esta implementación, aseguras que Kubernetes maneje automáticamente la creación y reinicio de pods para mantener el estado deseado de la aplicación.

Explorar el comando kubectl expose

El comando kubectl expose se utiliza para crear un nuevo servicio de Kubernetes para exponer un recurso existente, como un pod, una implementación (deployment) o un controlador de replicación (replication controller). Simplifica las configuraciones de red al crear automáticamente servicios basados en el recurso proporcionado.

Ejecuta el siguiente comando para ver las opciones disponibles para kubectl expose:

kubectl expose -h

Verás la siguiente salida:

Expose a resource as a new Kubernetes service.

Looks up a deployment, service, replica set, replication controller or pod by name and uses the selector for that
resource as the selector for a new service on the specified port. A deployment or replica set will be exposed as a
service only if its selector is convertible to a selector that service supports, i.e. when the selector contains only
the matchLabels component. Note that if no port is specified via --port and the exposed resource has multiple ports, all
will be re-used by the new service. Also if no labels are specified, the new service will re-use the labels from the
resource it exposes.

Possible resources include (case insensitive):
  pod (po), service (svc), replicationcontroller (rc), deployment (deploy), replicaset (rs)

Examples:
  ## Create a service for a replicated nginx, which serves on port 80 and connects to the containers on port 8000
  kubectl expose rc nginx --port=80 --target-port=8000

  ## Create a service for a replication controller identified by type and name specified in "nginx-controller.yaml",
  which serves on port 80 and connects to the containers on port 8000
  kubectl expose -f nginx-controller.yaml --port=80 --target-port=8000

  ## Create a service for a pod valid-pod, which serves on port 444 with the name "frontend"
  kubectl expose pod valid-pod --port=444 --name=frontend

  ## Create a second service based on the above service, exposing the container port 8443 as port 443 with the name
  "nginx-https"
  kubectl expose service nginx --port=443 --target-port=8443 --name=nginx-https

  ## Create a service for a replicated streaming application on port 4100 balancing UDP traffic and named 'video-stream'.
  kubectl expose rc streamer --port=4100 --protocol=UDP --name=video-stream

  ## Create a service for a replicated nginx using replica set, which serves on port 80 and connects to the containers on
  port 8000
  kubectl expose rs nginx --port=80 --target-port=8000

  ## Create a service for an nginx deployment, which serves on port 80 and connects to the containers on port 8000
  kubectl expose deployment nginx --port=80 --target-port=8000

Exponer la implementación (deployment)

Para hacer que la implementación (deployment) sea accesible desde fuera del clúster de Kubernetes, debes exponerla como un servicio. Un servicio en Kubernetes actúa como un punto final de red estable, incluso si los pods subyacentes cambian.

Ejecuta el siguiente comando para crear un servicio NodePort llamado hello-service:
```
kubectl expose deployment hello-world --name=hello-service --port=80 --target-port=80 --type=NodePort
```
- La opción (flag) --port especifica el puerto que el servicio expondrá a los clientes externos.
- La opción (flag) --target-port define el puerto en el contenedor al que el servicio enrutará el tráfico.
- La opción (flag) --type=NodePort hace que el servicio sea accesible en un puerto específico en cada nodo del clúster.
Verifica que el servicio se haya creado correctamente:
```
kubectl get services hello-service
```
Este comando muestra los detalles del servicio, incluyendo su tipo y el NodePort asignado.

Servicios como NodePort permiten que los clientes externos interactúen con los pods en el clúster de Kubernetes reenviando solicitudes a los puertos de contenedor correctos.

Recuperar detalles del servicio

Para acceder al servicio expuesto, necesitas el NodePort asignado al servicio y la dirección IP interna de un nodo en el clúster. Estos detalles permiten que los clientes externos se conecten a tu aplicación.

Obtén el NodePort asignado al hello-service ejecutando:
```
kubectl get service hello-service -o jsonpath='{.spec.ports[0].nodePort}'
```
Este comando extrae el valor del NodePort de la definición del servicio.
Obtén la dirección IP interna de cualquier nodo en el clúster utilizando el siguiente comando:
```
kubectl get nodes -o wide
```
Observa el campo INTERNAL-IP en la salida. Esta dirección IP representa la dirección de red privada del nodo.

Con el NodePort y la dirección IP interna (InternalIP), ahora tienes los detalles necesarios para acceder al servicio desde fuera.

Acceder al servicio

Con el NodePort y la dirección IP del nodo, puedes probar el servicio utilizando una herramienta como curl o un navegador web.

Reemplaza <NODE_IP> y <NODE_PORT> con los valores obtenidos en el paso anterior, luego ejecuta:
```
curl <NODE_IP>:<NODE_PORT>
```
Si todo está configurado correctamente, deberías ver la página de bienvenida predeterminada de Nginx en la terminal. Esta salida confirma que el servicio está en ejecución y es accesible desde fuera.

<!doctype html>
<html>
  <head>
    <title>Welcome to nginx!</title>
    <style>
      html {
        color-scheme: light dark;
      }
      body {
        width: 35em;
        margin: 0 auto;
        font-family: Tahoma, Verdana, Arial, sans-serif;
      }
    </style>
  </head>
  <body>
    <h1>Welcome to nginx!</h1>
    <p>
      If you see this page, the nginx web server is successfully installed and
      working. Further configuration is required.
    </p>

    <p>
      For online documentation and support please refer to
      <a href="http://nginx.org/">nginx.org</a>.<br />
      Commercial support is available at
      <a href="http://nginx.com/">nginx.com</a>.
    </p>

    <p><em>Thank you for using nginx.</em></p>
  </body>
</html>

Acceder al servicio demuestra cómo Kubernetes gestiona el enrutamiento del tráfico entre los clientes y los puertos de contenedor adecuados.

Limpiar recursos

Después de completar el laboratorio, es importante limpiar los recursos que has creado para evitar un consumo innecesario de recursos en tu clúster de Kubernetes.

Elimina el hello-service ejecutando:
```
kubectl delete service hello-service
```
Elimina la implementación (deployment) hello-world con el siguiente comando:
```
kubectl delete deployment hello-world
```

Limpiar los recursos asegura que tu clúster se mantenga en un estado limpio, listo para futuros experimentos.

Resumen

En este laboratorio, aprendiste cómo usar el comando expose en Kubernetes para crear un servicio NodePort. Expusiste una implementación (deployment) de Nginx, accediste a ella a través del NodePort y verificaste su funcionalidad. Este ejercicio demostró los conceptos fundamentales de los servicios de Kubernetes y cómo proporcionan acceso de red a tus cargas de trabajo.