1. Installation et configuration initiale

1.1 Installation

Debian / Ubuntu

sudo apt update
sudo apt install git -y

# Verifier la version
git --version

CentOS / RHEL / AlmaLinux

sudo dnf install git -y

# Ou sur CentOS 7
sudo yum install git -y

git --version

Windows

Telecharger l'installateur depuis https://git-scm.com/download/win et suivre l'assistant. Git Bash sera installe en meme temps, fournissant un terminal Unix-like sous Windows.

Avec winget (Windows 10/11) :

winget install Git.Git

1.2 Configuration globale

Ces parametres s'appliquent a tous les depots de l'utilisateur courant. Le fichier de configuration se trouve dans ~/.gitconfig (Linux/Mac) ou C:\Users\USERNAME\.gitconfig (Windows).

# Identite (obligatoire pour commiter)
git config --global user.name "Prenom Nom"
git config --global user.email "prenom.nom@exemple.com"

# Editeur par defaut
git config --global core.editor "vim"
# Ou pour nano :
git config --global core.editor "nano"
# Ou pour VS Code :
git config --global core.editor "code --wait"

# Branche par defaut lors de git init
git config --global init.defaultBranch main

# Activer la coloration syntaxique
git config --global color.ui auto

# Fin de ligne (important en environnement mixte Windows/Linux)
# Sur Windows :
git config --global core.autocrlf true
# Sur Linux/Mac :
git config --global core.autocrlf input

1.3 Configuration par depot

Pour surcharger la config globale dans un depot specifique (sans --global) :

cd /chemin/vers/mon-depot
git config user.name "Autre Nom"
git config user.email "autre@exemple.com"

1.4 Verifier la configuration

# Lister toute la configuration active
git config --list

# Voir une valeur specifique
git config user.name
git config user.email

# Voir d'ou vient chaque parametre (system, global, local)
git config --list --show-origin

1.5 Configurer l'authentification SSH

# Generer une cle SSH
ssh-keygen -t ed25519 -C "prenom.nom@exemple.com"

# Demarrer l'agent SSH
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

# Afficher la cle publique (a copier dans GitLab/GitHub/Gitea)
cat ~/.ssh/id_ed25519.pub

# Tester la connexion
ssh -T git@github.com
ssh -T git@gitlab.com

Host github.com
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_ed25519_github

Host gitlab.interne.local
    HostName gitlab.interne.local
    User git
    IdentityFile ~/.ssh/id_ed25519_gitlab

1.6 Alias utiles

# Raccourcis pour les commandes frequentes
git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.lg "log --oneline --graph --all --decorate"
git config --global alias.last "log -1 HEAD"
git config --global alias.unstage "reset HEAD --"

2. Commandes de base

2.1 Initialiser un depot

# Creer un nouveau depot local
mkdir mon-projet
cd mon-projet
git init

# Le dossier .git est cree, contenant tout l'historique
ls -la .git/

2.2 Cloner un depot existant

# Cloner via SSH (recommande)
git clone git@gitlab.exemple.com:equipe/projet.git

# Cloner via HTTPS
git clone https://gitlab.exemple.com/equipe/projet.git

# Cloner dans un dossier specifique
git clone git@gitlab.exemple.com:equipe/projet.git mon-dossier

# Cloner une branche specifique
git clone -b develop git@gitlab.exemple.com:equipe/projet.git

# Clone superficiel (uniquement le dernier commit - utile pour les gros depots)
git clone --depth 1 git@gitlab.exemple.com:equipe/projet.git

2.3 Le cycle de travail Git

Git gere trois zones principales :

• Working directory : les fichiers sur le disque, tels que modifies
• Staging area (index) : les modifications preparees pour le prochain commit
• Repository (.git) : l'historique complet des commits

# Flux de travail classique :
# 1. Modifier des fichiers
# 2. Ajouter au staging (git add)
# 3. Commiter (git commit)

# Verifier l'etat des fichiers
git status

# Version courte du status
git status -s

2.4 Ajouter des fichiers au staging

# Ajouter un fichier specifique
git add fichier.txt

# Ajouter plusieurs fichiers
git add fichier1.txt fichier2.txt dossier/

