Page locked

This page is currently locked for editing by another user. You have to wait until this user finishes editing or the lock expires.
Currently locked by: 192.168.200.11,192.168.10.1
Lock expires at: 2025/12/10 00:43 (15 min)
This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Cisco ======

Para configurar un dispositivo Cisco, hay que entrar en modo de administración. Esto se hace con `enable`:
```
Router>enable
Router#
```

Una vez en modo administrativo, cambia el prompt de `>` a `#`. 

En este modo, podemos ver bastantes cosas y configurar alguna, pero por lo general, será insuficiente. 

===== Router =====

Los routers tienen varios interfaces. También, según modelo, tiene unos módulos precargados, con su firmware y sus interfaces. Usaremos básicamente 3 modelos:
  * El modelo 2901, que trae un módulo con 2 interfaces Gigabit. Para serial, hay que añadir un módulo adicional (`HWIC-2T`), en caso de ser necesario.
  * El modelo PT (o PT empty), que es totalmente configurable y puede tener muchos módulos Gigabit.
  * El modelo 2811, el único que soporta telefonía.

==== Comandos en modo administrativo ====

Como ayuda, siempre podremos pulsar la interrogación `?` (no hace falta ni pulsar Enter) para ver los comandos disponibles:

```
Router#?
Exec commands:
  <1-99>      Session number to resume
  auto        Exec level Automation
  clear       Reset functions
  clock       Manage the system clock
  configure   Enter configuration mode
  connect     Open a terminal connection
  copy        Copy from one file to another
  debug       Debugging functions (see also 'undebug')
  delete      Delete a file
  dir         List files on a filesystem
  disable     Turn off privileged commands
  disconnect  Disconnect an existing network connection
  enable      Turn on privileged commands
  erase       Erase a filesystem
  exit        Exit from the EXEC
  logout      Exit from the EXEC
  mkdir       Create new directory
  more        Display the contents of a file
  no          Disable debugging informations
  ping        Send echo messages
  reload      Halt and perform a cold restart
  resume      Resume an active network connection
  rmdir       Remove existing directory
  send        Send a message to other tty lines
  setup       Run the SETUP command facility
  show        Show running system information
  ssh         Open a secure shell client connection
  telnet      Open a telnet connection
  terminal    Set terminal line parameters
  traceroute  Trace route to destination
  undebug     Disable debugging functions (see also 'debug')
  vlan        Configure VLAN parameters
  write       Write running configuration to memory, network, or terminal
```

También se puede usar dentro de cada opción, para ver las opciones secundarias.


Podemos usar el tabulador para completar un comando después de escribir al menos los 3 primeros caracteres:

```
Router#conf
Router#configure ter
Router#configure terminal 
Enter configuration commands, one per line.  End with CNTL/Z.
Router(config)#
```

En este modo, principalmente se pueden usar comandos `show`:

=== Ver las ip de las interfaces ===


```
Router#show ip interface brief
Interface              IP-Address      OK? Method Status                Protocol 
GigabitEthernet0/0     192.168.10.1    YES manual up                    up 
GigabitEthernet0/1     192.168.20.1    YES manual up                    up 
Vlan1                  unassigned      YES unset  administratively down down
```

=== Ver la configuración actual ===

```
Router#show running-config 
Building configuration...

Current configuration : 984 bytes
!
version 16.6.4
no service timestamps log datetime msec
no service timestamps debug datetime msec
no service password-encryption
!
hostname Router
!
!
interface GigabitEthernet0/0
 ip address 192.168.10.1 255.255.255.0
 duplex auto
 speed auto
!
interface GigabitEthernet0/1
 no ip address
 duplex auto
 speed auto
!
interface Vlan1
 no ip address
 shutdown
!
!
end
```

Se han omitido algunas líneas.

=== Guardar la configuración ===

Se usa el comando `write memory` (sólo en este modo):

```
Router#write memory 
Building configuration...
[OK]
Router#
```



==== Entrar en modo configuración ====

Desde el modo administración, entraremos al modo configuración con `configure terminal`:

```
Router#
Router#configure terminal
Enter configuration commands, one per line.  End with CNTL/Z.
Router(config)#
```

En general, observaremos que el prompt cambia según estemos en un modo u otro. También, dentro del modo de configuración, cambiará el prompt según el submenú en el que estemos.


==== Asignar una ip a una interfaz ====

=== Sin VLAN específica ===


En general, para trabajar con una interfaz, primero tenemos que entrar en esa opción mediante el comando `interface` seguido de la interfaz. Se puede usar el nombre largo o el nombre corto(`int`), que se muestra al tener un cable conectado. El nombre NO es sensible a mayúsculas:

```
Router(config)#interface gig0/0
Router(config-if)#exit
Router(config)#int gigabitEthernet 0/0
Router(config-if)#
```

