"Formation RHCSA : Administration Système sous Red Hat Enterprise Linux"

● Installation de Red Hat Enterprise Linux & Enregistrement

● Craquer ou Réinitialiser le Mot de Passe Root
● Commandes Générales & Scripts Shell
● Gestion des Utilisateurs et des Groupes
● Systèmes de Fichiers
● Gestion des Packages Logiciels
● Réseaux
● Gestion des Services
● Automatisation des Tâches
● Gestion du Stockage
● Gestion des Conteneurs
 Installation de Red Hat Enterprise Linux & Enregistrement:

- créer un compte sur redhat.com

- s'inscrire sur developers.redhat
- subscription-manager register

Craquer ou Réinitialiser le Mot de Passe Root

to open prompt: init= /bin/sh

mount -o remount,rw /
passwd root
new password retype new password
touch /.autorelabel
/usr/sbin/reboot -f

Commandes Générales & Scripts Shell:

théorique:

★ commandes:
cd directory → Change le répertoire courant vers "directory".
pwd → afficher path du répertoire courant.
cd .. → Change le répertoire courant vers le répertoire
parent.
ls → Liste les fichiers et répertoires du répertoire
courant.
ls -l → Liste les détails des fichiers et répertoires.
ls -a → Liste tous les fichiers, y compris les fichiers
cachés.
pwd → Affiche le répertoire de travail actuel.
whoami → Affiche le nom de l'utilisateur actuel.
touch file → Crée un nouveau fichier.
mkdir dir → Crée un nouveau répertoire.
mkdir -p → Crée des répertoires récursivement, y compris les
parents.
cat → Affiche le contenu d'un fichier.
echo "text" → Affiche du texte.
 echo "text" > file → Écrase le contenu du fichier avec le
texte.
echo "text" >> file → Ajoute du texte à la fin du fichier.
vim / nano → Édite un fichier en utilisant l'éditeur Vim ou
Nano.
rmdir → Supprime un répertoire vide.
rm → Supprime un fichier.
rm -rf → Supprime un répertoire récursivement et de force.
man / help → Fournit des informations sur la commande.
cp -rf sourceLocation destinationLocation → Copie un répertoire.
cp sourceLocation destinationLocation → Copie un fichier.
mv sourceLocation destinationLocation → Renomme ou déplace un
fichier ou un répertoire.
ctrl + a → Déplace le curseur au début de la ligne.
ctrl + e → Déplace le curseur à la fin de la ligne.
ctrl + c → Arrête l'exécution d'une commande.
history → Affiche l'historique des commandes.
sudo → Exécuter une commande avec des privilèges root.
grep → Recherche des motifs dans un fichier.
grep -w → Recherche un mot exact.
find → Recherche des fichiers dans un répertoire.
find répertoire [options] -exec cp -a {} destination \;
options:
-name: nom de fichier,
-group: le grp propriétaire,
-user: le propriétaire,
-size: taille +n{k,M,G…} ou -n{k,M,G…},
-perm: permission,
-type: f pour fichier et d pour directory,
commande:
- cp: copier les fichiers recherché (cp -a {})
★ script shell:

doit avoir l'extension .sh.

doit commencer par le shebang : #!/bin/bash ou #!/bin/sh.

afficher du texte: echo “texte”

entrer une variable : read variable

appel variable: $variable

enregistrer des messages dans le journal du système: logger “texte”

vérifier le texte de journal du système: journalctl | grep “texte”

pour exécuter les scripts : bash fichier.sh ou sh fichier.sh,

ou chmod +x fichier.sh puis ./fichier.sh.

Pratique:

Q0. Ask the user for their name, Greet the user then Log the event in the
system logs using a script called greeting.sh

vim greeting.sh

#! /bin/bash

echo “donner le nom”

read nom

echo “hello $nom”

logger “user $nom executed the greeting script”

bash greeting.sh

journalctl | grep user

Q1. Copy '/etc/passwd' to '/tmp'.

cp /etc/passwd /tmp

Q2. Copy "/etc/shadow" to "/home/tekup/" and create a new file called

"nopass" containing all lines with "!!".

mkdir /home/tekup

cp /etc/passwd /tmp
 grep ‘!!’ /home/tekup/shadow > nopass

Q3. Find all lines in the file '/usr/share/dict/words' that contain the string
"seismic". Copy all these lines to the file '/root/wordlist'.

