Module 2: The Network Layer

Computers are able to communicate across
massive distances at near instant speeds. It’s a remarkable technical advancement
at the root of how billions of people use the internet every single day. Earlier in this course, we learned about
how computers communicate with each other over short distances or
on a single network segment or LAN. In these next lessons, will focus on
the technologies that allow data to across many networks, facilitating
communications over great distances. By the end of this module, you’ll be able
to describe the IP addressing scheme and how sub netting works. This means you’ll learn how
to perform basic math and binary in order to describe subnets. You’ll also be able to demonstrate
how encapsulation works and how protocols such as ARP allow different
layers of the network to communicate. And finally, you’ll gain an understanding
of the basics behind routing, routing protocols and
how the internet works. For now, route yourself to the next
video and we’ll get started.

Network Addressing Tutorial: Demystifying MAC vs. IP

Welcome to the world of network addressing! In this tutorial, we’ll delve into the two key players: MAC addresses and IP addresses, exploring their roles and the crucial distinctions between them.

Living in the Neighborhood: MAC Addresses:

Imagine your local community. Each resident has a unique house number – their MAC address. This helps neighbors and delivery services find them within the neighborhood. Similarly, MAC addresses identify network devices within a local area network (LAN). These hardware-embedded codes are unique and permanent, allowing switches to direct traffic efficiently within the LAN.

MAC addresses work beautifully for small-scale networks:

• Quick and efficient for local communication.
• Switches learn connected devices’ MACs effortlessly.
• No central management or organization needed.

However, scaling up with MACs becomes tricky:

• Unstructured addressing scheme – no way to map location or route across networks.
• Every device on the planet has a unique MAC – collision chaos awaits!

Enter the Big League: IP Addresses:

Think of IP addresses as your unique internet address, guiding you across the vast digital map. Unlike MACs, IP addresses are logical, structured, and assigned by software, offering a scalable solution for larger networks and the internet.

Here’s why IP addresses rule the wider world:

• Hierarchical and routable: Organized in regions and subnets, enabling efficient routing across networks.
• Dynamic or static: Can be assigned temporarily or permanently, catering to diverse needs.
• Location-agnostic: Independent of physical hardware, allowing devices to move and connect seamlessly.

Understanding IP Datagrams:

Imagine wrapping a neatly addressed letter (IP datagram) within a sealed package (Ethernet frame) for delivery. IP datagrams contain information like source and destination IP addresses, data, and header fields, while Ethernet frames provide the physical delivery mechanism using MAC addresses.

Let’s explore the key sections of an IP datagram header:

• Version: Identifies the IP protocol version being used.
• IHL (Internet Header Length): Indicates the header size in 32-bit words.
• Type of Service (ToS): Specifies priority and quality of service requirements.
• Total Length: Shows the entire datagram size, including header and data.
• Time to Live (TTL): Prevents datagrams from endlessly traversing the network.
• Protocol: Identifies the protocol transporting the data within the datagram (e.g., TCP, UDP).
• Source and Destination IP Addresses: Specify the origin and final destination of the datagram.
• Checksum: Ensures data integrity during transmission.

By mastering these concepts, you’ll gain a clear understanding of how network devices communicate efficiently on both local and global scales.

Remember:

• MAC addresses are for local LAN communication, while IP addresses guide data across vast networks.
• IP datagrams, encapsulated within Ethernet frames, carry information necessary for routing and delivery.
• Understanding IP header fields demystifies the language of internet communication.

This tutorial provides a foundational understanding of network addressing. By delving deeper into these concepts, you’ll unlock the secrets of how devices connect and share information seamlessly across the digital landscape.

On a local area network or LAN, nodes can communicate with each other through their
physical MAC addresses. This works well on small scale because switches
can quickly learn the MAC addresses connected to each other ports to four
transmissions appropriately. But MAC addressing isn’t a
scheme that scales well. Every single network
interface on the planet has a
unique MAC address, and they aren’t ordered
in any systematic way. There’s no way of knowing
where on the planet a certain MAC address might
be at any one point in time, so it’s not ideal for
communicating across distances. Later on in this lesson
when we introduce ARP or address
resolution protocol, you’ll see that the way
that nodes learn about each other’s physical
addressing isn’t translatable to anything besides a single network segment anyway. Clearly, we need
another solution, and that is the network layer, and the Internet Protocol or IP, and the IP addresses
that come along with it. By the end of this lesson, you’ll be able to
identify an IP address, describe how IP datagrams are encapsulated inside the
payload of an Ethernet frame, and correctly
identify and describe the many fields of an
IP datagram header.

Demystifying IP Addresses: Your Guide to Internet Navigation

Welcome to the exciting world of IP addresses, the language devices use to communicate across the vast digital landscape! This tutorial will equip you with the essential knowledge about these unique identifiers, empowering you to navigate the internet with confidence.

Anatomy of an IP Address:

Imagine an IP address like a house address, guiding packets of information to their rightful destinations. Just like your address has a specific format, so does an IP address. It’s a 32-bit number divided into four sections called octets, each represented by a decimal number between 0 and 255. Think of it as a four-part code, written in dotted decimal notation:

Understanding Octets:

Each octet can represent 256 unique values (0-255) thanks to its 8 bits of data. This allows for a massive range of possible IP addresses, crucial for accommodating the ever-growing internet.

Valid vs. Invalid Addresses:

Remember, each octet’s value can’t exceed 255. So, while 192.168.1.1 is a valid IP address, 123.456.789.100 wouldn’t be, as the fourth octet exceeds the allowable range.

Hierarchical Distribution:

Unlike house addresses assigned by physical location, IP addresses are distributed in a hierarchical manner. Large sections are allocated to organizations and companies, creating a structured system for routing information across vast networks.

Think of it this way:

• Imagine IBM owning every IP address with the first octet “9”.
• If an internet router needs to send data to 90.0.0.1, it only needs to route it to one of IBM’s routers.
• IBM’s internal network can then handle the final delivery within its infrastructure.

Network vs. Device:

It’s important to remember that IP addresses belong to networks, not individual devices. Your laptop has the same MAC address (hardware identifier) everywhere you use it, but its IP address changes depending on the network it’s connected to.

Think of it like this:

• The cafe’s wifi and your home network will each assign your laptop a different IP address when you connect.
• Each network is responsible for managing its own pool of IP addresses for connected devices.

Dynamic vs. Static IP Addresses:

In most cases, obtaining an IP address is a seamless process. Many modern networks utilize Dynamic Host Configuration Protocol (DHCP) to automatically assign an IP address to each device that connects. These are called dynamic IP addresses.

However, there’s another type:

• Static IP addresses are manually configured on individual devices, often for servers and network equipment.
• They offer greater control and stability, making them crucial for certain network functions.

Remember:

• Dynamic IP addresses are common for everyday devices like laptops and phones.
• Static IP addresses are typically reserved for servers and critical network components.

Beyond the Basics:

This tutorial provides a foundational understanding of IP addresses. In upcoming lessons, we’ll delve deeper into:

• Subnetting: How large IP address blocks are further divided for efficient network management.
• Routing protocols: How internet routers exchange information to direct data packets to their destinations.
• Troubleshooting: Techniques for identifying and resolving IP address-related issues.

Mastering IP addresses empowers you to navigate the intricacies of the digital world with confidence. Remember, these unique identifiers are the cornerstone of online communication, ensuring data reaches its intended destination across the vast expanse of the internet.

IP addresses are a 32-bit
long numbers made up of four octets and each octet is normally described
in decimal numbers. Eight bits of data or
a single octet can represent all decimal
numbers from 0-255. For example, 12.34.56.78
is a valid IP address, but 123.456.789.100 would not be because it has numbers larger than could be
represented by eight bits. This format is known as
dotted decimal notation. We’ll deep dive into
how some of this works in an upcoming
lesson about subnetting. The important thing to
know for now is that IP addresses are distributed in large sections to various
organizations and companies instead of being determined by hardware vendors. This means that IP
addresses are more hierarchical and easier to store data about than
physical addresses are. Think of IBM, which owns every single IP that has the
Number 9 as the first octet. At a very high level, this means that if an Internet router needs to
figure out where to send a data packet intended for
the IP address 90.0.0.1, that router only has to know to get it to one
of IBM’s routers. That router can handle the rest of the delivery
process from there. It’s important to call out that IP addresses belong
to the networks, not to the devices attached
to those networks. Your laptop will always have the same MAC address no
matter where you use it, but it’ll have a different
IP address assigned to it at an Internet cafe than it
would when you’re at home. The LAN at the Internet cafe or the LAN at your
house would each be individually responsible
for handing out an IP address to your laptop
if you power it on there. On a day-to-day basis, getting an IP address is usually a pretty
invisible process. You’ll learn more about some of the technologies that
play in a later lesson. For now, remember that
on many modern networks, you can connect a new device and an IP address will
be assigned to it automatically through
a technology known as Dynamic Host
Configuration Protocol. An IP address assigned this way is known as a
dynamic IP address. The opposite of this is known
as a static IP address, which must be configured
on a node manually. In most cases,
static IP addresses are reserved for servers and network devices while
dynamic IP addresses are reserved for clients. But there are
certainly situations where this might not be true.

Welcome to the world of IP datagrams, the tireless couriers of the internet! In this tutorial, we’ll dive into their structure, fields, and journey across networks. Get ready to uncover the secrets of internet communication!

Imagine a well-organized traveler’s backpack, packed with essentials for a successful journey. That’s an IP datagram, carrying crucial information to guide data across the internet. Let’s unpack its contents:

