Temporisation de l'exécution sous Linux

Introduction

Dans ce laboratoire, vous apprendrez à utiliser la commande sleep sous Linux, qui permet d'introduire des pauses ou des délais chronométrés dans vos scripts et séquences de commandes. La capacité à contrôler le timing est essentielle pour de nombreuses tâches de script, comme la création de périodes d'attente entre des opérations, la simulation d'interactions utilisateur ou le contrôle du flux d'exécution d'un script.

À la fin de ce laboratoire, vous comprendrez comment utiliser la commande sleep avec des valeurs fixes et des variables pour créer des contrôles de timing flexibles dans vos scripts shell Linux.

Comprendre la commande Sleep

La commande sleep sous Linux est un utilitaire simple mais puissant qui suspend l'exécution d'un script ou d'une séquence de commandes pendant une durée spécifiée. Cela est particulièrement utile dans les scripts shell lorsque vous devez créer des délais entre les commandes.

Commençons par explorer l'utilisation de base de la commande sleep.

Tout d'abord, accédez à votre répertoire de projet :

cd ~/project

Maintenant, essayons d'utiliser la commande sleep directement dans le terminal. Tapez la commande suivante :

echo "Start time: $(date +%H:%M:%S)"
sleep 3
echo "End time: $(date +%H:%M:%S)"

Lorsque vous exécutez cette séquence de commandes, vous verrez l'heure de début s'afficher, suivie d'une pause de 3 secondes, puis l'heure de fin. La sortie ressemblera à ceci :

Start time: 10:15:30
End time: 10:15:33

La syntaxe de base de la commande sleep est :

sleep NUMBER[SUFFIX]

Où :

