RH12405 - La Ligne de Commande

• RH12405 - La Ligne de Commande
  • Contenu du Module
  • Le Shell
  • LAB #1 - Le Shell /bin/bash
    • 1.1 - Les Commandes Internes et Externes au shell
    • 1.2 - Les alias
    • 1.3 - Définir le Shell d'un Utilisateur
    • 1.4 - Le Prompt
    • 1.5 - Rappeler des Commandes
    • 1.6 - Générer les fins de noms de fichiers
    • 1.7 - Le shell interactif
      • Caractère *
      • Caractère ?
      • Caractères [ ]
    • 1.8 - L'option extglob
      • ?(expression)
      • *(expression)
      • +(expression)
      • @(expression)
      • !(expression)
      • Caractères d'Échappement
  • 1.9 - Codes Retour
  • 1.10 - Redirections
  • 1.11 - Pipes
  • 1.12 - Substitutions de Commandes
  • 1.13 - Chaînage de Commandes
  • 1.14 - Affichage des variables du shell
    • Les variables principales
    • Les Variables de Régionalisation et d'Internationalisation
    • Les variables spéciales
  • 1.15 - La Commande env
  • 1.16 - Options du Shell Bash
    • Exemples
      • noclobber
      • noglob
      • nounset
  • LAB #2 - Les Scripts Shell
    • 2.1 - Exécution
    • 2.2 - La commande read
      • Code de retour
      • La variable IFS
    • 2.3 - La commande test
      • Tests de Fichiers
      • Tests de chaînes de caractère
      • Tests sur des nombres
      • Les opérateurs
      • Tests d'environnement utilisateur
    • 2.4 - La commande [[ expression ]]
    • 2.5 - Opérateurs du shell
    • 2.6 - L'arithmétique
      • La commande expr
        • Opérateurs Arithmétiques
        • Opérateurs de Comparaison
        • Opérateurs Logiques
      • La commande let
        • Opérateurs Arithmétiques
        • Opérateurs de comparaison
        • Opérateurs Logiques
        • Opérateurs travaillant sur les bits
    • 2.7 - Structures de contrôle
      • If
      • case
        • Exemple
      • Boucles
        • for
        • while
        • Exemple
    • 2.8 - Scripts de Démarrage
      • ~/.bash_profile
      • ~/.bashrc

Un shell est un interpréteur de commandes ou en anglais un Command Line Interpreter (C.L.I). Il est utilisé comme interface pour donner des instructions ou commandes au système d'exploitation.

Le mot shell est générique. Il existe de nombreux shells dans le monde Unix, par exemple :

Sous RHEL/CentOS 8 le shell /bin/sh est un lien symbolique vers /bin/bash :

[trainee@redhat9 ~]$ ls -l /bin/sh
lrwxrwxrwx. 1 root root 4 Feb 15  2024 /bin/sh -> bash

Ce module concerne l'utilisation du shell bash sous Linux. Le shell bash permet de:

• Rappeler des commandes
• Générer la fin de noms de fichiers
• Utiliser des alias
• Utiliser les variables tableaux
• Utiliser les variables numériques et l'arithmétique du langage C
• Gérer des chaînes de caractères
• Utiliser les fonctions

Une commande commence toujours par un mot clef. Ce mot clef est interprété par le shell selon le type de commande et dans l'ordre qui suit :

1. Les alias
2. Les fonctions
3. Les commandes internes au shell
4. Les commandes externes au shell

Les commandes internes au shell sont des commandes telles cd. Pour vérifier le type de commande, il faut utiliser la commande type :

[trainee@redhat9 ~]$ type cd
cd is a shell builtin

Les commandes externes au shell sont des binaires exécutables ou des scripts, généralement situés dans /bin, /sbin, /usr/bin ou /usr/sbin :

[trainee@redhat9 ~]$ type ifconfig
ifconfig is /usr/sbin/ifconfig

Les alias sont des noms permettant de désigner une commande ou une suite de commandes et ne sont spécifiques qu'au shell qui les a créés ainsi qu'à l'environnement de l'utilisateur :