1. Structure:

• Backpack with Two Compartments: An IP datagram has a header (like a backpack’s top compartment for maps and tools) and a payload (like the main compartment for clothes and supplies).
• Clearly Labeled Pockets: The header contains meticulously organized fields, each with a specific purpose, ensuring a smooth journey.

2. Header Fields: Your Essential Guide:

• Version: A tag indicating the IP protocol version (IPv4 or IPv6) being used, like a luggage tag specifying travel mode (plane, train, or boat).
• Header Length: A ruler measuring the header’s size, ensuring everything fits snugly.
• Service Type: A VIP pass for priority treatment, indicating Quality of Service (QoS) requirements for time-sensitive data.
• Total Length: A measuring tape showing the entire datagram’s size, helping routers plan efficient routes.
• Identification: A group badge for keeping track of fragmented messages, ensuring all pieces arrive together.
• Flags & Fragmentation Offset: A puzzle instruction manual for reassembling fragmented datagrams in the correct order.
• Time to Live (TTL): A countdown timer preventing endless loops, limiting the number of router hops a datagram can traverse before being discarded.
• Protocol: A shipping label specifying the transport layer protocol (TCP or UDP), ensuring proper handling at the destination.
• Checksum: A meticulous inspector verifying data integrity during transmission, like a passport control officer checking for passport validity.
• Source & Destination IP Addresses: The travel itinerary, containing the sender’s and recipient’s addresses for accurate routing.
• Optional Fields (IP Options & Padding): Extra pockets for special instructions or padding to maintain a tidy structure.

3. Encapsulation: The Russian Nesting Doll of Networking:

• Datagram Within a Frame: Just as a backpack fits inside a suitcase, an IP datagram nests within an Ethernet frame, the physical layer’s packet format, for delivery across physical networks.
• Packet Within a Datagram: Like a suitcase containing a smaller backpack, the IP datagram carries a TCP or UDP packet within its payload, ensuring seamless communication between higher-level protocols.

4. Journey Across the Internet:

• Routers: The Traffic Guides: Routers, the internet’s tireless traffic controllers, examine IP datagram headers to determine the best routes, directing data towards its destination.
• Hop by Hop Delivery: Datagrams travel from router to router, like adventurers hopping from one destination to the next, until reaching their final goal.

Remember: IP datagrams are the foundation of internet communication. By understanding their structure and fields, you’ll gain a deeper appreciation of how information flows across the vast digital landscape. Stay tuned for more thrilling chapters in our networking adventure!

Just like all the data packets at
the ethernet layer have a specific name. Ethernet frames. So do packets at the network layer. Under the IP protocol, a packet is
usually referred to as an IP datagram. Just like any ethernet frame, IP datagram is a highly structured series
of fields that are strictly defined. The two primary sections of an IP
datagram are the header and the payload. You’ll notice that an IP datagram header
contains a lot more data than an ethernet frame header does. The very first field is four bits and indicates what version of
Internet Protocol is being used. The most common version of
IP is version 4 or IPv4. Version 6 or IPv6 is rapidly
seeing more widespread adoption after the version field we
have the header length field. This is also a four bit field that
declares how long the entire header is. This is almost always 20 bytes in length,
when dealing with IPv4. In fact 20 bytes is the minimum
length of an IP header. You couldn’t fit all the data you need for a properly formatted IP
header in any less space. Next we have the service type field. These 8 bits can be used to specify
details about quality of service or QoS technologies. The important takeaway about QoS is that
there are services that allow routers to make decisions about which IP datagram
maybe more important than others. The next field is a 16 bit field
known as the total length field. It’s used for exactly what it sounds like
to indicate the total length of the IP datagram it’s attached to. The identification field is a 16 bit
number that’s used to group messages together. IP datagrams have a maximum size and you
might already be able to figure out what that is since the total
length field is 16 bits and this field indicates the size
of an individual datagram. The maximum size of a single datagram
is the largest number you can represent with 16 bits 65,535. If the total amount of data that needs to
be sent is larger than what can fit in a single data gram the IP layer needs to
split this data up into many individual packets. When this happens,
the identification field is used so that the receiving end understands that
every packet with the same value in that field is part of the same transmission. Next up we have two closely
related fields the flag field and the fragmentation offset field. The flag field is used to indicate if
a datagram is allowed to be fragmented or to indicate that the datagram
has already been fragmented. Fragmentation is the process of
taking a single IP datagram and splitting it up into
several smaller datagrams. While most networks operate with similar
settings in terms of what size and IP datagram is allowed to be. Sometimes this could be configured
differently if a datagram has to cross from a network allowing a larger data gram
size to one with a smaller datagram size, the datagram would have to be
fragmented into smaller ones. The fragmentation offset field contains
values used by the receiving end to take all the parts of a fragmented packet and put them back together
in the correct order. Let’s move along to the time to live or
TTL field. This field is an 8 bit field that
indicates how many router hops a datagram can traverse
before it’s thrown away. Every time a datagram
reaches a new router, that router deck remains
the TTL field by one. Once this value reaches zero, a router knows it doesn’t have to
forward the datagram any further. The main purpose of this field
is to make sure that when there’s a miss configuration in
routing that causes an endless loop. Datagrams don’t spend all eternity
trying to reach their destination. And endless loop could be when router
A thinks router B is the next hop and router B thinks router A is the next hop. After the TTL field,
you’ll find the protocol field. This is another 8 bit field that contains
data about what transport layer protocol is being used. The most common transport layer
protocols are TCP and UDP. So next we find the header checksum field. This field is a check some of the contents
of the entire IP datagram header. It functions very much like the ethernet
checksum field we discussed in the last module since the TTL field
has to be re computed at every router that a data gram touches the check
some field necessarily changes too. After all of that we finally get to two
very important fields the source and destination IP address fields. Remember that an IP address is a 32 bit
number so it should come as no surprise that these fields are each 32 bits long
up next we have the IP options field. This is an optional field and
is used to set special characteristics for data grams primarily used for
testing purposes. The IP options field is usually followed
by a padding field since the IP options field is both optional and
variable in length. The padding field is just a series of
zeroes used to ensure the header is the correct total size. Now that you know about all of
the parts of an IP datagram. You might wonder how this relates
to what we’ve learned so far. You might remember that in
our breakdown of an ethernet frame we mentioned a section we
described as the data payload section. This is exactly what
the IP datagram is and this process is known as encapsulation. The entire contents of an IP datagram
are encapsulated as the payload of an ethernet frame. You might have picked up on the fact
that our IP datagram also has a payload section. The contents of this payload
are the entirety of a TCP or UDP packet. Hopefully this helps you better
understand why we talk about networking in terms of layers,
each layer is needed for the one above it.

Welcome to the IP Address Academy! Today’s lesson explores IP address structure and classes, the organizational system that keeps the internet’s addressing system in check. Let’s dive in!

Imagine IP addresses as postal codes for the digital world:

• They guide data to the correct destinations across vast networks.
• They’re structured like numerical ZIP codes, but with a unique twist!

IP Address Breakdown:

• Octets: IP addresses consist of four blocks of numbers, called octets, each ranging from 0 to 255.
• Dotted Decimal Notation: They’re written in a format like 192.168.1.100, separating each octet with a dot.

Unlocking the Network ID and Host ID:

• Network ID: Think of it as the city in a postal code. It identifies a specific network within the internet.
• Host ID: It’s like the street address within a city, pinpointing a particular device on that network.

Sorting into Classes:

Class A:

• First octet for network ID, leaving a spacious 3 octets for host IDs.
• Ideal for large networks with many devices.
• First octet ranges from 0 to 127.

Class B:

• First two octets for network ID, allowing for 2 octets of host IDs.
• Suitable for medium-sized networks.
• First octet ranges from 128 to 191.

Class C:

• First three octets for network ID, providing a single octet for host IDs.
• Designed for smaller networks.
• First octet ranges from 192 to 223.

Specialized Classes:

• Class D: Used for multicasting, sending data to multiple devices simultaneously.
• Class E: Reserved for experimental and testing purposes.

Beyond Classes: CIDR:

• While classes offer a structured approach, a newer system called CIDR (Classless Inter-Domain Routing) provides more flexibility in allocating IP addresses.

Key Takeaways:

• Understanding IP address structure and classes unlocks the logic behind internet addressing.
• This knowledge empowers you to troubleshoot network issues and grasp core networking concepts.
• Stay tuned for more exciting lessons as we delve deeper into the world of IP networking!

