GitHub + SSH + Mac : le guide express

🤔 Pourquoi Git te demande ton mot de passe à chaque fois ?

C’est souvent parce que le remote de ton dépôt a été configuré en HTTPS (qui est un protocole de communication HTTP sécurisé avec TLS (Transport Layer Security)).

Et dans ce mode, Git n’a aucun moyen de mémoriser ton mot de passe ou ton token GitHub. Il se connecte comme un simple navigateur web qui doit s'authentifier à chaque fois. Et c'est pour cette raison qu'il te redemande ton user et mot de passe à chaque git push.

Pour vérifier que le remote est configuré en HTTPS, la manip' est simple :

BASH
git remote -v

Si tu vois https:// au lieu de git@, c'est que le remote est configuré en HTTPS. Et bonne nouvelle, ce guide est fait pour toi !

BASH
# Exemple de remote configuré en HTTPS
origin	https://github.com/ton-nom-github/ton-projet.git (fetch)
origin	https://github.com/ton-nom-github/ton-projet.git (push)

# Exemple de remote configuré en SSH
origin	[email protected]:ton-nom-github/ton-projet.git (fetch)
origin	[email protected]:ton-nom-github/ton-projet.git (push)

🚀 SSH : la solution simple

Tu l'as compris, SSH est la clé (littéralement) pour en finir avec les mots de passe.

Petit rappel rapide sur le fonctionnement de SSH:

• ton Mac stocke ta clé privée (cachée, à ne jamais partager 🚫),
• GitHub connaît ta clé publique (que tu peux diffuser sans risque ✅).

Grâce à cette paire de clés, ton Mac peut prouver à GitHub que c’est bien toi, sans jamais avoir à retaper ton mot de passe.

Et le secret, c’est l’agent SSH (via la commande ssh-add) qui tourne en arrière-plan : il garde ta clé privée en mémoire et répond à ta place.

Au bilan:

• tu fais la manip 1 fois sur ta machine
• et tu n'as plus jamais à t'en soucier

Et c'est pour ça que j'ai fait ce guide, car bonne chance pour te souvenir dans 3 ans de toutes ces commandes 🤯 !

📚 Pour ceux qui aiment lire la doc officielle

Avant de plonger dans les commandes, voici les ressources officielles que tu peux garder sous le coude :

• GitHub Docs – Utiliser SSH
• OpenSSH – Générer et utiliser des clés SSH

Ces pages sont parfois un peu indigestes 😅 ...
... c’est exactement pour ça que j’ai écrit ce guide express : pour te donner la version simple, claire et pratique.

⚡️ Résumé express

Voici les grandes étapes. N'oublie pas de réajuster les commandes en fonction de ton email et de ton nom de dépôt.

Étape	Commande
1️⃣ Créer une clé SSH sur ton Mac	ssh-keygen -t ed25519 -C "[email protected]" -f ~/.ssh/id_ed25519
2️⃣ Configurer ton Mac pour utiliser la clé SSH	vim ~/.ssh/config + le contenu du fichier est dispo en section 2
3️⃣ Lancer l’agent SSH	eval "$(ssh-agent -s)"
3️⃣ Ajouter la clé au trousseau	ssh-add --apple-use-keychain ~/.ssh/id_ed25519
4️⃣ Corriger l'URL du remote	git remote set-url origin [email protected]:ton-nom-github/ton-projet.git
5️⃣ Mettre la clé publique sur Github	pbcopy < ~/.ssh/id_ed25519.pub
6️⃣ Et voilà !	git push

🔑 Étape 1 - Créer une clé SSH sur ton Mac

Par convention, les clés SSH sont stockées dans le dossier ~/.ssh. Dans cet exemple:

• le fichier id_ed25519 est la clé privée
• le fichier id_ed25519.pub est la clé publique

BASH
❯ ls -lha ~/.ssh
total 56
drwxr-xr-x@  10 your-name  staff   320B 23 jan  2025 .
drwxr-x---+ 124 your-name  staff   3,9K 11 sep 14:42 ..
-rw-------@   1 your-name  staff   2,1K 22 mai  2023 known_hosts
-rw-------@   1 your-name  staff   464B 22 mai  2023 id_ed25519
-rw-r--r--@   1 your-name  staff   108B 22 mai  2023 id_ed25519.pub

