RHCSA Cheat Sheet

🧠 Méthode

🧭 Mental model

Workflow RHCSA (anti-panique)

Tu es noté sur le résultat: observe → change minimal → rends persistant → prouve.

La recette universelle

1) État → 2) Hypothèse → 3) Fix minimal → 4) Test → 5) Persistance.

Beaucoup d'erreurs RHCSA = "ça marchait en runtime, puis reboot = RIP".

# Diagnostic express
systemctl status SERVICE
journalctl -xeu SERVICE

# Ports + process
ss -lntup

# Réseau
ip a
ip r

# SELinux (si c'est inexpliqué)
getenforce
ausearch -m AVC -ts recent

🆕 Changements RHEL 10 vs RHEL 9

NOUVEAU : Flatpak ajouté aux objectifs (gestion paquets conteneurisés).

RETIRÉ : Containers/Podman, Stratis et VDO ne sont plus aux objectifs EX200.

~85-90% du contenu RHEL 9 reste valide
DNF + RPM + Flatpak = trio logiciel
Le reste (LVM, SELinux, firewalld, systemd, scripting) → inchangé
Toujours 3h, performance-based, tout doit persister au reboot

🔧 Outils essentiels

⌨️ Essential Tools

Fichiers, grep, find, tar

Manipulations de base: navigation, recherche, archivage, redirections I/O.

Navigation & fichiers

# Copier, déplacer, supprimer
cp -r /src /dest
mv file newname
rm -rf /dir

# Liens
ln file hardlink
ln -s /path/to/target symlink

# Infos fichier
file document.pdf
stat file
wc -l file

grep & expressions régulières

# Chercher dans fichiers
grep "pattern" file
grep -i "insensible" file         # ignore casse
grep -r "pattern" /etc/           # récursif
grep -v "exclure" file            # inversion
grep -c "count" file              # nb occurrences
grep -E "regex|extended" file     # ERE

# Exemples utiles
grep -E "^root" /etc/passwd
grep -E "failed|error" /var/log/messages

