Introduction

Piloter vos machines sans avoir à connaitre toutes les commandes Linux en utilisant cockpit.

• Vous avez envie d'administrer vos machines sans connaitre de commandes Linux ?
• Vous avez envie de vous amuser sur une interface web sans passer par un terminal sur la machine ?
• Vous avez envie d'utiliser un terminal sur votre navigateur sans revenir sur votre terminal en local ?
  Alors utilisez cockpit !!

Fonctionnement

Cockpit est une interface graphique web pour serveurs, destinée à tous(débutants, confirmé et administrateurs système sous Linux), notamment ceux qui sont :
Grâce à Cockpit toute une équipe d'administrateurs peut gérer un système de la manière la plus simple.
Avec cockpit, vous pouvez vérifier : vos containers, votre CPU, votre RAM, disque dur, etc.

Installation sur Ubuntu

L'installation est l'une des plus simples. Il suffit de taper la commande

sudo apt install cockpit

Démarrage de cockpit

Une fois l'installation terminée lancer votre cockpit avec la commande

sudo service cockpit start

Vérification du status

Une fois lancé vous pouvez vérifier son status avec la commande :

sudo service cockpit status

Une fois Cockpit en cours d'exécution, visitez adresse-ip-de-la-machine:9090 dans votre navigateur Web. Si votre navigateur est sur la même machine sur laquelle Cockpit est exécuté, visitez localhost:9090 (par exemple).

Ainsi, une interface qui ressemble à celle-ci s'affichera sur votre navigateur.

Interface de cockpit

NB: Les comptes avec lesquels vous pouvez vous connecter sont les comptes systèmes.

Docker et cockpit

Vous avez la possibilité de vérifier si vos conteneurs sont en cours d'exécution ou s'ils sont en panne.

Il se comporte comme portainer mais en plus avancé, car il contient des graphes et beaucoup d'autres outils.

Pour cela installer sur votre machine le docker-cockpit.

sudo apt-get -y install cockpit-docker

Redémarrer le socket docker pour appliquer les changements

sudo systemctl restart cockpit.socket

Containeur monitoring

Metrics et Cockpit

Lecture et diffusion de données de métriques.
Les métriques concernant le système peuvent être extraites de plusieurs sources à l'aide de "cockpit.metrics()". On peut exploiter les données des métriques avec les fonctions cockpit.series() et cockpit.grid().
Pour plus d'informations, je vous invite à visiter le site officiel de cockpit

Conclusion

Vous pouvez désormais gérer facilement les conteneurs Docker à partir de votre navigateur Web avec une interface facile à utiliser !
Vous pouvez également monitorer votre machine avec cockpit sans soucis !

Sources:
Site officielle de cockpit
Hostwinds

Introduction

Utilisé pour le transfert de Machine-to-Machine (M2M), MQTT est considéré comme l'un des principaux protocoles de messagerie de l'internet des objets, mais côté industriel (IoT). Il est open source, léger (en tête de messages de 2 octets), faible utilisation de la bande passante du réseau (93 fois plus rapides que le HTTP), faible consommation d'énergie (11 fois moins pour envoyer et 170 pour ne recevoir que le HTTP) et fiable (mécanisme natif de Qos, acronyme de Quality of Service).

Son autre avantage, c'est qu'il est extrêmement facile à mettre en œuvre du côté client. C'est donc la solution parfaite pour l'IoT.