# Ajouter tous les fichiers modifies et nouveaux
git add .

# Ajouter tous les fichiers (y compris les suppressions)
git add -A

# Ajouter de maniere interactive (par morceaux)
git add -p fichier.txt

2.5 Commiter

# Commit avec message
git commit -m "Ajouter la page de connexion"

# Commit avec message multi-lignes
git commit -m "Titre du commit" -m "Description detaillee du changement."

# Ajouter et commiter en une seule commande (fichiers deja suivis uniquement)
git commit -am "Corriger le bug d'affichage"

# Modifier le dernier commit (message ou contenu)
git commit --amend -m "Nouveau message"

# Ajouter un fichier oublie au dernier commit
git add fichier-oublie.txt
git commit --amend --no-edit

feat: ajouter l'export CSV des rapports
fix: corriger le calcul de TVA sur les factures
docs: mettre a jour le README avec les prereqs
refactor: simplifier la logique de validation
chore: mettre a jour les dependances npm

2.6 Voir les differences

# Differences entre working directory et staging
git diff

# Differences entre staging et dernier commit
git diff --staged
# (synonyme)
git diff --cached

# Differences entre deux commits
git diff abc1234 def5678

# Differences sur un fichier specifique
git diff fichier.txt

# Resume statistique des changements
git diff --stat

2.7 Consulter l'historique

# Historique complet
git log

# Historique compact (une ligne par commit)
git log --oneline

# Historique avec graphe des branches
git log --oneline --graph --all

# Limiter le nombre de commits affiches
git log -5

# Historique d'un fichier specifique
git log -- chemin/vers/fichier.txt

# Historique avec les differences
git log -p

3. Branches

Les branches permettent de travailler sur des fonctionnalites ou correctifs en parallele, sans affecter la branche principale.

3.1 Lister les branches

# Branches locales
git branch

# Branches distantes
git branch -r

# Toutes les branches (locales + distantes)
git branch -a

# Branches avec dernier commit
git branch -v

# Branches deja mergees dans la branche courante
git branch --merged

# Branches pas encore mergees
git branch --no-merged

3.2 Creer une branche

# Creer une branche (sans y basculer)
git branch ma-feature

# Creer et basculer dessus immediatement
git checkout -b ma-feature

# Syntaxe moderne (Git 2.23+)
git switch -c ma-feature

# Creer une branche a partir d'un commit specifique
git branch ma-feature abc1234

# Creer une branche a partir d'une branche distante
git checkout -b ma-feature origin/ma-feature

3.3 Changer de branche

# Syntaxe classique
git checkout ma-feature

# Syntaxe moderne (Git 2.23+)
git switch ma-feature

# Revenir a la branche precedente
git checkout -
git switch -

3.4 Fusionner une branche (merge)

# Se placer sur la branche de destination
git checkout main

# Fusionner la branche feature
git merge ma-feature

# Merge sans fast-forward (force la creation d'un commit de merge)
git merge --no-ff ma-feature

# Annuler un merge en cours (en cas de conflit)
git merge --abort

3.5 Supprimer une branche

# Supprimer une branche locale (deja mergee)
git branch -d ma-feature

# Forcer la suppression (meme si non mergee)
git branch -D ma-feature

# Supprimer une branche distante
git push origin --delete ma-feature

# Nettoyer les references locales vers des branches distantes supprimees
git fetch --prune

3.6 Renommer une branche

# Renommer la branche courante
git branch -m nouveau-nom

# Renommer une autre branche
git branch -m ancien-nom nouveau-nom

# Renommer sur le remote (supprimer + push)
git push origin --delete ancien-nom
git push origin nouveau-nom

4. Travail avec les remotes

Un remote est un depot distant (GitLab, GitHub, Gitea, Bitbucket, etc.) avec lequel votre depot local se synchronise.

4.1 Gerer les remotes

# Lister les remotes configures
git remote -v

# Ajouter un remote
git remote add origin git@gitlab.exemple.com:equipe/projet.git

# Ajouter un second remote (ex: miroir)
git remote add backup git@backup.exemple.com:equipe/projet.git

