Ce support s’adresse principalement aux développeurs et aux chefs de projet mais également aux professionnels appelés à modifier des codes sources (graphiste, webdesigner, etc.).

Le support présente tout d’abord l’historique des solutions de gestion de versions et leur intérêt. Il permet ensuite au lecteur d’installer et de configurer Git puis de l’utiliser tout au long de cinq chapitres progressifs (fonctionnement des branches, partage d’un dépôt, outils internes...). Un chapitre permet au lecteur de bien appréhender git-flow, une méthode pour gérer efficacement les différentes versions d’un projet en entreprise.

Deux chapitres présentent la gestion de versions de manière très pragmatique en utilisant deux scénarios mettant en oeuvre des développeurs. Le premier scénario reprend les bases de l’utilisation de Git et montre l’utilisation des principales commandes dans des cas quasi-réels. Le deuxième scénario met en scène une équipe de développeurs : de l’installation de Git- Lab, jusqu’à une utilisation de la méthode git-flow par l’équipe. Ce chapitre détaille les principales étapes par lesquelles l’équipe doit passer pour versionner un projet existant.

Un chapitre présente une liste d’alias et de commandes prêtes à l’emploi, fruit d’années de pratique de Git de l’auteur, afin que le lecteur utilise Git plus efficacement et puisse obtenir des solutions de problèmes communs. Le dernier chapitre présente un cas réel d’intégration continue 100% Git dans le cadre d’un développement web avec le framework Django.

En annexe, un aide-mémoire permet de visualiser rapidement les principales commandes et leurs principales options. Une présentation de la plateforme GitHub et des changements qu’elle apporte dans la collaboration entre développeurs est également proposée par l’auteur.

Téléchargements

• Des fichiers complémentaires (206 Ko)

Avant-propos

1. 1. À qui s’adresse cet ouvrage ?
2. 2. Objectifs de l'ouvrage
3. 3. Prérequis
4. 4. Progression
5. 5. Détail des chapitres
6. 6. Un point sur les langues
7. 7. Remerciements
8. 8. Introduction à Git

Git et la gestion de version

1. 1. La gestion de version
2. 2. Les intérêts de la gestion de version
   1. 2.1 Une véritable machine à remonter le temps
   2. 2.2 Une documentation détaillée et datée
   3. 2.3 Une pierre de Rosette pour collaborer
3. 3. Histoire de la gestion de version
   1. 3.1 Systèmes de gestion de versions locaux
   2. 3.2 Systèmes de gestion de versions centralisés
   3. 3.3 Systèmes de gestion de versions décentralisés
4. 4. Pourquoi Git ?

Installation de Git

1. 1. Installation sous Linux
   1. 1.1 Installation à partir de paquets préexistants
   2. 1.2 Installation à partir des sources
2. 2. Installation sous Mac OS X
3. 3. Installation sous Windows
4. 4. L’aide de Git
   1. 4.1 Généralités
   2. 4.2 Types de commandes Git
      1. 4.2.1 Les commandes de porcelaine
      2. 4.2.2 Les commandes de plomberie
5. 5. Configuration requise
   1. 5.1 Configurer le nom de l'utilisateur
   2. 5.2 Configurer l'e-mail de l'utilisateur

Création d’un dépôt

1. 1. Créer un dépôt local
2. 2. Le contenu du dossier .git
3. 3. Le fichier README
4. 4. Markdown
   1. 4.1 Présentation
   2. 4.2 Éléments de syntaxe
      1. 4.2.1 Titres
      2. 4.2.2 Listes non ordonnées
      3. 4.2.3 Listes ordonnées
      4. 4.2.4 Mettre en gras
      5. 4.2.5 Mettre en italique
      6. 4.2.6 Ligne horizontale
      7. 4.2.7 Code
      8. 4.2.8 Tableaux
      9. 4.2.9 Liens
      10. 4.2.10 Notes de bas de page
5. 5. reStructuredText
   1. 5.1 Présentation
   2. 5.2 Éléments de syntaxe
      1. 5.2.1 Titres
      2. 5.2.2 Listes autonumérotées
   3. 5.3 Logiciels
6. 6. Outils pour travailler avec Markdown
   1. 6.1 Sublime Text
   2. 6.2 Texts
   3. 6.3 Ulysses
