5 Métodos de comprobar la conectividad de un puerto remoto en Linux

Acabas de desplegar un servicio, abrir una regla de firewall o configurar un proxy inverso, y ahora quieres confirmar que un puerto específico es realmente accesible. El problema es que telnet no está instalado, y instalar un paquete adicional solo para una prueba rápida de conectividad parece innecesario.

La buena noticia es que no necesitas telnet, porque la mayoría de las distribuciones de Linux ya incluyen herramientas que pueden probar la conectividad de puertos, y algunas no requieren instalación adicional en absoluto.

Ya sea que estés solucionando problemas con una conexión MySQL, comprobando si Nginx está escuchando en el puerto 443 o verificando que un cambio de firewall funcionó como se esperaba, estas herramientas pueden decirte rápidamente qué está sucediendo.

¿Por qué telnet está obsoleto para probar puertos en Linux?

Durante muchos años, telnet fue la forma estándar de comprobar si un puerto estaba abierto y aceptando conexiones. Si querías ver si un servidor web, una base de datos o un servicio de correo era accesible, telnet solía ser el primer comando que la gente probaba.

Sin embargo, las cosas han cambiado. La mayoría de las distribuciones modernas de Linux ya no instalan telnet por defecto, especialmente en despliegues de servidores mínimos. Si ejecutas el comando hoy, a menudo verás un simple mensaje de “comando no encontrado”.

Incluso si está disponible, telnet no siempre es la herramienta de solución de problemas más útil. Puede decirte si una conexión tiene éxito, pero proporciona muy poca información más allá de eso.

Afortunadamente, Linux ofrece varias alternativas mejores. Algunas ya están instaladas en la mayoría de los sistemas, mientras que otras se pueden añadir con una sola instalación de paquete. Estas herramientas no solo prueban la conectividad, sino que también pueden proporcionar mensajes de error más claros, detalles de conexión y una resolución de problemas más rápida cuando algo no funciona como se esperaba.

Comparativa rápida de herramientas

1. Probar puertos abiertos usando Bash /dev/tcp

Si estás trabajando en un servidor Linux mínimo y solo necesitas una respuesta rápida a “¿Este puerto es accesible?”, Bash tiene una característica incorporada que puede ayudar. Proporciona un pseudo-dispositivo especial llamado /dev/tcp que te permite abrir una conexión TCP directamente desde el shell sin instalar herramientas adicionales.

Ejecuta el siguiente comando:

(echo >/dev/tcp/192.168.1.10/80) &>/dev/null && echo "Puerto abierto" || echo "Puerto cerrado"

Si la conexión tiene éxito, verás:

Puerto abierto

Si el puerto está bloqueado, cerrado o es inalcanzable, verás:

Puerto cerrado

En este ejemplo, el comando intenta conectarse al puerto 80 en 192.168.1.10, lo que es especialmente útil cuando estás conectado a un servidor remoto que no tiene herramientas como telnet, nc o nmap instaladas.

Por ejemplo, para probar si un servicio HTTPS es accesible en un sitio web remoto, ejecuta:

(echo >/dev/tcp/example.com/443) &>/dev/null && echo "Puerto abierto" || echo "Puerto cerrado"

Si no estás seguro de qué shell se está usando, ejecuta explícitamente la prueba a través de Bash:

bash -c '(echo >/dev/tcp/example.com/443) &>/dev/null && echo "Puerto abierto" || echo "Puerto cerrado"'

Aunque /dev/tcp no proporciona información detallada de solución de problemas, es una de las formas más rápidas de verificar si un puerto TCP está aceptando conexiones, lo que lo hace perfecto para comprobaciones rápidas en servidores ligeros o recién desplegados.

2. Comprobar puertos abiertos con Netcat (nc)

Si /dev/tcp te parece demasiado básico, nc (Netcat) suele ser la siguiente herramienta a la que recurren los administradores. Es ligera, fácil de usar y proporciona comentarios más útiles cuando estás solucionando problemas de conexiones de red.

