Hvordan gjøre en Linux-server om til en ruter for å håndtere trafikk statisk og dynamisk - del 10


Som vi har forutsett i tidligere veiledninger i denne LFCE (Linux Foundation Certified Engineer)-serien, vil vi i denne artikkelen diskutere ruting av IP-trafikk statisk og dynamisk med spesifikke applikasjoner.

Vi introduserer Linux Foundation-sertifiseringsprogrammet

Først, la oss få noen definisjoner rett:

  1. Med enkle ord er en pakke den grunnleggende enheten som brukes til å overføre informasjon i et nettverk. Nettverk som bruker TCP/IP som nettverksprotokoll følger de samme reglene for overføring av data: den faktiske informasjonen deles opp i pakker som er laget av både data og adressen den skal sendes til.
  2. Routing er prosessen med å «veilede» dataene fra kilde til destinasjon i et nettverk.
  3. Statisk ruting krever et manuelt konfigurert sett med regler definert i en rutingtabell. Disse reglene er faste og brukes til å definere måten en pakke må gå gjennom når den går fra en maskin til en annen.
  4. Dynamisk ruting, eller smart ruting (hvis du ønsker det), betyr at systemet automatisk, etter behov, kan endre ruten som en pakke følger.

Avansert IP- og nettverksenhetskonfigurasjon

iproute-pakken inneholder et sett med verktøy for å administrere nettverk og trafikkkontroll som vi vil bruke gjennom denne artikkelen, da de representerer erstatningen av eldre verktøy som ifconfig og route.

Det sentrale verktøyet i iproute-pakken kalles ganske enkelt ip. Dens grunnleggende syntaks er som følger:

ip object command

Hvor objekt bare kan være ett av følgende (bare de mest hyppige objektene vises – du kan henvise til man ip for en fullstendig liste):

  1. kobling: nettverksenhet.
  2. addr: protokoll (IP eller IPv6) adresse på en enhet.
  3. rute: oppføring i rutetabell.
  4. regel: regel i rutingpolicydatabase.

Mens kommando representerer en spesifikk handling som kan utføres på objektet. Du kan kjøre følgende kommando for å vise den komplette listen over kommandoer som kan brukes på et bestemt objekt:

ip object help

For eksempel,

ip link help

Bildet ovenfor viser for eksempel at du kan endre statusen til et nettverksgrensesnitt med følgende kommando:

ip link set interface {up | down}

For slike flere eksempler på 'ip'-kommandoen, les 10 nyttige 'ip'-kommandoer for å konfigurere IP-adresse

Eksempel 1: Deaktivering og aktivering av et nettverksgrensesnitt

I dette eksemplet vil vi deaktivere og aktivere eth1:

ip link show
ip link set eth1 down
ip link show

Hvis du vil aktivere eth1 på nytt,

ip link set eth1 up

I stedet for å vise alle nettverksgrensesnittene, kan vi spesifisere ett av dem:

ip link show eth1

Som vil returnere all informasjon for eth1.

Eksempel 2: Viser hovedrutingstabellen

Du kan se din gjeldende hovedrutingstabell med en av følgende 3 kommandoer:

ip route show
route -n
netstat -rn

Den første kolonnen i utdataene til de tre kommandoene indikerer målnettverket. Utdataene fra ip-rute-show (etter søkeordet dev) presenterer også nettverksenhetene som fungerer som fysisk gateway til disse nettverkene.

Selv om ip-kommandoen i dag foretrekkes fremfor rute, kan du fortsatt se man ip-route og man route for en detaljert forklaring av resten av kolonnene.

Eksempel 3: Bruk av en Linux-server til å rute pakker mellom to private nettverk

Vi ønsker å rute icmp (ping) pakker fra dev2 til dev4 og omvendt også (merk at begge klientmaskinene er på forskjellige nettverk). Navnet på hvert nettverkskort, sammen med dens tilsvarende IPv4-adresse, er gitt innenfor hakeparenteser.