7. 7. Configurer le dépôt local
   1. 7.1 Configuration minimale
   2. 7.2 Niveaux de configuration
      1. 7.2.1 Le niveau système
      2. 7.2.2 Le niveau utilisateur
      3. 7.2.3 Le niveau dépôt
   3. 7.3 Les paramètres configurables
      1. 7.3.1 Définir l'éditeur de texte
      2. 7.3.2 Modèle de commit
      3. 7.3.3 Ignorer des fichiers
      4. 7.3.4 Hashs abrégés
   4. 7.4 Définition d'alias Git
8. 8. Les options de configuration avancées
   1. 8.1 Pagination
   2. 8.2 Expressions régulières étendues
   3. 8.3 Séparateur de mots
   4. 8.4 Ancêtre commun des conflits
   5. 8.5 Configurer le cache de l'authentification

Manipulation des fichiers et commit

1. 1. Gestion des fichiers et commit
2. 2. Une histoire de hash
   1. 2.1 Une identification par contenu
   2. 2.2 Risque de collision
   3. 2.3 Fonctionnalité expérimentale de hash SHA2-256
3. 3. Les trois zones d’un fichier
   1. 3.1 Le répertoire de travail
   2. 3.2 L'index
   3. 3.3 Le dépôt
4. 4. Manipuler les fichiers
   1. 4.1 Ajouter des fichiers dans l'index
   2. 4.2 Déplacer ou renommer des fichiers
   3. 4.3 Supprimer des fichiers
   4. 4.4 Arrêter de suivre un fichier
   5. 4.5 Ignorer des fichiers
5. 5. Commiter ou enregistrer des modifications
   1. 5.1 Effectuer un premier commit
   2. 5.2 Rédiger un bon message de commit
      1. 5.2.1 Les règles d'un message de commit
      2. 5.2.2 Méthode pour le titre
      3. 5.2.3 En quelle langue ?

Consultation et manipulation de l’historique

1. 1. Lister les commits avec git log
   1. 1.1 Limiter le nombre de commits affichés
   2. 1.2 Afficher les statistiques
   3. 1.3 Afficher chaque commit sur une seule ligne
   4. 1.4 Filtrer les commits chronologiquement
   5. 1.5 Filtrer les commits selon les intervenants
   6. 1.6 Afficher le graphique des branches
   7. 1.7 Spécifier un format de sortie
   8. 1.8 Prendre en compte les merges
   9. 1.9 Lister les commits impactant un fichier
   10. 1.10 Afficher des dates plus lisibles
2. 2. Afficher les différences de contenu
   1. 2.1 Différences en cours dans le répertoire
   2. 2.2 Différences entre l'index et HEAD
   3. 2.3 Différences entre le répertoire de travail et HEAD
   4. 2.4 Différences introduites par un ou plusieurs commits
   5. 2.5 Différences de mots
   6. 2.6 Visualiser les blocs de code déplacés
3. 3. Identifier l’auteur d’une ligne de code
4. 4. Rechercher des commits avec le mode pick axe
5. 5. Supprimer les modifications du répertoire de travail
6. 6. Supprimer les modifications de l'index
7. 7. Revenir à un état antérieur
8. 8. Modifier le dernier commit
9. 9. Afficher un résumé des commits

Les branches et les tags

1. 1. Les tags
   1. 1.1 Numérotation des versions
   2. 1.2 Différents types de tags
   3. 1.3 Création des tags
   4. 1.4 Création d’un tag annoté
   5. 1.5 Liste des tags
   6. 1.6 Détails d’un tag
   7. 1.7 Envoi des tags vers le dépôt distant
   8. 1.8 Suppression d’un tag
2. 2. Les branches
   1. 2.1 Liste des branches existantes
   2. 2.2 Création d’une branche
   3. 2.3 Positionnement sur une branche
   4. 2.4 Fusionner deux branches
      1. 2.4.1 L'avance rapide
      2. 2.4.2 Nettoyer votre dépôt
      3. 2.4.3 Les conflits de fusion
   5. 2.5 Supprimer une branche
   6. 2.6 Rebaser une branche dans une autre

Partager un dépôt

1. 1. Qu'est-ce qu'un dépôt distant ?
2. 2. Créer un dépôt distant
   1. 2.1 Pour un nouveau projet
   2. 2.2 Pour un projet existant
