index.md 11 KB


title: "Tutoriel git" output:

toc: true


Introduction

À qui s'adresse ce tutoriel ?

  • Objectif du tutoriel : apprendre à utiliser le système git et le serveur gogs mis en place par le SCOSI.
  • Pré-requis : utilisation basique d'un ordinateur.
  • Public visé : les développeurs au sens large (code latex, python, matlab, R, java...)

Qu'est-ce-que git et gogs ?

  • git : système de journalisation de code source décentralisé (alternative à mercurial, subversion, CVS...)
  • gogs : service d'hébergement de code source utilisable avec git (alternative à github, bitbucket...)

Dans quels cas utiliser git/gogs ?

git est conçu pour manipuler principalement des fichiers au format texte (code source, code latex, fichier CSV...). Il permet notamment :

  • journalisation
  • sauvegarde distante
  • synchronisation
  • travail en équipe
  • projets publics ou privés :

Dans quels cas ne pas utiliser git/gogs ?

  • édition collaborative en temps-réel -> sharelatex
  • partage de fichiers -> serveur ftp, http...
  • fichiers dans un format non textuel (jpg, word, excel...) -> dropbox

Concepts de base

Notion de "version" (commit)

Un "projet git" contient l'historique de toutes les modifications de chaque fichier. On appelle "commit" un état sauvegardé de ces modifications (une version du projet en quelque sorte).

Généralement, on modifie le projet à partir de la version précédente et ansi de suite; ce qui correspond à une succession de commits :

Mais on peut également effectuer des modifications en parallèles. On appelle ça des branches :

On peut ensuite rassembler ces modifications en fusionnant les branches :

Notion de dépôt (repository)

On appelle dépôt l'ensemble des fichiers de notre "projet git", avec l'historique des commits.

Un dépôt peut être dupliqué sur différentes machines, pour synchroniser les données ou pour travailler en équipe.

Dans l'ancien temps des années 2000, on avait un dépôt principal distant que l'on synchronisait ou modifiait via des copies locales partielles (subversion, CVS...) :

Aujourd'hui, on utilise plutôt un système de dépôts décentralisés (git, mercurial...). Avec ce système, tous les dépôts sont identiques et peuvent se synchroniser entre eux :

Généralement, on garde tout de même un dépôt sur un serveur distant accessible en permanence (serveur gogs, github...).


Installation et configuration

Pour utiliser git, il vous faut une connexion internet et un client git.

Installation sous Linux

La plupart des systèmes Linux modernes propose le client git dans leur système de paquets. Par exemple, sur les Linux basés Debian, il suffit de lancer la commande console :

sudo apt-get install git

Il existe également des clients graphiques : gitg, giggle, qgit, gitk, git-gui...

Installation sous Windows ou Mac

Télécharger et installer le client git pour Windows ou le client git pour Mac.

Configuration

Après avoir installé le client git, il faut configurer le nom et l'adresse e-mail de l'utilisateur (à faire une seule). Par exemple, en tapant les commandes consoles :

$ git config --global user.name "Julien Dehos"
$ git config --global user.email dehos@nimpe.org

On peut également configurer l'éditeur de texte et le proxy que le client git doit utiliser. Par exemple, en tapant les commandes consoles :

$ git config --global core.editor emacs
$ git config --global http.proxy http://user:pass@proxyhost:proxyport

ou alors en ajoutant des variables d'environnement (par exemple, dans le .bashrc):

export EDITOR=emacs
export http_proxy=http://user:pass@proxyhost:proxyport

Obtenir de l'aide

Aide générale sur git :

$ git help 

Aide sur une commande git :

$ git help <commande git>

Voir également la section références.

Exercice

Installez et configurez le client git sur votre machine. Vérifiez que votre client git peut accéder à l'extérieur, par exemple en récupérant le dépôt distant https://github.com/juliendehos/invinoveritas :


Dépôt local (journaliser un projet)

L'élément de base d'un projet git est le dépôt. Il s'agit simplement d'un dossier classique que l'on demande à git de versionner.

Initialiser un dépôt

Allez dans le dossier à versionner puis lancez la commande git init.

Git créé alors un dossier .git pour y stocker ses metadonnées. Si vous ne voulez plus versionner votre dossier, il suffit de supprimer ce dossier. Le reste du temps, ne touchez pas à ce dossier si vous n'êtes pas absolument sûr(e) de ce que vous faites.

Afficher l'état d'un dépôt

La commande git status affiche l'état courant du dépôt : nouveaux fichiers, fichiers modifiés, fichiers supprimés. Cette commande est très sûre; elle ne peut rien casser. N'hésitez donc pas à la lancer pour voir où vous en êtes.

Ajouter des fichiers dans le dépôt

