Git / GitLab

Qualiopi

En centre

Recyclage

Initial

Non éligible CPF

Objectifs

Programme

Prendre en main GIT
Devenir autonome sur vos projets
Comprendre la philosophie GIT pour l’intégrer comme un outil fonctionnel
Utiliser de la forge opensource GITLAB
Mettre en place et administrer les pipelines de test automatisés pour les applications

lus personne ne se pose la question : GIT est devenu LE système de gestion de configuration dominant du marché.

De nos jours, tout développeur, intégrateur, testeur doit connaître GIT et être autonome et compétent avec cet outil.
GIT est un outil extrêmement puissant qui offre liberté, sécurité et confort aux développeurs qui le maîtrisent, mais cela ce fait au prix d'un abord complexe et souvent effrayant pour les débutants

Cette formation a pour but de permettre aux élèves non seulement de prendre en main GIT et de devenir autonomes sur leurs projets mais également de comprendre la philosophie de GIT pour l'intégrer comme un outil fondamental, un véritable appui dans les processus de développement et d'intégration.
La troisième journée de formation (optionnelle) aborde l'utilisation de la forge open-source GITlab, à la fois pour les utilisateurs (pull-requests, tickets, relecture de code) et pour les intégrateurs (tags, livraison, gestion des workflow projet).
Une moitié de la journée est spécifiquement consacrée à l'intégration continue avec GITlab, la mise en place et l'administration de pipelines de test automatisés pour les applications

GIT : The king of SCM

Introduction

Smile: a quick overview
Introduction to GIT

Installing GIT

Exercise: Installing GIT
Exercise: Using the first commands
Exercise: TP creating a local repository

Building a commit

Creating a commit

Exercise: Commits
Exercise: Commits with a GUI
Exercise: .GITignore

Manipulating the index

Exercise: Reverting your work in progress
Exercise: Synthesis

Working with patch series

Working with branches

Exercise: Branching
Exercise: Branching 2

GIT rebase : Rewriting a branch

Exercise: Interactive rebase

Updating and merging branch

Rebasing your work

Exercise: GIT rebase

Merging branches

Exercise: Merges and Fast-Forward

Rebase Vs merge
Resolving conflicts

Exercise: Solving conflicts

GIT for the project maintainer

Tagging and releasing

Exercise: Manipulating tags
Exercise: GIT archive

Searching for a commit

Exercise: Looking at commits
Exercise: GIT bisect
Exercise: Putting the blame

Maintenance branches

Exercise: GIT cherry
Exercise: CherryPick and Revert

How the GIT tree works

Exercise: A small exercise

Sharing commits

Remote repositories

Exercise: Managing remotes

Fetching remote changes
Pushing your changes

Exercise: Fetching and pushing.

Repository organisation

Exercise: Working with emails \046

Introduction to forges
Other GIT features
GIT : conclusion

GITLab : The open-source forge

GITLab as a user

Introduction
Exploring a project on GITLab
Introduction to markdown

Exercise: Playing with Markdown

Creating an issue

Exercise: Creating an issue

Creating a merge request

Exercise: Configuring the triangular workflow
Exercise: Creating a merge request

GITLab as a maintainer

Issues and workflow management

Exercise: Labels and workflow

Merge Requests and branch management

Exercise: Merge-requests

Branch workflow
Tagging and releasing
Groups and permissions
Other GITLab features

GiLab-CI : The new standard for CI/CD

Introduction to GITLab-CI

What is CI/CD?
CI/CD with GITLab and external tools
GITLab-CI: GITLab's integrated CI/CD

GITLab-CI for the source code developer

Viewing pipeline results
Forcing or skipping pipeline execution

GITLab Runners
GITLab-CI for the pipeline developer

Introduction to YAML
Defining jobs
Exercise: Your first job
Saving job artifacts

Exercise: Saving artifacts

Organizing jobs into a pipeline

Exercise: Multiple stages

Defining conditions on pipeline execution

Exercise: Conditional pipelines

Organizing YML files
Defining a system of pipelines
GITLab-CI for the job developer

Choosing your runner
Handling errors
Caching job data

Exercise: Configuring caches

undefined

Public visé

Toute personne devant utiliser ou administrer GIT dans le cadre de ses fonctions : Développeurs, Intégrateurs, Ingénieurs systèmes, Autre

Prérequis

Familiarité générale avec les problématiques de développement
* Familiarité générale avec les opérations en ligne de commande
* Aucun langage de programmation spécifique n'est nécessaire

Méthodes pédagogiques

Tous nos stages reposent sur une alternance entre transfert de connaissances et de savoir-faire, à travers des exercices concrets, des tests pratiques et des analyses de situations. Cette méthode permet une appropriation rapide des sujets par les stagiaires.
Notre formateur s’appuie sur les connaissances préexistantes du stagiaire. Il combine diverses modalités pédagogiques: des exposés théoriques, des temps d’échanges, des études de cas, permettant à l’apprenant d’être acteur de la séance de formation.
Lors des formations en groupe, l’accent est mis sur l’interactivité, intégrant ainsi la possibilité de progresser en équipe et de réussir ensemble.
Le scénario de nos cours est adapté afin de faire directement référence aux attentes des stagiaires. Les exemples et exercices sont, dans la mesure du possible, au plus près des missions réalisées par vos collaborateurs.
En effet, notre processus de personnalisation d’accès à la formation nous conduit à choisir et combiner différentes méthodes classiques qui ont fait preuve de leur efficacité, en fonction des objectifs à atteindre et du public reçu en formation.