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 anticipado en tutoriales anteriores de esta serie de 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.

Lo primero es 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. Enrutamiento es el proceso de " guiar " los datos desde el origen al destino dentro de una red.
  3. 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 mientras viaja de una máquina a otra.
  4. 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 la red 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

En este ejemplo, inhabilitaremos 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 que devolverá toda la información para eth1.

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 a esas redes.

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

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, se proporciona 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 modificarlo 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 básicamente 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 (caja de 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 esta configuración sea persistente entre los arranques, edite /etc/sysctl.conf en el enrutador y asegúrese de que la variable net.ipv4.ip_forward esté configurada como verdadera 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

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), lo que indica que la NIC eth0 debe usarse 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 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 dónde devolver la respuesta de Internet.

Solo una parte del resultado de:

# cat /proc/net/ip_conntrack

se muestra en la siguiente captura de pantalla.

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

# curl www.tecmint.com

en la caja de openSUSE.

Como estoy seguro de que ya puede adivinar, el enrutador está usando 8.8.8.8 de Google como servidor de nombres, lo que explica por qué el destino de los paquetes salientes apunta a esa dirección.

Nota: que los paquetes entrantes de Internet solo se aceptan si son parte de una conexión ya establecida (comando # 2), mientras que los paquetes salientes se permiten “ 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, un programa cuyo desarrollo cesó hace un tiempo, mantiene por razones históricas los mismos comandos y estructura que zebra. Es por eso que verás muchas referencias a 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 que se presenta aquí le servirá como punto de partida sobre el que construir.

Para instalar quagga en su 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 una contraseña de su elección):

service quagga restart
hostname    	dev2
password    	quagga
# service quagga restart

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

Tenga en cuenta que este es solo uno de los protocolos que se pueden usar 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 las credenciales en texto sin formato. Por esa razón, debe asignar los permisos adecuados al archivo de configuración:

# chown quagga:quaggavty /etc/quagga/*.conf
# chmod 640 /etc/quagga/*.conf 

En este ejemplo usaremos la siguiente configuración con dos enrutadores (asegúrese de crear los archivos de configuración para el enrutador # 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 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 (los comentarios se agregan 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 /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 ese 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 el enrutamiento estático y dinámico, utilizando un enrutador (es) de caja de Linux. Siéntase libre de agregar tantos enrutadores como desee y de experimentar tanto como desee. No dude en ponerse en contacto con nosotros mediante el formulario de contacto a continuación si tiene algún comentario o pregunta.