View - Download Chap 2 : gestion du code source avec Git/GitHub - WordPresscom

Previous PDF

Next PDF

Chap. 2 : gestion du code source avec Git/GitHub

L'objectif de ce cours est de présenter une solution libre et gratuite pour la gestion du code source : l'outil Git associé à la forge logicielle GitHub.

Table des matièresIntroduction à la gestion du code source..........................................................................................2

La nécessité d'une gestion du code source.................................................................................2

Les logiciels de gestion du code source......................................................................................2

Gestion centralisée Vs gestion décentralisée..............................................................................3

Principaux logiciels de gestion du code source............................................................................3

Présentation de Git...........................................................................................................................4

Fonctionnement de Git.................................................................................................................4

Exemple d'utilisation de Git avec Netbeans.................................................................................5

Initialisation du dépôt Git.........................................................................................................5

Mise à jour des sources..........................................................................................................6

Création d'une version............................................................................................................8

Utilisation de GitHub en complément de Git.....................................................................................8

Rôle de GitHub dans le processus de travail en équipe...............................................................8

Présentation de GitHub................................................................................................................9

Fonctionnement de GitHub..........................................................................................................9

Exemple d'utilisation de GitHub avec Netbeans.........................................................................10

Création du dépôt GitHub......................................................................................................10

Synchronisation entre les dépôts..........................................................................................11

Clonage d'un dépôt GitHub...................................................................................................13

B. Pesquet - 2013Page 1 / 14

Introduction à la gestion du code source

La nécessité d'une gestion du code source

Un projet logiciel d'entreprise a une durée de vie de plusieurs années et subit de nombreuses évolutions au cours de cette période. On rencontre souvent le besoin de livrer de nouvelles versions qui corrigent des bogues ou apportent de nouvelles fonctionnalités. Le code source du

logiciel "vit" donc plusieurs années. Afin de pouvoir corriger des problèmes signalés par un

utilisateur du logiciel, on doit savoir précisément quels fichiers sources font partie de quelle(s)

version(s).

En entreprise, seuls une petite minorité de logiciels sont conçus par un seul développeur. La

grande majorité des projets sont réalisés et/ou maintenus par une équipe de plusieurs personnes

travaillant sur la même base de code source. Ce travail en parallèle est source de complexité :

