---
title: "Laboratorio: diseñar y validar un plan de direccionamiento"
domain: networking
level: intermediate
duration: "60 min"
cost: "gratis"
environment: "máquina local con Python 3 (cualquier sistema operativo); opcional: máquina Linux o VM con sudo para el Paso 8"
lang: es
source_hash: 65c96f2cb08f
---

# Laboratorio: diseñar y validar un plan de direccionamiento

## Objetivo
Diseñas el plan de direccionamiento IPv4 de una empresa ficticia con tres sedes, usando VLSM dentro del bloque privado `10.20.0.0/16`. Después lo compruebas con un pequeño script de Python que detecta solapes, subredes demasiado pequeñas y prefijos desalineados, y arreglas un plan roto.

## Objetivos
- Dimensionar cada segmento de red con el prefijo más largo que cubra su número de hosts.
- Asignar un plan VLSM por sede, de la subred mayor a la menor, en límites alineados.
- Elegir un bloque por sede de modo que cada sede se pueda anunciar como una única ruta resumen.
- Validar un plan automáticamente (contención, solapes, capacidad, espacio sobrante) y corregir los fallos que encuentre.
- (Opcional) Observar en Linux cómo una máscara de subred incorrecta rompe la alcanzabilidad.

## Requisitos previos
- Python 3.8 o posterior (solo se usa la biblioteca estándar). Compruébalo con `python3 --version`; en Windows usa `py` en lugar de `python3`.
- Un editor de texto y una terminal.
- La [lección](lesson.es.md) de este módulo, sobre todo VLSM y el resumen de rutas.
- Solo para el Paso 8 opcional: una máquina Linux o VM donde puedas usar `sudo`, con iproute2 (`ip`) y `ping` instalados.

