Cómo configurar y optimizar el enrutamiento estático en Linux

¿Qué es el enrutamiento?

Cada vez que conectas una computadora a una red, estás lidiando con la cuestión del enrutamiento. El enrutamiento es un medio de enviar un paquete IP de un punto a otro. Por ejemplo, cuando envías un correo electrónico a un amigo en otro país o al otro lado de la calle, estás transmitiendo una serie de paquetes IP, o datagramas, desde tu computadora hacia la computadora de tu amigo. ¿Pero cómo llega la información hasta allí?

Tu sistema envía los paquetes que contienen tu correo electrónico hacia tu gateway especificado. El gateway luego reenvía los paquetes hacia otro gateway o enrutador. El proceso continúa hasta que el paquete llega al sistema de tu amigo y él o ella lee el mensaje. Esto es cierto para todos los protocolos de Internet, ya sea FTP, HTTP, IRC, y así sucesivamente.

Si solo tienes una computadora, generalmente no necesitas preocuparte por el enrutamiento. Simplemente le dices a tu computadora que use la dirección IP del gateway proporcionado por tu proveedor de servicios de Internet y listo. Sin embargo, si ejecutas una red de computadoras, esto puede complicarse un poco más. Si colocas un firewall frente a tu red, necesitas configurar las cosas de manera más exhaustiva. Con esta configuración, en realidad estás lidiando con dos redes: tu red local y la Internet. Los paquetes que van de una a la otra necesitan ser reenviados de manera especial para que lleguen a sus destinos apropiados.

Entendiendo el enrutamiento

En los sistemas Linux y UNIX, la información sobre cómo se deben reenviar los paquetes se almacena en una estructura del kernel llamada tabla de enrutamiento. Necesitas manipular esta tabla al configurar tu computadora para hablar con otras computadoras a través de una red. La tabla de enrutamiento se puede utilizar tanto para enrutamiento estático como dinámico. El enrutamiento dinámico consiste en que el kernel tome decisiones sobre qué ruta, de entre varias rutas presentes, debería tomar un paquete. Dado que los enrutadores dedicados y los proveedores de servicios de Internet generalmente lidiarán más con el enrutamiento dinámico, no profundizaré en los detalles, ya que está más allá del alcance de este artículo. En cambio, me centraré en el enrutamiento estático, ya que es el más común.

Puedes examinar la tabla de enrutamiento utilizando el programa netstat de la siguiente manera:
```
netstat -r
```

Esto imprimirá una tabla de enrutamiento que puede parecerse a la mostrada en la **Tabla A**.

Cómo utilizar Isearch para buscar archivos de texto en Linux

```
Tabla A

Destino Gateway Genmask Flags MSS Ventana Irtt Interfaz
192.168.10.0 * 255.255.255.0 U 40 0 0 eth0
127.0.0.0 * 255.0.0.0 U 40 0 0 lo
default 192.168.10.1 0.0.0.0 UG 40 0 0 eth0
```

La columna *Destino* identifica la red de destino. La columna *Gateway* identifica el gateway definido para la red especificada. Aparece un asterisco (*) en esta columna si no se necesita un gateway de reenvío para la red. La columna *Genmask* muestra la máscara de red; en este caso, es 255.255.255.0. La columna *Interfaz* muestra la interfaz de red. Si tuvieras más de una interfaz, verías *lo* (para loopback), *eth0* (primer dispositivo Ethernet) y *eth1* (para el segundo dispositivo Ethernet), y así sucesivamente por la cantidad de interfaces que hayas instalado. En la sección *Flags*, la flag *U* significa que la ruta está activa y la flag *G* significa que se debe usar el gateway especificado para esta ruta. Hay otras flags que puedes ver, como *D* para instalación dinámica, *M* para modificación y *R* para reinstalación. Estas tres flags indican que la ruta fue creada o modificada por un demonio de enrutamiento después de encontrarse con un mensaje de redirección ICMP. (Por lo general, no verás estas flags a menos que uses enrutamiento dinámico). Por último, puede que veas una flag de exclamación (!), que indica una ruta de rechazo.

