---
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: "AdminDocs"
category: "linux-administration"
tags: ["networking", "ip", "dns", "dhcp", "ssh", "firewall", "network-manager", "linux-administration"]
toc: true
reading_time: 45
---
**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){.badge-link-text}, [Benutzerverwaltung](/de/linux-administration/linux-administration-fortgeschrittene-benutzerverwaltung){.badge-link-text} und [Prozessverwaltung](/de/linux-administration/linux-administration-prozesse-und-ressourcenverwaltung){.badge-link-text} 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.
**Netzwerk-Grundlagen:**
```markdown
┌─────────── 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
**Physische Netzwerkkomponenten:**
```markdown
┌─────────── 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
**Logische Netzwerkkonfiguration:**
```markdown
┌─────────── 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:
**IP-Adressierung:**
```markdown
┌─────────── 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:
**DNS-Auflösung:**
```markdown
┌─────────── 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
**DNS-Auflösungsprozess:**
```markdown
┌─────────── 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
**DNS-Tools im Überblick:**
```markdown
┌─────────── 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
**DNS-Troubleshooting-Tools:**
```markdown
┌─────────── 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:
**Routing-Konzepte:**
```markdown
┌─────────── 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:**
* 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:
**Netzwerk-Konfiguration:**
```markdown
┌─────────── Interfaces ──────────────────────────────────────┐
│ • IP-Adressen zuweisen │
│ • Netzwerkmasken setzen │
│ • Gateway konfigurieren │
├─────────── DNS ─────────────────────────────────────────────┤
│ • Nameserver einstellen │
│ • Hostnamen konfigurieren │
│ • Domänen festlegen │
└─────────────────────────────────────────────────────────────┘
```
### Interface-Konfiguration
IP-Adresse zuweisen
* 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:
**DNS-Konfigurationsdateien:**
```markdown
┌─────────── /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
* 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`
* hosts: files dns
## Netzwerk-Sicherheit
Die Absicherung deines Netzwerks ist eine wichtige Aufgabe in der Linux-Administration. Hier lernen wir die grundlegenden Sicherheitskonzepte kennen:
**Netzwerk-Sicherheit:**
```markdown
┌─────────── 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:
**Firewall-Grundlagen:**
```markdown
┌─────────── 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)
**Erweiterte UFW-Regeln:**
```markdown
┌─────────── 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)
**IPtables-Struktur:**
```markdown
┌─────────── 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:
**IPtables-Grundregeln:**
```markdown
┌─────────── 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:
**nftables-Struktur:**
```markdown
┌─────────── 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:
**SSH-Sicherheit:**
```markdown
┌─────────── 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:
**SSH-Konfiguration:**
```markdown
┌─────────── 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:
**SSH-Sicherheitsoptionen:**
```markdown
┌─────────── 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
```
**Monitoring-Tools in der Praxis:**
```markdown
┌─────────── 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
* vnstati -s -i eth0 -o summary.png
## Troubleshooting
Wenn Netzwerkprobleme auftreten, hilft dir eine systematische Vorgehensweise bei der Fehlersuche:
**Troubleshooting-Schritte:**
```markdown
┌─────────── 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.
**Übungsaufgaben:**
```markdown
┌─────────── 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
```
## Befehlsreferenz (Cheatsheet)
Für den schnellen Zugriff bei der Netzwerkadministration, Fehlerdiagnose und Firewall-Konfiguration fasst die folgende Referenztabelle die wichtigsten Linux-Kommandos zusammen:
| Befehl / Syntax | Kategorie | Funktion & Beschreibung |
|---|---|---|
| `ip link show` | Schnittstellen | Zeigt alle Netzwerkadapter und deren Link-Status (UP/DOWN). |
| `ip addr show` | IP-Adressen | Listet alle IPv4- und IPv6-Adressen aller Interfaces auf. |
| `ip route show` | Routing | Zeigt Kernel-Routingtabelle und das aktive Default-Gateway. |
| `ip route get ` | Routing | Ermittelt das Interface und den Next-Hop für eine bestimmte Ziel-IP. |
| `sudo netplan try` | Netplan | Testet YAML-Netzwerkkonfiguration mit automatischem 120s-Rollback. |
| `sudo netplan apply` | Netplan | Übernimmt Netplan-Netzwerkkonfigurationen dauerhaft. |
| `nmcli device status` | NetworkManager | Zeigt Status und Verbindungsprofile aller NetworkManager-Geräte. |
| `nmcli connection up ` | NetworkManager | Aktiviert ein definiertes NetworkManager-Verbindungsprofil. |
| `resolvectl status` | DNS | Zeigt aktive DNS-Server und Suchdomänen von systemd-resolved. |
| `dig +short ` | DNS | Liefert präzise IP-Adressen einer Domain via DNS-Abfrage. |
| `sudo ss -tulpn` | Ports & Sockets | Listet alle lauschenden TCP/UDP-Sockets mit zugehöriger PID auf. |
| `sudo ufw default deny incoming` | Firewall | Setzt restriktive Standard-Policy für alle eingehenden Pakete. |
| `sudo ufw allow 22/tcp` | Firewall | Öffnet TCP-Port 22 (SSH) in der Uncomplicated Firewall. |
| `sudo ufw limit 22/tcp` | Firewall | Aktiviert automatisches Rate-Limiting gegen SSH-Brute-Force-Angriffe. |
| `sudo ufw status verbose` | Firewall | Zeigt detaillierte Liste aller aktiven UFW-Regeln und Policies. |
| `nc -zv ` | Diagnose | Prüft schnelle TCP-Verbindungsfähigkeit zu einem Zielport (Netcat). |
| `traceroute ` | Diagnose | Zeigt Hop-by-Hop die Router-Stationen auf dem Weg zum Ziel. |
## Weiterführende Ressourcen
Die folgenden Leitfäden, Spezifikationen und internen Kursmodule vertiefen die Linux-Netzwerkkonfiguration und Fehlersuche:
| Ressource | Beschreibung |
|---|---|
| [Netplan Documentation](https://netplan.readthedocs.io/){.badge-link-text} | Offizielle Dokumentation zur deklarativen YAML-Netzwerkkonfiguration. |
| [iproute2 Documentation](https://wiki.linuxfoundation.org/networking/iproute2){.badge-link-text} | Offizieller Leitfaden zu ip, ss, tc und Netzwerk-Namespaces. |
| [systemd-resolved Manual](https://manpages.debian.org/systemd-resolved.8){.badge-link-text} | Offizielle Dokumentation zum systemd Name Resolution Service. |
| [UFW Community Documentation](https://help.ubuntu.com/community/UFW){.badge-link-text} | Ausführlicher Leitfaden zur Uncomplicated Firewall auf Ubuntu/Debian. |
| [Linux Administration #3: Prozesse](/de/linux-administration/linux-administration-prozesse-und-ressourcenverwaltung){.badge-link-text} | Das vorherige Modul: Prozesse, Signale, Nice & cgroups. |
| [Linux Administration #5: Shell-Scripting](/de/linux-administration/linux-administration-shell-scripting-und-automatisierung){.badge-link-text} | Das nachfolgende Modul: Automatisierung, Cron, Traps & Bash. |
| [Befehlszeilenprozessor in Linux](/de/linux-neulinge/befehlszeilenprozessor-in-linux){.badge-link-text} | Fundamentales Wissen zu Shells, I/O-Streams und Pipes. |
## Fazit
Die Netzwerkverwaltung ist das fundamentale Bindeglied, das eigenständige Linux-Server in ausfallsichere Cloud- und Rechenzentrumsinfrastrukturen integriert. Durch die Beherrschung moderner `iproute2`-Befehle, deklarativer Netzwerkkonfiguration über Netplan und NetworkManager, transparenter DNS-Auflösung via `systemd-resolved` und solider Firewall-Regeln mit UFW und nftables bist du in der Lage, Servernetzwerke hochverfügbar aufzusetzen und Störungen im Betrieb systematisch zu lokalisieren.
💡 **Praxis-Tipp:** Teste neue Netzwerkkonfigurationen über Netplan immer mit `sudo netplan try`. Dieser Befehl wendet die Konfiguration an und setzt sie nach 120 Sekunden automatisch zurück, falls du dich durch einen Tippfehler selbst vom SSH-Zugang aussperrst und den Timeout nicht rechtzeitig mit Enter bestätigen kannst.
Im nächsten Modul unseres Administrationskurses widmen wir uns der Automatisierung wiederkehrender Aufgaben:
👉 **Weiter geht es mit:** [Linux Administration #5: Shell-Scripting und Automatisierung](/de/linux-administration/linux-administration-shell-scripting-und-automatisierung){.badge-link-text}
👉 **Zur Kursübersicht:** [Alle Linux-Administrations-Artikel & Module](/de/category/linux-administration){.badge-link-text}