← Volver al listado de tecnologías ← Índice de Dokploy

Redes y Puertos

28 de febrero de 2026 Por: Artiko

dokployredespuertosnetworking

Redes y Puertos

Dokploy corre todos los servicios dentro de redes Docker. Entender como funciona el networking es clave para conectar aplicaciones entre si, exponer servicios al exterior y aislar componentes.

Como funciona la red interna de Docker en Dokploy

Dokploy crea una red Docker compartida llamada dokploy-network. Todos los servicios desplegados se conectan a esta red automaticamente.

Verificar la red

docker network ls | grep dokploy

Salida esperada:

abc123  dokploy-network  bridge  local

Listar contenedores en la red

docker network inspect dokploy-network --format '{{range .Containers}}{{.Name}} {{.IPv4Address}}{{"\n"}}{{end}}'

Salida ejemplo:

api-backend-abc123    172.18.0.5/16
frontend-def456       172.18.0.6/16
cache-redis-ghi789    172.18.0.7/16
db-postgres-jkl012    172.18.0.8/16
dokploy-traefik       172.18.0.2/16

Todos los contenedores dentro de dokploy-network pueden comunicarse entre si directamente.

Comunicacion entre servicios

Por nombre de contenedor

Dentro de la red Docker, cada contenedor es accesible por su nombre. No necesitas usar IPs (que pueden cambiar entre reinicios).

Ejemplo: una aplicacion Node.js conectandose a PostgreSQL y Redis:

# En las variables de entorno de la aplicacion
DATABASE_URL=postgresql://user:pass@db-postgres-jkl012:5432/mydb
REDIS_URL=redis://:pass@cache-redis-ghi789:6379/0

El hostname db-postgres-jkl012 se resuelve automaticamente dentro de la red Docker al IP del contenedor.

Obtener el nombre exacto del contenedor

El nombre del contenedor aparece en:

Panel de Dokploy: en la seccion General de cada servicio
Terminal: ejecutando hostname dentro del contenedor
Docker CLI:

docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"

Ejemplo: arquitectura tipica

[Traefik :80/:443]
       |
       +---> frontend:3000    (Next.js)
       |
       +---> api:8080         (Express)
                |
                +---> postgres:5432   (no expuesto al exterior)
                +---> redis:6379      (no expuesto al exterior)

En esta arquitectura:

Traefik enruta el trafico externo a frontend y api
api se conecta a postgres y redis por la red interna
Las bases de datos no tienen puertos expuestos al exterior

Probar conectividad entre contenedores

Desde la terminal de un contenedor:

# Verificar que el otro contenedor es alcanzable
ping nombre-contenedor

# Verificar que un puerto especifico esta abierto
nc -zv nombre-contenedor 5432

Si ping no esta disponible (imagenes minimas):

# Alternativa usando wget
wget -qO- http://nombre-contenedor:puerto/ 2>&1 | head -1

Exponer puertos adicionales

Por defecto, Traefik solo expone los puertos HTTP/HTTPS (80/443). Si necesitas exponer puertos adicionales (por ejemplo, para acceso SSH a Gitea o conexion directa a una base de datos), configuralo en la aplicacion.

Desde el panel

Selecciona el servicio
Ve a Advanced > Ports
Agrega el mapeo:

Host Port:      5432
Container Port: 5432
Protocol:       TCP

Esto mapea el puerto 5432 del servidor al puerto 5432 del contenedor, haciendolo accesible desde fuera.

Consideraciones de seguridad

Exponer puertos de bases de datos al exterior es un riesgo de seguridad. Si necesitas acceso remoto:

Opcion recomendada: usa un tunel SSH en lugar de exponer el puerto

# Desde tu maquina local
ssh -L 5432:localhost:5432 usuario@tu-servidor
# Ahora puedes conectarte a localhost:5432 desde tu maquina

Si debes exponer: restringe por IP en el firewall

# Solo permitir tu IP
sudo ufw allow from 203.0.113.10 to any port 5432

Puertos comunes que podrias necesitar exponer

