SSH-sleutels uitgelegd: gids voor snelle en veilige externe toegang

Ben je het beu om elke keer je wachtwoord te typen wanneer je verbinding maakt met een externe server of een GitHub-repository?

SSH-sleutels zijn precies wat je zoekt. Ze bieden een veilige en handige vervanging voor wachtwoordauthenticatie wanneer je toegang wilt tot externe systemen. SSH-sleutels zijn ook veiliger dan wachtwoorden, omdat ze in de praktijk niet te kraken zijn met brute-force-aanvallen.

Door de jaren heen zijn ze de standaard geworden voor veilige externe verbindingen in professionele omgevingen. Ze zijn onmisbaar voor iedereen die met externe servers, clouddiensten of versiebeheersystemen zoals Git werkt.

In dit artikel leer je hoe je SSH-sleutels genereert, toevoegt aan externe systemen en best practices toepast om ze veilig te beheren.

Wat zijn SSH-sleutels?

SSH-sleutels zijn cryptografische gegevens die je veilige toegang geven tot externe systemen zonder wachtwoorden te typen. In plaats van complexe wachtwoorden met cijfers, hoofdletters en speciale tekens te onthouden, maak je een sleutelpaar aan – één publieke en één private sleutel.

Zie je publieke sleutel als een hangslot dat je vrij kunt uitdelen aan elke server waartoe je toegang wilt. Je private sleutel werkt als de unieke sleutel die die hangsloten opent. Wanneer je verbinding maakt met een extern systeem, controleert het of je private sleutel overeenkomt met de opgeslagen publieke sleutel. Als ze overeenkomen, krijg je direct toegang zonder een wachtwoord in te voeren.

Aan de hand van de publieke sleutel kun je de private sleutel niet achterhalen, wat dit systeem extreem veilig maakt. Je private sleutel moet geheim blijven en op je computer blijven, dus deel die alsjeblieft nooit met iemand.

> Wil je beter begrijpen hoe veilige verbindingen passen binnen het bredere cybersecurity-landschap? Bekijk de cursus Introduction to Data Security.

Wat de voordelen ten opzichte van traditionele wachtwoordauthenticatie betreft, zijn dit de belangrijkste punten:

• Verbeterde veiligheid – In tegenstelling tot wachtwoorden zijn SSH-sleutels niet te raden of te brute-forcen vanwege hun lengte en complexiteit (meestal 2048 bits of meer).
• Meer gemak – Na de setup kun je verbinding maken met servers zonder telkens wachtwoorden te typen.
• Geschikt voor automatisering – Perfect voor scripts en geautomatiseerde processen die veilige authenticatie nodig hebben.
• Gecentraliseerd toegangsbeheer – Voeg toegang toe of trek die in door simpelweg publieke sleutels op je servers te beheren.
• Geen wachtwoordmoeheid meer – Je hoeft geen complexe wachtwoorden te maken, te onthouden of periodiek te wijzigen.

SSH-sleutels werken met vrijwel elk systeem dat SSH ondersteunt, waaronder Linux-servers, cloudplatforms en coderepositories zoals GitHub en GitLab. Ze zijn uitgegroeid tot de standaard voor veilige externe toegang in professionele omgevingen.

> Voor cloudprofessionals zijn zowel security als kostenefficiëntie cruciaal—leer meer in de cursus AWS Security and Cost Management.

Nu je weet wat SSH-sleutels zijn, leer je vervolgens hoe je ze genereert.

SSH-sleutels genereren

SSH-sleutels maken kost slechts een paar minuten, ongeacht je besturingssysteem. 

Het proces genereert twee bestanden: je private sleutel (die veilig op je computer moet blijven) en je publieke sleutel (die je aan externe servers toevoegt).

SSH-sleutels genereren op Linux/macOS

Om SSH-sleutels te maken op Linux of macOS, gebruik je de ingebouwde opdracht ssh-keygen. Open je terminal en typ:

ssh-keygen -t rsa -b 4096 -C "[email protected]"Mogelijk gemaakt door

Deze opdracht vertelt je systeem een nieuwe RSA-sleutel met 4096-bit versleuteling (zeer veilig) te maken en je e-mailadres als opmerking toe te voegen voor herkenning.

Je systeem vraagt waar de sleutel moet worden opgeslagen en of je een passphrase wilt toevoegen. De standaardlocatie werkt voor de meeste gebruikers prima, maar de passphrase is het overwegen waard. 