find (très demandé à l'examen)

# Par nom
find / -name "*.conf" 2>/dev/null
find / -iname "*.LOG"             # insensible casse

# Par type
find /home -type f                # fichiers
find /home -type d                # dossiers

# Par propriétaire / groupe
find / -user alice
find / -group devs

# Par taille
find / -size +100M                # > 100 Mo
find / -size -1k                  # < 1 Ko

# Par date modif
find / -mtime -7                  # modifié < 7 jours

# Par permissions
find / -perm /4000                # SUID
find / -perm -222                 # world writable

# Actions
find /tmp -name "*.tmp" -delete
find / -user alice -exec cp {} /backup/ \;

tar & compression

# Créer archive
tar cf archive.tar /dir
tar czf archive.tar.gz /dir      # gzip
tar cjf archive.tar.bz2 /dir     # bzip2
tar cJf archive.tar.xz /dir      # xz

# Lister contenu
tar tf archive.tar.gz

# Extraire
tar xf archive.tar.gz
tar xf archive.tar.gz -C /dest/  # vers destination

# Astuce: préserver les perms
tar czpf backup.tar.gz /etc/

Redirections I/O & pipes

# stdout → fichier
ls > output.txt          # écrase
ls >> output.txt         # ajoute

# stderr → fichier
cmd 2> errors.txt
cmd 2>/dev/null          # ignorer erreurs

# stdout + stderr
cmd &> all.txt
cmd > out.txt 2>&1

# Pipes
cat /etc/passwd | grep bash | wc -l
journalctl | tail -50

# tee (écran + fichier)
cmd | tee output.txt

📖 Man & Docs

Man pages & documentation

Tu as accès à la doc Red Hat pendant l'examen. man est ton meilleur ami.

man & info

# man pages
man passwd                        # commande
man 5 passwd                      # format fichier
man -k "keyword"                  # chercher
apropos selinux                   # = man -k

# Sections man
# 1=commandes  5=fichiers config
# 8=admin sys

# info
info coreutils

# Doc installée
ls /usr/share/doc/

Vim (essentiel exam)

# Modes: Normal → i=Insert → Esc=Normal → :=Command

# Navigation
gg          # début fichier
G           # fin fichier
/pattern    # chercher (n=suivant, N=précédent)

# Édition
dd          # supprimer ligne
yy          # copier ligne
p           # coller
u           # undo
Ctrl+r      # redo

# Sauver / quitter
:w          # sauver
:q          # quitter
:wq         # sauver et quitter
:q!         # quitter sans sauver

# Remplacement
:%s/old/new/g    # remplacer tout

👥 Utilisateurs & groupes

👤 Users & Groups

useradd, usermod, groupadd

Créer, modifier, supprimer users. Gérer mots de passe et groupes.

Créer & modifier utilisateurs

# Créer un user
useradd alice
useradd -u 1050 -g devs -G wheel -s /bin/bash -d /home/alice alice

# Mot de passe
passwd alice
echo "P@ss123" | passwd --stdin alice

# Modifier
usermod -aG wheel alice           # ajouter au groupe (ATTENTION -a !)
usermod -L alice                  # verrouiller compte
usermod -U alice                  # déverrouiller
usermod -s /sbin/nologin alice    # no login shell

# Supprimer
userdel alice
userdel -r alice                  # + home + mail

Groupes

# Créer groupe
groupadd devs
groupadd -g 2000 ops

# Modifier
groupmod -n newname oldname

# Supprimer
groupdel devs

# Voir les groupes d'un user
id alice
groups alice

# Fichiers clés
cat /etc/passwd    # users
cat /etc/group     # groupes
cat /etc/shadow    # hash mdp (root only)

Politique de mots de passe (chage)

# Voir la politique
chage -l alice

# Configurer
chage -M 90 alice     # max 90 jours
chage -m 7 alice      # min 7 jours entre changements
chage -W 14 alice     # warning 14 jours avant
chage -I 5 alice      # inactive après 5 jours expiré
chage -E 2026-12-31 alice   # date expiration

# Forcer changement au prochain login
chage -d 0 alice

🔐 Sudo & Privileges

sudo, visudo, /etc/sudoers.d/

Délégation de privilèges. Toujours visudo, jamais vim directement.

Configuration sudo

# Éditer (validation syntaxe)
visudo

# Ou fichier drop-in (recommandé)
visudo -f /etc/sudoers.d/alice

# Syntaxe: user HOST=(RUNAS) CMD
alice ALL=(ALL) ALL               # tout
alice ALL=(ALL) NOPASSWD: ALL     # sans mdp
alice ALL=(ALL) /usr/bin/systemctl restart httpd

# Groupe
%devs ALL=(ALL) /usr/bin/dnf      # groupe devs

# Vérifier
sudo -l                           # lister ses droits
sudo -l -U alice                  # droits d'alice

🛡️ Permissions & ACL

🔒 Permissions

chmod, chown, umask, SUID/SGID/sticky

Permissions Unix classiques + bits spéciaux.

chmod & chown

# chmod symbolique
chmod u+x file        # user +execute
chmod g=rw file       # group = read+write
chmod o-rwx file      # others = rien
chmod a+r file        # all +read

# chmod numérique
chmod 755 file        # rwxr-xr-x
chmod 640 file        # rw-r-----
chmod -R 750 /dir     # récursif

# chown
chown alice file
chown alice:devs file
chown -R alice:devs /dir

# chgrp
chgrp devs file

umask

# Voir umask courant
umask              # ex: 0022

# Logique: perms par défaut
# fichiers: 666 - umask = 644 (rw-r--r--)
# dossiers: 777 - umask = 755 (rwxr-xr-x)

# Changer (session)
umask 027          # fichiers=640, dirs=750

# Persistant: ajouter dans
# ~/.bashrc ou /etc/profile.d/custom.sh

SUID, SGID, Sticky bit

# SUID (4): exécute avec les droits du propriétaire
chmod u+s /usr/bin/prog
chmod 4755 /usr/bin/prog
# ex: /usr/bin/passwd a SUID root

# SGID (2): sur dossier = nouveaux fichiers héritent du groupe
chmod g+s /shared
chmod 2770 /shared

# Sticky bit (1): seul le propriétaire peut supprimer
chmod o+t /shared
chmod 1777 /tmp

# Trouver SUID/SGID
find / -perm /4000 -type f 2>/dev/null   # SUID
find / -perm /2000 -type d 2>/dev/null   # SGID dirs

🗝️ ACL

ACL (mask, defaults)

Le mask est le plafond. Default ACL = héritage à la création.

Lecture/écriture + piège du mask

getfacl file
setfacl -m u:alice:rw file
setfacl -m g:devs:rx file
setfacl -m m::rwx file   # mask

# default ACL (héritage dans un dossier)
setfacl -m d:u:alice:rwX /shared
setfacl -m d:g:devs:rx /shared

Nettoyer / restaurer

# Supprimer une entrée
setfacl -x u:alice file

# Tout supprimer
setfacl -b file

# Backup / restore
getfacl -R /shared > acls.backup
setfacl --restore=acls.backup

🔥 Réseau & sécurité

🧱 firewalld

firewall-cmd / firewalld

Zones + runtime vs permanent. Piège classique: ouvrir la bonne règle… dans la mauvaise zone.

Logique mentale (zones + permanent)

runtime = immédiat, non persistant • permanent = écrit la config, nécessite --reload.

État + zones

systemctl enable --now firewalld
firewall-cmd --state

firewall-cmd --get-default-zone
firewall-cmd --get-active-zones
firewall-cmd --zone=public --list-all
firewall-cmd --get-zones

Ajouter services/ports (runtime + permanent)

# runtime
firewall-cmd --zone=public --add-service=http
firewall-cmd --zone=public --add-port=8080/tcp

# permanent
firewall-cmd --zone=public --permanent --add-service=http
firewall-cmd --zone=public --permanent --add-port=8080/tcp
firewall-cmd --reload

# Raccourci: runtime + permanent en 2 commandes
firewall-cmd --zone=public --add-service=https
firewall-cmd --runtime-to-permanent

Interfaces, sources, debug

firewall-cmd --get-active-zones

# Changer zone par défaut
firewall-cmd --set-default-zone=internal

# Assigner interface
firewall-cmd --zone=public --permanent --add-interface=ens192
firewall-cmd --reload

# Rich rules (pour des règles plus fines)
firewall-cmd --zone=public --permanent \
  --add-rich-rule='rule family=ipv4 source address=192.168.1.0/24 service name=ssh accept'
firewall-cmd --reload

# Debug
ss -lntup
curl -I http://SERVER:80
firewall-cmd --zone=public --list-all

🛰️ NetworkManager

nmcli (devices vs connections)

Le profil (connection) est persistant. ip montre l'état courant.

État

nmcli general status
nmcli device status
nmcli device show ens192

nmcli connection show
nmcli connection show "Wired connection 1"

# Hostname (souvent demandé)
hostnamectl set-hostname server.lab.local
hostnamectl

IPv4 statique (classique RHCSA)

CON="Wired connection 1"

nmcli connection modify "$CON" \
  ipv4.method manual \
  ipv4.addresses 192.168.50.10/24 \
  ipv4.gateway 192.168.50.1 \
  ipv4.dns "1.1.1.1 9.9.9.9" \
  ipv4.dns-search "lab.local" \
  connection.autoconnect yes

nmcli connection down "$CON"
nmcli connection up "$CON"

ip a
ip r

Routes + debug

CON="Wired connection 1"
nmcli connection modify "$CON" +ipv4.routes "10.10.0.0/16 192.168.50.254"
nmcli connection up "$CON"

# Vérification
ip route
getent hosts google.com
cat /etc/resolv.conf
journalctl -xeu NetworkManager

🧪 SELinux

🧬 SELinux

SELinux (domptage)

Pense "AVC → (fcontext | port | boolean) → restorecon/semanage → test".

Modèle mental

1) labels (contextes) • 2) policy • 3) décision (AVC si refus).