NUMBER est la durée de la pause
SUFFIX est optionnel et peut être :
- s pour les secondes (par défaut si aucun suffixe n'est spécifié)
- m pour les minutes
- h pour les heures
- d pour les jours

Essayons quelques exemples pour voir comment fonctionnent les différentes unités de temps :

## Pause de 5 secondes
echo "Sleeping for 5 seconds..."
sleep 5
echo "Done!"

## Pause de 0,5 seconde (une demi-seconde)
echo "Sleeping for half a second..."
sleep 0.5
echo "Done!"

Vous comprenez maintenant le fonctionnement de base de la commande sleep. Dans l'étape suivante, nous l'intégrerons dans un script shell.

Créer un script shell de base avec Sleep

Maintenant que vous comprenez comment fonctionne la commande sleep, créons un script shell qui l'utilise. Les scripts shell vous permettent d'automatiser des séquences de commandes et constituent un outil fondamental de l'administration Linux.

Tout d'abord, créons un nouveau fichier de script shell dans votre répertoire de projet :

cd ~/project
touch delay_script.sh

Ensuite, ouvrez le fichier à l'aide de l'éditeur de texte nano :

nano delay_script.sh

Ajoutez le contenu suivant au fichier :

#!/bin/zsh

echo "Starting the script..."
echo "First message appears immediately."
sleep 2
echo "Second message appears after 2 seconds."
sleep 3
echo "Third message appears after 3 more seconds."
echo "Script execution complete."

Pour enregistrer le fichier dans nano, appuyez sur Ctrl+O, puis sur Enter pour confirmer, et enfin sur Ctrl+X pour quitter l'éditeur.

Avant de pouvoir exécuter le script, nous devons le rendre exécutable :

chmod +x delay_script.sh

Maintenant, exécutons le script :

./delay_script.sh

Vous devriez voir les messages apparaître avec les délais spécifiés :

Starting the script...
First message appears immediately.
Second message appears after 2 seconds.
Third message appears after 3 more seconds.
Script execution complete.

Ce script simple démontre comment la commande sleep peut être utilisée pour contrôler le timing de l'affichage des messages. Cette technique est utile dans de nombreux scénarios de script, tels que :

Simuler une interaction utilisateur
Attendre la fin d'un processus
Créer des indicateurs de progression
Limiter le débit des opérations

Analysons ce que fait le script ligne par ligne :

#!/bin/zsh - C'est ce qu'on appelle une ligne shebang, qui spécifie que le script doit être exécuté en utilisant le shell zsh.
echo "Starting the script..." - Affiche le message initial.
echo "First message appears immediately." - Affiche le premier message immédiatement.
sleep 2 - Suspend l'exécution du script pendant 2 secondes.
echo "Second message appears after 2 seconds." - Affiche le deuxième message après le délai de 2 secondes.
sleep 3 - Suspend l'exécution du script pendant 3 secondes supplémentaires.
echo "Third message appears after 3 more seconds." - Affiche le troisième message après le délai de 3 secondes.
echo "Script execution complete." - Affiche le message final.

Dans l'étape suivante, nous explorerons comment rendre nos durées de pause plus flexibles en utilisant des variables.

Utiliser des variables avec la commande Sleep

Dans les scripts réels, vous avez souvent besoin de plus de flexibilité que des durées de pause codées en dur. L'utilisation de variables pour les temps de pause rend vos scripts plus adaptables et plus faciles à maintenir. Créons un nouveau script qui illustre ce concept.

Tout d'abord, créez un nouveau fichier :

cd ~/project
touch variable_delay.sh

Ouvrez le fichier avec nano :

nano variable_delay.sh

Ajoutez le contenu suivant :

#!/bin/zsh

## Define delay durations as variables
SHORT_DELAY=1
MEDIUM_DELAY=3
LONG_DELAY=5

echo "Starting the script with variable delays..."

echo "This is displayed immediately."
echo "Waiting for a short delay (${SHORT_DELAY} seconds)..."
sleep $SHORT_DELAY
echo "Short delay completed."

echo "Waiting for a medium delay (${MEDIUM_DELAY} seconds)..."
sleep $MEDIUM_DELAY
echo "Medium delay completed."

echo "Waiting for a long delay (${LONG_DELAY} seconds)..."
sleep $LONG_DELAY
echo "Long delay completed."

echo "Script execution complete."

Enregistrez et quittez nano avec Ctrl+O, Enter et Ctrl+X.

Rendez le script exécutable :

chmod +x variable_delay.sh

Exécutez maintenant le script :

./variable_delay.sh

La sortie sera similaire à :

Starting the script with variable delays...
This is displayed immediately.
Waiting for a short delay (1 seconds)...
Short delay completed.
Waiting for a medium delay (3 seconds)...
Medium delay completed.
Waiting for a long delay (5 seconds)...
Long delay completed.
Script execution complete.

Comprenons pourquoi l'utilisation de variables pour les temps de pause est bénéfique :

Lisibilité : L'utilisation de noms de variables descriptifs comme SHORT_DELAY rend le code auto-documenté.
Maintenabilité : Si vous devez modifier une durée de pause, il vous suffit de la modifier à un seul endroit (la déclaration de la variable) plutôt que dans tout le script.
Cohérence : Si la même durée de pause est utilisée plusieurs fois, l'utilisation d'une variable garantit que toutes les instances utilisent la même valeur.
Flexibilité : Vous pouvez facilement modifier les temps de pause en changeant simplement les valeurs des variables.

Vous pouvez également effectuer des calculs avec ces variables. Créons un dernier script pour le démontrer :

cd ~/project
touch calculated_delay.sh
nano calculated_delay.sh

Ajoutez le contenu suivant :

#!/bin/zsh

## Base delay time in seconds
BASE_DELAY=2

echo "Starting script with calculated delays..."

## Using the base delay
echo "Waiting for the base delay (${BASE_DELAY} seconds)..."
sleep $BASE_DELAY
echo "Base delay completed."

## Double the base delay
DOUBLE_DELAY=$((BASE_DELAY * 2))
echo "Waiting for double the base delay (${DOUBLE_DELAY} seconds)..."
sleep $DOUBLE_DELAY
echo "Double delay completed."

## Half the base delay
HALF_DELAY=$(echo "scale=1; $BASE_DELAY / 2" | bc)
echo "Waiting for half the base delay (${HALF_DELAY} seconds)..."
sleep $HALF_DELAY
echo "Half delay completed."

echo "Script execution complete."

Enregistrez, quittez nano et rendez le script exécutable :

chmod +x calculated_delay.sh

Exécutez le script :

./calculated_delay.sh

La sortie sera similaire à :

Starting script with calculated delays...
Waiting for the base delay (2 seconds)...
Base delay completed.
Waiting for double the base delay (4 seconds)...
Double delay completed.
Waiting for half the base delay (1.0 seconds)...
Half delay completed.
Script execution complete.

Cela démontre comment vous pouvez calculer dynamiquement les temps de pause en fonction d'une valeur de base unique, rendant vos scripts encore plus flexibles et puissants.

Applications pratiques de la commande Sleep

Maintenant que vous comprenez les bases de la commande sleep et comment l'utiliser avec des variables, explorons quelques applications pratiques. Ces exemples montrent comment la commande sleep est utilisée dans des scénarios réels.

Créer un compte à rebours simple

Créons un compte à rebours qui démontre une utilisation plus complexe de la commande sleep :

cd ~/project
touch countdown.sh
nano countdown.sh

Ajoutez le contenu suivant :

#!/bin/zsh

## Function to display a countdown
countdown() {
  local seconds=$1
  while [ $seconds -gt 0 ]; do
    echo -ne "\rTime remaining: $seconds seconds "
    sleep 1
    ((seconds--))
  done
  echo -e "\rCountdown complete!            "
}

## Specify the countdown duration
echo "Starting a 5-second countdown:"
countdown 5
echo "Countdown script execution complete."

Enregistrez, quittez nano et rendez le script exécutable :

chmod +x countdown.sh

Exécutez le script :

./countdown.sh

Vous devriez voir un compte à rebours de 5 secondes à 0, avec le temps qui se met à jour sur place :

Starting a 5-second countdown:
Time remaining: 5 seconds
Time remaining: 4 seconds
Time remaining: 3 seconds
Time remaining: 2 seconds
Time remaining: 1 seconds
Countdown complete!
Countdown script execution complete.

Simuler un processus avec un indicateur de progression

Créons un script qui simule un processus long avec un indicateur de progression simple :

cd ~/project
touch progress.sh
nano progress.sh

Ajoutez le contenu suivant :

#!/bin/zsh

## Function to show a simple progress bar
show_progress() {
  local duration=$1
  local steps=10
  local step_duration=$(echo "scale=2; $duration / $steps" | bc)

  echo "Starting process..."
  echo -n "Progress: ["
  for i in {1..10}; do
    sleep $step_duration
    echo -n "#"
  done
  echo "] Done!"
}

## Run a process that takes 5 seconds with a progress indicator
show_progress 5
echo "Process completed successfully."

Enregistrez, quittez nano et rendez le script exécutable :

chmod +x progress.sh

Exécutez le script :

./progress.sh

Vous devriez voir une barre de progression qui se remplit sur 5 secondes :

Starting process...
Progress: [##########] Done!
Process completed successfully.

Contrôler le débit des opérations

Dans cet exemple, nous montrerons comment utiliser la commande sleep pour contrôler le débit des opérations, ce qui est utile pour limiter le taux d'appels API ou le traitement de grands ensembles de données :

cd ~/project
touch rate_limit.sh
nano rate_limit.sh

Ajoutez le contenu suivant :

#!/bin/zsh

## Define the rate limit (operations per second)
OPERATIONS_PER_SECOND=2
SLEEP_DURATION=$(echo "scale=3; 1 / $OPERATIONS_PER_SECOND" | bc)

echo "Performing operations at a rate of $OPERATIONS_PER_SECOND per second"
echo "Each operation will be followed by a $SLEEP_DURATION second delay"

## Simulate 6 operations with rate limiting
for i in {1..6}; do
  echo "Performing operation $i at $(date +%H:%M:%S.%N | cut -c1-12)"
  ## Simulate the operation
  sleep 0.1
  ## Rate-limiting delay between operations
  if [ $i -lt 6 ]; then
    sleep $SLEEP_DURATION
  fi
done

echo "All operations completed"

Enregistrez, quittez nano et rendez le script exécutable :

chmod +x rate_limit.sh

Exécutez le script :

./rate_limit.sh

Vous devriez voir les opérations s'effectuer à un rythme contrôlé :

Performing operations at a rate of 2 per second
Each operation will be followed by a 0.500 second delay
Performing operation 1 at 10:30:45.12
Performing operation 2 at 10:30:45.72
Performing operation 3 at 10:30:46.32
Performing operation 4 at 10:30:46.92
Performing operation 5 at 10:30:47.52
Performing operation 6 at 10:30:48.12
All operations completed

Ces exemples démontrent comment la commande sleep peut être utilisée dans des scénarios de script plus avancés. La capacité à contrôler le timing est un outil puissant dans les scripts shell qui permet de nombreuses applications pratiques.

Résumé

Dans ce laboratoire, vous avez appris à utiliser la commande sleep sous Linux pour introduire des délais chronométrés dans vos scripts shell. Il s'agit d'une compétence fondamentale pour l'écriture de scripts et les opérations en ligne de commande qui nécessitent un timing contrôlé.

Concepts clés abordés dans ce laboratoire :

Utilisation de base de la commande sleep avec différentes unités de temps (secondes, minutes, heures)
Création de scripts shell intégrant la commande sleep
Utilisation de variables pour rendre les durées de pause plus flexibles et maintenables
Effectuer des calculs avec des variables de durée de pause
Applications pratiques de la commande sleep :
- Création de comptes à rebours
- Mise en œuvre d'indicateurs de progression
- Contrôle du débit des opérations

Ces compétences seront précieuses dans de nombreux scénarios de script Linux, notamment :

Automatiser des tâches nécessitant un timing spécifique
Créer des interfaces conviviales avec des pauses appropriées
Mettre en œuvre une limitation de débit pour les appels API ou les opérations gourmandes en ressources
Simuler des interactions utilisateur
Gérer le flux d'exécution des scripts

En maîtrisant la commande sleep, vous disposez désormais d'un outil important dans votre boîte à outils de script Linux qui vous aidera à créer des scripts plus sophistiqués et conviviaux.