La columna *MSS* indica el tamaño máximo de segmento predeterminado para las conexiones TCP a través de esta ruta. La columna *Ventana* indica el tamaño predeterminado de ventana para conexiones TCP a través de esta ruta y la columna *Irtt* indica el tiempo inicial de ida y vuelta para esta ruta. El kernel utiliza esto para seleccionar valores para ciertos parámetros TCP sin tener que esperar respuestas potencialmente lentas de hosts remotos. Por lo general, no te preocuparás por estas tres columnas a menos que el rendimiento se vea afectado y estés intentando encontrar una forma de ajustarlo. En la mayoría de los casos, no necesitarás redefinir los valores predeterminados aquí.

Como puedes ver, he definido una ruta para 127.0.0.0, que es la red de loopback. La red de loopback se maneja localmente, por lo que no se requiere un gateway de reenvío. También tengo una ruta definida para 192.168.10.0, que es la red a la que está conectada la interfaz *eth0*. Tampoco requiere un gateway de reenvío porque esta es la red local. La última línea contiene un destino predeterminado, a veces mostrado como 0.0.0.0, lo que significa que todo lo que no está clasificado ya será enviado a la dirección 192.168.10.1, que es el gateway de reenvío y la ruta hacia Internet.

Cambiar rutas estáticas

Ahora que te he mostrado cómo mostrar las rutas definidas actualmente, necesitarás saber cómo cambiarlas. Esto se puede hacer más fácilmente utilizando el programa *Linuxconf* en Red Hat o Linux-Mandrake y programas de administración similares en otras variantes de Linux. Sin embargo, hay algunas variantes que no tienen herramientas como *Linuxconf* para manejar la definición de rutas, así que echemos un vistazo al método "tradicional". Para hacer esta configuración manualmente, tendrás que aprender a usar el comando *route*.

Guía para entender y gestionar los permisos de archivos y directorios en Linux

El primer argumento que se pasa a *route* será *add* o *del*, que indicará si se está agregando o eliminando una ruta de la tabla de enrutamiento. El resto de los argumentos que *route* utiliza dependen de la acción que hayas elegido.

Veamos cómo crear una tabla de enrutamiento de manera que hayamos definido las mismas rutas que se muestran en el ejemplo anterior. Lo primero que debes hacer es agregar la red a la que perteneces utilizando:
```
route add -net 192.168.10.0 netmask 255.255.255.0 dev eth0
```

Esto agregará la red 192.168.10.0/255.255.255.0 al dispositivo Ethernet *eth0*. Esto corresponde con la primera línea mostrada en la salida de *netstat*.

Para agregar la red de loopback, usarías:
```
route add -net 127.0.0.0 netmask 255.0.0.0 lo
```

Esto agrega la red 127.0.0.0/255.0.0.0 al dispositivo Ethernet *lo*, que representa la red de loopback (o local). No es necesario hacer esto si usas kernels de Linux 2.2 o superiores, ya que esos kernels manejarán esto automáticamente.

Finalmente, necesitas agregar el gateway predeterminado usando:
```
route add default gw 192.168.10.1
```

Cómo configurar un servidor Linux como puerta de enlace para una red local

Esto crea la entrada final mostrada por *netstat* y le dice a Linux que envíe todos los paquetes que no están destinados a la red 192.168.10.0 o la red de loopback al gateway definido, en este caso, 192.168.10.1.

De la misma manera, puedes eliminar redes utilizando el comando *del* con *route* de la siguiente manera:
```
route del -net 192.168.10.0
```

Esto eliminará la entrada de la tabla de enrutamiento para la red 192.168.10.0.

Enrutamiento multinetwork

¿Qué sucede si tienes una red más complicada? Supongamos por un momento que tienes dos LAN, la primera con la red 10.0.0.0 y una segunda con la red 192.168.10.0. Hay un firewall entre las dos redes, con dos tarjetas de red: *eth0* está conectada a la red 10.0.0.0, mientras que *eth1* está conectada a la red 192.168.10.0. Este firewall necesita enrutarse paquetes desde la red 10.0.0.0 a través de la red 192.168.10.0, que a su vez reenviará paquetes a Internet.