Las dos formas entran en el mismo interfaz, `gig0/0` o `gigabitEthernet 0/0` (se puede omitir el espacio entre el nombre y el número dentro del interfaz). Vemos que cambia el prompt a `(config-if)`.

Ahora, asignamos la ip principal, con su máscara de red:

```
Router(config-if)# ip address 192.168.1.1 255.255.255.0
Router(config-if)#
```

Si todo ha ido correcto, no muestra ningún error.

Después de asignar la ip, conviene decirle al dispositivo que levante la interfaz, que por defecto está bajado. Esto se hace con el comando `no shutdown`. Veremos mensajes relativos al cambio de estado de la interfaz, si estuviera bajada:

```
Router(config-if)#no shutdown

Router(config-if)#
%LINK-5-CHANGED: Interface GigabitEthernet0/0, changed state to up

%LINEPROTO-5-UPDOWN: Line protocol on Interface GigabitEthernet0/0, changed state to up
```
=== Múltiples IP es la misma interfaz lógica ===

Se pueden asignar más de una ip a la misma interfaz, haciendo lo mismo, pero añadiendo al final `secondary`.

=== Encapsulado para VLAN ===

Cuando hay que configurar múltiples ip para distintas VLAN, hay que encapsular. Para ello, procedemos de la siguiente forma:
  - Accedemos a la interfaz principal, y no le asignamos ip: `no ip address`. Opcionalmente, la levantamos con `no shutdown`.
  - Después, accedemos a la subinterfaz añadiendo `.<VLAN>`. Es decir, para la interfaz gig0/0 y la VLAN 10, sería `interface gig0/0.10`. Debería levantarse inmediatamente.
  - En la subinterfaz, asignamos primero la encapsulación con el número de VLAN, es decir `encapsulation dot1Q 10`.
  - Por último, asignamos la dirección ip, igual que si fuera la principal, con `ip address <ip> <mask>`.
  - Repetimos los pasos para las otras subinterfaces, pero con su VLAN, con su número y su dirección IP.
  - Si no levantamos la interfaz principal en su momento, lo hacemos ahora con `no shutdown`. Debería levantar todas las subinterfaces.


```
Router(config)#int gig0/0
Router(config-if)#no ip address
Router(config-if)#no shutdown
Router(config-if)#int gig0/0.10
Router(config-subif)#encapsulation dot1Q 10
Router(config-subif)#ip address 192.168.1.1 255.255.255.0
Router(config-subif)#int gig0/0.20
Router(config-subif)#encapsulation dot1Q 20
Router(config-subif)#exit
```


==== Enrutado ====

Hay varios tipos de enrutado.

=== Enrutado estático ===

Consiste en decirle de forma explícita por dónde tiene que enrutar a una red de destino. La salida puede ser una ip o el interfaz local. No hay que entrar en ninguna interfaz:

```
Router(config)# ip route 0.0.0.0 0.0.0.0 Gig0/0
Router(config)# ip route 10.1.0.0 255.255.0.0 172.16.1.1
```

=== Enrutado por RIPv2 ===

El enrutado por RIPv2 está basado en que en una red donde hay varios routers, se comunican y se anuncian las redes que cada cual conoce, para aprenderlas de forma dinámica. A pesar de que el router conozca sus redes, tiene que habilitar la opción que se va a comunicar con otros routers y decirles qué redes conoce.

```
Router(config)#router rip
Router(config-router)#version 2
Router(config-router)#network 192.168.10.0
```

=== Enrutado por Eigrp ===

El enrutado eigrp se basa en crear un "Sistema autónomo" (AS), con una numeración única entre 1 y 65535. Cada AS anuncia las redes que tiene a los routers vecinos que lo requieran, siendo lo más habitual que cada router que quiera tener conocimiento de un AS, tiene que configurarse con ese AS y anunciar todas las rutas asociadas a sus interfaces. Se inicia con el comando `router eigrp <AS>` en modo configuración. No hay que asociarlo a ningún interfaz. Ejemplo básico:

```
Router(config)#router eigrp 10
Router(config-router)#network 192.168.10.64 0.0.0.31
Router(config-router)#network 192.168.10.132 0.0.0.3
Router(config-router)#network 192.168.10.136 0.0.0.3
Router(config-router)#no auto-summary

```

El segundo parámetro de `network` es la //wildmask//. La forma más simple de entenderlo es que es justo lo contrario de la máscara de subred, es decir, cada octeto es el resultado de restar a 255 el octeto de la máscara de subred. En firmware modernos, es posible que se acepte la máscara de subred directamente, y ya el firmware la traduce a una wildmask. Finalmente, conviene añadir siempre el comando `no auto-summary`. Esto impide que, en casos de subnetting, se unifiquen esas subredes en redes más amplias, ignorando la especificidad que se pudiera haber definido de forma explícita.


