Basic Connectivity​

• ping [host] - Test connectivity to a host
• ping -c 4 [host] - Send 4 packets (Linux/Mac)
• traceroute [host] - Show route packets take to destination (Linux/Mac)
• tracert [host] - Show route packets take to destination (Windows)
• mtr [host] - Combined ping and traceroute (Linux)

Network Information​

• ifconfig - Display network interfaces (Linux/Mac, deprecated)
• ip addr show - Display IP addresses and interfaces (Linux, modern)
• ip link show - Display network interfaces status
• ipconfig - Display network configuration (Windows)
• ipconfig /all - Detailed network configuration (Windows)
• hostname -I - Show all IP addresses of the host

DNS​

• nslookup [domain] - Query DNS for domain information
• dig [domain] - Detailed DNS lookup (Linux/Mac)
• host [domain] - Simple DNS lookup
• dig +short [domain] - Brief DNS response
• nslookup -type=mx [domain] - Query MX records

Port Scanning & Connections​

• netstat -tuln - Show listening ports (Linux)
• netstat -ano - Show all connections with process IDs (Windows)
• ss -tuln - Modern alternative to netstat (Linux)
• lsof -i :[port] - Show process using specific port (Linux/Mac)
• nc -zv [host] [port] - Test if port is open (netcat)
• telnet [host] [port] - Test port connectivity
• nmap [host] - Scan ports on target host
• nmap -p- [host] - Scan all ports

Network Statistics​

• netstat -s - Display network statistics
• iftop - Real-time bandwidth monitoring (Linux)
• nethogs - Monitor bandwidth per process (Linux)
• tcpdump -i [interface] - Capture network packets
• tcpdump -i eth0 port 80 - Capture HTTP traffic

Linux Firewalls​

iptables​

• iptables -L - List all rules
• iptables -L -v -n - List rules with verbose output
• iptables -A INPUT -p tcp --dport 22 -j ACCEPT - Allow SSH
• iptables -A INPUT -s 192.168.1.0/24 -j ACCEPT - Allow subnet
• iptables -A INPUT -p tcp --dport 80 -j DROP - Block port 80
• iptables -D INPUT [rule_number] - Delete rule by number
• iptables -F - Flush all rules (caution!)
• iptables -P INPUT DROP - Set default policy to DROP
• iptables-save > /etc/iptables/rules.v4 - Save rules
• iptables-restore < /etc/iptables/rules.v4 - Restore rules

firewalld (RHEL/CentOS/Fedora)​

• firewall-cmd --state - Check firewall status
• firewall-cmd --list-all - List all settings
• firewall-cmd --get-zones - List all zones
• firewall-cmd --get-active-zones - Show active zones
• firewall-cmd --zone=public --add-port=8080/tcp - Open port temporarily
• firewall-cmd --zone=public --add-port=8080/tcp --permanent - Open port permanently
• firewall-cmd --reload - Reload firewall rules
• firewall-cmd --zone=public --add-service=http - Allow service
• firewall-cmd --zone=public --remove-port=8080/tcp --permanent - Remove port
• firewall-cmd --list-ports - List open ports

ufw (Ubuntu/Debian)​

• ufw status - Check firewall status
• ufw enable - Enable firewall
• ufw disable - Disable firewall
• ufw allow 22 - Allow port 22
• ufw allow ssh - Allow SSH service
• ufw allow from 192.168.1.0/24 - Allow subnet
• ufw deny 80 - Deny port 80
• ufw delete allow 80 - Remove allow rule
• ufw status numbered - List rules with numbers
• ufw delete [number] - Delete rule by number
• ufw reset - Reset to default settings

Windows Firewall​

netsh (Command Line)​

• netsh advfirewall show allprofiles - Show all firewall profiles
• netsh advfirewall set allprofiles state on - Enable firewall
• netsh advfirewall set allprofiles state off - Disable firewall
• netsh advfirewall firewall show rule name=all - List all rules
• netsh advfirewall firewall add rule name="Allow Port 80" dir=in action=allow protocol=TCP localport=80 - Add inbound rule
• netsh advfirewall firewall delete rule name="Allow Port 80" - Delete rule
• netsh advfirewall reset - Reset firewall to defaults

