LabEx
EntrarÚnete

Comando de reenvío de puertos de Kubernetes

KubernetesBeginner
Practicar Ahora

Introducción

En este laboratorio, aprenderás cómo utilizar el comando port-forward de Kubernetes para reenviar un puerto local a un puerto en un pod. El reenvío de puertos es una herramienta de depuración crucial que te permite acceder de forma segura a las aplicaciones que se ejecutan en tu clúster sin exponerlas a Internet. Comenzarás con ejemplos simples y progresarás gradualmente hacia escenarios más complejos, incluyendo trabajar con múltiples puertos, múltiples contenedores y servicios.

Este es un Guided Lab, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel principiante con una tasa de finalización del 97%. Ha recibido una tasa de reseñas positivas del 94% por parte de los estudiantes.

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 iniciar, 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.

Explorar el comando kubectl port-forward

El comando kubectl port-forward te permite reenviar uno o más puertos locales a un pod, despliegue (deployment) o servicio en tu clúster de Kubernetes. Se utiliza comúnmente para probar y depurar servicios sin exponerlos externamente.

Ejecuta el siguiente comando para ver las opciones disponibles para kubectl port-forward:

kubectl port-forward -h

Verás la siguiente salida:

Forward one or more local ports to a pod.

Use resource type/name such as deployment/mydeployment to select a pod. Resource type defaults to 'pod' if omitted.

If there are multiple pods matching the criteria, a pod will be selected automatically. The forwarding session ends
when the selected pod terminates, and a rerun of the command is needed to resume forwarding.

Examples:
  ## Listen on ports 5000 and 6000 locally, forwarding data to/from ports 5000 and 6000 in the pod
  kubectl port-forward pod/mypod 5000 6000

  ## Listen on ports 5000 and 6000 locally, forwarding data to/from ports 5000 and 6000 in a pod selected by the deployment
  kubectl port-forward deployment/mydeployment 5000 6000

  ## Listen on port 8443 locally, forwarding to the targetPort of the service's port named "https" in a pod selected by the service
  kubectl port-forward service/myservice 8443:https

  ## Listen on port 8888 locally, forwarding to 5000 in the pod
  kubectl port-forward pod/mypod 8888:5000

  ## Listen on port 8888 on all addresses, forwarding to 5000 in the pod
  kubectl port-forward --address 0.0.0.0 pod/mypod 8888:5000

  ## Listen on port 8888 on localhost and selected IP, forwarding to 5000 in the pod
  kubectl port-forward --address localhost,10.19.21.23 pod/mypod 8888:5000

  ## Listen on a random port locally, forwarding to 5000 in the pod
  kubectl port-forward pod/mypod :5000

Reenviar un puerto local a un pod

En este paso, aprenderás cómo reenviar un puerto local a un puerto en un pod. Esto es útil para depurar aplicaciones o acceder a servicios que no están expuestos fuera del clúster.

Nota sobre la gestión de terminales:

  • El comando kubectl port-forward seguirá ejecutándose en tu terminal y la bloqueará para otros usos.
  • Necesitarás abrir una nueva ventana de terminal para ejecutar comandos adicionales mientras el reenvío de puertos esté activo.
  • Para detener el reenvío de puertos en cualquier momento, puedes presionar Ctrl+C en la terminal donde se esté ejecutando.

  1. Comienza creando un despliegue (deployment) con una réplica y un contenedor Nginx:

    kubectl create deployment nginx --image=nginx --replicas=1

    Este comando crea un despliegue que ejecuta la imagen oficial del contenedor Nginx.

  2. Espera a que el pod esté listo:

    kubectl wait --for=condition=Ready pod -l app=nginx

    Obtén el nombre del pod que usaremos para el reenvío de puertos:

    kubectl get pod -l app=nginx

    Deberías ver una salida similar a:

    NAME                     READY   STATUS    RESTARTS   AGE
nginx-66b6c48dd5-abcd1   1/1     Running   0          30s

  3. Utiliza el comando kubectl port-forward para reenviar un puerto local al pod:

    Primero, obtén el nombre de tu pod:

    export POD_NAME=$(kubectl get pods -l app=nginx -o jsonpath='{.items[0].metadata.name}')