Desde el punto de vista de eigrp, sólo "conoce" las redes que, de forma explícita, se configuran dentro del AS. Esto quiere decir que, a pesar de conocer las rutas locales que tiene por asociar ip al interfaz, si no se incluyen de forma explícita, no se distribuyen por eigrp. Esto incluye la interfaz que puede conectar directamente dos routers.

En otro router, se inicia otra sección con el mismo AS, y cuando se dé de alta la interfaz común, se conectarán por eigrp y se compartirán las rutas anunciadas. Estas rutas podrán verse con el comando `show ip route` en modo administrativo (`do show ip route` en modo configuración).

```
R2(config)#do show ip route
Codes: L - local, C - connected, S - static, R - RIP, M - mobile, B - BGP
       D - EIGRP, EX - EIGRP external, O - OSPF, IA - OSPF inter area
       N1 - OSPF NSSA external type 1, N2 - OSPF NSSA external type 2
       E1 - OSPF external type 1, E2 - OSPF external type 2, E - EGP
       i - IS-IS, L1 - IS-IS level-1, L2 - IS-IS level-2, ia - IS-IS inter area
       * - candidate default, U - per-user static route, o - ODR
       P - periodic downloaded static route

Gateway of last resort is not set

     192.168.10.0/24 is variably subnetted, 9 subnets, 4 masks
D       192.168.10.0/26 [90/2172416] via 192.168.10.133, 00:05:05, Serial0/0/0
C       192.168.10.64/27 is directly connected, GigabitEthernet0/0.20
L       192.168.10.65/32 is directly connected, GigabitEthernet0/0.20
D       192.168.10.96/27 [90/2172416] via 192.168.10.138, 00:05:08, Serial0/0/1
D       192.168.10.128/30 [90/2172416] via 192.168.10.133, 00:05:05, Serial0/0/0
C       192.168.10.132/30 is directly connected, Serial0/0/0
L       192.168.10.134/32 is directly connected, Serial0/0/0
C       192.168.10.136/30 is directly connected, Serial0/0/1
L       192.168.10.137/32 is directly connected, Serial0/0/1
```

Las líneas que comienzan por `D` o `EX` son las 'heredadas' por eigrp de otros routers.

== Configuración con distintos AS ==

Para anunciar rutas entre distintos AS, tenemos el comando `redistribute`, que se ubica dentro de la configuración del AS. La sintaxis es:
```
redistribute eigrp <AS> metric <bandwith> <delay> <reliability> <load> <MTU>
```

  * **AS**: Sistema autónomo de origen que se quiere redistribuir.
  * **bandwidth**: Normalmente `10000`. Ancho de banda (en kilobits por segundo) — se usa para calcular la velocidad del enlace.
  * **delay**: Normalmente `100`. Retardo (en decenas de microsegundos). Ejemplo: 100 = 1 ms.
  * **reliability**: Normalmente `255`. Confiabilidad del enlace (1–255). 255 = 100% confiable.
  * **load**: Normalmente `1`. Carga actual (1–255). 1 = enlace sin congestión.
  * **MTU**: Normalmente `1500`. Tamaño máximo de unidad de transmisión (bytes). Solo se incluye para compatibilidad; EIGRP no lo usa en el cálculo.

Cuando tenemos varios routers con distintos AS, el principio es parecido, pero con dos diferencias:
  - Añadir en la sección del AS propio una línea para redistribuir las rutas del AS anterior (de cara a otros routers):

```
Router(config)#router eigrp 200
Router(config-router)#redistribute eigrp 100 metric 10000 100 255 1 1500 
Router(config-router)#network 10.1.12.0 0.0.0.3
Router(config-router)#network 10.1.23.0 0.0.0.3
Router(config-router)#network 10.102.2.0 0.0.0.255
```
  - En el mismo router, añadir una sección haciendo referencia al AS anterior, pero tiene que importar las rutas propias para poder tenerlas. Aquí hay que poner la interfaz que comunica los AS.

```
Router(config)#router eigrp 100
Router(config-router)#redistribute eigrp 200 metric 10000 100 255 1 1500 
Router(config-router)#network 10.1.12.0 0.0.0.3
```






=== OSPF ===

El enrutamiento OSPF (Open Shortest Path First) es un protocolo de enrutamiento dinámico. Calcula el camino más corto usando el algoritmo SPF (Dijkstra).
El principio básico es que se parte de un área (la 0) y los routers del mismo área se comunican las rutas.

Cada router, en OSPF, tiene un router ID (RID). 
El RID es un identificador lógico único dentro del dominio OSPF, no del área.

Es un número de 32 bits con formato de dirección IP (por ejemplo, 1.1.1.1 o 192.168.255.1),
pero no tiene por qué ser una IP real o asignada a ninguna interfaz.