Een goede passphrase voegt een extra beveiligingslaag toe - zelfs als iemand je private sleutelbestand bemachtigt, kan diegene het niet gebruiken zonder deze zin te kennen.

Afbeelding 1 - SSH-sleutelpaar maken op Linux/macOS

Na het bevestigen van je keuzes maakt je systeem beide sleutels in de map .ssh in je thuismap:

• Je private sleutel: Het bestand zonder extensie (zoals id_rsa).
• Je publieke sleutel: Het bestand met de extensie .pub (zoals id_rsa.pub).

Afbeelding 2 - Gemaakte sleutelbestanden

SSH-sleutels genereren op Windows

Windows-gebruikers hebben een paar goede opties om SSH-sleutels te maken: Git Bash en WSL.

Git Bash biedt een commandline-ervaring vergelijkbaar met Linux/macOS. Als je Git for Windows hebt geïnstalleerd, heb je deze tool al. Open Git Bash en gebruik dezelfde opdracht ssh-keygen als hierboven.

Windows Subsystem for Linux (WSL) is een andere goede optie als je liever in een Linux-omgeving werkt op je Windows-machine. De opdrachten werken exact hetzelfde als op een native Linux-systeem.

Voor wie liever een grafische interface, PuTTYgen biedt een meer visuele aanpak.

Afbeelding 3 - PuTTYgen-sleutelgeneratie op Windows

Dit zijn de stappen die je moet nemen om je sleutelpaar te maken:

1. Start PuTTYgen vanuit je Startmenu.
2. Selecteer RSA als sleuteltype.
3. Klik op "Generate" en beweeg je muis in het lege gebied.
4. Voeg een passphrase toe voor extra beveiliging.
5. Sla zowel je publieke als je private sleutels op met de bijbehorende knoppen.

Afbeelding 4 - Gemaakte sleutelbestanden (2)

De sleutelbestanden begrijpen

Het genereren van SSH-sleutels maakt twee bestanden die als paar werken.

Je private sleutel moet geheim en veilig op je computer blijven. Zie het als een hoofdsleutel die je identiteit bewijst. Private sleutels heten meestal ongeveer zo:

• id_ed25519 (voor Ed25519-sleutels).
• id_rsa (voor RSA-sleutels).

Je publieke sleutel kun je vrij delen met elk systeem waarvoor je toegang wilt. Het werkt als een slot dat alleen jouw private sleutel kan openen. Publieke sleutels hebben altijd dezelfde naam als hun bijbehorende private sleutel, plus de extensie .pub.

De veiligheid van dit systeem hangt volledig af van het beschermen van je private sleutel.

Deel hem nooit, mail hem niet rond en sla hem niet op onbetrouwbare apparaten op. Denk je dat je private sleutel is gecompromitteerd, genereer dan meteen een nieuw paar en werk alle servers bij die je oude publieke sleutel hadden.

Je kunt de inhoud van je publieke sleutel bekijken met:

cat ~/.ssh/id_rsa.pubMogelijk gemaakt door

Afbeelding 5 - Inhoud publieke sleutel

De uitvoer toont de volledige tekenreeks die je nodig hebt bij het configureren van externe servers, wat we in de volgende sectie doornemen.

SSH-sleutels toevoegen aan externe systemen

Nu je je SSH-sleutelpaar hebt aangemaakt, moet je je publieke sleutel toevoegen aan elk extern systeem waartoe je toegang wilt. Simpel gezegd vertelt dit proces de externe server om je private sleutel als geldige authenticatiemethode te herkennen.

Publieke sleutels toevoegen aan een externe server

Er komt niet veel bij kijken; je hoeft je publieke sleutel alleen toe te voegen aan een speciaal bestand op de externe server. Dit bestand, authorized_keys, bevat een lijst met publieke sleutels die mogen verbinden.

De eenvoudigste manier om je sleutel toe te voegen is met de opdracht ssh-copy-id:

ssh-copy-id username@remote_hostMogelijk gemaakt door

Deze opdracht maakt verbinding met de externe server, maakt de benodigde mappen aan als ze niet bestaan en voegt je publieke sleutel toe aan het bestand authorized_keys. Je moet hierbij nog één keer je wachtwoord invoeren.

Afbeelding 6 - Inhoud van het bestand authorized_keys

Als je systeem de opdracht ssh-copy-id niet heeft, kun je hetzelfde handmatig doen, maar dat kost een paar stappen.

Volg deze instructies en voer de opdrachten één voor één uit:

# Toon je publieke sleutel en kopieer deze
cat ~/.ssh/id_rsa.pub

# Maak verbinding met je externe server met wachtwoordauthenticatie
ssh username@remote_host

# Maak de map .ssh aan als deze niet bestaat
mkdir -p ~/.ssh

# Open of maak het bestand authorized_keys en plak je publieke sleutel
echo "your_copied_public_key" >> ~/.ssh/authorized_keysMogelijk gemaakt door

En dat is alles!

Voor servers waar je je sleutel aan een systeembeheerder moet geven, stuur je eenvoudig de inhoud van je publieke sleutelbestand. Zij voegen hem voor je toe op de server.

SSH configureren voor sleutelauthenticatie

Na het toevoegen van je publieke sleutel wil je mogelijk de SSH-server configureren om de beveiliging verder te verbeteren. Voor deze stappen zijn administratieve (sudo) rechten nodig.

Om de SSH-serverconfiguratie te bewerken, open je het hoofdconfiguratiebestand:

sudo nano /etc/ssh/sshd_configMogelijk gemaakt door

Afbeelding 7 - Inhoud van het bestand sshd_config

In dit bestand kun je een paar beveiligingsverbeteringen doorvoeren:

• Stel PasswordAuthentication no in om wachtwoordinlog volledig uit te schakelen.
• Zorg dat PubkeyAuthentication yes is ingesteld (meestal standaard ingeschakeld).
• Overweeg PermitRootLogin prohibit-password in te stellen om rootlogin met wachtwoord te voorkomen.

Na het aanpassen, vergeet niet de SSH-service te herstarten om de wijzigingen toe te passen:

sudo systemctl restart sshdMogelijk gemaakt door

Het is ook goed om te weten dat de juiste bestandsrechten cruciaal zijn voor sleutelauthenticatie. De SSH-server is zeer strikt qua beveiliging en weigert verbindingen als de rechten te open zijn. Zorg dat je bestanden deze rechten hebben:

• Je thuismap: chmod 755 ~.
• De map .ssh: chmod 700 ~/.ssh.
• Het bestand authorized_keys: chmod 600 ~/.ssh/authorized_keys.

Met je publieke sleutel op zijn plek en de server goed geconfigureerd, kun je nu verbinden met externe servers zonder je wachtwoord in te voeren. 

In de volgende sectie laat ik je zien hoe je je SSH-sleutels gebruikt voor authenticatie.

SSH-sleutels gebruiken voor authenticatie

Je bent nu klaar om te profiteren van het gemak en de veiligheid van wachtwoordloze authenticatie. Laten we bekijken hoe je met je SSH-sleutels verbinding maakt met servers en coderepositories.

Verbinden met een externe server met sleutelauthenticatie

Verbinden met een server met SSH-sleutels werkt net als reguliere SSH-toegang, maar zonder de wachtwoordprompt. Open je terminal en gebruik de standaard SSH-opdracht:

ssh username@hostnameMogelijk gemaakt door

Als je je sleutel op de standaardlocatie (~/.ssh/id_rsa) hebt opgeslagen, vindt SSH hem automatisch. Als je een passphrase hebt ingesteld bij het aanmaken van je sleutel, moet je die invoeren, maar slechts één keer per sessie.

Voor sleutels op niet-standaardlocaties geef je het pad op met de vlag -i:

ssh -i ~/path/to/your/private_key username@hostnameMogelijk gemaakt door

Afbeelding 8 - Verbinden met een externe server via SSH

Elke keer je passphrase typen kan gaan vervelen. Daar komt de SSH-agent van pas. Die draait op de achtergrond en bewaart je ontsleutelde private sleutels veilig in het geheugen, zodat je je passphrase maar één keer hoeft in te voeren.

Om de SSH-agent te starten en je sleutel toe te voegen:

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_rsaMogelijk gemaakt door

Afbeelding 9 - SSH-agent

Je voert je passphrase één keer in en de agent handelt de authenticatie af voor alle verdere verbindingen tijdens je sessie. Dit is handig wanneer je meerdere keren met servers moet verbinden of wanneer applicaties meerdere SSH-verbindingen opzetten.

Op macOS start de SSH-agent automatisch en kun je tijdens de eerste verbinding "remember passphrase in keychain" inschakelen om te voorkomen dat je die in toekomstige sessies opnieuw moet invoeren. Helaas is deze functie alleen beschikbaar op macOS.