PowerShell​

• Get-NetFirewallRule - List all firewall rules
• Get-NetFirewallProfile - Show firewall profiles
• Set-NetFirewallProfile -Profile Domain,Public,Private -Enabled True - Enable firewall
• New-NetFirewallRule -DisplayName "Allow Port 8080" -Direction Inbound -LocalPort 8080 -Protocol TCP -Action Allow - Create rule
• Remove-NetFirewallRule -DisplayName "Allow Port 8080" - Remove rule
• Get-NetFirewallRule | Where-Object {$_.Enabled -eq 'True'} - Show enabled rules

Routing​

Linux​

• ip route show - Display routing table
• route -n - Display routing table (deprecated)
• ip route add 10.0.0.0/24 via 192.168.1.1 - Add static route
• ip route del 10.0.0.0/24 - Delete route
• ip route get [IP] - Show route to specific IP

Windows​

• route print - Display routing table
• route add 10.0.0.0 mask 255.255.255.0 192.168.1.1 - Add static route
• route delete 10.0.0.0 - Delete route
• route -p add [destination] mask [netmask] [gateway] - Add persistent route

Network Configuration​

Linux​

• ip addr add 192.168.1.10/24 dev eth0 - Add IP to interface
• ip link set eth0 up - Bring interface up
• ip link set eth0 down - Bring interface down
• dhclient eth0 - Request DHCP address
• systemctl restart networking - Restart networking (Debian/Ubuntu)
• systemctl restart NetworkManager - Restart NetworkManager (RHEL/Fedora)

Windows​

• ipconfig /release - Release DHCP lease
• ipconfig /renew - Renew DHCP lease
• ipconfig /flushdns - Clear DNS cache
• netsh interface ip set address "Ethernet" static 192.168.1.10 255.255.255.0 192.168.1.1 - Set static IP

Troubleshooting Tips​

• Always test firewall rules before applying permanently
• Use --permanent flag with firewalld to make changes persistent
• Check logs: /var/log/firewalld (firewalld), /var/log/syslog or /var/log/messages (iptables)
• Remember that some tools require root/administrator privileges
• Document all firewall changes for future reference

Quick navigation:

cd -                    # Switch to previous directory
pushd /path && popd     # Save current dir, go to path, then return
!!                      # Repeat last command

Working with Bash History​

Basic history commands:

history                                # Show all command history
history 20                             # Show last 20 commands
history | grep docker                  # Search history for specific command
!123                                   # Execute command #123 from history
!docker                                # Execute most recent command starting with "docker"
!?search                               # Execute most recent command containing "search"

History argument shortcuts:

!$                                     # Last argument of previous command
!^                                     # First argument of previous command
!*                                     # All arguments of previous command
!:2                                    # Second argument of previous command
!:2-4                                  # Arguments 2 through 4
!:2*                                   # Arguments 2 through end
!:2-$                                  # Arguments 2 through last

# Example usage:
# After: ls /var/log/nginx/access.log
vim !$                                 # Opens vim /var/log/nginx/access.log

Interactive history search:

ctrl+r                                 # Search history backward (type to search)
ctrl+g                                 # Exit search without running
ctrl+o                                 # Execute found command (after ctrl+r)

History navigation (in command line):

ctrl+p or ↑                            # Previous command
ctrl+n or ↓                            # Next command

Managing history:

history -c                             # Clear current session history
history -w                             # Write current history to file
history -d 123                         # Delete command #123 from history
history -a                             # Append current session to history file
cat /dev/null > ~/.bash_history        # Clear entire history file

History configuration (add to ~/.bashrc):