En este escenario, configurarías el sistema de firewall con dos direcciones IP: 10.0.0.1 en *eth1* y 192.168.10.25 en *eth0*. La puerta de enlace a Internet en la red 192.168.10.0 sigue siendo 192.168.10.1. En el sistema de firewall, ejecutarías *route* con los siguientes comandos:
```
route add -net 192.168.10.0 netmask 255.255.255.0 dev eth1
route add default gw 192.168.10.1
route add -net 10.0.0.0 netmask 255.0.0.0 dev eth0
```

En el enrutador, esto define ambas redes: 192.168.10.0 en *eth1* y 10.0.0.0 en *eth0*. También asigna 192.168.10.1 como la puerta de enlace predeterminada.

Windows al alcance de Linux: Accede a recursos con smbmount y smbclient

En las computadoras de la red 10.0.0.0, usarías *route* de la siguiente manera:
```
route add -net 10.0.0.0 netmask 255.0.0.0 dev eth0
route add default gw 10.0.0.1
```

Esto le dice a cada computadora que la puerta de enlace predeterminada es 10.0.0.1, que es tu firewall/enrutador.

Con el firewall y la red 10.0.0.0 configurados, deberías poder enrutarse todos los paquetes desde la red 10.0.0.0 hasta Internet y hasta la red 192.168.10.0. ¿Qué sucede si tienes un sistema en la red 192.168.10.0 con el que deseas poder comunicarte con sistemas en la red 10.0.0.0?

En cada sistema en la red 192.168.10.0, deberás configurar la tabla de enrutamiento de manera un poco diferente. Aquí, tradicionalmente usarías:
```
route add -net 192.168.10.0 netmask 255.255.255.0 dev eth0
route add default gw 192.168.10.1
```

Esto configura la red y la puerta de enlace predeterminada. Sin embargo, en este caso, 192.168.10.1 no sabe nada acerca de la red 10.0.0.0, por lo que tus paquetes se perderían porque 192.168.10.1 no tiene idea de dónde enviar los paquetes y tratará de enviarlos a través de la puerta de enlace predeterminada. Necesitas agregar otra declaración de enrutamiento a cada sistema en la red 192.168.10.0 de la siguiente manera:
```
route add -net 10.0.0.0 netmask 255.0.0.0 gw 192.168.10.25
```

Este comando le dice al kernel que enrutase todos los paquetes destinados a la red 10.0.0.0 a 192.168.10.25, que define como una puerta de enlace. Así que ahora, utilizando los tres comandos de *route*, tu kernel sabrá dónde enviar los paquetes. En esta situación, ocurren algunas cosas:
- Los paquetes a 192.168.10.0 se manejan sin un gateway.
- Los paquetes a 10.0.0.0 se envían a la puerta de enlace definida, 192.168.10.25.
- Los paquetes que viajan a cualquier otro lugar se envían a la puerta de enlace predeterminada, 192.168.10.1.

Cómo configurar y utilizar logrotate para la gestión de archivos de registro en Linux

Usando Linuxconf

El enrutamiento se puede configurar de manera más intuitiva si tienes el programa *Linuxconf* o algo similar disponible.

Con *Linuxconf*, puedes configurar fácilmente el enrutamiento. Para hacerlo, ejecuta *Linuxconf* y selecciona la sección de Networking. Haz clic en Routing And Gateways. Aquí, tienes algunas opciones entre las que puedes elegir.

Primero, deberás configurar los valores predeterminados. Haz clic en el botón Defaults, y define tu puerta de enlace predeterminada ingresando *192.168.10.1*. Si este fuera un enrutador que estás configurando, harías clic en Enable Routing para indicarle al kernel que permita que los paquetes de otros sistemas sean enrutados a través de tu sistema hacia la puerta de enlace definida.

Aquí, también puedes definir rutas a otras redes, rutas a otros hosts y rutas a redes locales alternativas. Para definir rutas a otras redes, usarías el comando *route*. Haz clic en Route To Other Networks y se te mostrará una lista de las rutas definidas actualmente. Haz clic en Add para agregar una nueva ruta.

