Importante es que la interfaz que se agregue en la nube sea el adaptadorVirtualBox Host-Only Network que es eth1 en Linux.

En este punto deberíamos tener ya GNS3 corriendo, VirtualBox con Linux también y los enlaces virtuales conectados.

Ahora veremos la configuración. Partiré por las máquinas Cisco en GNS3:

R1:

!interface FastEthernet0/0ip address 192.168.0.1 255.255.255.0duplex autospeed auto

!interface Serial0/0ip address 10.0.0.2 255.255.255.252clock rate 2000000!router ospf 1router-id 1.1.1.1log-adjacency-changesnetwork 10.0.0.0 0.0.0.3 area 0network 192.168.0.0 0.0.0.255 area 0!

R2:

!interface Loopback0ip address 200.200.200.200 255.255.255.255!interface Serial0/0ip address 10.0.0.1 255.255.255.252

clock rate 2000000!router ospf 1router-id 2.2.2.2log-adjacency-changesnetwork 10.0.0.0 0.0.0.255 area 0network 200.0.0.0 0.255.255.255 area 0!

Hasta ese punto debería haber conectividad completa entre R1 y R2. Probamos haciendo ping desde R1 a la interfaz Loopback0 de R2:

R1#ping 200.200.200.200

Type escape sequence to abort.Sending 5, 100-byte ICMP Echos to 200.200.200.200, timeout is 2 seconds:!!!!!Success rate is 100 percent (5/5), round-trip min/avg/max = 4/66/132 msR1#

A continuación vamos a levantar OSPF en Linux. Para esto utilizaremos Quagga, el cual se puede descargar fácilmente mediante apt-get. Por eso es importante que la interfaz eth0 de Linux siga con conexión a Internet.

root@router :~# apt-get update && apt-get install quagga

Configuramos la interfaz de red eth1 que es la que se conectará con nuestro router Cisco R1 en GNS3 con la IP 192.168.0.2/24 y como puerta de enlace 192.168.0.1 (FastEthernet 0/0 de R1). Lo demás queda intacto

 root@router:~# nano /etc/network/interfaces

——————————————————————–

# The loopback network interfaceauto loiface lo inet loopback

# The primary network interfaceallow-hotplug eth0iface eth0 inet dhcp

auto eth1iface eth1 inet staticaddress 192.168.0.2netmask 255.255.255.0gateway 192.168.0.1

———————————————————————

Aquí ya deberíamos tener conexión de capa 3 en enlace virtual entre Debian y R1. Subimos la interfaz eth1 y probamos con un ping:

root@router:~# ifup eth1root@router:~# ping 192.168.0.1PING 192.168.0.1 (192.168.0.1) 56(84) bytes of data.64 bytes from 192.168.0.1: icmp_req=1 ttl=255 time=68.8 ms64 bytes from 192.168.0.1: icmp_req=2 ttl=255 time=44.0 ms64 bytes from 192.168.0.1: icmp_req=3 ttl=255 time=52.2 ms^C— 192.168.0.1 ping statistics —3 packets transmitted, 3 received, 0% packet loss, time 2004msrtt min/avg/max/mdev = 44.022/55.015/68.818/10.319 msroot@router:~#

Perfecto. El enlace entre Linux y GNS3 funciona! Ahora, a configurar el enrutamiento OSPF en Debian. Hay que decir que Quagga contiene soporte para varios protocolos de enrutamiento como BGP (muy interesante), OSPFv2, OSPFv3 para IPv6 y RIP. Para nuestro ejemplo utilizaremos dos: Zebra y OSPF, el primero se encargará de habilitar las interfaces de Linux para el enrutamiento dinámico.

El directorio de configuración de Quagga es /etc/quagga/.

1. Lo primero que haremos será copiar los archivos de configuración de ejemplo de OSPF y Zebra a /etc/quagga:

root@router:~# cp /usr/share/doc/quagga/examples/zebra.conf.sample /etc/quagga/zebra.conf

root@router:~# cp /usr/share/doc/quagga/examples/ospfd.conf.sample /etc/quagga/ospfd.conf

Importante es que estos archivos puedan ser leídos por el usuario quagga. Aplicamos los permisos correspondientes:

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

2. Editamos /etc/quagga/zebra.conf :

! -*- zebra -*-!! zebra sample configuration file!! $Id: zebra.conf.sample,v 1.1 2002/12/13 20:15:30 paul Exp $!hostname Routerpassword zebraenable password zebra!! Interface’s description.!!interface lo! description test of desc.!!interface sit0! multicastinterface eth1ip address 192.168.0.2/24no shutdown!! Static default route sample.!!ip route 0.0.0.0/0 203.181.89.241!