echo $POD_NAME

    Deberías ver una salida como:

    nginx-748c667d99-pdhzs

    Ahora utiliza el nombre del pod para configurar el reenvío de puertos:

    kubectl port-forward $POD_NAME 19000:80

    Deberías ver una salida como:

    Forwarding from 127.0.0.1:19000 -> 80
Forwarding from [::1]:19000 -> 80

  4. Abre una nueva ventana de terminal (ya que el reenvío de puertos sigue ejecutándose en la terminal actual) y verifica el reenvío de puertos:

    curl http://localhost:19000

    Deberías ver el contenido HTML de la página de bienvenida de Nginx.

    También puedes abrir un navegador web y visitar http://localhost:19000 para ver la página renderizada.

Reenviar múltiples puertos locales a un pod

Antes de comenzar este paso, debes:

  1. Detener el reenvío de puertos del Paso 1. Vuelve a esa terminal y presiona Ctrl+C.

En este paso, aprenderás cómo reenviar múltiples puertos locales a un pod. Reenviaremos dos puertos locales diferentes al mismo puerto del contenedor, lo cual es útil cuando quieres proporcionar diferentes puntos de acceso al mismo servicio.

  1. Utiliza los siguientes comandos para configurar el reenvío de puertos:

    Primero, obtén el nombre de tu pod si aún no lo has hecho:

    export POD_NAME=$(kubectl get pods -l app=nginx -o jsonpath='{.items[0].metadata.name}')
echo $POD_NAME

    Deberías ver una salida como:

    nginx-748c667d99-pdhzs

    Ahora configura el reenvío de puertos para mapear dos puertos locales (19080 y 19081) al puerto 80 del contenedor:

    ## The correct format is: kubectl port-forward POD_NAME LOCAL_PORT:CONTAINER_PORT [LOCAL_PORT:CONTAINER_PORT...]
kubectl port-forward pod/$POD_NAME 19080:80 19081:80

    Deberías ver una salida como:

    Forwarding from 127.0.0.1:19080 -> 80
Forwarding from [::1]:19080 -> 80
Forwarding from 127.0.0.1:19081 -> 80
Forwarding from [::1]:19081 -> 80

    Este comando reenvía:

    • El puerto local 19080 al puerto 80 del contenedor.
    • El puerto local 19081 al puerto 80 del contenedor.

    Ambos puertos locales se mapean al mismo puerto 80 del contenedor Nginx, lo que te permite acceder al mismo servidor web a través de diferentes puertos locales.

  2. Verifica el reenvío de puertos comprobando los puertos en escucha:

    ss -tulnp | grep 1908

    Deberías ver una salida similar a esta:

    tcp   LISTEN  0       4096         0.0.0.0:19080     0.0.0.0:*
tcp   LISTEN  0       4096         0.0.0.0:19081     0.0.0.0:*

  3. Ahora puedes acceder a la página de bienvenida de Nginx a través de cualquiera de los puertos:

    curl http://localhost:19080
    curl http://localhost:19081

Ambas URLs mostrarán la misma página de bienvenida de Nginx ya que ambas se reenvían al mismo puerto del contenedor.

Reenviar un puerto local a un pod con múltiples contenedores

Antes de comenzar este paso:

  1. Si tienes algún comando de reenvío de puertos en ejecución de pasos anteriores, ve a esas terminales y presiona Ctrl+C para detenerlos.
  2. Comenzaremos de nuevo con una nueva configuración de un pod de múltiples contenedores.

En este paso, aprenderás cómo reenviar un puerto local a un contenedor específico en un pod con múltiples contenedores. Este es un escenario común en las arquitecturas de microservicios donde se utilizan sidecars (contenedores auxiliares).

  1. Primero, limpiemos los recursos anteriores:

    kubectl delete deployment nginx

  2. Crea un pod con dos contenedores: Nginx y BusyBox:

    cat << EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: nginx-busybox
  labels:
    app: nginx-multi