SSH-sleutels gebruiken voor GitHub/GitLab-authenticatie

Diensten zoals GitHub en GitLab ondersteunen ook authenticatie met SSH-sleutels, en raden dit aan boven wachtwoordauthenticatie.

Om je SSH-sleutel aan GitHub toe te voegen, open je GitHub en log je in op je account. Klik vervolgens op je profielfoto rechtsboven en selecteer "Settings". Klik in de zijbalk op "SSH and GPG keys":

Afbeelding 10 - GitHub-authenticatie instellen (1)

Klik op "New SSH key", geef je sleutel een beschrijvende titel, plak je publieke sleutel in het veld "Key" en klik tot slot op "Add SSH key":

Afbeelding 11 - GitHub-authenticatie instellen (2)

Als alles is voltooid, zie je een succesbericht dat aangeeft dat de sleutel aan je account is toegevoegd:

Afbeelding 12 - GitHub-authenticatie instellen (3)

Na het toevoegen van je sleutel kun je repositories clonen, pullen en pushen met SSH-URL’s in plaats van HTTPS-URL’s. Dit is de opdracht die je gebruikt:

git clone [email protected]:username/repository.gitMogelijk gemaakt door

Afbeelding 13 - Een repo clonen via SSH

Dat is alles. Het proces voor GitLab is heel vergelijkbaar—zoek in je accountinstellingen gewoon naar SSH Keys.

Kortom, SSH gebruiken voor Git-operaties betekent dat je je gebruikersnaam en wachtwoord niet meer hoeft in te voeren telkens wanneer je met de externe repository werkt. Je SSH-sleutel verzorgt automatisch de veilige authenticatie.

Als je met meerdere diensten werkt (zoals zowel GitHub als GitLab), kun je overwegen om aparte sleutels voor elke dienst te maken. Zo beperk je de impact als één sleutel gecompromitteerd raakt.

> Wil je dieper duiken in het beheren van repositories, bekijk dan Intermediate GitHub Concepts.

SSH-sleutels beheren

Als je SSH-sleutels op meerdere systemen en diensten gebruikt, heb je vroeg of laat een manier nodig om ze te beheren.

In deze sectie laat ik je zien wat erbij komt kijken om bestaande sleutels bij te houden, oude of gecompromitteerde sleutels te verwijderen en eventuele problemen op te lossen.

SSH-sleutels bekijken en opvragen

Je kunt al je SSH-sleutels bekijken door de map .ssh in je thuismap te controleren. Deze map bevat zowel je private sleutels als de bijbehorende publieke sleutels.

Voer de volgende opdracht uit om alle bestanden in je SSH-map te tonen:

ls -la ~/.sshMogelijk gemaakt door

Afbeelding 14 - Alle bestanden in de map .ssh

Deze opdracht toont alle bestanden in de map, inclusief verborgen bestanden. Je ziet doorgaans bestanden zoals:

• id_rsa - Je private RSA-sleutel.
• id_rsa.pub - Je publieke RSA-sleutel.
• known_hosts - Een lijst met servers waarmee je verbonden bent geweest.
• authorized_keys - Publieke sleutels die toegang hebben tot deze machine (als die is ingesteld als server).
• config - Je SSH-clientconfiguratie (als je die hebt aangemaakt).

Als je meerdere sleutels hebt gemaakt voor verschillende diensten, zie je extra sleutelpaarbestanden met de namen die je tijdens het aanmaken hebt opgegeven.

Om te bekijken wat een specifieke publieke sleutel bevat, voer je de volgende opdracht uit:

cat ~/.ssh/id_rsa.pubMogelijk gemaakt door

Afbeelding 15 - Inhoud publieke sleutel

Dit toont de volledige publieke sleutel, die begint met ssh-rsa en eindigt met je opmerking (meestal je e-mailadres).

SSH-sleutels verwijderen

Na verloop van tijd moet je mogelijk SSH-sleutels verwijderen om verschillende redenen - misschien stap je over op een sterker sleuteltype, is een apparaat kwijtgeraakt of heb je geen toegang meer nodig tot bepaalde systemen.

Om sleutels van een externe server te verwijderen, moet je het bestand authorized_keys bewerken:

# Maak verbinding met de externe server
ssh username@remote_host

#  Open het bestand authorized_keys:
nano ~/.ssh/authorized_keysMogelijk gemaakt door

Voor GitHub en GitLab is het verwijderen van sleutels zelfs eenvoudiger:

1. Ga naar je accountinstellingen.
2. Navigeer naar de sectie "SSH and GPG keys".
3. Zoek de sleutel die je wilt verwijderen.
4. Klik op het prullenbak-icoon naast die sleutel.

Afbeelding 16 - Verwijderen van sleutel bevestigen op GitHub

En tot slot, om sleutels van je lokale machine te verwijderen, verwijder je simpelweg de bestanden:

rm ~/.ssh/id_rsa ~/.ssh/id_rsa.pubMogelijk gemaakt door

Vervang id_rsa door de naam van de sleutel die je wilt verwijderen.

Als je een externe host uit je bestand known_hosts moet verwijderen (doorgaans nadat een server is geherconfigureerd), voer dan deze opdracht uit:

ssh-keygen -R hostnameMogelijk gemaakt door

Dit verwijdert het vermelde hostrecord uit je bestand known_hosts, wat handig is wanneer je de foutmelding "host key verification failed" krijgt.

Veelvoorkomende SSH-sleutelproblemen oplossen

Authenticatie met SSH-sleutels kan soms om allerlei redenen mislukken. In deze sectie laat ik je oplossingen zien voor veelvoorkomende problemen.

• Rechtenproblemen. SSH is streng wat bestandsrechten betreft om veiligheidsredenen. Als je sleutels onjuiste rechten hebben, mislukt de authenticatie. Los dit op met:

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_rsa
chmod 644 ~/.ssh/id_rsa.pub
chmod 600 ~/.ssh/authorized_keysMogelijk gemaakt door

• Passphrase-problemen. Als je je passphrase bent vergeten, is er helaas geen manier om die te herstellen. Je moet het volgende doen:
• Genereer een nieuw sleutelpaar.
• Voeg de nieuwe publieke sleutel toe aan je externe systemen.
• Verwijder het oude sleutelpaar.

• Connection refused. Als je de fout "Connection refused" krijgt, kan dat veel oorzaken hebben. Neem deze stappen om het op te lossen:
• Controleer of de server draait en bereikbaar is.
• Controleer of de SSH-service draait op de server.
• Bevestig dat je de juiste poort gebruikt (standaard 22).

• Authenticatiefouten. Krijg je "Permission denied (publickey)"-fouten, doe dan het volgende om het op te lossen:
• Zorg dat je publieke sleutel correct is toegevoegd aan het bestand authorized_keys op de server.
• Controleer of de server publieke-sleutelauthenticatie toestaat.
• Verifieer dat je de juiste gebruikersnaam en hostnaam gebruikt.
• Zorg dat je de juiste private sleutel gebruikt.

• Agent-problemen. Deze kunnen optreden als de SSH-agent niet werkt. Doe dit:
• Controleer of de agent draait met ssh-add -l.
• Start hem indien nodig met eval "$(ssh-agent -s)".
• Voeg je sleutel toe met ssh-add ~/.ssh/id_rsa.

Tot slot bekijken we enkele best practices voor het beheer van SSH-sleutels.

Best practices voor SSH-sleutelbeheer

Authenticatie met SSH is geweldig om je systemen te beschermen tegen ongewenste toegang, maar eerlijk is eerlijk - soms is het wat gedoe. De tips hieronder helpen je de balans te vinden tussen sterke beveiliging en dagelijks gemak.

Sterke passphrases gebruiken voor SSH-sleutels

De passphrase van je private sleutel is de laatste verdedigingslinie als iemand je sleutelbestand in handen krijgt. Kies altijd een sterke en unieke passphrase die moeilijk te raden is maar voor jou goed te onthouden.

Een goede passphrase heeft deze kenmerken:

• Minstens 12-15 tekens lang.
• Een mix van hoofdletters, kleine letters, cijfers en speciale tekens.
• Vermijdt veelvoorkomende patronen of woordenboekwoorden.
• Wordt niet hergebruikt van andere diensten.

Voor sleutels die toegang geven tot kritieke systemen of productieomgevingen is een sterke passphrase absoluut essentieel. Het kleine ongemak weegt ruimschoots op tegen de veiligheidsrisico’s.

Met de SSH-agent hoef je je passphrase slechts één keer per sessie in te voeren. Daardoor zijn sterke passphrases prima in het dagelijks gebruik. Overweeg een wachtwoordmanager om complexe passphrases veilig op te slaan.

Verschillende sleutels voor verschillende systemen

