I - Git : Les bases
Tags: git, code, devops
Published: 2021-12-11 01:16:36

---
title: I - Git : Les bases
published: true
date: 2021-02-04 22:29:36 UTC
tags: git,code,devops
canonical_url: https://thanos.savoirguinee.com/git/
---

 ![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/03/gitbase.png)

Dans le cycle de développement d'une application,  la gestion du code (collaboration et version) est une étape importante.

**Linus Torvalds** créa git en 2005 en afin de remplacer BitKeeper qui assurait le partage gestion des patch du noyau Linux. Git est parti donc de ces  principes: vitesse, distribution, simplicité et est  distribué selon les termes de la licence GNU 2.0.  
 C'est un logiciel de contrôle des versions décentralisées. Permettant ainsi à un groupe de personnes de travailler sur un même projet en gérant les différentes versions et fusionnant à un moment donnant leur travail. C'est l’outil de gestion de version le plus populaire.  
 Git permet de gérer tout type de documents textes, donc il n'est pas destiné uniquement aux développeurs, mais aussi à des utilisateurs d'outils comme latex ou Markdown pour leur création de contenu.

## I - Installation

L'installation de git est assez simple en fonction de votre système d'exploitation:  
  
<u><strong>A - Windows:</strong></u>  Git est disponible en téléchargement sur [ce lien](https://gitforwindows.org/). Après téléchargement, l'installation se fait de la manière que toute application Windows.  
  
<u><strong>B- Linux et dérivé:</strong></u> Sur les systèmes linux (Ubuntu, Debian, Redhat, ...), l'installation se fait directement via le source code disponible sur  Github (un peu compliqué) ou en utilisant simplement le gestionnaire de package correspondant au système d'exploitation (apt, aptitude, yum, ....).

```
apt-get install git
```

L'installation est maintenant terminé, vous pouvez vérifier la version de git installée grâce à cette commande:

```
git --version
```

Dans la prochaine section nous verrons comment initialiser notre 1er " **repository**" (appellation commune des dossiers git).

Pour la suite je considère que vous utilisez un terminal linux, mais sachez que que  les commandes Git restent valide sur Windows.

## II - Création d'un "repository" local

Dans cette section, nous allons créer un projet sur la machine local et gérer son évolution avec git. Pour cela suivez ces étapes:

### 1- Créer un dossier  qui va contenir notre projet git :

```
mkdir tuto-git
cd tuto-git
```

Une fois dans le dossier (tuto-git), nous allons maintenant initialiser le repository :

```
➜ tuto-git git init
Initialized empty Git repository in /Users/boubacar/Desktop/projects/git/tuto-git/.git/
```

Après initialisation, un dossier ".git" sera créé dans le répertoire. il sera visible avec la commande "ls -al".

![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/02/Capture-d-e-cran-2021-02-16-a--23.54.20.png)

Ce dossier ".git" contient l'ensemble des informations de notre projet. Nous allons nous intéresser particulièrement au fichier  ".git/config" qui évoluera tout au long de ce tutoriel.

![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/02/image-1.png)

Avant de continuer nous allons configurer 2 variables qui vont nous aider à identifier l'utilisateur qui effectue les actions sur le repository git. Remplaces ces valeurs par ton nom et votre adresse email. (Oui là, on va se tutoyer maintenant).

```
git config --global user.name "Your Name"
git config --global user.email you@example.com
```

### 2- États du repository et création des fichiers:

Vérifions l'état de notre repository (dossier git) avec la commande: git status

![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/02/image-3.png)

Il est mentionné que nous somme sur la branche master et qu'aucun commit n'a pour l'instant été effectué. Quelques définitions:  
 -  _ **Une branche** est un dossier virtuel dans le repository qui contient des commits._  
**_- Un commit_** _est une sauvegarde d'un état du repository. Chaque commit peut être accessible avec son ID._

Pour un début nous allons travailler sur la branche par défaut qui dans notre cas s'appel "master" et nous ferons évoluer notre repository dans cette branche.  
Nous allons créer un 1er fichier que nous allons appeler _tuto-git.py_ qui sera notre programme python à manipuler.

<!--kg-card-begin: markdown-->

tuto-git.py

```
def main():
    print("Bienvenue sur Git")

if __name__ == " __main__":
    main()

```
<!--kg-card-end: markdown-->

L'état de notre repository va changer avec l'ajout de ce ficher. Toujours avec la commande "git status" nous aurons:

![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/02/image-7.png)

Le fichier est vu par git, mais est pour l'instant à l’état " **Untracked**".  A rappeler qu'un fichier git peut avoir l'un des 4 états affiché sur le schéma ci-dessous.

![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/02/image-6.png)

Pour que le fichier soit pris en compte nous devons l'ajouter à git avec la commande:

<!--kg-card-begin: markdown-->
```
$ git add tuto-git.py

```
<!--kg-card-end: markdown-->

![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/02/image-8.png)

Le fichier passe ainsi à l'état "Stagged". A noter que la commande "git add " permet d'ajouter plusieurs fichier (et uniquement des fichiers) en les séparant par un espace ou bien ajouter tout le contenu du répertoire git avec la commande:

<!--kg-card-begin: markdown-->
```
# Ajoute tout le contenu du repertoire
$ git add . 

# Ajoute tout le contenu de dossier 
$ git add dossier/* 

```
<!--kg-card-end: markdown-->

Une fois le fichier ajouté, nous pouvez créer notre 1er commit qui sera l'enregistrement de l'état de notre répertoire dans git. Et comme indiqué au niveau du schéma des états, le fichier passera à l'état "Unmodified". Pour créer un commit, nous utilisons la commande suivante avec le paramètre  "-m" permettant de spécifier le message.

![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/02/image-10.png)

Notre commit s'appel "_Mon coomit: 1_". Tu aurais pu mettre un nom de commit différent, en général il correspond à une description de tes modifications. Nous voyons aussi que git nous fait un petit résumé des modifications.

Voici la liste des commits disponibles avec la commande: "git logs"

![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/02/image-11.png)

Nous reviendrons plus en détails sur la magie de "git log", mais intéressons nous un peu à cette image. Nous avons:

<!--kg-card-begin: markdown-->
- L'identifiant du commit : b0ea64360e6ea6165e98d95e2eb668ee325aec8d
- La branche associé au commit: _master_
- Auteur du commit: Ce sont les infos que nous avions saisi au début avec la commande "git config --global user.name" et "git config --global user.email"
- Messsage: "Mon commit: 1"
<!--kg-card-end: markdown-->

Nous allons effectuer les opérations suivantes afin d'avoir 3 commits au niveau de notre repository:  
 a - Modifier le contenu de contenu du fichier avec un éditeur de texte classique et remplacer notre texte (print) par  "Bienvenue sur ce cours Git". Un git status nous montre que le fichier repasse à l’état "Modified".

En plus du "git status",  nous pouvons vérifier les modifications effectuées (depuis le commit précédent) avec la commande: "git diff".

![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/02/image-14.png)

Il faut à nouveau refaire les commandes:

<!--kg-card-begin: markdown-->
```
# Changer l'état à Stagged
$ git add tuto-git.py

# Changer l'état à Unmodified
$ git commit -m "Changement du message"

```
<!--kg-card-end: markdown-->

![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/02/image-15.png)

b -  Créer un second fichier  que nous allons appeler "lib-python.py" qui aura pour commit message "Ajout d'une lib" une fois ajouté à git.

![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/02/image-16.png)

Le fichier lib-python.py contient uniquement la ligne: #Lib python

Maintenant que nous avons 3 commits nous pouvons voyager dans le temps.

### 3- Voyage dans le temps

Revoyons vite fait nos commits et leur infos sur la branche master:

![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/02/image-17.png)

Pour avoir un minimum d'informations, nous pouvons rajouter des paramètres à la commande "git log".

![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/02/image-18.png)

A noter qu'il y'a plusieurs format de logs que vous pouvez afficher. Celà peut par exemple être utile lorsque vous effectuer des releases notes. Plus de details sur ce [site-web](https://www.edureka.co/blog/git-format-commit-history/).

Attentions, les commit ID seront différents sur ton ordinateur. Tu remarquera aussi la branche master correspond toujours au dernier commit. En accéder à une branche correspond juste à accéder au dernier commit, et HEAD est une variable qui correspond au commit sur lequel nous nous trouvons.  
 cela:

<!--kg-card-begin: markdown-->
### Accèder au 1er commit

```
$ git checkout b0ea643

```

Mettre les 7 premières valeurs du commit sont suffisant. Git t'informera que que HEAD pointe maintenant vers ce commit. Tu remarqueras aussi le fichier que l'etat de notre dossier a changé:

- Le dernier fichier que nous avons rajouté a disparu.
- Le fichier tuto-git.py a repris son contenu initial.

### Verifier le commit actuel.

Il suffit d'afficher le HEAD.

```
$ git show head

```

### Créer une branche

Une branche est créée (par defaut) à partir du HEAD sur lequel nous nous trouvons, ce qui peut donc être un commit ou une autre branche. Nous allons nous deplacer vers le commit 2 et créer une branch que nous appelerons "dev".

```
$ git checkout 37ec6a7
$ git checkout -b dev
# le paramètre -b indique que nous créeons une nouvelle branch

```

Nous aurons ainsi ce graphe, qui indique que la branche "dev" se situe sur le second commit.

<!--kg-card-end: markdown-->

![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/02/image-19.png)

La branche dev devient ainsi notre nouveau HEAD et nous pouvons y rajouter d'autres modifications. La branch master dépasse pour l'instant dev d'un commit qui correspond au dernier fichier que nous avons ajouté (lib-python.py). Ce fichier ne s'affichera que lorsque nous revenons sur la branche "master".

```
$ git checkout master
```

Nous pouvons ainsi créer plusieurs branches qui vont correspondre à la modification (sujet du sprint) que nous voulons effectuer.

Voici  un exemple de repository différent du notre  ayant plusieurs branches:

![I - Git : Les bases](https://thanos.savoirguinee.com/content/images/2021/03/image.png)

Une fois l'ensemble des modifications effectuées sur une branche, nous pouvons les appliquer sur la branche principale (master) en effectuant une fusion.  
 Ainsi, plusieurs développeurs peuvent ajouter des modifications du projets sur des branches différentes et fusionner plus tard leurs modifications sur la branche principale.  Pour effectuer cette fusion il faut:

<!--kg-card-begin: markdown-->

Se placer sur la branche qui reçoit la fusion (master par exemple)

```
$ git checkout master

```

Fusionner la branche dev vers master

```
$ git merge dev

```
<!--kg-card-end: markdown-->

Tous les commits qui ont été rajouté sur la branche  "dev" vont ainsi se retrouver sur la branche "master".

### 4- Ajouter des versions grâce aux tags

Lors de la création d'un projet, nous utilisons un système de version qui est en général sous ce format X.Y.Z ( Ex: 1.0.1) où les valeurs de X, Y ou Z correspondent à une évolution d'une certaine catégorie de fonctionnalité de notre projet. Plus de détails sur ce format avec [cette page](https://semver.org/)  qui décrit le semantic versionning.   
C'est en anglais je sais, mais dis toi que moi aussi j'aurai pu ecrire ce document en anglais.

Une version n'est rien d'autre qu'un commit que nous allons nommer au format X.Y.Z. Ci dessous les commandes pour créer un tag ou le manipuler:

<!--kg-card-begin: markdown-->

Se placer au niveau du commit à nommer.

```
$ git checkout 224916aef8c1776778eb79c0537365d4989d374c

```

Ajouter un tag avec un message

```
git tag -a 1.4.0 -m "my version 1.4.0"

```

Ajouter un tag sans message

```
git tag 1.4.0 

```

Afficher les tags

```
git tag 

```

Supprimer un tag

```
git tag -d 1.4.0 

```

Accèder à un tag specifique:

```
git checkout 1.4.0

```
<!--kg-card-end: markdown-->

Ces tags sont ainsi beaucoup plus facile à manipuler que les commits et permettent de livrer une version spécifique de notre projet.

## II - Rappel des commandes de base:

Ci-dessous les commandes à retenir pour manipuler votre "repository git".

<!--kg-card-begin: markdown-->
### 1- Le rapository git

- 
##### Creation

```
$ git init

```

- 
##### Suppression du repository

```
$ rm -r .git

```

### 2 - Les branches

- 
##### Création d'une branche

```
$ git checkout -b nom_branche 

```

- 
##### Liste des branches

```
$ git branch 

```

- 
##### Accèder à une branche

```
$ git checkout nom_branche 

```

- 
##### Fusionner 2 branches

```
$ git checkout nom_branche_destination
$ git merge nom_branche_source

```

- 
##### Supprimer une branche

```
$ git branch -D nom_branch 

```

### 3 - Les commits

- 
##### Ajouter un ou des fichiers au prochain commit

```
$ git add nom_fichier_1 [nom_fichier_1 .... nom_fichier_X]

```

- 
##### Ajouter tous les fichiers

```
$ git add .

```

- 
##### Créer un commit

```
$ git commit -m "Message du commit"

```

- 
##### Modifier le commit précedent après avoir rajouté un fichier

```
$ git commit --amend 

```

- 
##### Liste de commit

```
$ git log
$ git log --oneline

```

- 
##### Annuler les modifications effectué lors d'un commit

```
$ git revert IDENTIFIANT_COMMIT

```

### 4 - Les tags

- 
##### Créer un tag

```
$ git tag -a nom_tag IDENTIFIANT_COMMIT -m "Message du tag"

```

- 
##### Créer un tag sans le message

```
$ git tag nom_tag IDENTIFIANT_COMMIT 

```

- 
##### Afficher les details d'un tag

```
$ git show nom_tag 

```

- 
##### Afficher la liste des tags

```
$ git tag

```

- 
##### Accèder à un tag

```
$ git checkout nom_tag

```

- 
##### Supprimer un tag

```
$ git tag -d nom_tag

```
<!--kg-card-end: markdown-->

Pour la suite de ces tutorials qui portent sur Git, nous parlerons d'un outils GitFlow qui permet de faciliter la création et la fusion des branches au niveau d'un projet. Retrouvez cet article sur [ce lien](https://thanos.savoirguinee.com/git-gitflow/).