Wat is een IP adres?
Dit artikel legt uit wat een IP-adres is, hoe het werkt, en hoe je er zelf mee kunt kijken op een Linux-systeem. Voor iedereen die servers beheert, netwerken inricht of gewoon wil snappen wat er onder de motorkap gebeurt wanneer je een website opent.
Vereisten
- Een Linux-systeem (Debian 12, Ubuntu 24.04 of vergelijkbaar) met een netwerkverbinding
- `iproute2` — standaard aanwezig op vrijwel elke moderne distributie, versie 6.x
- `whois` — installeer met `apt install whois` (versie 5.5.x)
- `dig` uit `dnsutils` of `bind9-dnsutils`
- Optioneel: `curl` versie 8.x voor het opvragen van je publieke IP
Stappen
1. Bekijk je eigen IP-adressen
Het `ip`-commando is de moderne opvolger van het verouderde `ifconfig`. Het laat direct zien welke interfaces welk adres hebben.```bash ip -brief address show ```
De uitvoer toont per interface een regel, bijvoorbeeld `eth0 UP 192.168.1.42/24`. Die `/24` is de subnetmasker in CIDR-notatie: 24 bits zijn het netwerkdeel, de laatste 8 bits het hostdeel. In de praktijk betekent dat: adressen van 192.168.1.1 tot 192.168.1.254 zitten in jouw subnet.
Wil je meer detail per interface, laat dan de `-brief` vlag weg.
```bash ip address show ```
Je ziet dan ook het MAC-adres, de status van de interface en eventuele IPv6-adressen. Dat laatste is belangrijk: op moderne systemen heeft bijna elke interface standaard een link-local IPv6-adres dat begint met `fe80::`.
2. Begrijp het verschil tussen publiek en privé
Je ziet in de uitvoer van stap 1 vrijwel zeker een adres uit een van deze drie bereiken:- `10.0.0.0/8` — 16,7 miljoen adressen
- `172.16.0.0/12` — 1 miljoen adressen
- `192.168.0.0/16` — 65.536 adressen
Dat is precies waarom je met tientallen apparaten achter één router kunt zitten terwijl de wereld maar één adres van je ziet. De router vertaalt heen en weer met NAT (Network Address Translation). Wat dat je kost: binnenkomende verbindingen werken niet zonder port forwarding, en peer-to-peer toepassingen zoals sommige games of torrents hebben er last van.
3. Vraag je publieke IP op
Je provider geeft je één publiek adres — of een klein blok — dat de buitenwereld ziet. Dat adres kun je opvragen bij een externe dienst.```bash curl -4 https://ifconfig.me ```
De `-4` dwingt IPv4 af. Zonder die vlag krijg je mogelijk een IPv6-adres terug als je provider dat ondersteunt. Wil je beide zien:
```bash curl https://ifconfig.me curl -6 https://ifconfig.me ```
Het eerste commando geeft je IPv4-adres, het tweede je IPv6-adres als dat er is. Als het tweede een foutmelding geeft, heeft je verbinding geen IPv6 — dat is nog steeds normaal bij veel providers.
4. Zoek uit wie een IP-blok bezit
Elk publiek IP-adres is toegewezen aan een organisatie. Met `whois` zie je welke.```bash whois 8.8.8.8 ```
Je krijgt de eigenaar, het toegewezen netwerkblok, de registratiedatum en contactgegevens. Voor 8.8.8.8 zie je Google LLC en het blok 8.8.8.0/24.
Het `whois`-commando gebruikt het WHOIS-protocol uit RFC 3912 en kiest automatisch de juiste server op basis van het adres. Voor Europese adressen is dat doorgaans de RIPE NCC, voor Noord-Amerikaanse ARIN, voor Azië-Pacific APNIC.
De RIPE NCC beheert de IP-adressen voor Europa, het Midden-Oosten en een deel van Centraal-Azië. Het is een non-profit ledenorganisatie die optreedt als Regional Internet Registry. Vergelijkbare organisaties zijn ARIN, APNIC, LACNIC en AFRINIC.
5. Test de bereikbaarheid van een adres
`ping` stuurt ICMP-pakketten naar een adres en wacht op antwoord. Het is de snelste manier om te zien of een host leeft.```bash ping -c 4 1.1.1.1 ```
De `-c 4` beperkt het aantal pakketten tot vier. Zonder die vlag blijft ping doorgaan tot je Ctrl+C indrukt.
Krijg je geen antwoord, dan betekent dat niet automatisch dat de host offline is. Veel servers blokkeren ICMP standaard. Gebruik dan `traceroute` om te zien waar het pad stopt.
```bash traceroute -n 1.1.1.1 ```
De `-n` vlag slaat DNS-resolutie over, wat het commando een stuk sneller maakt. Je ziet elke hop tussen jou en het doel, met het IP-adres en de responstijd per hop.
6. Zet een statisch IP-adres op een server
Servers hebben een vast adres nodig. Een DHCP-adres kan bij een reboot veranderen, en dan is je server onbereikbaar — tot iemand fysiek langsgaat.Op Debian 12 en Ubuntu 24.04 regel je dat met Netplan of met `systemd-networkd`. Voor Netplan ziet de configuratie er zo uit, in `/etc/netplan/01-static.yaml`:
```yaml network: version: 2 ethernets: eth0: dhcp4: no addresses: - 192.168.1.50/24 routes: - to: default via: 192.168.1.1 nameservers: addresses: - 1.1.1.1 - 9.9.9.9 ```
Pas daarna toe met:
```bash sudo netplan apply ```
Wat dit je kost: je moet het gateway-adres en de subnetgrootte kennen voordat je dit schrijft. Klopt er iets niet, dan verlies je de verbinding en moet je via console of IPMI terug. Test altijd eerst met `netplan try`, dat draait de configuratie 120 seconden en rolt automatisch terug als je niet bevestigt.
7. Begrijp IPv6 in één oogopslag
IPv4 heeft 2^32 adressen — ongeveer 4,3 miljard. Dat is allang op. IPv6 heeft 2^128 adressen, wat neerkomt op ongeveer 340 undeciljoen. Genoeg voor de komende eeuwen.Een IPv6-adres bestaat uit acht groepen van vier hexadecimale cijfers, gescheiden door dubbele punten:
``` 2001:0db8:85a3:0000:0000:8a2e:0370:7334 ```
Nullen aan het begin van een groep mag je weglaten, en één opeenvolging van nullen-groepen mag je vervangen door `::`. Het bovenstaande adres schrijf je dus ook als:
``` 2001:db8:85a3::8a2e:370:7334 ```
Op je Linux-systeem bekijk je je IPv6-adressen met hetzelfde `ip`-commando:
```bash ip -6 address show ```
Wat dit je kost: IPv6 heeft geen NAT nodig, en dat betekent dat elk apparaat in principe een eigen publiek adres heeft. Je firewall wordt dus belangrijker, niet minder. Veel thuisrouters blokkeren inkomend IPv6-verkeer standaard, maar op een server moet je dat zelf regelen.
8. Bekijk je actieve verbindingen
`ss` vervangt het verouderde `netstat`. Het toont welke poorten openstaan en met wie je systeem praat.```bash ss -tunap ```
De vlaggen: `-t` voor TCP, `-u` voor UDP, `-n` om poorten als nummers te tonen in plaats van namen, `-a` voor alle sockets, `-p` om het bijbehorende proces te tonen. Voor het laatste heb je `sudo` nodig, anders zie je alleen je eigen processen.
Wil je alleen luisterende poorten zien:
```bash sudo ss -tlnp ```
Dit is het commando dat je draait wanneer je wilt weten of er iets onverwachts op je server luistert. Een open poort naar buiten is een open deur naar binnen.
Verificatie
Controleer of je alles goed hebt: je publieke IP uit stap 3 moet overeenkomen met wat een externe dienst ziet, en je privé-IP uit stap 1 moet in een van de RFC 1918-bereiken vallen.```bash echo "Privé: $(ip -brief address show | grep -v '^lo' | awk '{print $3}' | head -1)" echo "Publiek: $(curl -s -4 https://ifconfig.me)" ```
Als het goed is zie je twee verschillende adressen. Het privé-adres begint met 10., 172.16-31. of 192.168. Het publieke adres is iets heel anders.
Test daarna of je een externe host kunt bereiken via IP:
```bash ping -c 2 1.1.1.1 && echo "Netwerk werkt" ```
Krijg je "Netwerk werkt" te zien, dan is je IP-configuratie in orde.
Veelgestelde problemen
Geen internet na het instellen van een statisch IP. Negen van de tien keer is het gateway-adres fout, of het subnetmasker. Controleer met `ip route` of je default route correct staat. Klopt die niet, dan gaan pakketten nergens heen.`whois` geeft "no entries found". Het adres valt dan in een blok dat niet direct is toegewezen, of je query wordt door de verkeerde server afgehandeld. Probeer de specifieke RIR-server: `whois -h whois.ripe.net 193.0.0.1` voor Europese adressen.
IPv6 werkt niet ondanks dat je provider het ondersteunt. Controleer of je router Router Advertisements doorgeeft. Op Linux zie je met `ip -6 route` of er een default route via IPv6 is. Ontbreekt die, dan krijg je wel een link-local adres (`fe80::`) maar geen routeerbaar adres.
Een IP-adres is geen eigenschap van een apparaat, maar van een interface op een moment. Zet je laptop uit en aan in een ander netwerk, dan is het adres weg. Het netwerk weet niet wie je bent — het weet alleen waar het antwoord naartoe moet.