# Modifier l'URL d'un remote
git remote set-url origin git@nouveau-serveur.com:equipe/projet.git

# Supprimer un remote
git remote remove backup

# Renommer un remote
git remote rename origin gitlab

# Voir les details d'un remote
git remote show origin

4.2 Recuperer les modifications distantes (fetch)

# Recuperer les modifications sans les integrer
git fetch origin

# Recuperer depuis tous les remotes
git fetch --all

# Recuperer et nettoyer les branches supprimees
git fetch --prune

4.3 Recuperer et integrer (pull)

# Pull = fetch + merge
git pull origin main

# Pull avec rebase au lieu de merge (historique lineaire)
git pull --rebase origin main

# Configurer le pull en mode rebase par defaut
git config --global pull.rebase true

# Pull de la branche trackee par defaut
git pull

4.4 Envoyer les modifications (push)

# Pousser la branche courante
git push origin main

# Premier push d'une nouvelle branche (definir l'upstream)
git push -u origin ma-feature
# Ensuite, un simple "git push" suffit

# Pousser toutes les branches
git push --all origin

# Pousser les tags
git push --tags

# Forcer le push (ecrase l'historique distant - DANGEREUX)
git push --force origin ma-feature

# Force-with-lease : plus sur, refuse si quelqu'un a pousse entre-temps
git push --force-with-lease origin ma-feature

4.5 Tracking des branches

# Voir quelle branche distante est trackee
git branch -vv

# Configurer le tracking manuellement
git branch --set-upstream-to=origin/ma-feature ma-feature

# Raccourci lors du checkout
git checkout --track origin/ma-feature

5. Merge et rebase

5.1 Git merge

Le merge combine deux branches en creant un commit de fusion. L'historique conserve la trace des deux branches.

# Se placer sur la branche cible
git checkout main

# Merger la feature
git merge feature/login

# Merge sans fast-forward (toujours creer un commit de merge)
git merge --no-ff feature/login

Resoudre les conflits de merge

# En cas de conflit, Git marque les fichiers concernes
# Ouvrir les fichiers et resoudre les marqueurs :
# <<<<<<< HEAD
# (votre version)
# =======
# (version de l'autre branche)
# >>>>>>> feature/login

# Apres resolution manuelle :
git add fichier-resolu.txt
git commit

# Ou utiliser un outil de merge graphique
git mergetool

# Annuler le merge en cours
git merge --abort

5.2 Git rebase

Le rebase re-applique vos commits par-dessus une autre branche. L'historique reste lineaire, sans commit de fusion.

# Se placer sur la branche feature
git checkout feature/login

# Rebaser sur main
git rebase main

# En cas de conflit pendant le rebase :
# 1. Resoudre le conflit dans le fichier
# 2. Ajouter le fichier resolu
git add fichier-resolu.txt
# 3. Continuer le rebase
git rebase --continue

# Annuler le rebase en cours
git rebase --abort

# Sauter un commit problematique
git rebase --skip

5.3 Quand utiliser merge vs rebase ?

5.4 Rebase interactif

Le rebase interactif permet de reorganiser, combiner ou modifier des commits avant de les partager :

# Rebase interactif sur les 3 derniers commits
git rebase -i HEAD~3

# L'editeur s'ouvre avec la liste des commits :
# pick abc1234 Premier commit
# pick def5678 Deuxieme commit
# pick ghi9012 Troisieme commit

# Actions disponibles :
# pick   = garder le commit tel quel
# reword = modifier le message du commit
# edit   = modifier le contenu du commit
# squash = fusionner avec le commit precedent (garder les messages)
# fixup  = fusionner avec le commit precedent (ignorer le message)
# drop   = supprimer le commit

6. Stash

Le stash permet de mettre de cote temporairement des modifications non commitees, pour travailler sur autre chose puis revenir.

6.1 Sauvegarder dans le stash

# Stasher les modifications (fichiers suivis modifies + staging)
git stash

# Stasher avec un message descriptif
git stash push -m "WIP: formulaire de contact"

# Stasher en incluant les fichiers non suivis (nouveaux fichiers)
git stash -u
git stash --include-untracked