3. 3. Cloner un dépôt distant
4. 4. Les protocoles d'échange
5. 5. Fonctionnement interne et branches distantes
   1. 5.1 Les dépôts distants liés
   2. 5.2 Les branches distantes suivies
6. 6. Envoyer ses modifications
7. 7. Recevoir les modifications

Git-Flow : workflow d’entreprise

1. 1. Un système de gestion des branches
   1. 1.1 Les branches éternelles
      1. 1.1.1 La branche de production (master)
      2. 1.1.2 La branche de développement (develop)
   2. 1.2 Les branches éphémères
      1. 1.2.1 Les branches de versions (release)
      2. 1.2.2 Les branches de correctifs (hotfix)
      3. 1.2.3 Les branches de fonctionnalités (feature)
      4. 1.2.4 Plusieurs commits dans une branche éphémère ?
2. 2. Exemple de workflow
3. 3. Git-Flow intuitif grâce à Tower
   1. 3.1 Client Git et Git-Flow
   2. 3.2 Cas pratique d’utilisation

Les outils de Git

1. 1. Mettre de côté des modifications avec git stash
2. 2. Dépôts intégrés avec submodules
   1. 2.1 Ajout du dépôt intégré
   2. 2.2 Cloner un dépôt et ses dépôts intégrés
   3. 2.3 Modification des dépôts intégrés
   4. 2.4 Supprimer un dépôt intégré
   5. 2.5 Inconvénients des dépôts intégrés
3. 3. Retrouver un commit erroné
   1. 3.1 Utilisation pratique de git bisect
   2. 3.2 Automatiser git bisect
4. 4. Journal des références (reflog)
5. 5. Les hooks
   1. 5.1 Les différents types de hooks
   2. 5.2 Comment utiliser les hooks ?
   3. 5.3 Exemple de hook : validation de message
   4. 5.4 Partager les hooks dans le dépôt
6. 6. Les notes Git
   1. 6.1 Créer une note
   2. 6.2 Afficher les notes
      1. 6.2.1 Lister les notes
      2. 6.2.2 Consulter les notes d'un commit
   3. 6.3 Éditer une note
   4. 6.4 Supprimer une note
   5. 6.5 Envoyer les notes vers le serveur

Scénario de développeur indépendant

1. 1. But de ce chapitre
2. 2. Contexte du scénario
3. 3. Création du dépôt
4. 4. Début du développement
5. 5. Enregistrer des modifications
6. 6. Bitbucket
   1. 6.1 Création d'un compte
   2. 6.2 Envoyer un dépôt local vers Bitbucket
   3. 6.3 Éditer un fichier sur Bitbucket
   4. 6.4 Récupérer les modifications du dépôt distant
7. 7. Intégrer un nouveau développement
   1. 7.1 Vérifier son code avant l'indexation
   2. 7.2 Commiter le nouveau développement
8. 8. Annuler les modifications d'un fichier
9. 9. .gitignore : ignorer une bibliothèque
10. 10. Commiter tous les fichiers ajoutés ou modifiés
11. 11. Envoyer les commits au dépôt distant
12. 12. Afficher les différences entre deux commits
13. 13. Cloner le dépôt distant
14. 14. Une branche, ça sert à quoi ?
15. 15. Changer de branche
16. 16. Fusionner deux branches

Scénario d’équipe

1. 1. Contexte du scénario
2. 2. Aperçu du projet
   1. 2.1 Installation de Python
   2. 2.2 Récupération du dépôt
   3. 2.3 Installation des dépendances Python
   4. 2.4 Initialisation des dépôts intégrés
   5. 2.5 Génération des bibliothèques
   6. 2.6 Création du fichier de configuration
   7. 2.7 Création de la base
   8. 2.8 Création d'un compte root
   9. 2.9 Lancement du serveur
3. 3. Installation de GitLab
4. 4. Création des comptes utilisateurs
5. 5. Création du projet
6. 6. Attribuer des projets aux utilisateurs
7. 7. Premier commit du projet
   1. 7.1 Rédaction du fichier .gitignore
      1. 7.1.1 Ignorer les bibliothèques
      2. 7.1.2 Ignorer les fichiers propres à la technologie
      3. 7.1.3 Ignorer les données sensibles
      4. 7.1.4 Ajouter les dépôts intégrés
      5. 7.1.5 Le fichier README
   2. 7.2 Commit du projet
   3. 7.3 Création de la branche develop pour Git-Flow