grep -w seismic /usr/share/dict/words > /root/wordlist

Q4. Locate all files owned by "user".

find / -type f -user user 2> /dev/null

Q5. Find all files less than 1 KB size in '/var'.

find /var -type f -size -1k

Q6. Find all files ending with ".txt" in the '/root/Documents' directory.

find /root/Documents -name *.txt

Q7. Copy all files owned by "user" to "/root/dir".

find / -type f -user user -exec cp -a {} /root/dir \;

Q8. Copy all files larger than 100 MB to the '/backup' directory.

find / -type f -size +100M -exec cp -a {} /backup \;

Q9. Copy all files in the "/home/user/documents" directory that have read and
write permissions for the owner, read-only permission for the group, and no
permission for others to the "/secure_backup" directory.

Gestion des Utilisateurs et des Groupes:

théorique:

/etc/shadow → contient les mots de passe.

/etc/passwd → contient les utilisateurs.
/etc/group→ contient les groupes.
/etc/skel→ modèle de répertoire personnel.
/etc/login.defs→ contient des paramètres de création de l’utilisateur.
/etc/default/useradd→ contient les valeurs par défaut.
~/.bash_profile & ~/.bashrc→ pour ajouter des variables spécifiques à un
utilisateur.
/etc/security/pwquality.conf→ changer les caractéristiques du mot de
passe (root).
su user → Passe à l'utilisateur spécifié.
su - user → Passe à l'utilisateur spécifié et change vers son
répertoire personnel.
man useradd
useradd [option] username → ajouter utilisateur
passwd username → affecter un mot de passe à l'utilisateur
useradd -M username → ajouter un utilisateur sans répertoire
personnel
man chage
chage [option] username → gérer mot de passe
chage -d 0 username → changer le mot de passe dès que username
se
connecte (Date de la dernière modification =0 days)
options:
-m → durée minimum en jour pour que le user change mot de
passe (days).
-M → nombre maximum du jour avant expiration de mot de passe.
-E → date exacte d’expiration (yyyy-mm-dd)
-W → nombre des jours de warning :avant expiration
man usermod
usermod [option] username → modifier utilisateur
options:
-u → modifier UID
-g → modifier GID (grp primaire)
-G → modifier grp secondaire
-aG → ajouter un autre grp secondaire
-c → ajouter un commentaire
-s → modifier le shell.
-d → modifier le répertoire personnel.
usermod -s /sbin/nologin username → rendre un utilisateur
inactif
usermod –L username→ désactive le compte de username en
verrouillant son mot de passe.
usermod –U username→ pour déverouiller.
 echo “username ALL=(ALL) ALL” >> /etc/sudoers → ajouter
l’utilisateur pour pouvoir utiliser la commande sudo
echo “username ALL=(ALL) NOPASSWD:ALL” >> /etc/sudoers →
ajouter l’utilisateur pour pouvoir utiliser la commande sudo
sans demande de mot de passe.
man groupadd
groupadd [option] groupname → ajouter groupe.
man groupmod
groupadd [option] groupname → modifier groupe.
groupadd -o -g 490 groupname → donner un gid déjà utilisé
usermod -g groupname→ affecter un utilisateur à un groupe
primaire.
usermod -G groupname→ affecter un utilisateur à un groupe
secondaire.
usermod -aG groupname→ affecter un utilisateur à un autre
groupe secondaire.
groups username→ affiche les groupes de username
userdel username → supprimer un utilisateur
userdel -r username → supprimer un utilisateur avec son
répertoire personnel
groupdel groupname→ supprimer un groupe
man chown
chown [options] [newowner][:newgroup] filename
→ modifier le propriétaire et le groupe propriétaire d’un
fichier
-R → pour un répertoire
chown newowner filename
→ modifier le propriétaire
chown :newgroup filename
→ modifier le groupe propriétaire

pratique:

Q0. Every newly created user must have a UID between 1000 and 3000.

vim /etc/login.defs

UID_MIN 1000
UID_MAX 3000

Q1. Create a user named 'student' with the password 'tekup'.

useradd student

passwd student

Q2. Set a specific umask=013 for 'student'.

su - student

vim .bash_profile

umask 0013

exit

su - student

umask

Q3. Assign this user to a secondary group named 'tekup'.

groupadd tekup

