GitLab - Les fondamentaux de la gestion de versions

Objectif : Découvrir l'architecture Git à trois niveaux (Working Directory, Staging Area, Repository). Configurer ses variables utilisateur globales et ses clés de sécurité SSH. Initialiser un dépôt local et le connecter à un projet distant sur GitLab.

• Comprendre l'intérêt et le fonctionnement de la gestion de versions décentralisée.
• Installation, configuration de base de Git et paramétrage de l'interface GitLab.
• Création d'un projet sur GitLab et clonage local.
• Mécanisme d'enregistrement local : le cycle d'un fichier (untracked, tracked, staged, committed).
• La synchronisation : l'utilisation des commandes git push et git pull.

Atelier pratique : Initialiser un projet de documentation technique, le lier à GitLab et publier sa première version.

Cas métier : Initialisation d'une base de code propre pour un nouveau projet d'entreprise.

Compétence acquise : Être capable de lier un répertoire de travail local à un projet centralisé sur GitLab.

Livrable : Un projet GitLab configuré contenant un fichier de configuration .gitignore fonctionnel.

Objectif : Manipuler la zone d'indexation avec précision. Naviguer et analyser l'historique des modifications d'un projet. Savoir annuler ou corriger des modifications locales non publiées.

• Différencier l'indexation partielle de l'indexation totale d'un dossier.
• Exploration de l'historique avec git log et ses options graphiques (--oneline, --graph).
• Comparaison de versions de fichiers à l'aide de la commande git diff.
• Les mécanismes de retour en arrière : git checkout, git restore et git reset (soft vs hard).
• Modification du tout dernier commit local non partagé via git commit --amend.

Atelier pratique : Navigation dans l'historique d'un site web d'entraînement pour identifier l'origine d'un dysfonctionnement et restaurer une version stable antérieure.

Cas métier : Diagnostic d'anomalie et restauration d'un état de code de production stable.

Compétence acquise : Savoir auditer, comparer et corriger de manière autonome ses fichiers en local avant de les pousser.

Livrable : Un historique local de commits nettoyé, corrigé et prêt pour la publication.

Objectif : Assimiler le concept d'isolation des développements par l'utilisation des branches. Créer, fusionner et supprimer des branches en local. Partager ses branches de fonctionnalités sur le serveur GitLab.

• La philosophie des branches avec Git : pointeurs légers et isolés.
• Créer, basculer et supprimer des branches (git branch, git checkout -b / git switch).
• Intégration de branches locales : les différents types de fusions (Fast-forward vs 3-way merge).
• Pousser ses branches locales vers le serveur et suivre des branches distantes.
• Introduction au concept de branche protégée sur GitLab.

Atelier pratique : Développement simultané d'une évolution de page et d'une correction de style sur deux branches d'activités distinctes, suivi d'une intégration locale.

Cas métier : Isolation des tâches de développement au sein d'une équipe de production.

Compétence acquise : Être capable de mener plusieurs pistes de développement de front sans corrompre le code de référence.

Livrable : Un arbre de branches propre, fusionné localement et publié sur GitLab.

Objectif : Ouvrir et mener une demande de fusion (Merge Request) sur GitLab. Comprendre l'origine technique d'un conflit de fusion. Résoudre méthodiquement les conflits en local pour finaliser l'intégration.

• Création d'une Merge Request sur l'interface GitLab : description, assignation, jalons.
• Le processus de revue de code : commentaires de lignes, modifications suggérées, approbation.
• Anatomie d'un conflit de fusion : quand deux branches modifient la même ligne du même fichier.
• Lecture et interprétation des balises de conflits générées par Git (<<<<<<<, =======, >>>>>>>).
• Résolution locale d'un conflit, validation et finalisation du merge sur GitLab.

Atelier pratique : Simulation d'un conflit de fusion d'équipe provoqué à dessein, édition des fichiers conflictuels et validation finale de la Merge Request sur GitLab.

Cas métier : Intégration de fonctionnalités croisées en équipe et revue de code collaborative.

Compétence acquise : Savoir collaborer de manière sécurisée via le flux GitLab et résoudre les blocages de fusion ordinaires.

Livrable : Une Merge Request revue, validée et fusionnée avec succès après résolution de conflits.

Objectif : Réutiliser en autonomie les commits, les branches, les Merge Requests et la résolution de conflits des journées ESSENTIEL pour faire travailler une équipe sur un même projet.

• Réactiver les acquis des journées ESSENTIEL : rappel visuel et quiz sur le cycle de vie des fichiers, les branches, les Merge Requests et les conflits.
• Mettre en place une organisation des branches (GitLab Flow) et protéger la branche principale.

Atelier pratique : Entraînement en binômes : provoquer puis résoudre des conflits de fusion de difficulté croissante, en testant le code en local avant de valider.

Cas métier : L'équipe sur un même projet (cas fil rouge) - Plusieurs développeurs travaillent en même temps sur le même code. Les participants créent leurs branches de fonctionnalités, protègent la branche principale, ouvrent et relisent des Merge Requests et résolvent les conflits, puis présentent leur organisation au groupe.

Compétence acquise : Savoir organiser et faire vivre le travail d'une équipe sur un même dépôt.

Livrable : Le dépôt d'équipe organisé et ses règles de fusion, construits avec les mémos des journées ESSENTIEL.

Objectif : Mettre à l'épreuve une chaîne d'automatisation complète : construction, tests et déploiement vers un environnement de test.

• Retour sur les Merge Requests et les bases du CI/CD vues les jours précédents.
• Écrire un fichier .gitlab-ci.yml avec ses étapes, ses variables masquées et ses tests automatiques.

Atelier pratique : Exercice guidé : casser volontairement un test, observer le blocage du pipeline, corriger puis comparer les fichiers de configuration entre participants.

Cas métier : La livraison d'un microservice (cas fil rouge) - Chaque participant écrit le pipeline qui construit, teste et déploie automatiquement un microservice vers un environnement de test, puis le présente au groupe et au formateur.

Compétence acquise : Savoir mettre en place une chaîne d'automatisation fiable pour livrer un code testé.

Livrable : Le fichier .gitlab-ci.yml opérationnel et documenté, issu des modèles des journées ESSENTIEL.