Maîtrisez les Commandes Git Essentielles

Git est l'outil de gestion de versions de code le plus populaire et largement utilisé dans le développement des infrastructures informatiques. Le but de cette documentation est de vous donner les bases pour vous débrouiller dans votre travail de tous les jours.

L'histoire de Git

Git est un système de contrôle de version distribué open source. Il est disponible sur presque tous les systèmes d'exploitation.

En 2005, Linus Torvalds a créé git en tant que système de contrôle de version distribué alors parce qu'il ne pouvait plus utiliser BitKeeper gratuitement.

Désormais, git est le système le plus utilisé par les développeurs. Sa nature distribuée facilite le développement, le suivi et la bonne collaboration avec les modifications de code.

Git dans le domaine du DevOps ?

Un consultant DevOps devra développer du code et de ce fait le stocker. Il se doit donc maîtriser Git pour stocker ses codes sources :

• de l'infrastructure pour le provisionnement et la gestion de configuration
• des pipelines CI/CD
• des programmes qu'il aura en charge d'écrire

Les Concepts Clés de Git

Dans cette section, nous allons aborder tous les concepts et mots clés qui vous aideront à progresser.

Système de contrôle de version distribué

Chaque développeur possède une copie complète de l'historique du projet, ce qui permet de travailler localement.

Dépôts (Repositories)

Les dépôts, souvent appelés "repos" en abrégé, est essentiellement une base de données qui stocke toutes les versions de votre projet, ainsi que l'historique complet des modifications. Il existe deux types principaux de dépôts Git.

Dépôt distant

Un dépôt distant est une copie du projet qui est hébergée sur un serveur distant. Les dépôts distants facilitent la collaboration entre plusieurs développeurs. Le dépôt distant peut être accessible en lecture et en écriture par plusieurs personnes, ce qui permet de partager le code, de travailler ensemble et de synchroniser les modifications. Des services tels que GitHub, GitLab et Bitbucket offrent des options d'hébergement de dépôts Git.

Dépôt local

Un dépôt local est une copie de votre projet stockée sur votre propre machine. Chaque développeur travaillant sur le projet aura son propre dépôt local. Cela permet à chacun de travailler indépendamment, d'effectuer des modifications, d'enregistrer des commits et d'explorer l'historique sans avoir besoin d'une connexion Internet.

Historique enregistré

Git enregistre l'historique complet des modifications apportées au code source, ce qui permet de suivre chaque modification, quel que soit le moment où elle a été effectuée.

Collaboration

Git facilite la collaboration entre plusieurs développeurs. Plusieurs personnes peuvent travailler sur le même projet simultanément en utilisant des branches distinctes.

Branches

Les branches est un concept central de Git. Elles permettent de travailler sur des fonctionnalités ou des correctifs de manière isolée sans affecter la branche principale (généralement appelée "master" ou "main").

Commit

Les commits sont la pierre angulaire de Git et sont utilisés pour enregistrer l'historique des modifications d'un projet. Un commit est un instantané (snapshot) de l'état d'un projet à un moment donné. Plus précisément, un commit représente une série de modifications apportées aux fichiers d'un projet à un moment précis, accompagnée d'un message descriptif qui les explique.

Grâce aux commits, il est possible de revenir en arrière et de restaurer le projet à un état antérieur en sélectionnant un commit précédent. Cela permet de résoudre les problèmes, de revenir à une version stable ou de réappliquer des modifications précédemment supprimées.

Les différentes URL git

Dans Git, il existe principalement deux types d'URLs utilisés pour accéder et interagir avec des dépôts distants : les URLs HTTPS et les URLs SSH. Chacun a ses propres caractéristiques et exigences en matière de configuration et d'utilisation.

URLs HTTPS

1. Format : Les URLs HTTPS ressemblent à des URLs web classiques et commencent par https://. Par exemple :

   https://github.com/username/repository.git
   

2. Utilisation : Les URLs HTTPS sont utilisées pour cloner, pousser et tirer des modifications depuis des dépôts distants via le protocole HTTPS. Elles sont souvent préférées dans les configurations où la simplicité est privilégiée.