usermod -G tekup student

Q4. give this user permission to use sudo without a password.

echo “student ALL=(ALL) NOPASSWD:ALL” >> /etc/sudoers

or

vim /etc/sudoers

student ALL=(ALL) NOPASSWD:ALL

Q5. As the 'student' user, create a file named 'fich'.

su - student

touch fich
 Q6. Change the group owner of this file to 'tekup'.

sudo chown :tekup fich

★ les droits d’accès

théorique:

read – write – execute

r w x
2^2 2^1 2^0
4 2 1 → de manière octale
user group others
u g o → de manière symbolique
man chmod
chmod [options] permission filename
→ modifier les permissions de fichier
exemple:
Propriétaire : lire et écrire
Groupe : Lire , écrire et exécuter
Autres : Lire
Mode octal : chmod 674 fichier
Mode symbolique : chmod u=rw,g=rwx,o=r filename
ajouter x pour user: chmod u+x filename
retirer x pour qroup: chmod g-x filename
0666 → Est la permission maximum pour un fichier
0777 → Est la permission maximum pour un répertoire
0022 → Est la valeur de Umask par défaut
umask
umask new_value → modifier temporairement le umask
echo “umask new_value” /etc/profile → modifier le umask de
manière persistante, s'appliquera à tous les utilisateurs
lorsqu'ils se connectent au système.
echo “umask new_value” ~/.bashrc → modifier le umask de manière
persistante, s'appliquera à un utilisateur spécifique
lorsqu'il se connectent au système.
permission maximum(777) - mask =permission par défaut
mask= permission maximum(777) - permission par défaut
exemple:
Quelles seront les permissions par défaut pour un fichier si le mask est 013?
○ rwx rwx rwx
 --- --x -wx
○ ----------------------------------
○ = rw- rw- r --
Quelles seront les permissions par défaut pour un dossier si le mask est 013?
○ rwx rwx rwx
--- --x -wx
○ ----------------------------------
○ = rwx rw- r --
★ Droits spéciaux:

SUID: 4000 ,(rws --- --- pour rwx --- ---), (rwS --- --- pour rw- --- ---)

Permet de bénéficier de droits supplémentaires lors de l’exécution d’une

commande, Un utilisateur quelconque peut alors avoir des droits
supplémentaires seulement s’il exécute la commande ayant le SUID.

exemple de commande ayant le SUID → passwd (ls -l

/usr/bin/passwd)

chmod u+s filename→ appliquer SUID a un fichier

SGID: 2000 ,(--- rws --- pour --- rwx ---), (--- rwS --- pour --- rw- ---)

Appliquée à un répertoire, dont tous ses fichiers nouvellement créés auront le

même groupe propriétaire

chmod g+s dirname→ appliquer SGID à un répertoire.

Sticky bit: 1000 ,(--- --- rwt pour --- --- rwx), (--- --- rwT pour — — rw-)

Appliquée à un répertoire, il interdit la suppression des fichiers (et de dossier)

qu’il contient à tout utilisateur (autre que le propriétaire et le root).

chmod o+t dirname→ appliquer Sticky bit à un répertoire.

pratique:

Q0. Create a directory named "test_directory" in your home directory, Ensure

that only the owner has the right to read, write, and execute, while others have
no access rights, files created in this directory inherit the group too and
cannot be deleted only by their owners or root.
chmod 3700 test_directory
or
chmod u=rwx,o=- test_directory
chmod g+s test_directory
chmod o+t test_directory
Q1. You have a sensitive file named "confidential" in your home directory.
You want to share this file with the user "friend" allowing them only to read it,
and with the group "colleagues" giving them both read and write permissions.
you also want to ensure that no one else has access to the file.
setfacl -m u:friend:r,g:colleagues:rw,o:- confidential

➔ Lab évaluation partie 1

➔ correction lab 1

Systèmes de Fichiers:

★ Application :

Application est une commande personalisé ou alias

Pour créer une application il faut ouvrir le fichier .bashrc et ajouter alias

Vim (Or nano) .bashrc

Alias <nom de commande>=’ Commande a exécuter ‘

Fermer fichier

Source .bashrc
Pratique :

Q0. Ecrire une application nommer redhat qui affiche un message « It’s exam
time » quand on l’execute :

vim .bashrc

alias redhat=’echo ‘’ It’s exam time ‘’ ‘

