Présentation du réseau ISI

Le réseau Informatique Scientifique de l’IRD (ISI)

Pour nous rejoindre : https://copnumeriquescientifique.ird.fr/

Contact : isi-contact@ird.fr

Lien : https://www.ird.fr/isi

Calendrier de formation ISI 2025

Qui sommes-nous ?

Benjamin Cuer (TransVIHMI)
Biostatisticien

Dominique Lamonica (AMAP)
Statisticienne

Crédits

Création du support pédagogique en 2025 par:

Benjamin Cuer

Ces slides ont été inspirées de

Introduction sur la formation

La formation et son déroulement

Objectif de la formation : apprendre à utiliser le gestionnaire de versions Git et la forge logicielle IRD en tant qu’utilisateur ou utilisatrice de R et RStudio

Cette formation s’adresse à des personnes qui découvrent le contrôle de version.

Programme de la formation

Horaire	Session / Activité
09h15 - 09h30	Présentation réseau ISI et introduction
09h30 - 10h45	Installations, pourquoi Git et les bases
10h45 - 11h15	Pause
11h15 - 12h45	Premiers pas avec Git
12h45 - 13h45	Déjeuner
13h45 - 15h00	Travail collaboratif, Forge IRD, exercice pratique

Les diapos seront mises à disposition

Contenu de la formation

La formation se concentre sur l’utilisation de R via RStudio. L’utilisation d’autres IDE n’est donc pas incluse
Ce support ne couvre pas tous les aspects du contrôle de version ni toutes les commandes Git.
Le travail collaboratif et la résolution de conflits ne seront pas abordés

Installations et pré-requis

Installation du logiciel Git

https://git-scm.com/install/

Console R

IDE RStudio

Source : https://docs.posit.co/ide/user/ide/get-started/

Exemples d’autres IDE

Connaissez-vous / utilisez-vous d’autres IDE ?

Exemples d’autres IDE : VS Code

Exemples d’autres IDE : Positron

Source : https://positron.posit.co/layout.html

Pourquoi Git ?

Versionner ses fichiers

Versionner, c’est suivre l’évolution d’un fichier ou d’un projet dans le temps, en enregistrant chaque modification de manière organisée.

Pourquoi versionner ses fichiers ?

Quelle est la version à utiliser pour l’analyse ?

Sans versionnement : on multiplie les fichiers
Risque de perdre des modifications, de confondre les versions, ou d’écraser du travail

Le versioning permet :

Revenir à une version antérieure facilement
Obtenir de la traçabilité : on sait qui a changé quoi, quand, comment et pourquoi
Travailler collectivement sur les mêmes programmes en même temps

Système de gestionnaire de versions

What are the primary version control systems you use?

Source : https://survey.stackoverflow.co/2022/#version-control-version-control-system

Git est parmi les logiciels de versioning existant les plus populaires.

Le versioning se justifie même quand on est tout seul sur un projet !

Git, c’est quoi ?

Git, c’est un système de contrôle de version (Version Control System).

Créé en 2005 par Linus Torvalds (aussi créateur de Linux)
Gratuit et open source
Fonctionne en ligne de commande, mais aussi intégré à RStudio

Comment utiliser Git ?

Interface graphique (IDE)

Via l’interface d’un IDE (ex : RStudio)
Aspects visuels (approche simple et guidée)
Onglets cliquables pour certaines commandes

Terminal (ligne de commande)

Utilisation directe de commandes qui commencent par git dans le terminal
Contrôle complet et opérations avancées

Les bases de Git

Qu’est-ce qu’on versionne ?

Le versionnement concerne principalement les fichiers texte.

Par exemple :

Programmes (R, Python, SAS, etc)
Fichiers Quarto (.qmd) ou Rmarkdown (.rmd)
De la documentation (texte (.txt) ou Markdown (.md))
Fichiers de configuration (ex. YAML)
etc

Et qu’est-ce qu’on ne versionne pas ?

Tous les autres fichiers (Par exemple : Documents Word, PDF, Power Point, etc)

Pour exclure ces fichiers, on utilise un fichier .gitignore. C’est un fichier texte qui liste les fichiers et dossiers à ignorer :

des fichiers spécifiques (exemple data.csv)
des dossiers entiers (data/)
des extensions (ex. *.xlsx)
etc

Exemple d’un fichier `.gitignore` ouvert avec RStudio

Raconter l’histoire de votre projet

Git enregistre des instantanés (snapshots) de votre projet dans un repository.

Raconter l’histoire de votre projet

Git enregistre des instantanés (snapshots) de votre projet dans un repository.

Chaque instantané correspond à un commit, qui contient :

Auteur de la modification
Date et heure de la modification
Message décrivant le changement

Versionner et voyager dans le temps

Git permet de revenir facilement à une version antérieure du projet.