Contexte fichier mauvais → semanage fcontext + restorecon
Port non autorisé → semanage port
Boolean désactivé → setsebool -P

État + triage

getenforce
sestatus

# Mode temporaire
setenforce 0           # permissive (debug)
setenforce 1           # enforcing

# Mode permanent
vi /etc/selinux/config
# SELINUX=enforcing

# Triage AVC
ausearch -m AVC -ts recent
ls -lZ /path/to/file
ps -eZ | grep httpd

Fix contexte (semanage fcontext + restorecon)

# Ajouter contexte persistant
semanage fcontext -a -t httpd_sys_content_t "/srv/site(/.*)?"
restorecon -Rv /srv/site

# Vérifier
ls -lZ /srv/site

# Lister les contextes existants
semanage fcontext -l | grep httpd

Fix port + booleans

# httpd sur 8080
semanage port -a -t http_port_t -p tcp 8080
# si déjà pris: semanage port -m -t http_port_t -p tcp 8080

# Lister ports
semanage port -l | grep http

# Booleans
getsebool -a | grep httpd
setsebool -P httpd_can_network_connect on    # -P = permanent !

# semanage boolean -l | grep httpd  (descriptions)

💾 Stockage

🧩 LVM

PV → VG → LV → FS → mount → fstab

Le pipeline RHCSA le plus rentable. Teste toujours mount -a.