# Stasher uniquement les fichiers dans le staging
git stash --staged

6.2 Lister les stashes

# Voir tous les stashes
git stash list

# Resultat typique :
# stash@{0}: On feature/login: WIP: formulaire de contact
# stash@{1}: WIP on main: abc1234 Dernier commit

6.3 Restaurer un stash

# Restaurer le dernier stash et le supprimer de la pile
git stash pop

# Restaurer le dernier stash sans le supprimer
git stash apply

# Restaurer un stash specifique
git stash apply stash@{2}
git stash pop stash@{1}

# Voir le contenu d'un stash avant de l'appliquer
git stash show stash@{0}
git stash show -p stash@{0}    # Avec le diff complet

6.4 Supprimer des stashes

# Supprimer un stash specifique
git stash drop stash@{0}

# Supprimer tous les stashes
git stash clear

6.5 Creer une branche depuis un stash

# Creer une nouvelle branche, y appliquer le stash, et supprimer le stash
git stash branch ma-nouvelle-branche stash@{0}

7. Tags

Les tags servent a marquer des points specifiques de l'historique, typiquement pour les versions de release.

7.1 Tags legers (lightweight)

Un tag leger est simplement un pointeur vers un commit. Pas de metadonnees supplementaires.

# Creer un tag leger sur le commit courant
git tag v1.0.0

# Creer un tag leger sur un commit specifique
git tag v0.9.0 abc1234

7.2 Tags annotes (annotated)

Un tag annote est un objet Git complet : il contient le nom du createur, la date, un message et peut etre signe avec GPG. C'est le type recommande pour les releases.

# Creer un tag annote
git tag -a v1.0.0 -m "Version 1.0.0 - Release initiale"

# Creer un tag annote sur un ancien commit
git tag -a v0.9.0 -m "Version 0.9.0 - Beta" abc1234

# Voir les details d'un tag annote
git show v1.0.0

7.3 Lister et rechercher des tags

# Lister tous les tags
git tag

# Lister avec filtre
git tag -l "v1.*"

# Trier par version (semver)
git tag -l --sort=version:refname "v*"

7.4 Partager les tags avec le remote

# Pousser un tag specifique
git push origin v1.0.0

# Pousser tous les tags
git push origin --tags

# Supprimer un tag local
git tag -d v1.0.0

# Supprimer un tag distant
git push origin --delete v1.0.0

7.5 Checkout sur un tag

# Se positionner sur un tag (mode "detached HEAD")
git checkout v1.0.0

# Creer une branche a partir d'un tag
git checkout -b hotfix/v1.0.1 v1.0.0

8. Git log avance

8.1 Formatage personnalise

# Format compact avec hash court, auteur, date relative et message
git log --pretty=format:"%h %an %ar - %s"

# Format detaille
git log --pretty=format:"%H%n Auteur: %an <%ae>%n Date: %ad%n Message: %s%n"

# Placeholders utiles :
# %H  = hash complet          %h = hash court
# %an = nom de l'auteur       %ae = email de l'auteur
# %ad = date de l'auteur      %ar = date relative
# %cn = nom du commiteur      %ce = email du commiteur
# %s  = sujet (1ere ligne)    %b  = corps du message
# %d  = noms de ref (branches, tags)

8.2 Graphe des branches

# Graphe simple
git log --oneline --graph --all

# Graphe avec decorations (branches et tags)
git log --oneline --graph --all --decorate

# Graphe avec dates
git log --graph --all --format="%h %d %s (%ar)"

8.3 Rechercher dans l'historique

# Commits d'un auteur specifique
git log --author="Prenom"

# Commits contenant un mot dans le message
git log --grep="correction"
git log --grep="fix" --grep="bug" --all-match

# Commits modifiant une chaine dans le code (pickaxe)
git log -S "nomDeFonction"

# Commits modifiant un pattern regex dans le code
git log -G "function\s+login"

# Historique d'un fichier specifique
git log --follow -- chemin/vers/fichier.txt

# Commits entre deux dates
git log --after="2024-01-01" --before="2024-06-30"

# Commits entre deux references
git log main..feature/login
git log v1.0.0..v2.0.0