3. Authentification : L'authentification avec les URLs HTTPS se fait généralement via un nom d'utilisateur et un mot de passe. Cependant, de nombreux services comme GitHub exigent désormais l'utilisation de jetons d'accès personnel (Personal Access Tokens) au lieu de mots de passe pour une sécurité accrue.

4. Avantages :

   • Facilité d'utilisation et configuration minimale.
   • Pas besoin de gérer des clés SSH.
   • Plus adapté aux environnements où les connexions SSH sont bloquées.

5. Inconvénients :

   • La nécessité de saisir des identifiants de manière répétée, sauf si un gestionnaire de mots de passe ou des jetons d'accès sont utilisés.
   • Moins sécurisé que SSH pour les opérations de transfert de données.

URLs SSH

1. Format : Les URLs SSH sont formatées différemment et commencent par ssh:// ou simplement par un identifiant d'utilisateur suivi d'un @ et de l'adresse du serveur. Par exemple :

   git@github.com:username/repository.git
   

2. Utilisation : Les URLs SSH sont utilisées pour des opérations similaires aux URLs HTTPS (clone, push, pull), mais via le protocole SSH.

3. Authentification : L'authentification SSH repose sur un échange de clés. Vous devez générer une paire de clés SSH (publique et privée) sur votre machine et enregistrer la clé publique sur le serveur Git distant (comme GitHub ou GitLab).

4. Avantages :

   • Plus sécurisé, car l'authentification est basée sur des clés et non sur des mots de passe.
   • Pas besoin d'entrer des identifiants à chaque opération une fois la clé SSH configurée.
   • Préférable pour des opérations automatisées, comme les scripts ou les intégrations continues.

5. Inconvénients :

   • Nécessite une configuration initiale de la clé SSH.
   • Peut être bloqué par certains pare-feux ou réseaux d'entreprise.

Installation de Git

Pour commencer à utiliser Git, vous devez d'abord l'installer sur votre système. Heureusement, Git est compatible avec différentes plates-formes, notamment Windows, macOS et Linux. Voici comment vous pouvez l'installer :

Installation de Git sous Windows

Je vous conseille de télécharger le package d'installation pour Windows à partir du site officiel de Git (<https://git-scm.com/download/win\>) et de suivre les instructions d'installation.

Installation de Git sous macOS

Sur macOS, Git est habituellement préinstallé. Vous pouvez vérifier s'il est déjà installé en ouvrant le Terminal puis en exécutant la commande git --version. Si ce n'est pas le cas, vous pouvez installer Git via un gestionnaire de paquets tel que Homebrew.

Installation de Git Sous Linux

Sur la plupart des distributions Linux, vous pouvez installer Git à l'aide du gestionnaire de paquets.

Par exemple, sur un poste Ubuntu :

sudo -i
add-apt-repository ppa:git-core/ppa
apt update
apt install git

Les principales commandes git

Configuration de Git

La configuration de git pour l'utilisateur se trouve dans le dossier ~/.gitconfig ou ~/.config/git/config. Pour éviter de véroler ce fichier de config, on fait appel à la commande git config. Par exemple pour définir la branche par défaut :

git config --global init.defaultBranch main

Pour retrouver les valeurs des configs actuelles :

git config --list
file:/home/bob/.gitconfig       user.name=Stéphane ROBERT
file:/home/bob/.gitconfig       user.email=stephane.robert.28@gmail.com
file:/home/bob/.gitconfig       core.editor=code --wait
file:/home/bob/.gitconfig       init.defaultbranch=main
file:.git/config        core.repositoryformatversion=0
file:.git/config        core.filemode=true
file:.git/config        core.bare=false
file:.git/config        core.logallrefupdates=true

Plus d'infos ici

Première configuration après installation

Une fois Git installé, vous devez le configurer. Les premiers paramètres à définir sont votre nom d'utilisateur et votre adresse e-mail, car ces informations seront associées à chaque commit que vous ferez. Vous pouvez configurer Git en utilisant les commandes suivantes dans le terminal :

