Ok, partamos de un caso concreto: tenemos la red 150.14.0.0/16. Hay que recordar que el sufijo /16 indica que los bits que representan la máscara de sub-red (que para las redes clase B, antes de ser "subneteadas", siempre es 16 o sea, 2 octetos de 8 bits). En una red de esta clase (clase B), la cantidad de hosts está determinada por los 16 bits restantes de la parte de hosts, por lo que 216-2=65,534 hosts posibles... ni hablar del desperdicio de direcciones.
Nuestra máscara /16, que en decimal es lo mismo que 255.255.0.0, se representa en binario de la siguiente manera.
11111111.11111111.00000000.00000000
<-------------red*host------------>
Ahora la parte crucial: ¿cómo comenzar a dividir la red? Simple: debemos partir de una necesidad: ¿qué requerimos?, ¿cierta cantidad de redes o cierta cantidad de direcciones de host por red? Tal vez son ambas cosas. En este ejemplo supondremos que el requerimiento es obtener de la dirección dada por lo menos 500 sub-redes con capacidad para 100 hosts cada una. Vamos a aplicar una sencilla regla para determinar cuántos bits necesitamos pedir (recuerden que no es un préstamo, sino un obsequio :-D):
Como necesitamos que haya 500 sub-redes, necesitamos encontrar un número tal que elevando la base 2 a dicho número nos de la cantidad de sub-redes necesaria, o un poco más. Como ya lo mencioné anteriormente, podemos obtener la potencia por aproximación (al "ojo por ciento") o usando logaritmos. Al final puse una breve explicación de ambos procedimientos, para quien tenga interés.
Lo importante es que obtuvimos el número que buscamos: 9 bits. Con 9 bits podemos obtener 512 combinaciones, lo que nos da alegremente la posibilidad de obtener tranquilamente las 500 sub-redes que nos piden. Ahora sólo nos resta verificar que cada sub-red (de las 512) pueda efectivamente incluir al menos 100 hosts. Para esto basta con obtener la cantidad de combinaciones que nos dan los bits restantes. Recuerda que una dirección IP está formada por 32 bits, y para nuestro caso 16 bits ya están siendo usados por la dirección clase B, y 9 bits son los que acabamos de calcular que necesitamos para obtener las 512 sub-redes. Así que, si la aritmética no nos falla, nos quedan 7 bits para obtener direcciones de hosts (sí, mira: 32-16-9=7). Con 7 posiciones podemos obtener 128 combinaciones de "0" y "1" (bits), y aún restándole las 2 direcciones de ley (al total de direcciones de hosts siempre restamos dos, porque una será la dirección de la sub-red y otra será la dirección de broadcast) nos da un número (126) que nos permite cumplir, también tranquilamente, con el requerimiento de 100 direcciones. Con "bolitas y palitos" (literalmente) queda de la siguiente manera:
11111111.11111111.11111111.10000000
<--red original--><-subred->
<--nueva máscara de subred->
11111111.11111111.11111111.10000000
Y esta nueva máscara de sub-red en decimal sería: 255.255.255.128 (él último octeto sólo tiene un bit 1 en la posición más significativa, y es el número 128).
Lo interesante de este caso es obtener las direcciones de sub-red, pues hay que observar que los bits de sub-redes abarcan dos octetos (9 bits). No se asusten, no pondré las 512. Voy a poner sólo las primeras combinaciones de sub-redes para los dos últimos octetos. Así tenemos:
00000000.00000000 (es decir, 0.0)
00000000.10000000 (es decir, 0.128)
00000001.00000000 (es decir, 1.0)
00000001.10000000 (es decir, 1.128)
00000010.00000000 (es decir, 2.0)
00000010.10000000 (es decir, 2.128)
Quiero hacer notar una cosa: el bit menos significativo de la nueva máscara es precisamente el que está en la posición 128 del cuarto octeto (y, por cierto, 128 es el número que resulta de 27, antes de restarle 2). Si lo que queremos es obtener más rápido las direcciones de red (¿quién no quiere?), puede hacerse con incrementos de 128 (el bit menos significativo de la máscara) en el octeto correspondiente. Sólo que hay un detalle: comenzamos con 0 (cero), luego sumamos 128, pero si sumamos 128 a 128 nos da 256, que no puede expresarse con sólo 8 bits (256=100000000, 9 bits). Lo que hacemos es exactamente lo mismo que con las horas y minutos del reloj: después de 59 minutos se incrementa en 1 la hora, y los minutos quedan en cero; por lo tanto, si tenemos 0.128, el siguiente número NO es 0.256, sino 1.0. ¿Está claro?
Ahora sí, poniendo las direcciones completas, quedarían:
150.14.0.0/25
150.14.0.128/25
150.14.1.0/25
150.14.1.128/25
150.14.2.0/25
150.14.2.128/25
etc.
"¡Espera! ¿De dónde salió el '/25'?". Originalmente teníamos 16 bits en la parte de la red, pero como pedimos 9 bits a la parte de hosts, sumando 16 mas 9 nos quedan ni más ni menos que 25 bits, por eso la nueva máscara es /25.
Muy bien, hasta este momento hemos obtenido las combinaciones de sub-redes. Ahora necesitamos obtener las direcciones de host para cada una de las sub-redes obtenidas. Eso es fácil. Hagámoslo primero en binario. Para cada sub-red vamos a calcular su dirección de broadcast:
00000000.01111111 (este es 0.127)
00000000.11111111 (este es 0.255)
00000001.01111111 (este es 1.127)
00000001.11111111 (este es 1.255)
00000010.01111111 (este es 2.127)
00000010.11111111 (este es 2.255)
etc.
No hay que olvidar la regla: "las direcciones de red tienen todos los bits de host en cero (0), y las direcciones de broadcast tienen todos los bits de host en uno (1)".
De esta manera, obtener los rangos de direcciones de host válidas es mucho más sencillo, pues la primera dirección válida será una más que la dirección de red, y la última dirección válida será una menos que la dirección de broadcast. Sencillo, ¿no?
Para la sub-red 150.14.0.0/25
150.14.0.0/25 (dirección de red)
150.14.0.1/25 (primera dirección de host válida)
150.14.0.126/25 (última dirección de host válida)
150.14.0.127/25 (dirección de broadcast)
Para la sub-red 150.14.0.128/25
150.14.0.128/25 (dirección de red)
150.14.0.129/25 (primera dirección de host válida)
150.14.0.254/25 (última dirección de host válida)
150.14.0.255/25 (dirección de broadcast)
Para la sub-red 150.14.1.0/25
150.14.1.0/25 (dirección de red)
150.14.1.1/25 (primera dirección de host válida)
150.14.1.126/25 (última dirección de host válida)
150.14.1.127/25 (dirección de broadcast)
Si observan, la cantidad de direcciones entre la primera y la última válida son exactamente las 128 que dijimos (aunque sólo necesitamos 100, pero no es lo mismo "desperdiciar" 28 que 15,000).
Y con esto hemos terminado de "subnetear" la red de clase B (¡perdón!, la palabra "subnetear" sigue sin existir en español) sin desperdiciar muchas direcciones.
(Ningún bit salió lastimado durante esta división de sub-redes).
:-D
:wq!
Procedimiento usando logaritmos
Me voy a permitir hacer un pequeño recordatorio matemático y pondré el procedimiento para obtener la potencia usando logaritmos:
Sabemos que:
x=bn
y que:
n=logbx
Si la base (b) fuera 10, obtener n con la calculadora es directo. El problema con una calculadora sería obtener n siendo la base (b) diferente de 10, como en nuestro caso que es 2. Para esto podemos usar la siguiente identidad:
log2 x=(log x)/(log 2)
De tal manera que la fórmula quedaría:
n=(log x)/(log 2)
Sustituyendo:
n=(log x)/(log 2) = (log 500)/(log 2)
n=2.7/0.3
n=9
Porque:
29=512
El resultado indica que necesitamos 9 bits para obtener las sub-redes. Este procedimiento es el más complejo y requiere usar calculadora o tablas de logaritmos, pero sirve por lo menos para impresionar a más de dos. ;-) Esto me recuerda lo que decía mi maestro de Ecuaciones Diferenciales, cuando nos motivaba a comprar el libro de texto. Él decía: "muchachos: compren el libro. Les aseguro que si no aprenden, por lo menos podrán impresionar a las muchachas con el puro título". :-D ¡Cuánta razón tenía!.
Procedimiento por aproximación
Perdón por haber puesto el procedimiento anterior, pero varios se habían quedado con la duda de cómo se resolvía por logaritmos, si es que realmente se podía. La realidad es que muchos de los que regularmente calculan sub-redes no usan ese procedimiento (y muchos ni siquiera lo conocen). Mejor hagámoslo de la manera tradicional, aunque no se vea tan nerd.
Si lo que necesitamos es un número al que podamos elevar (potencia) el 2 (la base) para que nos dé 500 redes, yéndonos por potencias de 2 podemos encontrarlo relativamente rápido:
n=9, pues
29=512 (porque 2*2*2*2*2*2*2*2*2=512)
El "secreto" es ir multiplicando 2*2, llevando la cuenta de cuántos "2" llevas, hasta que encuentres el número que buscas... ;) Este procedimiento es más práctico que el anterior; tal vez no impresiones a nadie (o ¿quién sabe?), pero al menos llegarás rápido al número que necesitas. ;-)
:wq!
Entradas
