Come trasformare un server Linux in un router per gestire il traffico in modo statico e dinamico - Parte 10
Come abbiamo anticipato nei tutorial precedenti di questa serie LFCE (Linux Foundation Certified Engineer), in questo articolo discuteremo dell'instradamento del traffico IP in modo statico e dinamico con applicazioni specifiche.
Presentazione del programma di certificazione Linux Foundation
Per prima cosa, chiariamo 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: l'informazione vera e propria viene suddivisa in pacchetti composti sia dai dati che dall'indirizzo a cui devono essere inviati.
- Il Routing è il processo di “guida” dei dati dalla sorgente alla destinazione all'interno di una rete.
- Il routing statico richiede un insieme di regole configurate manualmente in una tabella di routing. Queste regole sono fisse e vengono utilizzate per definire il modo in cui un pacchetto deve passare mentre viaggia da una macchina all'altra.
- Routing dinamico, o routing intelligente (se lo si desidera), significa che il sistema può modificare automaticamente, secondo necessità, il percorso seguito da un pacchetto.
Configurazione avanzata di dispositivi IP e di rete
Il pacchetto iproute fornisce una serie di strumenti per gestire la rete e il controllo del traffico che utilizzeremo in questo articolo poiché rappresentano la sostituzione di strumenti legacy come ifconfig e route.
L'utilità centrale della suite iproute si chiama 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):
- collegamento: dispositivo di rete.
- addr: indirizzo del protocollo (IP o IPv6) su un dispositivo.
- route: voce della tabella di routing.
- regola: regola nel database delle politiche di routing.
Mentre comando rappresenta un'azione specifica che può essere eseguita sull'oggetto. È possibile eseguire il comando seguente per visualizzare l'elenco completo dei comandi che possono essere applicati a un particolare oggetto:
ip object help
Per esempio,
ip link help
L'immagine sopra mostra, ad esempio, che è possibile modificare lo stato di un'interfaccia di rete con il seguente comando:
ip link set interface {up | down}
Per ulteriori esempi di comando "ip", leggi 10 comandi "ip" utili 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 vuoi riattivare 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 tabella di routing principale corrente con uno dei 3 comandi seguenti:
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 tali reti.
Anche se al giorno d'oggi il comando ip è preferito rispetto a route, puoi comunque 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 i pacchetti tra due reti private
Vogliamo instradare i 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 NIC, insieme al corrispondente indirizzo IPv4, è riportato 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
Vediamo la tabella di routing in dev1 (box CentOS):
ip route show
e quindi modificarlo per utilizzare la sua NIC 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 in sostanza recita: “Aggiungi un percorso alla rete 10.0.0.0/24 attraverso l'interfaccia di rete enp0s3 utilizzando 192.168.0.15 come gateway”.
Allo stesso modo in dev4 (box openSUSE) per eseguire il ping degli host nella rete 192.168.0.0/24:
ip route add 192.168.0.0/24 via 10.0.0.15 dev enp0s3
Infine, dobbiamo abilitare l'inoltro nel nostro router Debian:
echo 1 > /proc/sys/net/ipv4/ip_forward
Ora eseguiamo il ping:
E,
Per rendere queste impostazioni persistenti durante gli avviamenti, 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
Inoltre, configura le NIC su entrambi i client (cerca il file di configurazione in /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 casella 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 i 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 statica nel client come nell'esempio precedente, dobbiamo 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 NIC eth0 dovrebbe essere utilizzata per i pacchetti in uscita.
MASQUERADE indica che questa NIC ha un IP dinamico e che prima di inviare il pacchetto nel “mondo selvaggio” di Internet, l'indirizzo privato di origine del pacchetto deve essere cambiato in 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 restituire la risposta da Internet.
Solo parte dell'output di:
cat /proc/net/ip_conntrack
è mostrato nello screenshot seguente.
Dove è evidenziata l'origine (IP privato del box openSUSE) e la destinazione (Google DNS) dei pacchetti. Questo è stato il risultato dell'esecuzione:
curl linux-console.net
nella casella openSUSE.
Come sicuramente avrai già intuito, il router utilizza come nameserver l’8.8.8.8 di Google, il che spiega perché la destinazione dei pacchetti in uscita punta a quell’indirizzo.
Nota: i pacchetti in entrata da Internet sono accettati solo se fanno parte di una connessione già stabilita (comando n. 2), mentre i pacchetti in uscita sono consentiti “uscita libera " (comando n. 3).
Non dimenticare di rendere persistenti le tue regole iptables seguendo i passaggi delineati nella Parte 8 – Configurare il firewall Iptables di questa serie.
Routing dinamico con Quagga
Al giorno d'oggi, lo strumento più utilizzato per il routing dinamico in Linux è quagga. Consente agli amministratori di sistema di implementare, con un server Linux relativamente a basso costo, le stesse funzionalità fornite dai potenti (e costosi) router Cisco.
Lo strumento in sé non gestisce il routing, ma piuttosto modifica la tabella di routing del kernel mentre apprende nuovi percorsi migliori per gestire i pacchetti.
Poiché si tratta di un fork di zebra, un programma il cui sviluppo è cessato qualche tempo fa, mantiene per ragioni storiche gli stessi comandi e la stessa struttura di zebra. Questo è il motivo per cui da questo punto in poi vedrai molti riferimenti alla zebra.
Tieni presente che non è possibile coprire il routing dinamico e tutti i protocolli correlati in un unico articolo, ma sono fiducioso che il contenuto presentato qui servirà come punto di partenza su cui costruire.
Installazione di Quagga su Linux
Per installare quagga sulla 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 dell'Esempio n. 3, con l'unica differenza che eth0 è connesso 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 una password di tua scelta):
service quagga restart
hostname dev2
password quagga
service quagga restart
Nota: ripd.conf è il file di configurazione per il Routing Information Protocol, che fornisce al router le informazioni su quali reti possono essere raggiunto e quanto lontano sono (in termini di quantità di luppoli).
Tieni presente 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, sebbene abbia lo svantaggio di passare le credenziali in testo semplice. Per questo motivo, è necessario assegnare i permessi adeguati 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 in modo dinamico
In questo esempio utilizzeremo la seguente configurazione con due router (assicurati di creare i file di configurazione per router n. 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, quindi abilita la configurazione:
enable
configure terminal
Immettere l'indirizzo IP e la maschera di rete di ciascuna scheda 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 configurati nel file /etc/quagga/ripd.conf, quindi digita i seguenti comandi in grassetto (i commenti vengono aggiunti per motivi di chiarimento):
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: in entrambi i casi la configurazione viene aggiunta alle righe che abbiamo aggiunto in precedenza (/etc/quagga/zebra.conf e < b>/etc/quagga/ripd.conf).
Infine, connettiti nuovamente al servizio zebra su entrambi i router e nota come ciascuno di essi ha "imparato" il percorso verso la rete che si trova dietro l'altro, e quale è il prossimo hop per arrivarci rete, eseguendo il comando mostra ip route:
show ip route
Se desideri provare protocolli o configurazioni diversi, potresti fare riferimento al sito del progetto Quagga per ulteriore documentazione.
Conclusione
In questo articolo abbiamo spiegato come impostare il routing statico e dinamico, utilizzando uno o più router Linux box. Sentiti libero di aggiungere tutti i router che desideri e di sperimentare quanto vuoi. Non esitate a contattarci utilizzando il modulo di contatto sottostante se avete commenti o domande.