source .bashrc

redhat

Q1. Ecrire une application nommer welcome qui affiche un message « Hello
World ! » executable que par le user test :

vim /home/test/.bashrc

alias welcome=’echo ‘’Hello World !’’ ‘

source /home/test/.bashrc

★ NFS:

théorique:

file server?

un ordinateur responsable du stockage afin que d'autres ordinateurs du

même réseau puissent accéder aux fichiers, via Network share: NFS (protocol
of Network share in linux)

how to use NFS service?

the server export the directory then the client mount the nfs filesystem.

any service have a layering protection: firewall; firewalld-cmd command

(default: rules are blocked), selinux; semanage command (security enhanced
linux)
pratique:

- partie serveur: (must be root: su -)

dnf install nfs* → install the service

systemctl enable --now nfs-server → enable & start the service

(or systemctl enable nfs-server then systemctl start nfs-server)

systemctl status nfs-server → verify the status of the service

configuration?

mkdir /shared_directory → create the directory to share

echo “/shared_directory @ipclient(x ,y) ” /etc/exports →

configure the shared directory in the server.

x can be ro or rw & y can be no_root_squash or async

no_root_squash → the root client will have the same ownership

of files in the shared directory

root_squash → (default) the root client will not have the same
ownership of files in the shared directory

rw → the shared directory will be readable and writable for

the client

ro → the shared directory will be just readable for the

client

sync → (default) synchronous connexion; the server waits for

data to be physically written to the disk (of client) before
responding to the client's write request.
 async → asynchronous connexion; the NFS server can respond to
the client before the data is physically written to the disk.

systemctl restart nfs-server → restarting the service because

we modified its configuration file (/etc/exports)

semanage boolean -l | grep nfs_export_all_ro → verifying that

nfs is allowed to export with ro mode: must be on

semanage boolean -l | grep nfs_export_all_rw → verifying that

nfs is allowed to export with ro mode: must be on

setsebool -P nfs_export_all_rw=1 → allow sharing with rw mode

setsebool -P nfs_export_all_ro=1 → allow sharing with ro mode

firewall-cmd --list-all → to see enabled services

firewall-cmd --add-service=nfs --permanent → to allow nfs

service

firewall-cmd --reload → to reload firewall rules

exportfs -avr → to export the directory to the client

- partie client: (must be root: su -)

dnf install nfs-utils → install the service

mkdir /mount_point→ create the directory where you will mount

the shared_directory

mount -t nfs -o rw @ipserver:/shared_directory /mount_point →

mount the shared_directory

umount /shared_directory → to unmount the shared_directory

echo “@ipserver:/shared_directory /mnt/mount_point nfs _netdev 0

0” >> /etc/fstab → mount the shared_directory permanently.
 mount -a → to execute the /etc/fstab

df -h → to verify

➔ AUTOFS: same thing just it will be automounted

example: to share a home directory (server) so users can use it (client)

Q0. Create a user named john on the two machines with uid 2001. His home
directory on the server is named /host/john. It will be mounted on /host/john with
autofs when john connects.

NB:the user in the server must have a base directory, the client must not have a
directory for testing.

Q1. /data directory is shared from machine2. Mount the shared directory so that :

• When a user try to access the mount point . The directory will be mounted

• Shared direcotry should be mounted on /mnt/data on this machine.

Notes:

- partie serveur:

dnf install nfs*

useradd -u 2001 -b /host john

echo “/host *(rw,no_root_squash) ” >> /etc/exports

firewall-cmd --add-service rpc-bind --permanent

firewall-cmd --add-service mountd --permanent

firewall-cmd --add-service nfs --permanent

firewall-cmd --reload

exportfs -arv

- partie client:

dnf install nfs-utils

dnf install autofs

//useradd -M -u 2001 -d /host/john john

echo “/host /etc/auto.misc” >> /etc/auto.master

echo “john -rw @ipserver:/host/john” >> /etc/auto.misc

systemctl restart nfs-server

systemctl restart autofs

★ archivage & compression

théorique:

tar -cvf archivename.tar répertoire→ réunir les fichiers dans

un seul gros fichier appelé archive. (étape 1)

tar -tvf archivename.tar→ lister le contenu d’une archive.

Compresser le gros fichier obtenu à l’aide de gzip ou de bzip2: (étape 2)