spec:
  containers:
  - name: nginx
    image: nginx
    ports:
    - containerPort: 80
  - name: busybox
    image: busybox
    command: ['sh', '-c', 'while true; do sleep 3600; done']
EOF

  3. Espera a que el pod esté listo:

    kubectl wait --for=condition=Ready pod/nginx-busybox

  4. Verifica que ambos contenedores estén en ejecución:

    kubectl get pod nginx-busybox -o wide

    Deberías ver 2/2 en la columna READY.

  5. Utiliza el comando kubectl port-forward para reenviar un puerto local al contenedor Nginx:

    kubectl port-forward pod/nginx-busybox 19001:80

  6. En una nueva terminal, verifica la conexión:

    curl http://localhost:19001

    Deberías ver el contenido HTML de la página de bienvenida de Nginx.

Usar port-forward con servicios de Kubernetes

Antes de comenzar este paso:

  1. Si tienes algún comando de reenvío de puertos en ejecución desde el Paso 3, ve a esa terminal y presiona Ctrl+C para detenerlo.
  2. Ten en cuenta que crearemos un nuevo despliegue (deployment) y servicio en este paso, pero no necesitas eliminar el pod anterior ya que no interferirá con nuestros nuevos recursos.

En este paso, aprenderás cómo usar el comando kubectl port-forward con servicios de Kubernetes. El reenvío de puertos a un servicio es diferente del reenvío de puertos a un pod porque te permite acceder a cualquier pod al que apunte el servicio.

  1. Primero, crea un nuevo despliegue con múltiples réplicas:

    kubectl create deployment nginx-service --image=nginx --replicas=3

  2. Espera a que todos los pods estén listos:

    kubectl wait --for=condition=Ready pod -l app=nginx-service

  3. Crea un servicio para el despliegue:

    kubectl expose deployment nginx-service --port=80 --type=ClusterIP --name=nginx-service

  4. Verifica que el servicio se haya creado:

    kubectl get service nginx-service

    Deberías ver una salida como:

    NAME           TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)   AGE
nginx-service  ClusterIP   10.96.123.456   <none>        80/TCP    10s

  5. Utiliza el comando kubectl port-forward para reenviar un puerto local al servicio:

    kubectl port-forward service/nginx-service 20000:80

  6. En una nueva terminal, prueba la conexión:

    curl http://localhost:20000

    Deberías ver el contenido HTML de la página de bienvenida de Nginx. Intenta ejecutar este comando varias veces: es posible que notes que las respuestas provengan de diferentes pods detrás del servicio.

Resumen

En este laboratorio, has aprendido cómo usar efectivamente el comando de reenvío de puertos de Kubernetes en diversos escenarios. Has practicado:

  1. Reenviar un solo puerto local a un pod.
  2. Reenviar múltiples puertos locales al mismo puerto de un contenedor.
  3. Trabajar con pods de múltiples contenedores y reenviar puertos.
  4. Reenviar puertos a servicios de Kubernetes.

Estas habilidades son esenciales para depurar y probar aplicaciones en un clúster de Kubernetes. El reenvío de puertos proporciona una forma segura de acceder a tus aplicaciones durante el desarrollo y la resolución de problemas sin exponerlas a Internet pública.

Algunos puntos clave a recordar:

  • El reenvío de puertos es una conexión temporal que dura solo mientras se ejecuta el comando kubectl port-forward.
  • Puedes reenviar múltiples puertos locales al mismo puerto de un contenedor.
  • El reenvío de puertos funciona tanto con pods como con servicios.
  • Cuando se reenvía un puerto a un servicio, las solicitudes pueden distribuirse entre múltiples pods.

Recuerda que el reenvío de puertos es principalmente una herramienta de depuración y no debe usarse para acceder a aplicaciones en producción. Para escenarios de producción, debes utilizar los tipos adecuados de servicios de Kubernetes (LoadBalancer, NodePort) o controladores Ingress.

Relacionado Kubernetes Cursos
Kubernetes para Principiantes

Kubernetes para Principiantes

kubernetesdevops
Kubernetes para Principiantes

Kubernetes para Principiantes

kubernetesdevops