resume du systeme Unix

Systems de type UNIX

génerale
connaitre la version du systeme	lsb_release -a cat /etc/issue cat /etc/debian_version uname -a
afficher les inforamtions systemes	neofetch

Le Système de Gestion de Fichier SGF
dossier	description
/home	dossier des utilisateurs
/bin /usr/bin	commandes systeme
/sbin /usr/sbin	commandes systeme "admin"
/etc	fichier de configuration
/var	dossier de log/spooler/mouchard etc...
/dev	point d'entré des périphériques
/dev/urandom	générateur aléatoire de texte
/proc	fichier systeme spéciaux
apt-cache search libSDL	chercher une librairie
fsck /dev/la_partition	pour restaurer un disque
ps aux	pour voir les processus zombie avec z
exiftool	affiche les info meta d'un fichier
editeur exadecinmale	GHex
filtrer les lignes	$(echo top) \| grep 'fire'
filtrer les lignes dans un dossier	grep -RFl "pattern recherchee" <dossier>
rechercher les depots	apt-cache search xxx

Paquets et dépôts
dpkg
	i	install
	r	remove (garde les fichier conf)
	l	liste l'enssemble des pacquets
	contents	contenue d'un pacquet
	info	info sur un pacquet
	purge	supprime les fichiers de conf
	L	liste les fichiers du pacquet déja installé
	—get-selections > liste	btenir la liste des paquets installés sur un système
	—set-selections < liste	ré-installer les paquets sur une autre machine à partir d’une liste (obtenue par –get-selections)(avec apt-get : apt-get dselect-upgrade pour installer la sélection.)
	-S Nom_Partiel_Du_Fichier	Rechercher un fichier contenu dans un paque
	-L Nom_Exacte_Du_Paquet	Connaître la liste des fichiers d’un paquet
	-p Nom_Du_Paquet	Informations complètes sur un paquet
	—configure paquet	Re-configurer un paquet pas encore installé :
	-reconfigure paquet	Un paquet déjà installé
	cat /var/log/dpkg.log	historique des actions effectuées par dpkg
	-S Nom_Fichier	retrouver le paquet origine d’un fichier installé
	-s nom-de-paquet (--status)	Rapporte l'état du paquet indiqué (le contenue du fichier status)