export HISTSIZE=10000                  # Commands to keep in memory
export HISTFILESIZE=20000              # Commands to keep in history file
export HISTTIMEFORMAT="%F %T "         # Add timestamps to history
export HISTCONTROL=ignoredups          # Ignore duplicate commands
export HISTCONTROL=ignoreboth          # Ignore duplicates and commands starting with space
export HISTIGNORE="ls:pwd:exit:clear"  # Don't save these commands
shopt -s histappend                    # Append to history, don't overwrite

Advanced history tricks:

fc                                     # Open last command in $EDITOR to modify
fc 100 105                             # Edit commands 100-105 in editor
fc -l -10                              # List last 10 commands
fc -s docker                           # Re-execute last docker command

# Run command without saving to history (note the leading space):
 secret-command                        # (requires HISTCONTROL=ignorespace)

# Execute multiple history commands:
!123 && !125                           # Run commands 123 and 125

History with grep patterns:

history | grep "git commit"            # Find all git commits
history | grep -E "npm|yarn"           # Find npm or yarn commands
history | awk '{$1=""; print $0}'      # Print history without numbers
history | tail -20 | head -10          # Show commands 11-20 from the end

Quick command editing:

# After typing a long command with a typo:
^typo^correct                          # Replace first occurrence
!!:gs/old/new                          # Replace all occurrences in last command
!:0 new-arg !:2-$                      # Reuse command with different first arg

Useful history aliases (add to ~/.bashrc):

alias h='history'
alias h1='history 10'
alias h2='history 20'
alias h3='history 30'
alias hgrep='history | grep'
alias histop='history | awk "{print \$2}" | sort | uniq -c | sort -rn | head -10'

FZF integration for enhanced history search:

# If fzf is installed, add to ~/.bashrc:
[ -f ~/.fzf.bash ] && source ~/.fzf.bash

# Then use:
ctrl+r                                 # Interactive fuzzy history search (much better!)

# Custom history search command:
h() {
  eval $(history | fzf --tac | sed 's/^[ ]*[0-9]*[ ]*//')
}

Zsh-specific history features:

# (if using zsh instead of bash)
!!:s/old/new                           # Substitute in last command
r old=new                              # Quick substitution
fc -l -20                              # List last 20 commands
history -i                             # Show timestamps
autoload -U history-search-end         # Better history search

Finding Files & Content​

Find files by name:

find . -name "*.js"                    # Find all .js files
find . -iname "config*"                # Case-insensitive search
fd "pattern"                           # Modern alternative (faster)
fd -e py                               # Find all .py files

Find files by content:

grep -r "function_name" .              # Recursive search in current dir
grep -rn "TODO" --include="*.js" .     # Search with line numbers, specific files
rg "pattern"                           # ripgrep (much faster)
rg -t python "def.*function"           # Search specific file types
ag "search_term"                       # The Silver Searcher (also fast)

Fuzzy finding:

fzf                                    # Interactive fuzzy finder
vim $(fzf)                             # Open selected file in vim
cat $(fzf)                             # View selected file
ctrl+r                                 # Fuzzy search command history (if fzf installed)

Process Management​

Finding & killing processes:

ps aux | grep nginx                    # Find process by name
pgrep nginx                            # Get PID by process name
pkill nginx                            # Kill process by name
kill -9 PID                            # Force kill by PID
killall process_name                   # Kill all instances
lsof -i :8080                          # See what's using port 8080
netstat -tulpn | grep :8080            # Alternative port check

Process monitoring:

top                                    # Real-time process viewer
htop                                   # Better interactive process viewer
watch -n 1 "ps aux | grep node"        # Monitor command every 1 second

File Operations​

Bulk operations:

find . -name "*.log" -delete           # Delete all .log files
find . -name "*.txt" -exec chmod 644 {} \;  # Change permissions
rename 's/\.txt$/.md/' *.txt           # Batch rename (Perl rename)

File inspection:

head -n 20 file.txt                    # First 20 lines
tail -n 50 file.txt                    # Last 50 lines
tail -f app.log                        # Follow log file in real-time
less +F file.log                       # Like tail -f but scrollable
wc -l file.txt                         # Count lines

Disk Usage & System Info​