En la ventana Add New Route, defines la puerta de enlace hacia la otra red, la red de destino y la máscara de red, que es una configuración opcional. En este caso, podrías establecer la puerta de enlace en *192.168.10.25* con la red de destino *10.0.0.0*. Opcionalmente, podrías seleccionar *255.0.0.0* como la máscara de red. Haz clic en Accept para guardar la definición de enrutamiento.

También puedes definir la ruta hacia otro host de manera similar. Por ejemplo, si solo deseas poder comunicarte con la computadora con la dirección IP *10.0.0.28*, podrías seleccionar la opción Route To Other Hosts y agregar una nueva ruta con la puerta de enlace *192.168.10.25* y el destino *10.0.0.28*. De esta manera, no tienes que hacer enrutamiento general, ya que solo estarías tratando con un host. Si deseas comunicarte con más de un host en la red 10.0.0.0, probablemente quieras definir una ruta a toda la red. Esto es útil si tienes múltiples gateways enrutando a diferentes partes de la misma red. Por ejemplo, si *10.0.0.28* se encuentra detrás de un gateway en *192.168.10.125*, mientras que el resto de la red *10.0.0.0* que necesitas está detrás de *192.168.10.25*, podrías definir la puerta de enlace aquí como *192.168.10.125* para el destino *10.0.0.28* y tener la ruta general a *10.0.0.0* definida en la sección Route To Other Networks. Dado que el paquete siempre se enruta con la mejor coincidencia (o el camino más corto), es seguro definir rutas de esta manera.

Cómo instalar y configurar ALSA en Linux: Guía paso a paso

Finalmente, puedes definir otras redes locales en la sección Route To Alternate Local Networks. A diferencia de las definiciones anteriores, esto no funciona pasando por una red definida, sino transmitiendo a través de la interfaz Ethernet definida. Por ejemplo, si estuvieras configurando tu enrutador, la red local definida podría ser *192.168.10.0* para *eth0* y *10.0.0.0* para *eth1*. Podrías definir la interfaz como *eth1*, el destino como *10.0.0.0* y la máscara de red como *255.0.0.0*. Esto le diría al kernel que enrute todo el tráfico a la red *10.0.0.0* directamente a través de la interfaz *eth1* en lugar de pasar por una puerta de enlace.

Otra interfaz probable sería ejecutar una red multinivel donde tu dirección principal está en la red *192.168.10.0* con una dirección secundaria como alias en la red *10.0.0.0*. Por ejemplo, tu dirección principal en *eth0* podría ser *192.168.10.12* y tu alias, que estaría listado como *eth0:0*, podría ser *10.0.0.12*. Definirías la interfaz como *eth0*, el destino como *10.0.0.0* y la máscara de red como *255.0.0.0*. Tu sistema manejaría entonces el tráfico para las redes *192.168.10.0* y *10.0.0.0* de manera transparente.

Sin embargo, en la mayoría de los casos, no necesitarás hacer uso de esto a menos que estés configurando un enrutador o tengas una LAN bastante grande y compleja.

Después de hacer tus cambios en *Linuxconf*, simplemente sal y guarda los cambios. Luego, reinicia tu red usando:
```
/etc/rc.d/init.d/network restart
```

si utilizas *scripts de inicio* en estilo *SysV*. Lo más probable es que, si tienes *Linuxconf* en tu sistema, estés utilizando *scripts de inicio* de esta manera.

Conclusión

Como puedes ver, el enrutamiento no necesariamente tiene que ser un asunto complicado. Las rutas estáticas son las más fáciles de manejar y crear. Con algunos comandos simples, puedes indicarle a tu computadora cómo lidiar con las diferentes redes disponibles para ti.

Consejos rápidos para la navegación de directorios en Linux: cd y pushd

En Newsmatic nos especializamos en tecnología de vanguardia, contamos con los artículos mas novedosos sobre Código abierto, allí encontraras muchos artículos similares a Cómo configurar y optimizar el enrutamiento estático en Linux , tenemos lo ultimo en tecnología 2023.