---
id: 2024-11-01-linux-administration-netzwerkkonfiguration-und-verwaltung
slug: linux-administration-netzwerkkonfiguration-und-verwaltung
title: "Linux Administration #4: Netzwerkkonfiguration und Verwaltung"
excerpt: "Lerne die Grundlagen der Linux-Netzwerkkonfiguration: Von der physischen Netzwerkebene über DNS-Konfiguration bis hin zu Firewall-Einstellungen und Netzwerk-Monitoring."
date: "2024-11-01T09:00:00+01:00"
updated: "2024-11-01T10:00:00+01:00"
author:
name: "Sebastian Palencsar"
handle: "spalencsar"
category: "linux-administration"
tags: ["networking", "ip", "dns", "dhcp", "ssh", "firewall", "network-manager", "linux-administration"]
toc: true
reading_time: 14
---
**Willkommen zum vierten Teil unserer technischen Wiki-Serie über Linux-Administration!**
Nachdem wir in den vorherigen Artikeln die [Grundlagen der Systemadministration](/de/linux-administration/linux-administration-grundlagen-der-linux-administration), [Benutzerverwaltung](/de/linux-administration/linux-administration-fortgeschrittene-benutzerverwaltung) und [Prozessverwaltung](/de/linux-administration/linux-administration-prozesse-und-ressourcenverwaltung) behandelt haben, widmen wir uns heute der Netzwerkkonfiguration und -verwaltung.
Als Linux-Administrator ist es wichtig zu verstehen, wie Netzwerke funktionieren und wie du sie konfigurierst. Stell dir ein Netzwerk wie ein Postsystem vor: Jeder Computer hat eine eigene Adresse IP-Adresse, und die Netzwerkkonfiguration bestimmt, wie Pakete zwischen den Computern ausgetauscht werden.
⚠️ Hinweis: In diesem Artikel verwenden wir Ubuntu/Debian als Beispiel-Distribution. Die grundlegenden Konzepte sind auf allen Linux-Systemen gleich, aber die Installation von Paketen und einige Konfigurationspfade können sich je nach Distribution unterscheiden. Wenn du eine andere Distribution verwendest, konsultiere bitte die entsprechende Dokumentation für die spezifischen Installationsbefehle und Pfade.
### Was ist ein Netzwerk?
Ein Netzwerk verbindet Computer und ermöglicht den Austausch von Daten. In Linux gibt es verschiedene Werkzeuge und Konzepte, die dir bei der Netzwerkverwaltung helfen.
```Markdown
Netzwerk-Grundlagen:
┌─────────── Physische Ebene ────────┐
│ - Netzwerkkarten │
│ - Kabel und Verbindungen │
│ - Hardware-Adressen (MAC) │
├─────────── Logische Ebene ─────────┤
│ - IP-Adressen │
│ - Routing │
│ - DNS und Namensauflösung │
└────────────────────────────────────┘
```
## Netzwerk-Grundlagen verstehen
In Linux-Systemen ist das Netzwerk in verschiedene Ebenen unterteilt. Lass uns diese Ebenen im Detail betrachten:
##### Physische Ebene
```Markdown
Physische Netzwerkkomponenten:
┌─────────── Hardware ─────────────┐
│ - Netzwerkkarten (eth0, wlan0) │
│ - Kabelverbindungen │
│ - MAC-Adressen │
├─────────── Verwaltung ───────────┤
│ - Treiber und Module │
│ - Geschwindigkeit/Duplex │
│ - Verbindungsstatus │
└──────────────────────────────────┘
```
```Bash
# Netzwerkkarten anzeigen
ip link show
# oder traditionell
ifconfig -a
# MAC-Adresse und Status prüfen
ip link show eth0
# Zeigt:
eth0:
link/ether 00:11:22:33:44:55
```
##### Logische Ebene
```Markdown
Logische Netzwerkkonfiguration:
┌─────────── Adressierung ──────────┐
│ - IP-Adressen (IPv4/IPv6) │
│ - Subnetzmasken │
│ - Gateway-Konfiguration │
├─────────── Namensauflösung ───────┤
│ - DNS-Server │
│ - Hostname │
│ - /etc/hosts │
└───────────────────────────────────┘
```
##### Die logische Netzwerkebene verstehen
###### IP-Adressierung
Eine IP-Adresse ist wie eine Postanschrift für deinen Computer. In IPv4 besteht sie aus vier Zahlen zwischen 0 und 255:
```Markdown
IP-Adressierung:
┌─────────── IPv4 ─────────────────┐
│ - Format: xxx.xxx.xxx.xxx │
│ - Beispiel: 192.168.1.100 │
│ - Subnetzmaske: 255.255.255.0 │
├─────────── Bereiche ─────────────┤
│ - Privat: 192.168.0.0/16 │
│ - Privat: 10.0.0.0/8 │
│ - Privat: 172.16.0.0/12 │
└──────────────────────────────────┘
```
# Die IP-Adresse teilt sich in Netzwerk- und Host-Teil:
┌ `192.168.1.0` ist das Netzwerk
├ `.100`ist der Host in diesem Netzwerk
└ Die Subnetzmaske `255.255.255.0` trennt diese Bereiche
#### DNS (Domain Name System)
DNS übersetzt Domainnamen in IP-Adressen, ähnlich wie ein Telefonbuch Namen in Nummern übersetzt:
```Markdown
DNS-Auflösung:
┌─────────── Ablauf ───────────────┐
│ 1. Anfrage: www.beispiel.de │
│ 2. DNS-Server fragen │
│ 3. IP erhalten: 93.184.216.34 │
├─────────── Konfiguration ────────┤
│ - /etc/hosts für lokale Namen │
│ - /etc/resolv.conf für DNS │
│ - NetworkManager-Einstellungen │
└──────────────────────────────────┘
```
##### DNS-Auflösung im Detail
Die DNS-Auflösung in Linux folgt einem bestimmten Ablauf, ähnlich wie eine Telefonauskunft, die verschiedene Verzeichnisse nacheinander durchsucht.
###### Ablauf der DNS-Auflösung
```Markdown
DNS-Auflösungsprozess:
┌─────────── Client-Anfrage ──────────┐
│ 1. Browser fordert www.example.com │
│ 2. System prüft lokalen DNS-Cache │
│ 3. System prüft /etc/hosts │
├─────────── DNS-Server ──────────────┤
│ 4. Anfrage an konfigurierten DNS │
│ 5. DNS fragt Root-Server │
│ 6. DNS fragt TLD-Server (.com) │
│ 7. DNS fragt autoritativen Server │
└─────────────────────────────────────┘
```
###### DNS-Konfiguration in Linux
Die DNS-Konfiguration erfolgt hauptsächlich über zwei Dateien:
```Bash
# 1. /etc/resolv.conf - DNS-Server-Konfiguration
nameserver 8.8.8.8 # Google DNS
nameserver 8.8.4.4 # Google DNS Backup
search example.com # Lokale Domänensuche
domain example.com # Lokale Domäne
# 2. /etc/hosts - Lokale DNS-Einträge
127.0.0.1 localhost
192.168.1.10 server1.local server1
```
###### DNS-Abfragewerkzeuge
```Markdown
DNS-Tools im Überblick:
┌─────────── dig ─────────────────────┐
│ - Detaillierte DNS-Abfragen │
│ - Verschiedene Record-Typen │
│ - Spezifische Nameserver abfragen │
├─────────── nslookup ────────────────┤
│ - Einfache DNS-Abfragen │
│ - Interaktiver Modus │
│ - Reverse-Lookups │
├─────────── host ────────────────────┤
│ - Schnelle, einfache Abfragen │
│ - IP zu Name und umgekehrt │
│ - Basis-DNS-Informationen │
└─────────────────────────────────────┘
```
```Bash
# Beispiel mit dig
dig example.com
# Zeigt A-Record (IPv4)
# Beispiel mit nslookup
nslookup example.com
# Zeigt Name und IP
# Beispiel mit host
host example.com
# Zeigt vereinfachte DNS-Information
```
###### DNS-Troubleshooting in der Praxis
```Markdown
DNS-Troubleshooting-Tools:
┌─────────── Diagnose ─────────────┐
│ - ping (Erreichbarkeit) │
│ - dig (DNS-Abfragen) │
│ - nslookup (Namensauflösung) │
├─────────── Logs ─────────────────┤
│ - /var/log/syslog │
│ - /var/log/messages │
│ - dmesg │
└──────────────────────────────────┘
```
```Bash
# 1. Basis-Konnektivität prüfen
ping 8.8.8.8
ping google.com
# 2. DNS-Auflösung testen
dig google.com
nslookup google.com
# 3. DNS-Server prüfen
cat /etc/resolv.conf
```
#### Routing verstehen
Das Routing in Linux bestimmt, wie Netzwerkpakete ihren Weg durch das Netzwerk finden. Stell dir Routing wie ein Navigationssystem vor:
```Markdown
Routing-Konzepte:
┌─────────── Standard-Route ─────────┐
│ - Default Gateway │
│ - Weg ins Internet │
│ - Fallback für unbekannte Ziele │
├─────────── Statische Routen ───────┤
│ - Manuell konfigurierte Wege │
│ - Direkte Verbindungen │
│ - Spezifische Netzwerke │
└────────────────────────────────────┘
```
###### Routing-Tabelle verstehen
```Bash
# Routing-Tabelle anzeigen
ip route show
# oder traditionell
route -n
```
**Beispielausgabe:**
```Bash
default via 192.168.1.1 dev eth0
192.168.1.0/24 dev eth0 proto kernel scope link src 192.168.1.100
```
###### Routen konfigurieren
```Bash
# Standard-Gateway setzen
ip route add default via 192.168.1.1
# Spezifische Route hinzufügen
ip route add 10.0.0.0/24 via 192.168.1.254
# Route löschen
ip route del 10.0.0.0/24
```
## Netzwerk-Konfiguration
Nach den Grundlagen kommen wir nun zur praktischen Konfiguration deines Netzwerks. In Linux gibt es verschiedene Tools und Methoden, um Netzwerkeinstellungen vorzunehmen:
```Markdown
Netzwerk-Konfiguration:
┌─────────── Interfaces ───────────┐
│ - IP-Adressen zuweisen │
│ - Netzwerkmasken setzen │
│ - Gateway konfigurieren │
├─────────── DNS ──────────────────┤
│ - Nameserver einstellen │
│ - Hostnamen konfigurieren │
│ - Domänen festlegen │
└──────────────────────────────────┘
```
##### Interface-Konfiguration
###### IP-Adresse zuweisen
```Bash
sudo ip addr add 192.168.1.100/24 dev eth0
```
###### Gateway setzen
```Bash
sudo ip route add default via 192.168.1.1
# Änderungen prüfen
ip addr show eth0
ip route show
```
##### DNS-Server konfigurieren
Die DNS-Konfiguration erfolgt hauptsächlich über drei wichtige Dateien:
```Markdown
DNS-Konfigurationsdateien:
┌─────────── /etc/resolv.conf ──────┐
│ - DNS-Server-Adressen │
│ - Suchdomänen │
│ - DNS-Optionen │
├─────────── /etc/hosts ────────────┤
│ - Lokale DNS-Einträge │
│ - Hostname-IP-Zuordnungen │
│ - Statische Einträge │
├─────────── /etc/nsswitch.conf ────┤
│ - Reihenfolge der Namensauflösung │
│ - DNS-Prioritäten │
└───────────────────────────────────┘
```
###### DNS-Server in `/etc/resolv.conf` konfigurieren
```Bash
nameserver 8.8.8.8 # Google DNS (primär)
nameserver 8.8.4.4 # Google DNS (sekundär)
nameserver 192.168.1.1 # Router/lokaler DNS
search local.domain # Lokale Suchdomäne
domain local.domain # Standard-Domain
```
###### Lokale Hosts in `/etc/hosts` definieren
```Bash
127.0.0.1 localhost
192.168.1.10 server1.local server1
192.168.1.11 server2.local server2
```
###### DNS-Auflösungsreihenfolge in `/etc/nsswitch.conf`
```Bash
hosts: files dns
```
## Netzwerk-Sicherheit
Die Absicherung deines Netzwerks ist eine wichtige Aufgabe in der Linux-Administration. Hier lernen wir die grundlegenden Sicherheitskonzepte kennen:
```Markdown
Netzwerk-Sicherheit:
┌─────────── Firewall ─────────────┐
│ - Ports öffnen/schließen │
│ - Regeln definieren │
│ - Zugriffskontrolle │
├─────────── SSH ──────────────────┤
│ - Sichere Verbindungen │
│ - Schlüssel-Management │
│ - Zugriffsbeschränkungen │
└──────────────────────────────────┘
```
#### Firewall-Konfiguration
Die Linux-Firewall (`iptables/nftables`) ist deine erste Verteidigungslinie gegen unerwünschten Netzwerkzugriff. Lass uns verstehen, wie sie funktioniert:
```Markdown
Firewall-Grundlagen:
┌─────────── Eingehend ────────────┐
│ - Verbindungen von außen │
│ - Port-Zugriffe │
│ - Dienst-Anfragen │
├─────────── Ausgehend ────────────┤
│ - Verbindungen nach außen │
│ - Updates & Downloads │
│ - Dienst-Antworten │
└──────────────────────────────────┘
```
##### UFW (Uncomplicated Firewall)
```Bash
# UFW aktivieren
sudo ufw enable
# Standard-Regeln setzen
sudo ufw default deny incoming
sudo ufw default allow outgoing
# Ports freigeben
sudo ufw allow 22/tcp # SSH
sudo ufw allow 80/tcp # HTTP
sudo ufw allow 443/tcp # HTTPS
# Status prüfen
sudo ufw status verbose
```
#### Erweiterte Firewall-Regeln
##### UFW (Uncomplicated Firewall)
```Markdown
Erweiterte UFW-Regeln:
┌─────────── Port-Bereiche ─────────┐
│ - Ports öffnen/schließen │
│ - Port-Ranges definieren │
│ - Protokolle festlegen │
├─────────── IP-Adressen ───────────┤
│ - Einzelne IPs erlauben/blocken │
│ - Netzwerke verwalten │
│ - Subnetz-Regeln │
└───────────────────────────────────┘
```
```Bash
# Port-Bereiche definieren
sudo ufw allow 3000:4000/tcp # Port-Range
sudo ufw allow 80,443/tcp # Mehrere Ports
# IP-basierte Regeln
sudo ufw allow from 192.168.1.0/24 # Subnetz
sudo ufw deny from 10.0.0.5 # Einzelne IP
```
##### IPtables (Klassische Firewall)
```Markdown
IPtables-Struktur:
┌─────────── Chains ───────────────┐
│ - INPUT (eingehend) │
│ - OUTPUT (ausgehend) │
│ - FORWARD (weitergeleitet) │
├─────────── Aktionen ─────────────┤
│ - ACCEPT (erlauben) │
│ - DROP (verwerfen) │
│ - REJECT (ablehnen) │
└──────────────────────────────────┘
```
###### Praktische Beispiele für IPtables
IPtables ist ein mächtiges Werkzeug zur Firewall-Konfiguration. Hier sind die wichtigsten Anwendungsfälle:
```Markdown
Soll ich mit dem nächsten Hauptthema fortfahren?IPtables-Grundregeln:
┌─────────── Eingehend ────────────┐
│ - SSH (Port 22) │
│ - Web (Port 80/443) │
│ - DNS (Port 53) │
├─────────── Ausgehend ────────────┤
│ - Updates und Downloads │
│ - DNS-Anfragen │
│ - Web-Zugriff │
└──────────────────────────────────┘
```
###### Basis-Konfiguration
```Bash
# Alle bestehenden Regeln löschen
iptables -F
# Standard-Policies setzen
iptables -P INPUT DROP # Alles blockieren
iptables -P FORWARD DROP # Kein Routing
iptables -P OUTPUT ACCEPT # Ausgehend erlauben
# Loopback erlauben
iptables -A INPUT -i lo -j ACCEPT
```
###### Wichtige Dienste freigeben
```Bash
# SSH erlauben
iptables -A INPUT -p tcp --dport 22 -j ACCEPT
# Webserver erlauben
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp --dport 443 -j ACCEPT
# Bestehende Verbindungen erlauben
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
```
##### nftables
nftables ist der moderne Nachfolger von iptables. Hier sind die wichtigsten Konzepte und Konfigurationen:
```Markdown
nftables-Struktur:
┌─────────── Tabellen ────────────┐
│ - filter (Paketfilterung) │
│ - nat (Adressübersetzung) │
│ - mangle (Paketmodifikation) │
├─────────── Chains ──────────────┤
│ - input (eingehend) │
│ - output (ausgehend) │
│ - forward (weitergeleitet) │
└─────────────────────────────────┘
```
###### Grundlegende Konfiguration
```Bash
# Neue Tabelle erstellen
nft add table inet firewall
# Basis-Chain erstellen
nft add chain inet firewall input { type filter hook input priority 0 \; }
nft add chain inet firewall output { type filter hook output priority 0 \; }
# Grundregeln setzen
nft add rule inet firewall input ct state established,related accept
nft add rule inet firewall input ct state invalid drop
```
###### Praktische Beispiele
```Bash
# SSH erlauben
nft add rule inet firewall input tcp dport 22 accept
# HTTP/HTTPS erlauben
nft add rule inet firewall input tcp dport { 80, 443 } accept
# Regeln anzeigen
nft list ruleset
```
#### SSH-Sicherheit
SSH (Secure Shell) ist ein wichtiges Werkzeug für die sichere Fernwartung deines Systems. Lass uns die wichtigsten Sicherheitsaspekte betrachten:
```Markdown
SSH-Sicherheit:
┌─────────── Authentifizierung ─────┐
│ - Passwort vs. Schlüssel │
│ - Public/Private Key-Paare │
│ - SSH-Agent │
├─────────── Konfiguration ─────────┤
│ - Port ändern │
│ - Root-Login deaktivieren │
│ - Protokoll-Version │
└───────────────────────────────────┘
```
##### SSH-Konfiguration im Detail
SSH (Secure Shell) ist ein wichtiges Werkzeug für die sichere Fernwartung. Lass uns die wichtigsten Konfigurationsaspekte durchgehen:
```Markdown
SSH-Konfiguration:
┌─────────── Server ──────────────┐
│ - Port und Bindung │
│ - Authentifizierung │
│ - Zugriffskontrolle │
├─────────── Client ──────────────┤
│ - Schlüssel-Management │
│ - Verbindungsoptionen │
│ - Known Hosts │
└─────────────────────────────────┘
```
###### Server-Konfiguration (`/etc/ssh/sshd_config`)
```Bash
# Grundlegende Sicherheitseinstellungen
Port 22 # Standard-SSH-Port
PermitRootLogin no # Root-Login verbieten
PasswordAuthentication no # Nur Schlüssel erlauben
MaxAuthTries 3 # Maximale Anmeldeversuche
# Dienst neu starten nach Änderungen
sudo systemctl restart sshd
```
###### Schlüssel-basierte Authentifizierung
```Bash
# Schlüsselpaar erstellen
ssh-keygen -t ed25519 -C "server1"
# Öffentlichen Schlüssel auf Server kopieren
ssh-copy-id -i ~/.ssh/id_ed25519.pub benutzer@server
# Berechtigungen prüfen
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519
```
##### Erweiterte SSH-Sicherheitseinstellungen
Die Absicherung deines SSH-Servers ist entscheidend für die Systemsicherheit. Hier sind die wichtigsten erweiterten Einstellungen:
```Markdown
SSH-Sicherheitsoptionen:
┌─────────── Zugriffskontrolle ────┐
│ - Erlaubte/verbotene Benutzer │
│ - IP-basierte Einschränkungen │
│ - Zeitbasierte Beschränkungen │
├─────────── Verschlüsselung ──────┤
│ - Schlüsselalgorithmen │
│ - Cipher-Suites │
│ - MAC-Algorithmen │
└──────────────────────────────────┘
```
###### Erweiterte `sshd_config` Einstellungen
```Bash
# /etc/ssh/sshd_config
# Sicherheitseinstellungen
AllowUsers anna bob # Nur bestimmte Benutzer
PermitRootLogin no # Root-Login verbieten
MaxAuthTries 3 # Maximale Anmeldeversuche
LoginGraceTime 30 # Zeitlimit für Login
# Verschlüsselungsoptionen
Ciphers aes256-ctr,aes192-ctr
MACs hmac-sha2-512,hmac-sha2-256
KexAlgorithms curve25519-sha256
```
## Netzwerk-Monitoring
Das Monitoring deines Netzwerks ist essentiell für einen stabilen Betrieb. Hier sind die wichtigsten Werkzeuge und Konzepte.
##### Installation der Monitoring-Tools
```Bash
sudo apt install net-tools # für netstat
sudo apt install iproute2 # für ss
sudo apt install iftop # für Interface-Monitoring
sudo apt install nethogs # für Prozess-Monitoring
sudo apt install iptraf-ng # für detaillierte Netzwerkanalyse
```
```Markdown
Monitoring-Tools in der Praxis:
┌─────────── Traffic-Monitor ───────┐
│ nethogs: Prozess-basiert │
│ iftop: Interface-basiert │
│ iptraf: Detaillierte Statistik │
├─────────── Ausgabe-Beispiele ─────┤
│ nethogs: PID USER PROGRAM KB/s │
│ iftop: SOURCE <-> DEST KB/s │
│ iptraf: PORTS, PROTOKOLLE │
└───────────────────────────────────┘
```
##### Traffic-Monitoring
```Bash
# Prozess-basiertes Monitoring
sudo nethogs eth0
# Interface-basiertes Monitoring
sudo iftop -i eth0
# Bandbreiten-Monitoring
nload eth0
```
##### Verbindungs-Monitoring
```Bash
# Aktive Verbindungen anzeigen
ss -tuln
# Offene Ports überprüfen
netstat -tulpn
# Prozesse mit Netzwerkverbindungen
lsof -i
```
##### Monitoring-Tools in der Praxis
###### Bandbreiten-Monitoring mit nload
```Bash
nload eth0
# Zeigt:
Incoming: ▁▂▃▅█▇ 2.5 MB/s
Outgoing: ▁▁▂▃▂▁ 1.2 MB/s
```
###### Prozess-basiertes Monitoring mit nethogs
```Bash
sudo nethogs eth0
# Zeigt:
PID USER PROGRAM SENT RECEIVED
1234 anna firefox 2.5KB/s 15.4KB/s
5678 bob wget 0.1KB/s 350.2KB/s
```
###### Interface-Statistiken mit iftop
```Bash
sudo iftop -i eth0
# Zeigt:
Source Destination Transfer
192.168.1.100:443 10.0.0.5:52431 1.2Mb 2.5Mb
```
##### Langzeit-Monitoring
###### Traffic-Statistiken sammeln
```Bash
vnstat -i eth0
# Zeigt:
heute: 15.24 GB / 25.31 GB / 40.55 GB
gestern: 12.54 GB / 22.35 GB / 34.89 GB
dieser Monat: 345.45 GB / 678.12 GB / 1.02 TB
```
###### Grafische Auswertung mit vnstati
```Bash
vnstati -s -i eth0 -o summary.png
```
## Troubleshooting
Wenn Netzwerkprobleme auftreten, hilft dir eine systematische Vorgehensweise bei der Fehlersuche:
```Markdown
Troubleshooting-Schritte:
┌─────────── Verbindung ───────────┐
│ - ping (Erreichbarkeit) │
│ - traceroute (Routing-Weg) │
│ - netstat (Verbindungen) │
├─────────── DNS ──────────────────┤
│ - nslookup (Namensauflösung) │
│ - dig (detaillierte DNS-Info) │
│ - /etc/resolv.conf prüfen │
├─────────── Logs ─────────────────┤
│ - dmesg (Kernel-Meldungen) │
│ - /var/log/syslog │
│ - journalctl │
└──────────────────────────────────┘
```
##### Praktische Fehlersuche
###### Grundlegende Konnektivität
```Bash
ping 8.8.8.8 # Internet-Verbindung
ping gateway # Router erreichbar
ip route show # Routing-Tabelle
```
###### DNS-Probleme diagnostizieren
```Bash
nslookup google.com # DNS-Auflösung
dig google.com # Detaillierte DNS-Info
cat /etc/resolv.conf # DNS-Konfiguration
```
###### Netzwerk-Interfaces prüfen
```Bash
ip addr show # Interface-Status
ethtool eth0 # Link-Status
iwconfig wlan0 # WLAN-Status
```
## Übung
In dieser Übung werden wir die wichtigsten Konzepte aus dem Artikel praktisch anwenden.
```Markdown
Übungsaufgaben:
┌─────────── Grundlagen ───────────┐
│ 1. Netzwerk-Status prüfen │
│ 2. DNS-Konfiguration │
│ 3. Firewall-Regeln │
├─────────── Ziele ────────────────┤
│ - Interface-Konfiguration │
│ - DNS-Server einrichten │
│ - Basis-Firewall aufsetzen │
└──────────────────────────────────┘
```
**Aufgabe 1:** Netzwerk-Grundkonfiguration
```Bash
# 1. Prüfe deine Netzwerk-Interfaces
ip addr show
# 2. Konfiguriere eine statische IP
sudo ip addr add 192.168.1.100/24 dev eth0
# 3. Setze die Default-Route
sudo ip route add default via 192.168.1.1
```
**Aufgabe 2:** DNS-Konfiguration
```Bash
# 1. DNS-Server konfigurieren
sudo nano /etc/resolv.conf
# Füge hinzu:
nameserver 8.8.8.8
nameserver 8.8.4.4
# 2. Teste die DNS-Auflösung
nslookup google.com
```
**Aufgabe 3:** Firewall-Grundeinrichtung
```Bash
# 1. UFW aktivieren
sudo ufw enable
# 2. Basis-Regeln erstellen
sudo ufw default deny incoming
sudo ufw allow 22/tcp
sudo ufw allow 80/tcp
# 3. Status prüfen
sudo ufw status verbose
```
## Fazit
In diesem vierten Teil unserer Linux-Administrations-Serie hast du gelernt, wie Netzwerke unter Linux funktionieren und verwaltet werden. Von den grundlegenden Konzepten der Netzwerkarchitektur bis hin zu praktischen Konfigurationsaufgaben hast du nun das Wissen, um eigenständig Netzwerke einzurichten, abzusichern und zu überwachen.
Die Netzwerkverwaltung ist eine zentrale Aufgabe in der Linux-Administration. Mit den erlernten Konzepten und praktischen Beispielen kannst du nun Netzwerk-Interfaces konfigurieren, DNS-Server einrichten, Firewall-Regeln erstellen und SSH-Verbindungen absichern. Besonders wichtig ist dabei das Verständnis für die verschiedenen Sicherheitsaspekte, von der grundlegenden Firewall-Konfiguration bis hin zur sicheren Fernwartung über SSH.
Das erworbene Wissen bildet eine solide Grundlage für fortgeschrittene Netzwerkaufgaben. Im nächsten Artikel der Serie werden wir uns mit [Shell-Scripting und Automatisierung](/de/linux-administration/linux-administration-shell-scripting-und-automatisierung) beschäftigen. Du lernst, wie du wiederkehrende Aufgaben automatisierst und deine Arbeit effizienter gestaltest.
**Bis dahin, happy networking!**