git config --global user.name "Votre Nom"
git config --global user.email "votre@email.com"

Téléchargement d'un projet git

La commande permettant de télécharger localement un projet avec la commande git clone :

git clone [OPTION] [dossier]

Si vous renseignez un dossier, la commande n'utilise pas le nom du projet pour le nom du dossier, mais celui indiqué.

Les principales options de la commande git clone :

• --recurse-submodules : Télécharge également tous les sous-modules. Un concept que nous verrons dans une autre documentation.

Exemple :

git clone https://github.com/git/git.git /tmp/git

git clone https://github.com/git/git.git /tmp/git

Clonage dans '/tmp/git'...
remote: Enumerating objects: 356178, done.
remote: Counting objects: 100% (458/458), done.
remote: Compressing objects: 100% (218/218), done.
Réception d'objets:  23% (81921/356178), 37.52 Mio | 4.29 Mio/s
...
Résolution des deltas: 100% (267808/267808), fait.

Initialisation d'un projet git

Nous verrons dans cette section comment initialiser votre premier projet Git localement. Pour cela, on fait appel à la commande git init :

git init [OPTION] [dossier]

• Si vous renseignez un dossier, la commande est exécutée à l’intérieur de celui-ci. Si ce dossier n’existe pas, il sera créé.
• Si vous ne renseignez pas de dossier alors la commande est exécutée dans le répertoire actuel.

Les principales options de la commande git init :

• --initial-branch=name :

Exemple :

git init --initial-branch=main /tmp/toto
Dépôt Git vide initialisé dans /tmp/toto/.git/

Comme vous le remarquez la commande git init créé un dossier .git dans lequel on trouve :

drwxrwxr-x 7 bob bob 4096 nov.   2 13:58 .
drwxrwxr-x 3 bob bob 4096 nov.   2 13:58 ..
drwxrwxr-x 2 bob bob 4096 nov.   2 13:58 branches
-rw-rw-r-- 1 bob bob   92 nov.   2 13:58 config
-rw-rw-r-- 1 bob bob   73 nov.   2 13:58 description
-rw-rw-r-- 1 bob bob   21 nov.   2 13:58 HEAD
drwxrwxr-x 2 bob bob 4096 nov.   2 13:58 hooks
drwxrwxr-x 2 bob bob 4096 nov.   2 13:58 info
drwxrwxr-x 4 bob bob 4096 nov.   2 13:58 objects
drwxrwxr-x 4 bob bob 4096 nov.   2 13:58 refs

• la configuration du fonctionnement du projet dans le fichier config.
• des dossiers qui permettent de gérer tout l'historique du projet. Plus d'infos ici
• ...

Gestion des branches dans git

La gestion des branches est fondamental de Git, offrant une flexibilité immense pour le développement parallèle et la collaboration. En DevOps, savoir manipuler les branches efficacement est important pour maintenir un flux de travail continu et organisé.

Création d'une Nouvelle Branche

Pour créer une nouvelle branche, la commande git branch <nom_de_la_branche> est utilisée. Cette opération est rapide car Git crée simplement un nouveau pointeur vers le commit actuel. Par exemple, git branch feature-nouvelle crée une branche nommée feature-nouvelle.

git branch feature-nouvelle

Basculer entre les Branches

Une fois la branche créée, il faut y basculer pour y apporter des modifications. La commande git checkout <nom_de_la_branche> permet de changer de branche. Ainsi, git checkout feature-nouvelle vous positionne sur la branche feature-nouvelle.

git checkout feature-nouvelle

Basculement sur la branche 'feature-nouvelle'

Lister les Branches

Pour lister les branches dans un dépôt Git, vous pouvez utiliser la commande git branch. Cette commande offre différentes options pour afficher les branches selon vos besoins. Voici quelques exemples courants :

