Configurer Git : git config, nom, e-mail et clés SSH

Configuration minimale de Git en une minute

Juste après l'installation, lancez quatre commandes. Sans les deux premières, Git refusera de créer un commit ; les autres vous épargneront les désagréments les plus courants.

git config --global user.name "Claire Martin"
git config --global user.email "claire@example.com"
git config --global init.defaultBranch main
git config --global core.editor "code --wait"

Vérifiez le résultat :

$ git config --global --list
user.name=Claire Martin
user.email=claire@example.com
init.defaultbranch=main
core.editor=code --wait

Voyons maintenant ce que fait chaque réglage, où Git les stocke et comment mettre en place la connexion à GitHub par SSH.

Comment fonctionne git config : trois niveaux de réglages

La commande git config lit et écrit les paramètres dans l'un des trois fichiers. Un niveau plus restreint l'emporte sur un niveau plus large.

Presque tous les réglages personnels se font au niveau global, et les exceptions au niveau local. Par exemple, l'e-mail professionnel pour les projets de l'entreprise se définit dans le dépôt concerné, sans l'option --global.

Commandes git config utiles

git config user.email                    # afficher la valeur actuelle
git config --list --show-origin          # tous les réglages et le fichier d'origine de chacun
git config --global --edit               # ouvrir ~/.gitconfig dans l'éditeur
git config --global --unset core.editor  # supprimer un paramètre

L'option --show-origin est votre meilleure alliée pour déboguer : elle explique pourquoi vous avez « le mauvais » e-mail en indiquant le fichier d'où vient la valeur.

Nom et e-mail : bien plus qu'une formalité

Chaque commit conserve pour toujours le nom et l'e-mail de son auteur. Ce n'est ni un identifiant ni un mot de passe — Git ne les vérifie pas. Mais GitHub et GitLab s'appuient sur l'e-mail pour relier les commits à votre compte : si l'adresse ne correspond à aucun e-mail confirmé de votre profil, les commits ne compteront pas dans le graphe d'activité et s'afficheront sans avatar.

Impossible de changer le nom ou l'e-mail après coup sans réécrire l'historique : vérifiez donc vos réglages avant le premier commit.

Masquer votre véritable adresse e-mail

Si le dépôt est public, votre e-mail est visible par quiconque consulte l'historique. GitHub propose une adresse technique du type ID+username@users.noreply.github.com (dans les réglages Emails). Indiquez-la à Git :

git config --global user.email "12345678+claire@users.noreply.github.com"

Un e-mail différent pour le travail et les projets personnels

Pour ne pas configurer chaque dépôt professionnel à la main, utilisez l'inclusion conditionnelle de configuration. Dans ~/.gitconfig :

[includeIf "gitdir:~/work/"]
    path = ~/.gitconfig-work

Et dans ~/.gitconfig-work :

[user]
    email = claire@company.com

Désormais, tous les dépôts situés dans ~/work/ utilisent automatiquement l'e-mail professionnel. La barre oblique finale du chemin est obligatoire.

Autres réglages Git utiles

L'éditeur

Git ouvre un éditeur pour les messages de commit, le rebase interactif et les fusions. Par défaut, c'est souvent Vim. Quelques options :

git config --global core.editor "code --wait"   # VS Code
git config --global core.editor "nano"          # Nano
git config --global core.editor "subl -n -w"    # Sublime Text

La branche par défaut

init.defaultBranch main définit le nom de la première branche des nouveaux dépôts (disponible depuis Git 2.28). Sans ce réglage, Git crée master et affiche un conseil pour la renommer.

Les fins de ligne

git config --global core.autocrlf true    # Windows
git config --global core.autocrlf input   # macOS et Linux

Ainsi, le dépôt stocke toujours des fins de ligne LF, et l'équipe ne voit pas apparaître de « modifications » sur toutes les lignes d'un fichier.

Le comportement de git pull

Si vous ne définissez pas de stratégie, les versions récentes de Git vous demandent de la choisir explicitement quand les branches ont divergé. Choisissez-en une :

git config --global pull.rebase false   # fusion (merge), comportement par défaut
git config --global pull.rebase true    # rebase, historique linéaire
git config --global pull.ff only        # fast-forward uniquement, sinon erreur

Caractères accentués dans les noms de fichiers et couleurs

git config --global core.quotepath false
git config --global color.ui auto

Les alias

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.lg "log --oneline --graph --decorate --all"
git config --global alias.last "log -1 HEAD"

Désormais, git lg dessine le graphe des branches et git last affiche le dernier commit.

À quoi ressemble ~/.gitconfig une fois configuré

[user]
    name = Claire Martin
    email = claire@example.com
[init]
    defaultBranch = main
[core]
    editor = code --wait
    autocrlf = input
    quotepath = false
[pull]
    rebase = false
[alias]
    st = status
    lg = log --oneline --graph --decorate --all

C'est un simple fichier texte : on peut le modifier à la main et le transférer d'un ordinateur à l'autre.

Git login : comment se connecter à GitHub

Il n'existe pas de commande git login dans Git — un piège fréquent pour les débutants. Git ne garde pas de « compte » : l'authentification a lieu lors des échanges avec le serveur (clone, push, fetch) via l'un des deux protocoles.

Connexion en HTTPS