Netcat a menudo se llama la “navaja suiza” de las redes porque puede hacer de todo, desde probar puertos hasta transferir datos entre sistemas.

Para comprobar si un puerto está abierto, usa la opción -z (zero-I/O):

nc -zv 192.168.1.10 22

Ejemplo de salida:

Connection to 192.168.1.10 22 port [tcp/ssh] succeeded!

El comando utiliza dos banderas importantes:

• -z : Realiza una prueba de conexión sin enviar datos.
• -v : Muestra salida detallada para que puedas ver el resultado.

A diferencia de telnet, que simplemente se conecta y te deja mirando una pantalla en blanco, Netcat te dice inmediatamente si la conexión tuvo éxito o falló.

Probemos un puerto donde no hay ningún servicio ejecutándose:

nc -zv 192.168.1.10 3306

Ejemplo de salida:

nc: connect to 192.168.1.10 port 3306 (tcp) failed: Connection refused

Un mensaje de Connection refused es en realidad información útil:

• El servidor de destino es accesible.
• La ruta de red está funcionando.
• Nada está escuchando actualmente en ese puerto.

Muchas distribuciones de Linux ya incluyen Netcat, pero algunas instalaciones mínimas de servidor no lo hacen. Instálala según tu distribución:

sudo apt install netcat-openbsd -y     # Debian, Ubuntu, Mint
sudo dnf install nmap-ncat -y          # RHEL/CentOS/Fedora, Rocky/AlmaLinux

Una vez instalada, nc se convierte en una de las herramientas de solución de problemas más útiles que tendrás en cualquier servidor Linux.

3. Escanear puertos abiertos con Nmap

Cuando necesitas más que una simple respuesta de “abierto” o “cerrado”, nmap es la herramienta a utilizar. Es una de las herramientas de escaneo de red más populares y es ampliamente utilizada por administradores de sistemas, ingenieros de redes y profesionales de seguridad.

A diferencia de nc o el método /dev/tcp de Bash, nmap puede identificar servicios, detectar puertos filtrados y proporcionar una imagen mucho más clara de lo que está sucediendo en un sistema remoto.

Si nmap no está instalado, puedes añadirlo usando tu gestor de paquetes:

sudo apt install nmap -y     # Debian, Ubuntu, Mint
sudo dnf install nmap -y     # RHEL/CentOS/Fedora, Rocky/AlmaLinux

Para comprobar si el puerto 80 está abierto en un servidor, ejecuta:

nmap -p 80 192.168.1.10

Ejemplo de salida:

Starting Nmap 7.93 ( https://nmap.org )
Nmap scan report for 192.168.1.10
Host is up (0.00023s latency).

PORT   STATE  SERVICE
80/tcp open   http

Nmap done: 1 IP address (1 host up) scanned in 0.12 seconds

La columna más importante aquí es STATE:

También puedes escanear un rango de puertos en un solo comando:

nmap -p 20-25 192.168.1.10

Ejemplo de salida:

PORT   STATE  SERVICE
20/tcp closed ftp-data
21/tcp closed ftp
22/tcp open   ssh
23/tcp closed telnet
24/tcp closed priv-mail
25/tcp closed smtp

Una de las funciones más útiles de Nmap es la detección de versiones. Simplemente añade la opción -sV y Nmap intentará identificar el software que se ejecuta detrás de un puerto abierto:

nmap -p 22 -sV 192.168.1.10

En lugar de simplemente informar que el puerto 22 está abierto, Nmap puede identificar la versión del servidor SSH y otros detalles del servicio.

4. Probar puertos HTTP y HTTPS con Curl

Cuando estás solucionando problemas con un servidor web, saber simplemente que un puerto está abierto no siempre es suficiente. Un puerto puede aceptar conexiones mientras la aplicación web detrás de él devuelve errores, sirve contenido incorrecto o falla por completo.

Ahí es donde curl se vuelve útil.

A diferencia de nc o /dev/tcp, curl no solo prueba la conexión TCP. En realidad envía una solicitud HTTP y te muestra cómo responde el servidor web, lo que lo convierte en una de las mejores herramientas para comprobar los puertos 80 (HTTP) y 443 (HTTPS).

Para probar un servidor web que escucha en el puerto 80, ejecuta:

curl -v --max-time 5 http://192.168.1.10:80

Ejemplo de salida:

* Trying 192.168.1.10:80...
* Connected to 192.168.1.10 (192.168.1.10) port 80 (#0)
> GET / HTTP/1.1
> Host: 192.168.1.10
> User-Agent: curl/7.88.1
> Accept: */*
>
< HTTP/1.1 200 OK

Para comprobar un servidor web seguro en el puerto 443, usa:

curl -v --max-time 5 https://192.168.1.10:443

Si el servicio HTTPS funciona correctamente, verás los detalles de la negociación SSL seguidos de los encabezados de respuesta HTTP.

5. Comprobar conectividad de puertos con Python

Si necesitas comprobar puertos desde un script, Python es una excelente opción. La mayoría de las distribuciones de Linux ya lo incluyen, y su módulo incorporado socket hace que la prueba de puertos sea sencilla.

Este enfoque es especialmente útil cuando estás creando comprobaciones de salud, scripts de validación de despliegues o herramientas de monitoreo simples.

Para probar un solo puerto, ejecuta:

python3 -c "import socket; s=socket.socket(); s.settimeout(3); result=s.connect_ex(('192.168.1.10', 5432)); print('abierto' if result == 0 else 'cerrado'); s.close()"

Ejemplo de salida:

abierto

En este ejemplo, Python intenta conectarse al puerto 5432, que es comúnmente utilizado por PostgreSQL.

Algunas cosas están sucediendo entre bastidores:

• socket.socket() crea un socket TCP.
• settimeout(3) limita el intento de conexión a tres segundos.
• connect_ex() intenta conectarse y devuelve un código de estado en lugar de lanzar una excepción.
• Un valor de retorno de 0 significa que la conexión tuvo éxito.

En entornos reales, a menudo necesitas verificar varios servicios después de un despliegue. Por ejemplo, es posible que quieras confirmar que SSH, HTTP y MySQL son todos accesibles.

El siguiente script comprueba múltiples combinaciones de host y puerto:

python3 << 'EOF'
import socket

hosts = [
    ("192.168.1.10", 22),
    ("192.168.1.10", 80),
    ("192.168.1.10", 3306),
]

for host, port in hosts:
    s = socket.socket()
    s.settimeout(3)
    result = s.connect_ex((host, port))
    status = "abierto" if result == 0 else "cerrado"
    print(f"{host}:{port} -> {status}")
    s.close()
EOF

Ejemplo de salida:

192.168.1.10:22 -> abierto
192.168.1.10:80 -> abierto
192.168.1.10:3306 -> cerrado

Este script recorre una lista de pares host/puerto e imprime el estado de cada uno, lo que es exactamente lo que necesitas para una lista de verificación previa al despliegue o una comprobación de tiempo de actividad simple en un trabajo cron.

¿Cuándo usar cada una de las herramientas?

Aquí tienes una referencia rápida para elegir la herramienta adecuada:

Conclusión

Hay varias formas sencillas de probar la conectividad de puertos en Linux sin usar telnet. Para ver estas herramientas en acción, prueba a comprobar un servicio que se esté ejecutando en tu propio sistema. Por ejemplo, si SSH está habilitado, puedes comprobar el puerto 22 con:

nc -zv -w 3 localhost 22

Deberías ver una conexión exitosa casi de inmediato. Luego prueba un puerto donde no haya ningún servicio escuchando y compara los resultados. Esta es una forma simple de entender la diferencia entre un puerto abierto, una conexión rechazada y un puerto filtrado.