nous voulons généralement qu’un script s’exécute rapidement, mais ce n’est pas toujours le cas. Parfois, il est logique que notre script Bash utilise la commande sleep avant d’exécuter la commande suivante. Voyons quand

quelle est la commande Bash sleep?

la commande Bash sleep retarde l’exécution de la commande après pendant un temps donné. Le temps de sommeil est exprimé en secondes. L’utilisation de la commande sleep est courante lors de la planification d’une tâche toutes les X secondes ou lorsqu’un script s’appuie sur un autre script pour terminer son exécution.,

examinons trois scénarios dans lesquels vous utiliseriez la commande sleep:

1. au lieu d’exécuter une commande immédiatement, vous souhaitez planifier son exécution X secondes à l’avenir.
2. Un programme qui prend beaucoup de temps pour traiter un ensemble de fichiers et lorsque le traitement est terminé, il génère un fichier pour indiquer qu’. Vous pouvez écrire un script qui vérifie si ce fichier existe et dort pendant une certaine période de temps si ce n’est pas le cas. sinon, exécute l’étape suivante du processus en fonction des fichiers générés par le premier programme.,
3. vous appelez une API tierce par programmation et vous savez que L’API n’autorise pas plus de 60 requêtes par minute. Dormir pendant X secondes vous permet de vous assurer de ne pas dépasser le nombre de requêtes par minute autorisé par le fournisseur D’API.

commençons!,

syntaxe de base de la commande Bash Sleep

la syntaxe de base de la commande sleep dans Bash est très simple:

sleep <SECONDS>

Voici ce qui se passe si vous l’exécutez dans la ligne de commande:

$ sleep 5$ 

dans ce cas, après secondes.

et maintenant passons à trois exemples pratiques de la façon dont vous la commande Bash sleep.,

scénario 1: commande Sleep qui retarde l’exécution d’une autre commande dans un Script Bash

je vais écrire un simple script shell Bash pour montrer le comportement exact de la commande sleep considering

considering considérant que l’exemple précédent ne pouvait pas vraiment montrer que la commande sleep a renvoyé le shell après 5 secondes.

écrivons un script qui fait ce que j’ai expliqué dans le scénario 1, il retarde L’exécution d’une commande de X secondes (dans ce cas 5 secondes).

c’est presque comme exécuter une commande à un moment précis en suivant le même principe que les planificateurs de tâches.,

alors, créez un script shell Bash très simple appelédelay_cmd.sh:

#!/bin/bash datesleep 5dateuptime 

la commande date est utilisée pour imprimer la date actuelle avant et après la commande sleep, de cette façon, vous pouvez voir que le script est suspendu pendant 5 secondes.

Après 5 secondes, la commande uptime est exécutée.

sens?

en théorie, nous pouvons écrire le même script en une seule ligne:

#!/bin/bash date; sleep 5; date; uptime 

c’est parce que le point-virgule est utilisé sous Linux pour séparer différentes commandes et les exécuter séquentiellement.,

en d’autres termes, Linux s’assure que chaque commande se termine avant d’exécuter la suivante.

scénario 2: Script Bash qui utilise la commande Sleep pour attendre qu’un autre Script se termine

dans cet exemple, je vais créer deux scripts:

1. program_1.sh: dort pendant 30 secondes, puis il crée un fichier appelé stage1.compléter. Cela simule essentiellement un programme qui prend beaucoup de temps pour terminer une tâche spécifique et confirme l’achèvement de son exécution en créant le stage1.dossier complet.
2. program_2.sh: utilise une boucle while et à chaque itération vérifie si le stage1.,le fichier complet existe. Si ce n’est pas elle dort pendant 6 secondes, si le fichier existe, il affiche le message « Fichier stage1.complet existe. Étape 1 terminée, à partir de L’Étape 2… ».

Voici program_1.sh:

#!/bin/bash sleep 30touch stage1.complete 

La commande touch est utilisée par le premier programme pour créer le stage1.terminer le fichier après 30 secondes à partir du moment où le script est exécuté.

et program_2.sh est la suivante, nous utiliserons une instruction Bash if else pour l’implémenter:

dans le deuxième script shell Bash, nous avons une boucle infinie., À chaque itération, le script:

• Vérifie si le fichier stage1.complet est présent.
• Si le fichier n’existe pas, il dort pendant 6 secondes
• Si le fichier existe, il supprime le stage1.terminer le fichier et arrêter l’exécution à l’aide de la commande Bash exit.,

avant d’exécuter les deux scripts, assurez-vous qu’ils sont tous les deux exécutables en utilisant la commande chmod +x:

chmod +x program_*.sh

donc, exécutons les scripts We

Nous allons exécuter program_1.sh tout d’abord, nous allons l’exécuter en arrière-plan afin que nous puissions exécuter program_2.sh immédiatement après dans le même terminal:

comme prévu, le deuxième script continue de dormir pendant 6 secondes jusqu’à ce qu’il trouve le fichier STAGE1.fichier complet, puis il arrête son exécution.,

scénario 3: Commande Sleep pour contrôler le nombre d’appels à une API tierce

Si vous souhaitez appeler une API à l’aide d’un script Bash, vous pouvez utiliser la commande curl.

utiliser curl pour appeler une API est simple, prenons par exemple le point de terminaison API suivant:

https://samples.openweathermap.org/data/2.5/weather?q=London,uk&appid=b6907d289e10d714a6e88b30761fae22 

Nous allons écrire un script Bash qui utilise curl pour effectuer une requête GET contre elle et utilise la commande sleep pour limiter le nombre d’appels API dans un certain laps de temps.

ceci est fait pour éviter de dépasser les limites potentielles imposées par le fournisseur D’API.,

Voici le script que j’ai écrit:

peu de choses sur ce script:

• la variable COUNTER est utilisée pour compter le nombre d’appels D’API à exécuter avant de quitter la boucle while.
• cURL est utilisé pour exécuter les requêtes GET sur le point de terminaison API.
• à chaque itération de la boucle while, nous suspendons le script pendant 10 secondes avec la commande sleep pour limiter le nombre d’appels API à un toutes les 10 Secondes.
• on incrémente la variable compteur en utilisant l’opérateur arithmétique $(( )).,

exécutez donc le script:

comme prévu, deux appels D’API sont exécutés, puis l’exécution de la boucle while s’arrête car la valeur du compteur de variables est 3.

Conclusion

je vous ai montré différentes façons d’utiliser la commande sleep dans un script Bash.

Et dans le processus, j’ai couvert beaucoup de choses différentes:

• l’Exécution de scripts en arrière-plan.
• à l’Aide de l’opérateur arithmétique.
• boucles infinies while.
• les variables Compteur.
• appel d’une API à l’aide de curl.
• création et suppression de fichiers.,
• définition des autorisations exécutables pour les scripts Bash.
• utiliser le point-virgule pour exécuter des commandes séquentiellement.

j’espère que cela a tout son sens!

Et vous? Sinon, comment utiliseriez-vous la commande sleep dans Bash? 🙂

LIBRE Cours: Déchiffrer l’écriture de Scripts Bash