[trainee@redhat9 ~]$ type ls
ls is aliased to `ls --color=auto'

Un alias se définit en utilisant la commande alias :

[trainee@redhat9 ~]$ alias dir='ls -l'
[trainee@redhat9 ~]$ dir
total 4
-rw-r--r--. 1 trainee trainee   0 Sep 25 15:11 aac
-rw-r--r--. 1 trainee trainee   0 Sep 25 15:11 abc
-rw-r--r--. 1 trainee trainee   0 Sep 25 15:11 bca
drwxr-xr-x. 2 trainee trainee   6 Oct 19  2023 Desktop
drwxr-xr-x. 2 trainee trainee   6 Oct 19  2023 Documents
drwxr-xr-x. 2 trainee trainee   6 Oct 19  2023 Downloads
drwxr-xr-x. 2 trainee trainee   6 Oct 19  2023 Music
drwxr-xr-x. 2 trainee trainee   6 Oct 19  2023 Pictures
drwxr-xr-x. 2 trainee trainee   6 Oct 19  2023 Public
drwxr-xr-x. 2 trainee trainee   6 Oct 19  2023 Templates
drwxr-xr-x. 2 trainee trainee   6 Oct 19  2023 Videos
-rw-r--r--. 1 trainee trainee 442 Sep 25 14:24 vitext
-rw-r--r--. 1 trainee trainee   0 Sep 25 15:11 xyz

La liste des alias définis peut être visualisée en utilisant la commande alias :

[trainee@redhat9 ~]$ alias
alias dir='ls -l'
alias egrep='egrep --color=auto'
alias fgrep='fgrep --color=auto'
alias grep='grep --color=auto'
alias l.='ls -d .* --color=auto'
alias ll='ls -l --color=auto'
alias ls='ls --color=auto'
alias xzegrep='xzegrep --color=auto'
alias xzfgrep='xzfgrep --color=auto'
alias xzgrep='xzgrep --color=auto'
alias zegrep='zegrep --color=auto'
alias zfgrep='zfgrep --color=auto'
alias zgrep='zgrep --color=auto'

Pour forcer l'exécution d'une commande et non l'alias il faut faire précéder la commande par le caractère \ :

[trainee@redhat9 ~]$ \dir
aac  abc  bca  Desktop  Documents  Downloads  Music  Pictures  Public  Templates  Videos  vitext  xyz

Pour supprimer un alias, il convient d'utiliser la commande unalias :

[trainee@redhat9 ~]$ unalias dir
[trainee@redhat9 ~]$ dir
aac  abc  bca  Desktop  Documents  Downloads  Music  Pictures  Public  Templates  Videos  vitext  xyz

Le shell des utilisateurs est défini par root dans le dernier champs du fichier /etc/passwd :

[trainee@redhat9 ~]$ cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
nobody:x:65534:65534:Kernel Overflow User:/:/sbin/nologin
systemd-coredump:x:999:997:systemd Core Dumper:/:/sbin/nologin
dbus:x:81:81:System message bus:/:/sbin/nologin
polkitd:x:998:996:User for polkitd:/:/sbin/nologin
avahi:x:70:70:Avahi mDNS/DNS-SD Stack:/var/run/avahi-daemon:/sbin/nologin
tss:x:59:59:Account used for TPM access:/dev/null:/sbin/nologin
colord:x:997:993:User for colord:/var/lib/colord:/sbin/nologin
clevis:x:996:992:Clevis Decryption Framework unprivileged user:/var/cache/clevis:/usr/sbin/nologin
rtkit:x:172:172:RealtimeKit:/proc:/sbin/nologin
sssd:x:995:991:User for sssd:/:/sbin/nologin
geoclue:x:994:990:User for geoclue:/var/lib/geoclue:/sbin/nologin
libstoragemgmt:x:988:988:daemon account for libstoragemgmt:/:/usr/sbin/nologin
systemd-oom:x:987:987:systemd Userspace OOM Killer:/:/usr/sbin/nologin
setroubleshoot:x:986:986:SELinux troubleshoot server:/var/lib/setroubleshoot:/sbin/nologin
pipewire:x:985:984:PipeWire System Daemon:/var/run/pipewire:/sbin/nologin
flatpak:x:984:983:User for flatpak system helper:/:/sbin/nologin
gdm:x:42:42::/var/lib/gdm:/sbin/nologin
cockpit-ws:x:983:982:User for cockpit web service:/nonexisting:/sbin/nologin
cockpit-wsinstance:x:982:981:User for cockpit-ws instances:/nonexisting:/sbin/nologin
gnome-initial-setup:x:981:980::/run/gnome-initial-setup/:/sbin/nologin
sshd:x:74:74:Privilege-separated SSH:/usr/share/empty.sshd:/sbin/nologin
chrony:x:980:979:chrony system user:/var/lib/chrony:/sbin/nologin
dnsmasq:x:979:978:Dnsmasq DHCP and DNS server:/var/lib/dnsmasq:/sbin/nologin
tcpdump:x:72:72::/:/sbin/nologin
trainee:x:1000:1000:trainee:/home/trainee:/bin/bash

Cependant l'utilisateur peut changer son shell grâce à la commande chsh. Les shells disponibles aux utilisateurs du système sont inscrits dans le fichier /etc/shells. Saisissez la commande cat /etc/shells :

[trainee@redhat9 ~]$ cat /etc/shells
/bin/sh
/bin/bash
/usr/bin/sh
/usr/bin/bash

Ensuite utilisez la commande echo pour afficher le shell actuel de trainee :

[trainee@redhat9 ~]$ echo $SHELL
/bin/bash

Changez ensuite le shell de trainee en utilisant la commande chsh en indiquant la valeur de /bin/sh pour le nouveau shell :

[trainee@redhat9 ~]$ chsh
Changing shell for trainee.
New shell [/bin/bash]: /bin/sh
Password: trainee
Shell changed.

Vérifiez ensuite le shell actif pour trainee :

[trainee@redhat9 ~]$ echo $SHELL
/bin/bash

Dernièrement contrôlez le shell stipulé dans le fichier /etc/passwd pour trainee :

[trainee@redhat9 ~]$ cat /etc/passwd | grep trainee
trainee:x:1000:1000:trainee:/home/trainee:/bin/sh

Modifiez votre shell à /bin/bash de nouveau en utilisant la commande chsh :

[trainee@redhat9 ~]$ chsh
Changing shell for trainee.
New shell [/bin/sh]: /bin/bash
Password: trainee
Shell changed.

Le prompt d'un utilisateur dépend de son statut :

• $ pour un utilisateur normal,
• # pour root.

Le shell /bin/bash permet le rappel des dernières commandes saisies. Afin de connaître la liste des commandes mémorisées, utilisez la commande history :

[trainee@redhat9 ~]$ history | more
    1  su -
    2  exit
    3  su -
    4  clear
    5  cd /
    6  ls -l
    7  cd afs
    8  ls
    9  cd /
   10  su -
   11  cd ~
   12  vi vitext
   13  view vitext
   14  vi vitext
   15  vi .exrc
   16  vi vitext
   17  su -
   18  stty -a
   19  date
   20  who
   21  df
   22  df -h
   23  free
   24  free -h
   25  whoami
   26  su -
   27  pwd
   28  cd /tmp
   29  pwd
   30  ls
   31  su -
   32  touch test
   33  ls
   34  echo fenestros
   35  cp test ~
   36  ls -l ~
   37  file ~/test
--More--
[q]

L'historique des commandes est en mode emacs par défaut. De ce fait, le rappel de la dernière commande se fait en utilisant la touche [Flèche vers le haut] ou bien les touches [CTRL]-[P] et le rappel de la commande suivante se fait en utilisant la touche [Flèche vers le bas] ou bien les touches [CTRL]-[N] :

Pour se déplacer dans la ligne de l'historique :

Pour rechercher dans l'historique il convient d'utiliser les touches :

Il est aussi possible de rappeler la dernière commande de l'historique en utilisant les caractères !!:

[trainee@redhat9 ~]$ ls
aac  abc  bca  Desktop  Documents  Downloads  Music  Pictures  Public  Templates  Videos  vitext  xyz
[trainee@redhat9 ~]$ !!
ls
aac  abc  bca  Desktop  Documents  Downloads  Music  Pictures  Public  Templates  Videos  vitext  xyz

Vous pouvez rappeler une commande spécifique de l'historique en utilisant le caractère ! suivi du numéro de la commande à rappeler :

[trainee@redhat9 ~]$ history
    1  su -
    2  exit
    3  su -
    4  clear
    5  cd /
    6  ls -l
    7  cd afs
    8  ls
    9  cd /
   10  su -
...
   85  echo $SHELL
   86  cat /etc/passwd | grep trainee
   87  chsh
   88  history | more
   89  clear
   90  ls
   91  history
[trainee@redhat9 ~]$ !90
ls
aac  abc  bca  Desktop  Documents  Downloads  Music  Pictures  Public  Templates  Videos  vitext  xyz

Le paramétrage de la fonction du rappel des commandes est fait pour tous les utilisateurs dans le fichier /etc/profile. Dans ce fichier, les variables concernant le rappel des commandes peuvent être définis. Le plus important est HISTSIZE :

[trainee@redhat9 ~]$ cat /etc/profile | grep HISTSIZE
HISTSIZE=1000
export PATH USER LOGNAME MAIL HOSTNAME HISTSIZE HISTCONTROL

Vous noterez que dans le cas précédent, la valeur de HISTSIZE est de 1000. Ceci implique que les dernières mille commandes sont mémorisées.

Les commandes mémorisées sont stockées dans le fichier ~/.bash_history. Les commandes de la session en cours ne sont sauvegardées dans ce fichier qu'à la fermerture de la session :

[trainee@redhat9 ~]$ nl .bash_history | tail
    59  ls
    60  ls | sort
    61  ls | sort -r
    62  more /etc/services
    63  less /etc/services
    64  find acc
    65  find aac
    66  su -
    67  sleep 10
    68  su -

Le shell /bin/bash permet la génération des fins de noms de fichiers. Celle-ci est accomplie grâce à l'utilisation de la touche [Tab]. Dans l'exemple qui suit, la commande saisie est :

$ ls .b [Tab][Tab][Tab]

[trainee@redhat9 ~]$ ls .bash
.bash_history  .bash_logout   .bash_profile  .bashrc 

La même possibilité existe pour la génération des fins de noms de commandes. Dans ce cas saisissez la commande suivante :

$ mo [Tab][Tab]

Appuyez sur la touche Tab deux fois. Vous obtiendrez une fenêtre similaire à celle-ci :

[trainee@redhat9 ~]$ mo
modinfo             modulemd-validator  more                mount.composefs     mount.fuse3         
modprobe            monitor-sensor      mount               mount.fuse          mountpoint 

Lors de l'utilisation du shell, nous avons souvent besoin d'exécuter une commande sur plusieurs fichiers au lieu de les traiter individuellement. A cette fin nous pouvons utiliser les caractères spéciaux.

Dans votre répertoire individuel, créez un répertoire training. Ensuite créez dans ce répertoire 5 fichiers nommés respectivement f1, f2, f3, f4 et f5 :

[trainee@redhat9 ~]$ mkdir training
[trainee@redhat9 ~]$ cd training
[trainee@redhat9 training]$ touch f1 f2 f3 f4 f5
[trainee@redhat9 training]$ ls
f1  f2  f3  f4  f5

Afin de démontrer l'utilisation du caractère spécial *, saisissez la commande suivante :

[trainee@redhat9 training]$ echo f*
f1 f2 f3 f4 f5

Créez maintenant les fichiers f52 et f62 :

[trainee@redhat9 training]$ touch f52 f62

Saisissez ensuite la commande suivante :

[trainee@redhat9 training]$ echo f?2
f52 f62

L'utilisation peut prendre plusieurs formes différentes :

Afin de démontrer l'utilisation des caractères [ et ], créez le fichier a100 :

[trainee@redhat9 training]$ touch a100

Ensuite saisissez les commandes suivantes et notez le résultat :

[trainee@redhat9 training]$ echo [a-f]*
a100 f1 f2 f3 f4 f5 f52 f62

[trainee@redhat9 training]$ echo [af]*
a100 f1 f2 f3 f4 f5 f52 f62

[trainee@redhat9 training]$ echo [!a]*
f1 f2 f3 f4 f5 f52 f62

[trainee@redhat9 training]$ echo [a-b]*
a100

[trainee@redhat9 training]$ echo [a-f]
[a-f]

Activez l'option extglob du shell bash afin de pouvoir utiliser ?(expression), *(expression), +(expression), @(expression) et !(expression) :

[trainee@redhat9 training]$ shopt -s extglob

La commande shopt est utilisée pour activer ou désactiver les options du comportement optional du shell. La liste des options peut être visualisée en exécutant la commande shopt sans options :

[trainee@redhat9 training]$ shopt
autocd          off
assoc_expand_once       off
cdable_vars     off
cdspell         off
checkhash       off
checkjobs       off
checkwinsize    on
cmdhist         on
compat31        off
compat32        off
compat40        off
compat41        off
compat42        off
compat43        off
compat44        off
complete_fullquote      on
direxpand       off
dirspell        off
dotglob         off
execfail        off
expand_aliases  on
extdebug        off
extglob         on
extquote        on
failglob        off
force_fignore   on
globasciiranges on
globstar        off
gnu_errfmt      off
histappend      on
histreedit      off
histverify      off
hostcomplete    off
huponexit       off
inherit_errexit off
interactive_comments    on
lastpipe        off
lithist         off
localvar_inherit        off
localvar_unset  off
login_shell     on
mailwarn        off
no_empty_cmd_completion off
nocaseglob      off
nocasematch     off
nullglob        off
progcomp        on
progcomp_alias  off
promptvars      on
restricted_shell        off
shift_verbose   off
sourcepath      on
syslog_history  off
xpg_echo        off

Créez les fichiers f, f.txt, f123.txt, f123123.txt, f123123123.txt :

[trainee@redhat9 training]$ touch f f.txt f123.txt f123123.txt f123123123.txt

Saisissez la commande suivante :

[trainee@redhat9 training]$ ls f?(123).txt
f123.txt  f.txt

Saisissez la commande suivante :

[trainee@redhat9 training]$ ls f*(123).txt
f123123123.txt  f123123.txt  f123.txt  f.txt

Saisissez la commande suivante :

[trainee@redhat9 training]$ ls f+(123).txt
f123123123.txt  f123123.txt  f123.txt

Saisissez la commande suivante :

[trainee@redhat9 training]$ ls f@(123).txt
f123.txt

Saisissez la commande suivante :

[trainee@redhat9 training]$ ls f!(123).txt
f123123123.txt  f123123.txt  f.txt

Afin d'utiliser un caractère spécial dans un contexte littéral, il faut utiliser un caractère d'échappement. Il existe trois caractères d'échappement :

Afin d'illustrer l'utilisation des caractères d'échappement, considérons la commande suivante :

$ echo * est un caractère spécial [Entrée]

Lors de la saisie de cette commande dans votre répertoire training, vous obtiendrez une fenêtre similaire à celle-ci :

[trainee@redhat9 training]$ echo * est un caractère spécial
a100 f f1 f123123123.txt f123123.txt f123.txt f2 f3 f4 f5 f52 f62 f.txt est un caractère spécial

[trainee@redhat9 training]$ echo \* est un caractère spécial
* est un caractère spécial

[trainee@redhat9 training]$ echo "* est un caractère spécial"
* est un caractère spécial

[trainee@redhat9 training]$ echo '* est un caractère spécial'
* est un caractère spécial

Chaque commande retourne un code à la fin de son exécution. La variable spéciale $? sert à stocker le code retour de la dernière commande exécutée.

Par exemple :

[trainee@redhat9 training]$ cd ..
[trainee@redhat9 ~]$ mkdir codes
[trainee@redhat9 ~]$ echo $?
0
[trainee@redhat9 ~]$ touch codes/exit.txt
[trainee@redhat9 ~]$ rmdir codes
rmdir: failed to remove 'codes': Directory not empty
[trainee@redhat9 ~]$ echo $?
1

Dans cette exemple la création du répertoire codes s'est bien déroulée. Le code retour stocké dans la variable $? est un zéro.

La suppression du répertoire a rencontré une erreur car codes contenait le fichier retour. Le code retour stocké dans la variable $? est un un.

Si le code retour est zéro la dernière commande s'est déroulée sans erreur.

Si le code retour est autre que zéro la dernière commande s'est déroulée avec une erreur.

Votre dialogue avec le système Linux utilise des canaux d’entrée et de sortie. On appelle le clavier, le canal d’entrée standard et l’écran, le canal de sortie standard :

Autrement dit, en tapant une commande sur le clavier, vous voyez le résultat de cette commande à l’écran.

Parfois, cependant il est utile de re-diriger le canal de sortie standard vers un fichier. De cette façon, le résultat d’une commande telle free peut être stocké dans un fichier pour une consultation ultérieure :

Cet effet est obtenu en utilisant une redirection :

[trainee@redhat9 ~]$ pwd
/home/trainee
[trainee@redhat9 ~]$ cd training
[trainee@redhat9 training]$ free > file
[trainee@redhat9 training]$ cat file
               total        used        free      shared  buff/cache   available
Mem:         7869560      996400     4964048       15324     2229600     6873160
Swap:        5242876           0     5242876

Si le fichier cible n’existe pas, il est créé et son contenu sera le résultat de la commande free.

Par contre si le fichier existe déjà, il sera écrasé :

[trainee@redhat9 training]$ date > file
[trainee@redhat9 training]$ cat file
Thu Sep 26 12:49:11 PM CEST 2024

Pour ajouter des données supplémentaires au même fichier cible, il faut utiliser une double redirection :

[trainee@redhat9 training]$ free >> file
[trainee@redhat9 training]$ cat file
Thu Sep 26 12:49:11 PM CEST 2024
               total        used        free      shared  buff/cache   available
Mem:         7869560      996392     4964048       15324     2229608     6873168
Swap:        5242876           0     5242876

De cette façon, la sortie de la commande free sera ajoutée à la fin de votre fichier après les informations de la commande free.

Les canaux d’entrées et de sorties sont numérotés :

• 0 = Le Canal d’entrée Standard
• 1 = Le Canal de Sortie Standard
• 2 = Le Canal d’erreur

La commande suivante créera un fichier nommé errorlog qui contient les messages d’erreur de l’exécution de la commande rmdir :

[trainee@redhat9 training]$ cd ..
[trainee@redhat9 ~]$ rmdir training/ 2>errorlog
[trainee@redhat9 ~]$ cat errorlog 
rmdir: failed to remove 'training/': Directory not empty

En effet l'erreur est générée parce que le répertoire training n'est pas vide.

Nous pouvons également réunir des canaux. Pour mettre en application ceci, il faut comprendre que le shell traite les commandes de gauche à droite.

Dans l’exemple suivant, nous réunissons le canal de sortie et le canal d’erreurs :

[trainee@redhat9 ~]$ free > file 2>&1

La syntaxe 2>&1 envoie la sortie du canal 2 au même endroit que le canal 1, à savoir le fichier dénommé file.

Il est possible de modifier le canal d'entrée standard afin de lire des informations à partir d’un fichier. Dans ce cas la redirection est obtenue en utilisant le caractère < :

[trainee@redhat9 ~]$ wc -w < errorlog
8

Dans cet exemple la commande wc compte le nombre de mots ( -w ) dans le fichier errorlog et l’affiche à l’écran :

D'autres redirections existent :

Il est aussi possible de relier des commandes avec un pipe | .

Dans ce cas, le canal de sortie de la commande à gauche du pipe est envoyé au canal d’entrée de la commande à droite du pipe :

[trainee@redhat9 ~]$ ls | wc -w
17

Cette commande, lancée dans votre répertoire personnel, prend la sortie de la commande ls et demande à la commande wc de compter le nombre de mots inclus dans la sortie de ls :

Rappelez-vous que la sortie standard ne peut être redirigée que dans une seule direction. Afin de pouvoir rediriger la sortie standard vers un fichier et la visualiser à l'écran, nous devons utiliser la commande tee avec un pipe :

[trainee@redhat9 ~]$ date | tee file1
Thu Sep 26 12:54:36 PM CEST 2024
[trainee@redhat9 ~]$ cat file1
Thu Sep 26 12:54:36 PM CEST 2024

Cette même technique nous permet de créer deux fichiers :

[trainee@redhat9 ~]$ date | tee file1 > file2
[trainee@redhat9 ~]$ cat file1
Thu Sep 26 12:55:11 PM CEST 2024
[trainee@redhat9 ~]$ cat file2
Thu Sep 26 12:55:11 PM CEST 2024

Il est parfois intéressant, notamment dans les scripts, de remplacer une commande par sa valeur de sa sortie. Afin d'illustrer ce point, considérons les commandes suivantes :

[trainee@redhat9 ~]$ echo date
date
[trainee@redhat9 ~]$ echo $(date)
Thu Sep 26 12:56:02 PM CEST 2024
[trainee@redhat9 ~]$ echo `date`
Thu Sep 26 12:56:17 PM CEST 2024

Il est possible de regrouper des commandes à l’aide d’un sous-shell :

$ (ls -l; ps; who) > list [Entrée]

Cet exemple envoie le résultat des trois commandes vers le fichier list en les traitant en tâches de fond.

Les commandes peuvent être aussi chainées en fonction du code retour de la commande précédente.

&& est utilisé afin de s’assurer que la deuxième commande s’exécute dans le cas où la valeur du statut de sortie est 0, autrement dit qu’il n’y a pas eu d’erreurs.

|| est utilisé afin de s’assurer de l’inverse.

Le syntaxe de cette commande est :

Commande1 && Commande2

Dans ce cas, Commande 2 est exécutée uniquement dans le cas où Commande1 s’est exécuté sans erreur

Ou :

Commande1 || Commande2

Dans ce cas, Commande2 est exécuté si Commande1 a rencontré une erreur.

Une variable du shell peut être affichée grâce à la commande :

$ echo $VARIABLE [Entrée]

L'Internationalisation, aussi appelé i18n car il y a 18 lettres entre la lettre I et la lettre n dans le mot Internationalization, consiste à adapter un logiciel aux paramètres variant d'une région à l'autre :

• longueur des mots,
• accents,
• écriture de gauche à droite ou de droite à gauche,
• unité monétaire,
• styles typographiques et modèles rédactionnels,
• unités de mesures,
• affichage des dates et des heures,
• formats d'impression,
• format du clavier,
• etc …

Le Régionalisation, aussi appelé l10n car il y a 10 lettres entre la lettre L et la lettre n du mot Localisation, consiste à modifier l'internalisation en fonction d'une région spécifique.

Le code pays complet prend la forme suivante : langue-PAYS.jeu_de_caractères. Par exemple, pour la langue anglaise les valeurs de langue-PAYS sont :

• en_GB = Great Britain,
• en_US = USA,
• en_AU = Australia,
• en_NZ = New Zealand,
• en_ZA = South Africa,
• en_CA = Canada.

Les variables système les plus importants contenant les informations concernant le régionalisation sont :

Par exemple :

[trainee@redhat9 ~]$ echo $LC_ALL

[trainee@redhat9 ~]$ echo $LC_CTYPE

[trainee@redhat9 ~]$ echo $LANG
en_US.UTF-8
[trainee@redhat9 ~]$ locale
LANG=en_US.UTF-8
LC_CTYPE="en_US.UTF-8"
LC_NUMERIC="en_US.UTF-8"
LC_TIME="en_US.UTF-8"
LC_COLLATE="en_US.UTF-8"
LC_MONETARY="en_US.UTF-8"
LC_MESSAGES="en_US.UTF-8"
LC_PAPER="en_US.UTF-8"
LC_NAME="en_US.UTF-8"
LC_ADDRESS="en_US.UTF-8"
LC_TELEPHONE="en_US.UTF-8"
LC_MEASUREMENT="en_US.UTF-8"
LC_IDENTIFICATION="en_US.UTF-8"
LC_ALL=

La commande env envoie sur la sortie standard les valeurs des variables système de l'environnement de l'utilisateur qui l'invoque :

[trainee@redhat9 ~]$ env
SHELL=/bin/bash
HISTCONTROL=ignoredups
HISTSIZE=1000
HOSTNAME=redhat9.ittraining.loc
PWD=/home/trainee
LOGNAME=trainee
XDG_SESSION_TYPE=tty
MOTD_SHOWN=pam
HOME=/home/trainee
LANG=en_US.UTF-8
LS_COLORS=rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:mi=01;37;41:su=37;41:sg=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*.arc=01;31:*.arj=01;31:*.taz=01;31:*.lha=01;31:*.lz4=01;31:*.lzh=01;31:*.lzma=01;31:*.tlz=01;31:*.txz=01;31:*.tzo=01;31:*.t7z=01;31:*.zip=01;31:*.z=01;31:*.dz=01;31:*.gz=01;31:*.lrz=01;31:*.lz=01;31:*.lzo=01;31:*.xz=01;31:*.zst=01;31:*.tzst=01;31:*.bz2=01;31:*.bz=01;31:*.tbz=01;31:*.tbz2=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.war=01;31:*.ear=01;31:*.sar=01;31:*.rar=01;31:*.alz=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.cab=01;31:*.wim=01;31:*.swm=01;31:*.dwm=01;31:*.esd=01;31:*.jpg=01;35:*.jpeg=01;35:*.mjpg=01;35:*.mjpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.webm=01;35:*.webp=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.cgm=01;35:*.emf=01;35:*.ogv=01;35:*.ogx=01;35:*.aac=01;36:*.au=01;36:*.flac=01;36:*.m4a=01;36:*.mid=01;36:*.midi=01;36:*.mka=01;36:*.mp3=01;36:*.mpc=01;36:*.ogg=01;36:*.ra=01;36:*.wav=01;36:*.oga=01;36:*.opus=01;36:*.spx=01;36:*.xspf=01;36:
SSH_CONNECTION=10.0.2.1 37578 10.0.2.101 22
XDG_SESSION_CLASS=user
SELINUX_ROLE_REQUESTED=
TERM=xterm-256color
LESSOPEN=||/usr/bin/lesspipe.sh %s
USER=trainee
SELINUX_USE_CURRENT_RANGE=
SHLVL=1
XDG_SESSION_ID=4
XDG_RUNTIME_DIR=/run/user/1000
SSH_CLIENT=10.0.2.1 37578 22
which_declare=declare -f
XDG_DATA_DIRS=/home/trainee/.local/share/flatpak/exports/share:/var/lib/flatpak/exports/share:/usr/local/share:/usr/share
PATH=/home/trainee/.local/bin:/home/trainee/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin
SELINUX_LEVEL_REQUESTED=
DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/1000/bus
MAIL=/var/spool/mail/trainee
SSH_TTY=/dev/pts/0
BASH_FUNC_which%%=() {  ( alias;
 eval ${which_declare} ) | /usr/bin/which --tty-only --read-alias --read-functions --show-tilde --show-dot $@
}
_=/usr/bin/env
OLDPWD=/home/trainee/training

La commande peut aussi être utilisée pour fixer une variable lors de l'exécution d'une commande. Par exemple, pour lancer xterm avec la variable EDITOR fixée à vi :

$ env EDITOR=vim xterm

Pour visualiser les options du shell bash, il convient d'utiliser la commande set :

$ set -o [Entrée]

Par exemple :

[trainee@redhat9 ~]$ set -o
allexport       off
braceexpand     on
emacs           on
errexit         off
errtrace        off
functrace       off
hashall         on
histexpand      on
history         on
ignoreeof       off
interactive-comments    on
keyword         off
monitor         on
noclobber       off
noexec          off
noglob          off
nolog           off
notify          off
nounset         off
onecmd          off
physical        off
pipefail        off
posix           off
privileged      off
verbose         off
vi              off
xtrace          off

Pour activer une option il convient de nouveau à utiliser la commande set :

[trainee@redhat9 ~]$ set -o allexport
[trainee@redhat9 ~]$ set -o
allexport       on
braceexpand     on
emacs           on
errexit         off
errtrace        off
functrace       off
hashall         on
histexpand      on
history         on
ignoreeof       off
interactive-comments    on
keyword         off
monitor         on
noclobber       off
noexec          off
noglob          off
nolog           off
notify          off
nounset         off
onecmd          off
physical        off
pipefail        off
posix           off
privileged      off
verbose         off
vi              off
xtrace          off

Notez que l'option allexport a été activée.

Pour désactiver une option, on utilise la commande set avec l'option +o :

$ set +o allexport [Entrée]

[trainee@redhat9 ~]$ set +o allexport
[trainee@redhat9 ~]$ set -o
allexport       off
braceexpand     on
emacs           on
errexit         off
errtrace        off
functrace       off
hashall         on
histexpand      on
history         on
ignoreeof       off
interactive-comments    on
keyword         off
monitor         on
noclobber       off
noexec          off
noglob          off
nolog           off
notify          off
nounset         off
onecmd          off
physical        off
pipefail        off
posix           off
privileged      off
verbose         off
vi              off
xtrace          off

Parmi les options, voici la description des plus intéressantes :

[trainee@redhat9 ~]$ set -o noclobber
[trainee@redhat9 ~]$ pwd > file
-bash: file: cannot overwrite existing file
[trainee@redhat9 ~]$ pwd >| file
[trainee@redhat9 ~]$ cat file
/home/trainee
[trainee@redhat9 ~]$ set +o noclobber

[trainee@redhat9 ~]$ set -o noglob
[trainee@redhat9 ~]$ echo *
*
[trainee@redhat9 ~]$ set +o noglob
[trainee@redhat9 ~]$ echo *
aac abc bca codes Desktop Documents Downloads errorlog file file1 file2 list Music Pictures Public Templates training Videos vitext xyz

[trainee@redhat9 ~]$ set -o nounset
[trainee@redhat9 ~]$ echo $FENESTROS
-bash: FENESTROS: unbound variable
[trainee@redhat9 ~]$ set +o nounset
[trainee@redhat9 ~]$ echo $FENESTROS

[trainee@redhat9 ~]$

Le but de la suite de cette unité est de vous amener au point où vous êtes capable de comprendre et de déchiffrer les scripts, notamment les scripts de démarrage ainsi que les scripts de contrôle des services.

Écrire des scripts compliqués est en dehors de la portée de cette unité car il nécessite une approche programmation qui ne peut être adressée que lors d'une formation dédiée à l'écriture des scripts.

Un script shell est un fichier dont le contenu est lu en entrée standard par le shell. Le contenu du fichier est lu et exécuté d'une manière séquentielle. Afin qu'un script soit exécuté, il suffit qu'il puisse être lu au quel cas le script est exécuté par un shell fils soit en l'appelant en argument à l'appel du shell :

/bin/bash myscript

soit en redirigeant son entrée standard :

/bin/bash < myscript

Dans le cas où le droit d'exécution est positionné sur le fichier script et à condition que celui-ci se trouve dans un répertoire spécifié dans le PATH de l'utilisateur qui le lance, le script peut être lancé en l'appelant simplement par son nom :

myscript

Pour lancer le script sans qu'il soit dans un répertoire du PATH, il convient de se placer dans le répertoire contenant le script et de le lancer ainsi :

./myscript

Dans le cas où le script doit être exécuté par le shell courant, dans les mêmes conditions que l'exemple précédent, et non par un shell fils, il convient de le lancer ainsi :

. myscript

Dans un script il est fortement conseillé d'inclure des commentaires. Les commentaires permettent à d'autres personnes de comprendre le script. Toute ligne de commentaire commence avec le caractère #.

Il existe aussi un pseudo commentaire qui est placé au début du script. Ce pseudo commentaire permet de stipuler quel shell doit être utilisé pour l'exécution du script. L'exécution du script est ainsi rendu indépendant du shell de l'utilisateur qui le lance. Le pseudo commentaire commence avec les caractères #!. Chaque script commence donc par une ligne similaire à celle-ci :

#!/bin/sh

Puisque un script contient des lignes de commandes qui peuvent être saisies en shell intéractif, il est souvent issu d'une procédure manuelle. Afin de faciliter la création d'un script il existe une commande, script, qui permet d'enregistrer les textes sortis sur la sortie standard, y compris le prompt dans un fichier dénommé typescript. Afin d'illustrer l'utilisation de cette commande, saisissez la suite de commandes suivante :

[trainee@redhat9 ~]$ script
Script started, output log file is 'typescript'.
[trainee@redhat9 ~]$ pwd
/home/trainee
[trainee@redhat9 ~]$ ls
aac  bca    Desktop    Downloads  file   file2  Music     Public     training    Videos  xyz
abc  codes  Documents  errorlog   file1  list   Pictures  Templates  typescript  vitext
[trainee@redhat9 ~]$ exit
exit
Script done.

[trainee@redhat9 ~]$ cat typescript 
Script started on 2024-09-26 13:05:22+02:00 [TERM="xterm-256color" TTY="/dev/pts/0" COLUMNS="121" LINES="38"]
[trainee@redhat9 ~]$ pwd
/home/trainee
[trainee@redhat9 ~]$ ls
aac  bca    Desktop    Downloads  file   file2  Music     Public     training    Videos  xyz
abc  codes  Documents  errorlog   file1  list   Pictures  Templates  typescript  vitext
[trainee@redhat9 ~]$ exit
exit

Script done on 2024-09-26 13:05:34+02:00 [COMMAND_EXIT_CODE="0"]

Cette procédure peut être utilisée pour enregistrer une suite de commandes longues et compliquées afin d'écrire un script.

Pour illustrer l'écriture et l'exécution d'un script, créez le fichier myscript avec vi :

[trainee@redhat9 ~]$ vi myscript
[trainee@redhat9 ~]$ cat myscript
pwd
ls

Sauvegardez votre fichier. Lancez ensuite votre script en passant le nom du fichier en argument à /bin/bash :

[trainee@redhat9 ~]$ /bin/bash myscript
/home/trainee
aac  bca    Desktop    Downloads  file   file2  Music     Pictures  Templates  typescript  vitext
abc  codes  Documents  errorlog   file1  list   myscript  Public    training   Videos      xyz

Lancez ensuite le script en redirigeant son entrée standard :

[trainee@redhat9 ~]$ /bin/bash < myscript
/home/trainee
aac  bca    Desktop    Downloads  file   file2  Music     Pictures  Templates  typescript  vitext
abc  codes  Documents  errorlog   file1  list   myscript  Public    training   Videos      xyz

Pour lancer le script en l'appelant simplement par son nom, son chemin doit être inclus dans votre PATH:

[trainee@redhat9 ~]$ echo $PATH
/home/trainee/.local/bin:/home/trainee/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin

Dans le cas de RHEL/CentOS, même si PATH contient $HOME/bin, le répertoire n'existe pas :

[trainee@redhat9 ~]$ ls
aac  bca    Desktop    Downloads  file   file2  Music     Pictures  Templates  typescript  vitext
abc  codes  Documents  errorlog   file1  list   myscript  Public    training   Videos      xyz

Créez donc ce répertoire :

[trainee@redhat9 ~]$ mkdir bin

Ensuite déplacez votre script dans ce répertoire et rendez-le exécutable pour votre utilisateur :

[trainee@redhat9 ~]$ mv myscript ~/bin
[trainee@redhat9 ~]$ chmod u+x ~/bin/myscript

Exécutez maintenant votre script en l'appelant par son nom à partir du répertoire /tmp :

[trainee@redhat9 ~]$ cd /tmp
[trainee@redhat9 tmp]$ myscript
/tmp
dbus-G7skg3Wlpv  filepartae  systemd-private-7e6b4544d8d34a9bb30a13aeb8e4e02a-colord.service-FfNuds
dbus-s2vBGtxTHi  greptest    systemd-private-7e6b4544d8d34a9bb30a13aeb8e4e02a-dbus-broker.service-VIpKgR
expand           greptest1   systemd-private-7e6b4544d8d34a9bb30a13aeb8e4e02a-kdump.service-0SbYbm
expand1          inode       systemd-private-7e6b4544d8d34a9bb30a13aeb8e4e02a-ModemManager.service-k4DpLF
expand2          newfile     systemd-private-7e6b4544d8d34a9bb30a13aeb8e4e02a-power-profiles-daemon.service-mIx9S5
filepartaa       sales.awk   systemd-private-7e6b4544d8d34a9bb30a13aeb8e4e02a-rtkit-daemon.service-2gD28Z
filepartab       sales.txt   systemd-private-7e6b4544d8d34a9bb30a13aeb8e4e02a-switcheroo-control.service-rLbOK4
filepartac       scriptawk   systemd-private-7e6b4544d8d34a9bb30a13aeb8e4e02a-systemd-logind.service-uLNyfd
filepartad       sedtest     systemd-private-7e6b4544d8d34a9bb30a13aeb8e4e02a-upower.service-bIpAUN

Placez-vous dans le répertoire contenant le script et saisissez les commandes suivantes :

[trainee@redhat9 tmp]$ cd ~/bin
[trainee@redhat9 bin]$ ./myscript
/home/trainee/bin
myscript
[trainee@redhat9 bin]$ . myscript
/home/trainee/bin
myscript

La commande read lit son entrée standard et affecte les mots saisis dans la ou les variable(s) passée(s) en argument. La séparation entre le contenu des variables est l'espace. Par conséquent il est intéressant de noter les exemples suivants :

[trainee@redhat9 bin]$ read var1 var2 var3 var4
fenestros edu is great!
[trainee@redhat9 bin]$ echo $var1
fenestros
[trainee@redhat9 bin]$ echo $var2
edu
[trainee@redhat9 bin]$ echo $var3
is
[trainee@redhat9 bin]$ echo $var4
great!

[trainee@redhat9 bin]$ read var1 var2
fenestros edu is great!
[trainee@redhat9 bin]$ echo $var1
fenestros
[trainee@redhat9 bin]$ echo $var2
edu is great!

La commande read renvoie un code de retour de 0 dans le cas où elle ne reçoit pas l'information fin de fichier matérialisée par les touches Ctrl+D. Le contenu de la variable var peut être vide et la valeur du code de retour 0 grâce à l'utilisation de la touche Entrée :

[trainee@redhat9 bin]$ read var

↵ Entrée

[trainee@redhat9 bin]$ echo $?
0
[trainee@redhat9 bin]$ echo $var

[trainee@redhat9 bin]$ 

Le contenu de la variable var1 peut être vide et la valeur du code de retour autre que 0 grâce à l'utilisation des touches Ctrl+D :

[trainee@redhat9 bin]$ read var1

Ctrl+D

[trainee@redhat9 bin]$ echo $?
1
[trainee@redhat9 bin]$ echo $var1

[trainee@redhat9 bin]$ 

La variable IFS contient par défaut les caractères Espace, Tab et Entrée :

[trainee@redhat9 bin]$ echo "$IFS" | od -c
0000000      \t  \n  \n
0000004

La valeur de cette variable définit donc le séparateur de mots lors de la saisie des contenus des variables avec la commande read. La valeur de la variable IFS peut être modifiée :

[trainee@redhat9 bin]$ OLDIFS="$IFS"
[trainee@redhat9 bin]$ IFS=":"
[trainee@redhat9 bin]$ echo "$IFS" | od -c
0000000   :  \n
0000002

De cette façon l'espace redevient un caractère normal :

[trainee@redhat9 bin]$ read var1 var2 var3
fenestros:edu is:great!
[trainee@redhat9 bin]$ echo $var1
fenestros
[trainee@redhat9 bin]$ echo $var2
edu is
[trainee@redhat9 bin]$ echo $var3
great!

Restaurez l'ancienne valeur de IFS avec la commande IFS=“$OLDIFS”

[trainee@redhat9 bin]$ IFS="$OLDIFS"
[trainee@redhat9 bin]$ echo "$IFS" | od -c
0000000      \t  \n  \n
0000004

La commande test peut être utilisée avec deux syntaxes :

test expression

ou

[EspaceexpressionEspace]

Testez si le fichier a100 est un fichier ordinaire :

[trainee@redhat9 bin]$ cd ../training/
[trainee@redhat9 training]$ test -f a100
[trainee@redhat9 training]$ echo $? 
0
[trainee@redhat9 training]$ [ -f a100 ]
[trainee@redhat9 training]$ echo $? 
0

Testez si le fichier a101 existe :

[trainee@redhat9 training]$ [ -f a101 ]
[trainee@redhat9 training]$ echo $?
1

Testez si /home/trainee/training est un répertoire :

[trainee@redhat9 training]$ [ -d /home/trainee/training ]
[trainee@redhat9 training]$ echo $?
0

Testez si les deux chaînes sont égales :

[trainee@redhat9 training]$ string1="root"
[trainee@redhat9 training]$ string2="fenestros"
[trainee@redhat9 training]$ [ $string1 = $string2 ]
[trainee@redhat9 training]$ echo $?
1

Testez si la string1 n'a pas de longueur 0 :

[trainee@redhat9 training]$ [ -n $string1 ]
[trainee@redhat9 training]$ echo $?
0

Testez si la string1 a une longueur de 0 :

[trainee@redhat9 training]$ [ -z $string1 ]
[trainee@redhat9 training]$ echo $?
1

Comparez les deux nombres value1 et value2 :

[trainee@redhat9 training]$ read value1
35
[trainee@redhat9 training]$ read value2
23
[trainee@redhat9 training]$ [ $value1 -lt $value2 ]
[trainee@redhat9 training]$ echo $?
1
[trainee@redhat9 training]$ [ $value2 -lt $value1 ]
[trainee@redhat9 training]$ echo $?
0
[trainee@redhat9 training]$ [ $value2 -eq $value1 ]
[trainee@redhat9 training]$ echo $?
1

Testez si $file n'est pas un répertoire :

[trainee@redhat9 training]$ file=a1OO
[trainee@redhat9 training]$ [ ! -d $file ]
[trainee@redhat9 training]$ echo $?
0

Testez si $directory est un répertoire et si l'utilisateur à le droit de le traverser :

[trainee@redhat9 training]$ directory=/usr
[trainee@redhat9 training]$ [ -d $directory -a -x $directory ]
[trainee@redhat9 training]$ echo $?
0

Testez si l'utilisateur peut écrire dans le fichier a100 et /usr est un répertoire ou /tmp est un répertoire :

[trainee@redhat9 training]$ [ -w a100 -a \( -d /usr -o -d /tmp \) ]
[trainee@redhat9 training]$ echo $?
0

[trainee@redhat9 training]$ [ -o allexport ]
[trainee@redhat9 training]$ echo $?
1

La commande [[EspaceexpressionEspace]] est une amélioration de la commande test. Les opérateurs de la commande test sont compatibles avec la commande [[ expression ]] sauf -a et -o qui sont remplacés par && et || respectivement :

D'autres opérateurs ont été ajoutés :

Testez si l'utilisateur peut écrire dans le fichier a100 et /usr est un répertoire ou /tmp est un répertoire :

[trainee@redhat9 training]$ [[ -w a100 && ( -d /usr || -d /tmp ) ]]
[trainee@redhat9 training]$ echo $?
0

[trainee@redhat9 training]$ [[ -d /root ]] && echo "The root directory exists"
The root directory exists
[trainee@redhat9 training]$ [[ -d /root ]] || echo "The root directory exists"
[trainee@redhat9 training]$  

La commande expr prend la forme :

expr Espace value1 Espace opérateur Espace value2 Entrée

ou

expr Tab value1 Tab opérateur Tab value2 Entrée

ou

expr Espace chaîne Espace : Espace expression_régulière Entrée

ou

expr Tab chaîne Tab : Tab expression_régulière Entrée

Ajoutez 2 à la valeur de $x :

[trainee@redhat9 training]$ x=2
[trainee@redhat9 training]$ expr $x + 2
4

Si les espaces sont retirés, le résultat est tout autre :

[trainee@redhat9 training]$ expr $x+2
2+2

Les opérateurs doivent être protégés :

[trainee@redhat9 training]$ expr $x * 2
expr: syntax error
[trainee@redhat9 training]$ expr $x \* 2
4

Mettez le résultat d'un calcul dans une variable :

[trainee@redhat9 training]$ resultat=`expr $x + 10`
[trainee@redhat9 training]$ echo $resultat
12

La commande let est l'équivalent de la commande ((expression)). La commande ((expression)) est une amélioration de la commande expr :

• plus grand nombre d'opérateurs
• pas besoin d'espaces ou de tabulations entre les arguments
• pas besoin de préfixer les variables d'un $
• les caractères spéciaux du shell n'ont pas besoin d'être protégés
• les affectations se font dans la commande
• exécution plus rapide

[trainee@redhat9 training]$ x=2
[trainee@redhat9 training]$ ((x=$x+10))
[trainee@redhat9 training]$ echo $x
12
[trainee@redhat9 training]$ ((x=$x+20))
[trainee@redhat9 training]$ echo $x
32

La syntaxe de la commande If est la suivante :

if condition
then
    commande(s)
else 
    commande(s)
fi

ou :

if condition
then
    commande(s)
    commande(s)
fi

ou encore :

if condition
then
     commande(s)
elif condition
then
     commande(s)
elif condition
then
     commande(s)
else 
    commande(s)

fi

Créez le script user_check suivant :

[trainee@redhat9 training]$ vi user_check
[trainee@redhat9 training]$ cat user_check
#!/bin/bash
if [ $# -ne 1 ] ; then
  echo "Mauvais nombre d'arguments"
  echo "Usage : $0 nom_utilisateur"
  exit 1
fi
if grep "^$1:" /etc/passwd > /dev/null
then
  echo "Utilisateur $1 est défini sur ce système"
else
  echo "Utilisateur $1 n'est pas défini sur ce système"
fi
exit 0

Testez-le :

[trainee@redhat9 training]$ chmod 770 user_check
[trainee@redhat9 training]$ ./user_check
Mauvais nombre d'arguments
Usage : ./user_check nom_utilisateur
[trainee@redhat9 training]$ ./user_check root
Utilisateur root est défini sur ce système
[trainee@redhat9 training]$ ./user_check mickey mouse
Mauvais nombre d'arguments
Usage : ./user_check nom_utilisateur
[trainee@redhat9 training]$ ./user_check "mickey mouse"
Utilisateur mickey mouse n'est pas défini sur ce système

La syntaxe de la commande case est la suivante :

case $variable in
modele1) commande
   ...
   ;;
modele2) commande
   ...
   ;;
modele3 | modele4 | modele5 ) commande
   ...
   ;;
esac

  case "$1" in
      start)
          start
          ;;
      stop)
          stop
          ;;
      restart|reload)
          stop
          start
          ;;
      status)
          status
          ;;
      *)
          echo $"Usage: $0 {start|stop|restart|status}"
          exit 1
esac

La syntaxe de la commande for est la suivante :

for variable in liste_variables
do
    commande(s)
done

La syntaxe de la commande while est la suivante :

while condition
do
    commande(s)
done

U=1
while [ $U -lt $MAX_ACCOUNTS ]
do
useradd fenestros"$U" -c fenestros"$U" -d /home/fenestros"$U" -g staff -G audio,fuse -s /bin/bash 2>/dev/null
useradd fenestros"$U"$ -g machines -s /dev/false -d /dev/null 2>/dev/null
echo "Compte fenestros$U créé"
let U=U+1
done

Quand Bash est appelé en tant que shell de connexion, il exécute des scripts de démarrage dans l'ordre suivant :

• /etc/profile,
• ~/.bash_profile ou ~/.bash_login ou ~/.profile selon la distribution,

Dans le cas de RHEL/CentOS, le système exécute le fichier ~/.bash_profile.

Quand un shell de login se termine, Bash exécute le fichier ~/.bash_logout si celui-ci existe.

Quand bash est appelé en tant que shell interactif qui n'est pas un shell de connexion, il exécute le script ~/.bashrc.

[trainee@redhat9 training]$ cat ~/.bash_profile
# .bash_profile

# Get the aliases and functions
if [ -f ~/.bashrc ]; then
        . ~/.bashrc
fi

# User specific environment and startup programs

[trainee@redhat9 training]$ cat ~/.bashrc
# .bashrc

# Source global definitions
if [ -f /etc/bashrc ]; then
        . /etc/bashrc
fi

# User specific environment
if ! [[ "$PATH" =~ "$HOME/.local/bin:$HOME/bin:" ]]
then
    PATH="$HOME/.local/bin:$HOME/bin:$PATH"
fi
export PATH

# Uncomment the following line if you don't like systemctl's auto-paging feature:
# export SYSTEMD_PAGER=

# User specific aliases and functions
if [ -d ~/.bashrc.d ]; then
        for rc in ~/.bashrc.d/*; do
                if [ -f "$rc" ]; then
                        . "$rc"
                fi
        done
fi

unset rc

Copyright © 2024 Hugh Norris.