Une seule version physique du fichier
Toutes les anciennes versions sont stockées dans l’historique
Chaque commit possède un identifiant unique (hash)

Stockage des différentes versions d’un fichier

Chaque fois que vous effectuez un commit dans Git, il prend un snapshot du contenu actuel du projet et enregistre une référence à ce snapshot. Si un fichier n’a pas changé depuis le commit précédent, Git ne le stocke pas à nouveau, mais conserve simplement une référence au fichier déjà enregistré.

Commit

Action de figer l’état du dépôt sous forme de snapshot

Commit

Chaque commit sécurise le projet.
Le commit conserve un état précis des fichiers suivis et permet de revenir à cet état si besoin.

Commit

On peut revenir en arrière
Les commits forment un historique consultable et réversible, facilitant la gestion des versions.

Les zones de Git

Fonctionnement général

Zones utilisées par Git :

Working directory : répertoire de travail
Staging area ou Index : zone tampon qui permet de sélectionner quels fichiers seront inclus dans le prochain commit
Local repository : dépôt Git présent en local et en caché (dans le dossier .git)
Remote repository : dépôt distant hébergé sur une forge.

Fonctionnement général - Commandes

Commandes Git essentielles

git add : ajoute les modifications dans l’index.
git commit : enregistre définitivement les modifications indexées.
git push : envoie les commits vers le dépôt distant.
git pull : récupère et intègre les changements du dépôt distant.
git checkout : permet de naviguer dans l’historique ou de changer de branche.

Une seconde illustration

Cheat Sheet de Git

Premiers pas de Git avec RStudio

Mais d’abord… les projets R !

Pré-requis

Pour pouvoir utiliser correctement Git avec l’IDE RStudio, il convient d’utiliser le mode projet. Avant d’utiliser Git, assurez-vous que le projet R (.Rproj) est créé et ouvert dans RStudio.

Les projets R sont des fichiers spéciaux avec l’extension .Rproj.
Il est recommandé de toujours structurer son code avec un .Rproj (même pour des petits scripts !)
Le projet R permet de regrouper facilement données, code et output pour un même projet.

Démonstration en live

Création d’un nouveau projet R
Choisir d’utiliser Git pour le versionnement

Exercice 1

Exercice - Initialiser un dossier local en dépôt Git avec RStudio

Créer un nouveau projet R appelé “formation-git”
Regarder attentivement les fenêtres de votre RStudio. Observez-vous des changements par rapport à l’affichage habituel ?
Si ce n’est pas fait dans votre configuration, activez la case “montrer les fichiers cachés” (More → Show Hidden File). Que voyez-vous apparaître ?

Projet R avec suivi Git en local

Création d’un projet R versionné avec Git

Dans RStudio : File → New Project, puis suivre les étapes suivantes :

Un projet R .Rproj est ainsi créé et une nouvelle fenêtre s’ouvre dans une nouvelle session. Cela peut prendre quelques minutes pour s’ouvrir.

Tip

Pour mes projets R, je coche l’option Open in new session systématiquement pour être sûr d’avoir un environnement neuf et propre.

Aperçu d’un projet R versionné avec Git

Nouvelles options : de nouvelles options apparaissent dans l’IDE de RStudio.
Versionnage : le fichier .git permet de savoir que le projet R est versionné avec Git.
Affichage des fichiers cachés : More → Show Hidden File.
Git : possibilité d’utiliser les commandes Git depuis le Terminal de la session.

Ajouter des fichiers dans la Staging Area

Objectif : sélectionner les fichiers que Git doit suivre et préparer pour le prochain commit.

Avec RStudio

Ajouter un fichier
Cocher la case dans l’onglet Git.
Ajouter plusieurs fichiers
Cocher plusieurs cases en une seule opération.

En ligne de commande

git add <nom_fichier>
Ajoute un seul fichier.
git add .
Ajoute tous les fichiers nouveaux/modifiés.

États des fichiers avec RStudio

L’onglet Git fournit des repères visuels sur l’état de chaque fichier.

Added : fichier ajouté à la staging area/Index
Deleted : fichier supprimé du working directory
Modified : contenu du fichier modifié
Renamed : fichier renommé
Untracked : fichier nouveau, jamais vu par Git

Avec RStudio

Terminal

git status

Principales commandes de l’onglet Git dans RStudio

Diff : comparer 2 versions d’un fichier ;
Commit : valider les modifications d’un ou plusieurs fichier(s) ;
History : consulter l’historique des modifications du projet ;
More : ajouter des fichiers à ignorer ou revenir en arrière ou utiliser le terminal ;
New Branch : créer une nouvelle branche dans le dépôt Git ;
Pull : récupérer sur le dépôt distant les modifications apportées au projet par d’autres contributeurs ;
Push : partager sur le dépôt distant les modifications que vous avez apportées au projet.