Vårt testmiljø er som følger:

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

La oss se rutingtabellen i dev1 (CentOS-boks):

ip route show

og deretter endre den for å bruke enp0s3 NIC og tilkoblingen til 192.168.0.15 for å få tilgang til verter i 10.0.0.0/24-nettverket:

ip route add 10.0.0.0/24 via 192.168.0.15 dev enp0s3

Som egentlig lyder: "Legg til en rute til 10.0.0.0/24-nettverket gjennom enp0s3-nettverksgrensesnittet ved å bruke 192.168.0.15 som gateway".

På samme måte i dev4 (openSUSE-boks) til ping-verter i 192.168.0.0/24-nettverket:

ip route add 192.168.0.0/24 via 10.0.0.15 dev enp0s3

Til slutt må vi aktivere videresending i vår Debian-ruter:

echo 1 > /proc/sys/net/ipv4/ip_forward

La oss nå pinge:

og,

For å gjøre disse innstillingene vedvarende på tvers av oppstarter, rediger /etc/sysctl.conf på ruteren og sørg for at net.ipv4.ip_forward-variabelen er satt til true som følger:

net.ipv4.ip_forward = 1

I tillegg konfigurerer du NIC-ene på begge klientene (se etter konfigurasjonsfilen i /etc/sysconfig/network på openSUSE og /etc/sysconfig/network-scripts på CentOS – i begge tilfeller kalles det ifcfg-enp0s3).

Her er konfigurasjonsfilen fra openSUSE-boksen:

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
Eksempel 4: Bruk av en Linux-server til å rute pakker mellom et privat nettverk og Internett

Et annet scenario der en Linux-maskin kan brukes som ruter er når du trenger å dele Internett-tilkoblingen din med et privat LAN.

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

I tillegg til å sette opp pakkevideresending og den statiske rutetabellen i klienten som i forrige eksempel, må vi legge til noen få iptables-regler i ruteren:

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

Den første kommandoen legger til en regel til POSTROUTING-kjeden i tabellen nat (Network Address Translation), som indikerer at eth0 NIC skal brukes for utgående pakker.

MASQUERADE indikerer at dette NIC har en dynamisk IP og at før pakken sendes til "wild wild world" på Internett, må den private kildeadressen til pakken være endret til den offentlige IP-en til ruteren.

I et LAN med mange verter holder ruteren oversikt over etablerte tilkoblinger i /proc/net/ip_conntrack slik at den vet hvor den skal returnere svaret fra Internett til.

Bare en del av produksjonen av:

cat /proc/net/ip_conntrack

vises i følgende skjermbilde.

Hvor opprinnelsen (privat IP for openSUSE-boksen) og destinasjonen (Google DNS) til pakker er uthevet. Dette var resultatet av løpingen:

curl linux-console.net

på openSUSE-boksen.

Som jeg er sikker på at du allerede kan gjette, bruker ruteren Googles 8.8.8.8 som navneserver, noe som forklarer hvorfor destinasjonen for utgående pakker peker til den adressen.