Avec Git for Windows et les builds macOS dotées de Git Credential Manager, le premier git push ouvre une fenêtre de navigateur pour se connecter à GitHub, et les identifiants sont enregistrés dans le trousseau du système. Autre option : l'outil officiel GitHub CLI, dont la commande gh auth login vous guide dans l'authentification et configure Git. Si vous faites tout à la main, créez un Personal access token dans les réglages GitHub (Developer settings) et saisissez-le à la place du mot de passe.

SSH pour Git : configuration pas à pas

Une clé SSH est une paire de fichiers : la clé privée reste chez vous, la clé publique est confiée à GitHub. Le serveur vérifie que vous possédez la partie privée, et on ne vous demande plus jamais de mot de passe.

Étape 1. Vérifiez si vous avez déjà une clé

ls -la ~/.ssh

Si vous y trouvez déjà id_ed25519 et id_ed25519.pub, passez à l'étape 3.

Étape 2. Créez une clé

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

Appuyez sur Entrée pour enregistrer la clé à l'emplacement par défaut, puis définissez une phrase de passe — elle protégera la clé si votre ordinateur portable est volé. Ed25519 est l'algorithme moderne recommandé. Si un ancien système ne le prend pas en charge, utilisez ssh-keygen -t rsa -b 4096 -C "claire@example.com".

Étape 3. Ajoutez la clé à ssh-agent

L'agent garde la clé déchiffrée en mémoire pour vous éviter de saisir la phrase de passe à chaque push.

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Sur macOS, ajoutez ces lignes dans ~/.ssh/config pour que la phrase de passe soit conservée dans le trousseau :

Host github.com
    AddKeysToAgent yes
    UseKeychain yes
    IdentityFile ~/.ssh/id_ed25519

puis lancez ssh-add --apple-use-keychain ~/.ssh/id_ed25519.

Étape 4. Ajoutez la clé publique sur GitHub

cat ~/.ssh/id_ed25519.pub

Copiez toute la ligne, à partir de ssh-ed25519. Sur GitHub, ouvrez Settings → SSH and GPG keys → New SSH key, collez la clé et donnez-lui un nom explicite, par exemple « Portable 2026 ». N'envoyez et ne publiez jamais le fichier sans .pub — c'est la clé privée.

Étape 5. Testez la connexion

$ ssh -T git@github.com
Hi claire! You've successfully authenticated, but GitHub does not provide shell access.

À la première connexion, SSH demande s'il faut faire confiance à l'hôte — comparez l'empreinte avec celles publiées dans la documentation GitHub et répondez yes.

Étape 6. Passez le dépôt en SSH

Si le dépôt a été cloné en HTTPS, changez l'adresse du remote :

git remote -v
git remote set-url origin git@github.com:claire/my-project.git
git push

Plusieurs comptes GitHub sur un même ordinateur

Une clé SSH ne peut être liée qu'à un seul compte GitHub. Pour un compte professionnel et un compte personnel, créez deux clés et des alias d'hôte dans ~/.ssh/config :

Host github-work
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_ed25519_work
    IdentitiesOnly yes

Clonez les dépôts professionnels via l'alias : git clone git@github-work:company/app.git. Combiné à includeIf pour l'e-mail, vous obtenez des environnements professionnel et personnel totalement séparés.

Erreurs fréquentes lors de la configuration

« Please tell me who you are »

user.name et user.email ne sont pas définis. Lancez les commandes du début de l'article et refaites le commit.

« Permission denied (publickey) »

GitHub n'a pas trouvé de clé valide. Vérifiez que la clé est chargée dans l'agent (ssh-add -l) et que sa partie publique est ajoutée au compte ; ssh -vT git@github.com donnera les détails.

« Support for password authentication was removed »

Vous avez saisi le mot de passe de votre compte en HTTPS. Utilisez un jeton, la connexion via Credential Manager, ou passez en SSH.

Commits sans avatar sur GitHub

L'e-mail de git config user.email n'est pas ajouté à votre profil GitHub. Ajoutez-le dans Settings → Emails — les anciens commits seront rattachés automatiquement.

Le port 22 est bloqué sur le réseau

GitHub accepte aussi SSH sur le port 443. Dans ~/.ssh/config, indiquez Host github.com, Hostname ssh.github.com, Port 443.

Ordre de configuration sur un nouvel ordinateur

1. Installez Git et vérifiez avec git --version.
2. Définissez user.name, user.email, init.defaultBranch et l'éditeur.
3. Transférez ou créez un ~/.gitconfig avec vos alias et votre stratégie de pull.
4. Créez une nouvelle clé SSH (ne copiez pas une ancienne clé privée d'une machine à l'autre sans nécessité) et ajoutez-la sur GitHub.
5. Testez l'accès avec ssh -T git@github.com et clonez votre dépôt de travail via son adresse SSH.

Une clé par appareil présente un autre avantage : si vous perdez votre portable, il suffit de supprimer une seule clé sur GitHub, sans toucher à l'accès depuis vos autres machines.

En résumé

Configurer Git revient à trois étapes : définir le nom et l'e-mail avec git config --global, choisir l'éditeur, la branche par défaut et la stratégie de pull, puis mettre en place la connexion à GitHub — le plus simple et le plus fiable étant la clé SSH. Rappelez-vous qu'il n'existe pas de commande git login : l'authentification se fait lors des échanges avec le serveur. La configuration et l'accès SSH sont détaillés en pratique dans le cours Git.