D’autres commandes existent : Cheatsheet Git and GitHub with RStudio

Comment faire un commit avec RStudio ?

Après avoir ajouté les fichiers modifiés à la staging area, il est temps de committer les changements, c’est-à-dire prendre un snapshot des fichiers suivis.

Dans la fenêtre qui s’ouvre :

Sélectionner les fichiers à inclure dans le commit
Rédiger un message clair et explicite
Puis cliquer sur Commit pour valider les changements.

Commiter depuis le terminal

La commande git commit -m "message" permet de faire le commit et de renseigner directement le message associé.

git commit -m "fix: ajout fichier odt dans .gitignore"

Commit en pratique

Bonnes pratiques pour un commit

Ne changer qu’une seule chose à la fois
Fournir un message court, clair et explicite décrivant le changement
S’écrit à l’impératif

Exemples :

feat: ajoute la fonction de calcul des moyennes
fix: corrige le chargement des données

💡 Astuce : pensez à vos commits comme à un journal clair de votre travail.

Commit en pratique (suite)

Mauvais	Pourquoi	Meilleur
`update`	trop vague	`update: ajoute le script de préparation`
`fix`	pas de contexte	`fix: corrige le nom de variable prix_total`
`ok`	inutile	`fix: ajuste la fonction moyenne`

Conseils pour bien nommer ses commits

Erreur courante des débutants

Programmer pendant des heures/jours/semaines
Ajouter toutes les modifications à la staging area avec git add .
Puis commiter tout d’un coup

Démonstration Live

Suivre des fichiers (staging area)
Faire un commit
Fichier .gitignore

Exercice 2

Exercice - Premier commit

Ajouter les nouveaux fichiers à la staging area / Index et faire un premier commit avec le message Initial commit
Créer et enregistrer un premier script hello.R à la racine de votre projet :

print("hello world")

Quel est le statut de ce fichier ?
Ajouter ce script à la staging area / Index et faire un second commit avec le message feat: ajout script hello.R.

Afficher les différences (onglet Diff)

Le code supprimé s’affiche en rouge
Le code ajouté s’affiche en vert

Équivalent en ligne de commande :
- git diff pour les fichiers non ajoutés à la staging area
- git diff --staged pour les fichiers déjà ajoutés

Tip

Le terminal permet d’aller plus loin dans l’observation des différences, par exemple en comparant 2 commits :

git diff <commit1> <commit2>

Onglet Historique des modifications

équivalent en ligne de commande : git log

Ignorer certains fichiers du suivi (Onglet Git ignore)

Il existe des exemples / modèles pour le gitignore à adapter en fonction de son besoin https://github.com/github/gitignore/blob/main/R.gitignore

Exercice 3

Exercice - Pratiquer les opérations Git de base

Ajouter un fichier de données tableur (ex. data.csv) dans votre projet.
Observer l’onglet Git : que voyez-vous dans l’onglet Git de RStudio ?
Modifier .gitignore pour ignorer le fichier de données
Ajouter et committer la modification de .gitignore avec un message explicite (ex. ajouter data.csv au .gitignore).
Créer un script analyse.R. Par exemple :

# Script pour importer et analyser les données
library(dplyr)


Attaching package: 'dplyr'

The following objects are masked from 'package:stats':

    filter, lag

The following objects are masked from 'package:base':

    intersect, setdiff, setequal, union

Ajouter et committer le script avec le message feat: ajouter script analyse.R.
Consulter l’historique du projet (dans RStudio : onglet Git → History)

Travail collaboratif avec Git

Partager du code avec d’autres personnes

Imagine…

Tu écris du code, et tu m’envoies par email pour relecture un fichier code.R
J’ajoute des commentaires ou des changements, et je te renvoie par mail un fichier code_Benjamin_comments.R
Tu corriges en ajoutant du code, et tu me demande de vérifier. Tu m’envoies par email un fichier code_v2.R
J’ajoute des commentaires ou des changements, et je te renvoie par mail un fichier code_v2_Benjamin_comments.R
etc

Versionner et partager du code

Git : un outil de gestion de versions gratuit et open source que vous installez sur votre ordinateur portable.

Forges comme GitHub, GitLab, Bitbucket : un service d’hébergement en ligne pour des dépôts Git, permettant à des personnes situées à différents endroits de collaborer sur le code.

Partager son code avec le monde

Les dépôts GitHub peuvent être privés ou publics
- Développement en privé ou en public
- Rendre public lors de la soumission à une revue
Ajouter un fichier licence pour indiquer comment le code peut être utilisé par d’autres
Choisir les fichiers qu’on ne veut pas partager avec un .gitignore (par exemple pour ne jamais partager accidentellement des données sensibles)

À retenir !