Se puede configurar manualmente en un process ID. Usaremos el process ID 10 como ejemplo:

```
R1(config)#router ospf 10
R1(config-router)#router-id 1.1.1.1
```
<note>
El process ID es un número entre 1 y 65535 que cada router usa internamente para su base de datos. Para comunicarse con otros routers, lo que se usa es el área 0. El process ID no tiene por qué coincidir entre routers del mismo área.
</note>
<note>
No se puede configurar mediante `router ospf <processID>` sin tener ninguna interfaz configurada, ya que el packet tracer muestra error.
</note>


Si el RID no está configurado, usa la IP más alta de una interfaz Loopback (si existe).

Si no hay loopback, usa la IP más alta de las interfaces activas.

<note>
Si el RID cambia, hay que reiniciar el proceso OSPF (`clear ip ospf process`) para que se aplique.
</note>

Cuando hay varios routers en el mismo área, el que tenga el RID más alto, toma el rol de router designado (DR) y el siguiente menos alto es el backup del router designado (BDR). El resto de routers toman el rol DROTHER. El DR se encarga de recoger las rutas y, para no cargar el tráfico, es el que se encarga de repartir las rutas a los routers del mismo área. Si por algún motivo el DR no está disponible, el BDR se convierte en DR, y el DROTHER con RID siguiente se convierte en BDR.

OSPF tiene 2 modos: área única y multiárea.




== OSPF de área única ==

Hay 2 formas de configurar el enrutamiento: usando `ip ospf <processID> area <area>` en cada interfaz, o definiendo las rutas explícitamente, de forma muy parecida a eigrp.

En cada interfaz:

```
R1(config)#interface GigabitEthernet 0/0/0 
R1(config-if)#ip address 192.168.10.1 255.255.255.0
R1(config-if)#ip ospf 10 area 0
R1(config-if)#no shutdown
R1(config-if)#interface GigabitEthernet 0/0/1 
R1(config-if)#ip address 192.168.11.1 255.255.255.0
R1(config-if)#no shutdown
R1(config-if)#ip ospf 10 area 0 
```

Opcionalmente, y siempre después de haber asignado direciones ip, asignamos el router-id:

```
R1(config)#router ospf 10
R1(config-router)#router-id 1.1.1.1
```


La otra forma, publicando manualmente las rutas, con wildmask y área:
```
R1(config)#router ospf 10
R1(config-router)#router-id 1.1.1.1
R1(config-router)#network 192.168.10.0 0.0.0.255 area 0
R1(config-router)#network 192.168.11.0 0.0.0.255 area 0
R1(config-router)#exit
```

<note>
Se puede usar una contraseña para proteger la distribución de las rutas. Para ello, en cada interfaz de cada router, hay que poner:
```
Router(config-if)#ip ospf message-digest-key 1 md5 clavesecreta
Router(config-if)#ip ospf authentication message-digest
```

donde //clavesecreta// es la clave en claro. No hay forma de ocultarla después al ver la configuración.
</note>

== OSPF multiárea ==

Mientras que en redes pequeñas es más sencillo usar un area única, cuando el tamaño de las redes crece, se hace más necesario, y a veces imprescindible, usar más de un área. Esto es por varios motivos:
  * Los recursos de un único router sin limitados, y muchas rutas pueden llegar a agotar la memoria
  * El tiempo empleado en usar el algoritmo SPF cuando hay un cambio, puede hacer que ralentice la operativa o que el propio router se sature.
  * El router recibe un número de peticiones LSA que no puede asumir.

Por ello, se establece un mecanismo donde haya varias áreas, y al dividir el trabajo, la carga y las responsabilidades, se reduce la cantidad de información que tiene que manejar cada router, y el resultado es una mayor eficacia.

En general, la implementación es muy parecida a la de área única. La diferencia principal es que se establece un área 0, que hace de intermediario entre todas las áreas.

<note>Si no hay un área 0, no habrá comunicación de enrutamiento entre el resto de áreas.
</note>




==== Servidor DHCP ====

Para configurar un router como servidor DHCP, el procedimiento consta de los siguientes pasos:
  - Configurar la interfaz (es decir, que tenga su ip) por la que se va a recibir una petición DHCPREQUEST.
  - Definir los rangos de exclusión. Esto se hace con `ip dhcp excluded-address <iporigen> [<ipfinal>]`.
  - Definir un pool con nombre. Dentro del pool definimos:
    - La red que cubre
    - El gateway de la red
    - Opcionalmente, el servidor dns.
    - Existen muchas opciones avanzadas, opcionales también.


```
Router(config)#ip dhcp excluded-address 192.168.0.1 192.168.0.10

Router(config)#ip dhcp pool POOL
Router(dhcp-config)#network 192.168.0.0 255.255.255.0
Router(dhcp-config)#default-router 192.168.0.1
Router(dhcp-config)#dns-server 192.168.1.5
```