IP addresses can be
split into two sections; the network ID and the host ID. Earlier, we mentioned that
IBM owns all IP addresses that have a nine as the value of the first
octet in IP address. If we take an example IP
address of 9.100.100.100, the network ID will be the first octet and the host
ID would be the second, third, and fourth octets. The address class
system is a way of defining how the global IP
address space is split up. There are three primary types of address classes:
Class A, class B, and class C. Class A
addresses are those where the first octet is used
for the network ID and the last three are
used for the host ID. Class B addresses are where
the first two octets are used for the network ID and the second two are used
for the host ID. Class C addresses, as
you might have guessed, are those where the first
three octets are used for the network ID and only the final octet is
used for the host ID. Each address class represents a network of vastly
different size. For example, since a
class A network has a total of 24 bits
of host ID space, this comes out to 2^24th or 16,777,216
individual addresses. Compare this with
a Class C network which only has eight
bits of host ID space. For a Class C network, this comes out to 2^8
or 256 addresses. You can also tell exactly
what address class an IP address belongs to
just by looking at it. If the very first bit of
an IP address is zero, it belongs to a Class A network. If the first bits are 10, it belongs to a Class B network. Finally, if the
first bits are 110, it belongs to a Class C network. Since humans aren’t great
at thinking in binary, it’s good to know that this
also translates nicely to how these addresses are represented in dotted
decimal notation. You might remember
that each octet in an IP address is eight bits, which means each octet can take a value between zero and 255. If the first bit
has to be a zero, as it is with the
Class A address, the possible values for
the first octet are 0-127. This means that any
IP address with a first octet with one of those values is a
Class A address. Similarly, Class B addresses are restricted to those that begin
with the first octet value of 128 through 191
and Class C addresses begin with the first octet
value of 192 through 223. You might notice
that this doesn’t cover every possible IP address. That’s because there are two
other IP address classes, but they’re not quite as
important to understand. Class D addresses always
begin with the bits 1110 and are used
for multicasting, which is how a
single IP datagram can be send to an
entire network at once. These addresses begin
with decimal values between 224 and 239. Lastly, Class E addresses makeup all of the
remaining IP addresses, but they are unassigned and only used for testing purposes. In practical terms,
this class system has mostly been replaced by a system known as CIDR or Classless
Inter-Domain Routing. But the address class system is still in place in
many ways and is important to
understand for anyone looking for a well-rounded
networking education, And you know we’re
all about that.

Welcome to the Network Matchmaker’s Office, where ARP works its magic! Today’s lesson explores how ARP bridges the gap between MAC and IP addresses, ensuring data finds its perfect match on the network. Let’s dive in!

Imagine a bustling city with two address systems:

• MAC addresses: Like house numbers, unique to each device on a local network.
• IP addresses: Like postal codes, identifying devices across the internet.

The Problem: Data needs both to reach its destination!

Introducing ARP, the Network Detective:

• It’s like a skillful private eye, uncovering MAC addresses for known IPs.

ARP in Action:

1. IP Datagram Needs a Ride: An IP datagram, ready for travel, needs to be packaged into an Ethernet frame. But it’s missing the destination’s MAC address!
2. Broadcasting a Search Warrant: The sender broadcasts an ARP request, essentially shouting, “Who has the MAC address for IP 10.20.30.40?”
3. Target Identity Revealed: The device with that IP proudly responds with its MAC address, like announcing, “That’s me!”
4. Completing the Delivery Address: The sender now has the missing piece to complete the Ethernet frame’s header, ensuring accurate delivery.
5. Address Book for Future Connections: The sender saves this IP-MAC pair in its ARP table, like jotting down a contact in an address book, for quick reference in future communications.
6. Keeping It Fresh: ARP table entries eventually expire, like updating old addresses, to ensure the network’s information stays current.

Key Takeaways:

• ARP is the invisible glue that connects different network layers, enabling seamless data exchange.
• It’s like a GPS for packet delivery, mapping IP addresses to their physical locations.
• Understanding ARP empowers you to troubleshoot network issues and appreciate the intricate coordination behind every online interaction.

Congrats! You now understand how both MAC
addresses are used at the data link layer and how IP addresses are used
at the network layer. Now we need to discuss how these two
separate address types relate to each other. This is where address resolution
protocol, or ARP, comes into play. ARP is a protocol used to discover
the hardware address of a node with a certain IP address. Once an IP datagram
has been fully formed, it needs to be encapsulated
inside an Ethernet frame. This means that the transmitting device
needs a destination MAC address to complete the Ethernet frame header. Almost all network connected devices will
retain a local ARP table. An ARP table is just a list of IP addresses and
the MAC address is associated with them. Let’s say we want to send some data
to the IP address 10.20.30.40. It might be the case that this destination
doesn’t have an entry in the ARP table. When this happens, the node
that wants to send data sends a broadcast ARP message to the MAC
Broadcast address, which is all Fs. These kinds of broadcast ARP messages
are delivered to all computers on the local network. When the network interface
that’s been assigned an IP of 10.20.30.40 receives this ARP broadcast, it sends
back what’s known as an ARP response. This response message will
contain the MAC address for the network interface in question. Now the transmitting computer knows what
MAC address to put in the destination hardware address field and
the Ethernet frame is ready for delivery. It will also likely store this IP address
in its local ARP table so that it won’t have to send an ARP broadcast the next
time it needs to communicate with this IP. Handy. ARP table entries generally expire
after a short amount of time to ensure changes in the network are accounted for.

[MUSIC] My name is Sergey Letter and
I’m a network engineer at google, when I was just a young kid. I liked analog tools like screwdrivers and
drills and then I like taking things apart, and
then as I got older in my teenage years. I realized I could take apart computers
and then that really interested me because when you opened it up it was fans,
lights, the circuitry. And I just didn’t understand
it didn’t make sense to me but if I knew if I put it
together the right way. I could actually interact with it and have
fun and play my video games off of it and that’s kind of how it really started. And by the time when I got a little older
outside of high school, I realized I could make this a passionate and actually
really learn how this technology works. I think the favorite part
is solving the problems, I really enjoy when we get to see
data go from one device to another. And how things communicate and how the
customers get to enjoy it, I’ve gained so many different tools and skills. And now I feel like a swiss army
knife when I’m working and there’s so many different experiences I can bring
back to solve problems I face today. Early starting off as an entry
level network technician, I had a project to upgrade a firewall for
a police department. And the firewall basically is
the security appliance and the entry point to the network. We thought it worked it went through
successfully until I got a phone call very late at night that things were broken. And when we realized that emails and
police calls, we’re not going through and
that the upgrade failed. And at that point, I realized
the magnitude of the things that I am working on can affect people’s lives and
it can cause harm and it can cause good. So it was really a good
humbling experience for me when I was working on that project.

Subnetting in a Nutshell: Conquer Network Complexity with Smaller Bites

Feeling overwhelmed by the sprawling jungle of IP addresses? Don’t worry, network explorer! This tutorial is your machete, ready to help you chop through confusion and master the art of subnetting.

Imagine a city: A bustling metropolis with millions of residents. Can you deliver a pizza to a specific apartment without knowing the street and building number? That’s like trying to route data in a single giant network – inefficient and chaotic.

Enter subnetting: Our network superhero! It’s the art of carving that mega-city into manageable neighborhoods called subnets. Each subnet has its own gateway router, like a friendly concierge directing data to its residents (devices).

Why subnet? Think convenience and control:

• Faster traffic flow: Smaller neighborhoods mean less congestion, speeding up data delivery.
• Enhanced security: Each subnet can have its own security rules, keeping sensitive data safe.
• Resource allocation: Imagine dividing pizza among friends. Subnetting lets you allocate IP addresses efficiently.

Meet the key players:

• Address classes: Think city districts like Class A, B, C, dividing the internet space.
• Network ID: The street address, identifying the subnet (like “Elm Street”).
• Host ID: The apartment number, identifying the specific device (like “123”).
• Gateway router: The friendly concierge, controlling traffic into and out of the subnet.

Unveiling the magic:

• Subnet mask: This handy mask works like a decoder ring, revealing which bits in an IP address belong to the network and which to the host.
• CIDR: A shorthand notation using a slash (/) and the number of bits for the network, simplifying subnet naming.
• Binary math: Don’t panic! Basic binary understanding helps decode IP addresses and masks.

IT needs subnetting superpowers:

• Troubleshooting network issues often involves untangling messy subnetting.
• Strong subnetting skills are an IT hero’s secret weapon!

Ready to master the art? Here’s your training plan:

1. Grasp the basics: Understand address classes, network/host IDs, and gateway routers.
2. Unmask the power of subnet masks: Learn how they work and how to calculate them.
3. Embrace CIDR’s simplicity: Practice using CIDR notation for clear communication.
4. Conquer binary basics: Get comfortable with binary numbers to decode IP addresses and masks.
5. Practice makes perfect: Don’t be afraid to experiment! Subnetting challenges will hone your skills.

Remember: Subnetting isn’t just about dividing, it’s about organizing and optimizing network resources. With dedication and practice, you’ll be slicing through network complexity like a pro!

Bonus tip: Online resources like subnetting calculators and practice exercises can be your training allies.

So, grab your subnet mask and prepare to tame the network beast! With these tools and this tutorial, you’ll be subnetting with confidence in no time.

In the most basic of terms, subnetting is the process of taking a large network
and splitting it up into many individual smaller
subnetworks or subnets. By the end of this lesson, you’ll be able to explain why subnetting is necessary
and describe how subnet masks extend what’s possible with just
network and host IDs. You’ll also be able to discuss
how a technique known as cider allows for even more flexibility
than plain subnetting. Lastly, you’ll be able to apply some basic binary
math techniques to better understand
how all of this works. Incorrect subnetting setups are a common problem you might run into as an IT
support specialist, so it’s important to have a strong understanding
of how this works. That’s a lot, so let’s dive in. Address classes give
us a way to break the total global IP space
into discrete networks. If you want to communicate with the IP address 9.100.100.100, core routers on the
Internet know that this IP belongs to the 9.O.O.O
Class A network. They then route the message
to the gateway router responsible for the network
by looking at the network ID. A gateway router
specifically serves as the entry and exit path
to a certain network. You can contrast this with
core Internet routers, which might only speak
to other core routers. Once your packet gets to
the gateway router for the 9.O.O.O Class A network, that router is now
responsible for getting that data to the proper system
by looking at the host ID. This all makes sense until you remember that a single
Class A network contains 16,777,216
individual IPs. That’s just way too many devices to connect to the same router. This is where
subnetting comes in. With subnets, you can split your large network up
into many smaller ones. These individual subnets will
all have their own gateway router’s serving as the ingress and egress point
for each subnet.