Attention à ce qu’on dépose sur les forges : les forges externes ont vocation à héberger les projets open-source

Une forge peut être interne ou externe à un institut :

URL de la forge interne à l’IRD : https://forge.ird.fr/ (instance GitLab)

La Forge IRD

Accessible directement via le site web IRD Forge ou depuis IRD Apps dans Partage

Connexion à la Forge IRD

https://forge.ird.fr/
On s’identifie avec ses identifiants habituels (adresse mail IRD) ou via Renater

Fonctionnement de la Forge IRD

Service institutionnel accessible à l’IRD et à ses partenaires (comptes RENATER ou CRU)
Documentation IRD Forge disponible : https://doc-forge.pages.ird.fr/
Une unité dispose de son espace dédié + gestionnaire(s) ; sinon, espace d’unité créé sur demande du DU
Dépôts de code (diffusion restreinte ou large), possibilité de générer des pages de documentation (GitlabPages)

Permissions et rôles

Chaque groupe est associé à des utilisateurs dont chacun dispose d’un niveau de permissions sur les projets du groupe et sur le groupe lui-même.

Ce qu’il faut retenir :

Rôle	Permissions	Exemple
Owner	Les propriétaires ont un contrôle total sur le projet ou le groupe.	Référent Forge
Maintainer	Les mainteneurs ont généralement des droits similaires aux propriétaires, mais ils n’ont pas accès à l’intégralité des paramètres du projet/groupe.	Responsable du code
Developer	Les développeurs ont des droits d’écriture sur le projet ou le groupe.	Stagiaire
Reporter	Les rapporteurs ont des droits de lecture sur le projet ou le groupe.	Chercheurs
Guest	Les invités ont des droits d’accès limités et sont souvent utilisés pour donner un accès en lecture seule à des personnes extérieures au projet.	Autres, collègues

Travailler avec la Forge IRD

Repo local et distant

Authentification pour travailler avec une Forge

Pour travailler avec une Forge, un mode d’authentification doit être configuré.

Deux approches principales sont disponibles :

SSH : échange de clés permettant une connexion sécurisée sans mot de passe.
HTTPS : utilisation d’un token personnel ou d’un mot de passe applicatif pour chaque interaction distante.

Connexion SSH entre Forge IRD et RStudio (1/2)

Avant de commencer, il faut établir une connexion sécurisée entre votre RStudio et la Forge

Cliquez sur View public key et copiez la clé.

Connexion SSH entre Forge IRD et RStudio (2/2)

Dépôt remote connecté à un projet R

2. Dans RStudio, créer un projet vide connecté à la Forge par clé SSH

Onglets Push/Pull

équivalent en ligne de commande : git push

Actualisation des fichiers sur la Forge IRD

Exercice

Exercice - Travailler avec la Forge

Aller dans la forge IRD et dans le groupe isi-formation-git-bac-a-sable (https://forge.ird.fr/isi/bacs-sable-formation). Vérifier que vous êtes bien connecté.e sur la forge (via votre login institutionnel).
Créer un dépôt vide dans ce groupe au format prenom-nom-ex1 en incluant la création d’un README.md.
Lier ce dépôt distant sur votre machine dans un nouveau répertoire (par exemple tp-exercice1).

Travailler avec les branches

Plusieurs chemins sont possibles

Qu’est-ce qu’une branche ?

Image : www.nobledesktop.com/learn/git/git-branches

Repo local et distant.. et les branches

Onglet Branche

Limitations : RStudio ne permet pas toutes les opérations sur les branches, notamment la fusion.

Solution : Pour les opérations avancées, utilisez les interfaces des forges comme GitLab ou GitHub.

Si pour terminer on se racontait une histoire ?

L’histoire

Image : https://openscapes.org/blog/2022-05-27-github-illustrated-series/

L’histoire

Conclusion

Take home message

Récapitulatif et recommendations

Recommandations générales sur l’usage de Git

Utiliser Git pour suivre les modifications des codes d’un projet RStudio ;
Ne jamais utiliser Git pour sauvegarder les données ;
Utiliser l’interface graphique de RStudio pour les usages courants de Git (ligne de commande si besoin ou si vous êtes très à l’aise)

Recommandations sur l’initialisation de Git

Utiliser Git dès le lancement de votre projet, même s’il est possible de commencer à suivre un projet déjà existant avec Git.
Commencer par créer un dépôt distant sur une forge (Github, Forge IRD, …), puis cloner ce dépôt pour travailler sur votre poste local.
Renseigner le fichier .gitignore afin d’exclure certains fichiers du suivi des modifications (notamment les fichiers de données).

Quelques liens utiles pour débuter

Ces liens sont utiles pour débuter et m’ont aussi aidé à construire ces diapositives.

Merci aux personnes ayant contribué !