Voir disques + LVM

lsblk -f
blkid
df -hT

pvs
vgs
lvs

Créer + monter + persister

pvcreate /dev/sdb
vgcreate vgdata /dev/sdb
lvcreate -n lvapp -L 5G vgdata

mkfs.xfs /dev/vgdata/lvapp
mkdir -p /mnt/app
mount /dev/vgdata/lvapp /mnt/app

blkid /dev/vgdata/lvapp
# fstab: UUID=... /mnt/app xfs defaults 0 0
vi /etc/fstab
mount -a
findmnt /mnt/app

Étendre LV + FS

# Ajouter un PV au VG
pvcreate /dev/sdc
vgextend vgdata /dev/sdc

# Étendre LV + resize FS en une commande (-r)
lvextend -r -L +2G /dev/vgdata/lvapp
# ou taille exacte:
lvextend -r -L 10G /dev/vgdata/lvapp

df -hT /mnt/app

Swap via LVM

lvcreate -n lvswap -L 2G vgdata
mkswap /dev/vgdata/lvswap
swapon /dev/vgdata/lvswap

# fstab
# UUID=... swap swap defaults 0 0
vi /etc/fstab

swapon -s
free -h

📁 Filesystems

Filesystems & Mount

Partitions classiques, mkfs, fstab. UUID obligatoire dans fstab !

Partitionnement (fdisk / parted)

# MBR (< 2 To)
fdisk /dev/sdb
# n → p → +2G → w

# GPT (> 2 To ou moderne)
gdisk /dev/sdb
# ou
parted /dev/sdb
(parted) mklabel gpt
(parted) mkpart primary xfs 1MiB 5GiB
(parted) quit

# Actualiser la table
partprobe /dev/sdb

Créer FS + mount + fstab

# Créer filesystem
mkfs.xfs /dev/sdb1
mkfs.ext4 /dev/sdb2

# Mount temporaire
mkdir -p /mnt/data
mount /dev/sdb1 /mnt/data

# Récupérer UUID
blkid /dev/sdb1

# fstab (PERSISTANT !)
vi /etc/fstab
# UUID=xxxx-xxxx  /mnt/data  xfs  defaults  0 0

# TOUJOURS TESTER
mount -a
findmnt /mnt/data