Merk: At innkommende pakker fra Internett bare aksepteres er hvis de er en del av en allerede etablert tilkobling (kommando #2), mens utgående pakker er tillatt "gratis utgang ” (kommando #3).

Ikke glem å gjøre iptables-reglene vedvarende ved å følge trinnene som er skissert i del 8 – Konfigurer Iptables-brannmuren i denne serien.

Dynamisk ruting med Quagga

I dag er verktøyet som brukes mest for dynamisk ruting i Linux quagga. Det lar systemadministratorer implementere, med en relativt rimelig Linux-server, den samme funksjonaliteten som leveres av kraftige (og kostbare) Cisco-rutere.

Verktøyet i seg selv håndterer ikke rutingen, men modifiserer heller kjernerutingstabellen ettersom det lærer nye beste ruter for å håndtere pakker.

Siden det er en gaffel av sebra, et program hvis utvikling opphørte for en stund siden, opprettholder det av historiske grunner de samme kommandoene og strukturen som sebraen. Det er derfor du vil se mye referanse til sebra fra dette tidspunktet.

Vær oppmerksom på at det ikke er mulig å dekke dynamisk ruting og alle relaterte protokoller i en enkelt artikkel, men jeg er sikker på at innholdet som presenteres her vil tjene som et utgangspunkt for deg å bygge videre på.

Installerer Quagga i Linux

Slik installerer du quagga på din valgte distribusjon:

aptitude update && aptitude install quagga 				[On Ubuntu]
yum update && yum install quagga 					[CentOS/RHEL]
zypper refresh && zypper install quagga 				[openSUSE]

Vi vil bruke det samme miljøet som med eksempel #3, med den eneste forskjellen at eth0 er koblet til en hovedgateway-ruter med IP 192.168.0.1.

Deretter redigerer du /etc/quagga/daemons med,

zebra=1
ripd=1

Lag nå følgende konfigurasjonsfiler.

/etc/quagga/zebra.conf
/etc/quagga/ripd.conf

og legg til disse linjene (erstatt med et vertsnavn og passord du ønsker):

service quagga restart
hostname    	dev2
password    	quagga
service quagga restart

Merk: ripd.conf er konfigurasjonsfilen for Routing Information Protocol, som gir ruteren informasjon om hvilke nettverk som kan nådd og hvor langt (i form av mengde humle) de er.

Merk at dette bare er en av protokollene som kan brukes sammen med quagga, og jeg valgte den for denne opplæringen på grunn av brukervennlighet og fordi de fleste nettverksenheter støtter den, selv om den har ulempen ved å sende legitimasjon i ren tekst. Av den grunn må du tildele riktige tillatelser til konfigurasjonsfilen:

chown quagga:quaggavty /etc/quagga/*.conf
chmod 640 /etc/quagga/*.conf 
Eksempel 5: Sette opp quagga for å rute IP-trafikk dynamisk

I dette eksemplet vil vi bruke følgende oppsett med to rutere (sørg for å lage konfigurasjonsfilene for ruter #2 som forklart tidligere):

Viktig: Ikke glem å gjenta følgende oppsett for begge ruterne.

Koble til zebra (lytter på port 2601), som er det logiske mellomleddet mellom ruteren og kjernen:

telnet localhost 2601

Skriv inn passordet som ble angitt i filen /etc/quagga/zebra.conf, og aktiver deretter konfigurasjonen:

enable
configure terminal

Skriv inn IP-adressen og nettverksmasken til hvert NIC:

inter eth0
ip addr 192.168.0.15
inter eth1
ip addr 10.0.0.15
exit
exit
write

Nå må vi koble til RIP-demonterminalen (port 2602):

telnet localhost 2602

Skriv inn brukernavn og passord som konfigurert i /etc/quagga/ripd.conf-filen, og skriv deretter inn følgende kommandoer med fet skrift (kommentarer legges til for klargjøring):

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.

Merk: at i begge tilfeller legges konfigurasjonen til linjene som vi la til tidligere (/etc/quagga/zebra.conf og < b>/etc/quagga/ripd.conf).

Koble til slutt igjen til sebratjenesten på begge ruterne og legg merke til hvordan hver av dem har «lært» ruten til nettverket som er bak den andre, og som er neste hopp for å komme til det nettverk, ved å kjøre kommandoen vis ip-rute:

show ip route

Hvis du vil prøve forskjellige protokoller eller oppsett, kan det være lurt å henvise til Quagga-prosjektsiden for ytterligere dokumentasjon.

Konklusjon

I denne artikkelen har vi forklart hvordan du setter opp statisk og dynamisk ruting ved å bruke en Linux-boksruter(e). Legg gjerne til så mange rutere du ønsker, og eksperimenter så mye du vil. Ikke nøl med å komme tilbake til oss ved å bruke kontaktskjemaet nedenfor hvis du har kommentarer eller spørsmål.