log file /var/log/quagga/zebra.log

La sintaxis de los archivos *.conf de Quagga tienen el mismo formato que los comandos de los routers Cisco, por lo que les parecerá muy familiar. Lo que he hecho en zebra.conf es habilitar la interfaz eth1 con la misma IP que ya tenía en la configuración de Linux.

3. Ahora abrimos /etc/quagga/ospfd.conf y declaramos las redes que participarán en OSPF, al igual que un router Cisco:

! -*- ospf -*-!! OSPFd sample configuration file!!hostname ospfdpassword zebra!enable password please-set-at-here!router ospfospf router-id 3.3.3.3network 192.168.0.0/24 area 0.0.0.0

log syslog!

Como ven, el entorno es familia ¿no?. He declarado el router-id de Linux como 3.3.3.3 y agregué la red 192.168.0.0 /24 al proceso de enrutamiento en el area 0 (también se puede poner area 0. O el área 1 sería: area 0.0.0.1). Luego enviamos logs al syslog por si algo no anda bien.

4. En el archivo /etc/quagga/daemons indicamos que servicios o protocolos de enrutamiento ejecutaremos. Indicamos con la opción =”yes” en Zebra y OSPF:

zebra=yesbgpd=noospfd=yesospf6d=noripd=noripngd=noisisd=no

5. Luego reiniciamos el servicio Quagga y éste debería levantar Zebra y OSPF:

#/etc/init.d/quagga restart

6. Comprobamos en R1 que se haya levantado la adyacencia con el vecino 3.3.3.3 que sería nuestro Debian:

R1#*Mar 1 03:06:52.919: %OSPF-5-ADJCHG: Process 1, Nbr 3.3.3.3 on FastEthernet0/0 from LOADING to FULL, Loading DoneR1#

7. Ya podríamos desde Linux entonces hacer ping a la interfaz Loopback de R2 en el otro extremo de la red. Antes comprobamos que la red 200.200.200.200/32 exista en la tabla de enrutamiento de Linux:

root@router:~# route -nKernel IP routing tableDestination Gateway Genmask Flags Metric Ref Use Iface200.200.200.200 192.168.0.1 255.255.255.255 UGH 75 0 0 eth110.0.0.0 192.168.0.1 255.255.255.252 UG 74 0 0 eth110.0.2.0 0.0.0.0 255.255.255.0 U 0 0 0 eth0192.168.0.0 0.0.0.0 255.255.255.0 U 0 0 0 eth10.0.0.0 192.168.0.1 0.0.0.0 UG 0 0 0 eth10.0.0.0 10.0.2.2 0.0.0.0 UG 0 0 0 eth0root@router:~# ping 200.200.200.200 -c 3PING 200.200.200.200 (200.200.200.200) 56(84) bytes of data.64 bytes from 200.200.200.200: icmp_req=1 ttl=254 time=98.4 ms64 bytes from 200.200.200.200: icmp_req=2 ttl=254 time=57.3 ms64 bytes from 200.200.200.200: icmp_req=3 ttl=254 time=66.0 ms

— 200.200.200.200 ping statistics —3 packets transmitted, 3 received, 0% packet loss, time 2002msrtt min/avg/max/mdev = 57.314/73.941/98.463/17.703 msroot@router:~#

Y eso es todo. ¿Fácil no?. Como complemento podemos levantar una sesión Telnet dentro de Linux hacia el servicio Quagga y controlar el enrutamiento en una consola muy similar a la CLI de Cisco. Los puertos de Telnet son los siguientes:

Zebra:   2601

RIPd:       2602

RIPng:    2603

OSPFd:   2604

BGPd:     2605

OSPF6d: 2606

Para entrar a configurar OSPF en tiempo real al más puro estilo Cisco, levantamos una sesión Telnet local al puerto 2604. La contraseña por defecto es zebra (tal como aparece en ospfd.conf)

 root@router:~# telnet 127.0.0.1 2604Trying 127.0.0.1…Connected to 127.0.0.1.Escape character is ‘^]’.

Hello, this is Quagga (version 0.99.17).Copyright 1996-2005 Kunihiro Ishiguro, et al.

User Access Verification

Password:ospfd>?echo Echo a message back to the vtyenable Turn on privileged mode commandexit Exit current mode and down to previous modehelp Description of the interactive help systemlist Print command listquit Exit current mode and down to previous modeshow Show running system informationterminal Set terminal line parameterswho Display who is on vtyospfd> enospfd#

