Come abbiamo anticipato nei precedenti tutorial di questa serie LFCE (Linux Foundation Certified Engineer), in questo articolo discuteremo del routing del traffico IP staticamente e dinamicamente con applicazioni specifiche.
Presentazione del Programma di Certificazione della Linux Foundation
Prima di tutto, chiariremo alcune definizioni:
- In parole semplici, un pacchetto è l’unità di base utilizzata per trasmettere informazioni all’interno di una rete. Le reti che utilizzano TCP/IP come protocollo di rete seguono le stesse regole per la trasmissione dei dati: le informazioni effettive vengono divise in pacchetti composti sia da dati che dall’indirizzo a cui devono essere inviati.
- Routing è il processo di “guida” dei dati dalla sorgente alla destinazione all’interno di una rete.
- Routing statico richiede un insieme di regole configurate manualmente definite in una tabella di routing. Queste regole sono fisse e vengono utilizzate per definire il percorso che un pacchetto deve seguire mentre viaggia da una macchina all’altra.
- Routing dinamico, o routing intelligente (se preferisci), significa che il sistema può modificare automaticamente, se necessario, il percorso che un pacchetto segue.
Configurazione avanzata di IP e dispositivi di rete
Il pacchetto iproute fornisce un insieme di strumenti per gestire la rete e il controllo del traffico che utilizzeremo in questo articolo in quanto rappresentano la sostituzione degli strumenti legacy come ifconfig e route.
La utility centrale nella suite iproute è chiamata semplicemente ip. La sua sintassi di base è la seguente:
# ip object command
Dove oggetto può essere solo uno dei seguenti (vengono mostrati solo gli oggetti più frequenti – puoi fare riferimento a man ip per un elenco completo):
- link: dispositivo di rete.
- addr: indirizzo del protocollo (IP o IPv6) su un dispositivo.
- route: voce della tabella di routing.
- rule: regola nel database di politica di routing.
Mentre comando rappresenta un’azione specifica che può essere eseguita sull’oggetto. Puoi eseguire il seguente comando per visualizzare l’elenco completo dei comandi che possono essere applicati a un particolare oggetto:
# ip object help
Ad esempio,
# ip link help
L’immagine sopra mostra, ad esempio, che è possibile cambiare lo stato di un’interfaccia di rete con il seguente comando:
# ip link set interface {up | down}
Per altri esempi di comando ‘ip‘, leggi 10 Comandi Utili ‘ip’ per Configurare l’Indirizzo IP
Esempio 1: Disabilitazione e abilitazione di un’interfaccia di rete
In questo esempio, disabiliteremo e abiliteremo eth1:
# ip link show # ip link set eth1 down # ip link show
Se desideri riabilitare eth1,
# ip link set eth1 up
Invece di visualizzare tutte le interfacce di rete, possiamo specificarne una:
# ip link show eth1
Che restituirà tutte le informazioni per eth1.
Esempio 2: Visualizzazione della tabella di routing principale
Puoi visualizzare la tua attuale tabella di routing principale con uno qualsiasi dei seguenti 3 comandi:
# ip route show # route -n # netstat -rn
La prima colonna nell’output dei tre comandi indica la rete di destinazione. L’output di ip route show (seguendo la parola chiave dev) presenta anche i dispositivi di rete che fungono da gateway fisico per quelle reti.
Anche se oggi il comando ip è preferito rispetto a route, è comunque possibile fare riferimento a man ip-route e man route per una spiegazione dettagliata del resto delle colonne.
Esempio 3: Utilizzo di un server Linux per instradare pacchetti tra due reti private
Vogliamo instradare pacchetti icmp (ping) da dev2 a dev4 e viceversa (nota che entrambe le macchine client si trovano su reti diverse). Il nome di ciascuna scheda di rete, insieme al relativo indirizzo IPv4, è fornito tra parentesi quadre.
Il nostro ambiente di test è il seguente:
Client 1: CentOS 7 [enp0s3: 192.168.0.17/24] - dev1 Router: Debian Wheezy 7.7 [eth0: 192.168.0.15/24, eth1: 10.0.0.15/24] - dev2 Client 2: openSUSE 13.2 [enp0s3: 10.0.0.18/24] - dev4
Visualizziamo la tabella di instradamento in dev1 (CentOS box):
# ip route show
e quindi modifichiamola per utilizzare la sua scheda di rete enp0s3 e la connessione a 192.168.0.15 per accedere agli host nella rete 10.0.0.0/24:
# ip route add 10.0.0.0/24 via 192.168.0.15 dev enp0s3
Che essenzialmente si traduce in “Aggiungi un percorso alla rete 10.0.0.0/24 tramite l’interfaccia di rete enp0s3 utilizzando 192.168.0.15 come gateway”.
Analogamente in dev4 (openSUSE box) per fare ping agli host nella rete 192.168.0.0/24:
# ip route add 192.168.0.0/24 via 10.0.0.15 dev enp0s3
Infine, è necessario abilitare l’inoltro nel nostro router Debian:
# echo 1 > /proc/sys/net/ipv4/ip_forward
Ora facciamo ping:
e,
Per rendere queste impostazioni persistenti durante il boot, modifica /etc/sysctl.conf sul router e assicurati che la variabile net.ipv4.ip_forward sia impostata su true come segue:
net.ipv4.ip_forward = 1
Configura le schede di rete su entrambi i client (cerca il file di configurazione all’interno di /etc/sysconfig/network su openSUSE e /etc/sysconfig/network-scripts su CentOS – in entrambi i casi si chiama ifcfg-enp0s3).
Ecco il file di configurazione dalla macchina openSUSE:
BOOTPROTO=static BROADCAST=10.0.0.255 IPADDR=10.0.0.18 NETMASK=255.255.255.0 GATEWAY=10.0.0.15 NAME=enp0s3 NETWORK=10.0.0.0 ONBOOT=yes
Esempio 4: Utilizzo di un server Linux per instradare pacchetti tra reti private e Internet
Un altro scenario in cui una macchina Linux può essere utilizzata come router è quando è necessario condividere la connessione Internet con una LAN privata.
Router: Debian Wheezy 7.7 [eth0: Public IP, eth1: 10.0.0.15/24] - dev2 Client: openSUSE 13.2 [enp0s3: 10.0.0.18/24] - dev4
Oltre a configurare l’inoltro dei pacchetti e la tabella di routing statico nel client come nell’esempio precedente, è necessario aggiungere alcune regole iptables nel router:
# iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE # iptables -A FORWARD -i eth0 -o eth1 -m state --state RELATED,ESTABLISHED -j ACCEPT # iptables -A FORWARD -i eth1 -o eth0 -j ACCEPT
Il primo comando aggiunge una regola alla catena POSTROUTING nella tabella nat (Network Address Translation), indicando che la scheda eth0 dovrebbe essere utilizzata per i pacchetti in uscita.
MASQUERADE indica che questa scheda ha un IP dinamico e che prima di inviare il pacchetto al “mondo selvaggio” di Internet, l’indirizzo sorgente privato del pacchetto deve essere cambiato con quello dell’IP pubblico del router.
In una LAN con molti host, il router tiene traccia delle connessioni stabilite in /proc/net/ip_conntrack in modo da sapere dove inviare la risposta da Internet.
Solo una parte dell’output di:
# cat /proc/net/ip_conntrack
è mostrata nello screenshot seguente.
Dove l’origine (IP privato della macchina openSUSE) e la destinazione (Google DNS) dei pacchetti sono evidenziati. Questo è stato il risultato dell’esecuzione di:
# curl www.tecmint.com
sulla macchina openSUSE.
Come puoi immaginare, il router utilizza l’8.8.8.8 di Google come nameserver, il che spiega perché la destinazione dei pacchetti in uscita punta a quell’indirizzo.
Nota: I pacchetti in ingresso da Internet vengono accettati solo se fanno parte di una connessione già stabilita (comando n. 2), mentre i pacchetti in uscita sono permessi in modo “libero” (comando n. 3).
Non dimenticare di rendere persistenti le regole iptables seguendo i passaggi descritti in Parte 8 – Configurare il firewall iptables di questa serie.
Routing dinamico con Quagga
Attualmente, lo strumento più utilizzato per il routing dinamico in Linux è quagga. Consente agli amministratori di sistema di implementare, con un server Linux a relativamente basso costo, la stessa funzionalità fornita dai potenti (e costosi) router Cisco.
Lo strumento stesso non gestisce il routing, ma modifica piuttosto la tabella di routing del kernel mentre apprende nuove migliori rotte per gestire i pacchetti.
Dato che è un fork di zebra, un programma il cui sviluppo è cessato tempo fa, per ragioni storiche mantiene gli stessi comandi e la stessa struttura di zebra. È per questo che vedrai molti riferimenti a zebra da questo punto in poi.
Si noti che non è possibile coprire il routing dinamico e tutti i protocolli correlati in un singolo articolo, ma sono sicuro che il contenuto presentato qui servirà come punto di partenza per costruire su di esso.
Installazione di Quagga in Linux
Per installare quagga sulla tua distribuzione scelta:
# aptitude update && aptitude install quagga [On Ubuntu] # yum update && yum install quagga [CentOS/RHEL] # zypper refresh && zypper install quagga [openSUSE]
Utilizzeremo lo stesso ambiente come nell’Esempio n. 3, con l’unica differenza che eth0 è collegato a un router gateway principale con IP 192.168.0.1.
Successivamente, modifica /etc/quagga/daemons con,
zebra=1 ripd=1
Ora crea i seguenti file di configurazione.
# /etc/quagga/zebra.conf # /etc/quagga/ripd.conf
e aggiungi queste righe (sostituisci con un nome host e password a tua scelta):
service quagga restart hostname dev2 password quagga
# service quagga restart
Nota: Che ripd.conf è il file di configurazione per il Protocollo di Informazioni di Routing, che fornisce al router le informazioni su quali reti possono essere raggiunte e a che distanza (in termini di numero di hop) si trovano.
Nota che questo è solo uno dei protocolli che possono essere utilizzati insieme a quagga, e l’ho scelto per questo tutorial per la facilità d’uso e perché la maggior parte dei dispositivi di rete lo supporta, anche se ha lo svantaggio di passare le credenziali in testo normale. Per questo motivo, è necessario assegnare le autorizzazioni adeguate al file di configurazione:
# chown quagga:quaggavty /etc/quagga/*.conf # chmod 640 /etc/quagga/*.conf
Esempio 5: Configurazione di quagga per instradare il traffico IP dinamicamente
In questo esempio utilizzeremo la seguente configurazione con due router (assicurati di creare i file di configurazione per router #2 come spiegato in precedenza):
Importante: Non dimenticare di ripetere la seguente configurazione per entrambi i router.
Connettiti a zebra (in ascolto sulla porta 2601), che è l’intermediario logico tra il router e il kernel:
# telnet localhost 2601
Inserisci la password impostata nel file /etc/quagga/zebra.conf, e quindi abilita la configurazione:
enable configure terminal
Inserisci l’indirizzo IP e la maschera di rete di ciascuna NIC:
inter eth0 ip addr 192.168.0.15 inter eth1 ip addr 10.0.0.15 exit exit write
Ora dobbiamo connetterci al terminale del demone RIP (porta 2602):
# telnet localhost 2602
Inserisci nome utente e password come configurato nel file /etc/quagga/ripd.conf, e poi digita i seguenti comandi in grassetto (i commenti sono aggiunti per chiarezza):
enable turns on privileged mode command. configure terminal changes to configuration mode. This command is the first step to configuration router rip enables RIP. network 10.0.0.0/24 sets the RIP enable interface for the 10.0.0.0/24 network. exit exit write writes current configuration to configuration file.
Nota: Che in entrambi i casi la configurazione viene aggiunta alle righe che abbiamo aggiunto in precedenza (/etc/quagga/zebra.conf e /etc/quagga/ripd.conf).
Infine, connettiti nuovamente al servizio zebra su entrambi i router e nota come ciascuno di essi ha “imparato” il percorso alla rete che si trova dietro l’altro, e qual è il prossimo salto per raggiungere quella rete, eseguendo il comando show ip route:
# show ip route
Se desideri provare diversi protocolli o configurazioni, potresti voler consultare il sito del progetto Quagga per ulteriori documentazioni.
Conclusione
In questo articolo abbiamo spiegato come configurare il routing statico e dinamico, utilizzando un router Linux. Sentiti libero di aggiungere quanti router desideri e di sperimentare quanto vuoi. Non esitare a contattarci utilizzando il modulo di contatto qui sotto se hai commenti o domande.