apt-get
	apt-get install Nom_Paquet	Installation d'un paquet
	apt-get remove Nom_Paquet	Suppression d'un paquet
	apt-get purge Nom_Paquet	Suppression avec les fichiers de configuration
	apt-get installl –reinstall Nom_Paquet	réinstallation d'un paquet
	apt-get autoremove Nom_Paquet	désinstaller les paquets indiqués avec leurs dépendances
	apt-get clean	supprime la totalité des paquets présents dans /var/cache/apt/archives
	apt-get installl --download-only Nom_Paquet	télécharge le packet dans /var/cache/apt/archives
	le fichier /etc/apt/preferences (si le fichier n'existe pas, le créer) pour y insérer les lignes suivantes: Package: nom_du_paquet Pin: version du paquet à conserver Pin-priority: 1001	Bloquer la mise à jour d'un paquet
	update	mettre à jour les catalogues de la base local des différents dépôt
upgrade	(ou dist-upgrade) pour mettre à jour les paquets installés
apt-cache
	cache apt-cache gencaches	Pour utiliser cette commande, il faut installer le paquet : apt-get install apt-cache et générer le
		permet de consulter des infos du cache d’apt
	search pop	permet de trouver un paquet / à un mot clé (ici pop),
	dumpavail	affiche les entêtes de tous les paquet
	pkgnames	affiche les noms de tous les paquets
	show paquet	pour afficher l’info d’un paquet
	showpkg paquet	pour avoir les dépendances, la version...
ar
	t pacquet.deb	affiche le contenue d'un pacquet
	x pacquet.deb	extrait le contenue

les dépots
/etc/apt/sources.list
lister les pacquets installés	dpkg –list
deb http://fr.archive.ubuntu.com/ubuntu/ gutsy main restricted
[deb=bianire deb-src=source]	nature du dépot
[http/ftp/disk]	adresse du dépot
[updates(correctif bug)/security/backport(maj officiel)]	distribution et type de débpot
[main(logiciel libre)/restricted(pilote propriétaire)/universe(libre pris en charge par la communauté)/multiverse(logiciel a utilisation restreinte)]

modules
lsmod	lister les modules actifs (également cat /proc/modules)
rmmod	décharger un module
insmod	charger un module
modinfo	information sur un module
modprobe	permet également de charger les modules dynamiques et prend en charge lesdépendances de modules.Par exemple pour monter les clés USB, il faut monter les modules suivants :Directement en ligne de commande :
	modprobe usbcore
	modprobe usb-storage
	Si un périphérique de stockage est connecté sur un port usb, le système sait alors l'identifieret créer un device (sous /dev) pour permettre son utilisation.
	modprobe module_carte io=0x280 irq=9 (on passe des options au module)
insmod	insérer un module dans le kernel exemple: insmod mondriver.o exemple un driver avec le major 10
	Le système à chargé le module et lui a affecté un numéro d'instance 62 (minor)
	mknod /dev/mondriver c 10 62
loop	mount -o loop=/dev/loop0 disk-image Point_Montage
lspci -nnv	fait le lien entre le matériel et le module affiche les informations

librairies
Afficher les bibliothèques partagées nécessaires	ldd (ldd /bin/ls)

Systeme et authentification

les logs
tail -f /var/log/auth.log	Pour voir "en direct" des logs (tail -f)
tail -n 20 /var/log/messages	Avoir les 20 dernières lignes d'un fichier log
tail -n 20 /var/log/messages \|less	Rechercher dans le texte facilement "à la vim" - "/recherche" avec less
grep -R "nom_du_paquet" /var/log/*	Rechercher un paquet en particulier
zgrep "nom_du-paquet" /var/log/*	Y compris dans les logs compressés sous forme de fichiers .gz
grep -r "dpkg" /var/log/* \| grep erreur	Il est également possible de "grepper" une commande grep
grep -r "dpkg" /var/log/* \| grep -v ejabberd	Et avec une commande d'exclusion (grep -v => À l'exclusion de)
grep -r -i -l 'dpkg' /var/log/	Trouver dans quels fichiers de logs se trouve la chaine "dpkg" (-r recursive, -i insensible à la "casse", -l n'affiche pas tous les résultats, seulement le nom des fichiers)
grep -r -i -l 'dpkg' /var/log/ > /tmp/ma_recherche_dpkg.log	Pour conserver le résultat des recherches dans un fichier (/tmp/ma_recherche_dpkg.log)
grep -r "dpkg" /var/log/* \| tail -n 20	Avoir les 20 dernières lignes d'une recherche avec grep
monitorer tous les logs via ssh	PROMPT_COMMAND='history -a >(logger -t "$USER[$PWD] $SSH_CONNECTION")'

les différents fichier de logs
Emplacement	Contenu
/var/log/alternatives.log	Les logs d'update-alternatives.
/var/log/apache2/*	Les logs du serveur http apache2.
/var/log/apt/*	Les logs d'apt. Tous les paquets installés avec apt-get install, par exemple.
/var/log/aptitude	Les logs d'aptitude. Contient toutes les actions demandées, même les abandonnées.
/var/log/auth.log	Les informations d'autorisation de système. Y sont consignées toutes les connexions (réussies ou pas) et la méthode d'authentification utilisée.
/var/log/bind.log	Les logs du serveur de nom bind9, s'il sont activés.
/var/log/boot.log	Les informations enregistrées lors du démarrage du système. Ce fichier n'est pas activé par défaut.
/var/log/btmp	Semblable à /var/log/wtmp. Affiche les connexions/déconnexions au système # lastb alors que # last lira le fichier /var/log/wtmp.
/var/log/cups/*	Les logs du système d'impression cups.
/var/log/cron	Les informations sur les tâches cron. Enregistrement à chaque fois que le démon cron (ou anacron) commence une tâche.
/var/log/daemon.log	Les informations enregistrées par les différents daemons (processus) de fond qui fonctionnent sur le système.
/var/log/debug	Les logs de debugging.
/var/log/dmesg	Les messages du noyau Linux depuis le démarrage.
/var/log/dpkg.log	Les informations sur les paquets installés ou retirés en utilisant la commande dpkg.
/var/log/fail2ban.log	Les Ban/Unban et infos sur le programme (Error, Info, etc.) si fail2ban est installé.
/var/log/faillog	Les échecs de connexion. # faillog -u root.
/var/log/kern.log	Les informations enregistrées par le noyau. Utile pour débogguer un noyau personnalisé, par exemple.
/var/log/lastlog	Les informations de connexion récente de tous les utilisateurs. Ce n'est pas un fichier ascii. Vous devez utiliser la commande lastlog pour afficher le contenu de ce fichier.
/var/log/mail.*	Les informations du serveur de messagerie. Par exemple, sendmail enregistre des informations sur tous les éléments envoyés dans ces fichiers.
/var/log/messages	Les messages du système, y compris les messages qui sont enregistrés au démarrage. Beaucoup de choses sont enregistrées dans /var/log/ messages y compris le courrier, cron, daemon, kern, auth, etc.
/var/log/syslog	Tous les messages, hormis les connexions des utilisateurs. Plus complet que /var/log/messages.
/var/log/user.log	Les informations sur tous les journaux de niveau utilisateur.
/var/log/wtmp	Toutes les connexions et déconnexions: last -f /var/log/wtmp.
/var/log/Xorg.x.log	Les messages du serveur X. N'existe pas sur un serveur.Le petit x est le N° d'instance du serveur X.

le matériel
affiche des informations sur les unités Virtual I/O Server	lsdev
affiche des informations très détaillées sur les périphériques du bus PCI d'un ordinateu	lspci
affiche des informations relatives aux bus USB du système et aux périphériques qui y sont connectés.	lsusb
afficher des informations sur l'architecture du processeur	lscpu
affiche des informations très détaillées sur les périphériques d'un ordinateur	lshw

le réseau
permet de capturer des pacquets	iftop
affiche la configuration réseau des interfcaces (déprécated) ip addr	ifconfig
affiche la configuration wifi	iwconfig
un analyseur de pacquets	tcpdump
un outils de sniff du réseau	wireshark
ping	permet de tester si un périphérique est présent sur une ip
arp	L'Address Resolution Protocol (ARP, protocole de résolution d'adresse) est un protocole utilisé pour associer l'adresse de protocole de couche réseau (typiquement une adresse IPv4) d'un hôte distant, à son adresse de protocole de couche de liaison (typiquement une adresse MAC).
traceroute	permet de résoudre un ping et de voir les différents sauts
tcpcheck	testez la connectivité à un serveur à l'intérieur de l'environnement clien
iptraf	permet de controler le trafic des interfaces en cli

les disques

crée un fichier tres grand

dd if=/dev/urandom of=file.xt bs=2048 count=10000000

pvdisplay
lvdisplay
vgdisplay

affihes les informations des (disques physiques, des volumes logiques, des groupes de volumes

pvcreate

permet de crée un volume (de dire que ce volume seras utilisable par lvm)

pvcreate /dev/sdb1

lvcreate

crée un volume logique

lvcreate -L XXG vg0 -n lv-usr

mkfs

crée un systeme de fichier

mkfs ext4 /dev/vg0/lv-usr

mount -o remount ,ro /usr

remonte un lecteur

mount -o remount ,ro /usr

lsof

voir ce qui est ouvert

lvreduce

réduit mais ecrase le formatage

resize2fs

redimentionne le File System d'une partition

resize2fs /dev/mapper/vg0-lv-xxx YY MB

affiche les informations des volumes

df -h

lvresize

redimentionne la taille d'un volume logique

lvresize -L -30G /dev/vg0/lv-home

fdisk

etc/fstab

file system	mount point	type	options	dump	pass
UUID=d773855f-be34-4c1b-a34f-acdfe48f1640	/mnt/Images	ext4	defaults	0	2

file system:le volume a monter (ici une partition identifié par son UUID)
mount point:un point de montage: (le dossier /mnt/Images)
type: de quel type de système de fichier il s'agit (ext4)
options: qui a les droits de lecture, écriture et exécution sur ce volume (ici defaults )
dump: Indicateur pour l'utilitaire de sauvegarde dump (0).
pass: Indicateur pour la vérification par la commande fsck(2)

sudo ./configure --help

options de montage du systeme de fichier
[ ] discard	réduit les blocs libéré du périphérique support
[ ] noatime	pas de MAJ des heures d'accèdes des inodes
[ ] nodiratime	pas de MAJ des heures d'accèdes des inodes de répertoires
[ ] relatime	MAJ relative des dates et heures d'accès des inodes
[ ] nodev	pas de gestion des périphériques blocs ou caractère
[ ] nosuid	pas de gestion des bits setuid ou setgid
[ ] noexec	interdiction de l'execution des programmes
[ ] ro	montage en lecture seule
[ ] sync	toutes les entrees/sorties sont synchrones
[ ] usrquota	gestion des quota des utilisateurs
[ ] grpquota	gestion du quota des groupes
[ ] user_xattr	gestion des attributs étendus pour les utilisateurs

l'interface graphique
il existe un bon nombre de "desktop environment" chacun avec ses particularités en voici quelques uns
Gnome	fournit deux choses : l'environnement de bureau GNOME, intuitif et séduisant pour les utilisateurs et la plate-forme de développement GNOME, un environnement cadre complet pour construire des applications qui s'intègrent dans le reste de l'environnement de bureau.
Plasma	de KDE est un puissant environnement de bureau libre pour les systèmes Unix et Linux. Il combine une facilité d'utilisation, les fonctionnalités les plus récentes et une conception graphique excellente avec la supériorité technologique des systèmes d'exploitation Unix et Linux.
XFCE	est un environnement de bureau léger pour divers systèmes *NIX. Conçu pour la productivité, il charge et exécute rapidement les applications tout en épargnant les ressources du système.
LXDE	est conçu pour bien fonctionner avec les machines les moins puissantes : les vieux ordinateurs avec des ressources limitées ou des netbook de nouvelle génération et autres petits ordinateurs.
Mate	est la continuation de GNOME 2. Il fournit un environnement de bureau attrayant et intuitif en utilisant des représentations traditionnelles d'environnement bureau pour Linux et d'autres systèmes d'exploitation de type Unix.
Plasma
Plasma

les dockers et environnement chrootè
Proc
	les fichiers
	buddyinfo	informations sur la mémoire et la fragmentation dans les différentes zones mémoire cgroups : liste des groupes de contrôle activés
	cmdline	ligne de commande du noyau
	consoles	consoles enregistrées sur le système
	cpuinfo	informations sur les CPUs de la machine
	crypto	chiffrements utilisables par le noyau
	devices	périphériques configurés sur le système dont le module noyau est chargé
	diskstats	statistiques sur les entrées/sorties
	dma	canaux DMA utilisés par le système
	execdomains	domaines d’exécution supportés par le noyau 1
	fb	périphériques "framebuffer" disponibles
	filesystems	systèmes de fichiers supportés par le noyau
	interrupts	nombre d’interruptions processeur gérées par le système (x86)
	iomem	mapping de la mémoire système pour les périphériques gérés par le noyau
	ioports	mapping des ports d’entrées/sorties des périphériques
	kallsyms	ensemble des symboles du noyau
	kcore	accès à la mémoire physique du système
	keys	tables des clés cryptographiques utilisées par le système
	kmsg	messages générés par le noyau
	loadavg	moyenne de charge du système depuis 1, 5 et 10 minutes
	locks	verrous posés par le noyau sur des fichiers
	meminfo	(nombreuses) informations sur la mémoire du système
	modules	liste des modules noyau chargés
	mounts	liste des montages de systèmes de fichiers en cours
	partitions	liste des partitions détectées par le système
	self	lien symbolique vers le répertoire "proc" de l’appelant
	stat	statistiques diverses sur le système depuis son lancement
	swaps	informations sur la ou les partition d’échange du système
	uptime	temps en seconde écoulé depuis le lancement / temps IDLE
	version	version du noyau chargé
	les repertoires
	bus	accès aux périphériques et aux informations sur ceux-ci (classiquement bus/pci; bus/input) driver : informations sur des drivers spécifiques utilisés par le système
	fs	informations sur les systèmes de fichiers utilisés par le système
	irq	informations/configuration des IRQs du système
	sys	informations/configurations des paramètres du noyau
	tty	informations sur les périphérique tty en cours d’utilisation
	quelques fichiers (dans Proc/xxx/)
	/proc/PID/cmdline	contient la ligne de lancement du processus
	/proc/PID/exe	pointe sur le fichier bianire contenue dans usr/bin/
	/proc/PID/environ	contient la liste des variabels d'environnement
	/proc/PID/cwd	boucle (cwd change le repertoire de travail)
	/proc/PID/stat	les informations relatives au processus (c.f. man proc)
	/proc/PID/fd	Il s'agit d'un sous-répertoire contenant une entrée pour chaque fichier que le processus a ouvert. Chaque entrée a le descripteur du fichier pour nom, et est représentée par un lien symbolique sur le vrai fichier. Ainsi, 0 correspond à l'entrée standard, 1 à la sortie standard, 2 à la sortie d'erreur, etc...

commande processus
SIGINT	2	Terminer le processus	Il s'agit d'une demande venant du clavier, le plus souvent à l'aide la combinaison de touches Ctrl+C
SIGKILL	9	Terminer le processus	Ce signal permet d'arrêter tout programme car il ne peut être géré différemment que le comportement par défaut. L'arrêt du programme est brutal.
SIGUSR1	10	Terminer le processus	Ce signal n'a pas de signification particulière. Il peut être utilisé de manière différente par chaque programme.
SIGSEGV	11	Terminer le processus	Ce signal est envoyé à un programme lorsque qu'il tente d'accéder à un endroit invalide en mémoire.
SIGUSR2	12	Terminer le processus	Identique à SIGUSR1.
SIGTERM	15	Terminer le processus	Si le programme n'a pas prévu de gérer ce signal, l'arrêt sera aussi brutal que pour SIGKILL. Mais comme le comportement par défaut peut être changé, le programme a la possibilité de réaliser des opérations avant de se terminer.
SIGCHLD	17	Ignorer ce signal	Envoyé à un processus dont un fils est arrêté ou terminé.
SIGCONT	18	Reprendre le processus	Permet de faire se continuer un processus qui avait été arrêté par exemple à l'aide de SIGSTOP (voir ci-après).
SIGSTOP	19	Arrêter le processus	Ce signal demande au processus de suspendre son exécution. Comme SIGKILL, ce signal ne peut être géré différemment.
exemples		kill -s SIGSTOP 256 kill -SIGSTOP 256

commande ps

-a

afficher les informations sur les processus des autres utilisateurs en plus de l'utilisateur lui-même (lorsque c'est possible - cf option hidepid du fs proc par exemple )

-c

ne pas afficher la ligne de commande complète mais seulement le nom de l'exécutable

-u

affiche les informations suivantes : user,pid,%cpu,%mem,vsz,rss,tty,stat,start,time,command

-w

affichage large (jusqu'à 132 caractères avec un seul "w", autant que nécessaire si plusieurs "w")

-x

afficher aussi les informations sur les processus qui ne sont pas attachés à un terminal

exemple

user	pid	%cpu	%mem	vsz	rss	tty	stat	start	time	command
propriétaire du processus	PID du processus	pourcentage de CPU utilisé par le processus	pourcentage de mémoire utilisé par le processus	taille de la mémoire virtuelle du processus	taille de la mémoire résidente du processus	terminal auquel est attaché le processus	état du processus (idle, running, ...)	heure du démarrage du processus	temps cumulé d'utilisation du CPU par le processus	ligne de commande du processus

programmes pour crée un environnement chrootè
copier dans un repertoire la commande et ses dépendances	#!/bin/bash ######################################### # Fichier rapatrie_dependance : copie les librairie d'une commande # Auteur : schnellbach tanguy # exemples : <sudo ./rpatriedep.sh <commande> <destination> > # sudo ./rpatriedep.sh /bin/touch /mnt/chroot ######################################### [ $# -lt 2 ] && echo "lisez la règle bordel" && exit 1 c_source=`echo $2 \|sed 's/^$.*$\/$/\1/p'` for i in $(ldd $1 \| awk 'NF == 4 {print $3}; NF == 2 {print $1}') do chemin="$(dirname $i)" mkdir -p $c_source$chemin cp $i "$2$chemin" 2> /dev/null done mkdir $c_source/bin 2> /dev/null cp $1 $c_source/bin/"$(basename $1)" 2> /dev/null
pour crée une image d'un repertoire	genisoimage -o image.iso /home/fred/rep/
pour changer le repertoire chroot	chroot /mnt/chroot/ /bin/bash

name spaces
unshare	permet de lancer un nouveau processus après création d'un ou plusieurs nouveaux namespaces des types demandés. echo "kernel.unprivileged_userns_clone = 1" >> /etc/sysctl.conf pour le rendre persistant echo "kernel.unprivileged_userns_clone=1" >> /etc/sysctl.conf (autoriser un user normal à crée un namespace)
	--mount	Annuler le partage de l'espace de noms de montage. Si le fichier est spécifié, un l'espace de noms persistant est créé par un montage de liaison. Notez que le fichier doit être situé sur un système de fichiers avec la propagation indicateur défini sur privé
	--user	Annuler le partage de l'espace de noms utilisateur. Si le fichier est spécifié, un espace de noms persistant est créé par un montage de liaison
	chroot	permet de lancer la commande chroot avec la commande unshare
	--pid	Dissociez l'espace de noms PID. Si le fichier est spécifié,l'espace de noms persistant est créé par un montage de liaison. Voir aussi les Options --fork et --mount-proc.
	--map-root-user (-r)	Exécutez le programme uniquement après l'utilisateur effectif actuel et les ID de groupe ont été mappés à l'UID et au GID du superutilisateur dans le espace de noms utilisateur nouvellement créé
	--fork	Fork le programme spécifié comme un processus enfant de non-partage plutôt que de l'exécuter directement. Ceci est utile lors de la création un nouvel espace de noms PID
	--uts	le processus a une copie distincte du nom d'hôte et du nom de domaine NIS (maintenant presque inutilisé), de sorte qu'il peut le définir sur autre chose sans affecter le reste du système.
	nsenter	permet de rentrer dans un namespace
	--net	Dissociez l'espace de noms du réseau.
		ip link add vhost type veth peer name vguest	On crée ici un lien réseau de type "virtuel" (veth) entre une interface nommée "vhost" (côté "hôte") reliée à une interface nommée "vguest" qui sera accessible dans le namespace du bash lancé via unshare. (Remarque : on peut tout à fait choisir un nom différent pour les interfaces) ip link list
		$ ip link set vguest netns <PID du bash >
		serveur	ip link set vhost up
		dockers	ip link set vguest up
		serveur	ip addr add 192.168.100.1/24 dev vhost
		dockers	ip addr add 192.168.100.2/24 dev vguest
		ip route add default via 192.168.100.1 dev vguest	on lie les deux adresses
	unshare --cgroup --mount-proc --user -r --mount --pid --uts --net --fork bash -c "mount --rbind /sys chroot/sys ; mount --rbind /dev chroot/dev ; /sbin/chroot chroot/ bash"
pour donner un nom	bash -c "exec -a '[definir un nom]' ps -aux &"

Bios

Bootloader

Noyau

Initrd (boot)

Les niveaux d'exécution (run levels)

les services qui doivent s'arréter lorsque l'on éteint physiquement la machine

ou (single) : uniquement pour root, permet de faire la maintenance (service minimum) equi mode sans echec

niveau par default sur ubuntu/debian, permet de définir un niveau de fonctionnement pour l'administrateur

niveau fonctionnel, tout les services sont démarré mais pas encore fonctionels

laissé à la disposition de l’administrateur qui pourra établir à partir de ce niveau un mode de fonctionnement particulier avec seulement certains services démarrés.

tous les services sont démarrés, et l’interface graphique est disponible

Temporaire par définition, le niveau 6 est celui d’un système en train de redémarrer. La configuration du niveau 6 consistera donc à déterminer quels services doivent être arrêtés au redémarrage du système. Après le redémarrage, un nouveau niveau d’exécution s’appliquera (en général le niveau par défaut) et les services associés à ce niveau seront démarrés.

les dossiers rc[N].d

rc0.d
rc1.d
rc2.d
rc3.d
rc4.d
rc5.d
rc6.d

contient les liens symboliques des fichiers contenus dans /etc/init.d
c est ici que le systeme iras chercher les programmes a executer

K01xxxx

le K en début de nom indique de tuer (KILL) le demon

S01xxxx

le S en début de nom indique de démarrer (START) le demon

inittab

Structure /etc/inittab -> identifiant:niveau:mode_action:commande

identifiant

Chaîne alphanumérique d’un ou deux caractères. Identifie la ligne. Pas d’autres contraintes que d’éviter d’avoir deux lignes avec le même identifiant.

niveau

Le ou les niveaux d’exécution (en chiffres) pour lesquels la ligne est pertinente.

mode_action

À choisir parmi quelques motsclés, définit la façon dont la commande du quatrième champ sera exécutée.

initdefault	un peu particulier, initdefault ne régit pas la façon dont la commande du quatrième champ sera exécutée. D’ailleurs, quand le mode d’action est initdefault, le quatrième champ est vide. initdefault ne sert en fait qu’à définir le niveau d’exécution du système par défaut.
sysinit	ert à exécuter des scripts à l’initialisation du système, indépendamment du niveau d’exécution. Pour cette raison, sysinit n’admet pas de valeur pour le deuxième champ.
wait	exécute la commande du quatrième champ (souvent un script), et attend la fin de cette exécution pour passer aux lignes suivantes du fichier inittab.
respawn	exécute la commande du quatrième champ, et laisse tourner le processus à l’arrièreplan. Passe ensuite aux lignes suivantes du fichier inittab. Si le processus appelé par la commande s’arrête, init le relancera systématiquement.

commande

La commande à exécuter au(x) niveau(x) défini(s) dans le deuxième champ selon le mode d’action du troisième champ

Exemple

gestion des services /etc/init.d/ree

#!/bin/bash
#pour relancer sudo systemctl daemon-reload
#pour tester sudo /etc/init.d/ree start
. /lib/lsb/init-functions
daemon_NAME="ree"
DAEMON="/etc/ree/connexion.sh"
#code de la fonction d_start
d_start() {
log_daemon_msg "Starting system $daemon_NAME Daemon"
printf '[ \033[1;32;32m ok \033[0m ]' && echo "Lancement de ree"
}
d_stop() {
log_daemon_msg "Starting system $daemon_NAME Daemon"
}
case $1 in
#action a realiser au demarage du service
start)
d_start
;;
#action a realiser a l'arret du service
stop)
# commande d’arrêt du service

;;
#action a realiser lorsque l on force l arret du service
force-stop)
d_stop
killall -q $daemon_NAME || true
sleep 2
killall -q -9 $daemon_NAME || true
;;
#action a realiser lorsque l'on demande le status du service
status)
status_of_proc "$daemon_NAME" "$DAEMON" "system-wide $daemon_NAME" && exit 0 || exit $?
;;
#action a realiser dans les autres cas
*)
echo "Usage: /etc/init.d/$daemon_NAME {start|stop|force-stop|restart|reload|force-reload|status}"
exit 1
;;
esac

les dossiers rcn

printf '[ \033[1;32;32m ok \033[0m ]' && echo \"postinst\""

update-rc.d nom_daemon defaults

Systemd
systemctl enable nom_du_service.service	demarre un service au demarrage	# systemctl enable sshd.service ln -s '/usr/lib/systemd/system/sshd.service' '/etc/systemd/system/multi-user.target.wants/sshd.service'
systemctl disable nom_du_service.service	arrete u service au demarrage	# systemctl disable sshd.service rm '/etc/systemd/system/multi-user.target.wants/sshd.service'
systemctl is-active nom_du_service.service	connaitre le status d'un service
systemctl start nom_du_service.service	démarrer un service
systemctl stop nom_du_service.service	stop un service
systemctl restart nom_du_service.service	redemarre un service	# systemctl restart sshd.service
systemctl reload nom_du_service.service	recharge la configuration d'un service	systemctl reload smb.service
systemctl get-default		multi-user.target
systemctl isolate nom.target	basculer de run level	systemctl isolate graphical.target
systemctl set-default nom.target	changer le runlevel par default	systemctl set-default graphical.target
exemple		touch /etc/systemd/system/mon-service.service -------------mon-service.service Description=Je dis ici à quoi sert le service ConditionPathExists=/usr/sbin/commande [Service] Type=forking ExecStart=/bin/sh -c 'commande' TimeoutSec=0 StandardOutput=tty RemainAfterExit=yes SysVStartPriority=99 [Install] WantedBy=multi-user.target ------------------------------------------------ #Ensuite, rendre exécutable ce service : chmod a+x /etc/systemd/system/mon-service.service #On recharge systemd systemctl --system daemon-reload #On tente de démarrer le service et on constate que ça marche bien : systemctl start mon-service.service #On peut ajouter ce service au démarrage si on le souhaite : systemctl enable mon-service.service

Systemd.conf
CtrlAltDelBurstAction=	Définit quelle action sera effectuée si l'utilisateur appuie sur Ctrl-Alt-Suppr plus de 7 fois en 2 secondes. Peut être réglé sur " reboot-force ", " poweroff-force ", " reboot-immediate ", " poweroff-immediate " ou désactivé avec " none ". Par défaut, " reboot-force ".
CPUAffinity=	Configure l'affinité CPU pour le gestionnaire de services ainsi que l'affinité CPU par défaut pour tous les processus dérivés. Prend une liste d'indices ou de plages CPU séparés par des espaces ou des virgules. Les plages de CPU sont spécifiées par les indices de CPU inférieur et supérieur séparés par un tiret. Cette option peut être spécifiée plusieurs fois, auquel cas les masques d'affinité CPU spécifiés sont fusionnés. Si la chaîne vide est affectée, le masque est réinitialisé, toutes les affectations antérieures n'auront aucun effet. Les services individuels peuvent remplacer l'affinité CPU pour leurs processus avec le CPUAffinity= dans les fichiers d'unité, voir systemd.exec (5) .
NUMAPolicy=	Configure la stratégie de mémoire NUMA pour le gestionnaire de services et la stratégie de mémoire NUMA par défaut pour tous les processus dérivés. Les services individuels peuvent remplacer la stratégie par défaut avec le NUMAPolicy= dans les fichiers d'unité, voir systemd.exec (5) .
NUMAMask=	Configure le masque de nœud NUMA qui sera associé à la stratégie NUMA sélectionnée. Notez que local stratégies NUMA local et default ne nécessitent pas de masque de nœud NUMA explicite et que la valeur de l'option peut être vide. De manière similaire à NUMAPolicy= , la valeur peut être remplacée par des services individuels dans les fichiers d'unité, voir systemd.exec (5) .
RuntimeWatchdogSec= , RebootWatchdogSec= , KExecWatchdogSec=	Configurez le chien de garde matériel à l'exécution et au redémarrage. Prend une valeur de temporisation en secondes (ou dans d'autres unités de temps si elles sont suffixées avec " ms ", " min ", " h ", " d ", " w "). Si RuntimeWatchdogSec= est défini sur une valeur non nulle, le matériel du chien de garde ( /dev/watchdog ou le chemin spécifié avec WatchdogDevice= ou l'option du noyau systemd.watchdog-device= ) sera programmé pour redémarrer automatiquement le système s'il ne l'est pas. contacté dans le délai spécifié. Le gestionnaire du système veillera à le contacter au moins une fois dans la moitié de l'intervalle de temporisation spécifié. Cette fonctionnalité nécessite la présence d'un dispositif de surveillance matériel, comme c'est généralement le cas dans les systèmes embarqués et serveurs. Tous les chiens de garde matériels ne permettent pas de configurer toutes les valeurs de délai de redémarrage possibles, auquel cas le délai disponible le plus proche est sélectionné. RebootWatchdogSec= peut être utilisé pour configurer le chien de garde matériel lorsque le système est invité à redémarrer. Il fonctionne comme un filet de sécurité pour garantir que le redémarrage a lieu même si une nouvelle tentative de redémarrage expire. Notez que le délai d'expiration RebootWatchdogSec= s'applique uniquement à la deuxième phase du redémarrage, c'est-à-dire après que tous les services réguliers sont déjà terminés et après que le processus du système et du gestionnaire de services (PID 1) a été remplacé par le binaire systemd-shutdown , voir démarrage du système ( 7) pour plus de détails. Pendant la première phase de l'opération d'arrêt, le système et le gestionnaire de services continuent de fonctionner et, par conséquent, RuntimeWatchdogSec= est toujours RuntimeWatchdogSec= . Afin de définir un délai d'expiration sur cette première phase d'arrêt du système, configurez JobTimeoutSec= et JobTimeoutAction= dans la section " [Unit] " de l'unité shutdown.target . Par défaut, RuntimeWatchdogSec= défaut à 0 (désactivé) et RebootWatchdogSec= à 10 RebootWatchdogSec= . KExecWatchdogSec= peut être utilisé pour activer en plus le chien de garde lorsque kexec est exécuté plutôt que lors du redémarrage. Notez que si le noyau ne réinitialise pas le chien de garde sur kexec (en fonction du matériel et / ou du pilote spécifique), dans ce cas, le chien de garde peut ne pas être désactivé après la réussite de kexec et donc le système peut être redémarré, sauf si RuntimeWatchdogSec= est également activé à la fois. Pour cette raison, il est recommandé d'activer KExecWatchdogSec= uniquement si RuntimeWatchdogSec= est également activé. Ces paramètres n'ont aucun effet si aucun chien de garde matériel n'est disponible.
WatchdogDevice=	Configurez le périphérique de surveillance du matériel que les temporisateurs de surveillance d'exécution et d'arrêt ouvriront et utiliseront. Par défaut, /dev/watchdog . Ce paramètre n'a aucun effet si aucun chien de garde matériel n'est disponible.
CapabilityBoundingSet=	Contrôle les capacités à inclure dans l'ensemble de limites de capacités pour PID 1 et ses enfants. Voir les capacités (7) pour plus de détails. Prend une liste de noms de capacités séparés par des espaces tels que lus par cap_from_name (3) . Les capacités répertoriées seront incluses dans l'ensemble de délimitation, toutes les autres sont supprimées. Si la liste des capacités est précédée de ~, toutes les capacités sauf celles répertoriées seront incluses, l'effet de l'affectation étant inversé. Notez que cette option affecte également les capacités respectives dans les ensembles de capacités efficaces, autorisés et héritables. L'ensemble de limites de capacité peut également être configuré individuellement pour les unités à l'aide de la directive CapabilityBoundingSet= pour les unités, mais notez que les capacités supprimées pour le PID 1 ne peuvent pas être récupérées dans les unités individuelles, elles sont perdues pour de bon.
NoNewPrivileges=	Prend un argument booléen. Si vrai, garantit que PID 1 et tous ses enfants ne pourront jamais obtenir de nouveaux privilèges via execve (2) (par exemple via les bits setuid ou setgid, ou les capacités du système de fichiers). La valeur par défaut est false. Les distributions à usage général reposent généralement sur des exécutables avec des bits setuid ou setgid et ne fonctionneront donc pas correctement avec cette option activée. Les unités individuelles ne peuvent pas désactiver cette option. Voir également Pas de nouveau drapeau de privilèges .
SystemCallArchitectures=	Prend une liste d'identifiants d'architecture séparés par des espaces. Sélectionne à partir de quelle architecture les appels système peuvent être appelés sur ce système. Cela peut être utilisé comme un moyen efficace de désactiver l'invocation de binaires non natifs à l'échelle du système, par exemple pour interdire l'exécution de binaires x86 32 bits sur des systèmes x86-64 64 bits. Cette option fonctionne à l'échelle du système et agit de manière similaire au paramètre SystemCallArchitectures= des fichiers d'unité, voir systemd.exec (5) pour plus de détails. Ce paramètre correspond par défaut à la liste vide, auquel cas aucun filtrage des appels système basé sur l'architecture n'est appliqué. Les identificateurs d'architecture connus sont " x86 ", " x86-64 ", " x32 ", " arm " et l'identifiant spécial " native ". Ce dernier correspond implicitement à l'architecture native du système (ou plus précisément, l'architecture pour laquelle le gestionnaire de système a été compilé). Définissez ce paramètre sur " native " pour interdire l'exécution de tous les fichiers binaires non natifs. Lorsqu'un binaire exécute un appel système d'une architecture qui n'est pas répertoriée dans ce paramètre, il se termine immédiatement avec le signal SIGSYS.
TimerSlackNSec=	Définit le relâchement du minuteur en nanosecondes pour le PID 1, qui est hérité par tous les processus exécutés, sauf s'il est remplacé individuellement, par exemple avec le TimerSlackNSec= dans les unités de service (pour plus de détails, voir systemd.exec (5) ). Le jeu du minuteur contrôle la précision des réveils déclenchés par les minuteurs du système. Voir prctl (2) pour plus d'informations. Notez que contrairement à la plupart des autres définitions d'intervalle de temps, ce paramètre prend une valeur entière en nano-secondes si aucune unité n'est spécifiée. Les unités de temps habituelles sont également comprises.
StatusUnitFormat=	Prend le name ou la description comme valeur. Si name , le gestionnaire système utilisera les noms d'unité dans les messages d'état, au lieu des descriptions plus longues et plus informatives définies avec Description= , voir systemd.unit (5) .
DefaultTimerAccuracySec=	Définit la précision par défaut des unités de minuterie. Cela contrôle la valeur par défaut globale pour le paramètre AccuracySec= des unités de temporisation, voir systemd.timer (5) pour plus de détails. AccuracySec= défini dans des unités individuelles remplace la valeur par défaut globale pour l'unité spécifique. Par défaut à 1 min. Notez que la précision des unités de temporisation est également affectée par le jeu de temporisation configuré pour le PID 1, voir TimerSlackNSec= ci-dessus.
DefaultTimeoutStartSec= , DefaultTimeoutStopSec= , DefaultTimeoutAbortSec= , DefaultRestartSec=	Configure les délais d'expiration par défaut pour le démarrage, l'arrêt et l'interruption des unités, ainsi que le délai de mise en veille par défaut entre les redémarrages automatiques des unités, comme configuré par unité dans TimeoutStartSec= , TimeoutStopSec= , TimeoutAbortSec= et RestartSec= (pour les services, voir systemd .service (5) pour plus de détails sur les paramètres par unité). Désactivé par défaut, lorsque le service avec Type=oneshot est utilisé. Pour les unités hors service, DefaultTimeoutStartSec= définit la valeur TimeoutSec= par défaut. DefaultTimeoutStartSec= et DefaultTimeoutStopSec= par défaut à 90 s. DefaultTimeoutAbortSec= n'est pas défini par défaut afin que toutes les unités reviennent à TimeoutStopSec= . DefaultRestartSec= défaut à DefaultRestartSec= .
DefaultStartLimitIntervalSec= , DefaultStartLimitBurst=	Configurez la limitation de taux de démarrage d'unité par défaut, telle que configurée par service par StartLimitIntervalSec= et StartLimitBurst= . Voir systemd.service (5) pour plus de détails sur les paramètres par service. DefaultStartLimitIntervalSec= défaut à 10 s. DefaultStartLimitBurst= 5 par défaut.
DefaultEnvironment=	Définit les variables d'environnement du gestionnaire transmises à tous les processus exécutés. Prend une liste des affectations de variables séparées par des espaces. Voir environ (7) pour plus de détails sur les variables d'environnement. Exemple: DefaultEnvironment = "VAR1 = mot1 mot2" VAR2 = mot3 "VAR3 = mot 5 6" Définit trois variables " VAR1 ", " VAR2 ", " VAR3 ".
DefaultCPUAccounting= , DefaultBlockIOAccounting= , DefaultMemoryAccounting= , DefaultTasksAccounting= , DefaultIOAccounting= , DefaultIPAccounting=	Configurez les paramètres de comptabilité des ressources par défaut, tels que configurés par unité par CPUAccounting= , BlockIOAccounting= , MemoryAccounting= , TasksAccounting= , IOAccounting= et IPAccounting= . Voir systemd.resource-control (5) pour plus de détails sur les paramètres par unité. DefaultTasksAccounting= défaut à yes, DefaultMemoryAccounting= à yes. DefaultCPUAccounting= défaut à yes si l'activation de la comptabilité CPU ne nécessite pas d'activer le contrôleur CPU (Linux 4.15+ en utilisant la hiérarchie unifiée pour le contrôle des ressources), sinon il est par défaut à no. Les trois autres paramètres sont définis par défaut sur non.
DefaultTasksMax=	Configurez la valeur par défaut pour le paramètre TasksMax= par unité. Voir systemd.resource-control (5) pour plus de détails. Ce paramètre s'applique à tous les types d'unités qui prennent en charge les paramètres de contrôle des ressources, à l'exception des unités de tranche. La valeur par défaut est 15%, ce qui équivaut à 4915 avec les valeurs par défaut du noyau sur l'hôte, mais peut être plus petit dans les conteneurs du système d'exploitation.
DefaultLimitCPU= , DefaultLimitFSIZE= , DefaultLimitDATA= , DefaultLimitSTACK= , DefaultLimitCORE= , DefaultLimitRSS= , DefaultLimitNOFILE= , DefaultLimitAS= , DefaultLimitNPROC= , DefaultLimitMEMLOCK= , DefaultLimitLOCKS= , DefaultLimitSIGPENDING=	Ces paramètres contrôlent diverses limites de ressources par défaut pour les unités. Voir setrlimit (2) pour plus de détails. La limite de ressource est possible de spécifier dans deux formats, la value pour définir des limites logicielles et strictes à la même valeur, ou soft:hard pour définir les deux limites individuellement (par exemple DefaultLimitAS = 4G: 16G). Utilisez la chaîne infinity pour configurer aucune limite sur une ressource spécifique. Les suffixes multiplicatifs K (= 1024), M (= 1024 * 1024) et ainsi de suite pour G, T, P et E peuvent être utilisés pour les limites de ressources mesurées en octets (par exemple DefaultLimitAS = 16G). Pour les limites se référant aux valeurs de temps, les unités de temps habituelles ms, s, min, h et ainsi de suite peuvent être utilisées (voir systemd.time (7) pour plus de détails). Notez que si aucune unité de temps n'est spécifiée pour DefaultLimitCPU= l'unité de secondes par défaut est implicite, tandis que pour DefaultLimitRTTIME= l'unité de microsecondes par défaut est implicite. Notez également que la granularité effective des limites peut influencer leur application. Par exemple, les délais spécifiés pour DefaultLimitCPU= seront arrondis implicitement à des multiples de 1. Ces paramètres peuvent être remplacés dans des unités individuelles à l'aide des directives LimitXXX = correspondantes. Notez que ces limites de ressources ne sont que des valeurs par défaut pour les unités, elles ne sont pas appliquées au PID 1 lui-même.
DefaultOOMPolicy=	Configurez la stratégie par défaut pour réagir aux processus tués par le tueur Linux hors mémoire (OOM). Cela peut être utilisé pour choisir une valeur par défaut globale pour le paramètre OOMPolicy= par unité. Voir systemd.service (5) pour plus de détails. Notez que cette valeur par défaut n'est pas utilisée pour les services pour lesquels Delegate= activé.

rc

maintenance
/etc/nologin	interdit tout utilisateur sauf root de se connecter. au démarrage de la machine se fichier est effacé
/etc/nologin	chattr option +i.	fait persister le fichier no-login apres le redémarrage

PAM
PAM	Pour commencer, PAM définit des services qui ont généralement pour nom celui des applications qui l'utilisent. Par exemple nous avons le service login qui correspond à la commande du même nom, chargée de la connexion de l'utilisateur en mode console. De même nous avons les services ftp, gdm, ssh, etc. En fait chaque application qui utilise PAM aura son propre service. Service qui généralement prendra la forme d'un fichier du même nom dans le dossier /etc/pam.d. les serice exemple : /usr/lib/x86_64-linux-gnu/security/pam_faildelay.so
auth	Vérification de l'identité d'un utilisateur et mise en place des accréditations associées.
account	Vérification du compte d'un utilisateur (expiration, plannings, etc.).
password	Vérification de la validité des mots de passes lorsqu'ils sont assignés à un utilisateur.
session	Vérification de la session d'un utilisateur, de son dossier de travail, etc.
required	Tous les modules utilisant ce contrôle doivent passer avec succès pour que la vérification soit accordée. Le cas échéant l'utilisateur n'est averti qu'à la fin du traitement de la pile.
requisite	La même chose que required sauf que l'utilisateur est averti tout de suite.
optionnal	L'échec ou le succès de ce module importe peu et ne peut faire échouer la vérification.
sufficient	S'il réussi et qu'il n'y a pas de required en échec, le traitement s'arrête là. Le reste de la pile n'est alors pas traité.

MOTD
crée une baniere personalisée	le fichier /etc/motd est généré automatiquement
procedure	sudo touch /etc/profile.d/motd.sh [...] script sh sudo chmod +x /etc/profile.d/motd.sh	#!/bin/bash name=`cat /etc/os-release \|grep "^PRETTY_NAME=" \|sed "s/^PRETTY_NAME=\"$.$\"/\1/"` date=` date +"%c"` memoire=`grep MemTotal /proc/meminfo \| grep -o "[0-9]"` memg=$(($memoire % 1000000)) thread=`lscpu \| egrep 'Model name\|Thread$s$'\| grep -o "[0-9]*" \| wc -l` nbcoeur=`cat /proc/cpuinfo \| grep processor \| wc -l` memoire_racine=$(df -B1 \| grep "/$" \| head -1 \| tail -4 \| cut -d" " -f9) user=$(whoami) machine=$(hostname) c0=`printf '\033[0m'` c1=`printf '\033[0;22;35m'` c2=`printf '\033[21;31m'` vert=`printf '\033[1;32;32m'` printf ' '$c1'[]'$c0'-----'$c1'[]'$c0' ' echo printf ' '$c1'[]'$c0'---'$c1'[]'$c0' ' echo printf ' '$c1'[]'$c0'-'$c1'[]'$c0' ' echo printf ' '$c1'[]]'$c0' ' echo printf ' '$c1'[]'$c0'-'$c1'[]'$c0' ' printf $vert;printf " NAME ";printf $c0' : ';printf "$name" echo printf ' '$c1'[]'$c0'---'$c1'[]'$c0' ' printf $vert;printf " DATE ";printf $c0' : ';printf "$date" echo printf ' '$c1'[]'$c0'------'$c1'[]'$c0' ' printf $vert;printf " MEMOIRE VIVE";printf $c0' : ';printf "$(($memoire / 1000000))Go $(($memoire / 1000 % 1000 ))Mo $(($memoire % 1000))ko" echo printf ' '$c1'[]'$c0'--------'$c1'[]'$c0' ' printf $vert;printf " NB COEURS ";printf $c0' : ';printf "$nbcoeur" echo printf ' '$c1'[]'$c0'----by----'$c1'[]'$c0' ' printf $vert;printf " THREAD/COEUR ";printf $c0' : ';printf "$thread" echo printf ' '$c1'[]'$c0'schnellbach-'$c1'[]'$c0'' printf $vert;printf " SPACE ";printf $c0' : ';echo "$(($memoire_racine / 1000000000))Go $(($memoire_racine / 1000000 % 1000 ))Mo $(($memoire_racine % 1000000 / 1000))ko $(($memoire_racine % 1000 ))o" printf ' '$c1'[]'$c0'----------'$c1'[]'$c0' ' echo printf ' '$c1'[]'$c0'--------'$c1'[]'$c0' ' echo printf ' '$c1'[]'$c0'------'$c1'[]'$c0' ' echo printf ' '$c1'[]'$c0'----'$c1'[]'$c0' ' echo printf ' '$c1'[]'$c0'--'$c1'[]'$c0' ' echo printf ' '$c1'[[]'$c0' ' echo printf ' '$c1'[]'$c0'-'$c1'[]'$c0' ' echo printf ' '$c1'[]'$c0'---'$c1'[]'$c0' ' echo printf ' '$c1'[]'$c0'-----'$c1'[]'$c0' ' printf $vert' BIENVENUE '$c2; echo "$user"$c0" sur "$c2"$machine"$c0 /usr/games/fortune -s echo "" echo ""