Podemos definir múltiples `pool`. Una vez definidos, ya entran automáticamente a funcionar, sin aplicar a ninguna interfaz.

=== DHCP Relay ===


También se puede hacer DHCP relay a otro servidor DHCP que está en otro sitio. El servidor DHCP tiene que tener previamente configurados los pool correspondientes a las redes que va a recibir peticiones. En este caso, además de tener conexión con ese servidor, hay que hacer dos cosas:
  - Averiguar la dirección IP del servidor DHCP para cada red a la que esté conectada el router.
  - En la interfaz o subinterfaz que tiene la ip de gateway y que sirve a la red, poner una línea `ip helper-address <ipservidor>`, poniendo la ip del servidor dhcp.


==== NAT ====

NAT (Network Address Translation) es una técnica que consiste en reescribir o traducir una dirección (a veces también el puerto) en otra con la intención de que la dirección reescrita esté al alcance del siguiente salto. De esta forma, se permite comunicar redes sin tener que habilitar todas las rutas en todos los sentidos.

En este proceso, se distinguen cuatro conceptos:

|Inside Local (IL)|La dirección IP privada (RFC 1918) asignada a un host dentro de la red local (inside) que inicia la comunicación. Esta es la dirección real del dispositivo antes de cualquier traducción.|
|Inside Global (IG)|La dirección IP pública que representa al host de la red interna (inside) cuando se comunica con la red externa (Internet). Es la dirección después de que el router ha realizado la traducción.|
|Outside Local (OL)|La dirección IP del host de destino en la red externa (outside) vista por el host interno. En la práctica, suele ser la dirección IP real (pública) del host de destino.|
|Outside Global (OG)|La dirección IP del host de destino en la red externa (outside) vista por el resto de la red global. En la mayoría de los casos, la Outside Local y la Outside Global son idénticas (la IP pública del servidor web), ya que el dispositivo externo no necesita ser traducido por el NAT de su red.|

Desde el punto de vista de Cisco, hay tres tipo de NAT: estático, dinámico y con sobrecarga.

En un router, de forma general, hay que configurar el interfaz que comunica la red interna con `ip nat inside`, para traducir el tráfico que le llega desde el interior con destino al exterior. Por otro lado, el interfaz que comunica con el exterior, hay que configurarlo con `ip nat outside`, para recoger el tráfico que proviene del exterior y hacer la traducción que coresponda, así como enviar el tráfico traducido hacia el exterior. El interfaz con `ip nat inside` gestiona las "Local", y el interfaz con `ip nat outside` gestiona las "Global", según su tabla de direcciones NAT.


Se puede ver la tabla de traducciones con `[do] show ip nat translation`.


=== NAT estático ===

El NAT estático está diseñado principalmente para el mapeo bidireccional entre una dirección IP privada y una IP pública.

Su uso más común es recibir tráfico del exterior. El tráfico que llega a una IP pública específica (IG) se traduce a una IP privada interna fija (IL), generalmente para publicar un servidor o servicio.

El mismo host interno, al generar tráfico saliente al exterior, utiliza su IP privada (IL), y el router la traduce a la misma IP pública fija (IG).


**IMPORTANTE**: Normalmente, el router nunca tendrá asignadas ni la IL ni la IG, pero sí tiene que hacer referencia a ambas para la tabla de NAT.


Ejemplo: Un servidor en la red que tiene la ip 192.168.10.254 (IL), se le quiere asociar con la ip pública 209.165.201.5 (IG). Para ello, en el router R2, que es el que hace de frontera (border), y que tiene enrutamiento hacia el servidor (aunque esté en otra subred). En la interfaz de R2 que comunica con el interior, tiene que configurarse con el siguiente salto, que será un dispositivo del ISP.

```
R2(config)# ip nat inside source static 192.168.10.254 209.165.201.5
R2(config)#
R2(config)# interface serial 0/1/0
R2(config-if)# ip address 192.168.1.2 255.255.255.252
R2(config-if)# ip nat inside
R2(config-if)# exit
R2(config)# interface serial 0/1/1
R2(config-if)# ip address 209.165.200.1 255.255.255.252
R2(config-if)# ip nat outside
```


=== NAT dinámico ===

El NAT dinámico es básicamente igual que el estático, pero en lugar de tener una única ip pública, se tiene un pool de direcciones ip públicas. La diferencia es que está orientado al tráfico de salida más que el de entrada. Se asigna una ip del pool (mientras haya libres), y cuando éstas se agotan, no hay nuevas asignaciones hasta que haya un timeout por inactividad en alguna, y libere esa asignación.

