Búsqueda de sitios web

Cómo convertir un servidor Linux en un enrutador para manejar el tráfico de forma estática y dinámica - Parte 10


Como hemos adelantado en tutoriales anteriores de esta serie LFCE (Ingeniero certificado de la Fundación Linux), en este artículo discutiremos el enrutamiento del tráfico IP de forma estática y dinámica con aplicaciones específicas.

Presentamos el programa de certificación de la Fundación Linux

Primero lo primero, aclaremos algunas definiciones:

  1. 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 se componen tanto de datos como de la dirección a la que se debe enviar.
  2. El enrutamiento es el proceso de “guiar” los datos desde el origen hasta el destino dentro de una red.
  3. El enrutamiento estático requiere un conjunto de reglas configuradas manualmente y definidas en una tabla de enrutamiento. Estas reglas son fijas y se utilizan para definir la forma en que debe pasar un paquete mientras viaja de una máquina a otra.
  4. El enrutamiento dinámico, o enrutamiento inteligente (si lo desea), 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 administrar las redes y el control del tráfico que usaremos a lo largo de este artículo, ya que representan el reemplazo de herramientas heredadas como ifconfig y route.

La utilidad central de la suite iproute se llama simplemente ip. Su sintaxis básica es la siguiente:

ip object command

Donde objeto puede ser solo uno de los siguientes (solo se muestran los objetos más frecuentes; puede consultar man ip para obtener una lista completa):

  1. enlace: dispositivo de red.
  2. addr: dirección de protocolo (IP o IPv6) en un dispositivo.
  3. ruta: entrada de la tabla de enrutamiento.
  4. regla: 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 de arriba muestra, por ejemplo, que puede cambiar el estado de una interfaz de red con el siguiente comando:

ip link set interface {up | down}

Para ver más ejemplos del comando 'ip', lea 10 comandos 'ip' útiles para configurar la 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 de eth1.

Ejemplo 2: visualización de la tabla de enrutamiento principal

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 el resultado de los tres comandos indica la red de destino. La salida de ip route show (después de la palabra clave dev) también presenta los dispositivos de red que sirven como puerta de enlace física a esas redes.

Aunque hoy en día se prefiere el comando ip a la ruta, aún puedes consultar man ip-route y man route para obtener una explicación detallada del resto. de las columnas.

Ejemplo 3: uso de un servidor Linux para enrutar paquetes entre dos redes privadas

Queremos enrutar paquetes icmp (ping) de dev2 a dev4 y también al revés (tenga en cuenta que ambas máquinas cliente están en redes diferentes). El nombre de cada NIC, junto con su dirección IPv4 correspondiente, aparece 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

Veamos la tabla de enrutamiento en dev1 (cuadro CentOS):

ip route show

y luego modifíquelo 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

Que esencialmente dice: "Agregue 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".

Del mismo modo, en dev4 (cuadro 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 que estas configuraciones sean persistentes en todos los arranques, edite /etc/sysctl.conf en el enrutador y asegúrese de que la variable net.ipv4.ip_forward esté configurada en verdadero de la siguiente manera:

net.ipv4.ip_forward = 1

Además, 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 del cuadro de 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: uso de un servidor Linux para enrutar paquetes entre redes privadas e Internet

Otro escenario en el que se puede utilizar una máquina Linux como enrutador es cuando necesita compartir su 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ático en el cliente como en el ejemplo anterior, necesitamos agregar algunas reglas de 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 usarse para los 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 cambiado a la de la IP pública del enrutador.

En una LAN con muchos hosts, el enrutador realiza un seguimiento de las conexiones establecidas en /proc/net/ip_conntrack para saber a dónde devolver la respuesta de Internet.

Sólo una parte de la producción de:

cat /proc/net/ip_conntrack

se muestra en la siguiente captura de pantalla.

Donde se resalta el origen (IP privada de la casilla openSUSE) y destino (DNS de Google) de los paquetes. Este fue el resultado de ejecutar:

curl linux-console.net

en el cuadro de openSUSE.

Como seguramente ya podrás adivinar, el enrutador utiliza el servidor de nombres 8.8.8.8 de Google, lo que explica por qué el destino de los paquetes salientes apunta a esa dirección.

Nota: Que los paquetes entrantes desde Internet sólo se aceptan si son parte de una conexión ya establecida (comando #2), mientras que los paquetes salientes están permitidos “salida libre” (comando #3).

No olvide hacer que sus reglas de iptables sean persistentes siguiendo los pasos descritos en la 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 costo relativamente bajo, 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 mejores rutas para manejar paquetes.

Al ser un fork de zebra, 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 la cebra a partir de este momento.

Tenga 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í le servirá como punto de partida para desarrollarlo.

Instalación de Quagga en Linux

Para instalar quagga en la distribución elegida:

aptitude update && aptitude install quagga 				[On Ubuntu]
yum update && yum install quagga 					[CentOS/RHEL]
zypper refresh && zypper install quagga 				[openSUSE]

Usaremos 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, edite /etc/quagga/daemons con,

zebra=1
ripd=1

Ahora cree los siguientes archivos de configuración.

/etc/quagga/zebra.conf
/etc/quagga/ripd.conf

y agregue estas líneas (reemplácelas por un nombre de host y contraseña de su elección):

service quagga restart
hostname    	dev2
password    	quagga
service quagga restart

Nota: 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 pueden ser alcanzados y qué tan lejos (en términos de cantidad de saltos) están.

Tenga en cuenta que este es sólo uno de los protocolos que se pueden usar junto con quagga, y lo elegí para este tutorial debido a su 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 ese motivo, es necesario asignar los permisos adecuados al archivo de configuración:

chown quagga:quaggavty /etc/quagga/*.conf
chmod 640 /etc/quagga/*.conf 
Ejemplo 5: configurar quagga para enrutar el tráfico IP dinámicamente

En este ejemplo usaremos la siguiente configuración con dos enrutadores (asegúrese de crear los archivos de configuración para el router #2 como se explicó anteriormente):

Importante: No olvide repetir la siguiente configuración para ambos enrutadores.

Conéctese a zebra (escuchando en el puerto 2601), que es el intermediario lógico entre el enrutador y el kernel:

telnet localhost 2601

Ingrese la contraseña que se estableció en el archivo /etc/quagga/zebra.conf y luego habilite 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 aclarar):

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 anexa a las líneas que agregamos anteriormente (/etc/quagga/zebra.conf y < b>/etc/quagga/ripd.conf).

Finalmente, conéctate nuevamente al servicio zebra en ambos routers y observa 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, explicamos cómo configurar el enrutamiento estático y dinámico utilizando un enrutador de caja Linux. Siéntete libre de agregar tantos enrutadores como desees y experimentar todo lo que quieras. No dude en comunicarse con nosotros mediante el formulario de contacto a continuación si tiene algún comentario o pregunta.