⚠️ Si fstab est cassé → le système ne boot plus ! Toujours mount -a avant reboot.

Swap sur partition

mkswap /dev/sdb3
swapon /dev/sdb3

# fstab
# UUID=... swap swap defaults 0 0

swapon -s
free -h

⚙️ Services & Scheduling

🔄 Systemd

Services & Systemd

systemctl + journalctl. N'oublie pas enable pour la persistance !

Gestion services

# Start / stop / restart
systemctl start httpd
systemctl stop httpd
systemctl restart httpd
systemctl reload httpd        # recharge config sans couper

# Activer au boot
systemctl enable httpd
systemctl enable --now httpd  # enable + start

# Désactiver
systemctl disable httpd

# État
systemctl status httpd
systemctl is-active httpd
systemctl is-enabled httpd

# Lister
systemctl list-units --type=service
systemctl list-units --type=service --state=failed

# Masquer (empêche tout démarrage)
systemctl mask httpd
systemctl unmask httpd

Boot targets

# Voir target actuel
systemctl get-default

# Changer (persistant)
systemctl set-default multi-user.target
systemctl set-default graphical.target

# Changer en live
systemctl isolate multi-user.target
systemctl isolate rescue.target
systemctl isolate emergency.target

journalctl (logs)

# Logs d'un service
journalctl -u httpd
journalctl -xeu httpd          # explications + erreurs

# Filtres temporels
journalctl --since "1 hour ago"
journalctl --since "2025-01-01" --until "2025-01-02"

# Live
journalctl -f
journalctl -fu httpd

# Par priorité
journalctl -p err               # erreurs et au dessus

# Boot
journalctl -b                   # boot actuel
journalctl -b -1                # boot précédent

# Rendre persistant (défaut RHEL 10)
mkdir -p /var/log/journal
systemctl restart systemd-journald

⏰ Scheduling

cron, at & systemd timers

Planification de tâches. cron = récurrent, at = one-shot, timers = moderne.

cron (crontab)

# Éditer crontab user
crontab -e
crontab -l                  # lister
crontab -e -u alice         # pour un autre user

# Format: min hour dom month dow command
# ┌──── minute (0-59)
# │ ┌── hour (0-23)
# │ │ ┌ day of month (1-31)
# │ │ │ ┌ month (1-12)
# │ │ │ │ ┌ day of week (0-7, 0 et 7 = dimanche)
# │ │ │ │ │
  * * * * * command

# Exemples
30 2 * * *   /root/backup.sh      # 2h30 chaque jour
0 */4 * * *  /root/check.sh       # toutes les 4h
0 9 * * 1-5  /root/workday.sh     # 9h lun-ven
*/5 * * * *  /root/monitor.sh     # toutes les 5 min

# Fichiers systèmes
ls /etc/cron.d/
ls /etc/cron.daily/

at (one-shot)

# Installer si absent
dnf install at
systemctl enable --now atd

# Planifier
at 14:30
> /root/script.sh
> Ctrl+D

at now + 5 minutes
at midnight
at noon tomorrow

# Lister / supprimer
atq
atrm 3

Systemd timers

# Lister les timers
systemctl list-timers --all

# Créer un timer: 2 fichiers dans /etc/systemd/system/

# 1) Le service: /etc/systemd/system/backup.service
# [Unit]
# Description=Daily backup
# [Service]
# Type=oneshot
# ExecStart=/root/backup.sh

# 2) Le timer: /etc/systemd/system/backup.timer
# [Unit]
# Description=Run backup daily
# [Timer]
# OnCalendar=daily
# Persistent=true
# [Install]
# WantedBy=timers.target

systemctl daemon-reload
systemctl enable --now backup.timer
systemctl list-timers

🚀 Boot & Troubleshooting

🔧 Boot & Rescue

Boot, GRUB, rescue, reset root password

Savoir réparer un système qui ne boot pas = points quasi gratuits.

Reset mot de passe root (classique exam !)