Si tu as déjà une clé SSH, tu peux la réutiliser ou la supprimer, c'est toi qui vois. Tu peux avoir autant de clés SSH que tu veux.

Pour en créer une nouvelle, tape la commande suivante et renseigne une passphrase (un mot de passe un peu long) pour protéger ta clé privée:

BASH
ssh-keygen -t ed25519 -C "[email protected]" -f ~/.ssh/id_ed25519

• ssh-keygen : la commande pour générer une clé SSH
• -t ed25519 : le type de clé SSH à générer (ED25519 est le plus rapide et recommandé)
• -C "[email protected]" : l'email associé à la clé SSH
• -f ~/.ssh/id_ed25519 : le nom du fichier de la clé SSH (choisis le nom que tu veux, mais pour s'y retrouver j'ai l'habitude de mettre au moins id_ed25519 en préfixe)

Une fois terminé, tu devrais obtenir un résultat du genre :

BASH
Generating public/private ed25519 key pair.
Enter passphrase for "/Users/olivier/.ssh/id_ed25519" (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /Users/olivier/.ssh/id_ed25519
Your public key has been saved in /Users/olivier/.ssh/id_ed25519.pub
The key fingerprint is:
SHA256: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa [email protected]
The key's randomart image is:
+--[ED25519 256]--+
|      ooo..oo-.+.|
|       o= oo= *o+|
|      o O =...X.*|
|     - O oo oo +.|
|      DE o ++.o .|
|     . ..o  -- .E|
|       .. .o ..  |
|            ..  .|
|                 |
+----[SHA256]-----+

🛠️ Étape 2 - Configurer ton Mac pour utiliser la clé SSH

Maintenant que la clé est créé, tu as besoin de configurer ton Mac pour qu'il sache quelle clé SSH utiliser pour se connecter à GitHub.

Pour cela, crée (ou modifie) le fichier de configuration SSH :

BASH
vim ~/.ssh/config

Ce fichier de config doit contenir ces infos pour savoir:

• quel user (User)
• et que clé SSH (IdentityFile)
• doivent être utilisés pour se connecter à Github (Host):

BASH
Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_ed25519
  AddKeysToAgent yes
  UseKeychain yes

🤖 Étape 3 - Lancer l’agent SSH

On y est presque avec la partie MacBook. 🎉

L’agent SSH est ton majordome : il s’occupe de tes clés et les garde en mémoire pour toi. Sans lui, tu devrais retaper ta clé privée à chaque commande (pas fun).

Pour le démarrer, lance simplement :

BASH
eval "$(ssh-agent -s)"

Si tout se passe bien, ton terminal répond avec un message du style :

BASH
Agent pid 12345

Ajoute ta clé au trousseau macOS :

BASH
# macOS
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

Et pour Linux :

BASH
# Linux
ssh-add ~/.ssh/id_ed25519

Et voilà, tu as l’agent qui tourne en arrière-plan !

Et si tu veux vérifier quelles clés sont actuellement chargées:

BASH
❯ ssh-add -l
256 SHA256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa [email protected] (ED25519)

📦 Étape 4 - Corriger l'URL du remote

Pour Git, un remote est l'alias de ton dépôt distant. Par exemple, origin est l'alias de ton projet hébergé sur github.com et accessible:

• soit via l'url https://github.com/ton-nom-github/ton-projet.git ,
• soit via ssh [email protected]:ton-nom-github/ton-projet.git.

C'est ce que t'indique cette commande:

BASH
❯ git remote -v

# Exemple de remote configuré en HTTPS
origin	https://github.com/ton-nom-github/ton-projet.git (fetch)
origin	https://github.com/ton-nom-github/ton-projet.git (push)

# Exemple de remote configuré en SSH
origin	[email protected]:ton-nom-github/ton-projet.git (fetch)
origin	[email protected]:ton-nom-github/ton-projet.git (push)

Si sur ta machine le remote est configuré en HTTPS, git ira chercher ton projet en HTTPS et te demandera ton mot de passe à chaque fois.

Si par contre le remote est configuré en SSH, git ira chercher ton projet en SSH et ne te demandera pas ton mot de passe.

Heureusement, c'est très simple à corriger:

BASH
git remote set-url origin [email protected]:ton-nom-github/ton-projet.git

Sur Github, va sur la page de ton projet et clique sur le bouton vert Code qui te sert à cloner un projet. Une modale s'ouvre, clique sur l'onglet SSH et copie l'URL (du type [email protected]:ton-nom-github/ton-projet.git).

🌐 Étape 5 - Mettre la clé publique sur Github

Ta clé privée est configurée sur ta machine. A présent il est temps de mettre ta clé publique sur Github.

BASH
# Copie ta clé publique dans le presse-papier
pbcopy < ~/.ssh/id_ed25519.pub

Sur Github, clique sur ton avatar en haut à droite, puis Settings > SSH and GPG keys > New SSH key ou alors clique sur ce lien Github

• Title => donne un nom explicite (par exemple Macbook Pro Travail)
• Key type => Authentication Key
• Key => colle ta clé publique
• Puis valide avec Add SSH key

🎉 Étape 6 - Et voilà !

Reste plus qu'à tester, mais normalement tout est carré !

BASH
# Magie magie, plus besoin de mot de passe !
git push

🚨🚨🚨 Mega Bonus : un script d’install 🚨🚨🚨

Dans une ancienne vie de Lead Dev, j'ai installé un bon nombre de machines. Et pour aller plus vite, j'ai créé un script que je vous offre en espérant que ça vous évitera quelques heures de galère.

Disclaimer: j'utilisais ce script sur des macbook formattés. Sur le tien, vérifie bien avant de ne pas écraser un fichier config déjà existant ou une clé ssh qui s'appellerait déjà id_ed25519...

Copie-colle ça dans un fichier formationgit-ssh.sh :

BASH
# Crée le fichier formationgit-ssh.sh
touch formationgit-ssh.sh

BASH
#!/bin/sh

SSH_KEY_NAME=id_ed25519

while read -p "Email: " EMAIL; do
	if [ -z ${EMAIL} ]; then
		continue;
	else
		break;
	fi
done

# Create SSH Key
ssh-keygen -f ~/.ssh/$SSH_KEY_NAME -t ed25519 -C "${EMAIL}"

# Launch ssh-agent in background
eval "$(ssh-agent -s)"

if [ -f ~/.ssh/config ]; then
  echo "⚠️ Le fichier ~/.ssh/config existe déjà, je ne l'écrase pas."
  exit 1
fi

# Load keys and passphrase in ssh-agent
cat <<EOT >> ~/.ssh/config

Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/${SSH_KEY_NAME}
  AddKeysToAgent yes
  UseKeychain yes
EOT

# Save key and passphrase in ssh-agent
ssh-add --apple-use-keychain ~/.ssh/$SSH_KEY_NAME

# Copy the ssh public key in clipboard
pbcopy < ~/.ssh/$SSH_KEY_NAME.pub

echo "✅ Ta clé ssh a été créée sous le nom $SSH_KEY_NAME \n"
echo "🥳 Elle a été copiée dans ton clipboard, il te reste à la coller dans ton github https://github.com/settings/keys \n"

N'oublie pas de rendre le fichier executable:

BASH
chmod +x formationgit-ssh.sh

Tu peux maintenant l'exécuter:

BASH
./formationgit-ssh.sh

❓ FAQ Express

Je peux utiliser RSA au lieu de ED25519 ?

Oui, mais ED25519 est plus rapide et recommandé. RSA c’est old-school.

Je dois refaire ça pour chaque repo ?

Non. Une fois ta clé configurée et ajoutée à GitHub, tu peux l’utiliser partout.

Je peux avoir plusieurs clés GitHub ?

Oui, mais c’est du sport (il faut jouer avec plusieurs Host dans ~/.ssh/config).

Et si je perds ma clé privée ?

Tu régénères une nouvelle paire et tu la réajoutes sur GitHub.