Para la configuración, hay que definir el pool de ips públicas, y el pool o lista de ips locales. Luego se hace el mismo NAT, con la diferencia de que en lugar de hacer una asignación estática (`static`) se hace al pool definido.


Ejemplo: Hay un pool de direciones asignadas por el ISP que van desde la 209.165.200.226 hasta la 209.165.200.240, para proporcionar salida al exterior a un rango de equipos.

```
R2(config)# ip nat pool NAT-POOL1 209.165.200.225 209.165.200.254 netmask 255.255.255.224
R2(config)# access-list 1 permit 192.168.0.0 0.0.0.255
R2(config)# ip nat inside source list 1 pool NAT-POOL1
R2(config)# interface serial 0/1/0
R2(config-if)# ip nat inside
R2(config-if)# interface serial 0/1/1
R2(config-if)# ip nat outside
```



=== PAT o NAT con sobrecarga ===

El PAT (Port Address Translation) se utiliza para eliminar la restricción que supone usar una asignación 1:1 entre equipo e ip pública. En este caso, al llegar al router, éste traduce la dirección a origen junto a un puerto, de tal manera que esa combinación, junto con lo mismo para una ip pública, permite tener más "canales" de comunicación.

El escenario más sencillo es que el border traduzca las direcciones al salir por su interfaz exterior. Esto hace que nos despreocupemos de la IG, y nos centremos en la red local. Al final, después de la lista, añadimos el interfaz y la palabra clave `overload`.


```
R2(config)#ip nat inside source list 1 interface serial 0/1/1 overload
R2(config)#access-list 1 permit 192.168.0.0 0.0.255.255
R2(config)#interface serial0/1/0
R2(config-if)#ip nat inside
R2(config-if)#exit
R2(config)#interface Serial0/1/1
R2(config-if)#ip nat outside
```

Otro escenario, en lugar de tener una única ip, es tener un pool de ips. Aplicamos lo ya visto en el dinámico y aplicamos `overload`:

```
R2(config)#ip nat pool NAT-POOL1 209.165.200.225 209.165.200.254 netmask 255.255.255.224
R2(config)#access-list 1 permit 192.168.0.0 0.0.255.255
R2(config)#ip nat inside source list 1 NAT-POOL1 overload
R2(config)#interface serial0/1/0
R2(config-if)#ip nat inside
R2(config-if)#exit
R2(config)#interface Serial0/1/1
R2(config-if)#ip nat outside
```


===== Switches =====

Usamos por defecto el modelo 2960, que tiene dos interfaces gigabit y 24 fast ethernet.

<note>
**IMPORTANTE**: Es en los switches donde se definen las VLAN, mientras que en los routers, si acaso, se define la encapsulación, que debe coincidir con la VLAN.
</note>

Tenemos el modo comando con `enable`. Ahí tenemos múltiples comandos, siendo quizá el más interesante `show vlan brief`:

```
Switch#show vlan brief 

VLAN Name                             Status    Ports
---- -------------------------------- --------- -------------------------------
1    default                          active    Fa0/1, Fa0/2, Fa0/3, Fa0/4
                                                Fa0/5, Fa0/6, Fa0/7, Fa0/8
                                                Fa0/9, Fa0/10, Fa0/11, Fa0/12
                                                Fa0/13, Fa0/14, Fa0/15, Fa0/16
                                                Fa0/17, Fa0/18, Fa0/19, Fa0/20
                                                Fa0/21, Fa0/22, Fa0/23, Fa0/24
                                                Gig0/1, Gig0/2
```

Al igual que con los router, entramos a configurar con `configure terminal`.

==== Crear una VLAN ====

Para crear una VLAN, simplemente usamos el comando `vlan <num>`, donde `<num>` es un número entre 1 y 4094:

```
Switch(config)#vlan 10
```

Opcionalmente, podemos darle un nombre:

```
Switch(config)#vlan 10
Switch(config-vlan)#name VENTAS
```

Si no ponemos nombre, le asigna el número de VLAN con 4 dígitos, precedido de `VLAN`. En el ejemplo, sería `VLAN0010`.

En modo configuración, podemos entrar en una interfaz, o en un rango:
```
Switch(config)#int gig0/1
Switch(config-if)#
Switch(config-if)#exit
Switch(config)#int range gig0/1-2
Switch(config-if-range)#
```

Después, configuramos la vlan correspondiente, o el modo trunk.

==== Modo trunk ====

Configurar una interfaz en modo trunk es muy sencillo, con una línea es suficiente:

```
Switch(config)#int range gig0/1-2
Switch(config-if-range)#switchport mode trunk
```

<note>
El modo trunk no significa "que pase todo", sino "que pasen todas las VLAN que tengo definidas en mi base de datos". Por ello, si tiene que pasar una VLAN que no está definida en el switch, aunque el interfaz esté en modo trunk, no pasará. Hay que crear la VLAN con `vlan X`, y ya está.
</note>
==== Modo para VLAN ====