gzip archivename.tar→ compression d’une archive avec gzip.

gzip -d archivename.tar.gz→ décompression d’une archive avec

gzip.

bzip2 archivename.tar→ compression d’une archive avec bzip2.

bzip2 -d archivename.tar.bz2→ décompression d’une archive avec

bzip2.

tu peux faire les deux étapes (archivage+compression):

tar -cvzf répertoire.tar.gz répetoire→ archiver et compresser un

répertoire vers gzip.

tar -cvjf répertoire.tar.bz2 répetoire→ archiver et compresser

un répertoire vers bzip2.

ls -lh → pour vérifier la taille

pratique:

Q0. Create an archive named "documents.tar.gz" containing all files of the

"/home/user/documents" directory.

tar -cvzf document.tar.gz /home/user/documents

Q1. Compress the entire "/var/log" directory into a file named

"logs_backup.tar.bz2"

tar -cvjf logs_backup.tar.bz2 /var/log

Q2. Make a compressed backup of the "/etc" directory and save it as

"etc_backup.tar.gz" .

tar -cvzf etc_backup.tar.gz /etc

Gestion du Stockage:

théorique:

partitionnement: créer une ou plusieurs zones de stockage indépendantes.

Organisation du disque avec MBR: maximum 4 partitions principales et une partition

étebdu qui peut contenir plusieurs partitions logiques.

exemple:

pour périphérique SATA:

on dit /dev/sda pour la première disque sata.

on dit /dev/sdb pour la deuxième disque sata…

on dit /dev/sda1 pour la première partition de la première disque sata.

on dit /dev/sda2 pour la deuxième partition du premier disque sata…

Les formats des systèmes de fichiers: c’est comment linux organise et stocke ses
fichiers sur un périphérique de stockage: ext2, ext3, ext4, jfs, xfs..

montage: intègre un système de fichiers dans l'arborescence, une fois que vous avez
monté le disque, vous pouvez naviguer dans ses fichiers comme si c'étaient ceux de
votre ordinateur principal.

partition SWAP : Une partition swap sur un disque dur agit comme un espace de
stockage temporaire utilisé par le système d'exploitation pour déplacer des données
inactives de la mémoire vive (RAM) vers le disque.

lsblk → pour voir les disques et les partitions

fdisk /dev/nom_disque then n (new)→ pour créer une partition.

mkfs.filesystem_name /dev/nom_partition→ pour formater une

partition.

mkdir /mount_point → créer le point de montage.

blkid /dev/nom_partition → afficher le uuid de partition.

echo “UUID=uuid_of_the_partition /mount_dir xfs

defaults 0 0” >> /etc/fstab then mount -a→ monter la
partition (permanent)

pour effacer une partition déjà monté:

RQ: il faut démonter avant d' effacer une partition.

effacer la ligne dans /etc/fstab si c’est monté (permanently) then mount -a.

umount nom_partition.

fdisk /dev/nom_disque then d (delete) then w→ pour effacer la

partition.

RQ: il faut démonter avant de changer le type de partition (par exemple to swap)

- pour créer une partition SWAP( créer une partition puis changer le type en
swap):
 fdisk /dev/nom_disk then t (change type),L(list all hex code) ,
chose the code of swap:82 ,w (write)→ pour changer le type de swap.

mkswap /dev/nom_partition → pour formater une partition SWAP.

free -m → pour vérifier SWAP.

echo “uuid_of_the_SWAPpartition none swap defaults 0 0” >>

/etc/fstab then swapon -a→ monter la partition (permanent)

swapoff -a → pour annuler le swap

pratique:

Q0. Create a 2G swap partition which takes effect automatically at boot-start, and it
should not affect the original swap partition.

(même étapes: créer partition 2G puis monter la partition swap permanently)

théorique:

★ gestion par volume logique (LVM):

pour obtenir un volume logique on doit:

- avoir un volume physique (PV) depuis une partition.

- créer un volume group (VG) depuis des volumes physiques (PV).
- créer un volume logique.
 pourquoi? ( on a besoin d’un volume de 8G et on a que des partions moins
que 8G; solution: utiliser le concept de LVM)

● création d’un LV en vous donnant une taille exacte (PE=4MIB par def):

pvcreate /dev/partition_name → pour créer physical volume.

vgcreate vg_name /dev/partition_name1 /dev/partition_name2… →

