Présentation de GIT

Lorsque l’on travail en équipe il est important d’utiliser un outil de gestion des versions (comme git) sinon tu rencontreras des problèmes tels que :

• Depuis la modification du fichier Y, le projet ne fonctionne plus ;
• Impossibilité de travailler en même temps sur les mêmes fichiers ;
• Comment revenir à la version précédente du fichier ?
• Qui a fait quoi sur le projet ?

Git est donc un logiciel de versionning (ou logiciel de gestion des versions) créé en 2005 par Linus Torvalds le créateur de Linux.
Git permet de conserver un historique des modifications effectuées sur un projet afin de pouvoir rapidement identifier les changements effectuées et de revenir à une ancienne version en cas de problème.
Aujourd’hui Git est incontournable pour les développeurs, les sysadmins et autres équipes IT qui travail sur des projets collaboratifs.

Les avantages de Git :

• très rapide
• On peut travailler avec des branches (versions parallèles d’un même projet) de façon très flexibles

Inconvénients :

• assez complexe, il faut un certain temps d’adaptation pour bien le comprendre et le maîtriser.

Pourquoi cet article sur git ?

Git est un incontournable mais énormément d’admin système ne l’utilisent pas par manque de connaissances.

Cette article à donc pour but de te donner les bases pour utiliser les fonctions basiques de Git.

Installer Git

Linux (Ubuntu/Debian):

sudo apt update
sudo apt install -y git

Windows :

Pour utiliser Git sous Windows, il faut installer msysgit : https://gitforwindows.org/.

Mac :

Il suffit d’installer Xcode Command Line Tools depuis l’App store.

Les commandes Git de bases

Pour initialiser un dépôt git dans ton dossier actuel en on utilise la commande :

git init

Cette commande va créer un dossier caché « .git » qui contient les fichiers de configurations du dépôt que tu viens de créer. Tu n’auras normalement pas besoin de te rendre dans ce dossier caché sauf si tu souhaites éventuellement modifier la configuration de git.

Si tu souhaites supprimer le dépôt Git, tu n’as qu’à supprimer le dossier .git

Nous allons maintenons configurer git avec notre username et adresse mail avec ces commandes :

git config --global user.name votre_pseudo
git config --global user.email moi@email.com

Nous avons maintenant un dépôt git initialiser dans notre dossier actuel, pour vérifier le status de notre dépôt nous utiliserons la commande :

git status

Résultat de la commande :

La commande git status nous indique :

• la branche sur laquelle on se trouve,
• le commit actuel (nous en reparlerons un peu plus loin)
• Les fichiers qui n’ont pas étaient ajouté au dépôt

Donc notre dépôt ne contient pour l’instant aucun fichier, pour en ajouter on utilise la commande :

git add nom_du_fichier

si l’on souhaite ajouter tous les fichiers du dossier on peut utiliser :

git add .

Si l’on relance la commande git status on peut voir que les fichiers ont été ajouté au dépôt :

Maintenant que l’on a effectué ces changements nous devons les sauvegarder dans un « commit ».

Un commit est une version du dépôt. Au fur et à mesure que le projet avance on créée des commit, on donne un nom explicite à chaque commit ce qui nous permet d’avoir un suivi de l’avancé du projet et des versions.

Pour créer un commit on utilise la commande :

git commit

Pour créer un commit qui ajoute tous les fichiers et donne un nom au commit :

git commit -am "description du commit"

Le paramètre -a permet de valider tous les fichiers modifiés

Le paramètre -m permet de donner un nom au commit

On a notre premier commit, nous allons maintenant effectuer des modifications puis créer un deuxième commit.

Une fois les modifications faites et le second commit créé, lances la commande :

git log

Cette commande te donne des indications sur chaque commit :

• identifiant du commit
• auteur
• date
• nom du commit

Ici on a les informations sur nos 2 commits

Si l’on souhaite revenir à un ancien commit on utilise la commande :

 git checkout identifiant_commit

Par exmple si je veux revenir à mon premier commit je tape :

 git checkout b5a8225da94eef58785ac7478aa2882ccbe109d6

Git clone :

La commande git clone permet de télécharger le contenu d’un dépôt distant cette commande est importante pour le travail en collaboration.

Exemple d’utilisation de git clone :

git clone https://gitlab.com/glpi-project/glpi

Cette commande permet de télécharger le projet glpi.

Les branches

Une branche git est en quelque sorte une variante du projet de base, il sert à tester et implémenter de nouvelles fonctionnalité sans modifier le projet de base. Les branches sont très pratique car si les modifications faites sur la branche rendent le projet inutilisable on peut abandonner la branche et dans le cas ou les modifications fonctionnes on peut fusionner la branche avec la branche par défaut du projet.