1. Lister les branches locales : Pour voir toutes les branches locales dans votre dépôt, utilisez simplement :

   git branch
   * dev
     feature-nouvelle
     main
   

   Cette commande affichera la liste des branches locales, en mettant en évidence la branche sur laquelle vous vous trouvez actuellement.

2. Lister toutes les branches, y compris les branches distantes : Si vous souhaitez voir à la fois les branches locales et les branches distantes (c'est-à-dire celles sur le serveur), utilisez :

   git branch -a
   * dev
     feature-nouvelle
     main
     remotes/origin/HEAD -> origin/main
     remotes/origin/dev
     remotes/origin/main
   

   Les branches distantes seront listées sous un préfixe remotes/.

3. Lister uniquement les branches distantes : Pour ne voir que les branches qui existent sur le serveur distant (par exemple, sur GitHub ou GitLab), vous pouvez utiliser :

   git branch -r
    origin/HEAD -> origin/main
    origin/dev
    origin/main
   

4. Afficher les branches avec les derniers commits : Pour obtenir une vue plus détaillée, y compris le dernier commit sur chaque branche, utilisez l'option -v :

   git branch -v
   * dev              2790a91 correction
     feature-nouvelle 2790a91 correction
     main             4e05890 add README
   

5. Rechercher des branches par un motif : Si vous cherchez des branches avec un nom spécifique ou suivant un motif, vous pouvez utiliser :

   git branch --list "*de*"
   * dev
   

Supprimer une Branche

Pour supprimer une branche dans Git, vous pouvez utiliser la commande git branch avec différentes options, en fonction de si vous souhaitez supprimer une branche localement ou sur un dépôt distant. Voici comment procéder :

Supprimer une Branche Locale

Pour supprimer une branche locale, la commande est la suivante :

git branch -d <nom_de_la_branche>

• -d est l'option pour "delete" (supprimer).
• Remplacez <nom_de_la_branche> par le nom de la branche que vous voulez supprimer.

Par exemple, pour supprimer une branche nommée feature-obsolete :

git branch -d feature-obsolete

astuce

Si Git détecte que les modifications dans la branche n'ont pas été fusionnées dans la branche actuelle et pourraient être perdues, il empêchera la suppression. Dans ce cas, vous pouvez forcer la suppression avec l'option -D (majuscule) :

git branch -D <nom_de_la_branche>

Supprimer une Branche sur un Dépôt Distant

Pour supprimer une branche sur un dépôt distant (comme GitHub ou GitLab), utilisez la commande suivante :

git push <remote> --delete <nom_de_la_branche>

• <remote> est le nom du dépôt distant (souvent origin).
• Remplacez <nom_de_la_branche> par le nom de la branche distante que vous souhaitez supprimer.

Par exemple, pour supprimer la branche feature-obsolete du dépôt distant nommé origin :

git push origin --delete feature-obsolete

Ajouter des fichiers à l'index

Pour ajouter des fichiers à l'index dans Git, ce qui signifie les préparer pour un commit, vous utilisez la commande git add. Voici les différentes manières de l'utiliser :

Ajouter un Fichier Spécifique

Pour ajouter un fichier spécifique à l'index, utilisez :

git add <nom_du_fichier>

Par exemple, pour ajouter un fichier nommé exemple.txt, tapez :

git add exemple.txt

Ajouter Plusieurs Fichiers

Si vous souhaitez ajouter plusieurs fichiers spécifiques, vous pouvez les lister tous dans la même commande :

git add <fichier1> <fichier2> <fichier3>

Par exemple :

git add exemple1.txt exemple2.txt exemple3.txt

Ajouter Tous les Fichiers Modifiés

Pour ajouter tous les fichiers modifiés (nouveaux fichiers, fichiers modifiés, fichiers supprimés) dans le répertoire courant et ses sous-répertoires, utilisez :

git add .

Ou :

git add -A

Ces commandes ajoutent tous les changements dans votre répertoire de travail à l'index.

Ajouter des Parties de Fichiers (Staging Interactif)

Si vous souhaitez ajouter seulement certaines parties d'un fichier modifié (et pas d'autres modifications dans le même fichier), utilisez :