Servicio	Puerto	Motivo
PostgreSQL	5432	Acceso remoto con cliente SQL
MySQL/MariaDB	3306	Acceso remoto con cliente SQL
MongoDB	27017	Acceso remoto
Redis	6379	Acceso remoto
SSH (Gitea/Forgejo)	22 o 2222	Git sobre SSH
SMTP	25/587	Servidor de correo

Redes privadas entre aplicaciones

Si necesitas aislar grupos de servicios, puedes crear redes Docker adicionales.

Cuando usar redes separadas

Multiples proyectos en el mismo servidor que no deben comunicarse entre si
Aislamiento por entorno (staging vs produccion)
Cumplimiento de seguridad que requiere segmentacion de red

Crear una red custom

docker network create --driver bridge mi-proyecto-network

Conectar un contenedor a una red adicional

# Agregar a la red sin desconectar de dokploy-network
docker network connect mi-proyecto-network nombre-contenedor

Configurar en Docker Compose de Dokploy

Si usas Docker Compose en Dokploy, define redes en el archivo:

services:
  api:
    image: mi-api:latest
    networks:
      - dokploy-network
      - backend-network

  worker:
    image: mi-worker:latest
    networks:
      - backend-network

  postgres:
    image: postgres:16
    networks:
      - backend-network

networks:
  dokploy-network:
    external: true
  backend-network:
    driver: bridge

En esta configuracion:

api esta en ambas redes: puede recibir trafico de Traefik y comunicarse con worker y postgres
worker y postgres solo estan en backend-network: no son accesibles desde Traefik ni desde otros servicios de Dokploy

Internal URLs para GitLab/Gitea (v0.27+)

Desde la version 0.27, Dokploy soporta configurar URLs internas para servicios Git como GitLab o Gitea. Esto permite que Dokploy se comunique con el servidor Git a traves de la red interna de Docker en lugar de pasar por el dominio publico.

Configurar URL interna

En Settings > Git Provider, al agregar o editar un proveedor Git:

Campo	Valor
Git URL	`https://git.tudominio.com` (URL publica)
Internal Git URL	`http://gitea-container:3000` (URL interna)

Ventajas

Menor latencia: el trafico no sale a internet y vuelve
No depende del DNS publico: funciona aunque el DNS tenga problemas
Menor carga en Traefik: las peticiones Git de Dokploy no pasan por el reverse proxy

Cuando usarlo

Es especialmente util cuando:

GitLab o Gitea corren como servicios dentro del mismo servidor Dokploy
Tienes webhooks que notifican a Dokploy sobre nuevos commits
El volumen de operaciones Git es alto (muchos deploys automaticos)

Port mapping avanzado

Multiples puertos por servicio

Un servicio puede exponer multiples puertos. Ejemplo para una aplicacion con API HTTP y WebSocket en puertos diferentes:

Puerto 1:
  Host: 8080
  Container: 8080
  Protocol: TCP

Puerto 2:
  Host: 8443
  Container: 8443
  Protocol: TCP

Puertos UDP

Para servicios que usan UDP (DNS, VPN, juegos):

Host Port:      51820
Container Port: 51820
Protocol:       UDP

Puerto efimero (asignar automaticamente)

Si no necesitas un puerto fijo en el host:

Host Port:      0
Container Port: 8080
Protocol:       TCP

Docker asigna un puerto aleatorio disponible. Para ver que puerto se asigno:

docker port nombre-contenedor

Restringir binding a localhost

Si solo necesitas acceso local (para tuneles SSH):

En la configuracion avanzada del servicio, configura el bind address:

Published Ports: 127.0.0.1:5432:5432

Esto solo permite conexiones desde localhost, no desde IPs externas. Util para acceso via tunel SSH sin exponer al mundo.

Diagnosticar problemas de red

# Ver todos los puertos mapeados de contenedores Dokploy
docker ps --format "{{.Names}}: {{.Ports}}" | grep -v "^$"

# Verificar que un puerto esta escuchando en el host
ss -tlnp | grep :5432

# Verificar conectividad desde dentro de un contenedor
docker exec nombre-contenedor sh -c "wget -qO- http://otro-contenedor:puerto/ 2>&1"

# Ver logs de red de un contenedor
docker logs nombre-contenedor 2>&1 | grep -i "connect\|listen\|bind\|error"

Siguiente: Capitulo 16: Variables de Entorno —>