Ministère de l’Enseignement Supérieur, de la Recherche Scientifique et de
l’Innovation
(MESRSI)
-----------------
Secrétariat Général
---------------------
Université Nazi BONI (UNB)
-------------------------
École Supérieure d’Informatique (ESI)
-------------------------------
Master en Informatique
Option : Réseaux et Systèmes
Spécialité : Cybersécurité
PROJET
MODULE : Administration et gestion des réseaux
THEME : « GIT »
Présenté par
SANOU François d’Assise
Enseignant :
Dr. YELEMOU
Enseignant-chercheur à l’ESI
Année universitaire : 2020-2021
SOMMAIRE
INTRODUCTION .................................................................................................................................. 2
I. La supervision réseau .................................................................................................................... 4
II. La gestion des changements .......................................................................................................... 4
III. Vocabulaire dans Git ................................................................................................................ 4
IV. Analyse comparée de Git, Subversion et CVS ........................................................................... 6
V. Déploiement ................................................................................................................................. 7
1. Installation................................................................................................................................ 7
2. Installation à partir des sources ................................................................................................. 7
3. Quelques commandes ............................................................................................................... 8
CONCLUSION ..................................................................................................................................... 10
REFERENCES BIBLIOGRAPHIQUES ET WEBBOGRAPHIES ..................................................... 11
SANOU FRANCOIS DASSISE 1
Liste des figures
Figure 1 : Illustration commit .................................................................................................................. 5
Figure 2 : Illustration branche ................................................................................................................. 5
Figure 3 : Illustration merge .................................................................................................................... 5
Figure 4 : Illustration tag ......................................................................................................................... 6
SANOU FRANCOIS DASSISE 2
INTRODUCTION
Git est un projet open source, initialement développé par Linus Torvald en 2005. C’est un
logiciel de gestion décentralisée de version permettant de gérer un ou des fichiers qui évoluent
avec le temps. Il permet de retracer l’origine de chaque modification, de rétablir des versions
précédentes et permet l’intégration de modifications effectuées en parallèle.
SANOU FRANCOIS DASSISE 3
I. La supervision réseau
La gestion d'un système informatique est un travail permanent. Ainsi le service informatique
ou l'administrateur réseaux doit savoir à tout moment l'état des équipements et des services
sur les réseaux. C'est pour cela qu'on a recourt à une technique de suivi qui est la
supervision, qui permet de surveiller, d'analyser, de rapporter et d'alerter les
fonctionnements normaux et anormaux des systèmes informatiques.
Plus particulière au niveau de la gestion des changements nous avons git, un logiciel de contrôle
de version, comme subversion et CVS.
Il va permettre de travailler tout en gardant une trace des modifications apportées
successivement, et de retrouver ainsi l’état antérieur de ses données.
II. La gestion des changements
Le principe d’un gestionnaire de version est qu’il gère un document comme “une
base” à laquelle est ajouté une suite de modifications.
Il y a un dépôt commun et les contributeurs travaillent sur des versions locales.
Lorsqu’un contributeur a réalisé une modification “qui fait sens” il l’envoie vers le
dépôt, qui en garde la trace.
Plutôt que de consacrer un seul emplacement pour l'historique complet des versions du logiciel
comme c'était souvent le cas dans les systèmes de contrôle de version ayant fait leur temps,
comme CVS et Subversion (également connu sous le nom de SVN), dans Git, chaque copie de
travail du code est également un dépôt qui contient l'historique complet de tous les changements.
En plus d'être décentralisé, Git a été conçu pour répondre à trois objectifs : performances,
sécurité et flexibilité.
Les performances brutes de Git sont très élevées par rapport à de nombreuses alternatives.
Commiter de nouveaux changements, créer des branches, faire des merges et comparer les
anciennes versions… Toutes ces actions sont optimisées pour les performances. Les algorithmes
implémentés dans Git tirent parti de connaissances approfondies sur les attributs courants des
arborescences de fichiers de code source réel, la manière dont ils sont modifiés au fil du temps et
les schémas d'accès.
III. Vocabulaire dans Git
un commit
La référence qui permet de retrouver l’état du projet à un moment donné dans le temps. Il peut
être vu comme un snapshot ou une photo instantannée de l’ensemble du projet à un moment dans
le temps. Il inclut chaque fichier et dossier, avec l’ensemble des modifications qui ont été
enregistrées dans l’historique du projet.
Chaque commit a un identifiant généré avec l’algorithme de hachage SHA-1 passé sur l’entier du
contenu du commit (tous les fichiers, la date, le nom et email du commiter, le message du commit
et l’identifiant du précédent commit). Cet identifiant ressemble à ceci :
ecd91c9baab1e7cab9dce65fa9dbefdaf13cd34d et est généralement résumé aux 7 premiers
caractères : ecd91c9.
SANOU FRANCOIS DASSISE 4
Figure 1 : Illustration commit
une branche
Le chemin qui relie plusieurs commits. Elle est signifiée par une référence qui est posée sur le
commit le plus récent de celle-ci.Commit
La branche par défaut se nomme master et est destinée, par convention, à être la branche principale
du projet.
On sera intéressé à créer de nouvelles branches, lorsqu’on souhaitera introduire de nouvelle choses
dans le projet, sans pour autant bloquer le développement global du projet. Ainsi le
développement d’une nouvelle fonctionnalité feature1 pourra prendre un peu de temps et
n’empêchera pas la branche principale d’évoluer. Pareil pour la correction d’un bug bugfix1,
comme le montre le schéma ci-dessous.
Figure 2 : Illustration branche
un merge
Le commit que l’on fait lorsque 2 branches sont finalement rassemblées en une seule. Cela signifie
que les modifications effectuées dans chaque branche sont fusionnées pour donner un code source
qui contient l’assemblage des 2.
Figure 3 : Illustration merge
SANOU FRANCOIS DASSISE 5
un tag
L’étiquette que l’on peut ajouter sur un commit signifiant généralement une version majeure. Elle
sert ensuite de référence pour repérer les commits significatifs.
Figure 4 : Illustration tag
IV. Analyse comparée de Git, Subversion et CVS
SVN est un système de contrôle de version centralisé. Vous avez un serveur qui contient
votre référentiel de code. Vous pouvez en extraire du code sur votre ordinateur local, y apporter
des modifications locales, puis les renvoyer dans le référentiel central.
Votre copie du code correspond généralement à ce que vous avez extrait et à la dernière version.
De nombreuses opérations nécessiteront une connexion réseau au référentiel central.
Git est un système de contrôle de version décentralisé. Chaque participant a un clone de
l’ensemble du référentiel. Il est utilisé pour suivre les changements dans le code source.
La plupart des opérations ne nécessitent pas de connexion réseau, car elles ne travaillent que sur
votre clone du référentiel.
La principale différence entre Git et CVS est que CVS est un système de contrôle de version
centralisé, tandis que Git est distribué.
Tableau 1 : Comparaison Git, CVS, SVN
CVS SVN Git
Versionning Centralisé Centralisé Décentralisé
Dépôt Dépôt plus Un dépôt central dans Des copies de dépôt,
compliqué dans lequel les copies de présentes localement, dans
CVSROOT travail sont créées lesquelles il est possible de
travailler
Droit d’accès Basé sur le Basé sur le chemin Pour le répertoire complet
fichier
Suivi des Enregistre des Enregistre des données Enregistre des données
modifications données
Journal de Uniquement Complet seulement Le dépôt et les copies de
modifications des sur les fichiers dans le dépôt. Les travail contiennent
données du projet copies de travail ne l’historique complet.
contiennent que la
version la plus récente.
Connectivité au Nécessaire Pour tous les accès Nécessaire seulement pour
réseau seulement pour réaliser une synchronisation
une
synchronisation
SANOU FRANCOIS DASSISE 6
V. Déploiement
1. Installation
Il existe deux manières d’installer git sur linux, à partir des dépôts sur internet ou
directement en ligne de commande avec la commande
$sudo apt-get install git
Configuration de Git:
❑ $ git config –global user.name “dassise”
❑ $ git config –global user.email
[email protected]Vérifier la configuration de Git:
❑ $ git config –list
❑ $ git config
2. Installation à partir des sources
Avant de commencer, nous devons installer le logiciel dont Git dépend. Tout cela est
disponible dans les référentiels par défaut, afin que nous puissions mettre à jour notre index local
de paquets et ensuite installer les paquets correspondants.
• sudo apt update
• sudo apt install libz-dev libssl-dev libcurl4-gnutls-dev libexpat1-
dev gettext cmake gcc
Une fois que nous avons installé les dépendances nécessaires, nous allons créer un répertoire
temporaire et se déplacer dans celui-ci. C'est là que nous téléchargerons notre tarball Git.
• mkdir tmp
• cd /tmp
Depuis le site web du projet Git, nous pouvons naviguer vers la liste des tarballs disponible à
l'adresse https://mirrors.edge.kernel.org/pub/software/scm/git/ et télécharger la version
souhaitée. Au moment où nous écrivons ces lignes, la version la plus récente est la 2.26.2, nous la
téléchargerons donc à des fins de démonstration. Nous utiliserons curl et sortirons le fichier que
nous téléchargerons sur git.tar.gz
• curl -o git.tar.gz
https://mirrors.edge.kernel.org/pub/software/scm/git/git-
2.26.2.tar.gz
Décompressez le fichier tarball compressé :
• tar -zxf git.tar.gz
SANOU FRANCOIS DASSISE 7
Ensuite, se déplacer dans le nouveau répertoire Git :
• cd git-*
Maintenant, nous pouvons créer le paquet et l'installer en tapant ces deux commandes :
• make prefix=/usr/local all
• sudo make prefix=/usr/local install
Maintenant, remplacez le processus shell pour que la version de Git que nous venons d'installer
soit utilisée :
• exec bash
Une fois cela terminé, nous pouvons vérifier que l’installation s’est bien déroulé :
• git --version
Output
git version 2.26.2
3. Quelques commandes
configuration : config
initialisation : init, clone
travail local : add, remove, rename, status, diff, commit, show
gérer le graphe : merge, rebase, squash, cherry-pick, revert, checkout (se déplacer)
diversifier le développement : branch, merge
référencer : tag
communiquer avec d'autres repositories : push, pull, fetch
revenir en arrière : reflog, reset
doc : help
git add
Lorsque vous créez un fichier dans votre version de travail, celui-ci n’est pas
automatiquement intégré aux éléments gérer par le dépôt git, il faut pour cela
utiliser la commande :
git add nomDuFichier
Pour ajouter tout le répertoire courant (par exemple pour intégrer toutes nos
classes créés) on utilisera :
git add .
Il faut encore commit et push pour les mettre sur le répertoire distant
git commit
La commande
git commit “Message du commit”
permet de déposer les modification de la version de travail sur la version locale.
SANOU FRANCOIS DASSISE 8
Les messages sont obligatoires, ils indiquent le contenu des modifications. Ils
doivent être compréhensibles et informatifs, souvent dans des gros projets des
normes sont données sur ce qu’ils doivent contenir
git push
la commande git push permet de pousser (la branche actuelle de) le local vers le
remote :
git applique alors successivement tous les commit au remote.
C’est la commande qui “valide” nos changement, il ne faut pas l’oublier !
Il y aura un soucis si notre copie n’est pas à jour ! Il est possible mais fortement
déconseillé de faire un force push pour écraser la copie distante par notre copie
locale. Il faudra surtout commencer par faire un git fetch.
git fetch, git checkout, git pull
La commande git fetch permet de mettre à jour notre dépôt local en récupérant l’
état courant qui remote. La commande git checkout permet de les appliquer à la
copie de travail (et donc de les voir).
La commande git pull fait les deux à la fois.
git status
La commande git status vous permet de connaître l’état courant de vos copies
locales (les modifications ont-elles été commitées, les fichiers ajoutés, les commit
pushé).
Le merge
Le merge est l’action de fusionner deux éléments : on ajoute les modifications de
l’un à l’autre. L’opération est, on l'espère, dans la plupart des cas transparente
mais des conflits peuvent apparaître : deux modifications sont vues comme
incompatibles (usuellement : on a touché à la même ligne de code). Il faut alors
résoudre le conflit, c’est à dire choisir/écrire à la main la version que l’on veut
garder pour chaque conflit.
SANOU FRANCOIS DASSISE 9
CONCLUSION
Avant d'utiliser git pour votre développement, il est bon de planifier notre flux de travail.
La décision concernant le flux de travail est généralement basée sur la taille et l'échelle du projet.
Afin d'acquérir une compréhension de base de git, un flux de travail simple, avec une seule
branche, suffira. Par défaut, la première branche de tout projet git est appelée "master".
SANOU FRANCOIS DASSISE 10
REFERENCES BIBLIOGRAPHIQUES ET WEBBOGRAPHIES
[1] Cours du module Administration et gestion des réseaux
[2] https://www.digitalocean.com/community/tutorials/how-to-use-git-effectively
[3] https://www.tuteurs.ens.fr/logiciels/git/
[4] https://www.digitalocean.com/community/tutorials/how-to-install-git-on-ubuntu-20-04-fr
[5] https://mirrors.edge.kernel.org/pub/software/scm/git/docs/user-manual.html
[6] https://doc.ubuntu-fr.org/git
[7] https://github.com/
SANOU FRANCOIS DASSISE 11
