Tema:

Acceso y Mapeo de Puertos en Docker Containers

Introducción

El acceso y mapeo de puertos en contenedores Docker es una característica fundamental que permite conectar aplicaciones dentro de los contenedores con el mundo exterior. Por defecto, los contenedores Docker están aislados de la red externa, lo que protege las aplicaciones internas, pero también dificulta el acceso a servicios que deben ser consumidos desde el host o por otros dispositivos en la red.

El mapeo de puertos proporciona una solución para esta barrera, asignando puertos del contenedor a puertos específicos del host, permitiendo así el tráfico entre ambos. Esta capacidad es especialmente útil para aplicaciones como servidores web, bases de datos y APIs que requieren interacción directa con usuarios o sistemas externos.

En este tema, aprenderemos cómo funciona el mapeo de puertos, sus configuraciones más comunes, y cómo evitar conflictos o problemas relacionados con el uso de puertos compartidos.

Objetivo

Objetivo General:

Capacitar a los participantes en el uso eficiente del mapeo de puertos en contenedores Docker, permitiéndoles configurar, probar y solucionar problemas de acceso a aplicaciones contenerizadas. Al final de este tema, los participantes serán capaces de exponer servicios de manera segura y escalable desde sus contenedores hacia el exterior, utilizando diferentes configuraciones de mapeo de puertos para atender diversas necesidades de despliegue y desarrollo.

Guía de Laboratorio: Uso de Docker Port Mapping en un Servidor Web

En este laboratorio, aprenderás cómo exponer aplicaciones dentro de contenedores Docker utilizando port mapping, una característica esencial para permitir que servicios dentro de un contenedor sean accesibles desde el host u otros dispositivos en la red.

Paso 1: Crear una aplicación de ejemplo

Para este laboratorio, usaremos un contenedor basado en NGINX, que ejecuta un servidor web.

Inicia un contenedor NGINX sin mapeo de puertos:
```
docker run -d --name nginx-no-port nginx
```
Verifica que el contenedor está corriendo:
```
docker ps
```

Observa que no hay puertos expuestos porque no se configuró ningún mapeo.

Intenta acceder al servidor web con el comando curl http://localhost:
Resultado esperado: No podrás acceder porque los puertos del contenedor no están mapeados al host.

Paso 2: Usar port mapping para exponer el servicio

Ahora crearemos un nuevo contenedor NGINX con mapeo de puertos.

Inicia un contenedor con el puerto 80 del contenedor mapeado al puerto 8080 del host:
```
docker run -d --name nginx-port-mapped -p 8080:80 nginx
```

En este caso: - -p 8080:80 mapea el puerto 80 del contenedor al puerto 8080 de tu máquina host.

Verifica que el contenedor está corriendo:
```
docker ps
```

Nota la columna PORTS, que debería mostrar 0.0.0.0:8080->80/tcp.

Accede al servidor web utilizando el comando curl http://localhost:8080: Resultado esperado: Verás la página de bienvenida de NGINX.

Paso 3: Probar diferentes configuraciones de port mapping

3.1 Mapear a un puerto diferente del host

Inicia otro contenedor con el puerto 80 del contenedor mapeado al puerto 9090 del host:
```
docker run -d --name nginx-port-9090 -p 9090:80 nginx
```
Accede al servidor web en curl http://localhost:9090.
Verifica los contenedores y sus puertos:
```
docker ps
```

3.2 Mapear a una interfaz específica

Mapea el puerto 80 del contenedor solo a la interfaz 127.0.0.1 en el host:

docker run -d --name nginx-localhost -p 127.0.0.1:8081:80 nginx

Intenta acceder al servidor web en curl http://localhost:8081. Resultado esperado: Deberías acceder al servidor web.
Intenta acceder desde otra ip del servidor host, puedes obtenerla con el comando ip a: curl http://10.138.0.19:8081 Resultado esperado: No podrás acceder porque el mapeo está restringido a la interfaz 127.0.0.1.

Paso 4: Probar múltiples contenedores con mapeos diferentes

Inicia tres contenedores con diferentes puertos:

docker run -d --name nginx-port-8082 -p 8082:80 nginx

docker run -d --name nginx-port-8083 -p 8083:80 nginx

docker run -d --name nginx-port-8084 -p 8084:80 nginx

Verifica que cada contenedor tiene un puerto mapeado único:
```
docker ps
```
Accede a cada contenedor desde el navegador en los puertos 8082, 8083, y 8084.