Attention cependant, fortement vulnérable si certaines conditions de sécurité ne sont pas réunies, comme l'absence de chiffrage sur la transmission & l'authentification (MQTT est capable d'être déployé sans chiffrement TLS ou SSL.)

Utilisé par nombreux acteurs dans le monde Facebook, openstack, geospatial, Bosh, IBM, Adarfuit, EVERYTHING IoT, Google Home Assistant, Pimatic, MS Azure, certains systèmes de signalisation, systèmes d'alarme, l'industrie du Gaz, de l'électricité et bien plus encore.

MQTT focntionne sur le principe de publication/abonnement(publish/subscribe)

Fonctionnement

C’est quoi un broker MQTT ?

Vous pouvez envoyer une commande pour contrôler une sortie ou vous pouvez la lire à partir d'un capteur et la publier.
Dans Mqtt, il y a quelques concepts de base que vous devez comprendre : publier et souscrire des messages, des topics et des broker.
Le premier concept est le système de publication et d'abonnement.

Qu'est-ce que cela signifie ? Cela signifie que le dispositif peut publier des messages à vos autres dispositifs ou votre dispositif peut s'abonner à un sujet particulier.Pour recevoir ces messages, par exemple, le dispositif 1 publie sur un sujet, le dispositif 2 s'abonne au même sujet que le dispositif 1 publie. Ainsi, le dispositif 2 reçoit le message.

Les messages sont les informations que vous souhaitez échanger entre vos appareils, qu'il s'agisse d'une commande ou de données avec le système de publication/abonnement.
Vous pouvez faire à peu près tout ce que vous voulez dans vos projets de mission en mode autonome.

Un autre concept important est celui des topics. Les topics sont la façon dont vous enregistrez l'intérêt pour les messages entrants ou je vais spécifier où vous voulez publier votre message.
votre message.
Les topics sont représentés par des chaînes de caractères séparées par des barres obliques. Les slashs indiquent le niveau du sujet, voici un exemple
si vous créez maintenant un sujet pour une lampe dans votre propre bureau (home/office/lamp).

Par exemple, si vous souhaitez allumer votre lampe dans votre bureau à la maison, vous publieriez un message dans un topic en utilisant node-red disant on et votre machine sera abonnée à ce même sujet.

Elle recevra donc le message on et allumera finalement la lampe.

Les topics sont sensibles à la casse : Ce qui fait que home/office/lamp et home/office/Lamp sont différents.

Faites attention au terme borker : le broker est principalement responsable de la réception de tous les messages.
Le broker MQTT est un equipement intermediaire entre le publisher et l'abonée, il filtre les messages pour décider qui est intéressé et publie ensuite le message aux clients abonnés.
Il y a plusieurs brokers que vous pouvez utiliser.

Nous allons utiliser le broker mosquito que vous installerez sur votre raspberry pi.

Installer Mosquitto sur Linux ou Raspberry Pi

D'abord mettons à jour notre système avant d’installer Mosquito ce n'est pas obligatoire mais recommandé.

sudo apt update && apt upgrade

Maintenant installons Mosquitto

sudo apt install mosquitto

Pour faire des tests il faut installer Mosquitto client

sudo apt-get install mosquitto-clients

Ici nos tests se baseront justes sur Lunix, si jamais vous voulez installer Mosquito pour Rasperry Pi, installer mosquitto_sub, mosquitto_pub et mosquitto_passwVous voulez faire du mosquito en python? Alors je vous conseille python-mosquitto
Exemple de server pour vos test: Server de test
Pour verifier l'insatllation

systemctl status mosquitto

Installer Mosquitto sur Windows ou macOS

Pour Windows ou macos je vous recommande de télécharger et installer via ce lien

Sécurisé Mosquitto

Maintenant on a Mosquitto qui fonctionne bien sur notre machine.
Mais pas sécurisé, maintenant sécurisons le! Creons un user avec un password
Pour cela tapez

cd /etc/mosquitto

Vous n'avez pas besoin de vous identifier tant que vous ne faite pas une gestion de votre domotique DIY car pour la domotique vous serez amené à sécuriser vos appareils car sinon tout le monde peut accéder à appareils(chauffage, climatisation, motorisation de volets roulants.....).

Donc le mieux c'est de les protéger avec un mot de passe.

sudo mosquitto_passwd -c /etc/mosquitto/passwd USER_NAME

Afin de limiter l'accès aux utilisateurs à un compte, modifiez le fichier de configuration.
Pour cela tapez la commande:

sudo /etc/mosquitto/mosquitto.conf

Ajoutez ceci à la fin du fichier

allow_anonymous false
password_file /etc/mosquitto/passwordfile

Maintenant on redemarre Mosquitto

systemctl restart mosquitto

Publier (envoyer) un message MQTT depuis le terminal

Pour publier un message on utilise la commande mosquitto_pub et pour connaitre les options liées à la commande on utilise mosquitto_pub -help

-h spcifie le nom du broker sur le quel on se connecte (ou IP)
-t spcifie le topic sur lequel le message est publié
-P spcifie le mot de passe (optionnel)
-m spcifie le message à envoyer qui peut être une valeur ou un JSON.
-u spcifie le nom d’utilisateur (optionnel)
-p spcifie le port, qui par défaut est 1883
Pour plus d'information voir documentation

Exemple: on se connecte au serveur -h localhost sur le Topic -t news/football et on publie le message -m j'ai gagné le ballon d'or.

mosquitto_pub -h localhost -t news/football -m "jai gagné le ballon d'or!"

Recevoir (souscrire) des messages

Pour recevoir un message on utilise la commande mosquitto_sub et pour connaitre les options liées à la commande on utilise mosquitto_sub -help
Ouvrez un second Terminal et exécutez la commande suivant.

mosquitto_sub -h localhost -t news/football

Exemple d'échange: à gauche le publisher et à droite le subscriber

Conclusion

Dans ce tutoriel nous avons parlé des avantages et inconvénients de MQTT.
Nous avons installé et testé MQTT en utilisant le serveur mosquito sur Lunix.
Pour ceux qui ont Windows ou macos nous les avons redirigé vers la documentation de Mosquito.
Rappelons que MQTT est un protocole TCP/IP utilisé beaucoup dans l'IoT industriel.Il est le protocole parfait pour votre domotique et est super bien adapté au développement d’objets connectés vus sa rapidité et sa lergerté.

II- Fonctionnement

III- Conclusion

I- Introduction:

Gitflow est un wrapper pour git qui est extrêmement utile pour le Devops.
Il permet de définir un modèle strict de structuration des branches lors de la gestion de grands projets.
Il n'ajoute pas grand choses au fonctionnement initial de Git si ce n'est le fait de pouvoir définir des branches avec des rôles spécifiques pour la gestion du développement local, des déploiement et des diverses maintenances liées à notre projet.

II- Fonctionnement:

Gitflow possède un cli permettant de faire des commandes basiques que vous verrez peuvent bien se faire en utilisant juste Git, mais pour des raisons de facilité nous utiliserons gitflow pour éviter de se tromper.
Vous pouvez l'installer en vous rendant sur le lien suivant.

Pour commencer un projet avec gitflow il vous suffit de faire un coup de git-flow init. Cette commande a le même fonctionnement que git init sauf qu'elle rajoute deux branches aux projets plutôt qu'une master et develop et crée l'organisation des branches de features, release, hotfix, ... dont on parlera dans la suite de cet article.

La commande git flow init sans aucune modification crée ceci

Cette commande peut être faite sans avoir besoin de git-flow en faisant:

git branch develop
git push -u origin develop

Au lieu de n'avoir que la branche master pour gérer l'entièreté du projet, gitflow crée la branche develop qui s'occupera de toutes les features qui seront développée et au debut cette branche là est directement forkée à partir de la branche master. La branche master ne servira qu'à stocker les informations sur les releases.
L'arborescence du git ressemblera à ceci

Maintenant que nous savons comment GitFlow crée le repo git sur le projet, nous allons essayer de démystifier les branches features, hotfix et release.

Features:

Les branches features sont forkées à partir de la dernière version de develop.
Elles se basent sur le fait que chaque fonctionnalité du projet doit résider sur une branche propre à elle et ne doit pas intéragir avec la branche master mais directement mergée sur develop à la fin son développement.
Pour créer une nouvelle feature la commande git-flow correspondante est:

git flow feature start feature_name

Avec git:

git checkout develop
git checkout -b feature_name

Ces branches comme toutes les autres d'ailleurs peuvent être rendues publiques pour des fins de collaboration. C'est à ça que sert la commande publish de git flow.
Pour publier notre branche feature_name, la commande correspondante est git flow feature publish feature_name.

Une fois le developpement de la feature terminée, elle sera mergée sur develop souvenez-vous rien ne doit toucher à la branche master venant des features.
Avec git flow:

git flow feature finish feature_name

Avec git:

git checkout develop
git merge feature_name

Releases:

Une release peut être vue comme une autorisation de publier. Elles sont nées lorsque la branche develop atteint un certain niveau de maturité et que l'on ait besoin de publier et partir de cette nouvelle base.
Une fois qu'une release est initiée il ne faut rajouter aucune feature dans celle-ci, on ne peut faire que des opérations de modifications mineures comme des résolutions de bugs par exemple.
Les releases sont forkées de develop pour aller se brancher sur master et representer de nouvelles versions du projet.
Il est important après une release de remerger le projet sur develop vu que des modifications ont peut-être pû être apportées entre l'initiation et la fin.
Pour créer une release avec git flow:

git flow release start version

Je vous invite à vous rendre sur ce lien pour comprendre comment les versions sont faites.
Avec git:

git checkout develop
git checkout -b release/version

On peut de la même manière qu'avec les features publier les release pour des fins de collaboration.
On peut se mettre sur la branche release publiée par un autre membre de l'équipe ou soi-même avec la commande git flow release track version.

Une fois que tout est prêt pour terminer la release, on la met sur master, on supprime la branche intermédiaire créée, et on n'oublie surtout pas de remerger sur develop.
Avec git flow:

git flow release finish version

Avec git:

git checkout master
git merge release/version
git checkout develop
git merge release/version
git branch -D release/version

Hotfixes

Les hotfixes ou branches de maintenance servent à faire des résolutions de bugs pour des versions dejà publiées sur master. Ce sont les seules branches à pouvoir directement récupérer le code se trouvant sur master et il faut noter qu'après avoir fini la maintenance il faut la merger et sur master et sur develop pour qu'elle puisse être repercutée dans tout le système.
Elles sont là pour éviter d'arrêter le développement pour de la maintenance.
Pour débuter une branche de hotfix avec git flow
git flow hotfix start branch_name
Avec git

git checkout master
git checkout -b branch_name

Pour terminer la maintenance avec git flow
git flow hotfix finish branch_name
Avec git

git checkout master
git merge branch_name
git checkout develop
git merge branch_name
git branch -D branch_name

III- Conclusion

Ce tutoriel est un bref résumé du fonctionnement de git flow qu'est aujourd'hui un outil intéressant pour faire du devops. Il vous aidera à sauver du temps et vous évitera des problèmes lourds en production ou en développement.

Vous avez peut-être eu besoin ou aurez un jour besoin de vous connecter à un serveur ou une machine distante sans devoir vous y déplacer physiquement.
Vous ne savez peut-être pas comment vous y prendre, ne vous inquiétez pas il existe un outil fait pour vous y aider en toute sécurité( s'il est bien configuré évidemment xD).

SSH ou Secure Shell est le meilleur moyen de vous connecter et d'administrer vos systèmes. Il est utilisé pour récupérer un Shell distant ou pour tunneliser une application.
Il a existé de nombreuses distributions de SSH mais la plus utilisée de nos jours reste OPENSSH qui vient de OPENBSD, pour les systèmes windows nous retrouvons Putty et winsshd.

Nous allons principalement nous focaliser sur OPENSSH dans ce tutoriel

Serveur SSH

Pour installer le serveur ssh sur les systèmes Debian et compagnie.

sudo apt-get update
sudo apt install openssh-server

Une fois le serveur installé, vous pouvez vérifier s'il est lancé, le lancer ou l'arrêter et vous pouvez aussi l'ajouter aux tâches à lancer au démarrage de la machine.
Pour lancer le serveur

sudo systemctl start ssh

Pour vérifier le statut du serveur afin de vérifier qu'il est actif

Pour arrêter le serveur

Configuration:

La configuration du serveur se trouve dans /etc/ssh/sshd_config.
Il y'a plusieurs paramètres dans ce fichier dont certains qui ne serviront pas. Nous allons survoler assez rapidement ceux qui vous serviront le plus.

Port 22

HostKey /etc/ssh/ssh_host_rsa_key
HostKey /etc/ssh/ssh_host_ecdsa_key
HostKey /etc/ssh/ssh_host_ed25519_key

La première ligne permet de fixer le port d'écoute pour les connexions qui par défaut est le 22 pour ssh mais vous pouvez bien le mettre sur un port différent pour des raisons que j'ignore.

Les trois dernières lignes permettent de localiser les clés d'hôtes.

LoginGraceTime 120
PermitRootLogin yes
StrictModes yes

• StrictModes permet de réfuser la connexion si les fichiers n'ont pas les bons droits
• PermitRootLogin permet d'activer ou non la connexion au compte root via ssh. Cette option doit être mise à no car la plus part du temps on configure un compte qui a accès à sudo ou su et on n'autorise pas du tout l'accès par le compte root.
• LogiGraceTime précise combien de secondes pour maintenir la connexion active sans se connecter avec succès.

Il y'a des options qui vous permette à partir du client ssh d'expprter une fenêtre graphique pour une application. Pour celà il faut activer le X11Forwarding

X11Forwarding yes
X11DisplayOffset 10

Une fois vos modifications enregistrées il faut recharger le serveur

sudo systemctl reload ssh

Maintenant que nous savons faire des configurations basiques du serveur, nous allons apprendre à configurer et se connecter au serveur dans la partie suivante

Client SSH

Dans le cycle de développement d'une application,  la gestion du code (collaboration et version) est une étape importante.

Linus Torvalds créa git en 2005 en afin de remplacer BitKeeper qui assurait le partage gestion des patch du noyau Linux. Git est parti donc de ces  principes: vitesse, distribution, simplicité et est  distribué selon les termes de la licence GNU 2.0.
C'est un logiciel de contrôle des versions décentralisées. Permettant ainsi à un groupe de personnes de travailler sur un même projet en gérant les différentes versions et fusionnant à un moment donnant leur travail. C'est l’outil de gestion de version le plus populaire.
Git permet de gérer tout type de documents textes, donc il n'est pas destiné uniquement aux développeurs, mais aussi à des utilisateurs d'outils comme latex ou Markdown pour leur création de contenu.

I - Installation

L'installation de git est assez simple en fonction de votre système d'exploitation:

A - Windows:  Git est disponible en téléchargement sur ce lien. Après téléchargement, l'installation se fait de la manière que toute application Windows.

B- Linux et dérivé: Sur les systèmes linux (Ubuntu, Debian, Redhat, ...), l'installation se fait directement via le source code disponible sur  Github (un peu compliqué) ou en utilisant simplement le gestionnaire de package correspondant au système d'exploitation (apt, aptitude, yum, ....).

apt-get install git

L'installation est maintenant terminé, vous pouvez vérifier la version de git installée grâce à cette commande:

git --version

Dans la prochaine section nous verrons comment initialiser notre 1er "repository" (appellation commune des dossiers git).

Pour la suite je considère que vous utilisez un terminal linux, mais sachez que que  les commandes Git restent valide sur Windows.

II - Création d'un "repository" local

Dans cette section, nous allons créer un projet sur la machine local et gérer son évolution avec git. Pour cela suivez ces étapes:

1- Créer un dossier  qui va contenir notre projet git :

mkdir tuto-git
cd tuto-git

Une fois dans le dossier (tuto-git), nous allons maintenant initialiser le repository :

➜  tuto-git git init
Initialized empty Git repository in /Users/boubacar/Desktop/projects/git/tuto-git/.git/

Après initialisation, un dossier ".git" sera créé dans le répertoire. il sera visible avec la commande "ls -al".

Ce dossier ".git" contient l'ensemble des informations de notre projet. Nous allons nous intéresser particulièrement au fichier  ".git/config" qui évoluera tout au long de ce tutoriel.

Avant de continuer nous allons configurer 2 variables qui vont nous aider à identifier l'utilisateur qui effectue les actions sur le repository git. Remplaces ces valeurs par ton nom et votre adresse email. (Oui là, on va se tutoyer maintenant).

git config --global user.name "Your Name"
git config --global user.email you@example.com

2- États du repository et création des fichiers:

Vérifions l'état de notre repository (dossier git) avec la commande: git status

Il est mentionné que nous somme sur la branche master et qu'aucun commit n'a pour l'instant été effectué. Quelques définitions:
-  Une branche est un dossier virtuel dans le repository qui contient des commits.
- Un commit est une sauvegarde d'un état du repository. Chaque commit peut être accessible avec son ID.

Pour un début nous allons travailler sur la branche par défaut qui dans notre cas s'appel "master" et nous ferons évoluer notre repository dans cette branche.
Nous allons créer un 1er fichier que nous allons appeler tuto-git.py qui sera notre programme python à manipuler.

tuto-git.py

def main():
    print("Bienvenue sur Git")

if __name__ == "__main__":
    main()

L'état de notre repository va changer avec l'ajout de ce ficher. Toujours avec la commande "git status" nous aurons:

Le fichier est vu par git, mais est pour l'instant à l’état "Untracked".  A rappeler qu'un fichier git peut avoir l'un des 4 états affiché sur le schéma ci-dessous.

Pour que le fichier soit pris en compte nous devons l'ajouter à git avec la commande:

$ git add tuto-git.py

Le fichier passe ainsi à l'état "Stagged". A noter que la commande "git add " permet d'ajouter plusieurs fichier (et uniquement des fichiers) en les séparant par un espace ou bien ajouter tout le contenu du répertoire git avec la commande:

# Ajoute tout le contenu du repertoire
$ git add . 

# Ajoute tout le contenu de dossier 
$ git add dossier/* 

Une fois le fichier ajouté, nous pouvez créer notre 1er commit qui sera l'enregistrement de l'état de notre répertoire dans git. Et comme indiqué au niveau du schéma des états, le fichier passera à l'état "Unmodified". Pour créer un commit, nous utilisons la commande suivante avec le paramètre  "-m" permettant de spécifier le message.

Notre commit s'appel "Mon coomit: 1". Tu aurais pu mettre un nom de commit différent, en général il correspond à une description de tes modifications. Nous voyons aussi que git nous fait un petit résumé des modifications.

Voici la liste des commits disponibles avec la commande: "git logs"

Nous reviendrons plus en détails sur la magie de "git log", mais intéressons nous un peu à cette image. Nous avons:

• L'identifiant du commit : b0ea64360e6ea6165e98d95e2eb668ee325aec8d
• La branche associé au commit: master
• Auteur du commit: Ce sont les infos que nous avions saisi au début avec la commande "git config --global user.name" et "git config --global user.email"
• Messsage: "Mon commit: 1"

Nous allons effectuer les opérations suivantes afin d'avoir 3 commits au niveau de notre repository:
a - Modifier le contenu de contenu du fichier avec un éditeur de texte classique et remplacer notre texte (print) par  "Bienvenue sur ce cours Git". Un git status nous montre que le fichier repasse à l’état "Modified".

En plus du "git status",  nous pouvons vérifier les modifications effectuées (depuis le commit précédent) avec la commande: "git diff".

Il faut à nouveau refaire les commandes:

# Changer l'état à Stagged
$ git add tuto-git.py

# Changer l'état à Unmodified
$ git commit -m "Changement du message"

b -  Créer un second fichier  que nous allons appeler "lib-python.py" qui aura pour commit message "Ajout d'une lib" une fois ajouté à git.

Le fichier lib-python.py contient uniquement la ligne: #Lib python

Maintenant que nous avons 3 commits nous pouvons voyager dans le temps.

3- Voyage dans le temps

Revoyons vite fait nos commits et leur infos sur la branche master:

Pour avoir un minimum d'informations, nous pouvons rajouter des paramètres à la commande "git log".

A noter qu'il y'a plusieurs format de logs que vous pouvez afficher. Celà peut par exemple être utile lorsque vous effectuer des releases notes. Plus de details sur ce site-web.

Attentions, les commit ID seront différents sur ton ordinateur. Tu remarquera aussi la branche master correspond toujours au dernier commit. En accéder à une branche correspond juste à accéder au dernier commit, et HEAD est une variable qui correspond au commit sur lequel nous nous trouvons.
cela:

Accèder au 1er commit

$ git checkout b0ea643

Mettre les 7 premières valeurs du commit sont suffisant. Git t'informera que que HEAD pointe maintenant vers ce commit. Tu remarqueras aussi le fichier que l'etat de notre dossier a changé:

• Le dernier fichier que nous avons rajouté a disparu.
• Le fichier tuto-git.py a repris son contenu initial.

Verifier le commit actuel.

Il suffit d'afficher le HEAD.

$ git show head

Créer une branche

Une branche est créée (par defaut) à partir du HEAD sur lequel nous nous trouvons, ce qui peut donc être un commit ou une autre branche. Nous allons nous deplacer vers le commit 2 et créer une branch que nous appelerons "dev".

$ git checkout 37ec6a7
$ git checkout -b dev
# le paramètre -b indique que nous créeons une nouvelle branch

Nous aurons ainsi ce graphe, qui indique que la branche "dev" se situe sur le second commit.

La branche dev devient ainsi notre nouveau HEAD et nous pouvons y rajouter d'autres modifications. La branch master dépasse pour l'instant dev d'un commit qui correspond au dernier fichier que nous avons ajouté (lib-python.py). Ce fichier ne s'affichera que lorsque nous revenons sur la branche "master".

$ git checkout master

Nous pouvons ainsi créer plusieurs branches qui vont correspondre à la modification (sujet du sprint) que nous voulons effectuer.

Voici  un exemple de repository différent du notre  ayant plusieurs branches:

Une fois l'ensemble des modifications effectuées sur une branche, nous pouvons les appliquer sur la branche principale (master) en effectuant une fusion.
Ainsi, plusieurs développeurs peuvent ajouter des modifications du projets sur des branches différentes et fusionner plus tard leurs modifications sur la branche principale.  Pour effectuer cette fusion il faut:

Se placer sur la branche qui reçoit la fusion (master par exemple)

$ git checkout master

Fusionner la branche dev vers master

$ git merge dev

Tous les commits qui ont été rajouté sur la branche  "dev" vont ainsi se retrouver sur la branche "master".

4- Ajouter des versions grâce aux tags

Lors de la création d'un projet, nous utilisons un système de version qui est en général sous ce format X.Y.Z ( Ex: 1.0.1) où les valeurs de X, Y ou Z correspondent à une évolution d'une certaine catégorie de fonctionnalité de notre projet. Plus de détails sur ce format avec cette page  qui décrit le semantic versionning.
C'est en anglais je sais, mais dis toi que moi aussi j'aurai pu ecrire ce document en anglais.

Une version n'est rien d'autre qu'un commit que nous allons nommer au format X.Y.Z. Ci dessous les commandes pour créer un tag ou le manipuler:

Se placer au niveau du commit à nommer.

$ git checkout 224916aef8c1776778eb79c0537365d4989d374c

Ajouter un tag avec un message

git tag -a 1.4.0 -m "my version 1.4.0"

Ajouter un tag sans message

git tag  1.4.0 

Afficher les tags

git tag 

Supprimer un tag

git tag -d 1.4.0 

Accèder à un tag specifique:

git checkout 1.4.0

Ces tags sont ainsi beaucoup plus facile à manipuler que les commits et permettent de livrer une version spécifique de notre projet.

II - Rappel des commandes de base:

Ci-dessous les commandes à retenir pour manipuler votre "repository git".

1- Le rapository git

• Creation

$ git init

• Suppression du repository

$ rm -r .git

2 - Les branches

• Création d'une branche

$ git checkout -b nom_branche 

• Liste des branches

$ git branch 

• Accèder à une branche

$ git checkout nom_branche 

• Fusionner 2 branches

$ git checkout nom_branche_destination
$ git merge nom_branche_source

• Supprimer une branche

$ git branch -D nom_branch 

3 - Les commits

• Ajouter un ou des fichiers au prochain commit

$ git add nom_fichier_1 [nom_fichier_1 .... nom_fichier_X]

• Ajouter tous les fichiers

$ git add .

• Créer un commit

$ git commit -m "Message du commit"

• Modifier le commit précedent après avoir rajouté un fichier

$ git commit --amend 

• Liste de commit

$ git log
$ git log --oneline

• Annuler les modifications effectué lors d'un commit

$ git revert IDENTIFIANT_COMMIT

4 - Les tags

• Créer un tag

$  git tag -a nom_tag IDENTIFIANT_COMMIT -m "Message du tag"

• Créer un tag sans le message

$  git tag  nom_tag IDENTIFIANT_COMMIT 

• Afficher les details d'un tag

$  git show  nom_tag 

• Afficher la liste des tags

$  git tag

• Accèder à un tag

$  git checkout nom_tag

• Supprimer un tag

$  git tag -d nom_tag

Pour la suite de ces tutorials qui portent sur Git, nous parlerons d'un outils GitFlow qui permet de faciliter la création et la fusion des branches au niveau d'un projet. Retrouvez cet article expliqué sur ce lien.