Bases de l’automatisation et des scripts Bash (partie 3) –
Shutterstock / Mopic
Dans ce dernier article de notre série en trois parties sur l’automatisation et les scripts Bash, nous explorerons le débogage de scripts, l’exécution de scripts en arrière-plan et l’importation d’autres scripts à l’aide de la commande source.
Sommaire
Bases de l’automatisation et des scripts Bash
Si vous souhaitez commencer par le début, veuillez lire notre article Bash Automation and Scripting Basics Part 1. Ce dernier article de notre série en trois parties sur les bases de l’automatisation et des scripts Bash se penchera sur l’exécution de scripts en arrière-plan.
Nous voulons également déboguer rapidement nos scripts avec un minimum de tracas et des résultats haut de gamme. Cela peut être fait en utilisant une fonction de traçage très pratique, intégrée directement dans l’interpréteur de commandes Bash. Nous examinerons cela dans le deuxième sujet. Vous voudrez peut-être également garder un œil sur notre prochain article sur la vérification du shell.
Et enfin, nous explorerons comment exécuter des scripts en tant que processus d’arrière-plan. Bien que cela puisse offrir des avantages immédiats modestes – comme le démarrage de plusieurs tâches à la fois, cela pose également une partie du travail de base pour les scripts multithreads plus avancés ultérieurs.
Débogage de script
Déboguer un script dans Bash n’a pas besoin d’être difficile! Gardez un œil sur le site Web CloudSavvyIT dès que nous passerons en revue l’outil de débogage Shellcheck plus complet pour Bash, mais pour le moment, je voudrais vous présenter un excellent moyen de déboguer les scripts Shell de manière simple et facile à comprendre.
Dans le shell Bash, qui après tout est un « Facile » binaire fonctionnant sur votre machine – à savoir le bash binaire, une option est fournie (-x) qui, selon man bash (l’exécuter dans votre terminal affichera un manuel Bash) est décrit comme Imprimer les commandes et leurs arguments au fur et à mesure de leur exécution, et c’est exactement ce qu’il fait! Comment cela aidera-t-il au débogage? Jetez un œil à l’exemple suivant:
#!/bin/bash
A=1
B=2
if [ "${AA}" == "1" -o "${B}" == "1" ]; then
echo "One ('1') was definitely stored in either the variable A, or the variable B"
exit 0
else
echo "Assert: could not locate the value '1' in the variables A and B"
exit 1
fi
Ici, nous vérifions les variables A et B contre la valeur 1. Le -o idiome dans le if déclaration signifie OR, soit soit la première partie (A, ou plutôt AA Voici 1) est vrai, ou la deuxième partie (B est 1) est vrai et dans ce cas, le succès est atteint.
La sortie du script sera l’assertion programmée, et le programme se terminera avec un code de sortie de 1, ce qui signifie généralement qu’il y a eu une erreur. Si le script avait fonctionné correctement, un message de confirmation serait affiché et le script se terminerait par un code de sortie de 0, ce qui signifie généralement qu’il y a eu du succès dans tout ce que le script ou l’utilitaire était censé faire.
Alors pourquoi le script se heurte-t-il à l’assert? Vous avez peut-être déjà remarqué que la variable A a rencontré une faute de frappe dans notre if déclaration, enregistrée dans le code comme AA: un bug! Nous pourrions aller vérifier le script, et s’il est aussi court et simple que le script montré ici, le bogue serait rapidement trouvé. Mais pour un programme de 5000 lignes, la solution n’est pas aussi simple, surtout pas s’il utilise plusieurs threads, des sous-shell complexes, etc.
Déboguons ceci maintenant avec le -x option à Bash. Vous vous souvenez peut-être de la deuxième partie de notre cours de base sur l’automatisation et les scripts Bash qu’un sous-shell peut être lancé à l’aide d’un $( ... ) ensemble d’idiomes. Il peut également être lancé en tapant simplement bash, ou dans ce cas bash -x à l’intérieur de notre coque supérieure. Dans ce cas, nous exécuterons le script dans notre sous-shell Bash, avec le -x option pour observer ce qui se passe étape par étape.
Nous avons donc exécuté bash -x ./test_debugging.sh et observez que le contrôle conditionnel suivant est en cours: '[' '' == 1 -o 2 == 1 ']'. Nous remarquons que quelque chose ne va pas: la valeur de 2 est comparé à 1 dans la deuxième partie de notre vérification conditionnelle, mais que se passe-t-il dans la première partie? Quelque chose est comparé à 1, mais ça quelque chose est… vide (comme indiqué par la chaîne vide '')!
Nous vérifions ensuite notre script pourquoi cet endroit vide est là, et pourquoi il n’a pas été rempli avec la valeur de notre A variable. Nous réalisons rapidement le AA au lieu de A erreur, corrigez l’erreur et le script fonctionne maintenant correctement!
Une chose vraiment cool à retenir lors de l’utilisation bash -x c’est que tu peux tee (lire ceci comme ‘copie’) la sortie de la commande Bash en redirigeant le stderr (la sortie d’erreur) vers stdout (la sortie standard) et en capturant le même avec tee:
Ici, nous exécutons notre script fixe et redirigeons la sortie d’erreur (bash -x envoie toute sa sortie de débogage informative à stderr, la sortie d’erreur standard, et non à stdout) en utilisant 2>&1 (qui redirige notre sortie stderr vers stdout – notre sortie standard – à la place). Nous capturons ensuite stdout en utilisant tee et cela enregistrera la sortie dans le fichier spécifié, à savoir bash_-x_output.txt.
Cela permet à un développeur Bash de revoir lentement, dans un format étape par étape, son code écrit. Surtout lorsque les programmes deviennent complexes, ont des fonctions, deviennent multi-threads, démarrent des processus d’arrière-plan, etc., cette méthode de débogage peut être très utile. A titre d’exemple, j’ai tendance à utiliser bash -x environ une fois tous les quinze jours pour déboguer des scripts complexes.
Exécution de scripts en tant que processus d’arrière-plan
Exécuter un script en arrière-plan est simple: il suffit d’apposer & à la fin du nom du script (avec un espace entre les deux). Nous définissons background.sh comme suit:
#!/bin/bash sleep 2
Nous le démarrons ensuite de la manière suivante – pour mettre en évidence le fait qu’il fonctionne en arrière-plan:
Ce que nous pouvons voir se produire ici est le suivant: le background.sh le script est lancé en arrière-plan (étant donné le & apposé au nom du script avec un espace), et l’invite de commande reviendra immédiatement. Nous utilisons ceci ici en spécifiant la commande suivante (sleep 1) directement après le & idiome d’arrière-plan, qui termine également cette commande par une commande unique / unique (en d’autres termes, sleep 1 est une commande complètement nouvelle).
Nous mettons également fin à notre sleep 1 commande avec une coutume fin de commande Idiome bash, après quoi nous exécuterons un echo que le sleep 1 est terminé / terminé. Voyons ensuite ce qui se passe lors de l’exécution de cette ligne.
Immédiatement, notre processus / script d’arrière-plan (background.sh) est démarré et cela durera environ 2 secondes. Le PID (identificateur de processus) du processus d’arrière-plan démarré est affiché visuellement (à savoir, 773183 pour notre premier ([1]) processus d’arrière-plan – et ce PID sera différent chaque fois que vous démarrez un programme / processus d’arrière-plan), et notre sleep 1 (l’instruction suivante pour l’exécution) peut maintenant être exécutée car l’autre programme a renvoyé notre invite (bien que ce ne soit pas directement montré ici, c’est ce qui se produit lorsque vous démarrez un processus en arrière-plan; vous récupérez immédiatement l’invite de commande).
Le sleep 1 commence (avec le sleep 2 ou plus précisément le background.sh script toujours en cours d’exécution en arrière-plan, en tant que processus différent, dans un sous-shell démarré sous ce shell de niveau supérieur ou supérieur), et se termine après 1 seconde. Après cela, notre echo est exécuté, nous montrant le sleep 1 est complet. Une seconde plus tard, notre background.sh le processus arrondit son attente de 2 secondes et se termine.
Nous ne voyons pas qu’il s’est terminé car le shell Bash attend une interaction pour nous montrer messages d’état. Ainsi, dès que nous appuyons sur Entrée, à tout moment après la fin des deux secondes de sommeil, nous verrons la fin du processus d’arrière-plan comme un [1]+ Done ./background.sh message d’état. Si vous revenez à la deuxième partie de notre mini-série, vous pouvez également voir comment nous aurions pu utiliser wait ici pour attendre l’achèvement / la fin du PID du processus d’arrière-plan. Il met également en évidence le nombre de commandes et d’utilitaires pouvant être utilisés de manière combinatoire dans Bash.
Importation de scripts à l’aide de la source
L’importation d’un autre script peut être effectuée facilement en utilisant le Bash source commander. Considérez le script suivant testsource.sh:
#!/bin/bash
source mysource.sh
echo "${MYVAR}"
Et la correspondance mysource.sh:
#!/bin/bash MYVAR="Hello CloudSavvyIT Readers!"
Si nous faisons simplement le premier script (testsource.sh) exécutable (en utilisant chmod +x testsource.sh), mais pas le deuxième script (en fait, nous désactivons l’indicateur exécutable pour montrer clairement que cela fonctionne en utilisant chmod -x sur mysource.sh), le deuxième script est toujours appelé avec succès suite à la source commande, et exécutée dans le cadre de la testsource.sh scénario:
Dans le mysource.sh script, nous définissons la variable MYVAR à Hello CloudSavvyIT Readers!. Ce script provient ensuite du testsource.sh script en utilisant l’instruction source mysource.sh. Cela provoquera le mysource.sh à exécuter à ce stade le code, et une fois terminé, le testsource.sh Le script continuera à s’exécuter, même si tout élément défini dans le mysource.sh sera conservé (pensez-y comme provenant d’un autre script pour se souvenir plus facilement de l’opération).
En résumé
Nous avons examiné le débogage de script en utilisant bash -x pour afficher toutes les commandes exécutées. Nous avons également exploré comment exécuter un script en tant que processus d’arrière-plan et appris comment importer des scripts à l’aide de source. Merci pour rester à l’écoute de cette série en 3 parties, dont c’était le dernier article!
Si vous souhaitez en savoir plus sur Bash, que diriez-vous de consulter notre ou nos articles Primer: Bash Loops: for, while, and Until, Conditional Testing in Bash: if, then, else, elif et Bash Functions and Local Variables