df -h                                  # Disk space human-readable
du -sh *                               # Size of each item in current dir
du -sh * | sort -h                     # Sorted by size
ncdu                                   # Interactive disk usage analyzer
free -h                                # Memory usage
uptime                                 # System uptime and load

Text Processing​

Useful one-liners:

cat file.txt | sort | uniq             # Remove duplicates
awk '{print $1}' file.txt              # Print first column
sed 's/old/new/g' file.txt             # Replace text
cut -d',' -f1,3 data.csv               # Extract CSV columns
jq '.name' data.json                   # Parse JSON

Git Shortcuts​

git log --oneline --graph --all        # Visual commit history
git diff --staged                      # See staged changes
git stash                              # Temporarily store changes
git stash pop                          # Restore stashed changes
git branch -d branch_name              # Delete local branch
git clean -fd                          # Remove untracked files/dirs
git reflog                             # See all ref changes (recover lost commits)

Network & HTTP​

curl -I https://example.com            # Get headers only
curl -o output.txt https://url         # Download to file
wget -r -np -k https://site.com        # Mirror website
ping -c 4 google.com                   # Ping 4 times then stop
traceroute google.com                  # Trace route to host
ss -tulpn                              # Socket statistics (modern netstat)

Docker Quick Commands​

docker ps                              # Running containers
docker ps -a                           # All containers
docker images                          # List images
docker logs -f container_name          # Follow container logs
docker exec -it container_name bash    # Shell into container
docker system prune -a                 # Clean up everything
docker-compose up -d                   # Start services in background

Permissions & Ownership​

chmod +x script.sh                     # Make executable
chmod 644 file.txt                     # rw-r--r--
chmod 755 script.sh                    # rwxr-xr-x
chown user:group file.txt              # Change owner
sudo chown -R $USER:$USER dir/         # Recursively claim ownership

Archive & Compression​

tar -czf archive.tar.gz folder/        # Create compressed archive
tar -xzf archive.tar.gz                # Extract compressed archive
tar -tzf archive.tar.gz                # List contents without extracting
unzip file.zip                         # Extract zip
zip -r archive.zip folder/             # Create zip archive

SSH & Remote​

ssh user@host                          # Connect to remote
ssh -i key.pem user@host               # Connect with key file
scp file.txt user@host:/path/          # Copy file to remote
scp user@host:/path/file.txt .         # Copy from remote
rsync -avz source/ user@host:/dest/    # Sync directories

Useful Aliases to Add to ~/.bashrc or ~/.zshrc​

alias ll='ls -alh'
alias ..='cd ..'
alias ...='cd ../..'
alias gs='git status'
alias gp='git pull'
alias gc='git commit -m'
alias ports='netstat -tulanp'
alias meminfo='free -h'
alias psg='ps aux | grep -v grep | grep -i -e VSZ -e'

Advanced Search Patterns​

Find and replace across files:

find . -name "*.js" -exec sed -i 's/oldText/newText/g' {} \;

Find recently modified files:

find . -mtime -7                       # Modified in last 7 days
find . -mmin -60                       # Modified in last 60 minutes

Find large files:

find . -type f -size +100M             # Files larger than 100MB

• Normal mode: Esc - Default mode for navigation and commands
• Insert mode: i - Type text before cursor; a - after cursor; I - start of line; A - end of line
• Visual mode: v - character selection; V - line selection; Ctrl+v - block selection
• Command mode: : - Execute commands

Navigation​

• Basic movement: h (left), j (down), k (up), l (right)
• Word movement: w (next word), b (previous word), e (end of word)
• Line movement: 0 (start of line), ^ (first non-blank), $ (end of line)
• Document movement: gg (file start), G (file end), {number}G (go to line number)
• Screen movement: Ctrl+f (page down), Ctrl+b (page up), Ctrl+d (half page down), Ctrl+u (half page up)
• Jump to matching bracket: %

Editing​