8.4 Statistiques

# Resume des fichiers modifies par commit
git log --stat

# Nombre de lignes ajoutees/supprimees par commit
git log --numstat

# Resume condense
git shortlog -sn

# Qui a modifie chaque ligne d'un fichier (blame)
git blame fichier.txt

# Blame sur une plage de lignes
git blame -L 10,20 fichier.txt

git config --global alias.lg "log --graph --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(auto)%d%C(reset)' --all"

9. Annuler des changements

9.1 Annuler des modifications dans le working directory

# Restaurer un fichier a son etat du dernier commit (Git 2.23+)
git restore fichier.txt

# Syntaxe ancienne (fonctionne toujours)
git checkout -- fichier.txt

# Restaurer tous les fichiers modifies
git restore .
git checkout -- .

# Restaurer un fichier depuis un commit specifique
git restore --source=abc1234 fichier.txt

9.2 Retirer du staging (unstage)

# Retirer un fichier du staging (Git 2.23+)
git restore --staged fichier.txt

# Syntaxe ancienne
git reset HEAD fichier.txt

# Retirer tous les fichiers du staging
git restore --staged .
git reset HEAD

9.3 Git reset (modifier l'historique local)

# --soft : deplace HEAD, garde staging et working directory intacts
git reset --soft HEAD~1
# Utile pour : refaire le message d'un commit, combiner des commits

# --mixed (defaut) : deplace HEAD, reinitialise le staging, garde le working directory
git reset HEAD~1
git reset --mixed HEAD~1
# Utile pour : annuler un "git add" et un commit, mais garder les fichiers modifies

# --hard : deplace HEAD, reinitialise staging ET working directory
git reset --hard HEAD~1
# DANGEREUX : les modifications non commitees sont perdues definitivement

# Revenir a un commit specifique
git reset --hard abc1234

# Revenir a l'etat du remote
git reset --hard origin/main

9.4 Git revert (annuler un commit de maniere sure)

Contrairement a reset, revert cree un nouveau commit qui annule les changements. Ideal pour les branches partagees.

# Annuler le dernier commit
git revert HEAD

# Annuler un commit specifique
git revert abc1234

# Annuler plusieurs commits (du plus recent au plus ancien)
git revert HEAD~3..HEAD

# Annuler sans commiter immediatement
git revert --no-commit abc1234

# Annuler un commit de merge (specifier le parent a garder)
git revert -m 1 abc1234

9.5 Git reflog (filet de securite)

Le reflog enregistre TOUS les mouvements de HEAD, meme apres un reset --hard. C'est votre dernier recours pour recuperer des commits perdus.

# Voir le reflog
git reflog

# Resultat typique :
# abc1234 HEAD@{0}: reset: moving to HEAD~1
# def5678 HEAD@{1}: commit: Ajout fonctionnalite X
# ghi9012 HEAD@{2}: checkout: moving from main to feature

# Recuperer un commit "perdu" apres un reset
git reset --hard def5678

# Ou creer une branche de recuperation
git branch recuperation def5678

9.6 Resume : quelle commande utiliser ?

10. Workflows

10.1 Gitflow

Gitflow est un modele de branchement structure, adapte aux projets avec des cycles de release bien definis.

Branches principales

• main (ou master) : code en production, toujours stable
• develop : branche d'integration, contient les dernieres fonctionnalites terminees

Branches de support

• feature/* : nouvelles fonctionnalites (branchees depuis develop, mergees dans develop)
• release/* : preparation de release (branchees depuis develop, mergees dans main ET develop)
• hotfix/* : correctifs urgents en production (branches depuis main, mergees dans main ET develop)

# Exemple de workflow Gitflow

# Creer une feature
git checkout develop
git checkout -b feature/authentification
# ... travailler, commiter ...
git checkout develop
git merge --no-ff feature/authentification
git branch -d feature/authentification

# Preparer une release
git checkout develop
git checkout -b release/1.2.0
# ... corrections de derniere minute, bump de version ...
git checkout main
git merge --no-ff release/1.2.0
git tag -a v1.2.0 -m "Version 1.2.0"
git checkout develop
git merge --no-ff release/1.2.0
git branch -d release/1.2.0

# Hotfix en production
git checkout main
git checkout -b hotfix/fix-crash-login
# ... corriger le bug ...
git checkout main
git merge --no-ff hotfix/fix-crash-login
git tag -a v1.2.1 -m "Hotfix: correction crash login"
git checkout develop
git merge --no-ff hotfix/fix-crash-login
git branch -d hotfix/fix-crash-login

10.2 Trunk-Based Development

Tout le monde travaille directement sur main (le "trunk") ou sur des branches de tres courte duree (1-2 jours max).

Principes

• Une seule branche principale : main
• Branches features tres courtes (mergees rapidement)
• Integration continue (CI) obligatoire
• Feature flags pour les fonctionnalites en cours de developpement
• Deploiement continu possible

# Workflow trunk-based typique

# Creer une branche courte pour une tache
git checkout main
git pull
git checkout -b fix/correction-rapide

# Travailler (quelques commits max)
git add .
git commit -m "fix: corriger la validation du formulaire"

# Rebaser sur main pour eviter les conflits
git fetch origin
git rebase origin/main

# Merger rapidement
git checkout main
git merge --no-ff fix/correction-rapide
git push origin main
git branch -d fix/correction-rapide

10.3 Comparaison des workflows

11. Fichier .gitignore

Le fichier .gitignore indique a Git quels fichiers et dossiers ne doivent pas etre suivis. Il se place a la racine du depot.

11.1 Syntaxe des patterns

# Commentaire
# Ignorer un fichier specifique
secret.txt

# Ignorer tous les fichiers avec une extension
*.log
*.tmp
*.bak

# Ignorer un dossier entier
node_modules/
vendor/
.cache/

# Ignorer les fichiers dans n'importe quel sous-dossier
**/logs/
**/*.pyc

# Negation : ne PAS ignorer un fichier (exception)
!important.log

# Ignorer les fichiers a la racine uniquement (pas dans les sous-dossiers)
/config.local.php

# Ignorer un dossier specifique mais pas les autres du meme nom
/build/

11.2 Patterns courants par type de projet

Projet Web / PHP

# Dependances
vendor/
node_modules/

# Environnement
.env
.env.local
.env.*.local

# IDE
.idea/
.vscode/
*.swp
*.swo
*~

# OS
.DS_Store
Thumbs.db
desktop.ini

# Logs et cache
*.log
storage/logs/
cache/
tmp/

# Fichiers compiles
*.min.js
*.min.css

Projet Python

# Environnement virtuel
venv/
.venv/
env/

# Cache Python
__pycache__/
*.py[cod]
*.pyo

# Distribution
dist/
build/
*.egg-info/

# Jupyter
.ipynb_checkpoints/

# Environnement
.env

Projet systeme / DevOps

# Secrets et credentials
*.pem
*.key
*.crt
*.p12
credentials.json
secrets.yaml

# Terraform
.terraform/
*.tfstate
*.tfstate.backup
*.tfvars

# Ansible
*.retry

# Docker
.docker/

# Vagrant
.vagrant/

11.3 Gerer les fichiers deja suivis

# Probleme : un fichier est deja dans Git mais vous l'ajoutez au .gitignore
# Solution : le retirer du suivi sans le supprimer du disque

# Retirer un fichier du suivi
git rm --cached fichier.txt

# Retirer un dossier entier du suivi
git rm -r --cached dossier/

# Puis commiter
git add .gitignore
git commit -m "chore: ajouter fichier.txt au gitignore"

11.4 Gitignore global

# Configurer un gitignore global (fichiers a ignorer dans TOUS vos depots)
git config --global core.excludesfile ~/.gitignore_global

# Exemple de contenu pour ~/.gitignore_global
# IDE
.idea/
.vscode/
*.swp

# OS
.DS_Store
Thumbs.db

12. Depannage courant

12.1 "detached HEAD"

Cet etat survient quand vous faites un checkout sur un commit ou un tag au lieu d'une branche.

# Verifier si vous etes en detached HEAD
git status
# "HEAD detached at abc1234"

# Solution : creer une branche pour conserver vos modifications
git checkout -b ma-branche-recuperation

# Ou revenir sur une branche existante (modifications locales perdues)
git checkout main

12.2 Conflit de merge impossible a resoudre

# Annuler le merge en cours
git merge --abort

# Voir les fichiers en conflit
git diff --name-only --diff-filter=U

# Accepter entierement une version
git checkout --theirs fichier.txt    # Garder la version de l'autre branche
git checkout --ours fichier.txt      # Garder notre version

# Puis marquer comme resolu
git add fichier.txt

12.3 Push rejete (non-fast-forward)

# Erreur : "Updates were rejected because the remote contains work that you do not have locally"

# Solution 1 : Recuperer et merger les changements distants
git pull origin main
# Resoudre les conflits si necessaire
git push origin main

# Solution 2 : Recuperer et rebaser
git pull --rebase origin main
git push origin main

# Solution 3 (DERNIER RECOURS - branche personnelle uniquement)
git push --force-with-lease origin ma-branche

12.4 Fichier trop volumineux (erreur de push)

# Erreur : "File xxx is 123.45 MB; this exceeds the file size limit of 100.00 MB"

# Retirer le fichier du dernier commit
git reset --soft HEAD~1
git reset HEAD fichier-volumineux.zip

# Ajouter au .gitignore
echo "fichier-volumineux.zip" >> .gitignore
git add .gitignore
git commit -m "chore: retirer le fichier volumineux"

# Si le fichier est dans l'historique profond, utiliser BFG :
# java -jar bfg.jar --strip-blobs-bigger-than 100M
# git reflog expire --expire=now --all
# git gc --prune=now --aggressive

12.5 Identifiants demandes a chaque push/pull (HTTPS)

# Activer le cache des credentials (pendant 1 heure)
git config --global credential.helper 'cache --timeout=3600'

# Ou stocker les credentials de maniere permanente (attention securite)
git config --global credential.helper store

# Sur Windows, utiliser le Credential Manager
git config --global credential.helper manager

# Meilleure solution : passer en SSH
git remote set-url origin git@gitlab.exemple.com:equipe/projet.git

12.6 Depot corrompu

# Verifier l'integrite du depot
git fsck --full

# Nettoyer les objets orphelins
git gc --prune=now

# En dernier recours : re-cloner
cd ..
mv projet projet-backup
git clone git@gitlab.exemple.com:equipe/projet.git
# Puis recopier les fichiers non commites depuis le backup

12.7 Recuperer un fichier supprime

# Trouver le dernier commit ou le fichier existait
git log --all --full-history -- chemin/vers/fichier-supprime.txt

# Restaurer le fichier depuis ce commit
git checkout abc1234^ -- chemin/vers/fichier-supprime.txt

# Ou avec la syntaxe moderne
git restore --source=abc1234^ chemin/vers/fichier-supprime.txt

12.8 Erreur SSL / Certificat auto-signe

# Desactiver la verification SSL pour un depot specifique (serveur interne)
git config http.sslVerify false

# Ou specifier un certificat CA personnalise
git config http.sslCAInfo /chemin/vers/ca-bundle.crt

# Pour un clone ponctuel
GIT_SSL_NO_VERIFY=true git clone https://gitlab-interne.local/projet.git

12.9 Permission denied (publickey)

# Verifier que l'agent SSH a la bonne cle
ssh-add -l

# Si la liste est vide, ajouter la cle
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

# Tester la connexion
ssh -vT git@gitlab.exemple.com

# Verifier que la cle publique est bien ajoutee dans GitLab/GitHub
cat ~/.ssh/id_ed25519.pub
# Copier cette cle dans : Profil > SSH Keys

12.10 Changer l'auteur d'un commit

# Modifier l'auteur du dernier commit
git commit --amend --author="Nouveau Nom <nouveau@email.com>" --no-edit

# Modifier l'auteur de plusieurs commits (rebase interactif)
git rebase -i HEAD~3
# Marquer les commits avec "edit"
# Pour chaque commit :
git commit --amend --author="Nouveau Nom <nouveau@email.com>" --no-edit
git rebase --continue