git add -p <nom_du_fichier>

Cette commande lance un mode interactif vous permettant de choisir quelles modifications ajouter au commit. C'est utile pour diviser vos modifications en commits logiques et clairs.

Ajouter des Fichiers par Motif

Enfin, vous pouvez ajouter des fichiers selon un motif spécifique. Par exemple, pour ajouter tous les fichiers .txt :

git add *.txt

L'utilisation de git add est une étape essentielle dans le workflow Git, car elle permet de sélectionner précisément les modifications que vous souhaitez inclure dans votre prochain commit. Cela facilite la création de commits propres et bien organisés.

Retirer des fichiers à l'index

Pour retirer des fichiers de l'index dans Git, c'est-à-dire annuler leur ajout (staging) en vue d'un futur commit, vous pouvez utiliser la commande git rm. Cette commande sert à la fois à supprimer des fichiers de votre répertoire de travail et à retirer ces modifications de l'index. Voici comment l'utiliser :

Supprimer et Retirer des Fichiers

Pour supprimer un fichier de votre répertoire de travail et retirer ce fichier de l'index, utilisez :

git rm <fichier>

Par exemple, pour supprimer et retirer exemple.txt :

git rm exemple.txt

Cette action supprime le fichier de votre système de fichiers et met à jour l'index pour refléter cette suppression.

Retirer des Fichiers de l'Index Sans les Supprimer

Si vous voulez simplement retirer un fichier de l'index sans le supprimer de votre répertoire de travail, utilisez l'option --cached :

git rm --cached <fichier>

Par exemple, pour retirer exemple.txt de l'index tout en le conservant dans votre répertoire :

git rm --cached exemple.txt

Cela est particulièrement utile si vous avez accidentellement ajouté un fichier à l'index que vous ne voulez pas inclure dans votre prochain commit.

Supprimer et Retirer Plusieurs Fichiers

Vous pouvez également appliquer git rm à plusieurs fichiers en même temps :

git rm <fichier1> <fichier2> ...

Utiliser des Motifs pour Supprimer des Fichiers

Pour supprimer tous les fichiers correspondant à un certain motif, par exemple tous les fichiers .log, utilisez :

git rm '*.log'

attention

Il est important de noter que git rm modifie à la fois votre répertoire de travail et l'index. Par conséquent, soyez prudent lorsque vous utilisez cette commande, surtout si vous ne voulez pas supprimer définitivement des fichiers de votre répertoire de travail.

Enregistrer des modifications (commit)

Pour enregistrer des modifications dans l'historique de votre dépôt Git, vous utilisez la commande git commit. Après avoir ajouté vos modifications à l'index avec git add, vous pouvez créer un commit pour capturer l'état actuel de ces fichiers dans votre dépôt. Voici comment procéder :

Créer un Commit Simple

Pour créer un commit avec un message, utilisez :

git commit -m "Votre message de commit ici"

Remplacez "Votre message de commit ici" par une description concise de vos modifications. Par exemple :

git commit -m "Ajout de la fonctionnalité de connexion utilisateur"

Ajouter et Commiter en une seule commande

Si vous avez des modifications qui sont déjà suivies par Git (c'est-à-dire des fichiers qui ont été ajoutés à l'index lors de commits précédents), vous pouvez les ajouter à l'index et les commiter en une seule commande :

git commit -am "Votre message de commit ici"

Modifier le Dernier Commit

Si vous avez oublié d'ajouter des changements à votre dernier commit ou si vous voulez changer le message de commit, vous pouvez le modifier avec :

git commit --amend

Cela ouvrira un éditeur pour vous permettre de modifier le message de commit. Si vous avez de nouvelles modifications à ajouter au même commit, ajoutez-les d'abord avec git add, puis utilisez git commit --amend.

Créer un Commit Vide

Dans certains cas, vous pourriez vouloir créer un commit sans aucun changement (pour déclencher un processus CI/CD, par exemple). Utilisez pour cela :