Para configurar una interfaz o rango, una vez dentro, tenemos que hacer dos cosas:

```
Switch(config)#int fa0/1-24
Switch(config-if-range)#switchport mode access
Switch(config-if-range)#switchport access vlan 10
```


===== Listas de control de acceso (ACL) =====

Las listas de control de acceso (ACL) sirven para permitir o denegar el tráfico por una interfaz de un dispositivo. Valen tanto para routers como para switches.

Las ACL pueden tener un número o un nombre. Cada ACL es un conjunto de ACEs (Access Control Entry) que permiten (`permit`) o deniegan (`deny`). También pueden tener un comentario (`remark`). Cada ACE se evalúa en el orden que se ha introducido, y cuando una ACE se cumple, el resto se ignoran. La ACE usa una wildmask para indicar la máscara de subred, y también puede usar la palabra `host` para indicar una única ip en lugar de la wildmask `0.0.0.0`.

Por defecto, sin ninguna ACL todo el tráfico está permitido. Sin embargo, cuando se crea una ACL, al final de la misma, lleva implícita una denegación de todo el tráfico que pase por la interfaz en que se aplica, por lo que previamente hay que combinar todas las reglas para que el resultado sea el esperado.

Las ACL numéricas pueden crearse de dos formas:
  - Líneas completas con el número. Ej: `access-list X <permit|deny> <args>`.
  - Una línea `ip access-list <tipo> <num|nombre>`, y después de pulsar enter, se entra en modo configuración de la ACL. Ahí se ponen las claúsulas `permit` o `deny` hasta que se pone `exit` para indicar que ya no hay mas ACEs y terminar la ACL. **IMPORTANTE**: En caso de usar un nombre, éste es sensible a mayúsculas.


==== ACL estándar ====

Una ACL estándar puede usarse cuando únicamente depende del origen.

Una ACL estándar númerica tiene el rango de 1 a 99 o de 1300 a 1999. Ejemplo:
```
Switch(config)#access-list 10 permit 192.168.10.0 0.0.0.255
Switch(config)#
```
o

```
Switch(config)#ip access-list standard 10
Switch(config-std-nacl)#permit 192.168.10.0 0.0.0.255
Switch(config-std-nacl)#exit
Switch(config)#
```

También se puede crear una ACL estándar con un nombre con `ip access-list standard <nombre>`. El resto es igual que con un número.

==== ACL extendida ====

Una ACL extendida permite tener ACEs complejas, con origen, destino, protocolo, puerto, etc. En su formato numérico, tiene el rango de 100 a 199, o de 2000 a 2699.

```
Router(config)#access-list 110 permit ...
```

o lo que es lo mismo

```
Router(config)#ip access-list extended 110 
Router(config-ext-nacl)#permit ...
Router(config-ext-nacl)#exit
```

Para crear una extendida con nombre, es `ip access-list extended <nombre>`.

La sintaxis de cada línea es:

```
permit|deny <proto> <origen> <destino> [eq <puerto>|established]
```

Donde:
  * <proto>: es el protocolo. Puede ser:
    * `udp`: para udp
    * `tcp`: para tcp
    * `ip`: para cualquier protocolo
    * `icmp`: para icmp.
    * etc
  * <origen>: origen de la petición. Puede ser:
    * `any`: para cualquier origen
    * `host` seguido de la ip, la ip de origen
    * <rango_red> <wildmask> para un rango de red
  * <destino>: destino de la petición. Tiene las mismas reglas que <origen>.
  * <puerto>: el puerto numérico o algún alias como `www` para el 80. El protocolo tiene que ser tcp o udp.
  * `established`. Para protocolo `tcp` o `udp`. Permite que el tráfico interno salga de la red privada interna y permite que el tráfico de respuesta devuelta entre en la red privada interna. Se deniega el tráfico TCP generado por un host externo e intentando comunicarse con un host interno.


==== Aplicación de ACL ====


Las ACL se definen a nivel global, pero no entran en funcionamiento hasta que se aplican a un interfaz. Esto permite tener múltiples ACLs inactivas, para pruebas. Las .ACL existentes se pueden ver con `[do] show access-lists`, y también con la configuración global.

Para aplicar una ACL, tenemos que entrar primero en la interfaz que vaya a aplicarla.:

```
Router(config)#int gig0/0
Router(config-if)#ip access-group 110 in
Router(config-if)#exit
Router(config)#
```