Network IDs & Subnet Masks: Unveiling the Magic Behind IP Addresses

Ever wondered how millions of devices around the world communicate seamlessly under one internet banner? The secret lies in a clever system of addresses and sub-addresses, orchestrated by a powerful duo: network IDs and subnet masks.

Imagine a bustling city: millions of residents living in various districts, streets, and apartments. Network IDs and subnet masks act like a sophisticated mapping system for this digital metropolis.

Network IDs:

• Think of them as the city districts. They identify large groups of devices on the same network, similar to how a district name identifies a specific area within the city.
• Network IDs are typically the first part of an IP address, separated by periods. For example, in the IP address 192.168.1.10, the “192.168.1” portion represents the network ID.

Subnet Masks:

• Now, imagine dividing each district into smaller neighborhoods. Subnet masks act like neighborhood boundaries, further segmenting the network into smaller, more manageable subnetworks.
• Subnet masks are also 32-bit numbers written in four decimal octets, just like IP addresses. But instead of identifying devices, they tell routers how to distinguish between the network ID, subnet ID (the neighborhood), and host ID (the specific apartment).

Think of a subnet mask as a decoder ring:

• Ones in the mask correspond to bits used for the network and subnet IDs.
• Zeros in the mask correspond to bits used for the host ID.

Why subnetting?

• Improved organization: Imagine delivering a pizza in a giant city without knowing the district or street – messy and inefficient! Subnetting organizes devices into smaller, easier-to-manage units, optimizing data flow and reducing network congestion.
• Enhanced security: Different subnets can have their own security rules, restricting access and protecting sensitive data within specific areas.
• Efficient resource allocation: Subnetting allows for allocating IP addresses more effectively, preventing waste and ensuring adequate resources for each subnetwork.

Decoding subnet masks:

• Common subnet masks often appear as “magic numbers” like 255.255.255.0. But understanding their binary representation unlocks the magic!
• In this example, the first 24 ones define the network and subnet IDs (24 bits), leaving the last 8 zeros for the host ID (8 bits).

The power of CIDR:

• CIDR (Classless Inter-Domain Routing) notation simplifies subnet mask representation using a slash (/) followed by the number of bits used for the network and subnet IDs (e.g., 192.168.1.10/24).
• This makes communication about subnets clear and concise, eliminating the need to memorize cryptic subnet mask numbers.

Mastering the art:

• Practice makes perfect! Experiment with different subnet masks and CIDR notations to solidify your understanding.
• Online resources like subnetting calculators and practice exercises can be your training allies.

Remember: Network IDs and subnet masks are the cornerstones of efficient network organization and communication. By understanding their roles and mastering their application, you unlock the power to navigate the digital metropolis with confidence!

Bonus tip: Subnetting skills are highly sought-after in IT professions. Mastering this powerful tool can boost your career prospects and empower you to tackle complex network challenges.

I hope this tutorial, with its visual aids and practical insights, demystifies the magic behind network IDs and subnet masks. Feel free to ask any questions you may have as you embark on your network exploration journey!

So far, we’ve learned
about network IDs, which are used to identify
networks and host IDs, which are used to identify
individual hosts. If we want to split things
up even further and we do, we’ll need to introduce a
third concept, the subnet ID. You might remember that an IP address is just
a 32-bit number. In a world without subnets, a certain number of
these bits are used for the network ID and
a certain number of the bits are used
for the host ID. In a world with subnetting, some bits that would
normally comprise the host ID are actually
used for the subnet ID. With all three of these IDs representable by a
single IP address, we now have a single
32-bit number that can be accurately delivered across
many different networks. At the Internet
level, core routers only care about the network ID and use this to
send the datagram along to the appropriate
gateway router to that network. That gateway router then has some additional information
that it can use to send the datagram along to the destination machine or the next router in the
path to get there. Finally, the host ID is used by that last router to deliver the datagram to the
intended recipient machine. Subnet IDs are calculated via what’s known
as a subnet mask. Just like an IP address, subnet masks are
32-bit numbers that are normally written out
as four octets in decimal. The easiest way to
understand how subnet masks work is to compare
one to an IP address. Subnet masks are often glossed
over as magic numbers. People just memorize
some of the common ones without fully
understanding what’s going on behind the scenes. In this course, we’re really
trying to ensure that you leave with a well-rounded
networking education. Even though subnet masks
can seem tricky at first, stick with it and you’ll get
the hang of it in no time. Let’s work with the IP
address 9.100.100.100 again. You might remember that each part of an IP
address is an octet, which means that it
consists of eight bits. The Number 9 in
binary is just 1001. But since each octet
needs eight bits, we need to pad it with
some zeros in front. As far as an IP
address is concerned, having a Number 9 as the
first octet is actually represented as 0000 1001. Similarly, the numeral 100 as an eight-bit number
is 0110 0100. The entire binary representation
of the IP address 9.100.100.100 is a lot
of ones and zeros. A subnet mask is a binary
number that has two sections. The beginning part, which
is the mask itself, is a string of ones. Just zeros come after this. The subnet mask,
which is the part of the number with all the ones, tells us what we can ignore
when computing a host ID. The part with all the zeros
tells us what to keep. Let’s use the common subnet
mask of 255.255.255.0. This would translate to 24
ones followed by eight zeros. The purpose of the mask or
the part that’s all ones, is to tell a router what part of an IP address
is the subnet ID. You might remember that
we already know how to get the network ID
for an IP address. For 9.100.100.100
a class A network. We know that this is
just the first octet. This leaves us with
the last three octets. Let’s take those remaining
octets and imagine them next to the subnet
mask in binary form. The numbers in the remaining
octets that have a corresponding one in the
subnet mask are the subnet ID. The numbers in the remaining
octets that have a corresponding zero
are the host ID. The size of a subnet is entirely defined by
its subnet mask. For example, with a subnet
mask of 2550255.255.0, we know that only the last
octet is available for host IDs regardless of what size the network
and subnet IDs are. A single eight-bit number can represent 256 different numbers, or more specifically,
the numbers 0-255. This is a good time to
point out that in general, a subnet can usually
only contain two less than the total
number of host IDs available. Again, using a subnet
mask of 255.255.255.0, we know that the octet
available for host IDs can contain the numbers 0-255, but zero is generally not used, and 255 is normally reserved as a broadcast
address for the subnet. This means that really
only the numbers 1-254 are available for
assignment to a host. While this total number
less than two approach is almost always true. Generally speaking, you’ll
refer to the number of hosts available in a subnet
as the entire number. Even if it’s understood that two addresses aren’t
available for assignment, you’d still say that eight-bits
of host ID space have 256 addresses
available, not 254. This is because those other
IPs are still IP addresses, even if they aren’t assigned directly to a node
on that subnet. Now, let’s look at a subnet
mask that doesn’t draw its boundaries at
an entire octet or eight-bits of address. The subnet mask 255.255.255.224 would translate to 27 ones
followed by five zeros. This means that we
have five bits of host ID space or a
total of 32 addresses. This brings up a shorthand
way of writing subnet masks. Let’s say we’re dealing
with our old friend, 9.100.100.100 with a subnet
mask of 255.255.255.224. Since that subnet
mask represents 27 ones followed by five zeros, a quicker way of
referencing this is with the notation /27. The entire IP and
subnet mask could be written out as 9.100.100.100/27. Neither notation is necessarily more common than the other, so it’s important
to understand both.

Welcome to the Binary Numbers and Subnet Masks Tutorial!

In this tutorial, you’ll unravel the mysteries of binary numbers and discover how they play a crucial role in networking concepts like subnet masks.

Let’s dive in!

Part 1: Exploring the World of Binary

1. What Are Binary Numbers?

• Computers use binary numbers (base 2) instead of decimal numbers (base 10).
• Binary only uses two digits: 0 and 1.
• It’s the foundation of computer logic and data storage.

2. Counting in Binary

• Just like decimal counting, increment digits and add columns for higher values.
• Example: 0, 1, 10 (2), 11 (3), 100 (4), 101 (5), 110 (6), 111 (7)

3. Bits and Representation

• Each 0 or 1 is a “bit.”
• Common groupings:
  • 8 bits = 1 byte
  • 16 bits = 1 word
  • 32 bits = 1 double word
• Number of values representable by ‘n’ bits = 2^n
  • Example: 8 bits can represent 2^8 = 256 values

4. Binary Arithmetic

• Simple addition:
  • 0+0=0, 0+1=1, 1+0=1, 1+1=10 (carry over to next column)

5. Logical Operators

• AND: 1 and 1 = 1, otherwise 0
• OR: 1 or 1 = 1, 1 or 0 = 1, otherwise 0
• Crucial for computer decision-making

Part 2: Unmasking Subnet Masks

1. What Are Subnet Masks?

• Divide larger networks into smaller, more manageable subnetworks.
• Improve efficiency, security, and organization.

2. Subnet Masks and Binary

• Typically 32-bit numbers like IP addresses.
• Use AND operator with IP address to extract network ID.
• Example: 255.255.255.0 mask with 192.168.1.100 address = network ID 192.168.1.0

3. CIDR Notation

• Compact representation: slash (/) followed by number of network bits.
• Example: 192.168.1.0/24 (24 bits for network, 8 bits for hosts)

Part 3: Hands-On Practice