git commit --allow-empty -m "Votre message de commit ici"

Vérifier l'État des Commits

Après avoir committé, vous pouvez vérifier l'état de vos commits par rapport au dépôt distant avec :

git status

Et pour voir l'historique des commits :

git log

Chaque commit dans Git représente un ensemble de modifications et est identifié par un identifiant unique (SHA-1). Le message de commit est important pour comprendre le contexte des modifications apportées. Assurez-vous donc que vos messages de commit sont clairs et descriptifs.

Envoyer et tirer des modifications

L'envoi (push) et la réception (pull) de modifications sont des opérations importantes dans l'utilisation de Git, surtout lorsqu'on travaille à plusieurs sur un projet. Ces commandes permettent de synchroniser les changements entre votre dépôt local et le dépôt distant (comme GitHub ou GitLab).

Tirer des Modifications (Git Pull)

Pour récupérer et fusionner les modifications depuis le dépôt distant vers votre dépôt local, utilisez git pull. Voici comment :

1. Tirer les modifications : La commande de base pour tirer les modifications est :

   git pull <remote> <branche>
   

   Par exemple :

   git pull origin main
   

   Cela récupère les modifications de la branche main du dépôt distant origin et les fusionne avec votre branche locale main.

2. Résoudre les conflits : Si des modifications ont été faites à la fois dans votre dépôt local et dans le dépôt distant sur les mêmes lignes de code, des conflits peuvent survenir. Git vous demandera de résoudre ces conflits avant de pouvoir compléter l'opération de pull.

Envoyer des Modifications (Git Push)

Après avoir commité vos modifications, vous pouvez les envoyer (push) vers un dépôt distant pour les partager avec d'autres. Voici comment faire :

1. Vérifier le dépôt distant : Avant de pousser vos changements, assurez-vous de connaître le dépôt distant avec lequel vous travaillez. Utilisez :

   git remote -v
   

   Cela vous montrera les URLs des dépôts distants associés à votre dépôt local.

2. Envoyer les modifications : Pour pousser vos commits sur la branche courante vers le dépôt distant, utilisez :

   git push <remote> <branche>
   

   Où <remote> est le nom du dépôt distant (souvent origin) et <branche> est le nom de votre branche. Par exemple :

   git push origin main
   

   Envoie les modifications de la branche locale main vers la branche main du dépôt distant origin.

Remiser des modifications (stash)

git stash est une fonctionnalité de Git qui permet de mettre de côté temporairement (ou "stash") les modifications en cours dans votre répertoire de travail, sans avoir à effectuer un commit. Cette fonction est utile dans plusieurs scénarios, tels que le besoin de basculer rapidement entre les branches sans vouloir commiter le travail en cours. Voici comment git stash fonctionne et comment l'utiliser :

1. Mettre de Côté des Modifications : Quand vous utilisez git stash, Git prend les modifications en cours dans votre répertoire de travail (modifications indexées et non indexées) et les sauvegarde dans une zone temporaire. Votre répertoire de travail revient alors à l'état du dernier commit.

2. Liste de Stash : Vous pouvez avoir plusieurs stashes enregistrés en même temps. Git les stocke dans une pile (stack), où le dernier stash est en haut de la pile.

Utilisation de Base

1. Créer un Stash : Pour mettre de côté vos modifications actuelles, utilisez :

   git stash
   

   Vous pouvez aussi lui donner un nom avec :

   git stash save "nom_du_stash"
   

2. Lister les Stashes : Pour voir tous les stashes que vous avez créés, utilisez :

   git stash list
   

3. Appliquer le Dernier Stash : Pour réappliquer les modifications du dernier stash (et le supprimer de la pile), utilisez :

   git stash pop
   

   Si vous voulez réappliquer les modifications sans supprimer le stash, utilisez git stash apply.

4. Supprimer un Stash : Pour supprimer le dernier stash de la pile, utilisez :

   git stash drop
   

   Pour supprimer un stash spécifique, utilisez git stash drop stash@{numéro} où {numéro} est l'index du stash dans la liste.

