Comment annuler une validation dans Git (Tutoriel PowerShell Git)

PowerShell

un ordinateur de bureau affichant un tutoriel Git dans PowerShell

Que vous écriviez des scripts de manière isolée ou que vous travailliez en équipe, il est essentiel de pouvoir suivre les différentes versions de votre code. Il peut arriver que du code ajouté finisse par ne pas fonctionner, et la possibilité d’annuler ces modifications (sans supprimer manuellement le code) peut sauver votre projet. Dans cet article, je vais vous expliquer comment utiliser la commande de réinitialisation Git reset pour revenir à une validation (« commit ») précédente de votre code dans le système de contrôle de source Git, et j’aborderai les sujets suivants :

Accédez à une série de cours sur l’automatisation des tâches Active Directory à l'aide de PowerShell et obtenez 3 crédits CPE (cours en anglais)

"PowerShell peut vous aider à automatiser des choses allant de la création de rapports AD à la création de boîtes aux lettres Exchange... et même à contrôler votre système d'arrosage."

Connaissances préalables requises : Comment utiliser Git ?

Le client Git doit être installé sur votre système. Vous pouvez télécharger le client ici, et un guide d’installation est disponible ici. Le client Git permet d’exécuter des commandes Git à partir du terminal. Vous aurez également besoin d’un fichier à modifier et pour lequel vous suivrez les modifications. Dans cet article, j’utilise un script PowerShell, mais vous pouvez utiliser le script que vous souhaitez.

Qu’est-ce que Git et que sont les validations Git ?

vue d'ensemble de ce que signifie Git et les validations dans Git

Git est un outil répandu de contrôle de code source qui assure le suivi des changements à l’aide de validations. Créer une validation revient à sauvegarder une version d’un fichier ou d’un groupe de fichiers. La validation assure le suivi des versions du fichier grâce à l’identifiant unique (ou SHA ou hachage) qui lui est associé. Cet identifiant unique permet de revenir à des versions de fichiers précédemment validées dans le référentiel.

Un workflow typique comprend les tâches suivantes :

    1. Extraction des fichiers du référentiel distant.
    2. Modification des fichiers locaux.
    3. Validation des changements.
    4. Envoi (« push ») des nouveaux fichiers vers le référentiel.

Toutefois, si vous ne disposez pas d’un référentiel distant centralisé ou si le fait de pousser/tirer/fusionner du code vous met mal à l’aise, vous pouvez toujours exploiter Git en l’utilisant sur votre système local. Vous pouvez valider des changements dans votre code et revenir sur ces changements pour vous familiariser avec les validations.

1. Configuration d’un référentiel local Git

La première commande pour démarrer est Git init. Cette commande initialise le dossier actuel en tant que référentiel Git. Dans cet exemple, j’initialise le dossier de projet en tant que référentiel Git.

  1. Git init

capture d'écran d'une commande Git init dans PowerShell

La commande ajoute un dossier caché nommé « .Git » qui assure le suivi de la branche active actuelle, des fichiers de configuration, des alias, et d’autres données.

capture d'écran d'un dossier créé avec la commande Git init

Ensuite, il me faut un fichier de travail afin de suivre des modifications. J’ai un fichier de script PowerShell appelé « myScript.ps1 ». Le script contient une boucle for qui itère cinq fois et sort à l’écran. Cette première boucle sera ma boucle extérieure. La finalité du code n’a pas d’importance en elle-même, je cherche simplement à montrer des modifications de code pour un script simple.

capture d'écran d'un fichier script PowerShell

L’étape suivante consiste à afficher l’état du référentiel en exécutant Git status. L’état indiquera sur quelle branche je suis (pour l’instant, sachez simplement que je suis sur la branche « Maître »). Il montrera également tous les fichiers nouveaux ou modifiés à partir de la dernière validation en les affichant en rouge.

capture d'écran montrant comment exécuter Git status

2. Suivi et validation de fichiers dans Git

Si je veux suivre les fichiers pour valider leurs modifications, je dois les ajouter à la zone de transit à l’aide de la commande Git add. Cette commande peut spécifier un ou plusieurs fichiers à ajouter à la zone de transit. Dans le cas présent, je n’ai qu’un seul fichier, et je l’ajoute en spécifiant son nom. Je vérifie ensuite l’état du référentiel pour visualiser le script dans la zone de transit.

  1. Git add myScript.ps1
  2. Git status