pour créer volume group.

lvcreate -L sizeunity -n lv_name vg_name → pour créer le

logical volume.

● monter le logical volume:

mkdir /mount_point → créer le point de montage

mkfs.xfs /dev/vg_name/lv_name → pour donner un filesystem:

formater lv.

echo “/dev/vg_name/lv_name /mount_point xfs defaults 0 0

” >> /etc/fstab then mount -a→ pour monter la lv

On peut aussi étendre la lv: on peut avoir deux cas si l’espace de vg est suffisante et
si l’espace de vg est insuffisante.
RQ: par défaut si on crée un vg 0.02G seront pour les métadonnés.

● si l’espace de vg est suffisante:

vgs → pour voir les détails de vg (free size)

lvextend -r -L +<size> /dev/group_name/lv_name → pour étendre

le lv.

lvs → pour vérifier

● si l’espace de vg est insuffisante: (étendre vg puis lv)

vgs → pour voir les détails de vg (free size)

pvs → voir s’il ya un pv sinon créer une → pvcreate

/dev/partition_name.

vgextend vg_name name_free_physical_volume → pour étendre la

vg.

lvextend -r -L +<size> /dev/group_name/lv_name → pour étendre

le lv.(un lv déja monté ayant un filesystem -r :pour étendre aussi
le filesystem)

lvs → pour vérifier

● création d’un LV en vous donnant nombre de PE: extent et sa taille de PE:

vgdisplay → pour voir le PE

vgcreate -s <size_extent>unity name_of_grp /dev/pv_name

/dev/pv_name… → pour créer un volume group ayant la taille de PE
size_extent.

lvcreate -l <number> -n name_of_lv name_of_grp → pour créer lv

selon le nombre de PE.

size of PE * number of PE = size of LV

lvs → pour vérifier: la taille doit être <number>*<size_extent>.

RQ: pour supprimer une lv il faut la démonter, lvremove /dev/grp_name/lv_name

RQ: pour supprimer une vg, vgremove grp_name

pratique:

Q0. Create a Logical Volume partition, Below mentioned the conditions: Volume
Group is 510MB and name as vol0 Logical Volume is 80 MB and name as lv0 File
type is xfs and permanently mounted to /cms file system.

création partition 510+(pe=2):

fdisk /dev/sda then n then +512m then w (par défaut le vg réduit un pe=2)

vgcreate -s 2M vol0 /dev/sda1

lvcreate -L 80M -n lv0 vol0

mkdir /cms

mkfs.xfs /dev/vol0/lv0

echo “/dev/vol0/lv0 /cms xfs defaults 0 0” >> /etc/fstab

Q1. Create a Logical Volume Lvi with 60 extents Volume Group Vgi with 16MB extent
size Mount it permanently under /record with file system ext3.

créer partition plus que 60*16 (/dev/sda2)

vgcreate -s 16M vgi /dev/sda2

lvcreate -l 60 -n lvi vgi

mkfs.ext3 /dev/vgi/lvi

mkdir /record

echo “/dev/vgi/lvi /record ext3 defaults 0 0” >> /etc/fstab

mount -a

Q2. Resize the LV named 'lv0'=152M so that it falls within the range of 200MB to
300MB.
création de lv0:

fdisk /dev/sda then +156M (152+4PE) → vgcreate vg /dev/sda1 →

lvcreate -L 152M -n lv0 vg

corrigé:

combien de PE tel que max=300: lvextend -l ? vg

max-152=300-152=148

PE=4*?=148 (car pe=4)

?= nb PE=148/4=37 PE

NB: partition → vgcreate/vgextend réduit une PE

étendre vg: on doit ajouter une PE a la partition. → création

partition:

fdisk /dev/sda then +152M(148+4) → on obtient /dev/sda2 :152

vgextend vg /dev/sda2 → (la vg est étendu de 152-4=148)

lvextend -L +148M -n lv0 vg ou lvextend -l 37 -n lv0 vg

➔ Lab évaluation partie 2

➔

Automatisation des Tâches:

théorique:

On peut exécuter automatiquement les tâches avec la commande crontab.

 cat /etc/crontab→ pour voir les détails de la commande.

crontab -e → pour exécuter une tâche de l'utilisateur actuellement

connecté.

crontab -e -u username→ pour exécuter une tâche spécifique à un

