Newer
Older
Bienvenue dans ce TD de formation sur Git/Gitlab
================================================
Au cours de ce TD, vous allez apprendre à vous servir du logiciel **Git**, permettant de gérer efficacement des projets informatique et de **GitLab**, une interface web pour administrer et partager des projets sous git.
Au cours de ce TD, si vous avez la moindre question, n'hésitez pas à demander à un membre du BR, ou directement à moi (Sosthène Guédon), le créateur de ce TD.
Dès qu'un projet commence à prendre de l'ampleur, Dropbox marche 5min mais risque rapidement de devenir impossible à maintenir sans les outils spécialisés.
Il permet de séparer chaque modification en *commit* et d'avoir un historique des modifications, comme on le voit sur cette image des premiers commit de Sigma.
Chaque point correspond à un *commit* et est accompagné d'un message décrivant ce qui est modifié.
De plus il permet de gérer la collaboration entre plusieurs individus extrêmement efficacement avec les branches (git est utilisé pour gérer le développement de projets extrêmement importants comptant parfois plusieurs milliers de contributeurs comme Linux, ou Windows).
Les développeurs peuvent créer des branches séparées en parallèle pour, travailler sur les branches sans se gêner les un les autres et mettre leur travail en commun lors d'opérations appelées *merge* qui consistent à fusionner les branches.
II Installation
---------------
Pour commencer, il va falloir installer [Git](https://git-scm.com/downloads), il y a des explication pour Windows Mac et Linux.
III La ligne de commande et GitLab
---------------------------------
Dans ce tutoriel, nous allons vous apprendre à se servir de Git depuis la console.
Il existe de nombreuses interfaces graphique que l'on ne vous présentera pas.
La raison est simple, les commandes sont les mêmes pour tout le monde et permettent de mieux comprendre le fonctionnement de git, et permettent de comprendre les interfaces graphiques facilement.
De plus, la plupart des IDE possèdent des intégrations de git.
Nous allons aussi vous expliquer le fonctionnement de Gitlab, un site web permettant de partager du code sous Git, concurrent libre de GitHub. Il permet aussi d'avoir accès à un suivi de bug et d'autres outils.
Une version de GitLab hébergée sur les serveurs du BR, réservée à l'X est [gitlab.binets.fr](gitlab.binets.fr) (normalement l'endroit où vous êtes en train de lire ceci) tandis qu'une version gérée par l'entreprise GitLab elle-même, publique est accessible par tous à [gitlab.com](gitlab.com),
IV Premier objectif : le Fork
-----------------------------
Chaque projet est accessible sur un dépôt (repository ou repo en anglais).
Certains projets peuvent être séparés en plusieurs dépôt, c'est le cas de Sigma par exemple.
Pour pouvoir commencer, il va falloir que vous ayez une copie de ce dépôt (repo en anglais) sur votre compte Gitlab.
Cette action s'appelle un *fork* et est disponible en haut de la page.
(Profitez en pour mettre une étoile au tuto avec le bouton *star*, il s'agit d'un système de mesure de popularité d'un dépôt )
Cliquez sur Fork, vous allez être rediriger vers une page vous demandant où vous souhaitez placer le fork. Ceci est utile si vous avez les droits pour certains groupes, comme le BR et vous permet de créer des projets au nom du groupe.
Normalement seuls votre nom est proposé.
Cliquez dessus puis vous serez redirigé vers la page de votre fork, presque identique à celle-là.
Gardez la page de votre fork ouverte et fermez l'ancienne, puis redescendez au même de la page du fork, pour maintenant suivre le tutoriel depuis votre fork.
V Deuxième objectif : Clone
---------------------------
Vous avez donc une copie du TD sur votre compte il va maintenant falloir la copier sur votre ordinateur. Pour cela, créez un dossier de travail pour ce TD puis ouvrez y une console.
Pour cela copiez le chemin puis faites, dans une console (si ctrl-c ne marche pas, utilisez ctrl+shift+c)
```bash
cd chemin/vers/dossier/de/travail
```
Retournez en haut de la page et cliquez sur *clone* (à côté de *fork*) puis copiez le lien de l'option https.
Retournez dans l'invite de commande et tapez
Le nom d'utilisateur et le mot de passe demandé sont ceux de Sigma.
Vous pouvez maintenant vous déplacer dans le dossier créé avec
```bash
cd "td-formation-git"
```
Bravo, vous venez d'effectuer votre première commande git.
Vous pouvez observer la syntaxe classique des commandes git :
```bash
git [commande] [arguments]
```
Cette syntaxe est commune à toutes les commandes git.
Vous allez enfin pouvoir commencer les exercices.
Il y en a 3, après lequel vous serez des pros de Git!!
Dans ce premier exercice, vous allez modifier un fichier puis créer votre premier *commit*.
Lorsque vous taperez certaines commandes, il est possible que git vous demande des options de configuration, pour avoir votre nom et adresse email.
De plus, dépendant de votre configuration, il est possible que les messages de git soient traduits en français.
Le nom et l'adresse que vous lui donnerez seront ceux affichés sur les commits.
Je recommande aussi d'effectuer la commande ``` git config core.editor nano ``` pour que git utilise l'éditeur nano au lieu de vim, l'éditeur par défaut.
Commencez par exécuter la commande
```bash
git status
```
Vous devriez voir :
```
On branch master
Your branch is up to date with 'origin/master'.
nothing to commit, working tree clean
```
Ceci signifie que rien n'a été modifié depuis le dernier commit
Vous allez pouvoir faire vos premières modifications.
Pour cela, ouvrez le fichier "exo1/noms_prenoms.txt" dans votre éditeur de texte/code préféré et ajoutez y votre nom et prénom.
L'objectif est de laissez une trace montrant toutes les personnes ayant effectué ce tutoriel.
Refaites
```bash
git status
```
Vous devriez voir:
``` bash
On branch exo1
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: exo1/noms_prenoms.txt
no changes added to commit (use "git add" and/or "git commit -a")
```
Ce qui signifie que git détecte que le fichier "noms_prenoms.txt" a été modifié.
Pour voir la modification, faites
```bash
git diff
```
Cette commande permet d'afficher les différences entre l'état actuel et le dernier commit
De mon côté, ceci affiche :
```diff
diff --git a/exo1/noms_prenoms.txt b/exo1/noms_prenoms.txt
index b2490e0..528d9e5 100644
--- a/exo1/noms_prenoms.txt
+++ b/exo1/noms_prenoms.txt
@@ -1 +1,2 @@
Sosthène Guédon
+Un nouveau nom
```
Ce qui permet de voir que la ligne *Un nouveau nom* viens d'être ajoutée car il y a un plus devant.
Il va maintenant falloir dire à git de sauvegarder ces modifications et les mettre dans un commit.
Pour cela faites
```bash
git add exo1/noms_prenoms.txt
```
Après,
```bash
git status
```
Vous donne
```
On branch exo1
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
modified: exo1/noms_prenoms.txt
```
Faites maintenant
```bash
git commit -m "Ajoute mon nom"
```
Bravo!! Vous avez fait votre premier commit, avec pour message "Ajoute mon nom"
Comme vous l'avez constaté, le commit s'est fait en deux commandes, *add* et *commit*
Pour avoir un contrôle fin sur les commit, git se sert de 3 "zones" de travail:
- le *working directory*
- la *staging area*
Le *working directory* correspond simplement au dossier dans lequel se trouve votre projet.
Les fichiers et dossiers dans le *working directory* peuvent être modifiés comme n'importe quel autre fichier, sans en informer git.
La *staging area* et la zone dans laquelle vous mettez les changements effectués aux fichiers que vous souhaitez qui git garde en mémoire.
Vous y ajoutez des fichiers avec la commande ```git add [nom d'un fichier]```
Ensuite ```git commit``` prend tout ce qui est dans la *staging area* et en fait un commit.
Ceci est expliqué simplement sur ce schéma:
Il est maintenant tant de comprendre l'utilité des commits.
Vous pouvez faire
```bash
git log
```
qui vous ouvre une interface qui permet de faire défiler la liste des commits (utilisez les flèches pour vous déplacer et q pour quitter).
Le premier devrait être le votre, avec le message que vous venez de mettre.
Chaque commit est accompagné d'une ligne de charabia:
```
commit 1755910a947f3d717f0bf107aee79939f8075fd0 (HEAD -> master)
```
Cette ligne de charabia est un *hash* qui sert d'identifiant unique au commit.
Vous pouvez la copier (Si ctrl+c ne marche pas, c'est parce que dans la console, il faut utiliser ctrl+shift+c et ctrl+shift+v pour copier coller).
Vous pouvez retourner à un commit avec
```bash
git checkout [insérer hash du commit]
```
Tous les fichiers sont alors retournés à l'état dans lequel ils étaient après ce commit.
Pour retourner au dernier commit, faites
```bash
git checkout master
```
L'exercice suivant vous fera comprendre cette commande.
Ensuite, il vous est possible de "push" votre commit sur GitLab.
Pour l'instant, votre commit n'est présent que sur votre ordinateur.
La commande pour envoyer vos commits au serveur GitLab s'appelle "push".
Cette commande vous demandera de vous authentifier avec vos identifiants Sigma, comme pour ```git clone```
Vous pouvez maintenant retourner sur la page de votre fork et voir votre commit.
---
Dans cet exercice, vous allez apprendre à utiliser les branches, la fonctionnalité fondamentale de git pour le travail en collaboration.
Git permet de créer des branches. Chaque branche correspond à un état différent du développement.
L'intérêt est que chaque développeur peut travailler sur une branche correspondant à a fonctionnalité sur laquelle il travaille, sans avoir à se soucier d'interférer avec le travail des autres développeurs.
Une fois que la fonctionnalité est terminée, il suffit de "merge" la branche de fonctionnalité avec la branche de développement principale, en s'assurant qu'il n'y a pas de conflits entre les branches et en les corrigeant s'il y en a.
Voici un exemple de d'utilisation des branches pour le développement de sigma:
Vous avez déjà utilisé une commande avec les branches lorsque vous avez fait
``` bash
git checkout master
```
master est le nom de la branche principale.
```git checkout``` est la commande permettant de se déplacer dans l'historique git.
Elle permet de visiter un commit précis avec son Hash, mais aussi de visiter une branche en utilisant son nom.
Ainsi, la commande ```git checkout master``` vous fait revenir au dernier commit de la branche master.
Pour créer une nouvelle branche tapez :
```bash
git checkout -b exo2
```
Vous avez maintenant créé une nouvelle branche appelée "exo2".
Vous pouvez vérifier ça avec ```git status```.
Pour pouvoir comprendre les merge, créez une nouvelle branche appelée "temp".
Sur cette branche, ajoutez un fichier appelé temp dans lequel vous pouvez ajouter quelques lignes.
Créez un commit pour cet ajout comme vous l'avez appris au premier exo.
Ensuite, passez à la branche exo2 avec ```git checkout exo2``` puis créez un fichier exo2 avec quelques lignes et le commit qui va avec. Ceci permet de simuler deux personnes travaillant sur deux branches séparées.
Il est maintenant temps de "merge" les deux branches.
Pour cela, il suffit d'utiliser la commande ```git merge [branche cible]``` depuis la branche sur laquelle vous voulez que le merge soit fait.
Dans notre cas, il faut donc faire ```git merge temp```.
Git vous ouvre ensuite l'éditeur pour écrire le message pour expliquant le merge.
Il est normalement déjà pré-rempli par ```merge branch 'temp' into exo2```.
Voilà, vous savez maintenant comment vous servir basiquement des branches.
GitLab possède pas mal de fonctionnalités, permettant de gérer efficacement le développement.
Si vous essayez de push des commits sur le dépo du BR du TD, vous n'aurez pas les droits (c'est pour cela que vous avez du fork le td pour en avoir une version sur votre compte sur lequel vous avez les droits de modification).
Cependant vous pouvez quand même participer aux développement d'autres projets sur GitLab, mais il faut pour cela avoir l'accord des des mainteneurs du projet.
Allez sur l'onglet Merge Request, puis faites "new merge request".
Selectionnez comme branche source votre branche master dans laquelle il y a le commit où vous avez ajouté votre nom et dans la branche cible la branche master du BR.
Ajoutez un petit message d'amour envoyez la merge request.
Ensuite, des membres du BR pourrons l'accepter et votre nom sera ajouté à la liste noms_prenoms.txt.