capture d'écran montrant comment utiliser la commande Git add dans PowerShell

Maintenant que je suis le fichier dans la zone de transit, je dois créer une validation de l’état du référentiel. J’utilise la commande Git commit avec l’option -m pour attribuer un message à la validation. Le message de validation doit être court mais descriptif pour indiquer les modifications apportées au code. Une fois la validation terminée, j’exécute un autre Git status pour vérifier qu’aucun autre fichier ne se trouve dans la zone de transit ou n’a été modifié depuis la dernière validation.

  1. Git commit -m “first version of script – outer loop only”
  2. Git status

3. Validation des changements additionnels dans Git

Maintenant que j’ai mon premier message de validation dans mon référentiel, je dois ajouter une amélioration à mon code. J’ajoute une autre boucle à l’intérieur de la boucle extérieure, que j’appellerai la boucle interne.

capture d'écran montrant comment suivre et valider des fichiers dans Git à l'aide de PowerShell

Si j’exécute à nouveau Git status, je verrai les mêmes résultats que précédemment. Le fichier apparaîtra comme étant non suivi car le fichier script a été modifié depuis la dernière validation. Je vais répéter le workflow de commandes pour ajouter le fichier et le valider. Mon message de validation montrera que j’ai ajouté la boucle interne.

  1. Git status
  2. Git add myScript.ps1
  3. Git commit -m “Added inner loop”

capture d'écran d'un message de validation Git

4. Gestion des validations Git

Maintenant que le référentiel contient quelques validations, je peux me tourner vers la commande Git log. Cette commande affiche les validations précédentes ainsi que les messages de validation. Chaque validation possède une valeur de hachage unique pour l’identifier. Dans cet exemple, la dernière validation est celle où j’ai ajouté la boucle interne, et elle est indiquée par le pointeur HEAD.

capture d'écran montrant comment gérer les validations Git dans PowerShell

Supposons maintenant que je ne souhaite pas conserver mon dernier changement et que je souhaite revenir à une version antérieure du script. Je pourrais supprimer manuellement la boucle interne, car ce script est suffisamment court pour le faire. Toutefois, cela pourrait poser problème pour les projets de codage plus importants. Je risquerais de supprimer trop de code, ou pas assez, et ainsi créer de nouveaux problèmes.

Au lieu de cela, je peux utiliser les sept premiers caractères de la valeur de hachage du journal des validations pour revenir à une version précédente du référentiel. Pour cela, j’utilise la commande Git reset tout en indiquant le hachage du journal des validations :

  1. Git reset a6dd1c2

capture d'écran montrant comment utiliser la commande Git reset dans PowerShell

Cette commande réattribue HEAD à une validation spécifique. La capture d’écran montre que myScript.ps1 est de retour dans la zone de transit avec les changements effectués à partir de la validation a6dd1c2. Si j’exécute à nouveau Git log, HEAD est revenu à la validation précédente, et la validation de l’ajout d’une boucle interne est supprimée.

capture d'écran montrant comment utiliser Git pour revenir à une validation précédente

Pour revenir au fichier, je dois extraire le fichier de la validation à l’aide de la commande Git checkout. Une fois le fichier extrait, je peux afficher son contenu, qui révèle que seule la boucle externe est présente. J’exécute ensuite Git status pour montrer que l’arbre actuel n’a pas de modifications à suivre.

capture d'écran de la procédure d'extraction d'un fichier à partir d'une validation avec la commande Git checkout

Glossaire des commandes Git

Voici une liste des commandes PowerShell Git que j’ai utilisées et leurs fonctions respectives :

glossaire des commandes Git PowerShell courantes

Si vous débutez dans le contrôle de version et n’êtes pas suffisamment sûr de vous pour travailler avec des référentiels distants, vous pouvez travailler avec un référentiel local et bénéficier des mêmes avantages. Vous pouvez utiliser ces commandes Git fondamentales afin de vous familiariser avec le processus d’utilisation de Git pour le contrôle de version.

Jeff Brown

Jeff Brown

Jeff Brown est un ingénieur en informatique Cloud, spécialisé dans les technologies Microsoft telles qu'Office 365, Teams, Azure et PowerShell.

 

Votre cybersécurité est-elle au cœur de votre infrastructure ?

Bénéficiez d'une évaluation personnalisée des risques auxquels sont exposées vos données, effectuée par des ingénieurs passionnés par la sécurité des données.