• Convert decimal to binary and vice versa.
• Perform binary addition.
• Apply subnet masks to IP addresses.

Conclusion

• Binary numbers are fundamental to computing.
• Subnet masks leverage binary logic for network organization.
• Mastering these concepts empowers you to explore advanced networking topics!

Ready for more?

• Explore subnet calculations and CIDR notation.
• Delve into digital logic gates and Boolean algebra.
• Experiment with subnetting tools and practice scenarios.

Binary numbers can
seem intimidating at first since they look so
different from decimal numbers. But as far as the basics go, the math behind counting, adding or subtracting
binary numbers is exactly the same as
with decimal numbers. It’s important to call out that there aren’t different
kinds of numbers. Numbers are universal. There are only
different notations for how to reference them. Humans, most likely
because most of us have 10 fingers and
10 toes decided on using a system with 10 individual numerals used
to represent all numbers. The numerals 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9 can be combined in ways to represent any
whole number in existence. Because there are
10 total numerals in use in a decimal system, another way of referring
to this is as base 10. Because of the
constraints of how logic gates work inside
of a processor, it’s way easier for
computers to think of things only in terms of 0 and 1. This is also known
as binary or base 2. You can represent
all whole numbers in binary in the same way
you can in decimal, it just looks a
little different. When you count in decimal, you move through
all the numerals upward until you run out, then you add a second column
with a higher significance. Let’s start counting at
zero until we get to nine. Once we get to nine, we basically just start over. We add a one to a new column, then start over at zero
in the original column. We repeat this
process over and over in order to count
all whole numbers. Counting in binary
is exactly the same. It’s just that you only have
two numerals available. You start with zero, which is the same as zero in decimal, then you increment once. Now you have one, which is
the same as one in decimal. Since we’ve already run
out of numerals to use, it’s time to add a new column. So now we have the number 1, 0, which is the same
as two in decimal, 1, 1 is three, 1, 0, 0, is four, 1 0, 1 is five, 1, 1, 0 is six, 1, 1, 1 is seven, etc. It’s the exact same thing
we do with decimal, just with fewer numerals
at our disposal. When working with various
computing technologies, you’ll often run into the
concept of bits or 1s and 0s. There’s a pretty simple
trick to figure out how many decimal numbers can be represented by a
certain number of bits. If you have an eight bit number, you can just perform
the math, 2^8. This gives you 256, which lets you know that
an eight bit number can represent 256 decimal numbers, or put another way,
the numbers 0-255. A four bit number would be 2^4, or 16 total numbers. A 16-bit number would be
2^16 or 65,536 numbers. In order to tie this back to
what you might already know, this trick doesn’t
only work for binary, it works for any number system, it’s just the base changes. You might remember that we
can also refer to binary as base 2 and
decimal as base 10. All you need to do
is swap out the base for what’s being raised
to the number of columns. For example let’s take a base 10 number with two
columns of digits. This would translate to 10^2. 10^2=100, which is exactly
how many numbers you can represent with two columns
of decimal digits, or the numbers 0-99. Similarly, 10^3 is 1,000, which is exactly how many
numbers you can represent with three columns of decimal
digits or the numbers 0-999. Not only is counting in
different bases the same, so it’s simple arithmetic
like addition. In fact, binary addition is even simpler than
any other base, since you only have four
possible scenarios. 0+0=0, just like in decimal, 0+1=1 and 1+0=1, should
also look familiar. 1+1= 10, looks a
little different, but should still make sense. You carry a digit
to the next column once you reach 10 in
doing decimal addition, you carry a digit to
the next column once you reach two when
doing binary addition. Addition is what’s
known as an operator, and there are many
operators that computers use to
make calculations. Two of the most important
operators are or and and. In computer logic,
a 1 represents true and a 0 represents false. The way the or operator
works is you look at each digit and if either of them is true, the
result is true. The basic equation
is X or Y equals Z, which can be read as if
either X or Y is true, then Z is true,
otherwise it’s false. Therefore, 1 or 0=1, but 0 or 0=0. The operator and does what
it sounds like it does, it returns true if
both values are true. Therefore, 1 and 1=1, but 1 and 0=0 and 0
and 0=0, and so on. Now, you might be wondering why we’ve
covered all of this. I know it’s not to confuse you. It’s all really to help explain
subnet masks a bit more. A subnet mask is a way for a computer to use
and operators to determine if an IP address
exists on the same network. This means that the
host ID portion is also known since it’ll
be anything left out. Let’s use the binary
representation of our favorite IP address, 9.100.100.100, and our favorite subnet
mask 255.255.255.0. Once you put one on
top of the other and perform a binary and
operator on each column you’ll notice that the
result is the network ID and subnet ID portion of our
IP address, or 9.100.100. The computer that just perform this operation can now
compare the results with its own network ID
to determine if the address is on the same
network or a different one. I bet you never
thought you’d have a favorite IP address or subnet, but that’s what happens in the wonderful world
of basic binary math.

Address classes were
the first attempt that splitting up the global
Internet IP space. Subnetting was introduced
when it became clear that address classes
themselves weren’t a sufficient way of keeping
everything organized. But as the Internet
continued to grow, traditional subnetting
just couldn’t keep up. With traditional subnetting
and the address classes, the network ID is always either eight bit for
class A networks, 16 bit for Class B networks, or 24 bits for class C networks. This means that
there might only be 254 class A networks
in existence. But it also means there are 2,097,152 potential
class C networks. That’s a lot of entries
in a routing table. To top it all off, the sizing
of these networks aren’t always appropriate for the
needs of most businesses. 254 hosts in a class C network is too small for many use cases. But the 65,534 hosts available for use in a class B network
is often way too large. Many companies ended up with various adjoining class C
networks to meet their needs. That meant that routing tables ended up with a
bunch of entries for a bunch of class C
networks that were all actually being routed
to the same place. This is where CIDR or classless inter-domain
routing comes into play. CIDR is even more
flexible approach to describing blocks
of IP addresses. It expands on the
concept of subnetting by using subnet masks to
demarcate networks. To demarcate something
means to set something off. When discussing
computer networking, you will often hear the
term demarcation point to describe where one network or system ends and
another one begins. In our previous model, we relied on a network ID, subnet ID, and host ID to deliver an IP datagram
to the correct location. With CIDR, the network ID and subnet ID are
combined into one. CIDR is where we get this shorthand
slash notation that we discussed in the earlier
video on subnetting. This slash notation is also
known as CIDR notation. CIDR basically just abandons the concept of address
classes entirely, allowing an address to be defined by only two
individual IDs. Let’s take 9.100.100.100 with a net mask of 255.255.255.0. Remember, this can also be
written as 9.100.100.100/24. In a world where we
no longer care about the address class of this IP, all we need is what
the network mask tells us to determine
the network ID. In this case, that
would be 9.100.100. The host ID remains the same. This practice not only
simplifies how routers and other network devices
need to think about parts of an IP address, but it also allows for more
arbitrary network sizes. Before, network
sizes were static, think only class A, class B, or class C, and only subnets could
be of different sizes. CIDR allows for networks themselves to be
differing sizes. Before this, if a company needed more addresses than a single
class C could provide, they need an entire
second class C. With CIDR they could combine
that address space into one contiguous chunk
with a net mask of slash 23 or 255.255.254.0. This means that routers now only need to know one entry in the routing table to deliver traffic to these
addresses instead of two, It’s also important to
call out that you get additional available host
IDs out of this practice. Remember that you always lose
to host IDs per network. If a slash 24 network has
2^8 or 256 potential hosts, you really only have 256 – 2 or 254 available
IPs to assign. If you need two
networks of this size, you have a total of 254

• 254 or 508 hosts. A single slash 23 network,
  on the other hand, is 2^9 or 512, 512 – 2, 510 hosts. Take a second and lock
  that into your memory.

If something is stumping you or you feel stuck
at a certain aspect, there’s always someone else who’s going through
the same thing. Anytime I started to
feel overwhelmed by information or I just
wasn’t getting it. I wasted so much time being unsure of myself
that I should have just listened to my friends and family when they said just
do it, you can do it. One of the greatest thing
that helped me to get back motivating is
the accessibility of the course on my phone, I was just able to go
into the app and listen to a few videos because
I can learn on the go. Having a network of people that motivates you, it’s
so fundamental. Even if it’s a friend or it is a family members that you
can get from the beginning, and he can be there for you
on your corner like a coach. Don’t be afraid to ask for help, whether it be from your peers, from your coaches,
friends, family. There’s always someone who knows more and you
can learn from them.

Demystifying the Maze: A Guide to Internet Routing

Imagine the internet as a vast highway system, connecting people and information across the globe. But unlike physical roads, the internet’s pathways are invisible, woven together by a complex dance of data packets and intelligent devices called routers. This tutorial aims to equip you with the knowledge to navigate this intricate maze, understanding how internet routing works and its vital role in our interconnected world.

1. The Building Blocks: Packets and IP Addresses

Our journey begins with understanding the basic units of information traveling through the internet: packets. Think of them as sealed envelopes containing data, like emails, website content, or video streams. Each packet carries a unique identifier called an IP address – its digital passport specifying its destination.

2. The Gatekeepers: Routers and Routing Tables

Picture traffic lights and road signs on the highway. In the internet world, these roles are played by routers. These intelligent devices sit at intersections of networks, directing packets based on their IP addresses. Each router houses a crucial map called a routing table, listing destination networks and the paths to reach them.

3. The Routing Dance: From Source to Destination

Now, let’s follow a packet’s journey:

1. Sent: A device creates a packet with its destination IP address (e.g., for accessing a website).
2. Local Gateway: The device sends the packet to its local gateway – usually a router provided by your internet service provider (ISP).
3. Route Lookup: The router examines the packet’s IP address and consults its routing table.
4. Path Forward: Based on the table, the router identifies the next “hop” on the journey – another router closer to the destination network.
5. Forwarding: The router sends the packet to the next hop router, repeating steps 3-5 until it reaches the destination network.
6. Delivery: Finally, the packet arrives at its intended device, and the information it carries is delivered (e.g., the website content gets displayed on your screen).

4. Advanced Routing Concepts:

This basic process forms the foundation of internet routing. However, the real world is more complex. Here are some additional concepts to consider:

• Multiple Paths: Often, multiple routes exist to reach a destination. Routers choose the “best” path based on factors like speed, congestion, and cost.
• Dynamic Routing: Routing tables are not static; they constantly update based on real-time network conditions through protocols like BGP (Border Gateway Protocol).
• Network Hierarchies: The internet is organized in a hierarchical structure, with different types of routers handling traffic at various levels.

5. Why Understanding Routing Matters:

Knowing how internet routing works empowers you in several ways:

• Troubleshooting: You can better diagnose connectivity issues by understanding the path your data takes.
• Security Awareness: Knowing about potential vulnerabilities in routing protocols can help you stay secure online.
• Appreciation for Technology: You gain a deeper appreciation for the invisible infrastructure that keeps our digital world connected.

6. Resources for Further Exploration:

This tutorial provides a basic overview of internet routing. To delve deeper, check out these resources:

• Interactive Tutorials: Cisco Networking Academy offers interactive tutorials on routing concepts: https://www.netacad.com/
• Books: “Routing TCP/IP” by Jeff Doyle and “Internet Routing Primer” by Mark Gilmore are excellent resources for deeper understanding.
• Online Communities: Engage with other network enthusiasts in online forums and communities to discuss routing and related topics.

Remember, mastering internet routing takes time and dedication. But with the knowledge gained here and your continued exploration, you can confidently navigate the intricate pathways of the online world!

The internet is an incredibly
impressive technological achievement. It meshes together millions
of individual networks and allows communications
to flow between them. From almost anywhere in the world, you can
now access data from almost anywhere else. Often in just fractions of a second. The way communications happen
across all these networks, allowing you to access data from the other
side of the planet is through routing. By the end of this lesson, you’ll be able
to describe the basics of routing and how routing tables work. You’ll be able to define some of the major
routing protocols and what they do and identify non routable address space and
how it’s used. You’ll also gain an understanding
of the RFC system and how it made the internet what it is today. All of these are very important
skills in order to troubleshoot the networking issues you might run
into as an IT support specialist. Routing is one of those things that is
both very simple and very complex, at a very high level what routing is and how
routers work is actually pretty simple. But underneath the hood,
routing is a very complex and technologically advanced topic. Entire books have been
written about the topic. Today, most intensive routing issues
are almost exclusively handled by ISPs and only the largest of companies. We’ll arm you with the basic overview
of routing to give you a well rounded networking education since it’s
an important topic to understand no matter what. But by no means will our
coverage be exhaustive. From a very basic standpoint,
a router is a network device that forwards traffic depending on the destination
address of that traffic. A router is a device that has at least
two network interfaces since it has to be connected to two networks to do its
job, basic routing has just a few steps. One, a router receives a packet
of data on one of its interfaces. Two, the router examines
the destination IP of this packet. Three, the router then looks up
the destination network of this IP in its routing table. Four, the router forwards that out through
the interface that’s closest to the remote network as determined by additional
info within the routing table. These steps are repeated as often
as needed until the traffic reaches its destination. Let’s imagine a router
connected to two networks. We’ll call the first network network A and give it an address space
of 192.168.1.0/24. We’ll call the second
network network B and give it an address space of 10.0.0.0/24. The router has an interface
on each network. On network A,
it has an IP of 192.168.1.1 and on network B it has an IP of 10.0.0.254. Remember IP addresses belong to networks,
not individual nodes on a network. A computer on network A with
an IP address of 192.168.1.100 sends a packet to the address 10.0.0.10. This computer knows that 10.0.0.10,
isn’t on its local subnets. So it sends this packet to the MAC
address of its gateway, the router. The router’s interface on network
A receives the packet because it sees that destination MAC
address belongs to it. The router then strips away
the data link layer encapsulation, leaving the network layer content,
the IP datagram. Now, the router can directly
inspect the IP datagram header for the destination IP field. It finds the destination IP of 10.0.0.10. The router looks at its routing table and
sees that network B or the 10.0.0.0/24, network is the correct
network for the destination IP. It also sees that this network is only
one hop away in fact, since it’s directly connected, the router even has the MAC
address for this IP in its ARP table. Next, the router needs to form a new
packet to forward along to network B, it takes all of the data from the first
IP datagram and duplicates it, but it detriments the TTL field by one and
calculates a new checksum. Then, it encapsulates this new IP
datagram inside of a new Ethernet frame. This time it sets its own MAC
address of the interface on network B as the source MAC address. Since it has the MAC address
of 10.0.0.10 in its ARP table, it sets that as
the destination MAC address. Lastly, the packet is sent out of
its interface on network B and the data finally gets delivered
to the node living at 10.0.0.10. That’s a pretty basic example
of how routing works, but let’s make it a little more complicated
and introduced a third network. Everything else is still the same. We have network A whose address
space is 192.168.1.0/24, we have network B whose
address space is 10.0.0.0/24. The router that bridges these two
networks still has the IPs of 192.168.1.1 on network A and
10.0.0.254 on network B. But let’s introduce a third network,
network C it has an address space of 172.16.1.0/23. There’s a second router connecting
network B and network C, its interface on network B
has an IP of 10.0.0.1 and its interface on network C
has an IP of 172.16.1.1. This time around our
computer at 192.168.1.100 wants to send some data to the computer
that has an IP of 172.16.1.100. We’ll skip the data link layer stuff, but remember that it’s still
happening of course. The computer at 192.168.1.100 knows that 172.16.1.100 is not on its local network. So it sends the packet to its gateway,
the router between network A network B. Again, the router inspects
the content of this packet, it sees a destination
address of 172.16.1.100. And through a look up
of its routing table, it knows that the quickest
way to get to the 172.16.1.0 /23 network is via another
router with an IP of 10.0.0.1. The router detriments the TTL field and sends it along to the router of 10.0.0.1. This router then goes through the motions, knows that the destination IP of
172.16.1.100 is directly connected and forwards the packet to its final
destination, that’s the basics of routing. The only difference
between our examples and how things work on the internet is scale. Routers are usually connected to
many more than just two networks. Very often your traffic may have to cross
a dozen routers before it reaches its final destination. And finally,
in order to protect against breakages, core internet routers
are typically connected in a mesh, meaning that there might be many
different paths for a packet to take. Still, the concepts are all the same. Routers inspect the destination IP,
look at their routing table to determine which path is the quickest and
forward the packet along the path. This happens over and
over every single packet, making up every single bit of traffic
all over the internet at all times. Pretty cool stuff?

️ Navigating the Network Maze: A Guide to Routing Tables

Imagine a bustling city with a network of roads and intersections. How do drivers know which routes to take to reach their destinations efficiently? They rely on maps and directions. In the digital world, routers play a similar role, and their essential maps are called routing tables.

In this tutorial, we’ll explore the fascinating world of routing tables, guiding you through:

1. What are Routing Tables?

• Roadmaps for the Internet: Routing tables are like detailed maps that routers use to determine the best paths for data packets to travel across a network.
• Decision-Making Guides: When a router receives a packet, it consults its routing table to decide where to send it next, ensuring efficient delivery.

2. Key Components of a Routing Table:

• Destination Network: This column specifies the network that the packet is trying to reach, defined by its network ID and netmask.
• Next Hop: This column indicates the IP address of the next router along the path to the destination network.
• Total Hops: This column shows the distance (in hops) to the destination network, helping routers choose the shortest and most efficient route.
• Interface: This column specifies the physical or logical interface on the router that the packet should be sent out of to reach the next hop.

3. How Routing Tables Work:

1. Packet Arrival: A packet arrives at a router, seeking a specific destination.
2. Table Lookup: The router examines the packet’s destination IP address and consults its routing table to find a matching entry.
3. Route Determination: Based on the table’s information, the router decides the most appropriate path to the destination network.
4. Packet Forwarding: The router forwards the packet to the next hop router on the determined path, repeating the process at each router until the packet reaches its final destination.

4. Dynamic Updates and Adaptability:

• Ever-Changing Network: Routing tables are not static; they dynamically adjust to changes in the network topology, such as link failures or congestion.
• Routing Protocols: Routers communicate with each other using routing protocols to share information about network changes and update their tables accordingly.

5. Beyond the Basics:

• Administrative Distance: Routers may have multiple routes to the same destination but prioritize them based on trustworthiness and metrics like administrative distance.
• Default Routes: A catch-all entry called a default route directs packets to a designated router when no specific route is found in the table.

Understanding routing tables is essential for network troubleshooting, optimization, and security. By grasping their structure and function, you gain a deeper appreciation for the intelligent systems that keep our digital world connected.