# 1) Reboot, interrompre GRUB (touche e)
# 2) Trouver la ligne linux et ajouter à la fin:
rd.break

# 3) Ctrl+x pour booter
# 4) Une fois dans le shell initramfs:
mount -o remount,rw /sysroot
chroot /sysroot
passwd root
# Taper le nouveau mot de passe

# 5) SELinux: relabeler au prochain boot
touch /.autorelabel

# 6) Quitter
exit
exit
# Le système reboote et relabel (patience !)

GRUB2 & boot targets

# Modifier GRUB temporairement
# Au boot: touche 'e', modifier la ligne linux
# Ajouter: systemd.unit=rescue.target
# ou:      systemd.unit=emergency.target
# Ctrl+x

# Modifier GRUB permanent
vi /etc/default/grub
grub2-mkconfig -o /boot/grub2/grub.cfg

# UEFI
grub2-mkconfig -o /boot/efi/EFI/redhat/grub.cfg

Diagnostic boot

# Logs du boot
journalctl -b            # boot actuel
journalctl -b -1         # boot précédent
systemd-analyze          # temps de boot
systemd-analyze blame    # services les plus lents

# Services en échec
systemctl --failed

# Réparer fstab cassé (en rescue)
mount -o remount,rw /
vi /etc/fstab
mount -a

📦 Logiciels & dépôts

📥 🆕 DNF + Flatpak

DNF, RPM & Flatpak (RHEL 10)

Trio logiciel RHEL 10. Flatpak est nouveau aux objectifs EX200.

DNF (gestion paquets)

# Chercher / installer / supprimer
dnf search httpd
dnf install httpd -y
dnf remove httpd -y

# Infos
dnf info httpd
dnf list installed
dnf list available

# Mise à jour
dnf update -y
dnf check-update

# Groupes
dnf group list
dnf group install "Development Tools" -y

# Historique
dnf history
dnf history undo 5

# Quel paquet fournit un fichier ?
dnf provides /etc/httpd/conf/httpd.conf

Repos DNF

# Lister les repos
dnf repolist all

# Ajouter un repo
dnf config-manager --add-repo https://example.com/repo

# Ou manuellement
vi /etc/yum.repos.d/myrepo.repo
# [myrepo]
# name=My Custom Repo
# baseurl=http://repo.lab.local/rhel10/
# enabled=1
# gpgcheck=0

# Activer/désactiver
dnf config-manager --set-enabled myrepo
dnf config-manager --set-disabled myrepo

# Nettoyer cache
dnf clean all
dnf makecache

RPM (queries bas niveau)

# Infos sur un paquet installé
rpm -qi httpd             # info
rpm -ql httpd             # lister fichiers
rpm -qf /usr/sbin/httpd   # quel paquet possède ce fichier
rpm -qc httpd             # fichiers config
rpm -qd httpd             # fichiers doc

# Vérifier intégrité
rpm -V httpd

# Installer un RPM local
rpm -ivh package.rpm
dnf localinstall package.rpm  # mieux (résout dépendances)

🆕 Flatpak (nouveau RHEL 10 !)

# Installer flatpak si absent
dnf install flatpak -y

# Ajouter un remote (dépôt Flatpak)
flatpak remote-add --if-not-exists flathub \
  https://flathub.org/repo/flathub.flatpakrepo

# Lister les remotes
flatpak remotes

# Chercher une app
flatpak search gimp

# Installer
flatpak install flathub org.gimp.GIMP -y

# Lister installés
flatpak list

# Lancer
flatpak run org.gimp.GIMP

# Mettre à jour
flatpak update

# Supprimer
flatpak uninstall org.gimp.GIMP

# Info sur une app
flatpak info org.gimp.GIMP

RHEL 10: Flatpak permet d'installer des applis conteneurisées indépendantes de la distro. Sache ajouter un remote, installer/supprimer une app.

AppStream & modules

# Lister les modules
dnf module list

# Activer un stream spécifique
dnf module enable php:8.3
dnf module install php:8.3