Il faut indiquer explicitement les fichiers que git doit journaliser.

Par exemple, imaginons qu'on ouvre un nouveau fichier rapport_01.tex dans notre projet.

On y écrit du code latex.

Et on affiche l'état du dépôt.

Git nous indique que le fichier rapport_01.tex existe bien dans le dossier (ainsi qu'un fichier de sauvegarde), mais qu'il ne fait pas partie du dépôt.

Pour ajouter un fichier au dépôt, il faut utiliser la commande git add.

Ceci indique que git doit prendre en compte le fichier lors des prochains commits (journalisation), ce qu'on peut vérifier avec un git status.

Valider les modifications (commit)

Après avoir ajouté, modifié ou supprimé des fichiers, on peut valider les modifications, c'est-à-dire sauvegarder un état du projet (commit). Encore une fois, seuls les fichiers qui ont été ajoutés au projet (avec git add) sont pris en compte.

La commande à lancer pour valider toutes les modifications est git commit -a.

Git lance alors l'éditeur de texte pour le message de commit. Le message est pré-rempli avec des informations concernant le commit. Ces informations vous permettent de vérifier que le commit correspond bien à ce que vous voulez mais ne feront pas partie du message final.

Écrivez un message expliquant rapidement les modifications que vous êtes en train de valider puis enregistrez et quittez.

Git créé alors le nouveau commit, qui valide ici le fichier rapport_01.tex.

Vous pouvez le vérifier avec un git status.

Fichiers autogénérés et .gitignore

Git est très pratique pour gérer des fichiers textes que l'on modifie régulièrement. En revanche, il n'est pas adapté pour gérer des fichiers dans un format non-textuel (images, données compressées, documents word...). Si on ajoute un tel fichier dans le dépôt alors à chaque modification, git stockera une nouvelle copie complète (au lieu de stocker uniquement les lignes qui ont changé), ce qui est inefficace.

D'autre part, il est inutile de versionner les fichiers autogénérés (créés automatiquement lors de la compilation du code). Par exemple, si on compile le code latex de notre projet :

des fichiers intermédiaires sont créés et apparaissent lors des git status :

Pour les ignorer, il suffit d'ajouter un fichier .gitignore et d'y indiquer les fichiers à ignorer.

Ainsi, il n'apparaissent plus lors des git status.

Il est de pratique courante d'ajouter le .gitignore au dépôt, ainsi qu'un fichier README.md qui servira de page d'accueil (au format markdown).

Renommer et supprimer des fichiers

La commande git mv permet de renommer un fichier versionné. Il ne faut pas utiliser la commande système (mv) car dans ce cas git ne saura pas qu'il faut renommer le fichier (il pensera que le fichier manque et essaiera de le recréer).

De même, la commande git rm permet de supprimer un fichier versionné.

Afficher l'historique des commits

Faisons d'abord une modification "commitée" puis une autre non commitée.

La commande git log permet d'afficher l'historique des commits.

On peut également le voir avec un client graphique graphique comme gitg.

Le "unstaged" correspond aux modifications courantes non commitées.

Pour représenter l'historique d'un dépôt, on utilise souvent un graphe où les noeuds représentent les commits. On ajoute également l'étiquette "master", qui indique le dernier commit principal, et l'étiquette "HEAD", qui indique l'état courant du dépôt.

Ainsi, un git commit créé un commit à partir de l'état pointé par HEAD et fait pointer master (et HEAD) sur ce nouveau commit.

Supprimer les modifications courantes

La commande git checkout -- . supprime les modifications courantes. Le dépôt revient alors dans l'état du dernier commit (master).

Revenir à un commit précédent (sans suppression)

La commande git checkout 7b3... permet de revenir au commit "7b3...". On passe ainsi dans un mode "détaché" (HEAD ne pointe plus sur un commit terminal).

Au lieu d'utiliser le numéro de commit, on peut également utiliser les étiquettes. Par exemple, git checkout master pour aller au dernier commit principal ou git checkout HEAD~1 pour aller au commit précédent le commit courant.

Marquer un commit

La commande git tag permet de nommer des commits pour, par exemple, fixer une version ou pouvoir revenir plus facilement sur un commit particulier.

Supprimer des commits précédents

La commande git reset 073... revient au commit "073..." et annule tous les commits suivant (jusqu'à l'ancien master). Les modifications correspondants à ces commits sont conservées dans l'état courant (non commité).

Exercice

TODO


Dépôt distant (sauvegarder un projet sur un serveur)

TODO

nouveau projet

projet existant

Exercice


Branches (travailler en équipe)

TODO

Exercice


Forks (collaborer avec d'autres projets)

Exercice


Références


Dernière mise à jour : 2016-03-05