During our earlier video
on the basics of routing, you might have noticed that
bunch of references to something known as
a routing table. Routing itself is
pretty simple concept, and you’ll find
that routing tables aren’t that much
more complicated. The earliest routers were just regular
computers of the era. They had two network interfaces, bridge two networks and had a routing table that
was manually updated. In fact, all major operating
systems today still have a routing table that they consult before
transmitting data. You can still build
your own router today if you had a computer with two network interfaces and a manually updated
routing table. Routing tables can vary a ton depending on the make
and class of the router, but they all share a
few things in common. The most basic routing table
will have four columns. Destination network. This column would contain a row for each network that
the router knows about. This is just the definition
of the remote network, a network ID and the net mask. These can be stored in one
column inside a notation, or the network ID and net mask might be in
a separate column. Either way, it’s
the same concept. The router has a definition
for a network and therefore knows what IP addresses
might live on that network. When the router receives
an incoming packet, it examines the destination IP address and determines which
network it belongs to. A routing table will generally have a catch-all
entry that matches any IP address that
it doesn’t have an explicit network
listing for. Next hop. This is the IP address of
the next router that should receive data intended for the destination
networking question, or this could just state
the network is directly connected and that there aren’t any additional
hops needed. Total hops. This is the crucial part to understand routing and how
routing tables work. On any complex network
like the Internet, there will be lots of
different paths to get from point A to point
B. Routers try to pick the shortest
possible path at all times to ensure
timely delivery of data. But the shortest
possible path to a destination network is something that could
change over time. Sometimes rapidly. Intermediary routers
could go down. Links could become disconnected and new routers
could be introduced. Traffic congestion could cause certain routes to
become too slow to use. We’ll get to know how routers know the shortest path
in an upcoming video. For now, it’s just
important to know that for each next hop and each
destination network, the router will have
to keep track of how far away that destination
currently is. That way, when it receives updated information from
neighboring routers, it will know if it currently
knows about the best path, or if they knew better
path is available. Interface, the
router also has to know which of its interfaces
it should forward traffic, matching the destination
network out of. In most cases, routing
tables are pretty simple. The really impressive
part is that many core Internet routers have millions of rows in
the routing tables. These must be consulted for
every single packet that flows through a router on its way to its
final destination.

Navigating the Network Maze: A Guide to Routing Protocols

Imagine a bustling city with thousands of interconnected roads. How do drivers efficiently navigate to their destinations without getting lost in the chaos? They rely on maps, traffic updates, and GPS systems. In the digital world, routers face a similar challenge, and their trusty navigation tools are called routing protocols.

In this tutorial, we’ll explore the fascinating world of routing protocols, unlocking the secrets behind how data packets find their way across complex networks.

1. What are Routing Protocols?

• The Language of Routers: Routing protocols are a set of rules and procedures that allow routers to communicate with each other, sharing information about available networks and paths.
• Building the Map: By exchanging information, routers construct a collective map of the network topology, enabling them to make intelligent decisions about where to send data packets.

2. Types of Routing Protocols:

2.1 Interior Gateway Protocols (IGPs):

• Operating within Borders: IGPs are used for routing within a single autonomous system (AS), which is a collection of networks under a single administrative control (e.g., a large organization’s network or an ISP’s network).
• Two Main Flavors:
  • Distance Vector Protocols (DVs): Routers share lists of known networks and their distances (in hops) with their neighbors, but they have limited knowledge of the overall network topology. Example: RIP.
  • Link State Protocols (LSs): Routers advertise the state of each link (connection) to all other routers in the AS, creating a comprehensive network map. This allows for faster convergence and more efficient routing. Example: OSPF.

2.2 Exterior Gateway Protocols (EGPs):

• Connecting Worlds: EGPs handle routing between different autonomous systems, enabling communication across the vast expanse of the internet. Example: BGP.

3. Key Characteristics of Routing Protocols:

• Convergence: The speed at which routers adapt to network changes, such as link failures or new routes becoming available. Faster convergence is generally desirable.
• Scalability: The ability to handle large and complex networks without significant performance degradation.
• Security: Measures to protect routing information from unauthorized access or manipulation, ensuring network integrity.

4. Choosing the Right Protocol:

• Network Size and Complexity: Consider the number of routers and networks involved, as well as the desired level of control and visibility.
• Traffic Patterns and QoS Requirements: Evaluate the nature of the traffic (e.g., real-time, bandwidth-intensive) and any specific quality of service (QoS) needs.
• Hardware and Software Capabilities: Ensure compatibility with existing infrastructure and resources.

5. Learning More:

• Explore Popular Protocols: Delve into the specifics of protocols like RIP, OSPF, and BGP to gain a deeper understanding of their mechanisms and applications.
• Hands-On Experience: Experiment with routing protocols in simulated or lab environments to solidify your knowledge and practice configuration skills.

By mastering routing protocols, you’ll gain the ability to design, troubleshoot, and optimize complex networks, ensuring efficient and reliable data delivery across the digital landscape.

We’ve covered the basics
of how routing works and how routing tables are constructed, and
they’re both really pretty basic concepts. The real magic of routing is in
the way that routing tables are always updated with new information about
the quickest path to destination networks. The protocols we’ll be learning about in
this video will help you identify routing problems on any network you might support. In order to learn about
the world around them, routers use what are known
as routing protocols. These are special protocols, the routers
use to speak to each other in order to share what information they might have. This is how a router on one side of the
planet can eventually learn about the best path to a network on
the other side of the planet. Routing protocols fall
into two main categories. Interior gateway protocols and
exterior gateway protocols. Interior gateway protocols are further
split into two categories, link state routing protocols and
distance vector protocols. In this video we’ll cover the basics
of interior gateway protocols. Interior gateway protocols are used by
routers to share information within a single autonomous system. In networking terms, an autonomous system
is a collection of networks that all fall under the control of
a single network operator. The best example of this would be a large
corporation that needs to route data between their many offices and each of which might have
their own local area network. Another example is the many routers
employed by an internet service provider whose reaches
are usually national in scale. You can contrast this with exterior
gateway protocols which are used for the exchange of information between
independent autonomous systems. The two main types of interior gateway
protocols are link state routing protocols and distance vector protocols. Their goals are super similar,
but the routers that employ them share different kinds
of data to get the job done. Distance vector protocols
are an older standard. A router using a distance vector protocol
basically just takes its routing table, which is a list of every
network known to it and how far away these networks
are in terms of hops. Then the router sends this list to every
neighboring router which is basically every router directly connected to it. In computer science,
a list is known as a vector. This is why a protocol that just sends a
list of distances to networks is known as a distance vector protocol. With a distance vector protocol, routers don’t really know that much about
the total state of an autonomous system. They just have some information
about their immediate neighbors. For a basic glimpse into how
distance vector protocols work. Let’s look at how two routers might
influence each other’s routing tables. Router A has a routing table
with a bunch of entries. One of these entries is for 10.1.1.0/24
network which we refer to as network X. Router A believes that the quickest
path to network X is through its own interface two which is where
router C is connected. Router A knows that sending data
intended for network X through interface to two Router C means it’ll take
four hops to get to the destination. Meanwhile, Router B is only two
hops removed from network X and this is reflected in its routing table. Router B using a distance vector
protocol sends the basic contents of its routing table to Router A. Router A sees that network X is
only two hops away from Router B. Even with the extra hop to get
from Router A to Router B, this means that Network X is only
three hops away from router A. If it forwards data to Router B instead of
router C, armed with this new information, Router A updates its routing
table to reflect this. In order to reach network X in
the fastest way it should forward traffic through its own
interface one to router B. Now, distance vector protocols are pretty
simple, but they don’t allow for a router to have much information about
the state of the world outside of their own direct neighbors. Because of this, a router might be slow to react to
a change in the network far away from it. This is why link state protocols
were eventually invented. Routers using a link state protocol
taking more sophisticated approach to determining the best path to a network. Link state protocols get their
name because each router advertises the state of the link
of each of its interfaces. These interfaces could be
connected to other routers or they could be direct
connections to networks. The information about each router is
propagated to every other router on the autonomous system. This means that every router on the system
knows every detail about every other router in the system. Each router then uses this much
larger set of information and runs complicated algorithms against it to determine what the best path to
any destination network might be. Link state protocols require both more
memory in order to hold all of this data and also much more processing power. This is because it has to run algorithms
against this data in order to determine the quickest path to
update the routing tables. As computer hardware has become more
powerful and cheaper, over the years, link state protocols have mostly made
distance vector protocols outdated.

️ Bridging Digital Worlds: A Guide to Exterior Gateway Protocols (EGPs)

In the vast realm of interconnected networks, how do we ensure seamless communication across different domains, managed by separate entities? Enter the realm of Exterior Gateway Protocols (EGPs), the skilled diplomats of the internet, facilitating conversations between autonomous systems.

In this tutorial, we’ll explore the role of EGPs, their key concepts, and how they contribute to the internet’s global connectivity.

1. Autonomous Systems: The Building Blocks

• Independent Realms: Imagine the internet as a collection of individual kingdoms, each with its own set of rules and infrastructure. These kingdoms are known as autonomous systems (AS).
• Under a Single Rule: An AS encompasses a group of networks under the control of a single administrative entity, such as an ISP, a large organization, or a university.
• ASN: The Unique Identifier: Each AS is assigned a unique number, called an Autonomous System Number (ASN), by the Internet Assigned Numbers Authority (IANA). This ASN serves as its address on the global internet map.

2. EGPs: Bridging the Gaps

• The Language of Diplomacy: EGPs are the protocols that enable routers at the edges of different ASes to exchange routing information, allowing them to learn about paths to networks in other ASes.
• Global Connectivity: Without EGPs, communication between networks belonging to different organizations would be impossible, fragmenting the internet into isolated islands.