Maak altijd aparte sleutelparen voor verschillende diensten of beveiligingsniveaus in plaats van één sleutel overal te gebruiken. Deze compartimentering beperkt je blootstelling als één sleutel wordt gecompromitteerd.

Je kunt bijvoorbeeld aanmaken:

• Een werksleutel voor de servers van je bedrijf.
• Een persoonlijke sleutel voor je eigen projecten.
• Een aparte sleutel voor GitHub of GitLab.
• Een hoogbeveiligde sleutel voor productieomgevingen.

Wederom: een klein ongemak, maar de extra moeite waard.

Wanneer je meerdere sleutels maakt, gebruik dan beschrijvende bestandsnamen die hun doel aangeven:

ssh-keygen -t rsa -b 4096 -f ~/.ssh/github_rsa -C "github access"Mogelijk gemaakt door

Om een specifieke sleutel te gebruiken bij het verbinden, kun je handig een configuratiebestand instellen:

# ~/.ssh/config
Host github.com
    IdentityFile ~/.ssh/github_rsa

Host companyserver
    HostName 255.255.255.255
    User ubuntu
    IdentityFile ~/.ssh/company_server_rsaMogelijk gemaakt door

Met deze aanpak hoef je bij een gecompromitteerde sleutel alleen die ene sleutel te vervangen in plaats van al je systemen bij te werken.

SSH-sleutels regelmatig roteren

Je SSH-sleutels periodiek vervangen verkleint de kans op onopgemerkte compromittering en volgt beveiligingsbest practices. 

Hoe vaak je dit doet hangt af van de gevoeligheid:

• Persoonlijke projecten: elke 1-2 jaar.
• Zakelijke systemen: elke 6-12 maanden.
• Omgevingen met hoge beveiliging: elke 3-6 maanden.
• Onmiddellijk na vertrek van teamleden of verdachte activiteit.

Het roteren van SSH-sleutels houdt in dat je nieuwe sleutelparen maakt, de nieuwe publieke sleutels aan je servers toevoegt, controleert of de nieuwe sleutels werken, de oude publieke sleutels van servers verwijdert en de oude private sleutels van je lokale machine wist.

Met andere woorden: het kost wat tijd, dus plan het in je schema.

Het is ook verstandig om bij te houden welke sleutels toegang hebben tot welke systemen. Voor organisaties loont het om geautomatiseerde sleutelbeheertools te gebruiken die rotatie systematisch afhandelen.

Authenticatie met SSH-sleutels afdwingen

De sterkste beveiligingsmaatregel die je kunt nemen is wachtwoordauthenticatie op je servers volledig uitschakelen en SSH-sleutels voor alle verbindingen verplichten.

Volg deze stappen om sleutelgebaseerde authenticatie af te dwingen:

# Bewerk je SSH-serverconfiguratie
sudo nano /etc/ssh/sshd_config

# Stel deze kritieke beveiligingsopties in
PasswordAuthentication no
ChallengeResponseAuthentication no
UsePAM no

# Herstart de SSH-service
sudo systemctl restart sshdMogelijk gemaakt door

Met deze configuratie voorkom je brute-force wachtwoordaanvallen volledig. 

Maar voordat je deze wijzigingen doorvoert, zorg dat authenticatie met SSH-sleutels goed werkt om te voorkomen dat je jezelf buitensluit. Het gebeurt.

Samenvatting van SSH-sleutels

Kortom, SSH-sleutels veranderen de manier waarop je verbinding maakt met externe systemen. Overschakelen van wachtwoorden naar sleutelgebaseerde authenticatie verbetert je dagelijkse workflow met zowel veiligheid als gemak.

Een ander voordeel is dat het proces niet ingewikkeld is. Je moet de sleutels genereren, ze toevoegen aan de servers die je gebruikt en verbinden zonder wachtwoorden te typen. Dat is het! In vergelijking met traditionele wachtwoordauthenticatie maken SSH-sleutels je verbindingen sneller en betrouwbaarder, en blokkeren ze ook veelvoorkomende aanvalsmethoden zoals wachtwoordraden.

Onthoud dat je private sleutel bescherming nodig heeft. Gebruik een sterke passphrase, houd je sleutel veilig en volg de best practices in dit artikel, vooral die over het compartimenteren van SSH-sleutels. 

Wil je meer leren over SSH-sleutels en werken met de commandline in het algemeen? Deze DataCamp-cursussen zijn een uitstekend vervolg:

• Introduction to Shell
• Introduction to Bash Scripting
• Bash & zsh Shell Terminal Basics Cheat Sheet