8. 8. Phase de développement
   1. 8.1 Fonctionnalité graphique
   2. 8.2 Correctif de temps négatif
   3. 8.3 Intégration du correctif
   4. 8.4 Fonctionnalité type de tâche
   5. 8.5 Finalisation des graphiques
   6. 8.6 Finalisation des types de tâche
   7. 8.7 Création de la branche de version
   8. 8.8 Export CSV
   9. 8.9 Correctif de version
   10. 8.10 Nouvelle version stable
   11. 8.11 Finalisation de l’export CSV
9. 9. Mise en ligne du dépôt sur GitHub
   1. 9.1 Création d'un compte GitHub
   2. 9.2 Création d'un dépôt
   3. 9.3 Ajout du remote au dépôt local
   4. 9.4 Envoi des branches
   5. 9.5 Le fichier LICENSE
   6. 9.6 Le fichier README

Productivité maximale avec Git

1. 1. Alias prêts à l'emploi
   1. 1.1 Alias simples
      1. 1.1.1 git last
      2. 1.1.2 git aa
      3. 1.1.3 git bv
      4. 1.1.4 git ba
      5. 1.1.5 git bd
      6. 1.1.6 git bdp
      7. 1.1.7 git ca
      8. 1.1.8 git cb
      9. 1.1.9 git cmf
      10. 1.1.10 git co
      11. 1.1.11 git di
      12. 1.1.12 git dc
      13. 1.1.13 git mnff
      14. 1.1.14 git st
      15. 1.1.15 git tg
      16. 1.1.16 git pu
      17. 1.1.17 git ss
      18. 1.1.18 git ssu
      19. 1.1.19 git sr
      20. 1.1.20 git srp
      21. 1.1.21 git sl
      22. 1.1.22 git sp
      23. 1.1.23 git sa
      24. 1.1.24 git sd_f
      25. 1.1.25 git sb
      26. 1.1.26 git na
      27. 1.1.27 git nl
      28. 1.1.28 git napp
      29. 1.1.29 git ne
      30. 1.1.30 git ns
      31. 1.1.31 git nr
      32. 1.1.32 git ready
   2. 1.2 Alias complexes
      1. 1.2.1 git bnew
      2. 1.2.2 git bold
      3. 1.2.3 git ll
      4. 1.2.4 git ld
      5. 1.2.5 git ls
      6. 1.2.6 git ln
      7. 1.2.7 git slv
      8. 1.2.8 git np
      9. 1.2.9 git bvn
      10. 1.2.10 git churn
      11. 1.2.11 git srr
      12. 1.2.12 git spr
      13. 1.2.13 git sar
      14. 1.2.14 git sdr
   3. 1.3 Récupérer les alias sur GitHub
2. 2. Commandes prêtes à l’emploi
   1. 2.1 Commandes liées à la configuration
      1. 2.1.1 Fichier de configuration actif pour une option
      2. 2.1.2 Afficher sa configuration
      3. 2.1.3 Éditer facilement un niveau de configuration
   2. 2.2 Commandes d'affichage
      1. 2.2.1 Afficher les informations techniques d'un commit
      2. 2.2.2 Afficher les parents des commits
      3. 2.2.3 Afficher les fichiers en conflit
      4. 2.2.4 Afficher la liste des fichiers modifiés
      5. 2.2.5 Afficher l'ancêtre commun
      6. 2.2.6 Afficher le premier commit d'une branche
      7. 2.2.7 Utiliser git show en masquant le diff
      8. 2.2.8 Vérifier une branche sur un dépôt distant
      9. 2.2.9 Fusionner des branches sans ancêtre commun
      10. 2.2.10 Afficher les dépôts distants et leur lien externe
      11. 2.2.11 Afficher les fichiers modifiés par un commit
      12. 2.2.12 Afficher le chemin du dépôt versionné
      13. 2.2.13 Consulter l'historique des commandes git
      14. 2.2.14 Afficher le nombre de commits par auteur
      15. 2.2.15 Afficher le nombre de commits d'un auteur
      16. 2.2.16 Afficher la dernière date de modification des branches
      17. 2.2.17 Lister les branches contenant un commit précis
      18. 2.2.18 Afficher l'historique avec les diff
      19. 2.2.19 Chercher un texte/regex dans les commits
      20. 2.2.20 Chercher un texte/regex dans les stashes
      21. 2.2.21 Lister les commits des branches
      22. 2.2.22 Comparer un fichier antérieur
      23. 2.2.23 Afficher les branches déjà fusionnées dans master
      24. 2.2.24 Lister les branches non mergées dans master
      25. 2.2.25 Lister les commits d'une branche non mergée à master
   3. 2.3 Commandes de manipulation
      1. 2.3.1 Supprimer ou inverser les modifications d'un commit
      2. 2.3.2 Supprimer du dépôt les fichiers déjà supprimés du projet
      3. 2.3.3 Retirer des modifications de l'index
      4. 2.3.4 Récupérer le fichier d'un autre commit
      5. 2.3.5 Supprimer les fichiers non suivis du répertoire
      6. 2.3.6 Supprimer les modifications des fichiers suivis
      7. 2.3.7 Supprimer une branche distante