Paso 5: Verificar conflictos de puertos

Intenta iniciar un contenedor con el puerto 80 mapeado al puerto 8080 nuevamente:
```
docker run -d --name nginx-port-conflict -p 8080:80 nginx
```
Resultado esperado: Docker mostrará un error porque el puerto 8080 ya está en uso por otro contenedor.

Paso 6: Limpieza

Detén y elimina todos los contenedores creados:

docker rm -f nginx-no-port nginx-port-mapped nginx-port-9090 nginx-localhost nginx-port-8082 nginx-port-8083 nginx-port-8084

Verifica que no hay contenedores corriendo:
```
docker ps -a
```

Conclusión

En este laboratorio, aprendiste cómo funciona el mapeo de puertos en Docker. Ahora puedes:

Exponer servicios dentro de un contenedor al host.
Configurar mapeos específicos para diferentes puertos y redes.
Evitar conflictos de puertos en entornos multi-contenedor.

Esta técnica es fundamental para desarrollar y desplegar aplicaciones contenerizadas accesibles desde el exterior.

Guía de Laboratorio: Uso de Docker Port Mapping en un Servidor Base de Datos

Ingresar al servidor proporcionado para el ambiente de laboratorio
Ejecutar contenedor realizando un mapeo del puerto 3306 del contenedor a puerto 30307 del equipo que ejecuta el contenedor de MariaDB llamado db
```
docker run -d -p 30307:3306 --name db mariadb:10.7
```
Verificar estado de contenedor de db
```
docker ps -a
```
Verificar logs de contenedor db
```
docker logs db
```
Borrar contenedor db
```
docker rm db
```
Ejecutar nuevamente contenedor de mariadb, de igual manera limpiando el puerto de servicio y agregando la variable MARIADB_ROOT_PASSWORD por medio de la opción -e con valor de M4rI_dB
```
docker run -d -p 30307:3306 -e MARIADB_ROOT_PASSWORD='M4rI_dB' \
--name db mariadb:10.7
```
Verificar logs de contenedor db
```
docker logs db
```
Verificar puertos mapeados
```
docker port db
```

Instalar cliente de MariaDB

curl -LsSO https://r.mariadb.com/downloads/mariadb_repo_setup

chmod +x mariadb_repo_setup

sudo ./mariadb_repo_setup

sudo yum install MariaDB-client

Conectarse a base de datos como localhost en el puerto 3307

mariadb -u root -p'M4rI_dB' -h 127.0.0.1 -P 30307 --ssl=0

exit

Verificar puerto 3307 en el equipo que ejecuta el contenedor
```
ss -ptnuol |grep 30307
```
Detener contenedor db
```
sudo docker stop db
```
Verificar que ya no se encuentre levantado el puerto 3307 en el equipo que ejecuta el contenedor
```
ss -ptnuol |grep 30307
```

Levantar otro contenedor de mariadb con un port mapping diferente

docker run -d -p 30308:3306 -e MARIADB_ROOT_PASSWORD='demo2' --name db2 mariadb:10.7

Verifique que el contenedor se levanto correctamente
```
docker ps
```
```
docker logs db2
```
Verificar puerto 30307 y 30308 en el equipo que ejecuta el contenedor
```
ss -ptnuol |grep 30307
ss -ptnuol |grep 30308
```

Haga conexión a la base de datos 2 por el puerto 30308

mariadb -u root -p'demo2' -h 127.0.0.1 -P 30308 --ssl=0

exit

Levante el contenedor db
```
docker start db
```
Verificar puerto 30307 y 30308 en el equipo que ejecuta el contenedor
```
ss -ptnuol |grep 30307
ss -ptnuol |grep 30308
```

Haga conexión a la base de datos 1 por el puerto 30307

mariadb -u root -p'M4rI_dB' -h 127.0.0.1 -P 30307 --ssl=0
exit

Haga conexión a la base de datos 2 por el puerto 30308

mariadb -u root -p'demo2' -h 127.0.0.1 -P 30308 --ssl=0
exit

Detenga el contenedor db2
```
docker stop db2
```
Verificar puerto 30307 y 30308 en el equipo que ejecuta el contenedor
```
ss -ptnuol |grep 30307
ss -ptnuol |grep 30308
```

Limpieza de ambiente

Detenga y elimine los recursos

docker stop db
docker rm db
docker stop db2
docker rm db2
docker image rm mariadb:10.7