> [!WARNING]
> Los Pasos 1–7 solo crean archivos en una carpeta de tu directorio personal. El Paso 8 crea namespaces de red y necesita `sudo`: ejecútalo en una máquina de pruebas o en una VM, no en un servidor de producción. Usa el rango de documentación `198.51.100.0/24` (RFC 5737) y no toca tus interfaces de red reales. Ejecuta siempre la sección de [Limpieza](#limpieza) al final.

## Arquitectura
Example Corp tiene una sede central (HQ) y dos sucursales (BR1, BR2), conectadas por enlaces WAN punto a punto. Posee el bloque RFC 1918 `10.20.0.0/16` para todo su direccionamiento interno.

![Example Corp: la sede central HQ con los segmentos Personal, Voz, Invitados, Servidores y Gestión, las sucursales BR1 y BR2 con sus segmentos, unidas por enlaces WAN /31, con BR1 a BR2 como respaldo](../../../assets/diagrams/subnetting-lab-sites.es.svg)

*Figura 1. Las sedes de Example Corp y los segmentos que necesita cada una. Los tres enlaces WAN son redes punto a punto /31.*

Los requisitos, en hosts necesarios hoy incluyendo el crecimiento:

| Sede | Segmento | Hosts |
|---|---|---|
| HQ | Staff (personal) | 900 |
| HQ | Voice (voz) | 400 |
| HQ | Guest (invitados) | 250 |
| HQ | Servers (servidores) | 200 |
| HQ | Management (gestión) | 40 |
| BR1 | Staff | 120 |
| BR1 | Voice | 60 |
| BR1 | Guest | 50 |
| BR1 | Management | 10 |
| BR2 | Staff | 55 |
| BR2 | Voice | 25 |
| BR2 | Management | 6 |
| WAN | HQ-BR1, HQ-BR2, BR1-BR2 | 2 cada uno |

Reglas de diseño:
1. Cada sede recibe **un bloque alineado**, para que el resto de la red pueda llegar a ella con una única ruta resumen.
2. Todos los enlaces WAN salen de un bloque de infraestructura, `10.20.255.0/24`, y usan prefijos /31 (RFC 3021).
3. Dentro de cada sede, asigna los segmentos de mayor a menor, empezando por el principio del bloque de la sede.

## Pasos

### Paso 1 — Crea un espacio de trabajo
Guarda todos los archivos de este laboratorio en una carpeta, para que la limpieza sea un solo comando.

```bash
mkdir -p ~/subnet-lab
cd ~/subnet-lab
python3 --version
```

Salida esperada (sirve cualquier versión desde la 3.8):
```text
Python 3.14.7
```

### Paso 2 — Dimensiona cada segmento
Antes de tocar ninguna dirección, decide la longitud de prefijo de cada segmento. Usa la tabla de potencias de dos de la lección: busca el prefijo más largo cuyos hosts utilizables (2<sup>bits de host</sup> − 2) cubran la necesidad.

Rellena esta tabla en papel o en un archivo de texto:

| Sede | Segmento | Hosts | Prefijo | Tamaño de bloque |
|---|---|---|---|---|
| HQ | Staff | 900 | ? | ? |
| HQ | Voice | 400 | ? | ? |
| … | … | … | … | … |

<details>
<summary>Mostrar los tamaños</summary>

| Sede | Segmento | Hosts | Prefijo | Utilizables | Tamaño de bloque |
|---|---|---|---|---|---|
| HQ | Staff | 900 | /22 | 1022 | 1024 |
| HQ | Voice | 400 | /23 | 510 | 512 |
| HQ | Guest | 250 | /24 | 254 | 256 |
| HQ | Servers | 200 | /24 | 254 | 256 |
| HQ | Management | 40 | /26 | 62 | 64 |
| BR1 | Staff | 120 | /25 | 126 | 128 |
| BR1 | Voice | 60 | /26 | 62 | 64 |
| BR1 | Guest | 50 | /26 | 62 | 64 |
| BR1 | Management | 10 | /28 | 14 | 16 |
| BR2 | Staff | 55 | /26 | 62 | 64 |
| BR2 | Voice | 25 | /27 | 30 | 32 |
| BR2 | Management | 6 | /29 | 6 | 8 |
| WAN | cada enlace | 2 | /31 | 2 | 2 |

</details>

### Paso 3 — Elige un bloque por sede
Suma los tamaños de bloque de cada sede y redondea a la siguiente potencia de dos. Ese es el bloque más pequeño que contiene toda la sede y que aún se puede resumir en una sola ruta.

- HQ: 1024 + 512 + 256 + 256 + 64 = 2112 direcciones. La siguiente potencia de dos es 4096, un **/20**.
- BR1: 128 + 64 + 64 + 16 = 272 direcciones. La siguiente potencia de dos es 512, un **/23**.
- BR2: 64 + 32 + 8 = 104 direcciones. El mínimo es un /25 (128). Este diseño lo redondea a un **/24** para dejar margen de crecimiento.

Coloca también los bloques de las sedes de mayor a menor, cada uno en su propio límite. Una elección válida:

| Sede | Bloque | Por qué es válido |
|---|---|---|
| HQ | `10.20.0.0/20` | Empieza en 0, múltiplo de 16 en el tercer octeto. |
| BR1 | `10.20.16.0/23` | 16 es múltiplo de 2. |
| BR2 | `10.20.18.0/24` | Sigue directamente a BR1. |
| WAN | `10.20.255.0/24` | Lo fijan las reglas de diseño; lejos de las sedes para que puedan crecer. |

> [!TIP]
> Si quieres otros bloques de sede, no pasa nada, siempre que cada uno esté alineado y no se solapen. Entonces tu salida del Paso 6 será distinta de la mostrada, pero debe seguir terminando en `PASS`.

### Paso 4 — Asigna los segmentos y escribe el plan
Ahora coloca los segmentos dentro de cada bloque de sede, de mayor a menor. En HQ, Staff (/22) empieza en `10.20.0.0`, así que termina en `10.20.3.255`. Voice (/23) empieza en la dirección siguiente, `10.20.4.0`, y así sucesivamente.

Escribe el plan como un archivo de valores separados por comas (CSV, comma-separated values) llamado `plan.csv`, con una fila por segmento y una fila `BLOCK` por sede:

```text
site,segment,prefix,hosts
HQ,BLOCK,10.20.0.0/20,
HQ,Staff,10.20.0.0/22,900
...
```

Las columnas son:
- `site`: el nombre de la sede (`HQ`, `BR1`, `BR2` o `WAN`).
- `segment`: el nombre del segmento, o `BLOCK` para el bloque resumen de la sede.
- `prefix`: la red en notación CIDR.
- `hosts`: hosts necesarios (déjalo vacío en las filas `BLOCK`).

Inténtalo primero por tu cuenta y luego compara con el plan de referencia.

<details>
<summary>Mostrar el plan de referencia</summary>

```bash
cat > plan.csv <<'EOF'
site,segment,prefix,hosts
HQ,BLOCK,10.20.0.0/20,
HQ,Staff,10.20.0.0/22,900
HQ,Voice,10.20.4.0/23,400
HQ,Guest,10.20.6.0/24,250
HQ,Servers,10.20.7.0/24,200
HQ,Management,10.20.8.0/26,40
BR1,BLOCK,10.20.16.0/23,
BR1,Staff,10.20.16.0/25,120
BR1,Voice,10.20.16.128/26,60
BR1,Guest,10.20.16.192/26,50
BR1,Management,10.20.17.0/28,10
BR2,BLOCK,10.20.18.0/24,
BR2,Staff,10.20.18.0/26,55
BR2,Voice,10.20.18.64/27,25
BR2,Management,10.20.18.96/29,6
WAN,BLOCK,10.20.255.0/24,
WAN,HQ-BR1,10.20.255.0/31,2
WAN,HQ-BR2,10.20.255.2/31,2
WAN,BR1-BR2,10.20.255.4/31,2
EOF
```

</details>

### Paso 5 — Crea el validador
Comprobar un plan a mano es lento y propenso a errores. Este script usa el módulo `ipaddress` de la biblioteca estándar de Python para comprobar cada regla de la lección:

- cada prefijo es una dirección de red real (sin bits de host activos, es decir, está alineado),
- todo está dentro de `10.20.0.0/16`, y cada segmento está dentro del bloque de su sede,
- los bloques de sede no se solapan, y los segmentos no se solapan,
- cada segmento tiene direcciones utilizables suficientes (/31 = 2, /32 = 1, en otro caso tamaño de bloque − 2).

También imprime el plan como una tabla con la máscara, el rango de hosts y las direcciones sobrantes de cada segmento.

```bash
cat > validate_plan.py <<'EOF'
#!/usr/bin/env python3
"""Validate an IPv4 addressing plan stored in a CSV file (site,segment,prefix,hosts)."""
import csv
import ipaddress
import sys

TOP_BLOCK = ipaddress.ip_network("10.20.0.0/16")


def usable(net):
    """Usable host addresses: /32 = 1, /31 = 2 (RFC 3021), otherwise all minus network and broadcast."""
    if net.prefixlen == 32:
        return 1
    if net.prefixlen == 31:
        return 2
    return net.num_addresses - 2


def host_range(net):
    if net.prefixlen >= 31:
        return f"{net[0]} - {net[-1]}"
    return f"{net[1]} - {net[-2]}"


def main(path):
    errors = []
    sites, segments = {}, []
    with open(path, newline="") as f:
        for row in csv.DictReader(f):
            site, name, prefix = row["site"].strip(), row["segment"].strip(), row["prefix"].strip()
            try:
                net = ipaddress.ip_network(prefix)  # strict: host bits must be zero
            except ValueError:
                fixed = ipaddress.ip_network(prefix, strict=False)
                errors.append(f"{site}/{name}: {prefix} is not a network address (did you mean {fixed}?)")
                continue
            if not net.subnet_of(TOP_BLOCK):
                errors.append(f"{site}/{name}: {net} is outside {TOP_BLOCK}")
            if name == "BLOCK":
                sites[site] = net
            else:
                segments.append((site, name, net, int(row["hosts"])))

    # Site blocks must not overlap each other.
    names = sorted(sites)
    for i, a in enumerate(names):
        for b in names[i + 1:]:
            if sites[a].overlaps(sites[b]):
                errors.append(f"site blocks overlap: {a} {sites[a]} and {b} {sites[b]}")

    print(f"{'Site':<6} {'Segment':<12} {'Prefix':<17} {'Mask':<16} {'Host range':<29} {'Usable':>6} {'Need':>5} {'Spare':>6}")
    total_need = total_alloc = 0
    for site, name, net, need in sorted(segments, key=lambda s: s[2]):
        spare = usable(net) - need
        total_need += need
        total_alloc += net.num_addresses
        print(f"{site:<6} {name:<12} {str(net):<17} {str(net.netmask):<16} {host_range(net):<29} {usable(net):>6} {need:>5} {spare:>6}")
        if spare < 0:
            errors.append(f"{site}/{name}: {net} has {usable(net)} usable addresses but needs {need}")
        if site not in sites:
            errors.append(f"{site}/{name}: site {site} has no BLOCK row")
        elif not net.subnet_of(sites[site]):
            errors.append(f"{site}/{name}: {net} is outside its site block {sites[site]}")

    # No two segments may overlap.
    for i, (s1, n1, a, _) in enumerate(segments):
        for s2, n2, b, _ in segments[i + 1:]:
            if a.overlaps(b):
                errors.append(f"overlap: {s1}/{n1} {a} and {s2}/{n2} {b}")

    print()
    print(f"Addresses allocated to segments: {total_alloc} of {TOP_BLOCK.num_addresses} in {TOP_BLOCK}")
    print(f"Hosts required: {total_need}; spare addresses inside segments: {total_alloc - total_need}")
    print("Summary routes (one per site):", ", ".join(f"{s} {sites[s]}" for s in names))
    print()
    if errors:
        print(f"FAIL: {len(errors)} problem(s)")
        for err in errors:
            print("  -", err)
        return 1
    print("PASS: no overlaps, every segment fits its site block and its host count")
    return 0


if __name__ == "__main__":
    if len(sys.argv) != 2:
        sys.exit("usage: python3 validate_plan.py <plan.csv>")
    sys.exit(main(sys.argv[1]))
EOF
```

> [!NOTE]
> «Direcciones sobrantes dentro de los segmentos» (`Spare`) cuenta todas las direcciones de las subredes asignadas que no son hosts necesarios, incluidas las direcciones de red y de broadcast. Mide cuánto margen de crecimiento (o desperdicio) tiene el plan, no cuántos hosts puedes añadir todavía.

### Paso 6 — Valida tu plan
Ejecuta el validador sobre tu plan:

```bash
python3 validate_plan.py plan.csv
```

Salida esperada para el plan de referencia:
```text
Site   Segment      Prefix            Mask             Host range                    Usable  Need  Spare
HQ     Staff        10.20.0.0/22      255.255.252.0    10.20.0.1 - 10.20.3.254         1022   900    122
HQ     Voice        10.20.4.0/23      255.255.254.0    10.20.4.1 - 10.20.5.254          510   400    110
HQ     Guest        10.20.6.0/24      255.255.255.0    10.20.6.1 - 10.20.6.254          254   250      4
HQ     Servers      10.20.7.0/24      255.255.255.0    10.20.7.1 - 10.20.7.254          254   200     54
HQ     Management   10.20.8.0/26      255.255.255.192  10.20.8.1 - 10.20.8.62            62    40     22
BR1    Staff        10.20.16.0/25     255.255.255.128  10.20.16.1 - 10.20.16.126        126   120      6
BR1    Voice        10.20.16.128/26   255.255.255.192  10.20.16.129 - 10.20.16.190       62    60      2
BR1    Guest        10.20.16.192/26   255.255.255.192  10.20.16.193 - 10.20.16.254       62    50     12
BR1    Management   10.20.17.0/28     255.255.255.240  10.20.17.1 - 10.20.17.14          14    10      4
BR2    Staff        10.20.18.0/26     255.255.255.192  10.20.18.1 - 10.20.18.62          62    55      7
BR2    Voice        10.20.18.64/27    255.255.255.224  10.20.18.65 - 10.20.18.94         30    25      5
BR2    Management   10.20.18.96/29    255.255.255.248  10.20.18.97 - 10.20.18.102         6     6      0
WAN    HQ-BR1       10.20.255.0/31    255.255.255.254  10.20.255.0 - 10.20.255.1          2     2      0
WAN    HQ-BR2       10.20.255.2/31    255.255.255.254  10.20.255.2 - 10.20.255.3          2     2      0
WAN    BR1-BR2      10.20.255.4/31    255.255.255.254  10.20.255.4 - 10.20.255.5          2     2      0

Addresses allocated to segments: 2494 of 65536 in 10.20.0.0/16
Hosts required: 2122; spare addresses inside segments: 372
Summary routes (one per site): BR1 10.20.16.0/23, BR2 10.20.18.0/24, HQ 10.20.0.0/20, WAN 10.20.255.0/24

PASS: no overlaps, every segment fits its site block and its host count
```

Lee el resultado como lo haría un revisor:
- **Rutas resumen.** El resto de la red solo necesita cuatro rutas para llegar a todas las subredes de Example Corp.
- **Columna Spare.** BR2 Management tiene 0 direcciones sobrantes: el séptimo dispositivo exigirá renumerar. En un diseño real probablemente le darías un /28. Hay espacio libre justo detrás en `10.20.18.0/24`.
- **Margen de crecimiento.** HQ usa 2112 de las 4096 direcciones de su /20, así que de `10.20.8.64` a `10.20.15.255` sigue libre para nuevos segmentos de HQ.

### Paso 7 — Encuentra y corrige los fallos de un plan roto
Un compañero te ha enviado este plan. Tiene varios de los fallos de la lección. Guárdalo y ejecuta el validador:

```bash
cat > broken.csv <<'EOF'
site,segment,prefix,hosts
HQ,BLOCK,10.20.0.0/20,
HQ,Staff,10.20.0.0/22,900
HQ,Voice,10.20.4.0/24,400
HQ,Guest,10.20.6.0/23,250
HQ,Servers,10.20.7.0/24,200
HQ,Management,10.20.8.0/26,40
BR1,BLOCK,10.20.16.0/23,
BR1,Staff,10.20.16.0/25,120
BR1,Voice,10.20.16.128/26,60
BR1,Guest,10.20.16.192/26,50
BR1,Management,10.20.18.0/28,10
BR2,BLOCK,10.20.18.0/24,
BR2,Staff,10.20.18.0/26,55
BR2,Voice,10.20.18.70/27,25
BR2,Management,10.20.18.96/29,6
WAN,BLOCK,10.20.255.0/24,
WAN,HQ-BR1,10.20.255.0/31,2
WAN,HQ-BR2,10.20.255.2/31,2
WAN,BR1-BR2,10.20.255.4/31,2
EOF
python3 validate_plan.py broken.csv
echo "exit code: $?"
```

Salida esperada (el final):
```text
FAIL: 5 problem(s)
  - BR2/Voice: 10.20.18.70/27 is not a network address (did you mean 10.20.18.64/27?)
  - HQ/Voice: 10.20.4.0/24 has 254 usable addresses but needs 400
  - BR1/Management: 10.20.18.0/28 is outside its site block 10.20.16.0/23
  - overlap: HQ/Guest 10.20.6.0/23 and HQ/Servers 10.20.7.0/24
  - overlap: BR1/Management 10.20.18.0/28 and BR2/Staff 10.20.18.0/26
exit code: 1
```

Copia el archivo (`cp broken.csv fixed.csv`), edita `fixed.csv` hasta que `python3 validate_plan.py fixed.csv` imprima `PASS` y, para cada fallo, anota qué regla de la lección infringe. Cambia el menor número de líneas posible.

> [!TIP]
> Cinco mensajes no siempre significan cinco fallos. Una línea errónea puede romper dos reglas a la vez.

<details>
<summary>Mostrar las correcciones</summary>

Hay cuatro líneas erróneas:

| Línea | Fallo | Corrección |
|---|---|---|
| `HQ,Voice,10.20.4.0/24,400` | Demasiado pequeña: un /24 tiene 254 hosts utilizables y se necesitan 400. | `10.20.4.0/23` |
| `HQ,Guest,10.20.6.0/23,250` | Demasiado grande: el /23 cubre `10.20.6.0`–`10.20.7.255` y se solapa con Servers. | `10.20.6.0/24` |
| `BR1,Management,10.20.18.0/28,10` | Fuera del bloque de BR1 (está en el de BR2), así que se solapa con BR2 Staff y rompe la ruta resumen de BR1. | `10.20.17.0/28` |
| `BR2,Voice,10.20.18.70/27,25` | No alineada: 70 no es múltiplo de 32. | `10.20.18.64/27` |

Tras estos cuatro cambios, `fixed.csv` es idéntico al `plan.csv` de referencia, y puedes comprobarlo con:

```bash
diff fixed.csv plan.csv && echo "identical"
```

</details>

### Paso 8 (opcional, Linux, requiere sudo) — Comprueba cómo una máscara incorrecta rompe la alcanzabilidad
El validador detecta errores sobre el papel. Este paso muestra qué aspecto tiene el mismo error en una red real. Creas dos **namespaces de red** (pilas de red aisladas en una misma máquina Linux), los unes con un cable Ethernet virtual (veth) y das a un lado una máscara incorrecta.

Ambos hosts deberían estar en `198.51.100.0/26`. El host B recibe `/28` por error, así que cree que su subred es `198.51.100.32/28` (`.33`–`.46`).

![Dos namespaces de red unidos por un par veth: lab-a con 198.51.100.10/26 y lab-b con 198.51.100.40/28. Una regla de .0 a .63 muestra que A considera local de .0 a .63, mientras que B considera local solo de .32 a .47, así que la dirección .10 de A queda fuera de la subred de B](../../../assets/diagrams/subnetting-lab-netns.es.svg)

*Figura 2. El mismo cable, dos visiones distintas de la subred. A puede llegar a B, pero B trata la dirección de A como remota y no tiene ruta para responder.*

Crea los namespaces, el cable y las direcciones:

```bash
sudo ip netns add lab-a
sudo ip netns add lab-b
sudo ip link add veth-a type veth peer name veth-b
sudo ip link set veth-a netns lab-a
sudo ip link set veth-b netns lab-b
sudo ip -n lab-a addr add 198.51.100.10/26 dev veth-a
sudo ip -n lab-b addr add 198.51.100.40/28 dev veth-b
sudo ip -n lab-a link set veth-a up
sudo ip -n lab-b link set veth-b up
sudo ip -n lab-b route
```

Salida esperada (la tabla de rutas de `lab-b`):
```text
198.51.100.32/28 dev veth-b proto kernel scope link src 198.51.100.40
```

El host B solo considera local `198.51.100.32/28`. `198.51.100.10` queda fuera, y B no tiene ninguna otra ruta.

Haz ping en ambos sentidos:

```bash
sudo ip netns exec lab-a ping -c 2 198.51.100.40
sudo ip netns exec lab-b ping -c 2 198.51.100.10
```

Salida esperada (los tiempos varían):
```text
PING 198.51.100.40 (198.51.100.40) 56(84) bytes of data.
From 198.51.100.10 icmp_seq=1 Destination Host Unreachable
From 198.51.100.10 icmp_seq=2 Destination Host Unreachable

--- 198.51.100.40 ping statistics ---
2 packets transmitted, 0 received, +2 errors, 100% packet loss, time 1026ms
pipe 2
ping: connect: Network is unreachable
```

Los dos lados fallan de forma distinta:
- **Desde A**, `.40` parece local (la máscara de A es correcta), así que A envía una solicitud ARP. B no responde, porque no tiene ruta de vuelta a `198.51.100.10`. Sin respuesta ARP, A informa `Destination Host Unreachable`.
- **Desde B**, `.10` queda fuera de su `/28` y no hay ruta predeterminada, así que el kernel se niega a enviar nada: `Network is unreachable`.

Ahora intenta dar a B una puerta de enlace predeterminada que esté fuera de su subred (incorrecta):

```bash
sudo ip -n lab-b route add default via 198.51.100.1
```

Salida esperada:
```text
Error: Nexthop has invalid gateway.
```

Linux rechaza una puerta de enlace que no está en una subred conectada directamente. Es el fallo de la «puerta de enlace fuera de la subred» de la lección.

Corrige la máscara y prueba de nuevo:

```bash
sudo ip -n lab-b addr del 198.51.100.40/28 dev veth-b
sudo ip -n lab-b addr add 198.51.100.40/26 dev veth-b
sudo ip netns exec lab-a ping -c 2 198.51.100.40
```

Salida esperada (los tiempos varían):
```text
PING 198.51.100.40 (198.51.100.40) 56(84) bytes of data.
64 bytes from 198.51.100.40: icmp_seq=1 ttl=64 time=0.040 ms
64 bytes from 198.51.100.40: icmp_seq=2 ttl=64 time=0.047 ms

--- 198.51.100.40 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1034ms
rtt min/avg/max/mdev = 0.040/0.043/0.047/0.003 ms
```

> [!NOTE]
> Las salidas anteriores proceden de iproute2 6.17 e iputils 20250605. Otras versiones redactan los mensajes de forma ligeramente distinta, y una configuración regional que no sea inglés los traduce; ejecuta los comandos con `LC_ALL=C` para obtener la salida en inglés. El comportamiento del enrutamiento es el mismo.

## Verificación
Has completado el laboratorio cuando:

1. Tu propio plan pasa:
   ```bash
   python3 validate_plan.py plan.csv; echo "exit code: $?"
   ```
   La salida termina con `PASS: ...` y `exit code: 0`.
2. Tu versión corregida del plan roto pasa:
   ```bash
   python3 validate_plan.py fixed.csv; echo "exit code: $?"
   ```
   La salida termina con `PASS: ...` y `exit code: 0`.
3. Sabes nombrar la regla de la lección que hay detrás de cada uno de los cuatro fallos del Paso 7.
4. (Paso 8 opcional) Con la máscara corregida, `sudo ip netns exec lab-a ping -c 2 198.51.100.40` muestra `0% packet loss`.

## Resolución de problemas
| Síntoma | Causa probable | Solución |
|---|---|---|
| `KeyError: 'segment'` (o `'site'`, `'prefix'`, `'hosts'`) | Falta la línea de cabecera del CSV o está mal escrita. | Haz que la primera línea sea exactamente `site,segment,prefix,hosts`. |
| `ValueError: invalid literal for int() with base 10: ''` | Una fila de segmento tiene la columna `hosts` vacía. | Solo las filas `BLOCK` pueden dejar `hosts` vacío. |
| `... is not a network address (did you mean ...?)` | El prefijo tiene bits de host activos: no empieza en su propio límite. | Usa la red sugerida y vuelve a comprobar que no se solape con una vecina. |
| `... is outside its site block ...` | Un segmento se colocó en el bloque de otra sede, o el bloque de la sede es demasiado pequeño. | Mueve el segmento a su propio bloque, o elige un bloque de sede alineado más grande. |
| `RTNETLINK answers: Operation not permitted` | Ejecutaste sin `sudo` un comando `ip` que modifica la red. | Antepón `sudo` al comando. |
| `Cannot open network namespace "lab-a": No such file or directory` | El namespace no existe (se saltó un paso o ya se ejecutó la limpieza). | Ejecuta `ip netns list` y repite los comandos de creación del Paso 8. |
| `File exists` al crear un namespace o el par veth | Restos de un intento anterior. | Ejecuta los comandos de [Limpieza](#limpieza) y empieza de nuevo el Paso 8. |

## Reto (opcional)
Example Corp abre una tercera sucursal, BR3, con Staff (200 hosts), Voice (100) y Management (10), más un enlace WAN con HQ. Añádela a tu plan sin renumerar nada. Después deja el plan aún más ordenado: elige el bloque de BR3 de modo que **todas las sucursales** juntas (BR1, BR2 y BR3) se puedan anunciar a HQ como una única ruta resumen. ¿Cuál es esa ruta y cuánto margen deja para futuras sucursales? Compruébalo con el validador.

## Limpieza
Elimina los archivos del laboratorio:

```bash
cd ~
rm -r ~/subnet-lab
```

Si hiciste el Paso 8, borra los dos namespaces. Borrar un namespace también borra la interfaz veth que contiene, y borrar un extremo de un par veth borra el otro.

```bash
sudo ip netns del lab-a
sudo ip netns del lab-b
ip netns list
```

Salida esperada: `ip netns list` no imprime nada (o no lista `lab-a` ni `lab-b`).

## Qué has aprendido
- Primero dimensionar y luego colocar: el prefijo de cada segmento sale de su número de hosts, y el bloque de cada sede de la suma de sus segmentos, redondeada a una potencia de dos.
- Asignar de mayor a menor en límites alineados empaqueta las subredes sin huecos y mantiene cada sede resumible en una sola ruta.
- Los solapes, las subredes demasiado pequeñas y los prefijos desalineados son fáciles de pasar por alto a simple vista y fáciles de detectar con un script.
- En un host real, una máscara incorrecta rompe la alcanzabilidad de forma asimétrica, y Linux rechaza una puerta de enlace predeterminada fuera de la subred del host.