Git en déploiement continu

1. 1. Objectifs du chapitre
2. 2. Le projet
3. 3. Présentation de Django
4. 4. Développement de la version initiale
   1. 4.1 Installation
   2. 4.2 Création du projet
      1. 4.2.1 Création du projet Django
      2. 4.2.2 Création du fichier .gitignore
      3. 4.2.3 Enregistrement des bibliothèques Python
      4. 4.2.4 Premier commit
   3. 4.3 Création des applications users et articles
   4. 4.4 Création des modèles Django
      1. 4.4.1 Le modèle BaseModel
      2. 4.4.2 Le modèle User
      3. 4.4.3 Le modèle Article
   5. 4.5 Mise en place du module d'administration
      1. 4.5.1 Démarrer le serveur de développement
      2. 4.5.2 Création des pages utilisateur
      3. 4.5.3 Templates parents
      4. 4.5.4 Liste des articles
      5. 4.5.5 Page de consultation d'un article
      6. 4.5.6 Page "À propos"
5. 5. Déploiement initial
   1. 5.1 Configuration des identifiants SSH
   2. 5.2 Création du site web Webfaction
   3. 5.3 Création des applications Webfaction
   4. 5.4 Création de la base de données
   5. 5.5 Externalisation du dépôt de la configuration
   6. 5.6 Préparer le dossier du projet et créer le dépôt
   7. 5.7 Configuration du dépôt en déploiement automatisé
   8. 5.8 Configuration du remote et premier push
   9. 5.9 Création de l'environnement virtuel
   10. 5.10 Configuration d'Apache
   11. 5.11 Envoi de la configuration de production
   12. 5.12 Exécuter les migrations
   13. 5.13 Synchroniser les fichiers statiques
   14. 5.14 Redémarrer Apache
6. 6. Déploiement automatisé
   1. 6.1 Développement du hook dans le dépôt
   2. 6.2 Configuration du dépôt distant
7. 7. Fonctionnalité : champ WYSIWYG pour l'article
   1. 7.1 Développement
   2. 7.2 Déploiement automatisé

Aide-mémoire

1. 1. Les références
   1. 1.1 HEAD
   2. 1.2 Les branches
   3. 1.3 Les tags
   4. 1.4 Référence des ancêtres
2. 2. Les commandes
   1. 2.1 git add
   2. 2.2 git archive
   3. 2.3 git bisect
   4. 2.4 git blame
   5. 2.5 git branch
   6. 2.6 git checkout
   7. 2.7 git cherry-pick
   8. 2.8 git clean
   9. 2.9 git clone
   10. 2.10 git commit
   11. 2.11 git config
   12. 2.12 git diff
   13. 2.13 git fetch
   14. 2.14 git gc
   15. 2.15 git help
   16. 2.16 git init
   17. 2.17 git log
   18. 2.18 git merge
   19. 2.19 git mv
   20. 2.20 git pull
   21. 2.21 git push
   22. 2.22 git rebase
   23. 2.23 git reflog
   24. 2.24 git remote
   25. 2.25 git reset
   26. 2.26 git revert
   27. 2.27 git rm
   28. 2.28 git show
   29. 2.29 git stash
   30. 2.30 git submodule
   31. 2.31 git tag
3. 3. GitHub
   1. 3.1 Gestion des dépôts
   2. 3.2 GitHub-Flow (fork et pull request)
   3. 3.3 Les "issues" GitHub
   4.  
   5.  
   6. Index