# Reset
dnf module reset php

💻 Shell Scripting

📝 Shell Script

Bash scripting (examen !)

Écrire des scripts simples: conditions, boucles, arguments, exit codes.

Base: shebang, variables, arguments

#!/bin/bash
# Shebang obligatoire !

# Variables
NAME="RHCSA"
echo "Préparation $NAME"

# Arguments
echo "Script: $0"
echo "Arg1: $1  Arg2: $2"
echo "Nb args: $#"
echo "Tous: $@"

# Exit code du dernier cmd
echo $?

# Lire input
read -p "Ton nom: " USERNAME
echo "Hello $USERNAME"

Conditions (if/elif/else, test)

#!/bin/bash

# if/elif/else
if [ -f /etc/passwd ]; then
  echo "Fichier existe"
elif [ -d /etc ]; then
  echo "Dossier existe"
else
  echo "Rien trouvé"
fi

# Tests fichiers
# -f fichier existe   -d dossier existe
# -r lisible          -w writable
# -x executable       -s non vide

# Tests strings
# -z "$VAR"  vide     -n "$VAR"  non vide
# "$A" = "$B"         "$A" != "$B"

# Tests numériques
# $A -eq $B  égal     $A -ne $B  différent
# $A -gt $B  >        $A -lt $B  <
# $A -ge $B  >=       $A -le $B  <=

