Infrastructure¶
First of all, what is a network?
Well, it’s an infrastructure that we use to transmit data.
In its most elementary version, a network consists of two devices connected to each other, by a network cable for example.
The important point here is that a device connected to the network must have a network interface, a component capable of communicating, i.e., sending and receiving a signal.
For example, your laptop has two network interfaces: the RJ45 port and the wifi card. The signal that passes through the network interface is a binary signal.
⚠️ The device itself doesn’t need to know the meaning of this signal,
because it’s a program running behind the network interface that will handle processing the signal in question ⚠️
Small parenthesis¶
Supercomputer: a peer-to-peer model¶


High Performance Computing¶
Divide and conquer

domain decomposition

Each subdomain “sent”
to a computing machine

Each subdomain “exploded” by packet of elements
for integration of the behavior law
At the level of each subdomain:
Distributed algebraic operations
Resolution of local problems (DD solvers)
but let’s close the parenthesis, we’re not here to talk about HPC but about networks!
Different network qualities¶
Network quality, a little thing that matters depending on the application 🚀
Generally we talk about three qualities:
Bandwidth: the amount of data that can be transmitted per unit of time (in bits per second, bps)
Latency: the time needed for a data packet to reach its destination
Reliability: the probability that data is transmitted without error
⏳️ In large simulations, communication time can represent 20% of computation time 💣
OSI Model¶
Open System Interconnexion
Standard established
by the ISO committee in 1984
Objectives:
standardize communications
between devices on a network
Addressing¶
Associate with each interface of each machine on a network a unique address
This address can be temporary or fixed.
This is what we call the IP address, for Internet Protocol.
The IP address of a network interface is written as a combination of four numbers between 0 and 255.
so there are two parts: the network address (often on 24 bits) and the host address (often on 8 bits) when we need to write the address of a network we write it like this the number of bits of the network address
IPv6 Addresses¶
in 2011 we predict the exhaustion 💣 of available IP addresses!...
232 = 4,294,967,296 that is about 1/2 address per person on earth
(of course some people have more than others 😅)
Therefore the IPv6 protocol was implemented (the old protocol was v4)
The principle is simple: go from an address on 32 bits to an address on 128 bits
for example (in hex) 2001:0db8:0000:85a3:0000:0000:ac1f:8001
In fact we have so many addresses that we can give an IP address to every grain of sand on earth 🏖 ️
Currently deployed but partially - mainly, but not only, in the network core at operators
And why not everywhere, you might ask?
well notably, the need for IPv6 is less important than expected thanks notably to NAT
we’ll talk about it again...
Interconnection¶
Local network¶
Remote network¶
To summarize:¶
interconnection which actually constitutes the third layer of the OSI model
manages three elements:
Routing
path between two machines in different networks,
path passing through gateways (routers)
these famous machines having interfaces in two distinct networks.Relaying
takes care, once the route is determined,
of transmitting the information from machine A to machine BFlow control
an optional but nevertheless essential functionality
which allows to decongest the entire network (in the broad sense).
A bit like Waze for data transit
By the way: what is my IP?¶
How do I
find out my IP?
to start I clone the course (if not already done)
on github: ue22-p25/backend
and I go to the python/ip-address folder
a small code to ask an external site
import requests
response = requests.get("https://api64.ipify.org?format=json")
public_ip = response.json()["ip"]
print("Public IP:", public_ip)
or to ask my OS(*)
import socket
def get_outgoing_ip():
with socket.create_connection(("8.8.8.8", 53)) as s:
return s.getsockname()[0]
print("Outgoing IP:", get_outgoing_ip())
and I get (try it!)
1 2$ python my-public-ip.py Public IP: 138.96.202.10
.. and it can be different! what is this mystery?
1 2$ python my-local-ip.py Outgoing IP: 10.1.1.15
(*) from the terminal, use: ipconfig on Windows, ifconfig on MacOS, ip address show on Linux
NAT (Network Address Translation)¶
and my little finger tells me that:
you will all have the same public address
but for the second one you each have a different local address
in fact there are two types of IP addresses:
public: those that are visible on the network, and which are unique
private: those that are used only in a local network
reserved private addresses:
192.168.0.0/16
216 = 65,536 adresses172.16.0.0/12
220 = 1,048,576 adresses10.0.0.0/8
224 = 16,777,216 adresses
Domain names in all this!¶
Remembering IP addresses is still not super 🤯!
For example imagine that you had to remember 91.134.82.158 (*)
to know the classrooms .... we wouldn’t see you often!
(*) this is the IP address of the server that hosts OASIS
--
For this in the Internet infrastructure there is a magic thing, the:
DNS = Domain Name System
Basically it’s the service that makes the association between a domain name and an IP address.
DNS from the terminal¶
# several utilities to make DNS queries
$ nslookup oasis.minesparis.psl.eu
Server: 192.168.0.1
Address: 192.168.0.1#53
Non-authoritative answer:
Name: oasis.minesparis.psl.eu
*Address: 91.134.82.158$ host oasis.minesparis.psl.eu
*oasis.minesparis.psl.eu has address 91.134.82.158$ dig @8.8.8.8 oasis.minesparis.psl.eu A +noall +answer
; <<>> DiG 9.10.6 <<>> @8.8.8.8 oasis.minesparis.psl.eu A +noall +answer
; (1 server found)
;; global options: +cmd
*oasis.minesparis.psl.eu. 161 IN A 91.134.82.158