La branche par défault est « master », c’est la branche que l’on utilise de base lorsque l’on créée des commits.

Créer une branche :

Pour créer une branche, on utilise la commande :

git branch nom_de_la_branche

Cette commande va créer une nouvelle branche qui pointe sur le dernier commit.

On a donc à ce moment deux branches qui pointent sur le dernier commit (la branche de base et la nouvelle).

Une fois une nouvelle branche crée on peut basculer dessus via la commande :

git checkout nom_de_la_branche

On peut vérifier sur quel branche nous nous situons grâce à la commande :

git branch

On peut aussi revenir à la branche de base (master) en tapant :

git checkout master

Si l’on effectue des modifications sur une des branches et que l’on nous créons un nouveau commit les 2 branches divergeront.

Dans ce cas on peut visualiser les différences avec la commande :

 git diff master nom_de_la_branche

Les fusions :

Fusionner 2 branches reviens à faire avancer la branche contenant moins de commit vers le commit de la dernière branche.

Pour se faire on se place donc sur la branche master puis on tape :

 git merge nom_de_la_branche

A partir de là nos 2 branches sont identique, on peut donc supprimer la branche en trop (on garde seulement master) :

git branch -d nom_de_la_branche

Pour ce cas la fusion n’a eu aucun mal à se faire puisque par rapport aux 2 branches un des 2 avait un commit d’avance.

Mais cela aurait pu être différent si les branches étaient au même niveau de commit mais avec chacun un commit différent. Dans ce cas il peut y avoir des conflits si une même partie d’un fichier a été modifiée de différentes manières dans les différentes branches.

Dans ce cas, lors de la fusion, Git nous alertera du conflit et nous demandera de le résoudre avant de terminer la fusion des branches.

La commande git status nous permet de voir dans ce cas quels sont les fichiers qui causent ce confit.

On peut alors ouvrir ces fichiers avec un éditeurs de texte et s’apercevoir que git à indiquer les passages qui posent problèmes, on pourra alors supprimer les conflits et enregistrer le fichier puis faire un git add et le problème sera résolu et nous pourrons créer un commit de fusion.

Rebaser :

Rebaser est la deuxième possibilité pour renvoyer le commit d’une branche vers une autre branche. La commande git rebase récupère les modifications validées sur une branche vers une autre branche.

Pour ce faire Git récupère le dernier commit commun des 2 branches puis récupère les modifications sur la branches qu’on souhaite récupérer et l’applique sur la branche vers laquelle on souhaite rebaser les modifications.

Le résultat final est le même qu’une fusion mais l’historique est plus clair puisque toutes les modifications apparaissent en série même si elles ont eu lieu en parallèle. Rebaser rejoue les modifications d’une ligne de commits sur une autre dans l’ordre d’apparition, alors que la fusion joint et fusionne les deux têtes.

Par contre il faut savoir que rebaser équivaut à supprimer des commits existants pour en créer de nouveaux. Pour cette raison, il ne faut jamais rebaser des commits qui ont déjà été poussés sur un dépôt public.

Présentation de GitHub

GitHub qui appartient à Microsoft est la plus grande plateforme d’hébergement de projets. Vous pouvez y stocker vos projet et télécharger les projets publics des autres contributeurs.

La plateforme se base sur git et sert de dépôt distant.

On l’a vu précedemment on peut cloner un projet en local avec la commande :

 git clone url_du_projet

Pour utiliser GitHub, il suffit de créer un compte gratuitement sur le site https://github.com.

Créer un dépôt distant sur GitHub :

1. Créer un nouveau projet sur GitHub
2. Dans notre projet local on créé un fichier README.md
3. On l’ajoute au projet : git add README.md
4. On créé un commit : git commit -am « ajout du readme »
5. On se positionne sur le dépôt distant : git remote add origin https://github.com/babidi34/test.git
6. Et on envoi le projet sur le dépot distant avec la commande : git push -u origin master

Pour obtenir des info sur le dépôt distant on utilise la commande :

git remote show nom_du_projet

Pour retirer un dépôt distant :

git remote rm nom_de_depot

Mettre en pratique :

Pour maîtriser les commandes de base de Git, je te propose un petit exercice pour mettre en pratique ces commandes étape par étape :

1. Initialise un dépôt Git
2. Ajouter les fichiers présent
3. Créer un commit
4. Créer de nouveau fichier de test et les ajouter
5. Créer un nouveau commit
6. Basculer entre les commits
7. Créer une branche de test
8. Créer des commits sur cette branche de test
9. Fusionner les branches
10. Upload ton dépôt Git sur un repository Github/Gitlab