Scénarios d'Utilisation

• Basculer entre les Branches : Si vous êtes en train de travailler sur une branche et devez rapidement passer à une autre pour une tâche urgente, vous pouvez utiliser git stash pour mettre de côté vos modifications actuelles, changer de branche, puis les réappliquer plus tard.
• Nettoyer le Répertoire de Travail : Si vous voulez revenir à un état de répertoire propre, sans perdre les modifications en cours, git stash est une bonne solution.

Fusion de branches

Le merge (fusion) de branches dans Git est un processus clé pour intégrer les modifications d'une branche dans une autre. Cette opération est couramment utilisée pour combiner les modifications de développement dans une branche principale ou de fonctionnalités. Voici comment cela fonctionne et comment l'effectuer :

Fonctionnement du Merge

1. Objectif : Le merge permet de prendre les commits d'une branche et de les intégrer dans une autre. Cela crée un nouveau commit dans la branche cible qui contient les modifications des deux branches.

2. Fast-Forward Merge : Si la branche cible n'a pas de commits divergents depuis la création de la branche source, Git effectuera un "fast-forward merge". Cela signifie que Git met simplement à jour la tête de la branche cible pour pointer vers le dernier commit de la branche source.

3. Three-Way Merge : Si des modifications ont été apportées sur les deux branches depuis leur divergence, Git effectue un "three-way merge". Git crée un nouveau commit qui combine les changements des deux branches. Ce commit a deux parents : le dernier commit de chaque branche.

Effectuer un Merge

1. Se Positionner sur la Branche Cible : Avant de faire un merge, assurez-vous d'être sur la branche dans laquelle vous voulez intégrer les changements. Par exemple, si vous voulez fusionner une branche de fonctionnalité dans main, vous devriez d'abord vous positionner sur main :

   git checkout main
   

2. Fusionner la Branche Source : Ensuite, fusionnez la branche source dans la branche actuelle (cible) en utilisant :

   git merge <nom_de_la_branche_source>
   

   Par exemple, pour fusionner une branche appelée feature dans main, utilisez :

   git merge feature
   

Résolutions de conflits

La résolution de conflits dans Git est un aspect important lorsqu'il s'agit de collaborer sur des projets de code. Les conflits surviennent généralement lorsqu'il y a des modifications contradictoires dans une même partie d'un fichier sur différentes branches ou lorsqu'une personne a modifié un fichier qui a été simultanément modifié par quelqu'un d'autre sur le dépôt distant. Voici les étapes pour gérer et résoudre ces conflits :

Identifier les Conflits

Après une tentative de fusion (git merge) ou de récupération (git pull), Git vous informe s'il y a des conflits. Les conflits doivent être résolus manuellement.

Comprendre les Marqueurs de Conflit

Dans les fichiers concernés, Git insère des marqueurs de conflit qui aident à visualiser la portion de code en conflit. Ces marqueurs se présentent comme suit :

• <<<<<<< HEAD marque le début des modifications de votre branche.
• ======= sépare vos modifications de celles provenant de la branche avec laquelle vous fusionnez.
• >>>>>>> <nom de la branche> marque la fin des modifications de l'autre branche.

Par exemple :

<<<<<<< HEAD
// Votre code ici
=======
// Code de l'autre branche
>>>>>>> feature-branch

Résoudre les Conflits

Ouvrez les fichiers en conflit dans votre éditeur de texte ou IDE et décidez manuellement de garder, modifier ou fusionner les parties en conflit. Vous pouvez choisir de garder les modifications de votre branche, celles de la branche distante, ou les combiner d'une manière qui a du sens pour votre projet.

Marquer les Conflits Comme Résolus

Une fois que vous avez modifié le fichier et résolu les conflits, vous devez marquer ces conflits comme résolus. Pour ce faire, utilisez la commande :

git add <nom_du_fichier>

Cela n'effectue pas de commit mais signale à Git que les conflits dans <nom_du_fichier> ont été résolus.