utilistaeur.

@hourly→ pour exécuter une tâche chaque heure.

@daily→ pour exécuter une tâche chaque jour.

@weekly→ pour exécuter une tâche chaque semaine.

@monthly→ pour exécuter une tâche chaque mois.

@annually→ pour exécuter une tâche chaque année.

@reboot→ pour exécuter une tâche chaque redémarrage.

RQ: x,y: x and y | x-y:from x to y | x-y/z:from x to y with step z | *: every unity | */z:
every 2 unity.

pratique:

Q0.supprimer le contenu de /tmp chaque mercredi a 15h15 a 12h 30 pour user 1.

crontab -e

30,15 12,15 * * * 3 rm -rf /tmp

Q1. executer le script backup.sh chaque redémarrage de systeme

@reboot bash backup.sh

Q2. écrire le message “hello” dans hello.txt chaque 3 minutes

crontab -e

*/3 * * * * echo “hello” >> hello.txt

Q3.En tant qu’utilisateur natasha, planifiez une tâche qui affiche toutes les 5 minutes
le texte suivant dans les messages logs «Examen en cours ».

crontab -e -u natasha

*/5 * * * * logger “Examen en cours”

Q4. Configurez une tâche pour l’utilisateur natasha devant s’exécuter chaque 2
minutes du lundi au vendredi pour insérer la phrase « Examen EX200 en cours » dans
les logs.

crontab -e -u natasha

*/2 * * * 1-5 logger “Examen EX200 en cours”

Gestion des Services:

★ Service SSHD:

connexion à une autre machine via ssh:

ssh user_client@address_client (the user must have a password)

ou

vim /etc/hosts

address_client hostname

ssh user_client@hostname

par défaut le port de ssh est 22 on peut le changer:

ssh user@client_address then su - → se connecter au client via

ssh puis en tant que root.

vim /etc/ssh/sshd_config
 port 2222 → changer le port de 22 à 2222

semanage port -a -t ssh_port_t -p tcp 2222 → ajouter le nouveau

port a selinux 2222

firewall-cmd --permanent --add-port=2222/tcp

firewall-cmd --reload → ajouter le port dans le firewall

systemctl restart sshd → restart the service

exit then exit then

ssh user@client_address -p 2222 → se connecter avec le nv

port.

★ Service httpd:

dnf install httpd

systemctl enable --now httpd → installer et activer le

service.

RQ: /var/www/html est un chemin de répertoire couramment utilisé pour

stocker les fichiers qui sont servis par un serveur web.

echo "bnj" >> /var/www/html/index.html

firewall-cmd --permanent --add-service=http

firewall-cmd --permanent --add-service=https

firewall-cmd --reload

→ ajouter http et https dans le firewall rules.

Par exemple, si vous placez un fichier index.html dans /var/www/html et que

votre serveur web est en cours d'exécution, l'accès à l'adresse IP ou au
 domaine du serveur dans un navigateur web affichera probablement le
contenu de index.html.

curl http://@server/index.html

(si n’est pas affiché chown apache:apache /var/www/html/index.html)

Changer le port 80 en <nv_port>:

vim /etc/httpd/conf/httpd.conf

listen <nv_port> → changer port dans le fichier de config

man semanage port

semanage port -a -t http_port_t -p tcp <nv_port> → ajouter le

nouveau port a selinux.

dnf install curl

curl localhost:<nv_port>/index.html → vérifier le nouveau port.

Changer le répertoire par défaut /var/www/html vers /var1/web/html:

vim /etc/httpd/conf/httpd.conf

DocumentRoot "/var1/web/html"

<Directory "/var1/web">

AllowOverride None

Require all granted

</Directory>

<Directory "/var1/web/html">

*****

man semanage fcontext

semanage fcontext -a -t httpd_sys_content_t "/var1/web/html(/.*)?"

restorecon -R -v /var1/web/html/
 echo "hello2" >> /var1/web/html/test.html

curl localhost/test.html ou curl http://@iphost/test.html

★ Service NTP:
- partie serveur: allow client access to time

dnf install chrony

systemctl enable chronyd

systemctl start chronyd → installer et activer le service

vim /etc/chrony.conf

allow @ipclient

systemctl restart chronyd

firewall-cmd --add-service=ntp --permanent

firewall-cmd --reload

- partie client: access to time

dnf install chrony

