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
Top Related