Finaliser la Fusion

Après avoir résolu tous les conflits et les avoir ajoutés à l'index, vous pouvez finaliser la fusion avec un commit. Utilisez :

git commit

Git ouvrira un éditeur de texte pour que vous puissiez saisir un message de commit pour la fusion. Habituellement, un message par défaut est déjà préparé pour indiquer une fusion.

Tester les Modifications

Avant de considérer la fusion comme complète, testez votre code pour vous assurer que les modifications fusionnées fonctionnent comme prévu.

Conseils

• Utilisez des outils de résolution de conflits : Certains IDEs et outils GUI pour Git offrent des interfaces visuelles pour aider à la résolution des conflits, ce qui peut être plus intuitif que de le faire directement via la ligne de commande.
• Communiquez avec votre équipe : Si le conflit est complexe ou implique des choix stratégiques, discutez-en avec les membres de l'équipe impliqués pour décider de la meilleure façon de procéder.
• Pratiquez des commits réguliers et des mises à jour fréquentes : Cela minimise le risque de conflits importants, rendant leur résolution plus gérable.

La résolution de conflits peut sembler intimidante au début, mais avec de la pratique, elle devient une partie naturelle du travail avec Git dans un environnement collaboratif.

Résumé

Voici résumé le fonctionnement des commandes git. (Merci L.Destailleur)

Notions sur HEAD

Dans Git, HEAD est une référence symbolique au dernier commit sur la branche courante dans votre dépôt local. En d'autres termes, c'est le commit sur lequel vous travaillez actuellement.

HEAD change dynamiquement lorsque vous changez de branche ou lorsque vous faites un nouveau commit. Il pointe toujours vers le dernier commit de la branche courante.

En utilisant la commande git log, vous pouvez voir où HEAD est actuellement pointé. Le commit sur lequel HEAD pointe est généralement marqué en haut de la liste des commits.

git log

commit 2790a912332c139e5f916ed8833eb82dbdd34724 (HEAD -> dev, origin/dev, feature-nouvelle)
Author: Stéphane ROBERT <robert.stephane.28@gmail.com>
Date:   Tue Dec 12 15:31:18 2023 +0100

    correction

HEAD peut être utilisé pour naviguer dans l'historique de votre dépôt. Par exemple, HEAD~1 réfère au commit précédent celui sur lequel HEAD est actuellement pointé.

La commande git reset utilise souvent HEAD. Par exemple, git reset --hard HEAD réinitialise votre espace de travail au dernier commit, supprimant toutes les modifications non commitées.

Un état de "HEAD détaché" se produit lorsque HEAD pointe directement sur un commit spécifique et non sur le dernier commit d'une branche. Cela peut arriver lorsque vous checkout un commit spécifique ou un tag. En état de HEAD détaché, les commits que vous créez ne sont rattachés à aucune branche. Si vous changez de branche sans créer une nouvelle branche à partir de ce point, ces commits peuvent devenir "orphelins" et difficiles à retrouver.Pour sortir de cet état, vous pouvez checkout une branche existante ou en créer une nouvelle à partir du commit sur lequel le HEAD détaché pointe.

Bonnes Pratiques

• Vérifiez l'état de votre dépôt : Utilisez git status régulièrement pour vérifier l'état de votre dépôt local et voir si des modifications nécessitent un commit ou un push.
• Commits fréquents, Pushs réfléchis : Faites des commits petits et fréquents pour un meilleur suivi des modifications, mais poussez les changements vers le dépôt distant après avoir vérifié et testé vos modifications localement.

Ces commandes constituent la base de la collaboration et de la gestion de versions dans Git, permettant une synchronisation efficace entre les différents contributeurs d'un projet.

Plus d'infos

Je ne vais pas tout documenter, donc si vous voulez plus d'informations voici un quelques liens.

Liens

• Wikipedia

Livres gratuits

• Git Magic
• Pro Git Le livre officiel
• Apprenez Git

Vidéos

• xavki 35 vidéos