systemctl enable chronyd

systemctl start chronyd → installer et activer le service

vim /etc/chrony.conf

server @ipserver iburst

systemctl restart chronyd

chronyc sources -c → pour vérifier.

pour activer ntp:

timedatectl set-ntp true

timedatectl

set a time zone:

timedatectl list-timezones

timedatectl set-timezone <zone>

timedatectl

★ target: (les deux machines seront en multi-user dans l’exam)

systemctl isolate multi-user.target → pour changer le target en

multi-user.

systemctl isolate graphical.target → pour changer le target en

graphical.

loadkeys fr → pour changer le clavier en azerty

systemctl set-default graphical.target → pour changer le target en

graphical ,persiste même après redémarrage .

systemctl set-default multi-user.target → pour changer le target en

multi-user , persiste même après redémarrage .

systemctl get-default → pour voir le target par défaut.

★ tuned: pour changer de profil.

dnf install tuned → installer tuned.

tuned-adm recommend→ voir le profil recommandé.

tuned-adm active→ voir mon profil.

tuned-adm list→ voir tous les profils.

tuned-adm profile <profile> → changer le profil.

systemctl restart tuned→ restart the service.

tuned-adm active→ vérifier le profil.

Q0. Set the recommended profile as tuned profile

tuned-adm recommend → te donne le recommended-profile

tuned-adm profile recommended-profile

systemctl restart tuned

tuned-adm active

Gestion des Packages Logiciels:

nano /etc/yum.repos.d/BaseOs.repo

[BaseOs]

name=BaseOs

baseurl=…

enabled=1

gpgcheck=1 (s’il ya un url key) sinon gpgcheck=0

gpgkey=…(s’il vous donne un url key)

nano /etc/yum.repos.d/AppStream.repo

[AppStream]

name= AppStream

baseurl=…

enabled=1

gpgcheck=1 (s’il ya un url key) sinon gpgcheck=0

gpgkey=…(s’il vous donne un url key)

Gestion des Conteneurs:

1. pull a container image:

2. run a container as rootless (user):
3. map the container to a local directory:
dnf install podman container-tools → installer les packages
nécessaires.

useradd user1 then passwd user1 → création user.

NB:loginctl enable-linger user → pour permettre aux processus de

l'utilisateur de persister même après la déconnexion.

mkdir /chemain_local then chown user1:user1 /chamein_local → créer le

répertoire a mapper.

ssh user1@localhost → se connecter a user via ssh.

(podman login registry.redhat.io → se connecter au registry

podman search pdf-converter → rechercher une image pdf-converter

podman pull pdf-converter → rechercher une image pdf-converter.)

NB: dans l’examen tu faits: wget <url_image> puis podman build -t <nom
image> . « n’oublier pas . »

podman images → afficher les images.

podman run -d –-name <container_name> -p <user_port>:<container_port> -

v <chemain_local>:<chemain_container>:Z <id_image>→ run and map the
container.

podman ps → afficher les conteneurs.

4. run the container as a service(systemd):

 mkdir -p /home/user1/.config/systemd/user → Créer le répertoire
pour la configuration systemd utilisateur.

cd /home/user1/.config/systemd/user → Accéder au répertoire de

configuration systemd utilisateur.

podman generate systemd --name container_name --file --new →

Générer un fichier de service systemd pour le conteneur.

RQ: the service name will be container-<container_name>.service

Changer ce qui est en gras :

vim service_name.service

[service]

restart=on-failure ⇒ restart=always

RestartSec=2s

StartLimitBurst=300000

[install]

WantedBy=default.target multi-user.target

systemctl --user daemon-reload → Recharge la configuration du

gestionnaire systemd pour l'utilisateur

systemctl --user enable --now service_name → Active et démarre

le service systemd pour l'utilisateur.

reboot machine then (root) systemctl status service_name →

Vérifier le statut du service systemd après reboot.
 Réseaux:

hostnamectl hostname name.example.com → changer le hostname.

(on peut le changer graphiquement) nmtui >> set system hostname

name.example.com

nmtui → gérer le réseau graphiquement.

edit a connection >> edit >> manual >> show: edit add,gateway,dns.>>ok

NB: ne pas oublier d' activer et désactiver l’interface après modification.

active a connection>> deactivate >> activate

nmcli con sh → vérifier l’interface (verte).