Ya con eso pueden luego implementar configuraciones más complejas como escenarios multiárea, OSPFv3 con IPv6 y BGP.

Para más información consulten la página oficial de Quagga http://www.quagga.net/docs/docs-info.php

//

RIP v2 en Linux con Quagga

miércoles, 13 de abril de 2011 en 16:21 Publicado por Jesús M.

¡Hola!

Hoy vamos a ver cómo se configura el encaminamiento dinámico en routers Linux, ya que no lo soportan

de forma nativa. Para ello vamos a utilizar la suite Quagga, que incorpora implementaciones de OSPFv2,

OSPFv3, RIP v1 y v2, RIPng y BGP-4 para plataformas Unix (FreeBSD, Linux, Solaris y NetBSD) y

permite modificar la configuración de los equipos a través de las órdenes típicas del Cisco IOS.

Arquitectura de Quagga

Quagga está compuesto por varios daemons que trabajan de forma colaborativa para construir la tabla de

encaminamiento. Por ejemplo, el daemon ripd maneja el protocolo RIP, mientras el daemon ospfd es el

que soporta el protocolo OSPF. Para realizar los cambios en la tabla de encaminamiento del kernel y para

la redistribución de las rutas entre diferentes protocolos, se utiliza el daemon zebra.

Instalación

Si quisiéramos realizar una instalación en producción con una configuración compleja, sería preferible

descargar el código para configurarlo y compilarlo con las opciones deseadas. Para este ejemplo, sin

embargo, instalaremos el paquete disponible en el repositorio de Debian.

#aptitude install quagga

Los daemons de quagga tienen su propio terminal o VTY (un CLI) al que nos conectaremos por telnet

para su configuración. Tras la instalación, podemos comprobar cómo se han añadido al fichero

/etc/services las siguientes entradas:

Configuración de RIPv2

La primera tarea consiste en editar el fichero /etc/quagga/daemons para activar los protocolos que

queremos configurar en nuestra máquina y reiniciar el servicio:

#nano /etc/quagga/daemons

zebra=yes

bgpd=no

ospfd=no

ospf6d=no

ripd=yes

ripngd=no

#/etc/init.d/quagga restart

A continuación tenemos que crear un fichero de configuración para cada daemon activado. Cada daemon

tiene asociado un fichero con un nombre específico:

zebra:

bgpd:

ospfd:

ospf6d:

ripd:

ripngd:

zebra.conf

bgpd.conf

ospfd.conf

ospf6d.conf

ripd.conf

ripngd.conf

Para crear los ficheros de configuración, podemos copiar los archivos de ejemplo que incorpora la

documentación:

#cp /usr/share/doc/quagga/examples/zebra.conf.sample /etc/quagga/zebra.conf

#cp /usr/share/doc/quagga/examples/ripd.conf.sample /etc/quagga/ripd.conf

Para terminar, tenemos que cambiar los permisos, el propietario y el grupo de estos ficheros:

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

#chmod 640 /etc/quagga/*.conf

Y reiniciamos el servicio:

#/etc/init.d/quagga restart

Ya podemos comenzar a configurar el encaminamiento dinámico, para lo que nos conectaremos por

telnet al VTY del daemon ripd. Nos pedirá una contraseña: por defecto es zebra, pero puedes cambiarla

en el fichero /etc/quagga/ripd.conf:

#telnet localhost ripd

Trying ::1...

Trying 127.0.0.1...

Connected to localhost.

Escape character is '^]'.

Hello, this is Quagga (version 0.99.15).

Copyright 1996-2005 Kunihiro Ishiguro, et al.

User Access Verification

Password:

ripd>

Y ya podríamos configurar nuestra máquina Linux para trabajar con RIP usando los comandos típicos del

Cisco IOS:

ripd> enable

ripd# configure terminal

ripd(config)# router rip

ripd(config-router)# network 10.0.0.0/8

ripd(config-router)# network 20.0.0.0/8

ripd(config-router)# exit

ripd(config)# exit

ripd# write

Configuration saved to /etc/quagga/ripd.conf

Aquí puedes encontrar todas las opciones de configuración de RIP con Quagga, pero si lo has hecho

alguna vez con un router Cisco verás que las órdenes son prácticamente iguales. Aquí tienes la guía de

configuración de RIP en dispositivos Cisco.

NOTA: ¡no olvides activar el bit de forwarding para que tu máquina enrute!