➔Comment récupérer le travail d'un autre membre de l'équipe ? ➔Comment publier ses propres modifications ? ➔Comment faire en cas de modifications conflictuelles (travail sur le même fichier source qu'un ou plusieurs collègues) ?

Pour les raisons précédentes, tout projet logiciel d'entreprise (même mono-déveleppeur) doit faire

l'objet d'une gestion de son code source (en anglais S C M, Source Code Management). La SCM vise les objectifs suivants : Assurer la pérennité du code source d'un logiciel

Permettre le travail collaboratif.

Fournir une gestion des versions du logiciel.

La SCM la plus basique consiste à déposer le code source sur un répertoire partagé par l'équipe

de développement. Si elle permet à tous de récupérer le code, elle n'offre aucune solution aux

autres complexités du développement en équipe et n'autorise pas la gestion des versions.

Heureusement, il existe une catégories de logiciels spécialisés dans la gestion du code source.

Les logiciels de gestion du code source

Afin de libérer l'équipe de développement des complexités du travail collaboratif, les logiciels de

SCM fournissent des services de gestion du code source. Un logiciel de SCM est un dépôt de

code qui héberge le code source du projet. Chaque développeur peut se connecter au dépôt afin

de récupérer le code source, puis de publier ses modifications (on parle de c o m m i t). Les autres développeurs peuvent alors récupérer le travail publié. Le logiciel garde la trace des modifications successives d'un fichier. Il permet d'en visualiser l'historique et de revenir à une version antérieure. En cas de modification conflictuelle, le logiciel de SCM permet de comparer les versions du fichier et de choisir les modifications à conserver ou à rejeter. Le logiciel de SCM permet la gestion des versions : sur demande d'un développeur, il ajoute aux fichiers sources une é t i q u e t t e (tag) permettant de marquer une version d'un logiciel.

B. Pesquet - 2013Page 2 / 14

Gestion centralisée Vs gestion décentralisée

Il existe deux catégories de logiciels de SCM.

La première catégorie offre une gestion centralisée du code source. Dans ce cas de figure, il

n'existe qu'un seul dépôt qui fait référence. Les développeurs se connectent au logiciel de SCM

suivant le principe du c l i e n t / s e r v e u r. Cette solution offre les avantages de la

centralisation (administration facilitée) mais handicape le travail en mode déconnecté : une

connexion au logiciel de SCM est indispensable.

Une seconde catégorie est apparu il y a peu. Elle consiste à voir le logiciel de SCM comme un outil

individuel permettant de travailler de manière décentralisée (hors ligne). Dans ce cas de figure, il

existe autant de dépôts de code que de développeurs sur le projet. Le logiciel de SCM fournit

heureusement un service de synchronisation entre toutes ces bases de code. Cette solution fonctionne suivant le principe du p a i r - à - p a i r. Cependant, il peut exister un dépôt de référence contenant les versions livrées.

Principaux logiciels de gestion du code source

Il existe de très nombreux logiciels de SCM. On en a un aperçu à la page ci-dessous :

B. Pesquet - 2013Page 3 / 14

Nous n'allons citer que les principaux. Assez ancien mais toujours utilisé, C V S (Concurrent Versioning System) fonctionne sur un principe centralisé, de même que son successeur

S V N(Subversion). Tous deux sont très employés dans le monde du logiciel libre (ce sont eux-mêmes

des logiciels libres).

Les logiciels de SCM décentralisée sont apparus plus récemment. On peut citer Mercurial et

surtout G i t, conçu pour le développement du noyau Linux et qui connaît un grand succès actuellement. Ce sont également des logiciels libres. Microsoft fournit un logiciel de SCM développé sur mesure pour son environnement. Il se nomme T F S (T e a m F o u n d a t i o n S e r v e r) et fonctionne de manière centralisée. TFS esr une solution payante.

Présentation de Git

Introduction

Commençons par une définition issue de Wikipedia : "Git est un logiciel de gestion de versions

d é c e n t r a l i s é. C'est un logiciel l i b r e créé par Linus Torvalds, le créateur du noyau

Linux, et distribué selon les termes de la licence publique générale GNU version 2."

Rappelez ce qu'est un logiciel libre.

U n l o g i c i e l q u i g a r a n t i t l a p o s s i b i l i t é d ' é t u d i e r , d e

m o d i f i e r e t d e d i f f u s e r s o n c o d e s o u r c e .Fonctionnement de Git

Git fonctionne selon un principe décentralisé. Chaque développeur dispose de son propre dépôt

personnel qui contient l'intégralité des données du projet : code source, historique, versions, etc.

La copie locale des fichiers sources qu'il édite dans son IDE est synchronisée non pas avec un

dépôt central, mais avec son dépôt Git local. Il reste toutefois possible, comme nous le verrons

plus loin, de se synchroniser avec un dépôt Git distant et commun.

A l'origine, Git a été conçu pour le système Linux sous la forme d'un ensemble de commandes

utilisables dans un terminal. Il existe cependant des plugins pour la plupart des IDE du marché, comme Netbeans ou Eclipse. Les principales commandes Git (intégrées dans les plugins) sont : init : crée un nouveau dépôt local clone : clone un dépôt distant add : ajoute des fichiers au dépôt local commit : intègre les modifications des fichiers dans le dépôt local

Nous n'allons pas détailler toutes les commandes ni le fonctionnement interne de Git, mais plutôt

étudier les grands principes de son fonctionnement au travers d'un exemple.

B. Pesquet - 2013Page 4 / 14

Exemple d'utilisation de Git avec Netbeans

Netbeans dispose d'un plugin pour Git permettant d'exécuter les commandes précédentes de

manière graphique à l'intérieur de l'IDE, et sans avoir à installer Git comme logiciel autonome.

Pour l'utiliser, il suffit de commencer par créer un projet de manière habituelle. Nous utiliserons

comme support un projet PHP nommé MonBlog qui affiche une page Web de type blog.

Initialisation du dépôt Git

Une fois le projet créé, on utilise la commande Versioning -> Initialize Git Repository après un

clic droit sur le projet. Cela permet de créer un dépôt Git local. Il est possible de sélectionner

l'emplacement du dépôt : le plus simple est de le laisser par défaut dans le répertoire du projet.

B. Pesquet - 2013Page 5 / 14

Remarque : un dépôt est appelé r e p o s i t o r y, en abrégé r e p o, dans la terminologie Git.

Le dépôt local est maintenant créé. On le constate par un changement des icônes des sources sous Netbeans, et par la présence dans le répertoire du projet d'un sous-répertoire . g i t. C'est dans ce répertoire que Git fait sa "cuisine" interne pour gérer le code source. Il n'est pas nécessaire d'y intervenir.

Il reste à intégrer les fichiers sources du projet à notre dépôt local. Pour cela, nous allons réaliser

une opération de c o m m i t, accessible sous Netbeans par clic doir sur le projet, puis choix de Git -> Commit... L'IDE présente alors toutes les différences par rapport au dernier commit (inexistant dans notre exemple) et permet la saisie d'un commentaire pour décrire l'opération. L'ajout d'un commentaire à chaque commit est plus que recommandé. L'identification du commiteur, et notamment son courriel, aura son importance lorsque nous utiliserons GitHub. Les fichiers sources du projet sont alors synchronisés avec le dépôt local.

Mise à jour des sources

Après toute série d'ajouts ou de modifications de code dans Netbeans, il suffit de réaliser un

nouveau commit pour intégrer les changements au dépôt Git local.

Imaginons par exemple qu'on souhaite ajouter au blog un lien sur le titre, qui ramène à la page

principale index.php.

B. Pesquet - 2013Page 6 / 14

Dépôt local

Mon Blog

Une fois le code source modifié, un Git -> Commit... affiche la fenêtre ci-dessous.

Il est possible de visualiser les différences avec la version du dépôt par clic droit sur un des fichiers

concernés, puis choix de l'opération D i f f. L'IDE affiche alors les différences entres les deux

versions du fichier sélectionné.

B. Pesquet - 2013Page 7 / 14

La validation du commit (après saisie d'un c o m m e n t a i r e approprié) intègre les

modifications dans le dépôt local.

Création d'une version

Au fur et à mesure de la vie du projet, les fichiers sources évoluent et il devient difficile de revenir

aux états précédents du code source. Les logiciels de SCM permettent de gérer les versions

successives d'un logiciel en plaçant sur les fichiers des

é t i q u e t t e s (tags). Tous les fichiers

sur lesquels l'étiquette est posée constituent une version du logiciel. Sous Netbeans, on identifie une version du projet avec un clic droit suivi de la commande Git ->

Tag -> Create tag... Une fenêtre de dialogue permet alors de saisir le nom et la description de la

version créée.

Après validation, tous les fichiers sources sont étiquetés "V1.0", ce qui permettra ultérieurement de

revenir facilement à cette version ou de la comparer à une autre.

Utilisation de GitHub en complément de Git

Rôle de GitHub dans le processus de travail en équipe

Jusqu'à présent, notre utilisation de Git est restée individuelle. Nous avons appris à créer un dépôt

et la y intégrer notre travail local. En imaginant que chaque développeur effectue ces tâches, on

aboutit à plusieurs dépôts de code sans aucune relation entre eux.

B. Pesquet - 2013Page 8 / 14

Le chaînon manquant pour pouvoir travailler en équipe serait de disposer d'un dépôt Git commun.

Ce dépôt serait créé en début de projet, puis cloné par chaque développeur pour en obtenir une

réplique exacte qui servirait de dépôt local. Les modifications de code source seraient d'abord

intégrées au dépôt Git local, puis synchronisées avec le dépôt Git commun.

Il est possible de créer ce dépôt commun sur le réseau local, mais il est souvent plus pertinent que

ce dépôt soit accessible en ligne à tout moment. C'est exactement le rôle de la plate-forme

GitHub : fournir aux développeurs des dépôts Git via Internet.

Présentation de GitHub

GitHub (https://github.com) est une plate-forme Web de publication de code source, sous la forme de dépôts Git. Elle fournit également (entre autres) des services de gestion des bogues, de

contrôle d'accès et de collaboration en ligne, ce qui en fait un système de gestion de

développement collaboratif de logiciel, autrement dit une f o r g e l o g i c i e l l e. GitHub offre aussi des services de type réseau social, comme le suivi d'autres développeurs inscrits sur GitHub et l'abonnements aux mises à jour de contenu.

Fonctionnement de GitHub

L'utilisation de GitHub par un développeur commence par la création (gratuite) d'un compte sur la

plate-forme. Il est alors possible de créer des dépôts Git en ligne. La création de dépôts publics est

gratuite. En revanche, un abonnement est nécessaire pour l'obtention de dépôts privés dont

l'accès est restreint. GitHub intègre également le concept d'organisation qui permet de gérer des

équipes de développeurs.

Le dépôt Git hébergé par GitHub fait office de dépôt distant commun pour tous les autres

développeurs qui travaillent sur un même projet. Chacun d'eux commence par c l o n e r le

dépôt distant. Cette opération permet d'obtenir localement les sources initiales ainsi que tout

B. Pesquet - 2013Page 9 / 14

l'historique du projet, étant donné qu'un dépôt Git renferme l'intégralité des données et pas

seulement la version courante du code. Ensuite, chaque développeur synchronisera ses

modifications avec le dépôt GitHub commun au fur et à mesure de son avancée, ce qui permet la

récupération des mises à jour par ses collègues et le travail en parallèle.

Exemple d'utilisation de GitHub avec Netbeans

Nous allons illustrer l'utilisation de GitHub par une organisation au travers de l'exemple du projet

MonBlog précédent. On suppose le compte GitHub de l'organisation créé, ainsi que le dépôt Git

local du projet.

Création du dépôt GitHub

La première étape consiste, pour un membre de l'organisation ayant les droits appropriés, à créer

le dépôt GitHub du projet. Il sera public par défaut, mais il est possible de créer un dépôt privé en

fonction des caractéristiques de l'organisation. Il est recommandé de donner au dépôt le même

nom que le projet et de créer à cette occasion un fichier README initial.

B. Pesquet - 2013Page 10 / 14

Le nouveau dépôt est alors accessible en ligne vie l'URL https://github.com/ l'organisation>/

Il est alors nécessaire de récupérer dans le dépôt Git local les données du dépôt GitHub. Cette

opération s'appelle un p u l l ("tirer"). Sous Netbeans, elle s'effectue par clic droit sur le projet

puis choix de Git -> Remote -> Pull...

Dans la boîte de dialogue qui apparaît, il faut coller l'URL du dépôt GitHub accessible sur la page

Web du dépôt en ligne. Il est également nécessaire de s'authentifier avec son compte GitHub et de

choisir un nom Netbeans pour le dépôt distant. On coche ensuite l'unique choix de branche, et on termine l'opération. Le fichier README est maintenant intégré aux sources du projet sous Netbeans.

Synchronisation entre les dépôts

Ensuite, le développeur travaille localement tout en commitant régulièrement son travail dans son

dépôt Git local. Lorsqu'il veut publier ses modifications en ligne, il effectue une opération de

p u s h ("pousser") pour synchroniser son dépôt Git local avec son dépôt distant sur GitHub.

B. Pesquet - 2013Page 11 / 14

Simulons ce processus en modifiant le fichier README du projet. Le commit intègre la

modification dans son dépôt Git local. Comme dit plus haut, l'identification du développeur lors d'un commit est essentielle.

Le courriel indiqué doit être identifique au courriel utilisé pour s'inscrire sur GitHub, afin

que la plate-forme puisse reconnaître le développeur dans l'historique du projet.

Ceci fait, il faut à présent pousser les modifications sur GitHub. Cela s'effectue grâce à l'opération

Git -> Remote -> Push... On identifie le dépôt GitHub concerné :

On conserve ensuite l'unique choix de branche possible, et on termine l'opération. Le dépôt distant

est mis à jour et la page GitHub du projet reflète les dernières opérations.

B. Pesquet - 2013Page 12 / 14

Clonage d'un dépôt GitHub

Lorsqu'un nouveau développeur rejoint le projet, il doit récupérer l'ensemble des fichiers sources

avant de pouvoir commencer à travailler. Cette opération s'effectue en clonant le dépôt GitHub.

Sous Netbeans, elle est accessible via le menu Team puis Git -> Clone...

Le développeur saisit l'URL du dépôt GitHub ainsi que les identifiants de son compte GitHub.

Ensuite, il doit cocher la branche à utiliser, puis choisir dans quel répertoire local le projet

Netbeans sera créé.

B. Pesquet - 2013Page 13 / 14

quotesdbs_dbs7.pdfusesText_13

[PDF] gestion cabinet medical gratuit

[PDF] gestion cabinet medical open source php

[PDF] gestion cabinet medical php

[PDF] gestion cabinet medical sous access

[PDF] gestion cabinet medical uml

[PDF] gestion client excel

[PDF] gestion clientèle bts nrc formules

[PDF] gestion commerciale cours

[PDF] gestion commerciale définition

[PDF] gestion commerciale excel

[PDF] gestion commerciale logiciel

[PDF] gestion commerciale sage

[PDF] gestion comptabilité definition

[PDF] gestion comptable cours

[PDF] gestion comptable d'une agence de voyage