Usamos `ip access-group <nombre|num> [in|out]`, donde `in` o `out` indica si se va a aplicar con tráfico entrante o tráfico saliente. Lo normal es a la entrada.
<note>
**IMPORTANTE**: Sólo puede haber una ACL por interfaz y sentido (`in`|`out`)
</note>
<note>
Al aplicarla, el nombre de la ACL debe coincidir **EXACTAMENTE** en mayúsculas y minúsculas. Si se pone un nombre distinto, no sale ningún error, lo que puede hacer creer que la ACL existe.
</note>

===== Telefonía IP =====

Para usar la telefonía IP, tenemos que tener en cuenta 2 prerrequisitos:
  - Hay que tener una VLAN dedicada para la telefonía de voz. Vamos a elegir la VLAN 2.
  - Hay que usar el router 8211 para configurar la telefonía, que es el único dentro de packet tracer que soporta los comandos de telefonía.


Vamos a configurar primero el switch:
  - Configuramos como trunk el interfaz por el que llega el router, porque también va a servir a la red.
  - Configuramos los puertos donde vayan los terminales con la vlan de voz.

```
Switch(config)#int gig0/1
Switch(config-if)#switchport mode trunk
Switch(config-if)#int range fa0/1-3
Switch(config-if)#switchport voice vlan 2
```

Opcionalmente, podemos dar nombre a la vlan 2.

Vamos a configurar el router. Lo primero, vamos a configurarlo como servidor DHCP para la red de telefonía.
```
Router(config)#ip dhcp excluded-address 192.168.0.1
Router(config)#ip dhcp pool VOZ
Router(dhcp-config)#network 192.168.0.0 255.255.255.0
Router(dhcp-config)#option default-router 192.168.0.1
Router(dhcp-config)#option 150 192.168.0.1
Router(dhcp-config)#exit
```

Asignamos la ip para la vlan 2:
```
Router(config)#int fa0/0
Router(config-if)#no ip address
Router(config-if)#no shutdown
Router(config-if)#int fa0/0.2
Router(config-if)#encapsulation dot1Q 2
Router(config-if)#ip address 192.168.0.1 255.255.255.0
Router(config-if)#exit
```

Hasta ahora, nada nuevo que no pudiéramos hacer en cualquier otro router. Ahora tenemos que configurar:
  * El número máximo de números a usar (`max-dn`)
  * El número máximo de terminales telefónicos (`max-ephones`)
  * Puerto e ip origen para las llamadas
  * Asignar automáticamente las direcciones ip

Vamos a usar 2 terminales de ejemplo:

```
Router(config)#telephony-service
Router(config-telephony)#max-dn 2
Router(config-telephony)#mex-ephones 2
Router(config-telephony)#ip source-address 192.168.0.1 port 2000
Router(config-telephony)#auto assign 1 to 2
Router(config-telephony)#exit
```

Ahora tenemos que configurar las extensiones de los terminales. Vamos a poner que son la 501 y la 502.

```
Router(config)#ephone-dn 1
Router(config-ephone-dn)#number 501
Router(config-ephone-dn)#ephone-dn 2
Router(config-ephone-dn)#number 502
Router(config-ephone-dn)#exit
Router(config)#
```

Ya está. Para probarlo, tenemos que conectar dos `IP Phone` a las bocas del switch que tengan la vlan de voz. Hay que poner el cable de corriente, esperar a que cojan ip y salga el número de la extensión en el terminal. Entonces podemos descolgar y marcar el número del otro terminal, y ver que parpadea.

==== Comunicación entre centralitas ====

Lo anterior vale para una centralita que tiene su rango de números, pero también podemos comunicar dos centralitas diferentes. Una vez configurada cada centralita individualmente, hay que añadir una sección en cada router para poder comunicarse con otra centralita. Hay que definir los siguientes parámetros:
  * Las extensiones que gestiona la otra centralita. Esto se hace con `destination-pattern` seguido de la plantilla, donde hay que poner un punto (`.`) por cada carácter comodín que represente las extensiones de la otra centralita. El valor `2...` indica que empiezan por 2 y pueden tener cualquier dígito, es decir, de 2000 a 2999.
  * La dirección ip de la centralita, con `session target ipv4:ip`.
  * Se usa el codec g711ulaw, pero no todas las versiones de firmware lo soportan.

Ejemplo de dos centralitas. La centralita del router 1 (10.10.10.1) gestiona las extensiones de 1000 a 1999, y la del router 2 (10.10.10.2), de 2000 a 2999.

ROUTER 1:
```
Router1(config)#dial-peer voice 1 voip
Router1(config-dial-peer)#destination-pattern 2...
Router1(config-dial-peer)#session target ipv4:10.10.10.2
Router1(config-dial-peer)#codec g711ulaw
```

ROUTER 2
```
Router2(config)#dial-peer voice 1 voip
Router2(config-dial-peer)#destination-pattern 1...
Router2(config-dial-peer)#session target ipv4:10.10.10.1
Router2(config-dial-peer)#codec g711ulaw
```