#echo "1" > /proc/sys/net/ipv4/ip_forward

Y si quieres que perdure tras un reinicio:

#echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.conf

//

Instalación de Quagga en Ubuntu

Esta instalación ha sido probada en:

Ubuntu 6.06 Dapper Drake Ubuntu 6.10 Edgy Ubuntu 7.04 Feisty Fawn

Instalamos quagga usando apt. Primero entraremos en modo root para no estar haciendo sudo constantemente.

sudo -s

apt-get install quagga

Se instalarán los siguientes paquetes NUEVOS:quaggaPreconfigurando paquetes …Seleccionando el paquete quagga previamente no seleccionado.(Leyendo la base de datos …100348 ficheros y directorios instalados actualmente.)Desempaquetando quagga (de …/quagga_0.99.6-2ubuntu3.1_i386.deb) …grep: /etc/quagga/*.conf: No existe el fichero ó directorioConfigurando quagga (0.99.6-2ubuntu3.1) …

Loading capability module if not yet done.Starting Quagga daemons (prio:10):.

Ponemos los ficheros de configuración de quagga en su sitio.

cd /usr/share/doc/quagga/examples/

cp * /etc/quagga/

Renombramos los ejemplos de configuración, para usarlos y activar Quagga con la configuración por defecto.

cd /etc/quagga/

cp zebra.conf.sample zebra.conf

cp ripd.conf.sample ripd.conf

Configuramos los demonios para que active zebra, y por el momento RIP, aunque se hace de igual modo para los demás protocolos.

vim daemons

Editamos las línas:

zebra=yes

ripd=yes

Así hemos marcado que queremos que Quagga arranque los demonios zebra y ripd (Que se encarga de RIP). Para que cargue de nuevo la configuración, reiniciamos Quagga.

/etc/init.d/quagga restart

Stopping Quagga daemons (prio:0): (ripd) (zebra) (bgpd) (ripngd) (ospfd) (ospf6d) (isisd).

Removing all routes made by zebra.

Nothing to flush.

Loading capability module if not yet done. Starting Quagga daemons (prio:10): zebra ripd.

Ahora podremos acceder por separado con una interfaz interactiva a cada uno de los demonios. Para acceder a Zebra (Password por defecto zebra):

telnet localhost 2601

Para acceder al demonio de RIP (ripd) y configurarlo:

telnet localhost 2602

Configurando Zebra

Zebra es el demonio gerente. Los demonios que se encargan de los protocolos de enrutamiento son: ripd, ripngd, ospfd, ospf6d, bgpd.

telnet localhost 2601

Password: zebra

Podemos configurar Zebra editando el fichero de configuración zebra.conf o bien accediendo al demonio y por diversos comandos. Antes que nada con el signo de interrogación ? obtenemos una ayuda contextual de las posibilidades que se va clasificando, es decir, si ponemos ? nada más entrar, nos dice los posibles comandos que tenemos, pero si escribimos

debug ?

Nos informa sobre los modificadores del comando debug en concreto. Esto es importante que quede claro, porque nos va a servir de mucho al principio, hasta que vayamos aprendiendo las principales instrucciones.

Un ejemplo, cambiemos el nombre de host del router, ¿para qué? Imaginemos una red de más de 10.000 ordenadores, dividida en subredes comunicadas entre unos cuantos routers, ¿no sería útil que cada router tuviera un prompt distinto? Así podríamos configurar varios a la vez sin tener que recordar que vty corresponde a cada router. Vamos con ello:

enable

Password: zebra

Hemos entrado en el modo privilegiado y salido del modo usuario, ahora entraremos en el modo configuración. Estos son los únicos 3 modos existentes.

configure terminal

Algunos estaréis pensando que se parece mucho a Cisco, pues sí. La sintaxis es en un 95% aproximadamente idéntica a la de un Cisco, aunque Quagga tiene algunas configuraciones que un router Cisco no dispone. Así del mismo modo, podemos abreviar comandos:

config t

Si ahora hacemos un ‘?’:

hostname -----> Set system's network name

Creo que resulta claro, que esto es lo que estábamos buscando. Así que:

hostname CHINI

Y después de darle al intro, veremos como el prompt del router se actualiza. Ahora grabamos la nueva configuración del router en el fichero estático zebra.conf. Para ello tecleamos el comando:

write memory

También podemos usar el antiguo comando respetado en versiones posteriores por Cisco:

wr

El router nos informará de que la configuración se guardó:

Configuration saved to /etc/quagga/zebra.conf