Como hemos anticipado en tutoriales anteriores de esta serie LFCE (Linux Foundation Certified Engineer), en este artículo discutiremos el enrutamiento del tráfico IP de forma estática y dinámica con aplicaciones específicas.
Introducción al Programa de Certificación de la Fundación Linux
Primero lo primero, aclaremos algunas definiciones:
- En palabras simples, un paquete es la unidad básica que se utiliza para transmitir información dentro de una red. Las redes que utilizan TCP/IP como protocolo de red siguen las mismas reglas para la transmisión de datos: la información real se divide en paquetes que están compuestos tanto por datos como por la dirección a la que deben ser enviados.
- El enrutamiento es el proceso de “guiar” los datos desde la fuente hasta el destino dentro de una red.
- El enrutamiento estático requiere un conjunto de reglas configuradas manualmente definidas en una tabla de enrutamiento. Estas reglas son fijas y se utilizan para definir la forma en que un paquete debe pasar a medida que viaja de una máquina a otra.
- El enrutamiento dinámico, o enrutamiento inteligente (si lo prefieres), significa que el sistema puede alterar automáticamente, según sea necesario, la ruta que sigue un paquete.
Configuración Avanzada de Dispositivos de Red e IP
El paquete iproute proporciona un conjunto de herramientas para gestionar la red y el control de tráfico que utilizaremos a lo largo de este artículo, ya que representan la sustitución de herramientas heredadas como ifconfig y route.
La utilidad central en el conjunto de herramientas iproute se llama simplemente ip. Su sintaxis básica es la siguiente:
# ip object command
Donde objeto solo puede ser uno de los siguientes (se muestran solo los objetos más frecuentes; puede consultar el manual ip para obtener una lista completa):
- link: dispositivo de red.
- addr: dirección de protocolo (IP o IPv6) en un dispositivo.
- route: entrada de tabla de enrutamiento.
- rule: regla en la base de datos de políticas de enrutamiento.
Mientras que comando representa una acción específica que se puede realizar en un objeto. Puede ejecutar el siguiente comando para mostrar la lista completa de comandos que se pueden aplicar a un objeto en particular:
# ip object help
Por ejemplo,
# ip link help
La imagen anterior muestra, por ejemplo, que puede cambiar el estado de una interfaz de red con el siguiente comando:
# ip link set interface {up | down}
Para más ejemplos de comandos ‘ip‘, lea 10 Comandos Útiles de ‘ip’ para Configurar Dirección IP
Ejemplo 1: Deshabilitar y habilitar una interfaz de red
En este ejemplo, deshabilitaremos y habilitaremos eth1:
# ip link show # ip link set eth1 down # ip link show
Si desea volver a habilitar eth1,
# ip link set eth1 up
En lugar de mostrar todas las interfaces de red, podemos especificar una de ellas:
# ip link show eth1
Lo cual devolverá toda la información para eth1.
Ejemplo 2: Mostrar la tabla de enrutamiento principal actual
Puede ver su tabla de enrutamiento principal actual con cualquiera de los siguientes 3 comandos:
# ip route show # route -n # netstat -rn
La primera columna en la salida de los tres comandos indica la red de destino. La salida de ip route show (siguiendo la palabra clave dev) también presenta los dispositivos de red que sirven como puerta de enlace física para esas redes.
Aunque hoy en día se prefiere el comando ip sobre route, aún puedes consultar el manual ip-route y man route para obtener una explicación detallada del resto de las columnas.
Ejemplo 3: Usando un servidor Linux para enrutar paquetes entre dos redes privadas
Queremos enrutar paquetes icmp (ping) desde dev2 hacia dev4 y viceversa (nota que ambas máquinas cliente están en redes diferentes). El nombre de cada NIC, junto con su dirección IPv4 correspondiente, se da entre corchetes.
Nuestro entorno de prueba es el siguiente:
Client 1: CentOS 7 [enp0s3: 192.168.0.17/24] - dev1 Router: Debian Wheezy 7.7 [eth0: 192.168.0.15/24, eth1: 10.0.0.15/24] - dev2 Client 2: openSUSE 13.2 [enp0s3: 10.0.0.18/24] - dev4
Vamos a ver la tabla de enrutamiento en dev1 (equipo CentOS):
# ip route show
y luego modificarla para usar su NIC enp0s3 y la conexión a 192.168.0.15 para acceder a los hosts en la red 10.0.0.0/24:
# ip route add 10.0.0.0/24 via 192.168.0.15 dev enp0s3
Lo cual esencialmente dice, “Agregar una ruta a la red 10.0.0.0/24 a través de la interfaz de red enp0s3 usando 192.168.0.15 como puerta de enlace”.
De igual manera en dev4 (equipo openSUSE) para hacer ping a los hosts en la red 192.168.0.0/24:
# ip route add 192.168.0.0/24 via 10.0.0.15 dev enp0s3
Finalmente, necesitamos habilitar el reenvío en nuestro enrutador Debian:
# echo 1 > /proc/sys/net/ipv4/ip_forward
Ahora hagamos ping:
y,
Para hacer que estos ajustes sean persistentes en los reinicios, edita /etc/sysctl.conf en el enrutador y asegúrate de que la variable net.ipv4.ip_forward esté configurada como true de la siguiente manera:
net.ipv4.ip_forward = 1
Configure las NIC en ambos clientes (busque el archivo de configuración dentro de /etc/sysconfig/network en openSUSE y /etc/sysconfig/network-scripts en CentOS, en ambos casos se llama ifcfg-enp0s3).
Aquí está el archivo de configuración de la caja openSUSE:
BOOTPROTO=static BROADCAST=10.0.0.255 IPADDR=10.0.0.18 NETMASK=255.255.255.0 GATEWAY=10.0.0.15 NAME=enp0s3 NETWORK=10.0.0.0 ONBOOT=yes
Ejemplo 4: Usar un servidor Linux para enrutar paquetes entre redes privadas e Internet
Otro escenario donde una máquina Linux puede ser utilizada como enrutador es cuando necesitas compartir tu conexión a Internet con una LAN privada.
Router: Debian Wheezy 7.7 [eth0: Public IP, eth1: 10.0.0.15/24] - dev2 Client: openSUSE 13.2 [enp0s3: 10.0.0.18/24] - dev4
Además de configurar el reenvío de paquetes y la tabla de enrutamiento estática en el cliente como en el ejemplo anterior, necesitamos agregar algunas reglas iptables en el enrutador:
# iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE # iptables -A FORWARD -i eth0 -o eth1 -m state --state RELATED,ESTABLISHED -j ACCEPT # iptables -A FORWARD -i eth1 -o eth0 -j ACCEPT
El primer comando agrega una regla a la cadena POSTROUTING en la tabla nat (Traducción de Direcciones de Red), indicando que la NIC eth0 debe ser utilizada para paquetes salientes.
MASQUERADE indica que esta NIC tiene una IP dinámica y que antes de enviar el paquete al “mundo salvaje” de Internet, la dirección de origen privada del paquete debe ser cambiada a la IP pública del enrutador.
En una LAN con muchos hosts, el enrutador lleva un registro de las conexiones establecidas en /proc/net/ip_conntrack para saber a dónde devolver la respuesta desde Internet.
Solo se muestra parte de la salida de:
# cat /proc/net/ip_conntrack
en la siguiente captura de pantalla.
Donde se resalta el origen (IP privada de la caja openSUSE) y el destino (DNS de Google) de los paquetes. Este fue el resultado de ejecutar:
# curl www.tecmint.com
en la caja openSUSE.
Como seguramente ya habrás adivinado, el enrutador está utilizando el 8.8.8.8 de Google como servidor de nombres, lo que explica por qué la dirección de destino de los paquetes salientes apunta a esa dirección.
Nota: Los paquetes entrantes desde Internet solo son aceptados si forman parte de una conexión ya establecida (comando #2), mientras que los paquetes salientes tienen permitida la “salida libre” (comando #3).
No olvides hacer que tus reglas de iptables sean persistentes siguiendo los pasos descritos en Parte 8 – Configurar el Firewall de Iptables de esta serie.
Enrutamiento Dinámico con Quagga
Hoy en día, la herramienta más utilizada para el enrutamiento dinámico en Linux es quagga. Permite a los administradores de sistemas implementar, con un servidor Linux de bajo costo, la misma funcionalidad que proporcionan los potentes (y costosos) enrutadores Cisco.
La herramienta en sí no maneja el enrutamiento, sino que modifica la tabla de enrutamiento del kernel a medida que aprende nuevas rutas óptimas para manejar paquetes.
Dado que es un fork de zebra, un programa cuyo desarrollo cesó hace un tiempo, mantiene por razones históricas los mismos comandos y estructura que zebra. Por eso verás muchas referencias a zebra a partir de este punto.
Ten en cuenta que no es posible cubrir el enrutamiento dinámico y todos los protocolos relacionados en un solo artículo, pero estoy seguro de que el contenido presentado aquí te servirá como punto de partida para que puedas avanzar.
Instalando Quagga en Linux
Para instalar quagga en tu distribución elegida:
# aptitude update && aptitude install quagga [On Ubuntu] # yum update && yum install quagga [CentOS/RHEL] # zypper refresh && zypper install quagga [openSUSE]
Utilizaremos el mismo entorno que en el Ejemplo #3, con la única diferencia de que eth0 está conectado a un enrutador de puerta de enlace principal con IP 192.168.0.1.
A continuación, edita /etc/quagga/daemons con,
zebra=1 ripd=1
Ahora crea los siguientes archivos de configuración.
# /etc/quagga/zebra.conf # /etc/quagga/ripd.conf
y añade estas líneas (reemplaza por un nombre de host y contraseña de tu elección):
service quagga restart hostname dev2 password quagga
# service quagga restart
Nota: Que ripd.conf es el archivo de configuración para el Protocolo de Información de Enrutamiento, que proporciona al enrutador la información de qué redes se pueden alcanzar y a qué distancia (en términos de cantidad de saltos) están.
Ten en cuenta que este es solo uno de los protocolos que se pueden utilizar junto con quagga, y lo elegí para este tutorial debido a la facilidad de uso y porque la mayoría de los dispositivos de red lo admiten, aunque tiene la desventaja de pasar credenciales en texto plano. Por esa razón, necesitas asignar permisos adecuados al archivo de configuración:
# chown quagga:quaggavty /etc/quagga/*.conf # chmod 640 /etc/quagga/*.conf
Ejemplo 5: Configuración de quagga para enrutar tráfico IP dinámicamente
En este ejemplo utilizaremos la siguiente configuración con dos enrutadores (asegúrate de crear los archivos de configuración para enrutador #2 como se explicó anteriormente):
Importante: No olvides repetir la siguiente configuración para ambos enrutadores.
Conéctate a zebra (escuchando en el puerto 2601), que es el intermediario lógico entre el enrutador y el kernel:
# telnet localhost 2601
Ingresa la contraseña que se estableció en el archivo /etc/quagga/zebra.conf, y luego habilita la configuración:
enable configure terminal
Ingrese la dirección IP y la máscara de red de cada NIC:
inter eth0 ip addr 192.168.0.15 inter eth1 ip addr 10.0.0.15 exit exit write
Ahora necesitamos conectarnos al terminal del demonio RIP (puerto 2602):
# telnet localhost 2602
Ingrese el nombre de usuario y la contraseña configurados en el archivo /etc/quagga/ripd.conf, y luego escriba los siguientes comandos en negrita (se agregan comentarios para mayor claridad):
enable turns on privileged mode command. configure terminal changes to configuration mode. This command is the first step to configuration router rip enables RIP. network 10.0.0.0/24 sets the RIP enable interface for the 10.0.0.0/24 network. exit exit write writes current configuration to configuration file.
Nota: Que en ambos casos la configuración se añade a las líneas que agregamos previamente (/etc/quagga/zebra.conf y /etc/quagga/ripd.conf).
Finalmente, conéctese nuevamente al servicio zebra en ambos enrutadores y observe cómo cada uno de ellos ha “aprendido” la ruta a la red que está detrás del otro, y cuál es el siguiente salto para llegar a esa red, ejecutando el comando show ip route:
# show ip route
Si desea probar diferentes protocolos o configuraciones, puede consultar el sitio del proyecto Quagga para obtener más documentación.
Conclusión
En este artículo hemos explicado cómo configurar enrutamiento estático y dinámico, utilizando un enrutador de caja Linux. Siéntase libre de agregar tantos enrutadores como desee y experimentar todo lo que quiera. No dude en ponerse en contacto con nosotros utilizando el formulario de contacto a continuación si tiene algún comentario o pregunta.