• Delete: x (character), dd (line), dw (word), d$ (to end of line)
• Change: cw (change word), cc (change line), C (change to end of line)
• Yank (copy): yy (line), yw (word), y$ (to end of line)
• Paste: p (after cursor), P (before cursor)
• Undo/Redo: u (undo), Ctrl+r (redo)
• Repeat last command: .
• Join lines: J

Search and Replace​

• Search: /pattern (forward), ?pattern (backward)
• Next/Previous match: n (next), N (previous)
• Replace: :s/old/new/ (first on line), :s/old/new/g (all on line)
• Replace in file: :%s/old/new/g (all occurrences), :%s/old/new/gc (with confirmation)
• Clear search highlighting: :noh

File Operations​

• Save: :w (write), :w filename (save as)
• Quit: :q (quit), :q! (quit without saving), :wq or :x (save and quit)
• Open file: :e filename
• Reload file: :e!

Multiple Files/Windows​

• Split windows: :split or :sp (horizontal), :vsplit or :vsp (vertical)
• Navigate windows: Ctrl+w h/j/k/l (move between splits)
• Close window: :close or Ctrl+w c
• Switch buffers: :bn (next), :bp (previous), :b {number/name} (specific buffer)
• List buffers: :ls

Visual Mode Operations​

After selecting text in visual mode:

• d - delete selection
• y - yank (copy) selection
• c - change selection
• > - indent right
• < - indent left
• = - auto-indent

Useful Combinations​