# Exemple pratique
if [ $# -lt 1 ]; then
  echo "Usage: $0 "
  exit 1
fi

Boucles (for, while)

#!/bin/bash

# for
for USER in alice bob charlie; do
  useradd "$USER" 2>/dev/null
  echo "Créé: $USER"
done

# for avec séquence
for i in {1..10}; do
  echo "Iteration $i"
done

# for sur fichiers
for FILE in /etc/*.conf; do
  echo "$FILE"
done

# while
COUNT=0
while [ $COUNT -lt 5 ]; do
  echo "Count: $COUNT"
  COUNT=$((COUNT + 1))
done

# Lire un fichier ligne par ligne
while IFS= read -r LINE; do
  echo "$LINE"
done < /etc/hosts

Exemple complet (style exam)

#!/bin/bash
# Créer des users à partir d'un fichier
# Usage: ./create_users.sh userlist.txt

if [ $# -ne 1 ]; then
  echo "Usage: $0 "
  exit 1
fi

if [ ! -f "$1" ]; then
  echo "Fichier $1 introuvable"
  exit 2
fi

while IFS= read -r USER; do
  if id "$USER" &>/dev/null; then
    echo "SKIP: $USER existe déjà"
  else
    useradd "$USER"
    echo "redhat123" | passwd --stdin "$USER"
    echo "OK: $USER créé"
  fi
done < "$1"

exit 0

N'oublie pas: chmod +x script.sh pour rendre exécutable !

🔑 Accès distant

🌐 SSH

SSH & Remote Access

Authentification par clé, config sshd. Sécurise tes accès.

Clés SSH (classique exam)

# Générer une paire de clés
ssh-keygen -t rsa -b 4096
# ou ed25519 (plus moderne)
ssh-keygen -t ed25519

# Copier la clé publique
ssh-copy-id alice@server2

# Connexion sans mdp
ssh alice@server2

# Copie de fichiers
scp file.txt alice@server2:/tmp/
scp -r /dir alice@server2:/tmp/

Config sshd

# Fichier config
vi /etc/ssh/sshd_config

# Options fréquentes
PermitRootLogin no          # bloquer root SSH
PasswordAuthentication no   # clés only
Port 2222                   # changer port
AllowUsers alice bob        # whitelist

# Appliquer
systemctl restart sshd

# ⚠️ Si port changé → SELinux + firewall
semanage port -a -t ssh_port_t -p tcp 2222
firewall-cmd --permanent --add-port=2222/tcp
firewall-cmd --reload

🕐 Time & Chrony

Chrony & NTP

Synchronisation temps. chronyd remplace ntpd depuis RHEL 8.

Configuration

# Service
systemctl enable --now chronyd

# Config
vi /etc/chrony.conf
# server ntp.lab.local iburst
# ou
# pool pool.ntp.org iburst

systemctl restart chronyd

# Vérifier
chronyc sources -v
chronyc tracking

# Timezone
timedatectl
timedatectl list-timezones | grep Paris
timedatectl set-timezone Europe/Paris

# Date/heure manuelles (si pas NTP)
timedatectl set-ntp false
timedatectl set-time "2025-06-15 14:30:00"

🎛️ Tuning & NFS

⚡ Tuned

Tuned Profiles

Profils de performance système. Simple mais souvent oublié.

Commandes

# Service
systemctl enable --now tuned

# Profil actif
tuned-adm active

# Lister les profils
tuned-adm list

# Profils courants:
# throughput-performance  → serveur
# virtual-guest           → VM
# balanced                → par défaut
# desktop                 → poste de travail
# latency-performance     → faible latence

# Changer de profil
tuned-adm profile throughput-performance

# Recommandation auto
tuned-adm recommend

# Vérifier
tuned-adm active
tuned-adm verify

🗄️ NFS & Autofs

NFS & Autofs

Monter des partages réseau. Autofs = montage à la demande.

Mount NFS manuel + fstab

# Installer client NFS
dnf install nfs-utils -y

# Voir les exports du serveur
showmount -e nfs-server.lab.local

# Mount temporaire
mkdir -p /mnt/nfsdata
mount -t nfs nfs-server:/share /mnt/nfsdata

# Mount persistant (fstab)
vi /etc/fstab
# nfs-server:/share  /mnt/nfsdata  nfs  defaults  0 0
mount -a

Autofs (montage automatique)

# Installer
dnf install autofs -y
systemctl enable --now autofs

# Config master: /etc/auto.master.d/
vi /etc/auto.master.d/nfs.autofs
# /mnt/auto  /etc/auto.nfs

# Config map: /etc/auto.nfs
vi /etc/auto.nfs
# data  -rw,sync  nfs-server:/share
# home  -rw,sync  nfs-server:/home

# Direct mount (point fixe)
vi /etc/auto.master.d/direct.autofs
# /-  /etc/auto.direct

vi /etc/auto.direct
# /mnt/public  -rw,sync  nfs-server:/public

systemctl restart autofs

# Test: accéder au dossier (monte automatiquement)
ls /mnt/auto/data
# le dossier se monte quand tu y accèdes !

# Wildcard (home dirs)
# *  -rw,sync  nfs-server:/home/&

📊 Processus & ressources

📈 Processes

Process & Resource Management

ps, top, kill, nice. Gérer les processus et signaux.

Voir les processus

# Lister
ps aux                    # tous les processus
ps -ef                    # format complet
ps -eZ                    # avec contextes SELinux

# Filtrer
ps aux | grep httpd
pgrep -u alice            # PIDs par user
pgrep -la httpd           # PIDs + cmdline

# Arbre
pstree -p

# Temps réel
top
# dans top: M=tri RAM, P=tri CPU, k=kill, q=quit

Signaux & kill

# Envoyer un signal
kill PID                  # SIGTERM (15) - arrêt propre
kill -9 PID               # SIGKILL - arrêt forcé
kill -HUP PID             # reload config

# Par nom
killall httpd
pkill -u alice            # tous les process d'alice

# Jobs (background/foreground)
command &                 # lancer en background
jobs                      # lister
fg %1                     # ramener en foreground
bg %1                     # reprendre en background
Ctrl+Z                    # suspendre

nice & renice (priorité)

# Nice: -20 (haute priorité) → 19 (basse priorité)
# Défaut: 0

# Lancer avec priorité basse
nice -n 15 /root/heavy-script.sh

# Modifier un process en cours
renice -n 10 -p PID
renice -n -5 -u alice     # tous les process d'alice

# Vérifier
ps -eo pid,ni,comm | head