3. The Role of EGPs

• Establishing Trust: EGPs establish trusted relationships between border routers in different ASes, ensuring secure and reliable exchange of routing data.
• Sharing Network Reachability: They advertise which networks are reachable within their respective ASes, allowing for efficient path calculations across the internet.
• Adapting to Changes: EGPs dynamically adapt to network changes, such as link failures or new routes becoming available, maintaining optimal connectivity.

4. BGP: The Internet’s Backbone

• The Dominant EGP: While various EGPs exist, the Border Gateway Protocol (BGP) is the most widely used protocol for inter-AS routing on the internet.
• Complex and Powerful: BGP is known for its complexity and ability to handle large-scale routing, making it the backbone of global internet connectivity.

5. Key Characteristics of EGPs

• Scalability: Ability to manage routing information for a vast number of networks across the internet.
• Security: Measures to protect routing data from unauthorized access or manipulation, preventing potential disruptions.
• Policy-Based Routing: Support for customized routing decisions based on factors beyond simple path metrics, allowing for greater control and optimization.

6. Understanding EGPs: The Foundation for Global Connectivity

• Network Design and Troubleshooting: Grasping EGPs is essential for network engineers involved in designing and maintaining large-scale networks that span multiple ASes.
• Internet Architecture: Understanding EGPs provides a deeper insight into the internet’s overall structure and how different networks seamlessly interconnect.

By delving into the world of EGPs, you’ll gain a valuable perspective on the internet’s underlying architecture and the mechanisms that keep us all connected across organizational boundaries.

Exterior gateway protocols are used
to communicate data between routers representing the edges
of an autonomous system. Since routers sharing data using interior
gateway protocols are all under control of the same organization. Routers use exterior gateway protocols
when they need to share information across different organizations. Exterior gateway protocols are really
key to the Internet operating how it does today. So thanks exterior gateway protocols. The Internet is an enormous
mesh of autonomous systems. At the highest levels, core Internet
routers need to know about autonomous systems in order to
properly forward traffic. Since autonomous systems are known and
defined collections of networks, getting data to the edge router of an
autonomous system is the number 1 goal of core Internet routers. The IANA or the Internet Assigned
Numbers Authority is a nonprofit organization that helps manage
things like IP address allocation. The Internet couldn’t function
without a single authority for these sorts of issues. Otherwise anyone could try and
use any IP space they wanted, which would cause total chaos online. Along with managing IP address allocation,
the IANA is also responsible for ASN or
Autonomous System Number allocation. ASNs are numbers assigned to
individual autonomous systems. Just like IP addresses ASNs
are 32 bit numbers, but unlike IP addresses they’re normally
referred to as just a single decimal number instead of being split
out into readable bits. There are two reasons for this, first,
IP addresses need to be able to represent a network ID portion and
a host ID portion for each number. This is more easily accomplished by
splitting the number in four sections of eight bits, especially back in the day
when address classes ruled the world. An ASN never needs to change in order for
it to represent more networks or hosts, it’s just the core Internet
routing tables that need to be updated to know what the ASN represents. Second, ASNs are looked at by humans
far less often than IP addresses are. So, because it can be useful to be able
to look at the IP 9.100.100.100 and know that 9.0.0.0/8 address
space is owned by IBM, ASNs represent entire autonomous systems. Just being able to look up the fact
that AS19604 belongs to IBM is enough. Unless you one day end up working
at an Internet service provider, understanding more details
about how exterior gateway protocols work is out of scope for
most people in IT. But grasping the basics of
autonomous systems, ASNs, and how core Internet routers route traffic
between them is important to understand some of the basic building
blocks of the Internet.

Navigating Private Networks: A Guide to Non-Routable Address Space

In the bustling world of the internet, where billions of devices communicate, how do we create private spaces for internal networks without running out of public IP addresses? The answer lies in Non-Routable Address Space (NRAS), a reserved range of IP addresses designed for this very purpose.

In this tutorial, we’ll explore the concept of NRAS, its importance, and how it’s used to manage internal networks effectively.

1. Understanding the Need for NRAS

• IPv4 Limitations: The original IPv4 protocol provides only 4.3 billion unique IP addresses, a number that has proven insufficient for the explosive growth of the internet.
• Conserving Public Addresses: To preserve the limited pool of public IP addresses for devices that need to be directly accessible on the internet, NRAS was introduced to provide private IP addresses for internal networks.

2. RFC 1918: Defining the Rules

• The Standard: In 1996, RFC 1918 established the guidelines for NRAS, outlining specific IP address ranges that are reserved for private use.
• Key Ranges: The three primary ranges of NRAS are:
  • 10.0.0.0/8 (10.0.0.0 to 10.255.255.255)
  • 172.16.0.0/12 (172.16.0.0 to 172.31.255.255)
  • 192.168.0.0/16 (192.168.0.0 to 192.168.255.255)

3. Characteristics of NRAS

• Not for the Public Internet: Routers on the public internet are configured to ignore traffic with source or destination IP addresses within these NRAS ranges.
• Internal Routing: Interior Gateway Protocols (IGPs) can route traffic within a private network using NRAS, but Exterior Gateway Protocols (EGPs) will not forward it across the internet.
• No Global Uniqueness: The same NRAS can be used by multiple private networks without conflict, as they are not visible to each other or the internet.

4. Benefits of Using NRAS

• Conserves Public IP Addresses: By using NRAS for internal networks, organizations can significantly reduce their consumption of public IP addresses.
• Security: NRAS provides an additional layer of security by making internal devices less directly accessible from the internet.
• Flexibility: NRAS allows for flexible network design and expansion within private networks without concerns about IP address conflicts or external routing.

5. Common Use Cases

• Home Networks: Most home routers use the 192.168.0.0/16 range for internal devices, allowing them to communicate with each other but not directly with the internet.
• Corporate Networks: Large organizations often use NRAS to manage internal communication between devices, servers, and workstations.
• Data Centers: Data centers extensively use NRAS to create isolated network segments for different applications and services.

6. Enabling Internet Access with NAT

• Network Address Translation (NAT): While devices using NRAS cannot directly communicate with the internet, a technology called NAT allows them to access the internet through a single public IP address.
• Gateway Router: A gateway router configured with NAT can translate private IP addresses into the public IP address, enabling internet access for devices on the private network.

By understanding and effectively utilizing Non-Routable Address Space, you can efficiently manage internal networks, conserve public IP addresses, and enhance network security. It’s a fundamental concept that plays a vital role in the efficient operation of the internet.

Now a brief history lesson. Even as far back as 1996, it was obvious that
the Internet was growing at a rate that
couldn’t be sustained. When IP was first defined, it defined an IP address
as a single 32-bit number. A single 32-bit number can represent 4,294,967,295
unique numbers, which definitely
sounds like a lot. But as of 2017, there are an estimated 7.5
billion humans on Earth. This means that the IPv4
standard doesn’t even have enough IP addresses available for every
person on the planet. It also can’t account for
entire data centers filled with thousands and
thousands of computers required for large-scale
technology companies to operate. So in 1996, RFC
1918 was published. RFC stands for request for comments and is a
longstanding way for those responsible for keeping
the Internet running to agree upon the standard
requirements to do so. RFC 1918 outlined a number of networks that would be defined as non-routable address space. Non-routable address space is basically exactly
what it sounds like. They are ranges of IPs set aside for use by anyone
that cannot be routed to. Not every computer connected
to the Internet needs to be able to communicate with every other computer
connected to the Internet. Non-routable address
space allows for nodes on such a network to
communicate with each other, but no gateway
router will attempt to forward traffic to
this type of network. This might sound super limiting, and in some ways it is. In a future module, we’ll cover a
technology known as NAT or network
address translation. It allows for computers on
non-routable address space to communicate with other
devices on the Internet. But for now, let’s just discuss non-routable address
space in a vacuum. RFC 1918 defined three ranges of IP addresses that will never be routed anywhere by core routers. That means that they belong to no one and that
anyone can use them. In fact, since they’re separated from the way traffic
moves across the Internet, there’s no limiting to
how many people might use these addresses for
their internal networks. The primary three ranges of non-routable address
space are 10.0.0.0/8, 172.16.0.0/12, and
192.168.0.0/16. These ranges are free for anyone to use for their
internal networks. It should be called out that interior gateway
protocols will route these address spaces
so they’re are appropriate for use within
an autonomous system, but exterior gateway
protocols will not. We’ve covered a lot
in this module and congratulations to you
for sticking with it.

[MUSIC]
So at one point I was working for a managed service provider which is
basically a company that provides IT support for other companies. And we were helping one of our clients
migrate some of their systems onto a new version. And every time I tried to start one of
their services, it would just error out and crash and kernel dump on
the screen and we couldn’t figure out why. And eventually we get support for the third party that actually writes
this piece of software on the line and they can’t figure it out and
it gets escalated and escalated. And eventually I have the personal phone
number of the vice president at this company who’s the person who
first wrote this software. And him and I spent several days trying to
figure out what was going on to no avail. We tried running this
on different servers. We tried everything we could possibly
think of until I realized that the license key that needed to
be in place for the software to work have been copied over from
a Windows machine onto a Linux machine. Which means that the characters used at
the end of the line to signal this line is over, please move on to the next one,
were different. This software was choking on this
difference break line character. All I had to do was run one command and
switch it over to a Linux file format and everything worked [LAUGH]. Also two weeks of my life lost but
we leave out exactly how long [LAUGH].