• ciw - change inner word (cursor anywhere in word)
• ci" - change inside quotes
• di{ - delete inside braces
• yi( - yank inside parentheses
• va} - visually select around braces (including braces)

Markers and Jumps​

• Set marker: m{a-z} (lowercase for file-specific, uppercase for global)
• Jump to marker: '{a-z} (line), `{a-z} (exact position)
• Jump back: Ctrl+o, Jump forward: Ctrl+i

Neovim-Specific​

• Built-in LSP: :LspInfo, :LspStart, :LspStop
• Treesitter: :TSInstall {language}, :TSUpdate
• Lua config: ~/.config/nvim/init.lua
• Terminal: :terminal or :term, exit with Ctrl+\ Ctrl+n

Recording Macros​

• Start recording: q{a-z} (record to register a-z)
• Stop recording: q
• Play macro: @{a-z}, repeat with @@

Miscellaneous​

• Show line numbers: :set number or :set nu
• Relative line numbers: :set relativenumber
• Show invisible characters: :set list
• Toggle paste mode: :set paste / :set nopaste
• Spell check: :set spell, ]s (next error), [s (previous), z= (suggestions)
• Fold: zc (close), zo (open), za (toggle)

Create SSH key

    ssh-keygen -t ed25519 -C "example@example.com"

Copy public key to remote server

    ssh-copy-id

SSH agent​

Use SSH-agent in remote server

    exec ssh-agent bash

Start SSH agent

    eval $(ssh-agent -s)

Add key to agent

    ssh-add ~/.ssh/[key file]

Enable agent forwarding in the local ssh config

      ForwardAgent yes

Enable agent forwarding in the remote ssh server config

    vi /etc/ssh/sshd_config

SSH server​

Start and stop SSH server

    systemctl status sshd
    systemctl start sshd

jump host​

    ssh -J user@jumphost -R 8080:localhost:8080 user@hiddenhost
    ssh -R 8080:hiddenhost:8080 user@jumphost

Zutaten für die Soße​

• 500g Nuss oder Schulter vom Schwein
• 1-2 große Zwiebeln
• 1 Stück Knollensellerie
• 1-2 Tomaten oder Tomatenmark

Zutaten für die Spätzle​

• 300g Mehl
• 3 Eier

Zubereitung der Soße​

Fleisch leicht salzen und gut anbraten. Dann die Zwiebeln kleinschneiden und beides zusammen anbraten. Nun gewürfelte Tomaten und geriebene Sellerie dazu und alles zusammen mehrmals anbraten. Immer wieder etwa eine halbe Tasse Wasser hinzufügen bevor es stark anbrennt. Mit Salz, Pfeffer und Paprikapulver abschmecken. Die Soße kann mit Mehl gebunden werden.

Zubereitung der Spätzle​

Zutaten mischen und einen halben Teelöffel Salz dazu. Dann mit etwa 200 ml Wasser mischen bis die Masse leicht umzurühren ist. Nun die Spätzle in kochendes Wasser geben. Um die Spätzle zu formen kann man Löffel verwenden, die zwischendurch immer wieder in das kochende Wasser getaucht werden sollten. Wenn die Spätzle an der Oberfläche schwimmen, sind sie fertig.

Zutaten​

Zubereitung​

Zutaten​

• grüne kleine Paprikaschoten
• viel Olivenöl

Zubereitung

So viel Olivenöl in einen Topf geben, dass die Paprikaschoten fast bedeckt werden würden. Das Öl zum Kochen bringen und sicherstellen, dass die Paprika trocken sind. Andernfalls spritzt das Öl sehr schnell. Am besten einen Schutz gegen Ölspritzer besorgen oder zur Not einen Topfdeckel. Dann Paprika frittieren bis sie gerade braun werden. Später die Paprika mit Salz bestreuen. Dazu am besten groben Salz verwenden.

Zutaten für 2 große runde Pizza-Böden​

• 400 g Mehl Typ 00
• 225 ml Wasser (20°C)
• 1 Päckchen Trockenhefe
• 11 g Salz

Zubereitung​

Wasser, einen kleinen Teil der Mehls und Hefe in eine Rührschüssel geben. Dann rühren und nach und nach das gesamte Mehl hinzugeben. Anschließend kneten bis der Teig geschmeidig ist.

Dann mindestens zwei Stunden an einem warmen Ort gehen lassen, dabei abdecken, sodass der Teig keine Feuchtigkeit verliert. Anschließend den Teig in Kugeln teilen und wieder 6 Stunden ruhen lassen.

Zum Backen:

• Ofen auf höchste Hitzestufe Ober- und Unterhitze
• Backblech drinn lassen, soll auch heiß werden
• Backzeit: ca. 8 Min

Zutaten für 15 Crepes​

• 250g Buchweizenmehl
• 1 Esslöffel Weizenmehl
• 1 Teelöffel grober Salz
• 1 Ei
• 12cl Wasser
• 48cl Halbfettmilch

Zubereitung​

Buchweizenmehl, Weizenmehl, Salz, Ei und Wasser in eine Schüssel geben. Verrühren bis sich eine kompakte Teigkugel ergibt. 12cl Milch hinzugeben und verdünnen, dann 5 Minuten schlagen bis ein absolut homogener Teig entsteht. Nach und nach weitere 36cl Milch hinzugeben.

Zutaten​

• 1 Tasse Mehl
• 1 Tasse Wasser
• 1 Teelöffel Butter
• Olivenöl
• dunkle Schokolade
• Milch

Zubereitung​

Wasser in einem Topf erhitzen und Butter und Salz hinzufügen. Wenn das Wasser kocht, unter ständigem Rühren mit einem Holzlöffel das Mehl hinzugeben, bis sich der Teig von dem Topf löst. Wenn der Teig sehr fest geworden ist, noch etwas Wasser dazugeben. Den Teig ruhen lassen bis er abgekühlt ist. Dann den Teig in eine Churros- oder Gebäckpresse geben.

Die Churros in eine tiefe kleine Pfanne mit reichlich sehr heißem Öl fallen lassen. Darauf achten, dass die Churros nicht anbrennen. Die Churros auf einem Teller mit Küchenpapier ablaufen lassen. Nebenbei die Schokolade erwärmen und etwas Milch dazu geben damit sie nicht zu dickflüssig wird.

Zutaten​

• 500g Mehl (Type 450)
• 50g Zucker
• 30g frische Hefe
• 1 TL Salz
• 250g Butter
• 310 ml Wasser (kalt)

Zubereitung​

Teig​

Hefe in das Wasser geben und verrühren. Mehl und Zucker vermischen und dann das Wasser mit Hefe dazugeben. Alles verrühren und durchkneten. Teig mit Mehl bestäuben und in einer Schüssel mit feuchtem Tuch bedeckt 30 Minuten im Kühlschrank lassen.

Butter vorbereiten​

Butter mit einer Teigrolle etwas plattdrücken. Dann die Butter auf ein Backpapier legen und dieses quadratisch falten. Nun die Butter mit der Teigrolle platthauen und ausrollen bis sie die Backpapierform ausfüllt. Die Butter ebenfalls für 20 Minuten in den Kühlschrank legen damit sie nicht weich wird.

Zutaten für 3-4 Personen​

• 200g Datteln
• 200g Schinken

Zubereitung​

Datteln mit einem halben Streifen Schinken (je nach Größe) umwickeln und in eine Backform geben. Dann bei 180 Grad Ober/Unterhitze 20 bis 30 Minuten (je nach Geschmack) im Backofen lassen.

Zutaten​

• 1 Packung Schmand
• 1 Packung Joghurt
• 1 Knoblauchzehe
• 1 Teelöffel Olivenöl
• Salz
• Pfeffer
• Frühlingszwiebeln und andere Kräuter

Zutaten für die Suppe​

• Butter
• 1 Zwiebel
• 1 kleine Möhre
• 1 Stückchen Knollen Sellerie
• 1 Knoblauchzehe
• 1 Tasse Linsen für 2 Pers. Padina
• Salz, Pfeffer

Zutaten für die Spätzle​

• 3 Esslöffel Mehl
• 1 Ei
• etwas Wasser ca 2 Esslöffel
• etwas Salz

Zubereitung​

Ohne Einweichen brauchen die Linsen etwa 1,5 Stunden. Zuerst die Butter auslassen und die Zwiebeln anbraten. Wenn die Zwiebeln glasig werden, kommt die fein gewürfelte Karotte hinein.

Dann 1 Liter Wasser dazugeben und den Herd auf die höchste Stufe stellen. Dann die Linsen in einem feinen Sieb waschen und in den Topf geben. Vorsicht, damit es nicht zu viel spritzt. Knoblauch schälen, kleinschneiden und dazugeben, ebenso die 1-2 Kartoffeln. Die Sellerie sauber abschneiden, würfeln und in den Topf geben. Dann etwa ein gestrichener Esslöffel Salz drauf - je nach Geschmack.

Wenn die Suppe kocht, auf Stufe die Hitze herunterdrehen, Deckel drauf und 1,5 Stunden köcheln lassen. Zum Schluss mit Pfeffer Schärfe abschmecken.

Wenn man will, kann man die letzten 10 Minuten Würstchen mit in der Suppe erwärmen. Dann aber vorsichtig mit dem Salz, weil die Würstchen auch Salz abgeben.

Zubereitung​

Baguette in Scheiben schneiden und mit Öl bestreichen. Dann bei 180 Grad etwa 5 Minuten im Backofen lassen.

Besonders gut passt dazu Gazpacho. Das Rezept dazu kommt noch ;-)

Zutaten für etwa 6 Stück​

• 225g Mehl
• 3 El Zucker
• 2 Tl Vanille-Zucker
• 3 Eier
• 2 gestr. Tl Backpulver
• 0.5 L Milch
• 1/4 Fl. Rumaroma

Zutaten für 20 Crepes​

• 100 bis 125g Zucker
• 250g Weizenmehl
• 50cl Milch (fettarm)
• 1 Esslöffel Buchweizenmehl
• 1 Prise Kochsalz
• 2 Eier
• 25g zerlassene Butter oder 1 Esslöffel Öl
• 1 Päckchen Vanillezucker
• 10cl Wasser

Zubereitung​

Zucker, Buchweizenmehl, Salz, Eier, Butter bzw. Öl, 1 Päckchen Vanillezucker und Wasser in eine Schüssel geben. Alles schlagen und nach und nach Weizenmehl und 12cl Milch hinzufügen bis Sie einen homogenen, klümpchenfreien Teig erhalten. Dann weitere 38cl Milch hinzugeben.