Initialisation
This commit is contained in:
@@ -0,0 +1,160 @@
|
||||
======= - Répertoire des commandes Linux =======
|
||||
|
||||
Débutons la découverte de commandes internes ou externes au shell.
|
||||
|
||||
Je vous propose de découvrir les commandes par catégories fréquemment utilisées :
|
||||
|
||||
<WRAP center round info 60%>Un signe **$** précède les commandes qui ne nécessitent pas de droits administrateur ; un signe **#** précède celles qui nécessitent des droits administrateur (ces signes ne font PAS partie des commandes).\\
|
||||
Les lignes qui ne commencent ni par un signe **$** ou ni par un signe **#** correspondent au résultat de la commande précédente.\\
|
||||
Les touches utilisées sont indiquées dans une touche graphique, exemple <button>Ctrl</button> pour la touche "contrôle"</WRAP>
|
||||
|
||||
===== Informations et éditions des commandes =====
|
||||
<nav>
|
||||
* [[informatique:linux:commandes:apropos|apropos]]
|
||||
* [[informatique:linux:commandes:man|man]]
|
||||
* [[informatique:linux:commandes:type|type]]
|
||||
* [[informatique:linux:commandes:alias|alias]]
|
||||
</nav>
|
||||
|
||||
|
||||
===== Naviguer dans l'arborescence des dossiers =====
|
||||
|
||||
<nav>
|
||||
* [[informatique:linux:commandes:cd|cd]]
|
||||
* [[informatique:linux:commandes:pwd|pwd]]
|
||||
* [[informatique:linux:commandes:ls|ls]]
|
||||
* [[informatique:linux:commandes:du|du]]
|
||||
</nav>
|
||||
|
||||
|
||||
===== Éditer les dossiers =====
|
||||
|
||||
<nav>
|
||||
* [[informatique:linux:commandes:mkdir]]
|
||||
* [[informatique:linux:commandes:rmdir]]
|
||||
* [[informatique:linux:commandes:rm]]
|
||||
</nav>
|
||||
|
||||
|
||||
===== Gérer le shell =====
|
||||
|
||||
<nav>
|
||||
* [[informatique:linux:commandes:history]]
|
||||
* [[informatique:linux:commandes:sudo]]
|
||||
* [[informatique:linux:commandes:watch]]
|
||||
* [[informatique:linux:commandes:symbole_e_commercial]]
|
||||
* [[informatique:linux:commandes:tmux]]
|
||||
</nav>
|
||||
|
||||
|
||||
===== Gestion des fichiers et des répertoires =====
|
||||
|
||||
Ces commandes permettent de gérer les fichiers et les répertoires sur le système, comme copier, déplacer, renommer, lister, supprimer, etc.
|
||||
|
||||
<nav>
|
||||
* [[informatique:linux:commandes:cp]]
|
||||
* [[informatique:linux:commandes:scp]]
|
||||
* [[informatique:linux:commandes:mv]]
|
||||
* [[informatique:linux:commandes:chown]]
|
||||
* [[informatique:linux:commandes:chmod]]
|
||||
* [[informatique:linux:commandes:touch]]
|
||||
* [[informatique:linux:commandes:symbole_plus_grand]]
|
||||
* [[informatique:linux:commandes:file]]
|
||||
* [[informatique:linux:commandes:md5sum]]
|
||||
* [[informatique:linux:commandes:tee]]
|
||||
* [[informatique:linux:commandes:umask]]
|
||||
* [[informatique:linux:commandes:setfacl]]
|
||||
</nav>
|
||||
|
||||
|
||||
===== Édition d'un fichier =====
|
||||
|
||||
Ces commandes permettent d'éditer des fichiers texte ou de code sur le système, comme ajouter, supprimer, chercher, remplacer du contenu, etc.
|
||||
|
||||
<nav>
|
||||
* [[informatique:linux:commandes:tail]]
|
||||
* [[informatique:linux:commandes:head]]
|
||||
* [[informatique:linux:commandes:cat]]
|
||||
* [[informatique:linux:commandes:tac|tac]]
|
||||
* [[informatique:linux:commandes:grep]]
|
||||
* [[informatique:linux:commandes:nano]]
|
||||
* [[informatique:linux:commandes:vi]]
|
||||
* [[informatique:linux:commandes:ed]]
|
||||
* [[informatique:linux:commandes:expand]]
|
||||
</nav>
|
||||
|
||||
|
||||
===== Configuration du système =====
|
||||
|
||||
<nav>
|
||||
* [[informatique:linux:commandes:timedatectl]]
|
||||
</nav>
|
||||
|
||||
|
||||
===== Gestion des processus =====
|
||||
|
||||
Ces commandes permettent de gérer les processus (c'est-à-dire les programmes en cours d'exécution) sur le système, comme lancer, arrêter, afficher, tuer, etc.
|
||||
|
||||
<nav>
|
||||
* [[informatique:linux:commandes:free]]
|
||||
* [[informatique:linux:commandes:htop]]
|
||||
* [[informatique:linux:commandes:ps]]
|
||||
* [[informatique:linux:commandes:reboot]]
|
||||
* [[informatique:linux:commandes:poweroff]]
|
||||
* [[informatique:linux:commandes:halt]]
|
||||
* [[informatique:linux:commandes:shutdown]]
|
||||
* [[informatique:linux:commandes:systemctl]]
|
||||
* [[informatique:linux:commandes:symbole_double_et_commercial]]
|
||||
* [[informatique:linux:commandes:cron]]
|
||||
</nav>
|
||||
|
||||
===== Gestion du réseau =====
|
||||
|
||||
Ces commandes permettent de configurer et de gérer le réseau sur le système, comme afficher les informations de connexion, ping, tracer des routes, etc.
|
||||
<nav>
|
||||
* [[informatique:linux:commandes:iftop]]
|
||||
* [[informatique:linux:commandes:ifconfig]]
|
||||
* [[informatique:linux:commandes:ip]]
|
||||
* [[informatique:linux:commandes:mtr]]
|
||||
* [[informatique:linux:commandes:nestat]]
|
||||
* [[informatique:linux:commandes:nslookup]]
|
||||
* [[informatique:linux:commandes:hostname]]
|
||||
</nav>
|
||||
|
||||
===== Gestion de l'utilisateur =====
|
||||
|
||||
Ces commandes permettent de gérer les utilisateurs et les groupes d'utilisateurs sur le système, comme créer, supprimer, changer le mot de passe, etc.
|
||||
|
||||
<nav>
|
||||
* [[informatique:linux:commandes:who]]
|
||||
* [[informatique:linux:commandes:whoami]]
|
||||
* [[informatique:linux:commandes:adduser|adduser]]
|
||||
* [[informatique:linux:commandes:addgroup]]
|
||||
* [[informatique:linux:commandes:usermod]]
|
||||
* [[informatique:linux:commandes:passwd]]
|
||||
* [[informatique:linux:commandes:write]]
|
||||
* [[informatique:linux:commandes:wall]]
|
||||
</nav>
|
||||
|
||||
===== Gestion des disques / flux I/O =====
|
||||
|
||||
<nav>
|
||||
* [[informatique:linux:commandes:dd|dd]]
|
||||
* [[informatique:linux:commandes:df]]
|
||||
* [[informatique:linux:commandes:lsio]]
|
||||
* [[informatique:linux:commandes:lsusb]]
|
||||
* [[informatique:linux:commandes:lsblk]]
|
||||
* [[informatique:linux:commandes:blkid]]
|
||||
</nav>
|
||||
|
||||
===== Configurer son environnement =====
|
||||
|
||||
<nav>
|
||||
* [[informatique:linux:commandes:tzselect]]
|
||||
</nav>
|
||||
|
||||
===== Gestionnaire de paquets =====
|
||||
|
||||
<nav>
|
||||
* [[informatique:linux:commandes:apt-get]]
|
||||
</nav>
|
||||
34
data/pages/informatique/linux/commandes/adduser.txt
Normal file
34
data/pages/informatique/linux/commandes/adduser.txt
Normal file
@@ -0,0 +1,34 @@
|
||||
====== adduser ======
|
||||
{{tag>"commande linux"}}
|
||||
|
||||
Créer un utilisateur dans le système suivant la configuration définie dans le fichier ''/etc/adduser.conf''.
|
||||
|
||||
La commande ''adduser'' est utilisée sous Linux pour ajouter un nouvel utilisateur à un système. Lorsque cette commande est exécutée, elle effectue les tâches suivantes :
|
||||
|
||||
* Crée un nouveau compte utilisateur dans le système.
|
||||
|
||||
* Crée un nouveau répertoire personnel pour le nouvel utilisateur.
|
||||
|
||||
* Copie les fichiers de base dans le répertoire personnel du nouvel utilisateur.
|
||||
|
||||
* Définit les permissions sur le répertoire personnel pour que seul le nouvel utilisateur puisse y accéder.
|
||||
|
||||
* Ajoute le nouvel utilisateur à certains groupes du système (par exemple, le groupe sudo pour donner les droits d'administration).
|
||||
|
||||
* Demande à l'utilisateur de fournir un mot de passe pour son compte.
|
||||
|
||||
La commande ''adduser'' est une commande plus conviviale que la commande [[.:useradd]] mais pas adaptée pour des scripts.
|
||||
|
||||
|
||||
===== Créer un utilisateur =====
|
||||
|
||||
Pour créer un utilisateur , c'est la commande ''adduser''.
|
||||
|
||||
Par exemple :
|
||||
<code>
|
||||
sudo adduser cedric
|
||||
</code>
|
||||
|
||||
|
||||
|
||||
|
||||
128
data/pages/informatique/linux/commandes/alias.txt
Normal file
128
data/pages/informatique/linux/commandes/alias.txt
Normal file
@@ -0,0 +1,128 @@
|
||||
====== alias ======
|
||||
{{ :dummy.png?75x75|Créer un raccourci ou une abréviation}}
|
||||
|
||||
En Bash, un **alias** est un raccourci ou une abréviation qui est utilisé pour remplacer une commande ou une séquence de commandes plus longue par un seul mot ou une expression.
|
||||
|
||||
Par exemple, si vous utilisez fréquemment la commande ''ls -al'', vous pouvez créer un alias nommé ''ll'' pour cette commande en utilisant la syntaxe suivante dans le terminal :
|
||||
|
||||
<code BASH>
|
||||
alias ll='ls -al'
|
||||
</code>
|
||||
|
||||
Maintenant, chaque fois que vous tapez ''ll'' dans le terminal, Bash exécutera automatiquement la commande ''ls -al''.
|
||||
|
||||
Les alias peuvent être utiles pour gagner du temps et améliorer l'efficacité lorsque vous travaillez avec la ligne de commande en réduisant la quantité de texte que vous devez taper pour exécuter une commande particulière.
|
||||
|
||||
Vous pouvez enregistrer des alias dans le fichier ''.bash_aliases'' si ce dernier existe.
|
||||
|
||||
Dans certains systèmes, le fichier ''.bash_aliases'' n'existe pas par défaut, mais vous pouvez le créer manuellement dans votre répertoire d'utilisateur en utilisant la commande suivante :
|
||||
|
||||
<code BASH>
|
||||
touch ~/.bash_aliases
|
||||
</code>
|
||||
|
||||
Ensuite, vous pouvez ajouter vos alias dans ce fichier en utilisant la même syntaxe que celle utilisée pour définir des alias dans le terminal. Par exemple :
|
||||
|
||||
<code BASH>
|
||||
alias ll='ls -al'
|
||||
</code>
|
||||
|
||||
Une fois que vous avez ajouté vos alias dans le fichier ''.bash_aliases'', vous devez exécuter la commande suivante pour les charger dans votre session Bash en cours :
|
||||
|
||||
<code BASH>
|
||||
source ~/.bashrc
|
||||
</code>
|
||||
|
||||
Cette commande rechargera le fichier .bashrc qui charge normalement le fichier ''.bash_aliases'' dans votre session Bash.
|
||||
|
||||
Notez que le nom et l'emplacement des fichiers de configuration Bash peuvent varier selon le système. Par conséquent, il est possible que vous deviez ajuster les instructions ci-dessus en fonction de votre configuration spécifique.
|
||||
|
||||
===== Quelques exemples =====
|
||||
|
||||
Voici quelques exemples d'alias de commandes qui peuvent être utiles :
|
||||
|
||||
* ''ll'' pour ''ls -al'' : comme expliqué précédemment, cela affichera le contenu d'un répertoire en mode long, avec les permissions et les détails de propriétaire affichés.
|
||||
|
||||
<code BASH>
|
||||
alias ll='ls -al'
|
||||
</code>
|
||||
|
||||
* ''grep'' avec couleur : pour ajouter de la couleur à la sortie de la commande grep pour améliorer la lisibilité, vous pouvez utiliser l'alias suivant :
|
||||
|
||||
<code BASH>
|
||||
alias grep='grep --color=auto'
|
||||
</code>
|
||||
|
||||
* ''mkdir -p'' : si vous créez souvent des répertoires imbriqués, vous pouvez utiliser l'option -p pour créer des répertoires parents si nécessaire. Vous pouvez également créer un alias nommé mkdirp pour simplifier l'opération.
|
||||
|
||||
<code BASH>
|
||||
alias mkdirp='mkdir -p'
|
||||
</code>
|
||||
|
||||
* ''ps'' avec tri inversé : si vous utilisez souvent la commande ps pour afficher les processus en cours d'exécution sur votre système, vous pouvez ajouter un alias nommé pss pour trier les résultats par ordre décroissant d'utilisation de la mémoire.
|
||||
|
||||
<code BASH>
|
||||
alias pss='ps aux --sort=-rss'
|
||||
</code>
|
||||
|
||||
* ''du'' trié par taille : si vous voulez afficher les dossiers par taille décroissante, vous pouvez ajouter un alias nommé dus pour trier la sortie de la commande du par ordre décroissant de taille.
|
||||
|
||||
<code BASH>
|
||||
alias dus='du -hs * | sort -hr'
|
||||
</code>
|
||||
|
||||
* ''cp'' avec confirmation : pour ajouter une confirmation avant de copier des fichiers, vous pouvez créer un alias nommé cp qui inclut l'option -i pour demander une confirmation avant d'écraser les fichiers existants.
|
||||
|
||||
<code BASH>
|
||||
alias cp='cp -i'
|
||||
</code>
|
||||
|
||||
* ''rm'' avec confirmation : de même, pour ajouter une confirmation avant de supprimer des fichiers, vous pouvez créer un alias nommé rm qui inclut l'option -i pour demander une confirmation avant de supprimer chaque fichier.
|
||||
|
||||
<code BASH>
|
||||
alias rm='rm -i'
|
||||
</code>
|
||||
|
||||
* ''git'' avec couleur : si vous utilisez Git pour gérer des projets de développement de logiciels, vous pouvez ajouter de la couleur à la sortie de la commande git pour améliorer la lisibilité.
|
||||
|
||||
<code BASH>
|
||||
alias git='git --color=auto'
|
||||
</code>
|
||||
|
||||
* ''cd'' avec retour rapide : pour revenir rapidement au répertoire parent, vous pouvez créer un alias nommé .. qui exécute la commande cd .. pour revenir au répertoire parent.
|
||||
|
||||
<code BASH>
|
||||
alias ..='cd ..'
|
||||
</code>
|
||||
|
||||
* ''free'' avec unités de mémoire lisibles : si vous utilisez souvent la commande free pour surveiller l'utilisation de la mémoire, vous pouvez ajouter l'option -h pour afficher les tailles de mémoire dans des unités lisibles pour l'homme (comme "1.23 GiB" au lieu de "1289311232").
|
||||
|
||||
<code BASH>
|
||||
alias free='free -h'
|
||||
</code>
|
||||
|
||||
* ''grep'' avec numéros de ligne : pour afficher les numéros de ligne dans la sortie de la commande grep, vous pouvez ajouter l'option -n à l'alias grep.
|
||||
|
||||
<code BASH>
|
||||
alias grep='grep -n'
|
||||
</code>
|
||||
|
||||
* ''ls'' avec tri inversé : pour afficher les fichiers et répertoires triés par ordre inverse de date de modification, vous pouvez créer un alias nommé lsr.
|
||||
|
||||
<code BASH>
|
||||
alias lsr='ls -ltr'
|
||||
</code>
|
||||
|
||||
* ''tar'' avec compression gzip : pour créer une archive tar compressée avec gzip, vous pouvez créer un alias nommé targz.
|
||||
|
||||
<code BASH>
|
||||
alias targz='tar -cvzf'
|
||||
</code>
|
||||
|
||||
* ''df'' avec taille et espace libre en unités lisibles : pour afficher l'espace disque disponible sur les partitions de votre système dans des unités lisibles pour l'homme, vous pouvez créer un alias nommé dfh.
|
||||
|
||||
<code BASH>
|
||||
alias dfh='df -hT'
|
||||
</code>
|
||||
|
||||
Ces exemples montrent comment vous pouvez personnaliser vos alias de commandes pour automatiser des tâches courantes, faciliter la navigation dans les répertoires et améliorer la lisibilité de la sortie de la commande.
|
||||
54
data/pages/informatique/linux/commandes/apropos.txt
Normal file
54
data/pages/informatique/linux/commandes/apropos.txt
Normal file
@@ -0,0 +1,54 @@
|
||||
====== apropos ======
|
||||
|
||||
|
||||
La commande ''apropos'' permet de lister les manuels dont la **description** ou le **nom** comprend les mots passés en arguments.
|
||||
|
||||
Par exemple ''apropos copy'' listera les commandes permettant d'effectuer des copies.
|
||||
|
||||
|
||||
<code BASH>
|
||||
$ apropos copy
|
||||
debconf-copydb (1) - copier une base de données debconf
|
||||
arm-linux-gnueabihf-objcopy (1) - copy and translate object files
|
||||
bcopy (3) - copy byte sequence
|
||||
copy_file_range (2) - Copy a range of data from one file to another
|
||||
copysign (3) - copy sign of a number
|
||||
copysignf (3) - copy sign of a number
|
||||
copysignl (3) - copy sign of a number
|
||||
cp (1) - copy files and directories
|
||||
cpgr (8) - copy with locking the given file to the password or group file
|
||||
cpio (1) - copy files to and from archives
|
||||
cppw (8) - copy with locking the given file to the password or group file
|
||||
dd (1) - convert and copy a file
|
||||
</code>
|
||||
|
||||
====== Des astuces ======
|
||||
|
||||
> Limiter la recherche à une section de la documentation
|
||||
|
||||
Pour afficher les commandes de l'interpréteur de commandes, j'utilise le paramètre ''-m'' :
|
||||
<code>
|
||||
apropos copy -s 1
|
||||
</code>
|
||||
|
||||
> Rechercher avec plusieurs mots clés
|
||||
|
||||
Par défaut, le recherche de plusieurs mots clés et conditionnée par un **OU**. Par exemple, la ligne de commande ''apropos copy file'' effectuera la recherche sur le mot ''copy'' ou ''file''.
|
||||
|
||||
Pour effectuer une recherche avec tous les mots clé inclus dans la recherche, il faut utiliser le paramètre ''-a''. Par exemple :
|
||||
|
||||
<code>
|
||||
$ apropos -s 1 -a copy file
|
||||
cp (1) - copy files and directories
|
||||
cpio (1) - copy files to and from archives
|
||||
dd (1) - convert and copy a file
|
||||
i686-linux-gnu-objcopy (1) - copy and translate object files
|
||||
install (1) - copy files and set attributes
|
||||
mcopy (1) - copy MSDOS files to/from Unix
|
||||
objcopy (1) - copy and translate object files
|
||||
rcp (1) - secure copy (remote file copy program)
|
||||
rsync (1) - a fast, versatile, remote (and local) file-copying tool
|
||||
scp (1) - secure copy (remote file copy program)
|
||||
</code>
|
||||
|
||||
|
||||
56
data/pages/informatique/linux/commandes/apt-get.txt
Normal file
56
data/pages/informatique/linux/commandes/apt-get.txt
Normal file
@@ -0,0 +1,56 @@
|
||||
====== apt-get ======
|
||||
{{tag>"Linux commande"}}
|
||||
{{ :informatique:1200px-gnulinux.jpg?75x75|Commande apt-get}}
|
||||
|
||||
Programme APT de gestion des paquets.
|
||||
|
||||
<well>
|
||||
__Éléments techniques sur Debian sid__
|
||||
|
||||
<text>
|
||||
**apt-get** is **/usr/bin/apt-get**
|
||||
|
||||
**/usr/bin/apt-get**: ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib, for GNU/Linux 3.2.0, BuildID[sha1]=2f2fdfecba1105efe70a5082eb019b16a2c47619, strippe
|
||||
</text>
|
||||
</well>
|
||||
|
||||
--
|
||||
|
||||
Liste les paquets installés sur le système.
|
||||
|
||||
<code>
|
||||
apt list --installed
|
||||
</code>
|
||||
|
||||
--
|
||||
|
||||
Mettre à jour l'index des paquets.
|
||||
|
||||
<code>
|
||||
apt update
|
||||
</code>
|
||||
|
||||
--
|
||||
|
||||
Mettre à jour les version les plus récentes de tous les paquets présents sur le système.
|
||||
|
||||
<code>
|
||||
apt upgrade
|
||||
</code>
|
||||
|
||||
--
|
||||
|
||||
Mettre à jour les version les plus récentes de tous les paquets présents sur le système et supprime des paquets installés si cela est nécessaire.
|
||||
|
||||
<code>
|
||||
apt full-upgrade
|
||||
</code>
|
||||
|
||||
--
|
||||
|
||||
Mettre à jour avec une gestion intelligente de résolution de conflits de paquets.
|
||||
|
||||
<code>
|
||||
apt-get dist-upgrade
|
||||
</code>
|
||||
|
||||
83
data/pages/informatique/linux/commandes/apt.txt
Normal file
83
data/pages/informatique/linux/commandes/apt.txt
Normal file
@@ -0,0 +1,83 @@
|
||||
====== apt ======
|
||||
|
||||
----
|
||||
|
||||
Le programme ''apt'' est un gestionnaire de paquets pour les systèmes d'exploitation basés sur **Debian**, tels que **Debian** lui-même, **Ubuntu**, **Linux Mint** et d'autres distributions Linux. Il permet à l'utilisateur de rechercher, installer, mettre à jour et supprimer des paquets logiciels sur le système.
|
||||
|
||||
Le nom ''apt'' est un acronyme pour "Advanced Packaging Tool", ce qui signifie "outil de gestion de paquets avancé" en français. Il est souvent utilisé en ligne de commande, bien qu'il existe également des interfaces graphiques qui permettent une utilisation plus conviviale pour les débutants.
|
||||
|
||||
En utilisant **apt**, l'utilisateur peut effectuer des opérations telles que l'installation de nouveaux programmes, la mise à jour de programmes existants, la suppression de programmes, la recherche de nouveaux paquets, la mise à jour du système d'exploitation et la résolution des dépendances des paquets.
|
||||
|
||||
===== Synchroniser la liste des paquets =====
|
||||
|
||||
Faire systématiquement un ''apt update'' avant d'installer un nouveau logiciel ou de mettre à jour des paquets sur un système **Debian** est une bonne pratique recommandée.
|
||||
|
||||
La commande ''apt update'' permet de synchroniser la liste des paquets disponibles sur les dépôts (ou sources) de logiciels configurés sur le système avec les dernières informations disponibles. En d'autres termes, elle permet de télécharger la dernière version de la liste des paquets disponibles, qui est stockée localement sur le système.
|
||||
|
||||
Cela permet à l'utilisateur de s'assurer qu'il installe la dernière version d'un paquet à partir des dépôts configurés sur son système, car ces dépôts peuvent être mis à jour fréquemment par les développeurs des logiciels pour corriger des bugs, ajouter des fonctionnalités, ou améliorer la sécurité.
|
||||
|
||||
Si l'utilisateur omet de mettre à jour la liste des paquets disponibles avant d'installer un nouveau logiciel ou de mettre à jour des paquets, il risque d'installer une version obsolète ou moins sécurisée du paquet, car il installera la version de la liste des paquets stockée.
|
||||
|
||||
===== Lister les paquets installés =====
|
||||
|
||||
La commande ''apt list --installed'' permet de lister tous les paquets installés sur votre système via le système de gestion de paquets apt.
|
||||
|
||||
Plus précisément, elle affiche la liste des paquets installés avec leur nom, leur version et leur description. Cela permet de savoir rapidement quels paquets sont installés sur votre système, ainsi que leur version actuelle.
|
||||
|
||||
Notez que cette commande nécessite des privilèges d'administrateur pour être exécutée.
|
||||
|
||||
<panel type="default" title="Exemple 1">
|
||||
|
||||
Lister tous les paquets installés sur votre système :
|
||||
|
||||
<code BASH>
|
||||
apt list --installed
|
||||
</code>
|
||||
{{ :informatique:applications:pasted:20230216-144114.png }}
|
||||
</panel>
|
||||
|
||||
|
||||
<panel type="default" title="Exemple 2">
|
||||
|
||||
Lister tous les paquets installés commençant par **php7.4-**, vous pouvez exécuter la commande suivante:
|
||||
|
||||
apt list --installed | grep '^php7.4-'
|
||||
|
||||
Cela va afficher la liste de tous les paquets installés commençant par ''php7.4-''.
|
||||
|
||||
{{ :informatique:applications:pasted:20230216-150140.png }}
|
||||
|
||||
</panel>
|
||||
|
||||
|
||||
<panel type="default" title="Exemple 3">
|
||||
Vous pouvez utiliser la commande suivante pour lister tous les paquets qui commencent par ''php7.4-'' et les remplacer par leurs versions équivalentes commençant par ''php8.2-'' :
|
||||
|
||||
echo $(dpkg -l | grep '^ii' | grep 'php7.4-' | awk '{ print $2 }' | sed -e 's/php7.4/php8.2/g')
|
||||
|
||||
Cette commande utilise plusieurs commandes Linux pour extraire les noms des paquets installés commençant par ''php7.4-'', les remplace par leur équivalent ''php8.2-'' et les affiche. Vous pourrez recopier le resultat pour l'utiliser dans un ''apt install'' par exemple.
|
||||
|
||||
|
||||
{{ :informatique:applications:pasted:20230216-150017.png }}
|
||||
|
||||
</panel>
|
||||
|
||||
|
||||
===== les signatures suivantes ne sont pas valables =====
|
||||
|
||||
{{ :informatique:linux:pasted:20220109-124015.png?75x75|apt, correction de l'erreur signatures non valables}}
|
||||
|
||||
En exécutant la commande ''apt update'', l'erreur suivante est apparue :
|
||||
Les signatures suivantes ne sont pas valables : EXPKEYSIG B188E2B695BD4743 DEB.SURY.ORG Automatic Signing Key <deb@sury.org>
|
||||
...
|
||||
Le téléchargement de quelques fichiers d'index a échoué, ils ont été ignorés, ou les anciens ont été utilisés à la place.
|
||||
|
||||
La clé de sécruité du serveur distant a changé et le programme ''apt'' bloque les informations car elles ne sont plus conformes. Il faut mettre à jour votre clé suivant celle qui est présente sur le serveur.
|
||||
|
||||
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys B188E2B695BD4743
|
||||
|
||||
La valeur ''B188E2B695BD4743'' correspond à la clé qui pose problème, affichée dans le message d'alerte du programme ''apt''.
|
||||
|
||||
===== Voir aussi =====
|
||||
|
||||
* [[informatique:linux:system:fichier-de-paquet-debian-.deb]]
|
||||
28
data/pages/informatique/linux/commandes/blkid.txt
Normal file
28
data/pages/informatique/linux/commandes/blkid.txt
Normal file
@@ -0,0 +1,28 @@
|
||||
====== blkid ======
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
|
||||
Ce programme permet d'afficher les propriétés des périphériques de type //block//.
|
||||
|
||||
Il peut être utiliser afin d référencer les partitions par leur identifiant unqiue vu par le système. Quelque soit le port où est branché le disque, l'//id// sera toujours le même. La commande ''blkid'' permet d'afficher le //partuuid// ou l'//uid// :
|
||||
|
||||
<code>$ sudo blkid</code>
|
||||
|
||||
Le système retourne les informations suivantes :
|
||||
|
||||
<code>
|
||||
/dev/sda1: PARTUUID="7a560b51-528c-4160-9865-83ed3222b3fd"
|
||||
/dev/sda2: UUID="f91bd1b8-9765-4e1b-a629-47dc219290cb" TYPE="ext4" PARTUUID="339404cb-449d-426f-9b14-40aa9da9cd0b"
|
||||
/dev/sda3: UUID="fa3a0392-150a-4cb6-b780-9ac7ffd894a4" TYPE="swap" PARTUUID="f26124e8-c4fe-48cd-b86f-24cfe6110764"
|
||||
/dev/sda4: UUID="2e3e7650-a1b9-4a1f-855d-5c22901a07e3" TYPE="ext4" PARTUUID="86f8087a-db91-46b3-a59f-85e15079da53"
|
||||
/dev/sda5: UUID="f4406f7c-f82f-4adf-9d19-b579b1e07e1d" TYPE="ext4" PARTUUID="367872e8-36e8-400b-a317-791c8b1e2017"
|
||||
/dev/sda6: UUID="a256acc0-21e4-40e6-a1d0-e5c89ea37b32" TYPE="ext4" PARTUUID="566a4015-03a9-413a-9ae5-829fed051cb1"
|
||||
/dev/sdb: LABEL="disk_19" UUID="d41ee57f-f890-41f2-ba00-37196b017a85" TYPE="ext4"
|
||||
/dev/sdc1: LABEL="disk_7" UUID="1CAA79C7AA799DC8" TYPE="ntfs" PARTUUID="0006fe3b-01"
|
||||
/dev/sdd1: LABEL="disk_18" UUID="956d32d8-a797-4632-a07e-6094b22d043a" SEC_TYPE="ext2" TYPE="ext3" PARTUUID="000a27b7-01"
|
||||
/dev/sde1: LABEL="disk_14" UUID="b3f715ae-591a-43e5-b14b-f565bc6d5e2c" TYPE="ext4" PARTUUID="0007ffc0-01"
|
||||
</code>
|
||||
|
||||
Le disque //sda// (de 80 Go) est réservé au système Linux.\\
|
||||
Ce sont les partitions des disques **sdb**, **sdc**, **sdd** et **sde** que je veux monter.\\
|
||||
Toutefois, pour une raison ou une autre, les disques peuvent être affecter différemment de **sdb**, **sdc**, **sdd** ou **sde**. De ce fait, je conseille d'utiliser l'**identifiant de disque**, appelé //UUID//.
|
||||
|
||||
5
data/pages/informatique/linux/commandes/cd.txt
Normal file
5
data/pages/informatique/linux/commandes/cd.txt
Normal file
@@ -0,0 +1,5 @@
|
||||
====== cd ======
|
||||
{{tag>"Linux commande"}}
|
||||
{{ :informatique:langage:logo_bash.png?75x75|bash}}
|
||||
|
||||
Changer de répertoire (**c**hange **d**irectory).
|
||||
23
data/pages/informatique/linux/commandes/chmod.txt
Normal file
23
data/pages/informatique/linux/commandes/chmod.txt
Normal file
@@ -0,0 +1,23 @@
|
||||
====== chmod ======
|
||||
|
||||
{{ :dummy.png?75x75|}}
|
||||
|
||||
La commande ''chmod'' est utilisée pour modifier les permissions d'accès des fichiers et des répertoires dans un système de fichiers UNIX/Linux. Les permissions d'accès permettent de définir qui peut lire, écrire ou exécuter un fichier ou un répertoire.
|
||||
|
||||
La commande ''chmod'' permet de définir les permissions pour trois types d'utilisateurs : le propriétaire du fichier, le groupe associé au fichier et les autres utilisateurs.
|
||||
|
||||
Les permissions d'accès peuvent être représentées sous forme de **notation numérique** ou **symbolique**.
|
||||
|
||||
La **notation numérique** utilise une combinaison de chiffres pour définir les permissions de chaque type d'utilisateur. Par exemple, ''r'' représente la permission de lecture, ''w'' représente la permission d'écriture et ''x'' représente la permission d'exécution. Les chiffres utilisés sont 4 pour la permission de lecture, 2 pour la permission d'écriture et 1 pour la permission d'exécution. La somme de ces chiffres représente les permissions totales pour chaque type d'utilisateur. Par exemple, 644 (ou 0644) représente les permissions de rw-r--r--, où le propriétaire peut lire et écrire le fichier, mais les autres utilisateurs ne peuvent que lire le fichier.
|
||||
|
||||
La **notation symbolique** utilise des lettres pour définir les permissions pour chaque type d'utilisateur. Par exemple, ''u'' représente le propriétaire du fichier, ''g'' représente le groupe associé au fichier et ''o'' représente les autres utilisateurs. Les lettres ''r'', ''w'' et ''x'' sont utilisées pour définir les permissions de lecture, d'écriture et d'exécution.
|
||||
|
||||
Par exemple :
|
||||
<code>
|
||||
chmod u+rwx fichier.txt
|
||||
|
||||
</code>
|
||||
|
||||
Cette commande ajoute les permissions de lecture, d'écriture et d'exécution pour le propriétaire du fichier.
|
||||
|
||||
|
||||
15
data/pages/informatique/linux/commandes/chpasswd.txt
Normal file
15
data/pages/informatique/linux/commandes/chpasswd.txt
Normal file
@@ -0,0 +1,15 @@
|
||||
====== chpasswd ======
|
||||
{{ :dummy.png?75x75|Modifier les mots de passe des comptes d'utilisateurs}}
|
||||
|
||||
La commande ''chpasswd'' sous Linux est utilisée pour modifier les mots de passe des comptes d'utilisateurs. Elle prend en entrée une liste de noms d'utilisateurs et de nouveaux mots de passe, et met à jour les fichiers système qui contiennent les informations de mot de passe.
|
||||
|
||||
La commande ''chpasswd'' peut être utilisée en conjonction avec d'autres commandes Linux pour automatiser la création ou la mise à jour de comptes d'utilisateurs, en particulier dans des environnements de déploiement ou de gestion de serveurs à grande échelle.
|
||||
|
||||
Voici un exemple d'utilisation de la commande ''chpasswd'' :
|
||||
|
||||
<code BASH>
|
||||
echo "utilisateur1:motdepasse1" | chpasswd
|
||||
</code>
|
||||
|
||||
Cet exemple met à jour le mot de passe du compte utilisateur ''utilisateur1'' avec le nouveau mot de passe ''motdepasse1''. Le mot de passe est fourni à la commande ''chpasswd'' via un tube (**pipe**) qui **redirige** la **sortie** de la commande ''echo'' vers l'**entrée** de la commande ''chpasswd''.
|
||||
|
||||
48
data/pages/informatique/linux/commandes/cp.txt
Normal file
48
data/pages/informatique/linux/commandes/cp.txt
Normal file
@@ -0,0 +1,48 @@
|
||||
====== cp ======
|
||||
{{ :dummy.png?75x75|Copier des fichiers et des répertoires}}
|
||||
|
||||
La commande ''cp'' sous Linux est une commande utilisée pour copier des fichiers et des répertoires d'un emplacement à un autre. ''cp'' signifie //copy// (copier en anglais).
|
||||
|
||||
La syntaxe de base de la commande est la suivante :
|
||||
|
||||
<code BASH>
|
||||
cp source_file destination_file
|
||||
</code>
|
||||
|
||||
où ''source_file'' est le fichier que vous souhaitez copier et ''destination_file'' est l'emplacement où vous souhaitez copier le fichier.
|
||||
|
||||
Vous pouvez également copier plusieurs fichiers en une seule fois en spécifiant plusieurs fichiers source, comme ceci :
|
||||
|
||||
cp source_file1 source_file2 source_file3 destination_directory
|
||||
|
||||
La commande ''cp'' peut également être utilisée pour copier des répertoires entiers, en utilisant l'option ''-r'' (récursive) pour copier tous les fichiers et sous-répertoires à l'intérieur du répertoire :
|
||||
|
||||
cp -r source_directory destination_directory
|
||||
|
||||
Si le fichier ou le répertoire de destination existe déjà, la commande ''cp'' remplacera le fichier ou le répertoire existant sans avertissement. Il est donc important d'être prudent lors de l'utilisation de cette commande.
|
||||
|
||||
-- Utiliser l'option ''-v'' pour afficher les fichiers copiés en temps réel :
|
||||
|
||||
<code BASH>
|
||||
cp -v source_file destination_file
|
||||
</code>
|
||||
|
||||
-- Utiliser l'option ''-i'' pour demander une confirmation avant d'écraser un fichier existant :
|
||||
|
||||
<code BASH>
|
||||
cp -i source_file destination_file
|
||||
</code>
|
||||
|
||||
-- Utiliser l'option ''-p'' pour conserver les attributs de fichier d'origine (comme les autorisations, la propriété, etc.) lors de la copie :
|
||||
|
||||
<code BASH>
|
||||
cp -p source_file destination_file
|
||||
</code>
|
||||
|
||||
-- Créer un [[informatique:linux:commandes:alias|alias]] pour la commande ''cp'' avec l'option ''-i'', ''-p'' et ''-v'' pour les raisons évoquées précédemment :
|
||||
|
||||
<code BASH>
|
||||
alias cp='cp -ipv'
|
||||
</code>
|
||||
|
||||
Ces astuces et alias peuvent vous aider à utiliser la commande ''cp'' de manière plus efficace et plus sûre.
|
||||
101
data/pages/informatique/linux/commandes/cron.txt
Normal file
101
data/pages/informatique/linux/commandes/cron.txt
Normal file
@@ -0,0 +1,101 @@
|
||||
====== crontab ======
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
Programme Unix qui exécute toutes les minutes un ensemble de taches prédéterminées.
|
||||
|
||||
Sous Linux, le programme **cron** s'appelle **crontab**, concaténation de **c**h**ron**o **tab**le, "table de planification". Il est exécuté par **root** et permet de s'adapter à l'identité à chacun des utilisateurs.
|
||||
|
||||
===== - Liste la table des tâches =====
|
||||
|
||||
Afficher la liste des tâches pour l'utilisateur connecté
|
||||
|
||||
<code>
|
||||
crontab -l
|
||||
</code>
|
||||
|
||||
===== - Mots clés =====
|
||||
|
||||
Des mots-clé peuvent remplacer le code horaire.
|
||||
|
||||
^ mot-clé ^ description ^ équivalent ^
|
||||
| @reboot | Au démarrage | Aucun |
|
||||
| @yearly | Tous les ans | 0 0 1 1 * |
|
||||
| @annually | Tous les ans | 0 0 1 1 * |
|
||||
| @monthly | Tous les mois | 0 0 1 * * |
|
||||
| @weekly | Toutes les semaines | 0 0 * * 0 |
|
||||
| @daily | Tous les jours | 0 0 * * * |
|
||||
| @midnight | Toutes les nuits | 0 0 * * * |
|
||||
| @hourly | Toutes les heures | 0 * * * * |
|
||||
|
||||
|
||||
===== - Éditer la tables des tâches =====
|
||||
|
||||
Éditer la liste des tâches pour l'utilisateur connecté
|
||||
|
||||
<code>
|
||||
crontab -e
|
||||
</code>
|
||||
|
||||
L'éditeur par défaut est exécuté pour éditer la table des tâches. Il est modifiable grâce à la variable d'environnement :
|
||||
<code>
|
||||
$ export EDITOR=nano
|
||||
</code>
|
||||
|
||||
|
||||
|
||||
===== - Supprimer la tables des tâches =====
|
||||
|
||||
Supprimer la liste des tâches pour l'utilisateur connecté
|
||||
|
||||
<code>
|
||||
crontab -r
|
||||
</code>
|
||||
|
||||
|
||||
|
||||
===== - Remplacer la tables des tâches =====
|
||||
|
||||
Remplacer la liste des tâches pour l'utilisateur connecté par une nouvelle table contenu dans ''<fichier>''
|
||||
|
||||
<code>
|
||||
crontab <fichier>
|
||||
</code>
|
||||
|
||||
|
||||
|
||||
===== - Journalisation =====
|
||||
|
||||
La sortie standard pour une tache **cron** est l'envoi d'un mail. Pour modifier la sortie, il faut utiliser la syntaxe suivante :
|
||||
|
||||
<code>
|
||||
mm hh jj MMM JJJ tâche > fichier1 2> fichier2
|
||||
</code>
|
||||
|
||||
* ''fichier1'' contient la sortie standard
|
||||
* ''fichier2'' contient l'erreur standard
|
||||
|
||||
Par exemple, pour ne rien afficher :
|
||||
<code>
|
||||
>/dev/null 2>&1
|
||||
</code>
|
||||
|
||||
**Afficher l'horaire de la dernière tâche exécutée** pour l'ensemble des utilisateurs :
|
||||
<code>
|
||||
ls -lut /etc/init.d/cron
|
||||
</code>
|
||||
|
||||
**Extraire du journal du système** les informations concernant la table **cron** :
|
||||
<code>
|
||||
grep -w cron /var/log/syslog
|
||||
</code>
|
||||
|
||||
|
||||
===== - + d'infos =====
|
||||
|
||||
Les informations de planification sont stockées dans un fichier relatif à l'utilisateur. Par exemple :
|
||||
* ''/var/spool/cron/crontabs/<utilisateur>'' sous Debian, MX Linux
|
||||
* ''/var/spool/cron/<utilisateur>'' sous Red Hat, Fedora et Cent OS
|
||||
|
||||
En plus, il existe un table cron centralisée dans ''/etc/crontab''.
|
||||
|
||||
Pour un poste de travail ne fonctionnant pas forcément toute une journée, l'application **anacron** permet de lancer les commandes qui dû l'être lorsque l'ordinateur était éteint.
|
||||
|
||||
100
data/pages/informatique/linux/commandes/dd.txt
Normal file
100
data/pages/informatique/linux/commandes/dd.txt
Normal file
@@ -0,0 +1,100 @@
|
||||
====== dd ======
|
||||
{{tag>"Linux commande"}}
|
||||
|
||||
dd permet de **copier** et **convertir des fichiers de type block**
|
||||
|
||||
**dd** signifie **Data Destroyer** ou **Data Dump** ou **Dataset Definition**
|
||||
|
||||
Il est possible d'utiliser la commande **ddrescue** qui reprend la copie en cas d'arrêt intempestif.
|
||||
|
||||
**dd** permet de reproduire des zones de disque qui ne font pas partie d'un système de fichier tels que le **secteur de démarrage** (le MBR), les **tables de partition**, les **traces laissées sur le disque par des fichiers effacés**, etc... L'un de ses emplois les plus importants est donc la création d'une copie de sauvegarde exacte d'une partition.
|
||||
|
||||
Le programme ''dd'' lance deux tâches asynchrones, d'une part de lecture et d'autre part d'écriture, contrairement à ''cp'' qui copie un fichier de façon séquentielle (lecture d'une partie du fichier sur un premier périphérique, puis copie sur le second).
|
||||
|
||||
===== - Exemples d'utilisation =====
|
||||
|
||||
==== - Créer une clé USB bootable ====
|
||||
|
||||
Pour créer une clé USB bootable à partir d'une image ISO.
|
||||
|
||||
On considère :
|
||||
* ''/dev/sdX'' la clé non montée
|
||||
* ''debian.iso'' est l'image ISO présent dans le dossier courant
|
||||
|
||||
<code>
|
||||
# dd if=debian.iso of=/dev/sdX bs=1M; sync
|
||||
</code>
|
||||
|
||||
==== - Réaliser une image d'un DVD ====
|
||||
|
||||
Créé une image ISO de sauvegarde d'un CD ou d'un DVD :
|
||||
|
||||
On considère :
|
||||
* ''/dev/cdrom'' le chemin d'accès au DVD
|
||||
* ''debian.iso'' est le nom de l'image ISO
|
||||
|
||||
<code>
|
||||
$ dd if=/dev/cdrom of=debian.iso
|
||||
</code>
|
||||
|
||||
|
||||
==== - Découper un fichier ====
|
||||
|
||||
Pour découper un fichier en tranches de 100 Mio.
|
||||
|
||||
On considère :
|
||||
* ''grosfichier'' le nom du fichier à découper
|
||||
* ''grosfichier-part1'' le nom du 1er fichier de 100 Mio.
|
||||
* ''grosfichier-part2'' le nom du 2nd fichier des 100 Mio suivant.
|
||||
|
||||
<code>
|
||||
$ dd bs=10K count=10K if=grosfichier of=grosfichier-part1
|
||||
$ dd bs=10K count=10K skip=10K if=grosfichier of=grosfichier-part2
|
||||
$ dd bs=10K count=10K skip=20K if=grosfichier of=grosfichier-part3
|
||||
$ dd bs=10K count=10K skip=30K if=grosfichier of=grosfichier-part4
|
||||
</code>
|
||||
|
||||
Remarque, la commande ''split'' aurait été plus appropriée.
|
||||
|
||||
==== - Copier la table MBR ====
|
||||
|
||||
Pour faire une copie du MBR (table des partitions principales comprises) d'un disque.
|
||||
|
||||
On considère :
|
||||
* ''/dev/hda'' le disque dur contenant le MBR
|
||||
* ''full-mbr.bin'' le nom du fichier contant le MBR sauvegardé
|
||||
|
||||
<code>
|
||||
$ dd if=/dev/hda of=full-mbr.bin bs=512 count=1
|
||||
</code>
|
||||
|
||||
|
||||
==== - Effacer un disque dur avec des zéros ====
|
||||
|
||||
Pour détruire les données d'un disque dur ''hda'' en le remplissant de zéros.
|
||||
|
||||
<code>
|
||||
$ dd if=/dev/zero of=/dev/hda
|
||||
</code>
|
||||
|
||||
Remarque, la commande ''shred'' aurait été plus approprié.
|
||||
|
||||
|
||||
|
||||
==== - Tester le débit des disques dur avec dd ====
|
||||
|
||||
Sous Linux, la commande ''dd'' peut être utilisée pour une mesure de performance en lecture et écriture séquentielle.
|
||||
|
||||
Pour se concentrer sur l'écriture des données sur un disque, la source des informations sera une suite de zero disponible depuis le chemin ''/dev/zero''. Si nous voulions mesurer la performance du disque, il aurait fallu écrire directement sur le chemin du disque (par exemple of=/dev/sda), mais cela effacerait le contenu du disque. En indiquant le chemin d'un fichier ''of=/media/disk_6/test'', nous devons passer par le systèmes de gestion de fichiers, qui peut nous ralentir. Mais cela n’enlèvera pas les conditions réelles que nous pouvons avoir avec un disque.
|
||||
|
||||
En utilisant ''if=/dev/zero et bs=1G'', Linux aura besoin de 1GB d'espace disponible dans la RAM. Si vous n'avez pas suffisamment d'espace disponible, pensez à réduire cette valeur, par exemple à 512MB.
|
||||
|
||||
<code bash>
|
||||
$ dd if=/dev/zero of=/media/disk_6/testfile bs=1G count=1 oflag=direct
|
||||
</code>
|
||||
|
||||
|
||||
===== - Biblio =====
|
||||
|
||||
* [[https://www.gnu.org/software/coreutils/dd]]
|
||||
* [[https://fr.wikipedia.org/wiki/Dd_(Unix)]]
|
||||
60
data/pages/informatique/linux/commandes/df.txt
Normal file
60
data/pages/informatique/linux/commandes/df.txt
Normal file
@@ -0,0 +1,60 @@
|
||||
====== df ======
|
||||
{{ :dummy.png?75x75|Afficher l'espace disque utilisé et disponible sur les systèmes de fichiers montés}}
|
||||
|
||||
La commande ''df'' est utilisée sous Linux pour afficher l'**espace disque utilisé et disponible** sur les systèmes de fichiers montés. Elle permet de connaître l'espace total, l'espace utilisé, l'espace disponible et le pourcentage d'utilisation de chaque système de fichiers.
|
||||
|
||||
La sortie de la commande **df** est présentée en tableau avec une ligne pour chaque système de fichiers monté. Les colonnes du tableau indiquent l'espace total, l'espace utilisé, l'espace disponible, l'utilisation en pourcentage et le point de montage associé à chaque système de fichiers.
|
||||
|
||||
<panel type="default" title="Exemple de résultat" subtitle="de la commande df" icon="fa fa-laptop">
|
||||
<code>
|
||||
Sys. de fichiers blocs de 1K Utilisé Disponible Uti% Monté sur
|
||||
devtmpfs 4096 0 4096 0% /dev
|
||||
tmpfs 8148596 0 8148596 0% /dev/shm
|
||||
tmpfs 3259440 2332 3257108 1% /run
|
||||
/dev/sda2 60718940 40851564 16750528 71% /
|
||||
/dev/loop0 128 128 0 100% /var/lib/snapd/snap/bare/5
|
||||
/dev/loop1 64768 64768 0 100% /var/lib/snapd/snap/core20/1738
|
||||
/dev/loop5 409088 409088 0 100% /var/lib/snapd/snap/obs-studio/1284
|
||||
/dev/loop4 93952 93952 0 100% /var/lib/snapd/snap/gtk-common-themes/1535
|
||||
/dev/loop3 64896 64896 0 100% /var/lib/snapd/snap/core20/1778
|
||||
/dev/loop6 50816 50816 0 100% /var/lib/snapd/snap/snapd/17883
|
||||
/dev/loop2 83328 83328 0 100% /var/lib/snapd/snap/gtk-common-themes/1534
|
||||
/dev/sda1 485330 328177 127457 73% /boot
|
||||
/dev/sdb2 446572352 349334928 74479488 83% /home
|
||||
/dev/sdc 122486728 876400 115342204 1% /home/cedric24c/_tmp
|
||||
tmpfs 1629716 324 1629392 1% /run/user/1000
|
||||
tmpfs 1629716 52 1629664 1% /run/user/0
|
||||
|
||||
</code>
|
||||
</panel>
|
||||
Par défaut, la commande df affiche les informations en octets, mais il est possible de spécifier d'autres unités telles que Ko, Mo ou Go. La commande df peut également être utilisée avec plusieurs options pour modifier son comportement, comme afficher les systèmes de fichiers inaccessibles ou ne pas afficher les systèmes de fichiers de type "tmpfs".
|
||||
|
||||
Voici un exemple de commande "df" pour afficher l'utilisation de l'espace disque sur les partitions montées et exclure les systèmes de fichiers "tmpfs", vous pouvez utiliser l'option ''-x'' suivie d'une liste de types de système de fichiers à exclure :
|
||||
|
||||
df -x tmpfs -h
|
||||
|
||||
<panel type="default" title="Exemple de résultat" subtitle="de la commande df" icon="fa fa-laptop">
|
||||
<code>
|
||||
Sys. de fichiers Taille Utilisé Dispo Uti% Monté sur
|
||||
devtmpfs 4,0M 0 4,0M 0% /dev
|
||||
/dev/sda2 58G 39G 16G 71% /
|
||||
/dev/loop0 128K 128K 0 100% /var/lib/snapd/snap/bare/5
|
||||
/dev/loop1 64M 64M 0 100% /var/lib/snapd/snap/core20/1738
|
||||
/dev/loop5 400M 400M 0 100% /var/lib/snapd/snap/obs-studio/1284
|
||||
/dev/loop4 92M 92M 0 100% /var/lib/snapd/snap/gtk-common-themes/1535
|
||||
/dev/loop3 64M 64M 0 100% /var/lib/snapd/snap/core20/1778
|
||||
/dev/loop6 50M 50M 0 100% /var/lib/snapd/snap/snapd/17883
|
||||
/dev/loop2 82M 82M 0 100% /var/lib/snapd/snap/gtk-common-themes/1534
|
||||
/dev/sda1 474M 321M 125M 73% /boot
|
||||
/dev/sdb2 426G 334G 72G 83% /home
|
||||
/dev/sdc 117G 856M 110G 1% /home/cedric24c/_tmp
|
||||
</code>
|
||||
</panel>
|
||||
|
||||
Cette commande affiche l'utilisation de l'espace disque pour tous les systèmes de fichiers montés, sauf pour les systèmes de fichiers de type "tmpfs", en utilisant des unités plus lisibles pour l'utilisateur, telles que Ko, Mo ou Go.
|
||||
|
||||
L'option ''-x'' est suivie de la liste des types de systèmes de fichiers à exclure, séparés par des virgules. Si vous souhaitez exclure d'autres types de systèmes de fichiers, vous pouvez les ajouter à la liste.
|
||||
|
||||
--- //[[user:cedricabonnel]] & [[user:cpt]]//
|
||||
|
||||
|
||||
165
data/pages/informatique/linux/commandes/dnf.txt
Normal file
165
data/pages/informatique/linux/commandes/dnf.txt
Normal file
@@ -0,0 +1,165 @@
|
||||
====== dnf ======
|
||||
{{ :dummy.png?75x75|DNF est un outil pour gérer les paquets sur les systèmes Linux qui utilisent RPM, et il facilite grandement la gestion des dépendances et des mises à jour de logiciels.}}
|
||||
|
||||
----
|
||||
|
||||
DNF signifie "Dandified Yum", et c'est un gestionnaire de paquets pour les systèmes d'exploitation Linux utilisant RPM (Red Hat Package Manager). Il est principalement utilisé pour gérer les paquets et les dépendances sur les distributions Fedora, CentOS et Red Hat Enterprise Linux.
|
||||
|
||||
Avec DNF, les utilisateurs peuvent installer, mettre à jour, désinstaller et rechercher des paquets sur leur système. Il peut également gérer les dépendances entre les paquets, de sorte que les utilisateurs n'ont pas à s'occuper de la résolution des dépendances manuellement.
|
||||
|
||||
===== Informations concernant les fichiers =====
|
||||
|
||||
* **Binaire** : ''/usr/bin/dnf''
|
||||
* **Fichiers de cache** : ''/var/cache/dnf''
|
||||
* **Configuration principale** : ''/etc/dnf/dnf.conf''
|
||||
* **Configuration des dépôts** : ''/etc/yum.repos.d/''
|
||||
|
||||
===== Configurer un proxy pour tous les utilisateurs =====
|
||||
|
||||
Parfois, lorsque vous travaillez dans un environnement réseau limité, vous devez configurer un proxy pour accéder à Internet. Vous pouvez également configurer un cache en ligne, également appelé //proxy cache// qui sera utilisé pour stocker des copies des paquets demandées afin d'être réutilisés ultérieurement pas d'autres machines. Voici comment configurer un proxy pour tous les utilisateurs et pour un utilisateur spécifique sur Fedora en utilisant DNF.
|
||||
|
||||
Pour configurer un proxy pour tous les utilisateurs, vous devez modifier le fichier ''/etc/dnf/dnf.conf''.
|
||||
|
||||
<callout icon="fa fa-slack">
|
||||
Ouvrez ce fichier en mode édition en utilisant la commande suivante :
|
||||
|
||||
<code>
|
||||
sudo nano /etc/dnf/dnf.conf
|
||||
</code>
|
||||
|
||||
Ajoutez les lignes suivantes pour configurer un proxy simple :
|
||||
|
||||
<code>
|
||||
proxy=http://192.168.100.5:3128/
|
||||
</code>
|
||||
|
||||
Si le proxy nécessite une identification, ajoutez également les lignes suivantes :
|
||||
<code>
|
||||
proxy=http://192.168.100.5:3128/
|
||||
proxy_username=vivek
|
||||
proxy_password=secretePasswordHere
|
||||
</code>
|
||||
</callout>
|
||||
|
||||
<callout icon="fa fa-slack">
|
||||
Enregistrez et fermez le fichier. À partir de maintenant, tous les utilisateurs sur votre système seront en mesure d'utiliser le proxy pour accéder à Internet en utilisant DNF.
|
||||
</callout>
|
||||
|
||||
C'est tout! Vous savez maintenant comment configurer un proxy avec DNF pour tous les utilisateurs sur Fedora. En suivant les étapes décrites ci-dessus, vous pouvez facilement accéder à Internet en utilisant DNF même dans un environnement réseau limité.
|
||||
|
||||
===== Configurer un proxy pour un utilisateur spécifique =====
|
||||
|
||||
Pour configurer un proxy pour un utilisateur spécifique, vous devez ajouter les lignes suivantes dans le fichier ''~/.bash_profile'' ou ''~/.bashrc'' :
|
||||
|
||||
<code>
|
||||
export http_proxy="http://vivek:secretePassword@192.168.100.5:3128"
|
||||
</code>
|
||||
|
||||
Le fichier ''~/.bash_profile'' est utilisé pour les utilisateurs **non-root**, tandis que le fichier ''~/.bashrc'' est lu à chaque démarrage de la session utilisateur. Il est recommandé de redémarrer la session utilisateur après avoir effectué des modifications pour que les modifications prennent effet.
|
||||
|
||||
C'est tout! Vous savez maintenant comment configurer un proxy avec DNF pour un utilisateur spécifique sur Fedora. En suivant les étapes décrites ci-dessus, vous pouvez facilement accéder à Internet en utilisant DNF même dans un environnement réseau limité.
|
||||
===== Rechercher un paquet installé =====
|
||||
|
||||
L'option "installed" spécifie à DNF de n'afficher que les paquets installés sur le système :
|
||||
|
||||
dnf list installed
|
||||
|
||||
--
|
||||
|
||||
Lister tous les paquets installés sur votre système qui correspondent à la expression régulière "krb?-" :
|
||||
|
||||
dnf list installed "krb?-*"
|
||||
|
||||
L'expression régulière "krb?-*" signifie que DNF va rechercher tous les paquets dont le nom commence par "krb" suivi d'un caractère unique, puis suivi d'un tiret et de tout ce qui suit. Cela signifie que tous les paquets qui ont un nom similaire à "krb-xxx" ou "krb-yyy" seront listés par la commande.
|
||||
|
||||
===== Surveiller les mises à jour disponibles sur Fedora DNF =====
|
||||
|
||||
Pour surveiller les mises à jour disponibles sur votre système Fedora utilisant DNF, vous pouvez utiliser un script **bash** utilisant ''dnf check-update'' sans **droit root**.
|
||||
|
||||
<image shape="thumbnail">
|
||||
{{ :informatique:linux:commandes:pasted:20230213-000058.png }}
|
||||
</image>
|
||||
|
||||
Pour exécuter la commande ''dnf check-update'' en tant que service et mémoriser les informations de mise à jour dans un fichier, vous pouvez utiliser un script **bash** et une tâche **cron**.
|
||||
|
||||
<callout icon="fa fa-slack">
|
||||
Le script ''check_update.sh'' peut être déposé dans n'importe quel répertoire sur votre système, mais il est souvent pratique de le déposer dans un répertoire dédié aux scripts. Certains répertoires communs pour les scripts incluent ''/usr/local/bin/'' (répertoire des binaires locaux).
|
||||
|
||||
Voici un exemple de scripts que vous pouvez utiliser :
|
||||
|
||||
<code BASH check_update.sh>
|
||||
#!/bin/bash
|
||||
|
||||
# Définir le chemin vers le fichier de mise à jour
|
||||
update_file=/var/udpate_file
|
||||
|
||||
# Exécuter la commande de mise à jour et stocker la sortie dans le fichier
|
||||
dnf check-update
|
||||
dnf check-update > $update_file
|
||||
</code>
|
||||
</callout>
|
||||
|
||||
<callout icon="fa fa-slack">
|
||||
Enregistrez ce script dans un fichier, puis rendez-le exécutable en utilisant la commande suivante :
|
||||
|
||||
<code BASH>
|
||||
chmod +x /usr/local/bin/check_update.sh
|
||||
</code>
|
||||
</callout>
|
||||
|
||||
|
||||
<callout icon="fa fa-slack">
|
||||
|
||||
La commande ''touch'' pour créer le fichier **update_file** s'il n'existe pas encore. La commande ''chmod'' avec l'option **644** permet à tous les utilisateurs (propriétaire, utilisateurs du groupe et autres utilisateurs) d'avoir uniquement des autorisations de lecture sur le fichier ''update_file'' :
|
||||
|
||||
<code BASH>
|
||||
sudo touch /var/udpate_file
|
||||
sudo chmod 644 /var/update_file
|
||||
</code>
|
||||
</callout>
|
||||
|
||||
|
||||
<callout icon="fa fa-slack">
|
||||
Ensuite, pour exécuter ce script en tant que service, vous pouvez ajouter une tâche **cron**. Pour ouvrir le fichier de configuration **cron**, utilisez la commande suivante :
|
||||
|
||||
sudo crontab -e
|
||||
|
||||
</callout>
|
||||
|
||||
<callout icon="fa fa-slack">
|
||||
Ajoutez la ligne suivante à ce fichier pour exécuter le script tous les heures :
|
||||
0 */1 * * * /usr/local/bin/check_update.sh
|
||||
|
||||
Cette ligne exécutera le script tous les heures. Vous pouvez ajuster l'heure en fonction de vos besoins.
|
||||
</callout>
|
||||
|
||||
|
||||
<callout icon="fa fa-slack">
|
||||
Pour afficher les informations de mise à jour lors de l'ouverture d'un terminal, vous pouvez ajouter le code suivant à votre fichier de configuration bash **~/.bashrc** :
|
||||
|
||||
<code BASH .bashrc>
|
||||
# Définir le chemin vers le fichier de mise à jour
|
||||
update_file=/var/udpate_file
|
||||
|
||||
# Vérifier si le fichier de mise à jour existe
|
||||
if [ -f $update_file ]; then
|
||||
# Compter le nombre de mises à jour
|
||||
updates=$(($(wc -l < $update_file) - 1))
|
||||
|
||||
# Afficher le nombre de mises à jour en attente
|
||||
echo "Il y a $updates mise(s) à jour en attente."
|
||||
fi
|
||||
</code>
|
||||
|
||||
</callout>
|
||||
|
||||
Après avoir enregistré les modifications, ouvrez un nouveau terminal pour vérifier que les informations de mise à jour s'affichent correctement.
|
||||
|
||||
<callout type="success" icon="true">
|
||||
Retrouver le script d'installation automatique à l'adresse [[https://git.abonnel.fr/cedricAbonnel/scripts-bash/src/branch/main/install_check_update.sh|git.abonnel.fr scripts-bash]]
|
||||
|
||||
Executez la ligne suivante dans votre Terminal :
|
||||
sudo bash -c "$(curl -fsSL https://git.abonnel.fr/cedricAbonnel/scripts-bash/raw/branch/main/install_check_update.sh)"
|
||||
|
||||
</callout>
|
||||
|
||||
49
data/pages/informatique/linux/commandes/double_dollar.txt
Normal file
49
data/pages/informatique/linux/commandes/double_dollar.txt
Normal file
@@ -0,0 +1,49 @@
|
||||
====== $$ ======
|
||||
{{tag>"script linux"}}
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
|
||||
En Bash, ''$$'' est une variable qui contient le PID (Process ID) du processus en cours d'exécution. Cette variable peut être utilisée pour identifier de manière unique un processus ou pour contrôler les processus enfants créés à partir du script.
|
||||
|
||||
Par exemple, vous pouvez utiliser ''$$'' pour créer un fichier journal unique pour chaque instance de votre script Bash en utilisant le PID comme partie du nom du fichier.
|
||||
|
||||
Notez cependant que le PID est une valeur dynamique qui change chaque fois que le processus est exécuté, donc ''$$'' ne doit être utilisé que dans le contexte du processus en cours d'exécution.
|
||||
|
||||
Pour utiliser "$$" correctement dans le contexte du processus en cours d'exécution, vous pouvez le stocker dans une variable dès le début de votre script Bash. De cette façon, la variable contiendra le PID du processus en cours d'exécution tout au long du script, même si le PID change pendant l'exécution du script.
|
||||
|
||||
Voici un exemple de code Bash montrant comment stocker "$$" dans une variable :
|
||||
<code BASH>
|
||||
#!/bin/bash
|
||||
|
||||
# stocker le PID dans une variable
|
||||
current_pid=$$
|
||||
|
||||
# afficher le PID
|
||||
echo "Le PID du processus en cours d'exécution est : $current_pid"
|
||||
|
||||
# faire quelque chose d'autre dans le script...
|
||||
|
||||
</code>
|
||||
|
||||
Ensuite, vous pouvez utiliser la variable ''current_pid'' tout au long de votre script pour référencer le PID du processus en cours d'exécution.
|
||||
|
||||
Notez que si votre script crée des processus enfants, le PID de ces processus enfants sera différent du PID du processus parent. Dans ce cas, vous pouvez utiliser ''$$'' pour référencer le PID du processus parent, et utiliser un autre mécanisme pour référencer le PID des processus enfants, comme par exemple en stockant le PID de chaque processus enfant dans un tableau ou un fichier.
|
||||
|
||||
|
||||
Pour connaître le PID du processus parent dans un script Bash, vous pouvez utiliser la variable spéciale ''$PPID''. Cette variable contient le PID du processus parent qui a créé le processus en cours d'exécution.
|
||||
|
||||
Voici un exemple de code Bash qui utilise ''$PPID'' pour afficher le PID du processus parent :
|
||||
|
||||
<code BASH>
|
||||
#!/bin/bash
|
||||
|
||||
# stocker le PID du processus parent dans une variable
|
||||
parent_pid=$PPID
|
||||
|
||||
# afficher le PID du processus parent
|
||||
echo "Le PID du processus parent est : $parent_pid"
|
||||
|
||||
# faire quelque chose d'autre dans le script...
|
||||
</code>
|
||||
|
||||
Notez que ''$PPID'' ne fonctionne que si le processus en cours d'exécution a été créé par un processus parent dans le même système d'exploitation. Si le processus en cours d'exécution a été créé par un autre système d'exploitation ou un autre type de processus, ''$PPID'' ne sera pas défini ou aura une valeur incorrecte.
|
||||
|
||||
11
data/pages/informatique/linux/commandes/dpkg.txt
Normal file
11
data/pages/informatique/linux/commandes/dpkg.txt
Normal file
@@ -0,0 +1,11 @@
|
||||
====== dpkg ======
|
||||
{{ :dummy.png?75x75|}}
|
||||
|
||||
Le programme ''dpkg'' est un outil de gestion de paquets sous Linux qui est utilisé pour installer, configurer, supprimer et gérer des paquets logiciels sur un système **Debian** ou dérivé de **Debian**. Il est utilisé en ligne de commande et fournit une interface de bas niveau pour travailler avec des fichiers de paquets **Debian**.
|
||||
|
||||
En utilisant **dpkg**, vous pouvez installer des paquets de logiciels localement à partir de fichiers de paquets **Debian** (fichiers ''.deb''), ainsi que gérer les paquets installés sur votre système, tels que les lister, les supprimer ou les mettre à jour.
|
||||
|
||||
''dpkg'' est utilisé en conjonction avec d'autres outils de gestion de paquets, tels que [[apt|apt]] ou [[..:..:applications:apt-get|apt-get]].
|
||||
|
||||
--- //[[user:cedricabonnel]]//
|
||||
|
||||
30
data/pages/informatique/linux/commandes/du.txt
Normal file
30
data/pages/informatique/linux/commandes/du.txt
Normal file
@@ -0,0 +1,30 @@
|
||||
====== du ======
|
||||
|
||||
|
||||
Exemple d'analyse d'une arborescence d'un Raspbian 10 :
|
||||
<code>
|
||||
$ sudo du -h --max-depth=1 /
|
||||
0 /dev
|
||||
8,6M /bin
|
||||
16K /lost+found
|
||||
41M /opt
|
||||
343M /lib
|
||||
3,4M /etc
|
||||
4,0K /mnt
|
||||
614M /usr
|
||||
96K /home
|
||||
4,0K /srv
|
||||
17M /run
|
||||
52M /boot
|
||||
36K /tmp
|
||||
32K /root
|
||||
260M /var
|
||||
8,8M /sbin
|
||||
du: impossible d'accéder à '/proc/23168/task/23168/fd/3': Aucun fichier ou dossier de ce type
|
||||
du: impossible d'accéder à '/proc/23168/task/23168/fdinfo/3': Aucun fichier ou dossier de ce type
|
||||
du: impossible d'accéder à '/proc/23168/fd/4': Aucun fichier ou dossier de ce type
|
||||
du: impossible d'accéder à '/proc/23168/fdinfo/4': Aucun fichier ou dossier de ce type
|
||||
0 /proc
|
||||
0 /sys
|
||||
|
||||
</code>
|
||||
22
data/pages/informatique/linux/commandes/echo.txt
Normal file
22
data/pages/informatique/linux/commandes/echo.txt
Normal file
@@ -0,0 +1,22 @@
|
||||
====== echo ======
|
||||
|
||||
La commande ''echo'' est couramment utilisée dans les scripts shell et dans les lignes de commande Unix/Linux pour afficher du texte ou des variables à la sortie standard (généralement la console ou le terminal). Elle est principalement utilisée pour produire une sortie textuelle à des fins de débogage, de communication avec l'utilisateur ou d'autres opérations d'affichage.
|
||||
|
||||
La syntaxe de base de la commande ''echo'' est la suivante :
|
||||
|
||||
<code bash>
|
||||
echo [options] [texte ou variables]
|
||||
</code>
|
||||
|
||||
- ''[options]'' : Vous pouvez spécifier des options pour modifier le comportement de la commande ''echo'', bien que la plupart des implémentations de shell n'en aient pas beaucoup. Par exemple, ''echo -n'' supprime la nouvelle ligne qui est généralement ajoutée à la fin de la sortie.
|
||||
|
||||
- ''[texte ou variables]'' : Vous pouvez fournir du texte à afficher ou des variables dont la valeur doit être affichée. Vous pouvez utiliser des guillemets simples (''''') ou doubles (''"'') pour encadrer le texte, selon que vous souhaitez ou non interpréter des variables à l'intérieur (les guillemets doubles permettent l'interpolation des variables).
|
||||
|
||||
Voici quelques exemples d'utilisation de la commande ''echo'' :
|
||||
|
||||
<code bash>
|
||||
echo "Bonjour, monde!" # Affiche le texte "Bonjour, monde!" avec une nouvelle ligne.
|
||||
echo -n "Bonjour, " ; echo "monde!" # Affiche le texte "Bonjour, monde!" sans nouvelle ligne entre les deux parties.
|
||||
nom="Alice"
|
||||
echo "Bienvenue, $nom" # Affiche "Bienvenue, Alice" en interprétant la variable $nom.
|
||||
</code>
|
||||
50
data/pages/informatique/linux/commandes/exit.txt
Normal file
50
data/pages/informatique/linux/commandes/exit.txt
Normal file
@@ -0,0 +1,50 @@
|
||||
====== exit ======
|
||||
{{ :dummy.png?75x75|commande système}}
|
||||
|
||||
La commande ''exit'' est une commande utilisée dans le shell BASH pour quitter une session de terminal. Lorsque vous exécutez la commande ''exit'', le shell BASH se termine et vous êtes retourné à l'invite de commande de votre système d'exploitation.
|
||||
|
||||
La commande ''exit'' prend également un code de sortie en argument optionnel. Par exemple, si vous exécutez ''exit 0'', cela signifie que le programme ou le script qui utilise le shell BASH s'est terminé sans erreur. Si vous spécifiez un autre code de sortie, cela indique qu'une erreur s'est produite lors de l'exécution du programme ou du script.
|
||||
|
||||
La commande ''exit'' ne fonctionne que dans le shell BASH et ne peut pas être utilisée dans d'autres shells de terminal.
|
||||
|
||||
La commande ''exit'' permet de quitter la session courante du shell BASH, mais elle ne ferme pas directement le terminal ou l'émulateur de terminal que vous utilisez. Une fois que vous avez exécuté la commande ''exit'', la session BASH actuelle se termine et vous êtes retourné à l'interface du terminal.
|
||||
|
||||
Cependant, si vous utilisez un terminal graphique (comme GNOME Terminal, KDE Konsole, ou iTerm2), la fermeture de la session BASH peut entraîner la fermeture du terminal si aucune autre session ou onglet n'est ouvert. Dans ce cas, la commande ''exit'' peut sembler fermer le terminal, mais en réalité, elle ne ferme que la session du shell en cours.
|
||||
|
||||
La manière dont un terminal gère la fermeture des sessions et des onglets peut varier selon l'application et les paramètres de configuration.
|
||||
|
||||
-- Dans le shell BASH, les commandes ''exit'' et [[informatique:linux:commandes:logout|logout]] ont des fonctions similaires, mais elles ne sont pas exactement les mêmes.
|
||||
|
||||
La commande ''exit'' permet de quitter la session du shell BASH en cours. Elle ferme le shell et retourne à l'invite de commande du système d'exploitation. Si vous exécutez la commande ''exit'' dans une session de shell, elle se termine immédiatement.
|
||||
|
||||
La commande ''logout'' est souvent utilisée pour se déconnecter d'une session de terminal interactive. Elle peut être utilisée pour se déconnecter d'une session de shell, mais elle peut également fermer une session de terminal en fonction de la configuration du système.
|
||||
|
||||
Dans de nombreux systèmes, ''logout'' et ''exit'' ont un effet similaire car ils quittent la session du shell. Cependant, il est possible que ces commandes aient des effets différents selon la configuration du système ou le shell utilisé. Par exemple, dans le shell Zsh, la commande ''logout'' peut être utilisée pour se déconnecter de la session de shell, mais elle ne peut pas être utilisée pour quitter une fenêtre de terminal.
|
||||
|
||||
===== Exemples =====
|
||||
|
||||
-- Supposons que vous avez ouvert un terminal et que vous êtes actuellement connecté en tant que utilisateur ''alice''. Vous pouvez exécuter la commande ''exit'' pour quitter la session du shell BASH en cours et retourner à l'invite de commande de votre système d'exploitation, comme ceci :
|
||||
|
||||
<code BASH>
|
||||
alice@ubuntu:~$ exit
|
||||
logout
|
||||
</code>
|
||||
|
||||
Après avoir exécuté la commande ''exit'', vous voyez l'affichage ''logout'' qui indique que vous avez quitté la session du shell BASH.
|
||||
|
||||
-- Vous pouvez également utiliser la commande ''exit'' avec un code de sortie en argument. Par exemple, si vous avez un script qui effectue une tâche spécifique et que vous voulez que le code de sortie soit ''0'' pour indiquer que le script s'est terminé sans erreur, vous pouvez utiliser la commande ''exit 0'', comme ceci :
|
||||
|
||||
<code BASH>
|
||||
#!/bin/bash
|
||||
|
||||
# Votre script ici
|
||||
|
||||
# Quitter le script avec un code de sortie 0 (aucune erreur)
|
||||
exit 0
|
||||
</code>
|
||||
|
||||
Dans cet exemple, la commande ''exit 0'' est utilisée pour quitter le script et renvoyer le code de sortie ''0''.
|
||||
|
||||
===== Astuces =====
|
||||
|
||||
Dans un terminal ou une console, le raccourci <key>Ctrl</key> + <key>D</key> est utilisé pour envoyer un signal de fin de fichier (''EOF''). Cela signifie que lorsque vous tapez ce raccourci, le terminal ou la console interprète cela comme la fin de l'entrée de données et affiche le résultat ou quitte l'interface de commande si rien n'est entré.
|
||||
14
data/pages/informatique/linux/commandes/expand.txt
Normal file
14
data/pages/informatique/linux/commandes/expand.txt
Normal file
@@ -0,0 +1,14 @@
|
||||
====== expand ======
|
||||
|
||||
~~TechArticle~~
|
||||
|
||||
C'est un programme Linux présent dans ''/usr/bin/''.
|
||||
|
||||
Le programme ''expand'' a pour fonction de convertir les tabulations (''\t'') en espaces. Il lit un fichier texte en entrée et écrit le fichier texte en sortie, en remplaçant toutes les tabulations par un nombre spécifié d'espaces (par défaut, huit).
|
||||
|
||||
===== Exemples =====
|
||||
|
||||
expand -4 input.txt > output.txt
|
||||
|
||||
Cet exemple prend le contenu du fichier ''input.txt'', le modifie pour remplacer chaque tabulation par quatre espaces, puis écrit le résultat dans le fichier ''output.txt''.
|
||||
|
||||
32
data/pages/informatique/linux/commandes/fdupes.txt
Normal file
32
data/pages/informatique/linux/commandes/fdupes.txt
Normal file
@@ -0,0 +1,32 @@
|
||||
====== fdupes ======
|
||||
|
||||
**FDupes** est un programme en ligne de commande utilisé pour identifier et supprimer les fichiers en double sur un système de fichiers. Il s'agit d'un outil open source couramment utilisé sur les systèmes d'exploitation de type Unix, y compris Linux. **FDupes** fonctionne en **comparant les tailles de fichiers** et en **calculant des empreintes MD5** pour identifier les fichiers avec des contenus identiques.
|
||||
|
||||
Les utilisateurs peuvent spécifier divers paramètres pour affiner la recherche, tels que l'exclusion de certains dossiers, la comparaison de fichiers en fonction de la taille ou du contenu, et la possibilité de conserver un exemplaire de chaque fichier en double.
|
||||
|
||||
===== Installer FDupes =====
|
||||
|
||||
<code>
|
||||
sudo apt install fdupes
|
||||
</code>
|
||||
|
||||
===== Recherche Basique de Doublons =====
|
||||
|
||||
<code>
|
||||
fdupes /chemin/du/dossier
|
||||
</code>
|
||||
|
||||
Cette commande recherche les fichiers en double dans le dossier spécifié et ses sous-dossiers.
|
||||
|
||||
===== Recherche de Doublons dans Plusieurs Dossiers =====
|
||||
|
||||
<code>
|
||||
fdupes /dossier1 /dossier2
|
||||
</code>
|
||||
|
||||
Cette commande compare les fichiers dans ''dossier1'' et ''dossier2'', identifiant les doublons entre ces deux dossiers.
|
||||
|
||||
|
||||
|
||||
|
||||
--- //[[user:cedricabonnel]]//
|
||||
18
data/pages/informatique/linux/commandes/file.txt
Normal file
18
data/pages/informatique/linux/commandes/file.txt
Normal file
@@ -0,0 +1,18 @@
|
||||
====== file ======
|
||||
|
||||
La commande "file" sous Linux est une commande en ligne de commande qui permet de déterminer le type de fichier d'un fichier donné. Elle peut être utilisée pour identifier le type de contenu d'un fichier, qu'il s'agisse d'un fichier texte, d'une image, d'un fichier audio ou vidéo, ou de tout autre type de fichier.
|
||||
|
||||
La syntaxe de base de la commande est la suivante :
|
||||
|
||||
file [options] nom_du_fichier
|
||||
|
||||
Cette commande retourne une brève description du type de fichier et du format utilisé
|
||||
|
||||
Exemple :
|
||||
<code>
|
||||
$ file /usr/sbin/poweroff
|
||||
/usr/sbin/poweroff: symbolic link to `../bin/systemctl'
|
||||
|
||||
|
||||
</code>
|
||||
|
||||
36
data/pages/informatique/linux/commandes/find.txt
Normal file
36
data/pages/informatique/linux/commandes/find.txt
Normal file
@@ -0,0 +1,36 @@
|
||||
====== find ======
|
||||
{{ :dummy.png?75x75|}}
|
||||
|
||||
La commande **find** sous Linux est utilisée pour rechercher des fichiers et des répertoires dans une hiérarchie de fichiers. Elle est souvent utilisée pour trouver des fichiers en fonction de leur nom, de leur type, de leur taille, de leur date de modification, de leur propriétaire ou de leurs permissions.
|
||||
|
||||
La commande **find** est très puissante et flexible, elle permet de trouver des fichiers dans toute la hiérarchie de fichiers à partir du répertoire spécifié en paramètre.
|
||||
|
||||
--
|
||||
|
||||
Par exemple, si vous voulez trouver tous les fichiers portant le nom ''exemple.txt'' dans votre répertoire personnel et ses sous-répertoires, vous pouvez utiliser la commande :
|
||||
|
||||
<code BASH>
|
||||
find ~/ -name exemple.txt
|
||||
</code>
|
||||
|
||||
Cette commande cherchera tous les fichiers portant le nom ''exemple.txt'' dans le répertoire personnel et ses sous-répertoires, et affichera leur chemin absolu.
|
||||
|
||||
--
|
||||
|
||||
Pour chercher un fichier avec **find** dont le nom contient "HDR", vous pouvez utiliser l'option ''-name'' suivi d'un motif de recherche qui inclut la chaîne de caractères "HDR". Par exemple :
|
||||
|
||||
<code>
|
||||
find . -type f -name *HDR*
|
||||
</code>
|
||||
|
||||
Dans cet exemple, ''.'' est le chemin courant dans lequel vous voulez rechercher le fichier. L'astérisque (*) est utilisé pour représenter tout texte qui peut se trouver avant et après "HDR" dans le nom du fichier. Cela permet de rechercher tous les fichiers dont le nom contient la chaîne de caractères "HDR", quelle que soit leur position dans le nom.
|
||||
|
||||
Si vous voulez supprimer ces fichiers, vous pouvez utiliser la commande ''rm'' avec l'option ''-f'' pour supprimer les fichiers sans confirmation :
|
||||
|
||||
<code>
|
||||
find . -type f -name *HDR* -exec rm -f {} \;
|
||||
</code>
|
||||
|
||||
Cette commande supprime tous les fichiers trouvés. L'option ''-exec'' permet d'exécuter la commande **rm** pour chaque fichier trouvé, et ''{}'' est remplacé par le nom de chaque fichier. L'option ''-f'' permet de supprimer les fichiers sans confirmation. Le ''\;'' indique la fin de la commande à exécuter pour chaque fichier.
|
||||
|
||||
Cependant, soyez très prudent lors de l'utilisation de la commande **rm**, car une fois les fichiers supprimés, il est très difficile de les récupérer. Vérifiez deux fois avant de lancer cette commande, ou assurez-vous que vous avez une sauvegarde des fichiers importants.
|
||||
9
data/pages/informatique/linux/commandes/free.txt
Normal file
9
data/pages/informatique/linux/commandes/free.txt
Normal file
@@ -0,0 +1,9 @@
|
||||
====== free ======
|
||||
{{tag>"Linux commande"}}
|
||||
{{ :informatique:1200px-gnulinux.jpg?75x75|linux}}
|
||||
|
||||
Afficher l'occupation de la mémoire.
|
||||
|
||||
<code>
|
||||
free -th
|
||||
</code>
|
||||
117
data/pages/informatique/linux/commandes/getfacl.txt
Normal file
117
data/pages/informatique/linux/commandes/getfacl.txt
Normal file
@@ -0,0 +1,117 @@
|
||||
====== getfacl ======
|
||||
{{ :dummy.png?75x75|getfacl}}
|
||||
|
||||
Programme Linux qui retourne les informations ACL (Contrôle d'Accès aux fichiers).
|
||||
|
||||
Il peut s'utiliser de la manière la plus simple :
|
||||
<code>
|
||||
$ getfacl ~
|
||||
</code>
|
||||
|
||||
===== - Installer getfacl =====
|
||||
|
||||
<code>
|
||||
$ sudo apt install acl
|
||||
</code>
|
||||
|
||||
====== - Exemples de retour ======
|
||||
|
||||
---
|
||||
|
||||
Dans un dossier **non** modifié par ''setfacl -d'', nous avons les propriétés suivantes :
|
||||
<code>
|
||||
$ getfacl /mnt/disk_23
|
||||
|
||||
getfacl : suppression du premier « / » des noms de chemins absolus
|
||||
# file: mnt/disk_23
|
||||
# owner: 99
|
||||
# group: 99
|
||||
user::rwx
|
||||
group::rwx
|
||||
other::rwx
|
||||
</code>
|
||||
|
||||
Le résultat obtenu avec la commande ''getfacl'' affiche les informations de contrôle d'accès (ACL) pour le fichier ou le répertoire spécifié. Voici la signification des différentes lignes du résultat :
|
||||
|
||||
* ''# file: mnt/disk_23'': Cette ligne indique le chemin d'accès au fichier ou répertoire dont les ACL sont affichées, dans ce cas précis, le fichier se trouve à ''mnt/disk_23''.
|
||||
|
||||
* ''# owner: 99'': Cette ligne indique l'identifiant du propriétaire du fichier ou du répertoire. Dans cet exemple, le propriétaire a l'ID 99.
|
||||
|
||||
* ''# group: 99'': Cette ligne indique l'identifiant du groupe propriétaire du fichier ou du répertoire. Dans cet exemple, le groupe propriétaire a l'ID 99.
|
||||
|
||||
Ensuite, les lignes suivantes décrivent les droits d'accès pour différentes entités :
|
||||
|
||||
* ''user::rwx'': Cela signifie que l'utilisateur (propriétaire) a les droits de lecture (r), d'écriture (w) et d'exécution (x) sur ce fichier ou répertoire.
|
||||
|
||||
* ''group::rwx'': Cela indique que les membres du groupe propriétaire ont les mêmes droits que l'utilisateur (propriétaire) précédemment mentionné, c'est-à-dire lecture, écriture et exécution.
|
||||
|
||||
* ''other::rwx'': Cela spécifie les droits d'accès pour tous les autres utilisateurs qui ne sont ni le propriétaire ni membres du groupe propriétaire. Dans ce cas, les autres utilisateurs ont également les droits de lecture, écriture et exécution.
|
||||
|
||||
Ainsi, le fichier ou le répertoire ''mnt/disk_23'' a les ACL configurées de manière à permettre au propriétaire, au groupe propriétaire et à tous les autres utilisateurs d'avoir des droits complets de lecture, écriture et exécution sur ce fichier ou répertoire.
|
||||
|
||||
---
|
||||
|
||||
Dans un dossier modifié par ''chmod'', nous avons les propriétés suivantes :
|
||||
<code>
|
||||
$ sudo chmod o-s,g+s,u+s /media/disk_23
|
||||
|
||||
$ sudo setfacl /media/disk_23
|
||||
getfacl : suppression du premier « / » des noms de chemins absolus
|
||||
# file: media/disk_23
|
||||
# owner: 99
|
||||
# group: 99
|
||||
# flags: ss-
|
||||
user::rwx
|
||||
group::rwx
|
||||
other::rwx
|
||||
|
||||
</code>
|
||||
|
||||
Si le résultat affiche la ligne ''# flags: ss-'' après les droits d'accès, cela indique la présence de certains indicateurs de contrôle d'accès spéciaux. Voici la signification de ces indicateurs :
|
||||
|
||||
* ''s'': L'indicateur "s" fait référence à l'ensemble de bits "setuid" ou "setgid". Lorsque l'indicateur "s" est présent pour l'utilisateur (propriétaire) ou le groupe, il indique que l'exécution de ce fichier ou répertoire sera effectuée avec les droits de l'utilisateur ou du groupe propriétaire, respectivement. Cela signifie que lorsque d'autres utilisateurs exécutent ce fichier, il aura les mêmes droits que l'utilisateur propriétaire, et lorsque d'autres fichiers sont créés dans ce répertoire, ils hériteront du groupe propriétaire.
|
||||
|
||||
* ''-'': Le tiret ("-") indique que l'indicateur "s" n'est pas activé. Dans ce cas, il n'y a pas d'ensemble de bits "setuid" ou "setgid" appliqué au fichier ou au répertoire.
|
||||
|
||||
Ainsi, avec l'indicateur "ss-", aucun ensemble de bits "setuid" ou "setgid" n'est activé pour ce fichier ou répertoire. Cela signifie que lorsqu'il est exécuté ou lorsqu'un nouveau fichier est créé dans ce répertoire, il n'y aura pas de changement de l'utilisateur ou du groupe propriétaire associé.
|
||||
|
||||
---
|
||||
|
||||
|
||||
Dans un dossier modifié par ''setfacl -d -m :rwx'', nous avons les propriétés suivantes :
|
||||
|
||||
<code>
|
||||
$ sudo setfacl -d -m :rwx /media/disk_23
|
||||
|
||||
$ getfacl /media/disk_23
|
||||
getfacl : suppression du premier « / » des noms de chemins absolus
|
||||
# file: media/disk_23
|
||||
# owner: 99
|
||||
# group: 99
|
||||
# flags: ss-
|
||||
user::rwx
|
||||
group::rwx
|
||||
other::rwx
|
||||
default:user::rwx
|
||||
default:group::rwx
|
||||
default:other::rwx
|
||||
</code>
|
||||
|
||||
Cela signifie que les droits d'accès par défaut sont définis pour les nouveaux fichiers et répertoires créés à l'intérieur de ce répertoire. Voici leur signification :
|
||||
|
||||
* ''default:user::rwx'' : Cela spécifie que par défaut, les nouveaux fichiers et répertoires créés auront les droits de lecture, écriture et exécution pour le propriétaire.
|
||||
|
||||
* ''default:group::rwx'' : Cela indique que par défaut, les nouveaux fichiers et répertoires auront les mêmes droits de lecture, écriture et exécution pour le groupe propriétaire que le répertoire parent.
|
||||
|
||||
* ''default:other::rwx'' : Cela spécifie que par défaut, les nouveaux fichiers et répertoires auront les droits de lecture, écriture et exécution pour tous les autres utilisateurs qui ne sont pas le propriétaire ni membres du groupe propriétaire.
|
||||
|
||||
En résumé, lorsque vous créez de nouveaux fichiers ou répertoires à l'intérieur de ce répertoire, les droits d'accès par défaut spécifiés ci-dessus seront automatiquement attribués à ces nouveaux éléments. Ces droits d'accès par défaut peuvent être modifiés selon vos besoins.
|
||||
|
||||
---
|
||||
|
||||
<code>
|
||||
default:user:www-data:rwx
|
||||
default:group:www-data:rwx
|
||||
</code>
|
||||
|
||||
Cela indique que par défaut, les nouveaux fichiers et répertoires créés auront "www-data" comme propriétaire et groupe propriétaire, avec les droits de lecture, écriture et exécution (rwx) accordés à la fois au propriétaire et au groupe.
|
||||
38
data/pages/informatique/linux/commandes/getopts.txt
Normal file
38
data/pages/informatique/linux/commandes/getopts.txt
Normal file
@@ -0,0 +1,38 @@
|
||||
====== getopts ======
|
||||
|
||||
La commande ''getopts'' est une commande intégrée (built-in) dans les scripts shell (en particulier dans les shells comme bash) qui permet de traiter facilement les options et les arguments passés en ligne de commande lors de l'exécution d'un script. Elle facilite la gestion des arguments de ligne de commande en permettant aux scripts d'analyser les options spécifiées par l'utilisateur.
|
||||
|
||||
La syntaxe générale de ''getopts'' est la suivante :
|
||||
|
||||
<code bash>
|
||||
getopts options variable
|
||||
</code>
|
||||
|
||||
- ''options'' est une chaîne qui spécifie les options que vous souhaitez gérer dans votre script. Chaque lettre dans cette chaîne représente une option, et si une lettre est suivie d'un deux-points ('':''), cela signifie que l'option attend un argument. Par exemple, ''"ab:c"'' signifie que le script gère les options ''-a'', ''-b'', et ''-c'', où ''-b'' attend un argument.
|
||||
- ''variable'' est la variable que vous déclarez pour stocker la lettre de l'option actuelle pendant le traitement.
|
||||
|
||||
Voici un exemple simple d'utilisation de ''getopts'' dans un script bash :
|
||||
|
||||
<code bash>
|
||||
#!/bin/bash
|
||||
|
||||
while getopts "a:b:c" option; do
|
||||
case "$option" in
|
||||
a)
|
||||
echo "Option -a avec argument: $OPTARG"
|
||||
;;
|
||||
b)
|
||||
echo "Option -b avec argument: $OPTARG"
|
||||
;;
|
||||
c)
|
||||
echo "Option -c sans argument"
|
||||
;;
|
||||
\?)
|
||||
echo "Option invalide: -$OPTARG"
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
done
|
||||
</code>
|
||||
|
||||
Dans cet exemple, le script peut être appelé avec des options comme ''-a valeur'', ''-b autre_valeur'', ou simplement ''-c''. ''getopts'' permet de traiter chaque option de manière séquentielle, en récupérant la lettre de l'option dans la variable ''$option'' et en utilisant un bloc ''case'' pour gérer chaque option spécifiée par l'utilisateur. Si l'utilisateur spécifie une option invalide, le script affiche un message d'erreur et se termine.
|
||||
241
data/pages/informatique/linux/commandes/git.txt
Normal file
241
data/pages/informatique/linux/commandes/git.txt
Normal file
@@ -0,0 +1,241 @@
|
||||
====== git ======
|
||||
{{tag>"script linux"}}
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
|
||||
Git est un système de gestion de versions qui permet de suivre les modifications apportées à des fichiers et de collaborer sur des projets informatiques de manière organisée. Il enregistre l'historique de toutes les modifications, ce qui permet de revenir en arrière en cas d'erreur et de travailler en équipe sur un même code source sans conflits majeurs. En résumé, Git est un outil essentiel pour les développeurs et d'autres personnes travaillant sur des projets informatiques pour gérer et suivre les modifications apportées aux fichiers.
|
||||
|
||||
|
||||
===== - Commandes Git de base =====
|
||||
|
||||
Lorsque vous travaillez uniquement en local avec Git, vous avez généralement besoin d'un ensemble de commandes Git de base pour gérer vos dépôts locaux. Voici quelques-unes des commandes Git les plus couramment utilisées dans ce contexte :
|
||||
* **git init** : Cette commande initialise un nouveau dépôt Git local dans le répertoire courant. Vous l'utiliserez une seule fois au début du projet pour créer un nouveau dépôt.
|
||||
|
||||
* **git clone** : Si vous avez déjà un dépôt distant et que vous souhaitez créer une copie locale de ce dépôt, vous pouvez utiliser la commande **git clone**.
|
||||
|
||||
* **git status** : Cette commande vous permet de vérifier l'état de votre répertoire de travail par rapport au dépôt Git local. Elle vous montre les fichiers modifiés, non suivis, en attente de commit, etc.
|
||||
|
||||
* **git add** : Utilisez cette commande pour mettre des fichiers sous suivi Git (//staging area//) en vue de les inclure dans le prochain commit.
|
||||
|
||||
* **git commit** : Crée un instantané (commit) des modifications enregistrées dans la //staging area//.
|
||||
|
||||
* **git log** : Cette commande affiche l'historique des commits du dépôt local, y compris les messages de commit et les informations sur les auteurs et les dates.
|
||||
|
||||
* **git branch** : Permet de lister les branches disponibles dans votre dépôt local, et de voir sur quelle branche vous vous trouvez actuellement.
|
||||
|
||||
* **git checkout** : Vous permet de passer d'une branche à une autre.
|
||||
|
||||
* **git merge** : Utilisé pour fusionner une branche avec une autre.
|
||||
|
||||
* **git diff** : Vous montre les différences entre deux commits, deux branches ou deux fichiers.
|
||||
|
||||
===== - Commandes Git avec un dépôt distant =====
|
||||
|
||||
Lorsque vous travaillez avec un dépôt distant en plus de votre dépôt local, vous devez utiliser quelques commandes supplémentaires pour synchroniser votre travail avec le dépôt distant. Voici les commandes Git les plus couramment utilisées dans ce contexte :
|
||||
|
||||
* **git remote** : Cette commande vous permet de voir la liste des dépôts distants associés à votre dépôt local.
|
||||
|
||||
* **git fetch** : Utilisez cette commande pour récupérer les dernières modifications du dépôt distant sans les fusionner dans votre branche actuelle. Elle met à jour vos références locales avec les modifications distantes.
|
||||
|
||||
* **git pull** : Cette commande récupère les dernières modifications du dépôt distant et les fusionne automatiquement dans votre branche locale. C'est équivalent à exécuter **git fetch** suivi de **git merge**.
|
||||
|
||||
* **git push** : Utilisez cette commande pour pousser vos commits locaux vers le dépôt distant. Vous devez spécifier la branche locale que vous souhaitez pousser et la branche distante vers laquelle vous voulez la pousser.
|
||||
|
||||
* **git clone** (déjà mentionné) : Utilisez cette commande pour cloner un dépôt distant et créer une copie locale de celui-ci.
|
||||
|
||||
* **git branch** (déjà mentionné) : Vous permet de voir les branches locales et distantes. Utilisez **git branch -r** pour voir les branches distantes.
|
||||
|
||||
* **git checkout** (déjà mentionné) : Vous permet de basculer entre les branches locales et de créer de nouvelles branches.
|
||||
|
||||
* **git merge** (déjà mentionné) : Utilisé pour fusionner les branches locales. Vous pouvez également utiliser git merge pour fusionner des branches distantes dans votre branche actuelle après avoir récupéré les modifications avec **git fetch**.
|
||||
|
||||
* **git remote add** : Si vous souhaitez ajouter un nouveau dépôt distant à votre dépôt local, vous pouvez utiliser cette commande pour l'associer.
|
||||
|
||||
* **git remote remove** : Cette commande vous permet de supprimer un dépôt distant associé à votre dépôt local.
|
||||
|
||||
===== - init =====
|
||||
|
||||
Que vous travailliez en collaboration avec d'autres développeurs ou que vous travailliez uniquement sur votre propre projet, vous effectuerez systématiquement une commande ''git init'' pour initialiser la construction de votre dépôt **Git**. Pour rappel, **Git** sait aussi bien travailler en collaboration à distance qu'en local, car il permet de gérer efficacement les versions de votre code, de suivre l'historique des modifications et de fusionner les contributions de différents collaborateurs, que ce soit sur un dépôt distant ou sur votre propre machine.
|
||||
|
||||
|
||||
===== - gitignore =====
|
||||
|
||||
Le fichier ''.gitignore'' est utilisé pour spécifier des règles sur les fichiers et les répertoires que Git doit ignorer lorsqu'il suit les modifications. Les règles définies dans ce fichier indiquent à Git de ne pas inclure certains fichiers ou dossiers dans les commits, ce qui peut être utile pour exclure des fichiers de configuration locaux, des fichiers de génération automatique, des fichiers temporaires, etc.
|
||||
|
||||
Placer le fichier ''.gitignore'' à la racine du dépôt est courant car cela permet de spécifier des règles d'ignorance qui s'appliquent à l'ensemble du projet. Cependant, il est également possible d'avoir des fichiers ''.gitignore'' dans des sous-répertoires si vous avez besoin de règles d'ignorance spécifiques à ces sous-répertoires.
|
||||
|
||||
|
||||
===== - clone =====
|
||||
|
||||
Ce terme désigne l'action de copier ou télécharger le contenu d'un dépôt dans un dossier de travail. L'adresse d'un dépot Git peut-être par exemple ''https://git.abonnel.fr/cedricAbonnel/scripts-bash''.
|
||||
|
||||
Dans le contexte de la gestion de versions et du contrôle de code source, un dépôt (ou repository en anglais) est un endroit où sont stockées toutes les informations liées à un projet, y compris les fichiers source, l'historique des versions, les branches de développement, etc.
|
||||
|
||||
Donc, lorsque vous souhaitez **cloner** ce lien avec la commande ''git clone'', vous obtenez une copie locale de ce dépôt sur votre machine, ce qui vous permet de travailler sur le projet et de suivre les modifications localement.
|
||||
|
||||
Par exemple :
|
||||
<code bash>
|
||||
cd ~/projets
|
||||
git clone https://git.abonnel.fr/cedricAbonnel/scripts-bash
|
||||
</code>
|
||||
|
||||
Ces commandes créent un dossier appelé "scripts-bash" dans le répertoire "~/projets" et téléchargent les fichiers et dossiers du dépôt, en préservant la structure de l'arborescence telle qu'elle est définie dans le dépôt. Le dossier "~/projets/scripts-bash" devient un dépôt Git local.
|
||||
|
||||
===== - remote =====
|
||||
|
||||
Pour collaborer avec d'autres sur **Git**, vous devez initialement créer un dépôt sur la plateforme de votre choix, que ce soit **GitHub**, **GitLab**, ou un dépôt géré par un service tel que **Gitea**. Une fois que votre dépôt distant est prêt, vous devez configurer votre dépôt local pour qu'il puisse interagir avec le dépôt distant en utilisant la commande ''git remote''. Cette commande permet d'établir le lien entre votre dépôt local et le dépôt distant en spécifiant son emplacement et un nom symbolique pour référencer le dépôt distant.
|
||||
|
||||
Voici quelques exemples d'utilisation de la commande ''git remote'' pour configurer des dépôts distants dans Git :
|
||||
|
||||
1. Ajouter un dépôt distant nommé "origin" avec une URL :
|
||||
<code>
|
||||
git remote add origin https://exemple.com/votre-utilisateur/votre-depot.git
|
||||
</code>
|
||||
|
||||
2. Voir la liste des dépôts distants configurés dans votre dépôt local :
|
||||
<code>
|
||||
git remote -v
|
||||
</code>
|
||||
|
||||
3. Modifier l'URL d'un dépôt distant existant (par exemple, changer l'URL du dépôt "origin") :
|
||||
<code>
|
||||
git remote set-url origin https://exemple.git
|
||||
</code>
|
||||
|
||||
4. Supprimer un dépôt distant spécifique (par exemple, supprimer le dépôt "origin") :
|
||||
<code>
|
||||
git remote remove origin
|
||||
</code>
|
||||
|
||||
5. Renommer un dépôt distant (par exemple, renommer "origin" en "new-origin") :
|
||||
<code>
|
||||
git remote rename origin new-origin
|
||||
</code>
|
||||
|
||||
6. Voir les informations détaillées sur un dépôt distant spécifique (par exemple, "origin") :
|
||||
<code>
|
||||
git remote show origin
|
||||
</code>
|
||||
|
||||
===== - origin =====
|
||||
|
||||
Dans **Git**, "origin" est généralement un nom symbolique utilisé pour faire référence par défaut au dépôt distant à partir duquel vous avez cloné votre dépôt local. Il est important de noter que "origin" n'est pas un terme réservé ou prédéfini par **Git**, mais c'est une convention couramment utilisée.
|
||||
|
||||
Plus précisément, "origin" est un alias que **Git** utilise pour simplifier les opérations de communication avec un dépôt distant. Lorsque vous clonez un dépôt distant avec la commande ''git clone'', **Git** configure automatiquement "origin" pour pointer vers l'URL du dépôt distant que vous avez cloné. Cela vous permet d'accéder facilement au dépôt distant sans avoir à spécifier son URL à chaque fois que vous effectuez des opérations telles que ''git fetch'' ou ''git push''.
|
||||
|
||||
Par exemple, après avoir cloné un dépôt depuis **GitHub**, votre dépôt local aura par défaut "origin" configuré pour pointer vers l'URL du dépôt **GitHub**. Vous pouvez ensuite utiliser des commandes comme ''git pull origin'' pour tirer les mises à jour du dépôt distant ou ''git push origin'' pour pousser vos modifications vers le dépôt distant, en utilisant simplement l'alias "origin".
|
||||
|
||||
Cependant, vous pouvez également configurer d'autres dépôts distants avec des noms différents si vous travaillez avec plusieurs dépôts distants dans votre projet. "origin" est simplement le nom par défaut pour le dépôt distant d'origine à partir duquel vous avez cloné.
|
||||
===== - add, commit, push =====
|
||||
|
||||
Les commandes **add**, **commit** et **push** sont des commandes essentielles dans Git qui vous permettent de gérer et de versionner vos fichiers et modifications.
|
||||
|
||||
**git add** : Cette commande est utilisée pour mettre des fichiers sous suivi Git (staging area). En d'autres termes, elle permet de préparer les modifications que vous souhaitez inclure dans votre prochain commit. Vous pouvez spécifier les fichiers individuellement ou utiliser des motifs pour ajouter plusieurs fichiers à la fois. Par exemple :
|
||||
<code bash>
|
||||
git add fichier1.txt
|
||||
git add dossier/
|
||||
git add .
|
||||
</code>
|
||||
|
||||
La première commande ajoute un fichier spécifique, la deuxième ajoute tous les fichiers dans un dossier, et la troisième ajoute tous les fichiers modifiés ou nouveaux dans le répertoire de travail.
|
||||
|
||||
**git commit** : Une fois que vous avez ajouté les fichiers à la staging area avec git add, vous pouvez utiliser git commit pour créer un instantané (commit) des modifications. Chaque commit est accompagné d'un message descriptif qui explique les changements apportés. Par exemple :
|
||||
|
||||
<code bash>
|
||||
git commit -m "Ajout de fonctionnalité XYZ"
|
||||
</code>
|
||||
|
||||
Cette commande crée un commit contenant les fichiers ajoutés à la staging area avec un message qui décrit la modification effectuée.
|
||||
|
||||
**git push** : Cette commande est utilisée pour pousser vos commits vers un dépôt distant, comme celui sur GitHub, GitLab ou un autre serveur Git. Lorsque vous effectuez des commits localement, ils ne sont pas automatiquement disponibles pour d'autres collaborateurs ou pour sauvegarde sur le serveur distant. git push permet de transférer vos commits locaux vers le dépôt distant. Par exemple :
|
||||
|
||||
<code bash>
|
||||
git push origin nom_de_la_branche
|
||||
</code>
|
||||
|
||||
Cette commande envoie les commits de la branche locale vers la branche correspondante sur le dépôt distant.
|
||||
|
||||
--
|
||||
|
||||
Si vous souhaitez modifier l'un des scripts ou fichier dans le dépôt cloné (par exemple, le "scripts-bash" que vous avez cloné), suivez ces étapes :
|
||||
|
||||
1. Naviguez vers le répertoire où vous avez cloné le dépôt. Vous avez mentionné que vous l'avez cloné dans "~/projets/scripts-bash". Utilisez la commande `cd` pour vous déplacer vers ce répertoire :
|
||||
|
||||
<code bash>
|
||||
cd ~/projets/scripts-bash
|
||||
</code>
|
||||
|
||||
2. Une fois dans le répertoire du projet, vous pouvez éditer le script que vous souhaitez modifier à l'aide de l'éditeur de texte de votre choix. Par exemple, si vous utilisez l'éditeur de texte "nano", vous pouvez l'ouvrir en spécifiant le nom du fichier à éditer :
|
||||
|
||||
<code bash>
|
||||
nano nom_du_script.sh
|
||||
</code>
|
||||
|
||||
3. Effectuez les modifications nécessaires dans le script à l'aide de l'éditeur de texte.
|
||||
|
||||
4. Enregistrez les modifications et quitter l'éditeur de texte.
|
||||
|
||||
5. Une fois les modifications enregistrées, vous pouvez les valider en utilisant **Git**. Voici comment cela peut être fait :
|
||||
|
||||
- Si vous avez modifié un fichier existant, utilisez la commande ''git add'' pour ajouter les modifications au suivi Git :
|
||||
|
||||
<code bash>
|
||||
git add nom_du_script.sh
|
||||
</code>
|
||||
|
||||
- Ensuite, utilisez la commande ''git commit'' pour enregistrer les modifications avec un message descriptif :
|
||||
|
||||
<code bash>
|
||||
git commit -m "Description de la modification"
|
||||
</code>
|
||||
|
||||
- Enfin, utilisez ''git push'' pour pousser les modifications vers le dépôt distant (si vous avez les autorisations nécessaires) :
|
||||
|
||||
<code bash>
|
||||
git push origin nom_de_la_branche
|
||||
</code>
|
||||
|
||||
Assurez-vous de remplacer "nom_de_la_branche" par le nom de la branche sur laquelle vous souhaitez pousser les modifications.
|
||||
|
||||
--
|
||||
|
||||
En résumé, **git add** prépare les modifications, **git commit** crée un instantané des modifications avec un message, et **git push** envoie ces commits vers un dépôt distant. Ensemble, ces commandes permettent de gérer efficacement les versions de votre code source. Elles permettront de modifier un script dans votre dépôt Git local et de mettre à jour le dépôt distant avec vos modifications.
|
||||
|
||||
===== - Enregistrer ces identifiants durant un laps de temps en mémoire =====
|
||||
|
||||
Comme vous l'aurez remarqué, les identifiants sont systématiquement requis lorsque vous effectuez des modifications sur le serveur distant avec la commande ''git push''. Vous avez la possibilité de mémoriser temporairement les identifiants de connexion Git localement en utilisant la commande ''git credential''. Voici comment procéder :
|
||||
|
||||
|
||||
1. Ouvrez votre Terminal
|
||||
|
||||
2. Exécutez les commandes suivantes pour définir votre nom d'utilisateur et votre mot de passe pour le dépôt distant :
|
||||
|
||||
<code>
|
||||
git config --global credential.helper 'cache --timeout=3600'
|
||||
git credential approve <<EOF
|
||||
protocol=https
|
||||
host=github.com
|
||||
username=VOTRE_NOM_D_UTILISATEUR
|
||||
password=VOTRE_MOT_DE_PASSE
|
||||
EOF
|
||||
|
||||
</code>
|
||||
|
||||
Assurez-vous de remplacer les valeurs de ''protocol'', ''host'', ''username'' et ''password'' par les valeurs appropriées pour votre dépôt distant.
|
||||
|
||||
--
|
||||
|
||||
Une fois que vous avez exécuté ces commandes, Git stockera vos informations d'identification en mémoire de manière sécurisée localement pendant un certain temps (dans cet exemple, pendant 3600 secondes, soit 1 heure). Vous n'aurez pas besoin de saisir vos informations d'identification à chaque opération Git pendant cette période.
|
||||
|
||||
|
||||
|
||||
//Source : https://git-scm.com/docs/git-credential-cache/fr //
|
||||
|
||||
===== - Enregistrer ces identifiants dans les gestionnaires de secrets =====
|
||||
|
||||
GNOME Keyring
|
||||
|
||||
//Source : https://pkgs.org/search/?q=git-credential-libsecret //
|
||||
|
||||
===== - Enregistrer ces identifiants dans keepassXC =====
|
||||
|
||||
//Source : https://github.com/Frederick888/git-credential-keepassxc //
|
||||
86
data/pages/informatique/linux/commandes/grep.txt
Normal file
86
data/pages/informatique/linux/commandes/grep.txt
Normal file
@@ -0,0 +1,86 @@
|
||||
====== grep ======
|
||||
{{tag>"linux commande"}}
|
||||
{{ :dummy.png?75x75|}}
|
||||
|
||||
**grep** est un outil de ligne de commande pour la recherche de motifs dans un fichier ou une entrée standard ou des entrées de pipelines. Il est utilisé pour afficher les lignes d'un fichier qui correspondent à un modèle spécifié. Le résultat peut être filtré ou utilisé comme entrée pour d'autres commandes.
|
||||
|
||||
Techniquement, **grep** analyse le contenu d'un fichier ou d'une entrée standard et affiche les lignes qui correspondent à un modèle spécifié. Le modèle peut être une expression régulière, qui est une forme d'expression mathématique utilisée pour décrire des ensembles de chaînes de caractères. **Grep** utilise un algorithme de correspondance rapide pour trouver rapidement les lignes qui correspondent au modèle, ce qui le rend utile pour la recherche de fichiers, la filtration de sorties et la manipulation de données complexes.
|
||||
|
||||
===== Rechercher une chaîne de caractères dans un fichier =====
|
||||
|
||||
grep "motif recherché" nom_du_fichier
|
||||
|
||||
===== Rechercher une chaîne de caractères dans un fichier sans respect de la casse =====
|
||||
|
||||
L'option ''-i'' indique de rechercher de manière insensible à la casse.
|
||||
|
||||
Par défaut, la commande **grep** effectue une recherche respectant la casse, ce qui signifie qu'elle ne fera correspondre que les occurrences exactes de la chaîne de caractères spécifiée. Si vous recherchez "bonjour" avec **grep**, il ne trouvera que "bonjour" et pas "Bonjour", "BONJOUR", etc.
|
||||
|
||||
Si vous souhaitez effectuer une recherche insensible à la casse avec **grep**, vous devez utiliser l'option **-i**, comme suit :
|
||||
|
||||
<code>
|
||||
grep -i bonjour *
|
||||
</code>
|
||||
|
||||
|
||||
===== Rechercher une chaîne de caractères dans plusieurs fichiers =====
|
||||
|
||||
grep "motif recherché" *
|
||||
|
||||
===== Afficher les lignes correspondantes avec le nom de fichier =====
|
||||
|
||||
grep -H "motif recherché" *
|
||||
|
||||
L'option ''-H'' indique à **grep** de inclure le nom de fichier pour chaque correspondance trouvée. La sortie sera la liste des lignes de chaque fichier qui correspondent à "motif recherché".
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
===== Rechercher une chaîne de caractères en utilisant une expression régulière =====
|
||||
|
||||
grep -E "^[0-9]+$" nom_du_fichier
|
||||
|
||||
L'option -E (extended regexp) pour rechercher les lignes du fichier ''nom_du_fichier'' qui correspondent à l'expression régulière ''^[0-9]+$''.
|
||||
|
||||
L'expression régulière ''^[0-9]+$'' signifie "une ou plusieurs chiffres consécutifs, débutant à la première colonne de la ligne et se terminant à la dernière colonne de la ligne". En d'autres termes, la commande ''grep'' affichera toutes les lignes du fichier ''nom_du_fichier'' qui ne contiennent que des chiffres.
|
||||
|
||||
===== Afficher le nombre de lignes correspondantes =====
|
||||
|
||||
grep -c "motif recherché" nom_du_fichier
|
||||
|
||||
L'option ''-c'' de la commande ''grep'' indique de ne retourner que le nombre de lignes qui correspondent au motif spécifié, sans afficher les lignes elles-mêmes.
|
||||
|
||||
|
||||
===== Afficher les lignes précédentes et suivantes correspondantes =====
|
||||
|
||||
grep -A 2 -B 1 "motif recherché" nom_du_fichier
|
||||
|
||||
L'option ''-A 2'' indique à grep d'afficher 2 lignes supplémentaires après chaque ligne contenant le "motif recherché".
|
||||
|
||||
L'option ''-B 1'' indique à grep d'afficher 1 ligne supplémentaire avant chaque ligne contenant le "motif recherché".
|
||||
|
||||
Ainsi, pour chaque correspondance trouvée, grep affichera la ligne correspondante, suivie de 1 ligne avant et 2 lignes après.
|
||||
|
||||
|
||||
===== Afficher des fichiers sans commentaires =====
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
|
||||
|
||||
Les fichiers de configurations peuvent contenir beaucoup de ligne. Mais la plus part de ces lignes sont des commentaires. Il est utile de les supprimer à l'affichage quand on veut uniquement conserver les paramètres pris en comptes.
|
||||
|
||||
---
|
||||
|
||||
Afficher toutes les lignes du fichier ''/etc/php/7.4/fpm/php.ini'' qui ne commencent pas par un point-virgule (;), qui est utilisé pour commenter les lignes dans ce type de fichier de configuration. Cela signifie que seules les lignes actives (non commentées) seront affichées à la sortie.
|
||||
|
||||
grep ^[^\;] /etc/php/7.4/fpm/php.ini
|
||||
|
||||
---
|
||||
|
||||
Affichons les lignes qui ne commencent pas avec un ''#'' dans le fichier ''/etc/postfix/main.cf''. Les crochets ''[]'' définissent une liste de caractères à inclure ou à exclure dans la recherche, et le ''^'' signifie le début d'une ligne. Le ''\'' est utilisé pour échapper certains caractères spéciaux. Ainsi, ^[^#] signifie que nous cherchons des lignes qui commencent avec un caractère qui n'est pas un ''#''. Les résultats de la commande afficheront uniquement les lignes du fichier ''main.cf'' qui ne commencent pas avec un ''#'' et seront donc actives et utilisées par Postfix.
|
||||
|
||||
grep ^[^#] /etc/postfix/main.cf
|
||||
|
||||
|
||||
--- //[[user:jeanserien]], [[user:cpt]]//
|
||||
|
||||
52
data/pages/informatique/linux/commandes/groups.txt
Normal file
52
data/pages/informatique/linux/commandes/groups.txt
Normal file
@@ -0,0 +1,52 @@
|
||||
====== groups ======
|
||||
|
||||
La commande ''groups'' est utilisée pour afficher les groupes auxquels un utilisateur appartient sur un système Unix ou Linux. Lorsqu'elle est exécutée sans argument, la commande ''groups'' affiche les groupes de l'utilisateur courant (l'utilisateur qui exécute la commande). Voici un exemple d'utilisation de la commande ''groups'' :
|
||||
|
||||
|
||||
<code bash>
|
||||
groups
|
||||
</code>
|
||||
|
||||
Le résultat sera une liste des groupes auxquels appartient l'utilisateur actuel, séparés par des espaces.
|
||||
|
||||
Par exemple, si l'utilisateur courant est ''alice'' et qu'elle appartient aux groupes ''users'' et ''sudo'', la commande ''groups'' affichera quelque chose comme ceci :
|
||||
|
||||
<code bash>
|
||||
alice users sudo
|
||||
</code>
|
||||
|
||||
La commande ''groups'' est utile pour vérifier rapidement les groupes auxquels un utilisateur est associé, ce qui peut être important pour comprendre ses autorisations et ses privilèges sur le système. Vous pouvez également spécifier un nom d'utilisateur en argument pour afficher les groupes auxquels un utilisateur spécifique appartient, par exemple :
|
||||
|
||||
<code bash>
|
||||
groups alice
|
||||
</code>
|
||||
|
||||
Cela affichera les groupes auxquels l'utilisateur ''alice'' appartient.
|
||||
|
||||
===== Scripts =====
|
||||
|
||||
La commande ''groups'' peut être utilisée dans des scripts shell pour récupérer la liste des groupes auxquels un utilisateur appartient et utiliser ces informations dans des opérations ou des prises de décision. Voici un exemple simple de la façon dont vous pourriez utiliser ''groups'' dans un script :
|
||||
|
||||
Supposons que vous ayez un script shell (par exemple, un script bash) et que vous souhaitiez effectuer une action différente en fonction des groupes auxquels l'utilisateur appartient. Voici un exemple de script qui utilise ''groups'' pour cela :
|
||||
|
||||
<code bash>
|
||||
#!/bin/bash
|
||||
|
||||
# Obtient la liste des groupes de l'utilisateur courant
|
||||
user_groups=$(groups)
|
||||
|
||||
# Vérifie si l'utilisateur appartient au groupe "admin"
|
||||
if [[ "$user_groups" == *admin* ]]; then
|
||||
echo "L'utilisateur appartient au groupe 'admin'."
|
||||
# Effectuez ici les actions spécifiques pour le groupe "admin"
|
||||
else
|
||||
echo "L'utilisateur n'appartient pas au groupe 'admin'."
|
||||
# Effectuez ici les actions pour les utilisateurs qui ne sont pas dans le groupe "admin"
|
||||
fi
|
||||
|
||||
# Autres actions communes à tous les utilisateurs
|
||||
</code>
|
||||
|
||||
Dans cet exemple, le script récupère la liste des groupes de l'utilisateur courant à l'aide de la commande ''groups'' et stocke cette liste dans la variable ''user_groups''. Ensuite, il vérifie si l'utilisateur appartient au groupe "admin" en utilisant une condition ''if''. Vous pouvez personnaliser le script en fonction des groupes que vous souhaitez vérifier.
|
||||
|
||||
L'utilisation de ''groups'' dans des scripts peut être utile pour personnaliser le comportement du script en fonction des autorisations ou des groupes d'utilisateurs. Assurez-vous que le script est exécuté par un utilisateur qui a la permission d'exécuter la commande ''groups'', et n'oubliez pas de gérer les erreurs potentielles, notamment si l'utilisateur n'appartient à aucun groupe.
|
||||
5
data/pages/informatique/linux/commandes/halt.txt
Normal file
5
data/pages/informatique/linux/commandes/halt.txt
Normal file
@@ -0,0 +1,5 @@
|
||||
====== halt ======
|
||||
|
||||
C'est un programme présent dans ''/usr/sbin/''. Par conséquent il doit être appelé avec les droits ''root''. Il permet d'arrêter l'ordinateur.
|
||||
|
||||
Le programme fait partie du groupe [[.:shutdown]], [[.:reboot]], [[.:halt]] et [[.:poweroff]], tous ayant un lien symbolique avec [[.:systemctl]] quand le système est piloté avec SystemD.
|
||||
22
data/pages/informatique/linux/commandes/index.txt
Normal file
22
data/pages/informatique/linux/commandes/index.txt
Normal file
@@ -0,0 +1,22 @@
|
||||
====== Commandes Linux et exemples ======
|
||||
{{ :informatique:langage:logo_bash.png?75x75|Commandes Linux et exemples}}
|
||||
|
||||
Cette sous-catégorie inclus des articles sur les commandes de terminal les plus courantes, avec des exemples et des explications détaillées.
|
||||
|
||||
|
||||
==== A propos ====
|
||||
|
||||
<nav stacked="true" fade="true">
|
||||
* [[informatique:linux:commandes:la-ligne-de-commande]]
|
||||
* [[les-commandes-a-connaitre]]
|
||||
* [[.tips:index]]
|
||||
</nav>
|
||||
|
||||
===== Sommaire =====
|
||||
|
||||
<nspages . -h1 -hideNoSubns -subns -nbCol=2 -textNS=" " -textPages=" " -exclude:cookie: -exclude:user: -exclude:playground: -exclude:[sidebar index start rightsidebar navbar topheader header help pageheader pagefooter legal-notices footer 404 les-commandes-a-connaitre 010100-repertoire-des-commandes-linux-sous-bash la-ligne-de-commande tips: super-index] -pagesInNs >
|
||||
|
||||
|
||||
|
||||
~~NOTOC~~
|
||||
~~NOCACHE~~
|
||||
42
data/pages/informatique/linux/commandes/ip.txt
Normal file
42
data/pages/informatique/linux/commandes/ip.txt
Normal file
@@ -0,0 +1,42 @@
|
||||
====== ip ======
|
||||
|
||||
Utilitaire de configuration réseau TCP/IP.
|
||||
|
||||
A noter que le manuel de cette commande se résume à un renvoi vers une page Internet.
|
||||
|
||||
<code>
|
||||
OPTIONS
|
||||
Pour des renseignements complets sur les commandes, prière de vous référer au document suivant :
|
||||
/usr/share/doc/iproute-2.4.7/ip-cref.ps
|
||||
ou http://linux-ip.net/gl/ip-cref/
|
||||
</code>
|
||||
|
||||
====== Exemples ======
|
||||
|
||||
> Lister les interfaces avec leurs paramètres
|
||||
|
||||
<code>
|
||||
$ ip a
|
||||
|
||||
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
|
||||
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
|
||||
inet 127.0.0.1/8 scope host lo
|
||||
valid_lft forever preferred_lft forever
|
||||
inet6 ::1/128 scope host
|
||||
valid_lft forever preferred_lft forever
|
||||
2: eno1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
|
||||
link/ether 00:22:4d:9d:47:03 brd ff:ff:ff:ff:ff:ff
|
||||
inet 192.168.100.100/24 brd 192.168.100.255 scope global dynamic noprefixroute eno1
|
||||
valid_lft 233861sec preferred_lft 233861sec
|
||||
inet6 fe80::73c1:c76e:7041:7336/64 scope link noprefixroute
|
||||
valid_lft forever preferred_lft forever
|
||||
|
||||
</code>
|
||||
|
||||
> Lister les interfaces avec adresses IP v.4 et V.6 et un peu de couleurs
|
||||
<code>
|
||||
$ ip -br -c a
|
||||
|
||||
lo UNKNOWN 127.0.0.1/8 ::1/128
|
||||
eno1 UP 192.168.100.100/24 fe80::73c1:c76e:7041:7336/64
|
||||
</code>
|
||||
160
data/pages/informatique/linux/commandes/la-ligne-de-commande.txt
Normal file
160
data/pages/informatique/linux/commandes/la-ligne-de-commande.txt
Normal file
@@ -0,0 +1,160 @@
|
||||
====== - La ligne de commande ======
|
||||
|
||||
----
|
||||
|
||||
Une **ligne de commande**, également appelée interface en ligne de commande (CLI), est un moyen d'interagir avec un système d'exploitation en saisissant des commandes à l'aide d'un clavier au lieu d'utiliser une interface graphique. Les commandes sont généralement entrées dans un terminal ou une fenêtre de commande et exécutées par le système d'exploitation. Les commandes peuvent effectuer des tâches telles que la gestion de fichiers, la modification de paramètres de configuration, la gestion des processus et la surveillance du système. Les lignes de commandes sont utilisés à l'aide d'un interpréteur de commande (par exemple BASH).
|
||||
|
||||
Une fois connecté à un terminal texte, un programme nommé shell est lancé automatiquement. Il permet de lancer des commandes.
|
||||
|
||||
===== Syntaxe des commandes =====
|
||||
|
||||
La **ligne de commande** regroupe une ou plusieurs instructions qui sont saisies et se termine par un retour à la ligne. La commande est composée d'un nom qui décrit une action ou un programme, éventuellement suivie d'arguments.
|
||||
|
||||
Par exemple la ligne de commande ''cal'' comporte la commande ''cal'' sans argument.
|
||||
|
||||
La ligne de commande ''cal -m apr'' comporte la commande ''cal'' avec 2 arguments : ''-m'' et ''apr''.
|
||||
|
||||
La ligne de commande ''echo "Bonjour Alpinux"'' comporte la commande ''echo'' avec 1 argument, ''"Bonjour Alpinux"''.
|
||||
|
||||
Les arguments d'une commande peuvent être des options ou des arguments, selon le contexte dans lequel ils sont utilisés.
|
||||
|
||||
Les options sont des arguments supplémentaires qui peuvent être utilisés pour personnaliser le comportement de la commande. Elles peuvent être courtes (précédées d'un tiret simple (-)) ou longues (précédées d'un double tiret (--)).
|
||||
|
||||
Les arguments sont des informations nécessaires à la commande pour accomplir son travail. Ils peuvent inclure des noms de fichiers, des répertoires, des noms d'utilisateurs, etc.
|
||||
|
||||
Par exemple, dans la commande ''ls -l /home/user'', ''-l'' est une option qui demande à la commande ''ls'' d'afficher les fichiers et répertoires sous forme de liste détaillée, tandis que "/home/user" est un argument qui spécifie le répertoire à afficher.
|
||||
|
||||
Il est important de comprendre les différences entre les options et les arguments pour utiliser correctement les commandes en ligne de commande sous Linux.
|
||||
|
||||
===== Options mono-caractère =====
|
||||
|
||||
Les options mono-caractère sont des options courtes qui peuvent être utilisées pour personnaliser le comportement des commandes en ligne de commande sous Linux. Elles sont généralement précédées d'un tiret simple (-) et peuvent être combinées pour obtenir des effets plus complexes.
|
||||
|
||||
Par exemple, la commande ''ls'' peut être utilisée avec l'option mono-caractère ''-l'' pour afficher les fichiers et répertoires sous forme de liste détaillée. La combinaison des options ''-l'' et ''-h'' peut être utilisée pour afficher les tailles de fichier de manière lisible pour les humains.
|
||||
|
||||
ls -l -h
|
||||
ls -h -l
|
||||
ls -lh
|
||||
ls -hl
|
||||
|
||||
Certaines options en ligne de commande peuvent être précédées d'un signe plus (+) au lieu d'un tiret simple (-). Ce type d'options sont généralement utilisées pour ajouter ou activer des fonctionnalités supplémentaires dans les programmes.
|
||||
|
||||
Par exemple, la commande ''ls'' peut être utilisée avec l'option "+l" pour afficher les fichiers et répertoires sous forme de liste détaillée, similaire à l'utilisation de l'option "-l".
|
||||
|
||||
Il est important de noter que l'utilisation de signes plus (+) pour les options est assez rare et n'est généralement pas standard pour la plupart des commandes en ligne de commande sous Linux. La plupart des options sont précédées d'un tiret simple (-). Il est donc toujours préférable de consulter la documentation pour comprendre les options disponibles et comment les utiliser correctement.
|
||||
|
||||
Certaines options en ligne de commande peuvent prendre une chaîne de caractères en argument. Ces options sont généralement utilisées pour fournir des informations supplémentaires au programme sur la façon de se comporter ou sur les données à utiliser.
|
||||
|
||||
Par exemple, la commande ''grep'' peut être utilisée avec l'option ''-e'' pour rechercher une expression régulière spécifiée dans un fichier ou sur l'entrée standard. L'expression régulière est spécifiée comme une chaîne de caractères après l'option ''-e''.
|
||||
|
||||
Supposons que vous avez un fichier nommé ''file.txt'' qui contient du texte.
|
||||
Pour rechercher la chaîne de caractères "sample" dans ce fichier, vous pouvez utiliser la commande grep avec l'option ''-e'' :
|
||||
|
||||
grep -e "sample" file.txt
|
||||
|
||||
Vous pouvez écrire la commande ''grep'' de cette façon :
|
||||
|
||||
grep -esample file.txt
|
||||
|
||||
Cela fonctionnera de la même manière que la commande précédente, avec l'option "-e" suivie de la chaîne de caractères "sample". La commande affichera la ligne du fichier "file.txt" qui contient la chaîne de caractères "sample".
|
||||
|
||||
Il est important de noter que le format des options qui prennent une chaîne de caractères en argument peut varier pour chaque commande. Il est donc toujours préférable de consulter la documentation pour comprendre les options disponibles et comment les utiliser correctement.
|
||||
|
||||
Les options mono-caractère peuvent varier pour chaque commande, et il est souvent utile de consulter la documentation pour comprendre les options disponibles et comment les utiliser correctement.
|
||||
|
||||
===== Les options longues =====
|
||||
|
||||
Les options longues sont généralement précédées d'un double tiret (--) et peuvent inclure des mots entiers pour décrire plus clairement leur fonctionnement.
|
||||
|
||||
Par exemple, la commande ''ls'' peut être utilisée avec l'option longue ''--human-readable'' pour afficher la taille des fichiers sous forme conviviale en utilisant des unités de taille, similaire à l'utilisation de l'option ''-h''.
|
||||
|
||||
===== La séparation des options et des arguments =====
|
||||
|
||||
La séparation des options et des arguments peut être faite en utilisant un double tiret (--) pour signaler la fin des options et le début des arguments. Tout ce qui suit le double tiret est considéré comme un argument, même s'il commence par un tiret simple (-).
|
||||
|
||||
Par exemple, considérons la commande "cp", qui permet de copier des fichiers d'un emplacement à un autre. Si vous souhaitez copier un fichier nommé "-f" à un emplacement nommé "destination", vous pouvez utiliser la commande suivante:
|
||||
|
||||
cp -- -f destination
|
||||
|
||||
Dans ce cas, le double tiret (--) signale la fin des options et le début des arguments. Le premier argument, "-f", est considéré comme un nom de fichier, même s'il commence par un tiret simple (-). Le second argument, "destination", est considéré comme l'emplacement de destination pour la copie de fichier.
|
||||
|
||||
L'utilisation de ce double tiret peut être utile lorsqu'il est nécessaire de traiter des arguments qui commencent par un tiret simple (-), qui pourraient autrement être interprétés comme des options.
|
||||
===== Aspect de la ligne de commandes =====
|
||||
|
||||
Sous Linux, l'invite de commande peut prendre différentes formes en fonction de la configuration. Par exemple, elle peut être configurée pour afficher le nom d'utilisateur, le nom d'hôte et le répertoire courant, ou seulement le nom d'utilisateur et le répertoire courant. La couleur et les caractères utilisés pour l'affichage peuvent également être personnalisés.
|
||||
|
||||
Il est également possible de changer le comportement de l'invite de commande en utilisant des alias, des variables d'environnement et d'autres outils de configuration. Cela peut aider à améliorer l'efficacité et la productivité en ligne de commande.
|
||||
|
||||
===== L'invite de commande =====
|
||||
|
||||
L'**invite de commande** **est l'endroit** où les utilisateurs peuvent **saisir des commandes** pour interagir avec un système d'exploitation.
|
||||
|
||||
Il s'agit généralement d'une fenêtre ou d'un **terminal** (appelé SHELL) qui **affiche un curseur clignotant**, où l'**utilisateur peut saisir des commandes** et les exécuter en appuyant sur la touche "Entrée".
|
||||
|
||||
**Les commandes saisies** dans l'invite de commande **sont** interprétées par le système d'exploitation et **exécutées** en conséquence.
|
||||
|
||||
Le dernier caractère de l'invite de commande peut être un dollar "$" ou un dièse "#". Cela dépend du niveau de privilèges de l'utilisateur actuel.
|
||||
|
||||
Un dollar ''$'' indique que l'utilisateur actuel est un utilisateur normal, sans privilèges d'administration.
|
||||
|
||||
Un dièse ''#'' indique que l'utilisateur actuel est un utilisateur avec des privilèges d'administration, également appelé "superutilisateur" ou "root".
|
||||
|
||||
Cela aide à identifier rapidement le niveau de privilèges de l'utilisateur actuel et peut être utile pour éviter de saisir accidentellement des commandes dangereuses avec des privilèges élevés.
|
||||
|
||||
Par exemple :
|
||||
|
||||
<code>
|
||||
cedric@eeepc:~$
|
||||
</code>
|
||||
|
||||
''cedric'' >> correspond à l'utilisateur connecté.
|
||||
|
||||
''eeepc'' >> correspond au nom de l’hôte, c'est-à-dire au nom de l'ordinateur.
|
||||
|
||||
''~'' >> correspond au répertoire courant. Lorsqu'il est représenté par le symbole **~**, cela indique qu'il s'agit du dossier personnel de l'utilisateur, appelé en anglais **home**.
|
||||
|
||||
''$'' >> indique que l'utilisateur est de type normal. Avec le caractère **#**, il indiquera qu'il s'agit d'un super-utilisateur, identifié **root**.
|
||||
|
||||
===== Applications avec une interface graphique =====
|
||||
|
||||
Il est possible d'exécuter des applications avec une interface graphique depuis un shell sous Linux.
|
||||
|
||||
Par exemple, pour exécuter une application telle que "gedit" avec une interface graphique depuis un shell, vous pouvez utiliser la commande suivante :
|
||||
|
||||
gedit
|
||||
|
||||
Cette commande ouvrira l'application fenêtrée **gedit**.
|
||||
|
||||
Cette méthode n'est pas toujours la plus pratique ou la plus efficace pour exécuter des applications avec une interface graphique depuis un shell. Dans de nombreux cas, il est plus facile de simplement cliquer sur l'icône de l'application dans le menu ou le gestionnaire de fichiers. Cependant, cette méthode peut être utile pour exécuter des applications depuis un script ou pour effectuer des tâches de ligne de commande.
|
||||
|
||||
===== Les raccourcis clavier en mode texte =====
|
||||
|
||||
Il existe de nombreux raccourcis clavier qui peuvent être utilisés en mode texte sous Linux pour effectuer des tâches rapidement et efficacement. Voici quelques-uns des raccourcis clavier les plus couramment utilisés :
|
||||
|
||||
* <key>Tab</key> : Complète automatiquement un nom de fichier ou de répertoire.
|
||||
* <key>Up</key> : Affiche la dernière commande entrée.
|
||||
* <key>Down</key> : Affiche la commande précédente entrée.
|
||||
|
||||
* <key>Ctrl</key> + <kbd>c</kbd> : Interrompt une commande en cours d'exécution.
|
||||
* <key>Ctrl</key> + <kbd>z</kbd> : Suspend une commande en cours d'exécution et la place en arrière-plan.
|
||||
* <key>Ctrl</key> + <kbd>d</kbd> : Termine une session en ligne de commande.
|
||||
* <key>Ctrl</key> + <kbd>l</kbd> : Efface l'écran.
|
||||
* <key>Ctrl</key> + <kbd>r</kbd> : Recherche dans l'historique des commandes.
|
||||
|
||||
* <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>c</kbd> : Copie dans le presse papier la sélection.
|
||||
* <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>v</kbd> : Colle le contenu du presse papier à l'endroit du curseur. Équivalent : <kbd>Shift</kbd> + <kbd>Inser</kbd>
|
||||
|
||||
* <key>Ctrl</key> + <kbd>a</kbd> : Déplace le curseur au début de la ligne actuelle.
|
||||
* <key>Ctrl</key> + <key>E</key> : Déplace le curseur à la fin de la ligne actuelle.
|
||||
* <key>Ctrl</key> + <key>left</key> : Déplace le curseur d'un mot à gauche.
|
||||
* <key>Ctrl</key> + <key>right</key> : Déplace le curseur d'un mot à droite.
|
||||
* <key>Alt</key> + <key>left</key> : Déplace le curseur d'un mot à gauche en conservant les mots en entier.
|
||||
* <key>Alt</key> + <key>right</key> : Déplace le curseur d'un mot à droite en conservant les mots en entier.
|
||||
|
||||
* <key>Ctrl</key> + <key>U</key> : Efface tout ce qui se trouve à gauche du curseur.
|
||||
* <key>Ctrl</key> + <key>K</key> : Efface tout ce qui se trouve à droite du curseur.
|
||||
* <key>Ctrl</key> + <key>W</key> : Efface le dernier mot à gauche du curseur.
|
||||
* <key>Ctrl</key> + <key>Y</key> : Colle le dernier élément coupé ou copié.
|
||||
|
||||
|
||||
Ces raccourcis peuvent varier en fonction de la distribution Linux utilisée et du shell utilisé.
|
||||
@@ -0,0 +1,72 @@
|
||||
====== Les commandes Linux à connaître ======
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
|
||||
|
||||
Les commandes Linux les plus importantes à connaître en premier sont :
|
||||
|
||||
* [[ls|ls]] : permet de lister les fichiers et dossiers dans un répertoire.
|
||||
|
||||
* [[cd|cd]] : permet de se déplacer dans les répertoires.
|
||||
|
||||
* [[pwd|pwd]] : permet de connaître le chemin absolu du répertoire courant.
|
||||
|
||||
* [[mkdir|mkdir]] : permet de créer un nouveau répertoire.
|
||||
|
||||
* [[rmdir|rmdir]] : permet de supprimer un répertoire vide.
|
||||
|
||||
* [[touch|touch]] : permet de créer un nouveau fichier.
|
||||
|
||||
* [[rm|rm]] : permet de supprimer un fichier ou un répertoire.
|
||||
|
||||
* [[cp|cp]] : permet de copier un fichier ou un répertoire.
|
||||
|
||||
* [[mv|mv]] : permet de déplacer ou renommer un fichier ou un répertoire.
|
||||
|
||||
* [[su|su]] : permet de se connecter avec un autre compte ou root.
|
||||
|
||||
* [[sudo|sudo]] : permet d'exécuter une commande en tant qu'administrateur.
|
||||
|
||||
* [[man|man]] : permet d'afficher la page de manuel d'une commande.
|
||||
|
||||
* [[echo|echo]] : permet d'afficher des informations dans la console.
|
||||
|
||||
* [[exit|exit]] : permet de quitter la session actuelle.
|
||||
|
||||
* [[reboot|reboot]] : permet de redémarrer le système.
|
||||
|
||||
|
||||
Cela vous donnera un bon départ pour naviguer et gérer les fichiers et les répertoires dans un système Linux.
|
||||
|
||||
Après avoir maîtrisé les commandes de base de Linux, il est utile de continuer à explorer d'autres commandes qui peuvent être utiles pour gérer et administrer votre système. Voici quelques exemples de commandes supplémentaires qui peuvent être utiles :
|
||||
|
||||
* [[ps|ps]] : permet d'afficher les processus en cours d'exécution sur votre système.
|
||||
|
||||
* [[kill|kill]] : permet de terminer un processus en cours d'exécution.
|
||||
|
||||
* [[top|top]] : permet d'afficher les processus les plus gourmands en ressources en temps réel.
|
||||
|
||||
* [[df|df]] : permet de vérifier l'utilisation de l'espace disque.
|
||||
|
||||
* [[du|du]] : permet de vérifier l'utilisation de l'espace disque pour un répertoire spécifique.
|
||||
|
||||
* [[chmod|chmod]] : permet de modifier les autorisations d'un fichier ou d'un répertoire.
|
||||
|
||||
* [[chown|chown]] : permet de changer le propriétaire d'un fichier ou d'un répertoire.
|
||||
|
||||
* [[find|find]] : permet de rechercher des fichiers ou des répertoires en fonction de critères spécifiques.
|
||||
|
||||
* [[cat|cat]] : permet d'afficher le contenu d'un fichier.
|
||||
|
||||
* [[nano|nano]] : permet d'éditer le contenu d'un fichier.
|
||||
|
||||
* [[tail|tail]] : permet d'afficher les dernières d'un fichier.
|
||||
|
||||
* [[head|head]] : permet d'afficher les premières d'un fichier.
|
||||
|
||||
* [[sed|sed]] : permet de modifier des fichiers de texte de manière automatisée.
|
||||
|
||||
* [[awk|awk]] : permet de traiter les données de manière avancée, comme la création de statistiques à partir de données enregistrées.
|
||||
|
||||
Il existe énormément de commandes Linux, chacun a des utilisations spécifiques.
|
||||
|
||||
|
||||
8
data/pages/informatique/linux/commandes/logout.txt
Normal file
8
data/pages/informatique/linux/commandes/logout.txt
Normal file
@@ -0,0 +1,8 @@
|
||||
====== logout ======
|
||||
{{ :dummy.png?75x75|commande système}}
|
||||
|
||||
La commande ''logout'' est une commande système qui permet de se déconnecter d'une session en cours sur un terminal ou une console.
|
||||
|
||||
Lorsque vous exécutez la commande ''logout'', le système met fin à votre session utilisateur en cours et ferme toutes les applications et processus en cours d'exécution associés à cette session. Vous serez alors retourné à l'écran de connexion ou de l'invite de commande, selon le système d'exploitation que vous utilisez.
|
||||
|
||||
Notez que la commande ''logout'' ne ferme pas la session du système d'exploitation lui-même. Si vous voulez arrêter complètement votre système, vous devriez utiliser la commande [[informatique:linux:commandes:shutdown|shutdown]] ou [[informatique:linux:commandes:poweroff|poweroff]] selon le système d'exploitation que vous utilisez.
|
||||
26
data/pages/informatique/linux/commandes/ls.txt
Normal file
26
data/pages/informatique/linux/commandes/ls.txt
Normal file
@@ -0,0 +1,26 @@
|
||||
====== ls ======
|
||||
{{tag>"Linux commande"}}
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
|
||||
|
||||
La commande ''ls'' en Unix/Linux affiche la liste des fichiers et dossiers dans le répertoire courant.
|
||||
|
||||
Le paramètre ''-l'' indique à la commande ''ls'' de fournir un format de sortie détaillé, qui inclut les permissions, le nombre de liens physique, le propriétaire, le groupe, la taille, la date de modification et le nom des fichiers et dossiers.
|
||||
|
||||
Voici un exemple de sortie de la commande ls -l :
|
||||
<code BASH>
|
||||
total 16
|
||||
-rw-rw-r-- 1 john users 0 Jan 1 01:00 file1.txt
|
||||
-rw-rw-r-- 1 john users 0 Jan 1 01:00 file2.txt
|
||||
drwxrwxr-x 2 john users 512 Jan 1 01:00 folder1
|
||||
</code>
|
||||
|
||||
Dans cet exemple, la commande ''ls -l'' a affiché la liste de trois fichiers et dossiers dans le répertoire courant. La première ligne indique le nombre total de blocs occupés par les fichiers et dossiers listés. Les autres lignes fournissent des informations détaillées sur chaque fichier et dossier, y compris les **permissions** (les neuf premiers caractères), le nombre de **lien physique**, le **propriétaire**, le **groupe**, la **taille**, la **date de modification** et le **nom**.
|
||||
|
||||
Concernant le nombre de **lien physique**. Dans notre exemple, le chiffre "1" qui apparaît après les permissions des fichiers ''file1.txt'' et ''file2.txt'' indique qu'il y a un seul lien physique vers chacun de ces fichiers. Le chiffre "2" qui apparaît après les permissions du dossier ''folder1'' indique qu'il y a deux liens physiques vers ce dossier, un pour le nom du dossier lui-même et un pour le dossier parent (''.'').
|
||||
|
||||
Un **lien physique** est un lien vers un fichier ou un dossier qui est enregistré sur le disque. **Chaque fichier a au moins un lien physique**, qui est le nom du fichier lui-même. **Chaque dossier a au moins deux liens physiques**, un pour le nom du dossier lui-même et un pour le dossier parent. Un fichier ou un dossier peut avoir plusieurs liens physiques s'il est accessible par plusieurs noms ou s'il se trouve dans plusieurs répertoires.
|
||||
|
||||
Les liens physiques permettent de créer plusieurs accès à un même fichier ou dossier sans avoir à en créer une copie. Ils sont utiles pour éviter la duplication de données et pour créer des raccourcis vers des fichiers ou des dossiers.
|
||||
|
||||
La commande ''ls'' peut être utilisée avec d'autres paramètres pour afficher différentes informations ou pour afficher la liste des fichiers et dossiers dans d'autres répertoires que le répertoire courant.
|
||||
33
data/pages/informatique/linux/commandes/lsblk.txt
Normal file
33
data/pages/informatique/linux/commandes/lsblk.txt
Normal file
@@ -0,0 +1,33 @@
|
||||
====== lsblk ======
|
||||
|
||||
lsblk - lister les périphériques de type bloc
|
||||
|
||||
Abordons des généralités concernant les périphériques de type bloc. C'est comme cela que le système voit vos différents espace de stockage.
|
||||
|
||||
Un périphérique de type bloc représente un dispositif matériel qui lit ou écrit des données sous forme de blocs de taille fixe. Les programmes traditionnels n’utiliseront jamais de périphériques blocs. Bien qu’un lecteur de disque soit représenté comme un périphérique matériel, le contenu de chaque partition contient habituellement un système de fichiers monté sur l’arborescence racine de GNU/Linux.
|
||||
|
||||
La commande **lsblk** permet de lister les périphériques de type bloc. Elle se prononce "L.S." et "B.L.K." et les connaisseurs l'appelleront "ls block" (list block).
|
||||
|
||||
<code bash>
|
||||
$ lsblk
|
||||
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
|
||||
sdf 8:80 0 3,7T 0 disk
|
||||
sdd 8:48 0 1,8T 0 disk
|
||||
└─sdd1 8:49 0 1,8T 0 part /media/disk_14
|
||||
sdb 8:16 0 3,7T 0 disk
|
||||
└─sdb1 8:17 0 3,7T 0 part /media/disk_21
|
||||
sr0 11:0 1 1024M 0 rom
|
||||
sde 8:64 0 2,7T 0 disk
|
||||
└─sde1 8:65 0 2,7T 0 part /media/disk_20
|
||||
sdc 8:32 0 1,8T 0 disk
|
||||
└─sdc1 8:33 0 1,8T 0 part /media/disk_18
|
||||
sda 8:0 0 74,5G 0 disk
|
||||
├─sda2 8:2 0 15G 0 part /
|
||||
├─sda3 8:3 0 4G 0 part [SWAP]
|
||||
└─sda1 8:1 0 1G 0 part /boot
|
||||
</code>
|
||||
|
||||
{{ informatique:linux_lsblk.png?600 |Exemple de la commande lsblk}}
|
||||
|
||||
|
||||
Dans cet exemple, le disque vu depuis **/dev/sdf** n'a aucune partition et aucun point de montage.
|
||||
51
data/pages/informatique/linux/commandes/lsof.txt
Normal file
51
data/pages/informatique/linux/commandes/lsof.txt
Normal file
@@ -0,0 +1,51 @@
|
||||
====== lsof ======
|
||||
{{ :dummy.png?75x75|}}
|
||||
|
||||
----
|
||||
|
||||
''lsof'' signifie **List Open Files**. C'est un outil en ligne de commande qui vous permet de voir les fichiers ouverts par les processus en cours d'exécution sur votre système Linux. Chaque processus utilise des fichiers pour communiquer avec le système, les autres processus et les périphériques, et lsof vous montre les fichiers qui sont utilisés par chaque processus.
|
||||
|
||||
Avec **lsof**, vous pouvez voir les fichiers de tout type, tels que les fichiers réguliers, les fichiers de sockets, les pipes nommées, les fichiers de blocs et les fichiers de caractères, qui sont utilisés par les processus en cours d'exécution sur votre système. Vous pouvez également utiliser **lsof** pour trouver les processus qui écoutent sur des ports réseau spécifiques, ce qui est utile pour déterminer les services en cours d'exécution sur votre système et qui utilisent un port donné.
|
||||
|
||||
===== Installer lsof =====
|
||||
|
||||
**lsof** n'est pas installé par défaut sur toutes les distributions. Cependant, il est facilement disponible dans les dépôts officiels et peut être installé facilement.
|
||||
|
||||
Si vous essayez d'utiliser **lsof** et que le système ne le reconnaît pas, cela signifie probablement qu'il n'est pas installé.
|
||||
|
||||
sudo apt update
|
||||
sudo apt install lsof
|
||||
|
||||
Une fois l'installation terminée, vous pouvez utiliser la commande ''lsof'' pour afficher les fichiers ouverts par les processus en cours d'exécution.
|
||||
|
||||
===== Consulter les connexions TCP et UDP =====
|
||||
|
||||
L'option -i de la commande lsof permet de consulter les connexions TCP et UDP en cours d'utilisation sur votre système Linux.
|
||||
|
||||
Par exemple, la commande suivante affichera les processus qui écoutent sur le port 993 :
|
||||
|
||||
lsof -i :993
|
||||
|
||||
La sortie de cette commande vous montrera le nom du processus, le numéro de PID, le nom d'utilisateur et d'autres informations sur les processus qui écoutent sur le port 993.
|
||||
|
||||
L'option -i peut être combinée avec d'autres options de la commande lsof pour affiner les résultats, selon vos besoins. Par exemple, vous pouvez utiliser -i TCP pour afficher uniquement les processus qui utilisent des sockets TCP, ou -i UDP pour afficher uniquement les processus qui utilisent des sockets UDP.
|
||||
|
||||
--
|
||||
|
||||
La commande ''lsof -i'' permet d'afficher les fichiers ouverts par les processus qui utilisent des connexions réseau actives sur le système. Si vous utilisez la commande ''lsof -i'' sans spécifier de numéro de port, elle affichera toutes les connexions réseau actives sur le système, y compris les connexions TCP et UDP.
|
||||
|
||||
Cela peut être utile pour déterminer quels processus utilisent des connexions réseau, les adresses IP et les noms d'hôtes auxquels ils sont connectés, les ports locaux et distants utilisés pour la connexion, et d'autres informations sur les connexions réseau actives sur le système.
|
||||
|
||||
Notez que l'utilisation de ''lsof'' avec la commande ''sudo'' peut être nécessaire pour afficher toutes les connexions réseau, car certaines connexions peuvent être ouvertes par des processus qui n'appartiennent pas à votre utilisateur courant.
|
||||
|
||||
{{ :informatique:linux:commandes:pasted:20230217-185748.png }}
|
||||
|
||||
|
||||
===== Différence entre netstat et lsof =====
|
||||
|
||||
**netstat -tulpn** et **lsof -i** sont tous les deux des outils qui permettent d'obtenir des informations sur les connexions réseau en cours sur un système Linux.
|
||||
|
||||
Si vous souhaitez obtenir une vue complète des statistiques réseau sur votre système Linux, **netstat -tulpn** peut être la meilleure option. Si vous souhaitez obtenir des informations sur les fichiers ouverts par les processus en cours d'exécution, **lsof -i** peut être plus utile. Les deux outils peuvent être utiles selon les besoins, et vous pouvez utiliser celui qui vous convient le mieux en fonction de la tâche que vous souhaitez accomplir.
|
||||
|
||||
--- //[[user:cedricabonnel]]//
|
||||
|
||||
23
data/pages/informatique/linux/commandes/man.txt
Normal file
23
data/pages/informatique/linux/commandes/man.txt
Normal file
@@ -0,0 +1,23 @@
|
||||
====== man ======
|
||||
|
||||
La commande ''man'' permet d'accéder au **man**uel de la documentation d'une commande. Pour appeler le manuel de la commande **touch**, il faudra appeler la commande ''man touch''.
|
||||
|
||||
Le défilement du manuel se gère avec les flèches de directions haut et bas,\\
|
||||
la recherche de texte s'effectue avec la commande ''/'' suivi du texte recherché.\\
|
||||
Pour sortir du manuel, il suffit de taper la touche ''q''
|
||||
|
||||
===== Pour aller plus loin avec man =====
|
||||
|
||||
''man'' n'est pas limité aux commandes, il comprend de la documentation sur d'autres sections :
|
||||
- Programmes exécutables ou commandes de l'interpréteur de commandes (shell)
|
||||
- Appels système (fonctions fournies par le noyau)
|
||||
- Appels de bibliothèque (fonctions fournies par les bibliothèques des programmes)
|
||||
- Fichiers spéciaux (situés généralement dans /dev)
|
||||
- Formats des fichiers et conventions. Par exemple /etc/passwd
|
||||
- Jeux
|
||||
- Divers (y compris les macropaquets et les conventions), par exemple man(7), groff(7)
|
||||
- Commandes de gestion du système (généralement réservées au superutilisateur)
|
||||
- Sous-programmes du noyau [hors standard]
|
||||
|
||||
Par exemple ''printf'' est à la fois une commande (''man 1 printf'') et une fonction de la bibliothèque **stdio** (''man 3 printf'').
|
||||
|
||||
@@ -0,0 +1,51 @@
|
||||
====== hdparm ======
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
|
||||
Hdparm est un outil à utiliser lorsqu'il s'agit de diagnostiquer et régler un disque dur. Cet outil a été développé en 2005 par Mark Lord (canadien).
|
||||
|
||||
La commande la plus simple et la moins dangeureuse est la commande de demande d'informations :
|
||||
hdparm -I /dev/sda | more
|
||||
|
||||
---
|
||||
|
||||
Si un disque dur ou un SSD n'a rien à faire pendant un certain temps, il passe automatiquement en mode veille. Cette fonction d'économie d'énergie peut être influencée par le paramètre -B. Ainsi, en utilisant la commande suivante, elle désactiverait la gestion de l'énergie ; cependant, tous les lecteurs ne le permettent pas.
|
||||
|
||||
hdparm -B255 /dev/sda
|
||||
|
||||
Au lieu de 255, des valeurs comprises entre 1 et 254 sont autorisées. Une valeur plus élevée signifie que plus d'énergie est utilisée, mais promet également des performances ou une vitesse plus élevées. Les valeurs comprises entre 1 et 128 autorisent l'arrêt du disque, tandis que les valeurs comprises entre 129 et 254 l'interdisent.
|
||||
|
||||
La valeur 1 permet d'économiser le plus d'énergie, tandis que la valeur 254 permet d'atteindre le taux de transmission de données le plus élevé (performance E/S). Vous pouvez appeler la valeur actuelle avec :
|
||||
|
||||
hdparm -B /dev/sda
|
||||
|
||||
L'effet spécifique des différentes valeurs dépend du lecteur lui-même. Cependant, vous devez garder à l'esprit que trop d'arrêts ne sont pas bons pour les disques durs de bureau : Chaque fois qu'il s'éteint, le disque doit garer les têtes, ce qui augmente l'usure. Par conséquent, vous ne devriez pas réveiller votre disque dur toutes les deux secondes - ce qui prend toujours plus de deux secondes.
|
||||
|
||||
---
|
||||
|
||||
Vous pouvez définir le nombre de secondes d'inactivité que le disque dur doit attendre avant de se mettre en veille avec la commande
|
||||
|
||||
hdparm -S 128 /dev/sda
|
||||
|
||||
Cependant, cette valeur n'est pas exprimée en secondes mais en un nombre compris entre 1 et 253. Le disque dur multiplie cette valeur par une autre. La valeur choisie dans l'exemple, 128, se situe entre 1 et 240, pour laquelle le disque utilise un facteur de cinq. Par conséquent, il s'arrêterait après 640 secondes d'inactivité.
|
||||
|
||||
A partir de 241, le facteur de multiplication augmente régulièrement. À 251, la période d'attente est passée à 5,5 heures. À 253, la valeur est prédéfinie par le fabricant, généralement entre 8 et 12 heures. La valeur 254 est omise ; à 255, le variateur attendra 21 minutes et 15 secondes. Une valeur de 0 désactive complètement le mode veille.
|
||||
|
||||
Exemple :
|
||||
<code>
|
||||
sudo hdparm -S 120 /dev/sda
|
||||
|
||||
/dev/sda:
|
||||
setting standby to 120 (10 minutes)
|
||||
</code>
|
||||
|
||||
---
|
||||
|
||||
Pour mettre le disque dur en veille immédiatement, entrez :
|
||||
|
||||
hdparm -y /dev/sda
|
||||
|
||||
Avec un Y majuscule, le disque passera dans un état de veille encore plus profond. Selon le disque, il se peut que le disque ne se réveille d'un état de sommeil profond qu'après une réinitialisation de l'ensemble du système.
|
||||
|
||||
|
||||
|
||||
|
||||
43
data/pages/informatique/linux/commandes/mkdir.txt
Normal file
43
data/pages/informatique/linux/commandes/mkdir.txt
Normal file
@@ -0,0 +1,43 @@
|
||||
====== mkdir ======
|
||||
{{ :dummy.png?75x75}}
|
||||
|
||||
Sous Linux, la commande ''mkdir'' permet de créer un nouveau répertoire ou dossier. La syntaxe de base de la commande est la suivante :
|
||||
|
||||
mkdir [options] nom_du_répertoire
|
||||
|
||||
Le paramètre ''nom_du_répertoire'' est le nom que vous voulez donner au nouveau répertoire que vous allez créer.
|
||||
|
||||
Il existe plusieurs options que vous pouvez utiliser avec la commande ''mkdir''. Voici quelques-unes des options les plus courantes :
|
||||
|
||||
* ''-p'' : cette option permet de créer plusieurs répertoires en une seule commande, en créant les répertoires parents si besoin.
|
||||
|
||||
* ''-m'' : cette option permet de définir les permissions pour le nouveau répertoire.
|
||||
|
||||
* ''-v'' : cette option affiche un message pour chaque répertoire créé.
|
||||
|
||||
Par exemple, si vous voulez créer un nouveau répertoire appelé ''nouveau_dossier'', vous pouvez utiliser la commande suivante :
|
||||
|
||||
mkdir nouveau_dossier
|
||||
|
||||
Si vous voulez créer un nouveau répertoire et ses répertoires parents en même temps, vous pouvez utiliser l'option ''-p'' :
|
||||
|
||||
mkdir -p repertoire_parent/nouveau_dossier
|
||||
|
||||
Cela créera un nouveau répertoire appelé ''nouveau_dossier'' dans le répertoire ''repertoire_parent'', en créant le répertoire parent ''repertoire_parent'' s'il n'existe pas déjà.
|
||||
|
||||
Voici quelques spécificités et pièges à prendre en compte lors de l'utilisation de la commande ''mkdir'' sous Linux :
|
||||
|
||||
* Les noms de fichiers et de répertoires sous Linux sont sensibles à la casse, ce qui signifie que ''monDossier'' et ''mondossier'' sont deux noms différents. Assurez-vous de bien saisir le nom du répertoire que vous souhaitez créer.
|
||||
|
||||
* La commande ''mkdir'' ne crée pas automatiquement les répertoires parents, sauf si vous utilisez l'option ''-p''. Si vous essayez de créer un répertoire dans un répertoire qui n'existe pas, vous obtiendrez une erreur.
|
||||
|
||||
* Les noms de fichiers et de répertoires peuvent contenir des caractères spéciaux, tels que des espaces ou des points. Cependant, il est recommandé d'utiliser des noms de fichiers et de répertoires sans espaces ni caractères spéciaux pour éviter les problèmes lors de l'utilisation de la ligne de commande.
|
||||
|
||||
* La commande ''mkdir'' ne vérifie pas si un répertoire portant le même nom existe déjà. Si vous essayez de créer un répertoire qui existe déjà, vous obtiendrez une erreur. Pour éviter cela, vous pouvez utiliser la commande ''ls'' pour vérifier si le répertoire existe déjà avant d'utiliser la commande ''mkdir''.
|
||||
|
||||
* Si vous n'avez pas les autorisations nécessaires pour créer un répertoire dans un certain emplacement, vous obtiendrez une erreur. Assurez-vous d'avoir les autorisations nécessaires pour créer un répertoire dans l'emplacement souhaité.
|
||||
|
||||
|
||||
--- //[[user:jeanserien]]//
|
||||
|
||||
|
||||
15
data/pages/informatique/linux/commandes/mtr.txt
Normal file
15
data/pages/informatique/linux/commandes/mtr.txt
Normal file
@@ -0,0 +1,15 @@
|
||||
====== mtr ======
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
|
||||
**mtr** (ou "My Trace Route") est un outil de dépannage de réseau pour Linux qui combine les fonctionnalités de [[.:ping]] et [[.:traceroute]]. Il permet de suivre l'itinéraire qu'un paquet de données prend pour atteindre un hôte distant, ainsi que de mesurer la qualité de chaque étape de cet itinéraire en affichant les temps de réponse et les taux de paquets perdus. Il est utile pour identifier les points de congestion ou les erreurs de configuration sur un réseau.
|
||||
|
||||
**mtr** est généralement disponible dans les dépôts de paquets de la plupart des distributions Linux. Il peut donc être installé en utilisant un gestionnaire de paquets tel que **apt** (pour Debian et Ubuntu), **yum** (pour CentOS et Fedora) ou **pacman** (pour Arch Linux). Il peut également être téléchargé et compilé à partir du code source disponible sur le site web du projet : https://www.bitwizard.nl/mtr/
|
||||
Il est souvent nécessaire d'être administrateur ou utilisateur root pour installer ou utiliser mtr.
|
||||
|
||||
Exemple d'utilisation :
|
||||
mtr abonnel.fr
|
||||
|
||||
{{ :informatique:linux:commandes:pasted:20230130-090351.png |Exemple d'utilisation de mtr sous Linux Fedora}}
|
||||
|
||||
--- //[[user:cedricabonnel]], [[user:CPT]] //
|
||||
|
||||
83
data/pages/informatique/linux/commandes/mv.txt
Normal file
83
data/pages/informatique/linux/commandes/mv.txt
Normal file
@@ -0,0 +1,83 @@
|
||||
====== mv ======
|
||||
{{ :dummy.png?75x75|Déplacer ou renommer des fichiers et des répertoires}}
|
||||
|
||||
La commande ''mv'' est une commande de la ligne de commande utilisée pour déplacer ou renommer des fichiers et des répertoires dans un système d'exploitation de type Unix. Le nom ''mv'' signifie ''move'' en anglais, ce qui se traduit par ''déplacer'' en français.
|
||||
|
||||
La syntaxe générale de la commande ''mv'' est la suivante :
|
||||
|
||||
<code BASH>
|
||||
mv [options] source destination
|
||||
</code>
|
||||
|
||||
Voici quelques exemples d'utilisation courante de la commande ''mv'' :
|
||||
|
||||
-- Déplacer un fichier ''file.txt'' du répertoire courant vers un autre répertoire :
|
||||
|
||||
<code BASH>
|
||||
mv file.txt /chemin/vers/nouveau/repertoire/
|
||||
</code>
|
||||
|
||||
-- Renommer un fichier ''file.txt'' en ''newfile.txt'' :
|
||||
|
||||
<code BASH>
|
||||
mv file.txt newfile.txt
|
||||
</code>
|
||||
|
||||
-- Déplacer un répertoire ''mydir'' du répertoire courant vers un autre répertoire :
|
||||
|
||||
<code BASH>
|
||||
mv mydir /chemin/vers/nouveau/repertoire/
|
||||
</code>
|
||||
|
||||
-- Renommer un répertoire ''mydir'' en ''newdir'' :
|
||||
|
||||
<code BASH>
|
||||
mv mydir newdir
|
||||
</code>
|
||||
|
||||
----
|
||||
|
||||
Pour faciliter votre travail et gagner du temps, voici quelques exemples que vous pouvez utiliser avec la commande ''mv'' :
|
||||
|
||||
-- Utiliser l'option ''-i'' pour demander une confirmation avant d'écraser un fichier existant lors d'un déplacement :
|
||||
|
||||
<code BASH>
|
||||
mv -i fichier.txt nouveau_dossier/
|
||||
</code>
|
||||
|
||||
-- Utiliser l'option ''-v'' pour afficher les fichiers qui sont déplacés :
|
||||
|
||||
<code BASH>
|
||||
mv -v fichier.txt nouveau_dossier/
|
||||
</code>
|
||||
|
||||
-- Utiliser l'option ''-u'' pour ne déplacer un fichier que s'il est plus récent que sa version existante dans le répertoire de destination :
|
||||
|
||||
<code BASH>
|
||||
mv -u fichier.txt nouveau_dossier/
|
||||
</code>
|
||||
|
||||
-- Utiliser l'option ''--backup'' pour créer une copie de sauvegarde des fichiers existants avant de les écraser :
|
||||
|
||||
<code BASH>
|
||||
mv --backup fichier.txt nouveau_dossier/
|
||||
</code>
|
||||
|
||||
-- Créer un [[informatique:linux:commandes:alias|alias]] pour éviter de saisir souvent la même commande, par exemple :
|
||||
|
||||
<code BASH>
|
||||
alias mvc='mv -v --backup'
|
||||
</code>
|
||||
|
||||
Cela crée un alias ''mvc'' qui déplace les fichiers en affichant une sortie verbale et en créant une copie de sauvegarde.
|
||||
|
||||
-- Utiliser un caractère générique ou une expression régulière pour déplacer plusieurs fichiers qui correspondent à un modèle donné :
|
||||
|
||||
<code BASH>
|
||||
mv *.txt nouveau_dossier/
|
||||
</code>
|
||||
|
||||
Cela déplace tous les fichiers qui ont l'extension ''.txt'' dans le répertoire actuel vers le répertoire ''nouveau_dossier''.
|
||||
|
||||
Ces astuces et alias peuvent être personnalisés en fonction de vos besoins et de votre façon de travailler avec la commande ''mv''.
|
||||
|
||||
114
data/pages/informatique/linux/commandes/nmap.txt
Normal file
114
data/pages/informatique/linux/commandes/nmap.txt
Normal file
@@ -0,0 +1,114 @@
|
||||
====== nmap ======
|
||||
|
||||
{{ :dummy.png?75x75|scanner les réseaux}}
|
||||
|
||||
La commande ''nmap'' est un outil en ligne de commande utilisé pour scanner les réseaux et les hôtes pour découvrir des informations sur les ports ouverts, les services en cours d'exécution, les systèmes d'exploitation et les vulnérabilités potentielles. C'est un outil très populaire pour les administrateurs système, les professionnels de la sécurité et les hackers éthiques pour explorer et auditer les réseaux.
|
||||
|
||||
La commande ''nmap'' est très flexible et peut être utilisée pour scanner des plages d'adresses IP, des hôtes individuels ou des noms de domaine. Elle peut également être utilisée pour effectuer des scans de port simples ou avancés, des scans de vulnérabilités et des scans de scripts personnalisés.
|
||||
|
||||
===== Installation =====
|
||||
|
||||
Vous pouvez installer ''nmap'' à l'aide de votre gestionnaire de paquets système. Voici comment installer Nmap sur les distributions Linux les plus courantes :
|
||||
|
||||
-- Ubuntu et Debian :
|
||||
|
||||
<code BASH>
|
||||
sudo apt update
|
||||
sudo apt install nmap
|
||||
</code>
|
||||
|
||||
-- Fedora :
|
||||
|
||||
<code BASH>
|
||||
sudo dnf install nmap
|
||||
</code>
|
||||
|
||||
-- CentOS et RHEL :
|
||||
|
||||
<code BASH>
|
||||
sudo yum install nmap
|
||||
</code>
|
||||
|
||||
-- Arch Linux :
|
||||
<code BASH>
|
||||
sudo pacman -S nmap
|
||||
</code>
|
||||
|
||||
----
|
||||
|
||||
Une fois que vous avez installé Nmap, vous pouvez l'utiliser en exécutant la commande ''nmap'' dans un terminal.
|
||||
|
||||
|
||||
===== Exemples =====
|
||||
|
||||
Voici quelques exemples de commandes ''nmap'' sous Linux :
|
||||
|
||||
-- Scanner les ports ouverts d'un hôte :
|
||||
|
||||
<code BASH>
|
||||
nmap <ip-address>
|
||||
</code>
|
||||
|
||||
Cela va scanner tous les ports ouverts de l'hôte spécifié.
|
||||
|
||||
-- Scanner les ports ouverts d'une plage d'adresses IP :
|
||||
|
||||
<code BASH>
|
||||
nmap <ip-address-range>
|
||||
</code>
|
||||
|
||||
Cela va scanner tous les ports ouverts de la plage d'adresses IP spécifiée.
|
||||
|
||||
<button collapse="plage-d-adresses-ip">Plus d'infos sur la plage d'adresses IP</button>
|
||||
|
||||
<collapse id="plage-d-adresses-ip" collapsed="true"><well>
|
||||
Il existe plusieurs façons de spécifier une **plage d'adresses IP** en utilisant ''nmap''. Voici quelques exemples :
|
||||
|
||||
-- Spécifier **une plage d'adresses IP** en utilisant une **notation CIDR** (Classless Inter-Domain Routing) :
|
||||
|
||||
nmap 192.168.0.0/24
|
||||
|
||||
Cela va scanner tous les hôtes de la plage d'adresses IP 192.168.0.0 à 192.168.0.255.
|
||||
|
||||
-- **Spécifier une plage d'adresses IP** en utilisant une **notation hybride** :
|
||||
|
||||
nmap 192.168.0-255.1-254
|
||||
|
||||
Cela va scanner tous les hôtes de la plage d'adresses IP 192.168.0.1 à 192.168.0.254 et de 192.168.1.1 à 192.168.1.254.
|
||||
|
||||
-- **Spécifier plusieurs plages d'adresses IP** en utilisant une **virgule** pour séparer les plages :
|
||||
|
||||
nmap 192.168.0.0/24,10.0.0.0/8
|
||||
|
||||
Cela va scanner tous les hôtes des plages d'adresses IP 192.168.0.0 à 192.168.0.255 et de 10.0.0.0 à 10.255.255.255.
|
||||
|
||||
Il existe d'autres façons de spécifier des plages d'adresses IP avec Nmap, telles que l'utilisation de fichiers de listes d'adresses IP ou l'utilisation d'expressions régulières.
|
||||
</well></collapse>
|
||||
|
||||
-- Scanner les ports ouverts d'un hôte et afficher les informations sur les services en cours d'exécution :
|
||||
|
||||
<code BASH>
|
||||
nmap -sV <ip-address>
|
||||
</code>
|
||||
|
||||
Cela va scanner tous les ports ouverts de l'hôte spécifié et afficher les informations sur les services en cours d'exécution.
|
||||
|
||||
-- Scanner les ports ouverts d'un hôte et afficher les informations sur le système d'exploitation :
|
||||
|
||||
<code BASH>
|
||||
nmap -O <ip-address>
|
||||
</code>
|
||||
|
||||
Cela va scanner tous les ports ouverts de l'hôte spécifié et tenter de déterminer le système d'exploitation en cours d'exécution.
|
||||
|
||||
-- Scanner les ports ouverts d'un hôte en utilisant un script personnalisé :
|
||||
|
||||
<code BASH>
|
||||
nmap --script=<script-name> <ip-address>
|
||||
</code>
|
||||
|
||||
Cela va scanner tous les ports ouverts de l'hôte spécifié en utilisant le script personnalisé spécifié.
|
||||
|
||||
----
|
||||
|
||||
Il existe de nombreuses autres options et paramètres que vous pouvez utiliser avec la commande nmap, vous pouvez consulter la page de manuel en tapant man nmap dans votre terminal pour plus d'informations.
|
||||
118
data/pages/informatique/linux/commandes/passwd.txt
Normal file
118
data/pages/informatique/linux/commandes/passwd.txt
Normal file
@@ -0,0 +1,118 @@
|
||||
====== passwd ======
|
||||
{{ :dummy.png?75x75|Changer de mot de passe}}
|
||||
|
||||
La commande ''passwd'' est une commande utilisée dans les systèmes d'exploitation de type Unix, tel que Linux, pour changer le mot de passe d'un utilisateur.
|
||||
|
||||
Lorsqu'un utilisateur exécute la commande ''passwd'' dans un terminal, le système lui demande d'abord de saisir son ancien mot de passe pour vérifier son identité. Ensuite, il lui est demandé de saisir le nouveau mot de passe deux fois pour s'assurer qu'il a été correctement saisi. Si les deux saisies sont identiques, le système enregistre le nouveau mot de passe.
|
||||
|
||||
Seuls les utilisateurs ayant les droits d'administration (tels que l'utilisateur ''root'' dans Linux) peuvent utiliser la commande ''passwd'' pour changer les mots de passe des autres utilisateurs.
|
||||
|
||||
Il est généralement déconseillé d'utiliser la commande ''passwd'' dans un script, car cela nécessiterait de saisir le mot de passe manuellement à chaque fois que le script est exécuté, ce qui peut ne pas être pratique ou sûr.
|
||||
|
||||
Au lieu de cela, pour changer le mot de passe d'un utilisateur dans un script, il est recommandé d'utiliser la commande [[.:chpasswd]]. Cette commande permet de changer le mot de passe d'un utilisateur en fournissant le nom d'utilisateur et le nouveau mot de passe directement en ligne de commande ou en utilisant des fichiers de texte.
|
||||
|
||||
===== Changer son mot de passe =====
|
||||
|
||||
Pour changer votre mot de passe sous Linux en utilisant Bash, vous pouvez utiliser la commande ''passwd''. Voici les étapes à suivre :
|
||||
|
||||
* Ouvrez un terminal Bash.
|
||||
|
||||
* Entrez la commande ''passwd'' suivie de votre nom d'utilisateur Linux. Si vous êtes déjà connecté sous votre propre compte, vous pouvez omettre le nom d'utilisateur et simplement taper ''passwd'' pour changer votre propre mot de passe.
|
||||
|
||||
passwd nom_utilisateur
|
||||
|
||||
* Vous serez alors invité à entrer votre mot de passe actuel pour vous authentifier.
|
||||
|
||||
* Ensuite, vous serez invité à saisir votre nouveau mot de passe deux fois, pour confirmer qu'il est correct.
|
||||
|
||||
* Une fois que vous avez entré votre nouveau mot de passe, celui-ci sera mis à jour.
|
||||
|
||||
Si tout s'est bien passé, vous devriez voir un message indiquant que votre mot de passe a été mis à jour avec succès. Vous pouvez maintenant utiliser votre nouveau mot de passe pour vous connecter à votre compte Linux.
|
||||
|
||||
Lorsque vous changez votre mot de passe sur un système Linux, il est important de mettre à jour tous les autres secrets qui l'utilisent. Voici une liste de certains des secrets qui peuvent nécessiter une mise à jour :
|
||||
|
||||
* Clés SSH : si vous utilisez des clés SSH pour vous connecter à des serveurs ou pour effectuer des opérations automatisées, vous devez mettre à jour les clés pour refléter votre nouveau mot de passe.
|
||||
|
||||
* Certificats SSL/TLS : si vous utilisez des certificats SSL/TLS pour sécuriser des connexions sur des sites web ou des applications, vous devez mettre à jour les certificats pour refléter votre nouveau mot de passe.
|
||||
|
||||
* Configuration de l'application : si vous utilisez une application qui stocke votre mot de passe, vous devez mettre à jour la configuration de l'application pour refléter votre nouveau mot de passe.
|
||||
|
||||
* Services tiers : si vous utilisez des services tiers tels que des services de stockage de fichiers en ligne, des services de messagerie, etc., vous devez mettre à jour les informations d'identification de votre compte pour refléter votre nouveau mot de passe.
|
||||
|
||||
Voici un exemple de script Bash qui vous permettra de mettre à jour plusieurs secrets après avoir changé votre mot de passe :
|
||||
|
||||
<code BASH>
|
||||
#!/bin/bash
|
||||
|
||||
# Mettre à jour les clés SSH
|
||||
for keyfile in ~/.ssh/*
|
||||
do
|
||||
if ssh-keygen -y -f "$keyfile" >/dev/null 2>&1 ; then
|
||||
echo "Mise à jour du mot de passe pour la clé : $keyfile"
|
||||
pwfile="${keyfile}.password"
|
||||
if [ -f "$pwfile" ]; then
|
||||
password=$(cat "$pwfile")
|
||||
else
|
||||
password=$(openssl rand -base64 32 | tr -d '=')
|
||||
fi
|
||||
echo "$password" > "$pwfile"
|
||||
chmod 600 "$pwfile"
|
||||
ssh-keygen -p -P "$password" -f "$keyfile"
|
||||
fi
|
||||
done
|
||||
|
||||
# Mettre à jour les certificats SSL/TLS
|
||||
# (vous devez remplacer les noms de fichiers et de dossiers par les vôtres)
|
||||
sudo openssl rsa -in /etc/ssl/private/server.key -out /etc/ssl/private/server.key
|
||||
sudo openssl req -key /etc/ssl/private/server.key -new -out /etc/ssl/certs/server.csr
|
||||
sudo openssl x509 -req -days 365 -in /etc/ssl/certs/server.csr -signkey /etc/ssl/private/server.key -out /etc/ssl/certs/server.crt
|
||||
|
||||
# Mettre à jour la configuration de l'application
|
||||
# (vous devez remplacer les noms de fichiers et de dossiers par les vôtres)
|
||||
sudo sed -i 's/ancien_mot_de_passe/nouveau_mot_de_passe/g' /etc/application/config.ini
|
||||
|
||||
# Mettre à jour les informations d'identification pour les services tiers
|
||||
# (vous devez remplacer les noms d'utilisateur et les mots de passe par les vôtres)
|
||||
echo 'ancien_nom_utilisateur:ancien_mot_de_passe' | sudo chpasswd
|
||||
echo 'nouveau_nom_utilisateur:nouveau_mot_de_passe' | sudo chpasswd
|
||||
</code>
|
||||
|
||||
Ce script utilise les commandes standard Linux pour mettre à jour les secrets courants qui peuvent nécessiter une mise à jour. Vous devez remplacer les noms de fichiers, de dossiers, d'utilisateurs, de mots de passe et autres informations par les vôtres. Vous pouvez également ajouter ou supprimer des commandes en fonction de vos besoins spécifiques.
|
||||
|
||||
Notez que certaines commandes dans ce script nécessitent des privilèges d'administration, vous devrez donc peut-être exécuter le script avec le compte d'utilisateur ayant ces privilèges ou utiliser la commande ''sudo''.
|
||||
===== Créer un compte utilisateur =====
|
||||
|
||||
Pour créer un compte utilisateur, il est nécessaire d'utiliser le commande ''passwd''. Consultez la page concernant la commande [[informatique:linux:commandes:useradd|useradd]].
|
||||
|
||||
|
||||
===== Forcer un utilisateur à changer son mot de passe au prochain démarrage =====
|
||||
|
||||
Sous Linux, vous pouvez utiliser la commande "**passwd**" avec l'option "-e" pour forcer un utilisateur à changer son mot de passe au prochain démarrage. La commande est généralement utilisée par un administrateur pour changer le mot de passe d'un utilisateur. Voici un exemple :
|
||||
|
||||
<code BASH>
|
||||
sudo passwd -e <username>
|
||||
</code>
|
||||
|
||||
Cela forcera l'utilisateur <username> à changer son mot de passe lors de sa prochaine connexion. À noter que cette commande n'affectera pas les utilisateurs connectés en ce moment.
|
||||
|
||||
Vous pouvez vérifier le fichier de ''/etc/shadow'' contenant les informations cryptées des utilisateurs, que la date (en jours depuis le 1er janvier 1970) à laquelle le mot de passe a été modifié pour la dernière fois soit à la valeur 0.
|
||||
|
||||
<code BASH>
|
||||
sudo cat /etc/shadow | grep <username>
|
||||
</code>
|
||||
|
||||
Vous pouvez utiliser la commande ''chage'' avec l'option ''-l'' pour afficher les informations de l'utilisateur, et vérifier que la date d'expiration du mot de passe est définie sur la mention ''password must be changed'' / ''le mot de passe doit être changé'' apparaisse.
|
||||
|
||||
<code BASH>
|
||||
sudo chage -l <username>
|
||||
</code>
|
||||
|
||||
Vous pouvez utiliser la commande ''passwd'' avec l'option ''-S'' pour vérifier les informations de l'utilisateur, et vérifier que la date d'expiration du mot de passe est définie sur un jour antérieur à aujourd'hui (par exemple le ''1970-01-01'') .
|
||||
|
||||
<code BASH>
|
||||
sudo passwd -S <username>
|
||||
</code>
|
||||
|
||||
===== Changer de mot de passe dans un script =====
|
||||
|
||||
Voir la commande [[informatique:linux:commandes:chpasswd|chpasswd]]
|
||||
30
data/pages/informatique/linux/commandes/poweroff.txt
Normal file
30
data/pages/informatique/linux/commandes/poweroff.txt
Normal file
@@ -0,0 +1,30 @@
|
||||
====== poweroff ======
|
||||
|
||||
~~TechArticle~~
|
||||
|
||||
C'est un programme Linux présent dans ''/usr/sbin/''. Par conséquent il doit être appelé avec les droits ''root''. Il permet d'arrêter l'ordinateur, alimentation arrêtée. ''poweroff'' est la concaténation de ''power'' et ''off''.
|
||||
|
||||
Le programme fait partie du groupe [[.:shutdown]], [[.:reboot]], [[.:halt]] et [[.:poweroff]], tous ayant un lien symbolique avec [[.:systemctl]] quand le système est piloté avec SystemD.
|
||||
|
||||
===== - Exemples =====
|
||||
|
||||
==== - Appel standard ====
|
||||
|
||||
<code>
|
||||
$ sudo systemctl poweroff
|
||||
</code>
|
||||
==== - Éteindre un ordinateur à distance avec root ====
|
||||
|
||||
L'ordinateur distant est ''rpitst001.acegrp.lan''. J'utilise la commande ''ssh'' pour exécuter une commande à distance (option -t). Le compte utilisé sur l'ordinateur distant est ''root''.
|
||||
|
||||
<code>
|
||||
$ ssh -t root@rpitst001.acegrp.lan 'systemctl poweroff'
|
||||
</code>
|
||||
|
||||
==== - Éteindre un ordinateur à distance ====
|
||||
|
||||
L'ordinateur distant est ''rpitst001.acegrp.lan''. J'utilise la commande ''ssh'' pour exécuter une commande à distance (option -t). Le compte utilisé sur l'ordinateur distant est ''cedric''. Ce compte utilisateur à le droit d'utiliser la commande ''sudo'' sur ''rpitst001.acegrp.lan''.
|
||||
|
||||
<code>
|
||||
$ ssh -t cedric@rpitst001.acegrp.lan 'sudo systemctl poweroff'
|
||||
</code>
|
||||
23
data/pages/informatique/linux/commandes/pwd.txt
Normal file
23
data/pages/informatique/linux/commandes/pwd.txt
Normal file
@@ -0,0 +1,23 @@
|
||||
====== pwd ======
|
||||
{{ :dummy.png?75x75}}
|
||||
|
||||
La commande ''pwd'' sous Linux (et d'autres systèmes d'exploitation similaires à Unix) signifie "Print Working Directory" (Afficher le répertoire de travail en français). Elle affiche le chemin complet du répertoire actuel dans lequel vous vous trouvez dans le système de fichiers.
|
||||
|
||||
Lorsque vous utilisez la commande ''pwd'', le système d'exploitation affiche le chemin complet à partir de la racine du système de fichiers jusqu'au répertoire courant. Cette commande est utile pour vous aider à comprendre où vous vous trouvez dans la structure des répertoires de votre système de fichiers et pour vous aider à naviguer vers d'autres répertoires en utilisant des chemins relatifs ou absolus.
|
||||
|
||||
La commande "pwd" a peu d'options, mais en voici quelques-unes qui peuvent être utiles :
|
||||
|
||||
* ''-P'' : Cette option force la résolution des liens symboliques présents dans le chemin affiché. Si votre répertoire courant contient des liens symboliques qui pointent vers d'autres répertoires, l'option ''-P'' affichera le chemin complet de ces répertoires. Par défaut, **pwd** affiche le chemin du répertoire courant sans suivre les liens symboliques.
|
||||
|
||||
* ''-L'' : Cette option est l'inverse de l'option ''-P''. Elle force **pwd** à ne pas suivre les liens symboliques dans le chemin affiché. Si votre répertoire courant contient des liens symboliques qui pointent vers d'autres répertoires, l'option "-L" affichera le chemin complet du répertoire courant sans suivre les liens symboliques.
|
||||
|
||||
* ''--help'' : Cette option affiche le message d'aide pour la commande **pwd**, qui résume les options disponibles.
|
||||
|
||||
* ''--version'' : Cette option affiche la version de la commande **pwd** installée sur votre système.
|
||||
|
||||
{{ :informatique:linux:commandes:pasted:20230217-003418.png }}
|
||||
|
||||
--- //[[user:jeanserien]]//
|
||||
|
||||
|
||||
|
||||
12
data/pages/informatique/linux/commandes/reboot.txt
Normal file
12
data/pages/informatique/linux/commandes/reboot.txt
Normal file
@@ -0,0 +1,12 @@
|
||||
====== reboot ======
|
||||
|
||||
C'est un programme présent dans ''/usr/sbin/''. Par conséquent il doit être appelé avec les droits ''root''. Il permet de redémarrer l'ordinateur.
|
||||
|
||||
Le programme fait partie du groupe [[.:shutdown]], [[.:reboot]], [[.:halt]] et [[.:poweroff]], tous ayant un lien symbolique avec [[.:systemctl]] quand le système est piloté avec SystemD.
|
||||
|
||||
Par bonne habitude, il vaut mieux utiliser la commande :
|
||||
<code>
|
||||
sudo systemctl reboot
|
||||
</code>
|
||||
|
||||
Vous pouvez aussi appuyer sur la combinaison de touches Ctrl+Alt+Del.
|
||||
19
data/pages/informatique/linux/commandes/rm.txt
Normal file
19
data/pages/informatique/linux/commandes/rm.txt
Normal file
@@ -0,0 +1,19 @@
|
||||
====== rm ======
|
||||
{{ :dummy.png?75x75|remove}}
|
||||
|
||||
La commande ''rm'' sur Linux est une commande qui permet de supprimer des fichiers ou des répertoires. ''rm'' est l'abréviation de **remove** (supprimer) et elle est utilisée pour supprimer des fichiers ou des répertoires de manière permanente.
|
||||
|
||||
La syntaxe de base de la commande ''rm'' est la suivante :
|
||||
|
||||
rm [options] fichier1 fichier2 ...
|
||||
|
||||
Par exemple, pour supprimer un fichier nommé ''mon_fichier.txt'', on peut utiliser la commande :
|
||||
|
||||
rm mon_fichier.txt
|
||||
|
||||
La commande ''rm'' supprime les fichiers de manière permanente et qu'il n'y a pas de moyen simple de récupérer les fichiers supprimés à l'aide de cette commande. Il est donc important de faire attention lors de l'utilisation de la commande ''rm'' et de vérifier que le ou les fichiers à supprimer sont bien ceux que vous souhaitez supprimer.
|
||||
|
||||
Pour effacer des fichiers ou des répertoires avec une notion de corbeille (c'est-à-dire, les déplacer vers un dossier spécial au lieu de les supprimer définitivement), vous pouvez utiliser la commande [[.:trash-put]].
|
||||
|
||||
|
||||
|
||||
25
data/pages/informatique/linux/commandes/rmdir.txt
Normal file
25
data/pages/informatique/linux/commandes/rmdir.txt
Normal file
@@ -0,0 +1,25 @@
|
||||
====== rmdir ======
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
|
||||
La commande ''rmdir'' est une commande en ligne de commande utilisée dans les systèmes d'exploitation de type Unix et Linux pour supprimer des répertoires (ou dossiers) vides. Le nom ''rmdir'' est une contraction de //remove directory//.
|
||||
|
||||
Lorsqu'on exécute la commande ''rmdir'' suivi du nom du répertoire à supprimer, le système supprime le répertoire uniquement s'il est vide. Si le répertoire contient des fichiers ou des sous-répertoires, la commande renverra une erreur.
|
||||
|
||||
Par exemple, pour supprimer le répertoire nommé ''monDossier'', la commande à exécuter est la suivante :
|
||||
|
||||
rmdir monDossier
|
||||
|
||||
Si le répertoire n'est pas vide, vous pouvez utiliser la commande ''rm -r'' pour supprimer le répertoire et tout son contenu. Cependant, soyez très prudent lors de l'utilisation de cette commande, car elle peut supprimer des fichiers et des répertoires de manière irréversible.
|
||||
|
||||
|
||||
<WRAP center round important 60%>
|
||||
La commande ''rm -fr /' est extrêmement dangereuse et elle peut entraîner la suppression de tout le système de fichiers sur lequel elle est exécutée, y compris les fichiers du système d'exploitation, les fichiers de configuration, les programmes, les données utilisateur, etc.
|
||||
</WRAP>
|
||||
|
||||
Cependant, la commande n'est pas protégée par défaut sur les systèmes d'exploitation de type Unix et Linux. Si vous exécutez cette commande en tant qu'utilisateur avec des privilèges d'administration, elle supprimera tout le système de fichiers.
|
||||
|
||||
L'exécution de cette commande peut causer des dommages irréparables à votre système et il est presque impossible de récupérer les fichiers supprimés. Il est donc très important d'utiliser cette commande avec une extrême prudence et uniquement lorsque vous êtes sûr de ce que vous faites.
|
||||
|
||||
En général, il est recommandé d'éviter d'utiliser cette commande ou toute autre commande potentiellement dangereuse si vous n'êtes pas certain de ce qu'elle fera et des conséquences qu'elle aura sur votre système.
|
||||
|
||||
|
||||
18
data/pages/informatique/linux/commandes/scp.txt
Normal file
18
data/pages/informatique/linux/commandes/scp.txt
Normal file
@@ -0,0 +1,18 @@
|
||||
{{ :dummy.png?75x75|Secure CoPy est un programme permettant la copie entre deux ordinateurs réliés par un réseau.}}
|
||||
|
||||
====== scp ======
|
||||
{{tag>"commande linux"}}
|
||||
|
||||
{{METATOC 2-5}}
|
||||
\\
|
||||
|
||||
Secure CoPy est un programme permettant la copie entre deux ordinateurs réliés par un réseau.
|
||||
|
||||
===== Exemple d'utilisation =====
|
||||
|
||||
scp -Cp /var/www cedric@lola.court.fr:/var/www/
|
||||
|
||||
* ''C'' active l'alogrithme de compression pendant la copie.
|
||||
* ''p'' conserve les dates de modification et de dernier accès, ainsi que les modes du fichier après copie.
|
||||
|
||||
|
||||
30
data/pages/informatique/linux/commandes/setfacl.txt
Normal file
30
data/pages/informatique/linux/commandes/setfacl.txt
Normal file
@@ -0,0 +1,30 @@
|
||||
====== setfacl ======
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
|
||||
La commande ''setfacl'' définit les ACLs pour les fichiers et les répertoires. Les ACLs sont des mécanismes de sécurité avancés qui permettent de définir des autorisations plus précises que les permissions de base UNIX (par exemple, en permettant à plusieurs utilisateurs ou groupes d'avoir des permissions différentes sur un même fichier).
|
||||
|
||||
|
||||
===== Installation =====
|
||||
|
||||
<code BASH>
|
||||
sudo apt install acl
|
||||
</code>
|
||||
|
||||
===== Utilisation =====
|
||||
|
||||
Par exemple :
|
||||
|
||||
<code BASH>
|
||||
sudo setfacl -d -m group:nogroup:rwx /mnt/anonymous
|
||||
</code>
|
||||
|
||||
Cette commande permet de définir une ACL par défaut pour le répertoire ''/mnt/anonymous'' afin que le groupe ''nogroup'' ait les permissions ''rwx'' sur tous les fichiers et les sous-répertoires créés dans ce répertoire.
|
||||
|
||||
Les options utilisées dans cette commande sont :
|
||||
|
||||
* ''-d'' : Définit l'ACL par défaut pour le répertoire ''/mnt/anonymous'', c'est-à-dire que tous les fichiers et les sous-répertoires créés dans ce répertoire hériteront de cette ACL par défaut.
|
||||
|
||||
* ''-m'' : Modifie l'ACL existante pour le groupe ''nogroup''.
|
||||
|
||||
* ''group:nogroup:rwx'' : Définit l'ACL pour le groupe ''nogroup'' avec les permissions ''rwx'' (lecture, écriture et exécution) sur le répertoire ''/mnt/anonymous''.
|
||||
|
||||
7
data/pages/informatique/linux/commandes/shutdown.txt
Normal file
7
data/pages/informatique/linux/commandes/shutdown.txt
Normal file
@@ -0,0 +1,7 @@
|
||||
====== shutdown ======
|
||||
|
||||
C'est un programme présent dans ''/usr/sbin/''. Par conséquent il doit être appelé avec les droits ''root''. Il permet de redémarrer l'ordinateur.
|
||||
|
||||
Le programme fait partie du groupe [[.:shutdown]], [[.:reboot]], [[.:halt]] et [[.:poweroff]], tous ayant un lien symbolique avec [[.:systemctl]] quand le système est piloté avec SystemD.
|
||||
|
||||
sudo systemctl poweroff
|
||||
9
data/pages/informatique/linux/commandes/sidebar.txt
Normal file
9
data/pages/informatique/linux/commandes/sidebar.txt
Normal file
@@ -0,0 +1,9 @@
|
||||
[[.:]]
|
||||
|
||||
<nspages . -h1 -hideNoSubns -subns -nbCol=1 -textNS=" " -textPages=" " -exclude:cookie: -exclude:user: -exclude:playground: -exclude:[sidebar index start rightsidebar navbar topheader header help pageheader pagefooter legal-notices footer 404 les-commandes-a-connaitre 010100-repertoire-des-commandes-linux-sous-bash la-ligne-de-commande tips: super-index] -pagesInNs >
|
||||
|
||||
retour à [[..:]]
|
||||
|
||||
{{page>:sidebar}}
|
||||
|
||||
~~NOCACHE~~
|
||||
55
data/pages/informatique/linux/commandes/smartctl.txt
Normal file
55
data/pages/informatique/linux/commandes/smartctl.txt
Normal file
@@ -0,0 +1,55 @@
|
||||
====== smartctl ======
|
||||
|
||||
Programme qui contrôle et monitor les informations SMART des disques durs.
|
||||
|
||||
<well>
|
||||
__**Informations techniques et conditions de tests**__
|
||||
|
||||
Commandes testées le 01/12/2019 avec la version **smartmontools-6.4 2014-10-07 r4002** sur **Fedora 30**.
|
||||
|
||||
<text>
|
||||
**smartctl** est **/usr/sbin/smartctl**
|
||||
|
||||
**usr/sbin/smartctl**: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=64c0e4ca5bd2b1c2b827b343abd67b5cbadb26b1, stripped
|
||||
</text>
|
||||
|
||||
</well>
|
||||
|
||||
--
|
||||
|
||||
Obtenir quelques infos disponibles par SMART sur le disque.
|
||||
<code>
|
||||
smartctl -H -i /dev/sdX
|
||||
</code>
|
||||
|
||||
--
|
||||
|
||||
Obtenir toutes les infos disponibles par SMART sur le disque.
|
||||
<code>
|
||||
smartctl -a /dev/sdX
|
||||
</code>
|
||||
|
||||
--
|
||||
|
||||
Tester les indicateurs SMART de manière courte (~1 min)
|
||||
<code>
|
||||
smartctl -t short /dev/sdX
|
||||
</code>
|
||||
|
||||
Ensuite pour accéder au résultats/statistiques de ces tests :
|
||||
<code>
|
||||
smartctl -l selftest /dev/sdX
|
||||
</code>
|
||||
|
||||
--
|
||||
|
||||
Tester les indicateurs SMART de manière longue (~10 min à 90 min)
|
||||
<code>
|
||||
smartctl -t long /dev/sdX
|
||||
</code>
|
||||
|
||||
Ensuite pour accéder au résultats/statistiques de ces tests :
|
||||
|
||||
<code>
|
||||
sudo smartctl -l selftest /dev/sdX
|
||||
</code>
|
||||
300
data/pages/informatique/linux/commandes/ssh.txt
Normal file
300
data/pages/informatique/linux/commandes/ssh.txt
Normal file
@@ -0,0 +1,300 @@
|
||||
====== ssh ======
|
||||
{{ informatique:applications:ssh.jpg?75x75|ssh client}}
|
||||
|
||||
''ssh'' est un programme pour se connecter à une machine distante et pour effectuer des commandes sur cette machine. La connexion et les échanges sont sécurisés. L'identité utilisé sur le poste distant peut être différente de l'identité du poste local utilisé.
|
||||
|
||||
La connexion ''ssh'' nécessite d'un [[service ssh]] sur la machine distante.
|
||||
|
||||
===== - Connexions sécurisées et simplifiées grâce à l'authentification par clé publique et privée : principe =====
|
||||
|
||||
Pour simplifier et sécuriser la connexion à une machine distante, il est possible d'utiliser une méthode basée sur l'authentification par clé publique et privée. Cette approche élimine la nécessité de saisir un login et un mot de passe à chaque connexion. Au lieu de cela, la connexion SSH vérifiera votre clé privée avec la clé publique enregistrée sur le serveur distant.
|
||||
|
||||
Cette méthode présente plusieurs avantages. Elle élimine la complexité liée à la gestion des mots de passe et permet un gain de temps considérable au quotidien. De plus, elle offre un niveau de sécurité supérieur, car les clés utilisées sont beaucoup plus robustes que les mots de passe traditionnels.
|
||||
|
||||
Si plusieurs utilisateurs doivent accéder au serveur distant, SSH permet de gérer plusieurs paires de clés, permettant ainsi à chaque utilisateur de se connecter avec sa propre clé. Si vous avez la responsabilité de plusieurs serveurs, vous pouvez utiliser la même clé publique sur tous les serveurs.
|
||||
|
||||
Voici un guide détaillé pour vous aider à créer un jeu de clés sur votre poste de travail. Nous allons générer deux clés : une clé privée et une clé publique. Seule la clé publique devra être déployée sur les différents serveurs, tandis que la clé privée doit être conservée précieusement sur votre ordinateur.
|
||||
===== - Création d'un jeu de clés ecdsa pour une connexion SSH sécurisée =====
|
||||
|
||||
|
||||
L'algorithme de signature numérique **ecdsa** est un nouveau standard utilisant les courbes elliptiques, réputé pour sa sécurité et sa performance. La taille maximale des clés supportées est de 521 bits, et la plupart des clients **SSH** le prennent en charge.
|
||||
|
||||
Si vous préférez utiliser l'algorithme RSA, vous pouvez simplement remplacer "ecdsa" par "rsa" dans les étapes suivantes.
|
||||
|
||||
**Étape 1:** Génération de la clé SSH
|
||||
|
||||
Pour créer une clé SSH de type "ecdsa", vous pouvez utiliser la commande suivante avec ssh-keygen. L'option -t spécifie le type de clé, et l'option -b définit la longueur de la clé.
|
||||
|
||||
<code BASH>
|
||||
ssh-keygen -t ecdsa -b 521
|
||||
</code>
|
||||
|
||||
-- Spécification de l'emplacement du stockage de la clé (optionnel)
|
||||
|
||||
Si vous souhaitez spécifier un emplacement particulier pour stocker la clé, vous pouvez utiliser l'option -f suivi du chemin d'accès souhaité. Par exemple :
|
||||
|
||||
<code BASH>
|
||||
ssh-keygen -t ecdsa -b 521 -f ~/.ssh/aws-cdc001-cedric-ecdsa
|
||||
</code>
|
||||
|
||||
-- Ajout d'un commentaire à la clé (optionnel)
|
||||
|
||||
Si vous souhaitez ajouter un commentaire à la clé pour une meilleure identification, vous pouvez utiliser l'option -C suivi du commentaire souhaité. Par exemple :
|
||||
|
||||
<code BASH>
|
||||
ssh-keygen -t ecdsa -b 521 -f ~/.ssh/aws-cdc001-cedric-ecdsa -C "cedric@dskcdc001"
|
||||
</code>
|
||||
|
||||
**Étape 2:** Sécurisation de la clé privée
|
||||
|
||||
Il est crucial de sécuriser la clé privée et de limiter l'accès aux personnes autorisées à l'utiliser. Lors de la création de la clé, le programme **ssh-keygen** vous demandera de définir une passphrase (mot de passe) pour la clé privée. Assurez-vous d'utiliser une passphrase sécurisée et de la mémoriser. Les caractères que vous entrez n'apparaîtront pas à l'écran pour des raisons de sécurité.
|
||||
|
||||
<code BASH>
|
||||
Enter passphrase (empty for no passphrase):
|
||||
Enter same passphrase again:
|
||||
</code>
|
||||
|
||||
En suivant ces étapes, vous aurez créé un jeu de clés **ecdsa** pour une connexion SSH sécurisée. Veillez à bien protéger la clé privée et à utiliser une **passphrase** forte pour garantir la sécurité de votre connexion.
|
||||
===== - Contrôle et gestion des clés dans SSH =====
|
||||
|
||||
|
||||
{{ informatique:terminal_ssh_cat_private_key.png?150x150|contenu d'une clé privée}}
|
||||
|
||||
|
||||
|
||||
Pour contrôler vos clés SSH et effectuer des opérations de gestion, vous pouvez suivre les étapes suivantes :
|
||||
|
||||
**Étape 1:** Lister les clés présentes dans votre compte
|
||||
|
||||
Utilisez la commande suivante dans votre terminal pour lister les clés présentes dans votre répertoire ~/.ssh/ :
|
||||
|
||||
<code BASH>
|
||||
ls ~/.ssh/
|
||||
</code>
|
||||
|
||||
Cette commande affichera la liste des clés présentes, le cas échéant.
|
||||
|
||||
**Étape 2:** Afficher le contenu d'une clé (à utiliser avec précaution)
|
||||
|
||||
Si vous souhaitez afficher le contenu d'une clé spécifique, vous pouvez utiliser la commande suivante :
|
||||
|
||||
<code BASH>
|
||||
cat ~/.ssh/maCle
|
||||
</code>
|
||||
|
||||
Remplacez "maCle" par le nom de votre clé. Cependant, il est important de noter que l'affichage du contenu d'une clé publique ou privée à l'aide de la commande "cat" est une pratique peu recommandée en raison de la sensibilité des informations contenues dans la clé. Veillez à utiliser cette commande avec précaution et évitez de divulguer le contenu de vos clés.
|
||||
|
||||
Il est essentiel de prendre des mesures pour sécuriser vos clés SSH, telles que la protection de la clé privée avec une passphrase et le contrôle strict des autorisations d'accès aux fichiers de clés.
|
||||
|
||||
En suivant ces étapes, vous pouvez contrôler et gérer vos clés SSH de manière sécurisée. Veillez à respecter les bonnes pratiques en matière de gestion des clés et à prendre les mesures appropriées pour protéger vos informations sensibles.
|
||||
===== - Copier et utiliser une clé publique avec SSH =====
|
||||
|
||||
Guide étape par étape pour copier et utiliser une clé publique avec SSH sous Linx.
|
||||
|
||||
--
|
||||
|
||||
Pour utiliser la clé, vous devez procéder à la copie de votre clé publique vers le poste distant. La clé publique est généralement stockée dans un fichier nommé "id_rsa.pub" situé dans le répertoire ".ssh" de votre dossier utilisateur. L'étape suivante consiste à ajouter cette clé publique au fichier "authorized_keys" du dossier ".ssh" sur l'ordinateur distant.
|
||||
|
||||
Voici un exemple plus détaillé du processus :
|
||||
|
||||
**1.** Tout d'abord, identifiez l'emplacement de votre clé publique. Par défaut, elle se trouve dans le fichier "~/.ssh/id_rsa.pub".
|
||||
|
||||
**2.** Ensuite, ouvrez une session sur le serveur distant en utilisant la commande SSH :
|
||||
|
||||
<code BASH>
|
||||
ssh utilisateur@srvprod.aceinternet.fr
|
||||
</code>
|
||||
|
||||
Remplacez "utilisateur" par votre nom d'utilisateur et "srvprod.aceinternet.fr" par l'adresse du serveur distant.
|
||||
|
||||
**3.** Une fois connecté au serveur distant, créez le dossier ".ssh" dans votre répertoire utilisateur s'il n'existe pas déjà :
|
||||
|
||||
<code BASH>
|
||||
mkdir -p ~/.ssh
|
||||
</code>
|
||||
|
||||
**4.** Utilisez la commande "ssh-copy-id" pour copier votre clé publique sur le serveur distant et l'ajouter au fichier "authorized_keys" :
|
||||
|
||||
<code BASH>
|
||||
ssh-copy-id -i ~/.ssh/id_rsa.pub utilisateur@srvprod.aceinternet.fr
|
||||
</code>
|
||||
|
||||
Cette commande copie le contenu de votre clé publique dans le fichier "authorized_keys" sur le serveur distant, ce qui vous permettra de vous connecter sans avoir à saisir de mot de passe. Cette commande est a utiliser sur votre poste local.
|
||||
|
||||
**5.** Après avoir exécuté la commande, vous serez invité à saisir votre mot de passe pour le serveur distant une dernière fois. Entrez-le et la copie de votre clé publique sera effectuée.
|
||||
|
||||
Une fois que vous avez suivi ces étapes, vous devriez être en mesure de vous connecter au serveur distant en utilisant votre clé privée, sans avoir à saisir votre mot de passe à chaque fois.
|
||||
|
||||
Veuillez noter que les noms de fichiers et les chemins d'accès peuvent varier en fonction de votre configuration spécifique, mais les étapes générales restent les mêmes.
|
||||
|
||||
===== - Gestion des clés SSH avec un fichier de configuration =====
|
||||
|
||||
|
||||
Pour faciliter la gestion des connexions SSH, vous pouvez créer un fichier de configuration qui regroupe toutes les informations nécessaires. Voici un exemple de configuration :
|
||||
|
||||
<code>
|
||||
host srvprod.aceinternet.fr
|
||||
HostName srvprod.aceinternet.fr
|
||||
Port 2134
|
||||
User adminsrv
|
||||
IdentityFile ~/.ssh/id_rsa_adminsrvAceinternetFr
|
||||
</code>
|
||||
|
||||
Ce fichier de configuration permet de spécifier les paramètres de connexion pour l'hôte distant "srvprod.aceinternet.fr". Les lignes suivantes indiquent respectivement le nom d'hôte, le port, le nom d'utilisateur et le chemin vers la clé privée à utiliser pour cette connexion.
|
||||
|
||||
Il est important de protéger le fichier de configuration pour garantir la sécurité de vos informations sensibles. Vous pouvez définir les permissions appropriées en utilisant les commandes suivantes :
|
||||
|
||||
<code BASH>
|
||||
chmod 600 ~/.ssh/config
|
||||
chown $USER ~/.ssh/config
|
||||
</code>
|
||||
|
||||
La première commande ''chmod 600'' définit les permissions du fichier de configuration de manière à ce qu'il soit accessible en lecture et écriture uniquement par le propriétaire (vous), et aucun accès en lecture pour les autres utilisateurs. La deuxième commande ''chown $USER'' garantit que le fichier appartient à l'utilisateur courant.
|
||||
|
||||
En veillant à protéger votre fichier de configuration, vous pouvez centraliser et gérer plus facilement vos connexions SSH en utilisant les paramètres spécifiés dans ce fichier. Cela simplifie également la maintenance et la modification des connexions SSH.
|
||||
===== - Conseils en cas de panne =====
|
||||
|
||||
|
||||
==== - Que faire en cas de changement de la clé publique de l'hôte distant ====
|
||||
|
||||
|
||||
Une **clé publique de l'hôte distant** est un élément essentiel dans le système d'authentification et de sécurité utilisé par le protocole SSH (Secure Shell) lors des connexions à distance. Lorsque vous vous connectez à un hôte distant via SSH, l'hôte présente sa clé publique au client pour vérifier son identité.
|
||||
|
||||
La **clé publique de l'hôte distant** est générée lors de la première connexion SSH à cet hôte et est ensuite stockée dans le fichier **known_hosts** du client. Elle est associée à une signature numérique unique qui permet d'authentifier l'hôte distant de manière sécurisée. Cette clé publique est utilisée pour chiffrer les données envoyées au serveur, assurant ainsi la confidentialité des communications.
|
||||
|
||||
Lorsque vous vous reconnectez à l'hôte distant ultérieurement, le client SSH vérifie si la clé publique présentée par l'hôte correspond à celle enregistrée dans le fichier **known_hosts**. Si les clés correspondent, la connexion est établie en toute sécurité. Cependant, si la clé publique a changé depuis la dernière connexion, le client SSH émet un avertissement indiquant qu'une attaque potentielle de type "**man-in-the-middle**" est possible, et la connexion est bloquée par mesure de sécurité.
|
||||
|
||||
La **clé publique de l'hôte distant** joue donc un rôle crucial dans l'établissement de connexions sécurisées via SSH. Elle permet d'authentifier l'hôte distant et de détecter tout changement potentiel dans l'identité de l'hôte. La gestion appropriée des clés publiques et la vérification de leur validité contribuent à assurer la sécurité des connexions SSH.
|
||||
|
||||
--
|
||||
|
||||
Si vous rencontrez une erreur indiquant que la clé publique de l'hôte distant a changé lors d'une tentative de connexion SSH, voici les étapes à suivre pour résoudre ce problème :
|
||||
|
||||
**1.** Tout d'abord, lorsque vous essayez de vous connecter à l'hôte distant avec la commande `ssh 192.168.100.5`, vous obtenez un message d'erreur indiquant que la clé a changé et qu'une attaque de type "man-in-the-middle" est possible.
|
||||
|
||||
<code>
|
||||
IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!
|
||||
Someone could be eavesdropping on you right now (man-in-the-middle attack)!
|
||||
It is also possible that a host key has just been changed.
|
||||
The fingerprint for the ECDSA key sent by the remote host is
|
||||
fa:f8:ec:af:20:0e:58:ca:d1:4d:47:b0:7e:fa:2b:e2.
|
||||
Please contact your system administrator.
|
||||
Add correct host key in /home/cedric/.ssh/known_hosts to get rid of this message.
|
||||
Offending ECDSA key in /home/cedric/.ssh/known_hosts:5
|
||||
ECDSA host key for 192.168.100.5 has changed and you have requested strict checking.
|
||||
Host key verification failed.
|
||||
</code>
|
||||
|
||||
**2.** Cela signifie que la clé ECDSA (ECDSA key) utilisée pour sécuriser la connexion entre votre client et l'hôte distant a été modifiée depuis votre dernière connexion. Cette clé est stockée localement sur votre client, dans le fichier known_hosts, qui se trouve généralement dans le répertoire caché .ssh de votre utilisateur (par exemple, /home/cedric/.ssh/known_hosts).
|
||||
|
||||
**3.** Pour résoudre ce problème, vous devez réinitialiser l'entrée de l'hôte distant dans le fichier known_hosts. Vous pouvez le faire en utilisant la commande suivante :
|
||||
|
||||
<code BASH>
|
||||
ssh-keygen -R 192.168.100.5
|
||||
</code>
|
||||
|
||||
Cette commande supprimera l'enregistrement de l'hôte **192.168.100.5** du fichier **known_hosts**.
|
||||
|
||||
**4.** Une fois que vous avez réinitialisé l'entrée, vous pouvez vous connecter à nouveau à l'hôte distant en utilisant la commande ''ssh 192.168.100.5''. Cette fois-ci, la nouvelle clé publique sera enregistrée dans le fichier **known_hosts**, et vous devriez pouvoir vous connecter sans erreur.
|
||||
|
||||
En suivant ces étapes, vous pourrez résoudre le problème lié au changement de la clé publique de l'hôte distant et vous reconnecter en toute sécurité.
|
||||
|
||||
==== - Possible usurpation DNS ====
|
||||
|
||||
Lorsque vous essayez de vous connecter à un hôte distant via SSH, vous pouvez rencontrer un avertissement indiquant une possible usurpation DNS. Voici le message d'erreur associé :
|
||||
|
||||
<code>
|
||||
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
|
||||
@ WARNING: POSSIBLE DNS SPOOFING DETECTED! @
|
||||
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
|
||||
The ECDSA host key for raspberrypi has changed,
|
||||
and the key for the corresponding IP address 192.168.100.84
|
||||
is unchanged. This could either mean that
|
||||
DNS SPOOFING is happening or the IP address for the host
|
||||
and its host key have changed at the same time.
|
||||
Offending key for IP in /home/cedric/.ssh/known_hosts:66
|
||||
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
|
||||
@ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @
|
||||
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
|
||||
IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!
|
||||
Someone could be eavesdropping on you right now (man-in-the-middle attack)!
|
||||
It is also possible that a host key has just been changed.
|
||||
The fingerprint for the ECDSA key sent by the remote host is
|
||||
SHA256:kAmTpCxHgmxEjMRO02lHxatQPXzJ3dHcaJCXb+eqswA.
|
||||
Please contact your system administrator.
|
||||
Add correct host key in /home/cedric/.ssh/known_hosts to get rid of this message.
|
||||
Offending ECDSA key in /home/cedric/.ssh/known_hosts:62
|
||||
ECDSA host key for raspberrypi has changed and you have requested strict checking.
|
||||
Host key verification failed.
|
||||
</code>
|
||||
|
||||
Ce message indique que la clé de l'hôte distant "raspberrypi" a changé, mais l'adresse IP correspondante (192.168.100.84) est restée inchangée. Cela peut signifier deux choses : soit une usurpation DNS est en cours, soit l'adresse IP de l'hôte et sa clé de connexion ont changé simultanément.
|
||||
|
||||
Pour résoudre ce problème, vous devez supprimer l'enregistrement associé à l'hôte en question. Vous pouvez le faire en utilisant la commande suivante :
|
||||
|
||||
<code BASH>
|
||||
ssh-keygen -R raspberrypi
|
||||
</code>
|
||||
|
||||
Cette commande supprimera l'enregistrement de l'hôte "raspberrypi" du fichier known_hosts.
|
||||
|
||||
Une fois que vous avez supprimé l'enregistrement, vous pouvez essayer de vous reconnecter à l'hôte. Cette fois-ci, l'association entre le nom de l'hôte et sa clé sera enregistrée à nouveau dans le fichier known_hosts.
|
||||
|
||||
Assurez-vous de suivre ces étapes pour garantir la sécurité de votre connexion SSH et éviter les risques potentiels liés à une usurpation DNS.
|
||||
|
||||
==== - Choix entre RSA et ECDSA ====
|
||||
|
||||
|
||||
Le choix entre l'utilisation d'ECDSA (Elliptic Curve Digital Signature Algorithm) ou de RSA (Rivest-Shamir-Adleman) dépend de plusieurs facteurs, notamment les considérations de sécurité et les préférences personnelles.
|
||||
|
||||
ECDSA utilise des courbes elliptiques pour la génération de clés et les opérations de signature numérique. Il est généralement considéré comme plus efficace en termes de performances et d'utilisation de la bande passante. Les clés ECDSA sont également plus courtes que les clés RSA équivalentes, ce qui peut être avantageux dans certains cas.
|
||||
|
||||
D'autre part, RSA est un algorithme de cryptographie asymétrique plus ancien et largement utilisé. Il est éprouvé et bien pris en charge par de nombreuses infrastructures et logiciels. RSA est généralement considéré comme étant plus sûr pour des longueurs de clé équivalentes, mais nécessite des clés plus longues pour offrir un niveau de sécurité comparable à ECDSA.
|
||||
|
||||
En fin de compte, le choix entre ECDSA et RSA dépend de la compatibilité avec les systèmes existants, des performances souhaitées et des recommandations de sécurité spécifiques. Il est recommandé de se référer aux recommandations de sécurité en vigueur et de prendre en compte les spécifications et les exigences propres à votre environnement avant de faire un choix.
|
||||
|
||||
===== - Script Bash pour générer une clé privée SSH et configurer la connexion =====
|
||||
|
||||
Voici un script Bash qui demande à l'utilisateur de saisir le nom de l'hôte distant, le numéro de port et son nom d'utilisateur pour se connecter via SSH. Il génère ensuite une clé privée et la pousse sur l'hôte distant. Enfin, il écrit un fichier de configuration dans le répertoire ".ssh/config".
|
||||
|
||||
<code BASH ssh-keygen-config.sh>
|
||||
#!/bin/bash
|
||||
|
||||
# Demande à l'utilisateur les informations nécessaires
|
||||
read -p "Nom de l'hôte distant : " hostname
|
||||
read -p "Numéro de port SSH : " port
|
||||
read -p "Nom d'utilisateur : " username
|
||||
|
||||
# Vérifie si le fichier de clé privée existe déjà
|
||||
private_key=~/.ssh/id_rsa_${hostname}
|
||||
if [[ -f $private_key ]]; then
|
||||
echo "La clé privée pour cet hôte existe déjà : $private_key"
|
||||
echo "Veuillez supprimer la clé existante ou utiliser un autre nom d'hôte."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Génère une clé privée avec un nom dynamique basé sur l'hôte distant
|
||||
ssh-keygen -t rsa -f $private_key
|
||||
|
||||
# Pousse la clé publique sur l'hôte distant
|
||||
ssh-copy-id -i $private_key.pub -p $port $username@$hostname
|
||||
|
||||
# Crée le fichier de configuration
|
||||
config_file=~/.ssh/config
|
||||
echo "Host $hostname" >> $config_file
|
||||
echo " HostName $hostname" >> $config_file
|
||||
echo " Port $port" >> $config_file
|
||||
echo " User $username" >> $config_file
|
||||
echo " IdentityFile $private_key" >> $config_file
|
||||
echo "" >> $config_file
|
||||
|
||||
# Définit les permissions du fichier de configuration
|
||||
chmod 600 $config_file
|
||||
|
||||
echo "Configuration terminée. Vous pouvez maintenant vous connecter en utilisant 'ssh $hostname' avec la nouvelle clé privée."
|
||||
|
||||
</code>
|
||||
|
||||
Le nom de la clé privée générée sera basé sur le nom de l'hôte distant fourni par l'utilisateur, ce qui permet de générer des clés privées uniques pour chaque hôte distant. Par exemple, si l'utilisateur saisit "**srvprod.aceinternet.fr**" comme nom d'hôte distant, la clé privée sera enregistrée sous ''~/.ssh/id_rsa_srvprod.aceinternet.fr''.
|
||||
|
||||
Assurez-vous d'exécuter le script en tant qu'utilisateur disposant des droits nécessaires pour effectuer les opérations (par exemple, l'utilisateur courant doit pouvoir générer une clé privée, écrire dans le répertoire ''.ssh'' et copier la clé publique sur l'hôte distant).
|
||||
40
data/pages/informatique/linux/commandes/su.txt
Normal file
40
data/pages/informatique/linux/commandes/su.txt
Normal file
@@ -0,0 +1,40 @@
|
||||
====== su ======
|
||||
{{ :dummy.png?75x75|Passer d'un utilisateur à un autre}}
|
||||
|
||||
La commande ''su'' sous Linux est utilisée pour passer d'un utilisateur à un autre en se connectant sous un compte différent, généralement en passant à un compte **superutilisateur** (//superuser//) tel que ''root''.
|
||||
|
||||
Voici comment utiliser la commande "su" :
|
||||
|
||||
-- Ouvrez un terminal sur votre système Linux.
|
||||
|
||||
-- Tapez ''su'' suivi de l'identifiant de l'utilisateur auquel vous voulez vous connecter, par exemple :
|
||||
|
||||
su utilisateur1
|
||||
|
||||
-- Appuyez sur Entrée. Si vous n'êtes pas connecté en tant que **superutilisateur** (''root''), vous devrez entrer le mot de passe de ce compte.
|
||||
|
||||
-- Une fois que vous êtes connecté en tant que cet utilisateur, vous pouvez effectuer toutes les opérations et exécuter toutes les commandes pour lesquelles cet utilisateur dispose des autorisations nécessaires.
|
||||
|
||||
-- Pour revenir à votre compte utilisateur d'origine, tapez simplement ''exit'' et appuyez sur Entrée.
|
||||
|
||||
La commande ''su'' peut être très puissante car elle permet d'accéder à toutes les autorisations et fonctionnalités d'un compte **superutilisateur**, il est donc important de l'utiliser avec précaution et seulement lorsque cela est nécessaire.
|
||||
|
||||
===== Astuces et recommandations =====
|
||||
|
||||
Voici quelques astuces pour utiliser la commande ''su'' sous Linux :
|
||||
|
||||
-- Utilisez ''su -'' pour se connecter avec l'environnement d'exécution de l'utilisateur de destination. Par exemple, si vous voulez vous connecter en tant que **superutilisateur** (''root''), vous pouvez taper :
|
||||
|
||||
su -
|
||||
|
||||
L'utilisation du signe ''-'' après la commande ''su'' assure que vous allez hériter de toutes les variables d'environnement de l'utilisateur de destination.
|
||||
|
||||
-- Utilisez [[.:sudo]] pour exécuter des commandes avec des privilèges d'administrateur sans vous connecter à un autre utilisateur. La commande ''sudo'' est souvent préférable à ''su'' pour des raisons de sécurité et de traçabilité des commandes exécutées. Par exemple, pour exécuter la commande ''apt update'' en tant qu'administrateur, vous pouvez taper :
|
||||
|
||||
sudo apt update
|
||||
|
||||
-- Utilisez ''su'' avec précaution et évitez de vous connecter en tant que **superutilisateur** (''root'') sauf si c'est absolument nécessaire. En effet, se connecter en tant que **superutilisateur** peut être dangereux car cela donne accès à tous les fichiers et processus du système, ce qui peut entraîner des dommages accidentels ou malveillants.
|
||||
|
||||
-- Si vous devez vous connecter en tant que **superutilisateur** (''root''), essayez d'utiliser la commande ''su'' pour une durée aussi courte que possible, et revenez à votre utilisateur normal dès que vous avez terminé.
|
||||
|
||||
-- Utilisez un mot de passe fort pour le compte **superutilisateur** (''root'') et ne partagez jamais ce mot de passe avec d'autres utilisateurs. Il est également recommandé de changer régulièrement les mots de passe pour garantir la sécurité de votre système.
|
||||
158
data/pages/informatique/linux/commandes/sudo.txt
Normal file
158
data/pages/informatique/linux/commandes/sudo.txt
Normal file
@@ -0,0 +1,158 @@
|
||||
====== sudo ======
|
||||
|
||||
{{ :informatique:linux:commandes:pasted:20231201-024429.png?400}}
|
||||
|
||||
La commande "sudo" est une commande sous Linux qui permet à un utilisateur d'exécuter des commandes avec les privilèges d'un autre utilisateur, généralement l'utilisateur **superutilisateur** (''root'').
|
||||
|
||||
La commande ''sudo'' est souvent utilisée pour exécuter des commandes en tant qu'administrateur sans avoir à se connecter en tant que **superutilisateur**, ce qui permet une meilleure sécurité et une meilleure traçabilité des actions effectuées.
|
||||
|
||||
Lorsque vous utilisez la commande ''sudo'', vous devez spécifier le nom de l'utilisateur dont les privilèges vous souhaitez utiliser, suivi de la commande à exécuter. Par exemple, si vous souhaitez mettre à jour votre système en tant qu'administrateur, vous pouvez taper :
|
||||
|
||||
<code BASH>
|
||||
sudo apt update
|
||||
</code>
|
||||
|
||||
Ensuite, vous devrez entrer le mot de passe de votre utilisateur pour confirmer que vous êtes autorisé à exécuter la commande avec les privilèges de l'utilisateur spécifié. Si vous avez les autorisations nécessaires, la commande sera exécutée.
|
||||
|
||||
Il est recommandé d'utiliser ''sudo'' plutôt que de ''su'' pour exécuter des commandes en tant qu'administrateur car elle permet de limiter les risques d'erreurs et de sécurité. En effet, les commandes exécutées avec ''sudo'' sont enregistrées dans les journaux système, ce qui facilite la détection des actions suspectes ou malveillantes.
|
||||
|
||||
La commande ''sudo'' est généralement déjà installée sur la plupart des distributions Linux. Cependant, si elle n'est pas installée sur votre système, vous pouvez l'installer en utilisant le gestionnaire de paquets de votre distribution en adminstrateur :
|
||||
|
||||
<code>
|
||||
su -
|
||||
</code>
|
||||
|
||||
Puis selon votre distribution :
|
||||
|
||||
Debian, Ubuntu et dérivés :
|
||||
<code>
|
||||
apt update
|
||||
apt install sudo
|
||||
</code>
|
||||
|
||||
Red Hat, CentOS et dérivés :
|
||||
<code>
|
||||
yum install sudo
|
||||
</code>
|
||||
|
||||
Fedora :
|
||||
<code>
|
||||
dnf install sudo
|
||||
</code>
|
||||
|
||||
Pour pouvoir utiliser la commande ''sudo'', l'utilisateur courant doit être autorisé à le faire. Je vous le détaille ci-dessous.
|
||||
|
||||
===== Préconfiguration du groupe sudo =====
|
||||
|
||||
Pour voir la préconfiguration du groupe ''sudo'', vous pouvez afficher le contenu du fichier ''/etc/sudoers''. Ce fichier contient la configuration globale de sudo et spécifie les utilisateurs, les groupes et les commandes qui sont autorisés à utiliser ''sudo''.
|
||||
|
||||
Voici comment afficher le contenu du fichier ''/etc/sudoers'' :
|
||||
|
||||
-- Ouvrez un terminal sur votre système Linux.
|
||||
|
||||
-- Tapez la commande suivante et appuyez sur Entrée :
|
||||
|
||||
<code BASH>
|
||||
sudo cat /etc/sudoers
|
||||
</code>
|
||||
|
||||
-- Entrez le mot de passe de votre utilisateur si vous y êtes invité.
|
||||
|
||||
Cette commande affiche le contenu du fichier ''/etc/sudoers'' dans le terminal. Vous pouvez y rechercher les sections qui concernent le groupe ''sudo'' pour voir les autorisations de ce groupe.
|
||||
|
||||
Par exemple, la section suivante du fichier ''/etc/sudoers'' accorde des autorisations au groupe ''sudo'' :
|
||||
|
||||
<code BASH>
|
||||
# Allow members of group sudo to execute any command
|
||||
%sudo ALL=(ALL:ALL) ALL
|
||||
</code>
|
||||
|
||||
Cette section spécifie que les membres du groupe ''sudo'' sont autorisés à exécuter toutes les commandes avec les privilèges de tous les utilisateurs et groupes. Vous pouvez également trouver d'autres sections qui spécifient des autorisations pour des utilisateurs ou des commandes spécifiques.
|
||||
|
||||
Le fichier ''/etc/sudoers'' est un fichier de configuration critique, et toute modification incorrecte peut entraîner des problèmes de sécurité ou des erreurs système. Par conséquent, il est recommandé de faire une copie de sauvegarde du fichier avant de le modifier et de suivre les bonnes pratiques de sécurité recommandées pour la gestion des utilisateurs et des permissions sur votre système.
|
||||
|
||||
|
||||
===== Ajouter un utilisateur au groupe sudo pour autoriser l'utilisation de sudo =====
|
||||
|
||||
Pour autoriser un utilisateur à utiliser la commande ''sudo'', vous pouvez suivre les étapes suivantes :
|
||||
|
||||
1. Ouvrez un terminal sur votre système Linux.
|
||||
|
||||
2. Utilisez la commande [[.:usermod|usermod]] pour ajouter l'utilisateur ''alice'' au groupe ''sudo'' :
|
||||
|
||||
<code bash>
|
||||
sudo usermod -aG sudo alice
|
||||
</code>
|
||||
|
||||
Cette ligne de commande ajoute l'utilisateur ''alice'' au groupe ''sudo'' en utilisant ''usermod''. Le paramètre ''-aG'' signifie "ajouter à un groupe".
|
||||
|
||||
Assurez-vous d'avoir les privilèges d'administrateur sur votre système pour exécuter ces commandes avec ''sudo''.
|
||||
|
||||
Si vous avez le message ''usermod : le groupe 'sudo' n'existe pas'' passez à la méthode "Ajouter des droits sudoers pour un utilisateur".
|
||||
|
||||
===== Ajouter des droits sudoers pour un utilisateur =====
|
||||
|
||||
Il s'agit de permettre à l'utilisateur courant d'utiliser la commande ''sudo'' en modifiant les droits d'accès dans le fichier **sudoers**.
|
||||
|
||||
Vous pouvez suivre également une approche qui consiste à ajouter des autorisations personnalisées dans des fichiers situés dans le répertoire ''/etc/sudoers.d/'' plutôt que de modifier directement le fichier principal ''/etc/sudoers'', ceci afin de suivre les meilleures pratiques. Voici comment ajouter l'utilisateur ''alice'' à la liste des utilisateurs autorisés à utiliser ''sudo'' en suivant cette approche :
|
||||
|
||||
1. Ouvrez un terminal sur votre système Linux.
|
||||
|
||||
2. Créez un fichier dans le répertoire ''/etc/sudoers.d/'' pour l'utilisateur ''alice''. Vous pouvez utiliser la commande ''sudo visudo'' pour éditer ce fichier spécifique avec ''visudo'' :
|
||||
|
||||
<code bash>
|
||||
sudo visudo -f /etc/sudoers.d/alice
|
||||
</code>
|
||||
|
||||
Si le fichier ''alice'' n'existe pas, il sera créé.
|
||||
|
||||
3. À l'intérieur de l'éditeur de texte ''visudo'', ajoutez la ligne suivante au fichier ''/etc/sudoers.d/alice'' :
|
||||
|
||||
<code bash>
|
||||
alice ALL=(ALL:ALL) ALL
|
||||
</code>
|
||||
|
||||
Cette ligne spécifie que l'utilisateur ''alice'' est autorisé à utiliser ''sudo'' pour toutes les commandes, avec les privilèges de tous les utilisateurs et groupes.
|
||||
|
||||
4. Après avoir ajouté la ligne, sauvegardez les modifications et quittez l'éditeur de texte. La commande ''visudo'' vérifiera la syntaxe du fichier pour s'assurer qu'il n'y a pas d'erreurs.
|
||||
|
||||
5. Assurez-vous que les fichiers dans ''/etc/sudoers.d/'' ont les bonnes autorisations. Ils doivent appartenir à ''root'' et avoir des permissions ''440'' :
|
||||
<code>
|
||||
chmod 440 /etc/sudoers.d/alice
|
||||
chown root:root /etc/sudoers.d/alice
|
||||
</code>
|
||||
===== Ne pas demander le mot de passe =====
|
||||
|
||||
Pour permettre à un utilisateur d'exécuter des commandes ''sudo'' sans être invité systématiquement à entrer son mot de passe, vous pouvez configurer des règles de sudoers spécifiques pour cet utilisateur.
|
||||
|
||||
<WRAP center round alert 60%>
|
||||
Il est essentiel de comprendre que cela peut introduire des problèmes de sécurité et doit être fait avec précaution. Ne désactivez pas systématiquement le mot de passe pour ''sudo'' sans une bonne raison, car cela peut compromettre la sécurité de votre système.
|
||||
|
||||
</WRAP>
|
||||
|
||||
1. Ouvrez un terminal sur votre système Linux.
|
||||
|
||||
2. Exécutez la commande suivante pour ouvrir le fichier ''/etc/sudoers'' avec ''visudo'' (en tant qu'administrateur) :
|
||||
|
||||
<code>
|
||||
sudo visudo -f /etc/sudoers.d/alice
|
||||
</code>
|
||||
|
||||
Cette commande ouvre le fichier ''sudoers'' en mode édition sécurisé.
|
||||
|
||||
3. À l'intérieur de l'éditeur de texte ''visudo'', ajoutez la ligne suivante en remplaçant ''alice'' par le nom de l'utilisateur pour lequel vous souhaitez désactiver le mot de passe pour ''sudo'' :
|
||||
|
||||
<code>
|
||||
alice ALL=(ALL:ALL) NOPASSWD:ALL
|
||||
</code>
|
||||
|
||||
Cette ligne indique que l'utilisateur ''alice'' peut exécuter toutes les commandes avec ''sudo'' sans être invité à entrer son mot de passe.
|
||||
|
||||
4. Après avoir ajouté la ligne, sauvegardez les modifications et quittez l'éditeur de texte. La commande ''visudo'' vérifiera la syntaxe du fichier pour s'assurer qu'il n'y a pas d'erreurs.
|
||||
|
||||
5. Pour que les modifications prennent effet, l'utilisateur ''alice'' devra exécuter des commandes ''sudo'' sans être invité à entrer son mot de passe lors de la prochaine session.
|
||||
|
||||
<WRAP center round alert 60%>
|
||||
Il est important de noter que la désactivation systématique du mot de passe pour ''sudo'' présente un risque de sécurité important, car cela permet à l'utilisateur de lancer des commandes avec des privilèges élevés sans vérification d'identité. Cette méthode doit être utilisée avec précaution et uniquement pour des cas spécifiques où elle est nécessaire, comme l'automatisation de certaines tâches système. Assurez-vous de comprendre les implications de cette configuration avant de l'appliquer et ne l'utilisez que lorsque c'est absolument nécessaire.
|
||||
</WRAP>
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
====== && ======
|
||||
{{ :dummy.png?75x75|Le ET logique}}
|
||||
|
||||
En Linux, ''&&'' est un opérateur logique appelé **et logique**. Cela signifie que la commande suivante ne sera exécutée que si la commande précédente a réussi.
|
||||
|
||||
Par exemple, si vous tapez la commande suivante dans le terminal :
|
||||
|
||||
<code BASH>
|
||||
commande1 && commande2
|
||||
</code>
|
||||
|
||||
La ''commande2'' sera exécutée uniquement si la ''commande1'' a été exécutée avec succès. Si la ''commande1'' échoue, la ''commande2'' ne sera pas exécutée.
|
||||
|
||||
Cet opérateur est souvent utilisé pour enchaîner plusieurs commandes dans un script ou dans une ligne de commande.
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
====== & ======
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
|
||||
En bash, le caractère ''&'' est utilisé pour lancer un processus en arrière-plan (background). Cela signifie que le programme lancé continuera à s'exécuter en arrière-plan, sans bloquer la ligne de commande. Cela peut être utile si vous avez besoin de lancer un programme qui prend du temps à s'exécuter, mais que vous souhaitez continuer à travailler dans la même fenêtre de terminal.
|
||||
|
||||
Par exemple, si vous tapez la commande suivante:
|
||||
|
||||
<code>
|
||||
firefox &
|
||||
</code>
|
||||
|
||||
Cela lancera le navigateur web **Firefox** en arrière-plan, sans bloquer la ligne de commande. Vous pourrez alors continuer à travailler dans le terminal pendant que Firefox s'exécute en arrière-plan.
|
||||
|
||||
Si vous fermez le terminal, tous les processus lancés en arrière-plan seront également terminés. Si vous voulez lancer un processus en arrière-plan qui ne sera pas affecté par la fermeture du terminal, vous pouvez utiliser les commandes [[.:nohup|nohup]] ou [[.:screen|screen]].
|
||||
|
||||
Il existe des commandes en Bash qui permettent de manipuler des programmes en arrière-plan. Voici quelques exemples :
|
||||
|
||||
* La commande [[.:jobs|jobs]] permet d'afficher la liste des processus en arrière-plan en cours d'exécution dans le shell courant. Chaque processus est identifié par un numéro de tâche (//job number//) et un état (//running//, //stopped//, etc.). Vous pouvez utiliser le numéro de tâche pour interagir avec le processus en question.
|
||||
|
||||
* La commande [[.:fg|fg]] (pour "foreground") permet de ramener un processus en arrière-plan au premier plan (foreground). Si vous avez plusieurs processus en arrière-plan, vous pouvez spécifier le numéro de tâche comme argument pour indiquer lequel vous voulez ramener en premier plan. Par exemple, si vous voulez ramener le processus 2 en premier plan, vous pouvez utiliser la commande ''fg 2''.
|
||||
|
||||
* La commande [[.:bg|bg]] (pour "background") permet de reprendre l'exécution d'un processus arrêté en arrière-plan. Si vous avez plusieurs processus en arrière-plan, vous pouvez spécifier le numéro de tâche comme argument pour indiquer lequel vous voulez reprendre. Par exemple, si vous voulez reprendre l'exécution du processus 3 en arrière-plan, vous pouvez utiliser la commande ''bg 3''.
|
||||
|
||||
* La commande [[.:kill|kill]] permet d'envoyer un signal à un processus en cours d'exécution, ce qui peut permettre de l'arrêter ou de le redémarrer. Si vous avez plusieurs processus en arrière-plan, vous pouvez spécifier le numéro de tâche comme argument pour indiquer lequel vous voulez arrêter. Par exemple, si vous voulez arrêter le processus 4 en arrière-plan, vous pouvez utiliser la commande ''kill %4''.
|
||||
|
||||
Ces commandes peuvent être utiles pour gérer des processus en arrière-plan dans un terminal Bash.
|
||||
@@ -0,0 +1,18 @@
|
||||
====== > ======
|
||||
{{ :dummy.png?75x75|Redirection de sortie}}
|
||||
|
||||
En Linux Bash, le symbole ''>'' est utilisé pour rediriger la sortie standard d'une commande vers un fichier plutôt que vers la sortie standard par défaut. Cela peut être utile pour enregistrer la sortie d'une commande dans un fichier plutôt que de l'afficher à l'écran.
|
||||
|
||||
Par exemple, si vous voulez exécuter une commande qui produit de la sortie et enregistrer cette sortie dans un fichier, vous pouvez utiliser la commande suivante:
|
||||
|
||||
commande > fichier_de_sortie
|
||||
|
||||
Cela redirigera la sortie de la commande vers le fichier spécifié. Si le fichier n'existe pas, il sera créé. Si le fichier existe déjà, son contenu sera écrasé.
|
||||
|
||||
Il est également possible d'ajouter du contenu à un fichier existant plutôt que de l'écraser en utilisant ''>>'' au lieu de ''>'' :
|
||||
|
||||
commande >> fichier_de_sortie
|
||||
|
||||
Cela ajoutera la sortie de la commande à la fin du fichier spécifié, plutôt que d'écraser son contenu.
|
||||
|
||||
Il est possible d'utiliser la commande [[.:tee|tee]] pour écrire la sortie d'une commande dans un fichier.
|
||||
62
data/pages/informatique/linux/commandes/systemctl.txt
Normal file
62
data/pages/informatique/linux/commandes/systemctl.txt
Normal file
@@ -0,0 +1,62 @@
|
||||
====== systemctl ======
|
||||
|
||||
===== - Éteindre la machine =====
|
||||
|
||||
Arrêter le système puis éteindre la machine via un signal ACPI, équivalent de ''init 0'' et ''halt''.
|
||||
|
||||
<code>
|
||||
# systemctl poweroff
|
||||
</code>
|
||||
|
||||
Équivalence :
|
||||
<code>
|
||||
# systemctl start poweroff.target --job-mode=replace-irreversibly
|
||||
</code>
|
||||
|
||||
<code>
|
||||
# systemctl --force poweroff
|
||||
</code>
|
||||
|
||||
Arrêt brutal :
|
||||
<code>
|
||||
# systemctl --force --force poweroff
|
||||
</code>
|
||||
|
||||
Arrêter le système puis éteindre via une interruption ROM
|
||||
|
||||
<code>
|
||||
# systemctl halt
|
||||
</code>
|
||||
(Équivalent de : systemctl start halt.target --job-mode=replace-irreversibly)
|
||||
|
||||
systemctl --force halt
|
||||
Arrêt brutal : systemctl --force --force halt
|
||||
|
||||
===== - Redémarrer le système =====
|
||||
|
||||
Redémarrer le système, équivalent de ''init 6'' et ''reboot''.
|
||||
|
||||
<code>
|
||||
# systemctl reboot
|
||||
</code>
|
||||
|
||||
Équivalence :
|
||||
<code>
|
||||
# systemctl start reboot.target --job-mode=replace-irreversibly
|
||||
</code>
|
||||
|
||||
Redémarrage brutal :
|
||||
<code>
|
||||
# systemctl --force --force reboot
|
||||
</code>
|
||||
|
||||
Pour certains BIOS (U)EFI, redémarrer dans le setup
|
||||
<code>
|
||||
# systemctl --firmware-setup reboot
|
||||
</code>
|
||||
|
||||
===== - Biblio =====
|
||||
|
||||
* [[https://wiki.ordi49.fr/doku.php/tech:tech_systemd_systemctl]]
|
||||
|
||||
* [[https://access.redhat.com/documentation/fr-fr/red_hat_enterprise_linux/7/html/system_administrators_guide/sect-managing_services_with_systemd-power]]
|
||||
35
data/pages/informatique/linux/commandes/tac.txt
Normal file
35
data/pages/informatique/linux/commandes/tac.txt
Normal file
@@ -0,0 +1,35 @@
|
||||
====== tac ======
|
||||
{{tag>"commande linux"}}
|
||||
|
||||
{{ :informatique:linux:commandes:pasted:20211112-002412.png|Concaténer et lit les fichiers en ordre inverse}}
|
||||
|
||||
Si [[.:cat|cat]] est une des commandes incontournables de la lignes de commande, elle sert le plus souvent à lire un contenu textuel, la commande **tac** assez simple mais rencontre peu d'application à son usage.
|
||||
|
||||
**tac** affiche en sortie standard le fichier en commençant par la dernière ligne.
|
||||
|
||||
|
||||
===== Lire un fichier en console =====
|
||||
|
||||
**tac** est adapté à la lecture de fichiers à en ordre inverse des numéros de lignes. Son utilisation standard est des plus simples :\\
|
||||
|
||||
Si nous prenons le fichier ''/home/tux/test.txt'' suivant :
|
||||
<code>$ cat /home/tux/test.txt
|
||||
ligne 1
|
||||
ligne 2
|
||||
ligne 3
|
||||
</code>
|
||||
|
||||
la commande ''tac'' sur le fichier ''/home/tux/test.txt'' produira le résultat suivant :
|
||||
<code>$ tac /home/tux/test.txt
|
||||
ligne 3
|
||||
ligne 2
|
||||
ligne 1</code>
|
||||
|
||||
Nous venons de lire le fichier ''test.txt'' dans le répertoire personnel de l'utilisateur ''tux'', rien de difficile.
|
||||
|
||||
|
||||
===== tac - Est-il vraiment utile ? =====
|
||||
|
||||
La commande **tac** est utilisée pour sortir un fichier en format inversé. Elle est utilisée principalement dans des scripts de manipulation de données.
|
||||
|
||||
D'autres commandes peuvent également répondre à vos besoins : [[.:tail|tail]], [[.:head|head]]
|
||||
127
data/pages/informatique/linux/commandes/tar.txt
Normal file
127
data/pages/informatique/linux/commandes/tar.txt
Normal file
@@ -0,0 +1,127 @@
|
||||
====== tar ======
|
||||
{{tag>"linux commande"}}
|
||||
|
||||
----
|
||||
|
||||
===== Comparaison des résultats des archives =====
|
||||
|
||||
Les archives **tar** ont une taille différentes suivant les options de compression utilisée. Par exemple, un dossier **html** contenant des fichiers **HTML**, **CSS** et **JS** :
|
||||
|
||||
^ archive ^ taille (octets) ^
|
||||
| tar | 40960 |
|
||||
| tar.gz | 6200 |
|
||||
| tar.bz2 | 6003 |
|
||||
| tar.xz | 5656 |
|
||||
|
||||
Voyons les commandes et options possibles.
|
||||
|
||||
===== tar sous Liunx : compresser et décompresser =====
|
||||
|
||||
Pour __créer une archive__ **tar** __d'un ou plusieurs fichiers__, on utilise la syntaxe
|
||||
|
||||
tar cvf archive.tar fichier1 fichier2...
|
||||
|
||||
--
|
||||
|
||||
Pour __créer une archive__ **tar** __d'un dossier__, on utilise la syntaxe
|
||||
tar cvf archive.tar dossier/
|
||||
|
||||
Le chemin complet de **dossier** sera copié dans l'archive. Attention à la décompression.
|
||||
|
||||
|
||||
--
|
||||
|
||||
Pour __extraire les fichiers d'une archive__ **tar**, on utilise la syntaxe
|
||||
tar xvf archivedossier.tar
|
||||
|
||||
--
|
||||
|
||||
Pour __afficher le contenu d'une archive__, on utilise la syntaxe
|
||||
|
||||
tar tvf archivedossier.tar
|
||||
|
||||
===== tar.gz sous Liunx : compresser et décompresser =====
|
||||
|
||||
La manipulation des archives **tar.gz** s'effectue systématiquement avec l'option **z**.
|
||||
|
||||
--
|
||||
|
||||
Pour __créer une archive__ compressée **tar.gz** __d'un ou plusieurs fichiers__, on utilise la syntaxe avec l'option **c**
|
||||
tar zcvf archive.tar.gz fichier1 fichier2...
|
||||
|
||||
Pour __créer une archive__ compressées **tar.gz** __d'un dossier__, on utilise la syntaxe la même syntaxe
|
||||
tar zcvf archive.tar.gz dossier/
|
||||
|
||||
--
|
||||
|
||||
Pour __créer une archive__ compressée **tar.gz** d'un ou plusieurs fichiers sans les informations de **l'owner** et du **groupe** renseignée, on utilise la syntaxe suivante :
|
||||
|
||||
tar zcvf archive.tar.gz . --owner=0 --group=0
|
||||
|
||||
Il faudra veiller à laisser des instructions pour attribuer des droits.
|
||||
|
||||
--
|
||||
|
||||
Pour __extraire les fichiers__ d'une archive compressée tar.gz, on utilise la syntaxe avec l'option **x**
|
||||
tar zxvf archivedossier.tar.gz
|
||||
|
||||
--
|
||||
|
||||
Pour __afficher le contenu__ d'une archive, on utilise la syntaxe avec l'option **t**
|
||||
|
||||
tar ztvf archivedossier.tar.gz
|
||||
|
||||
|
||||
--
|
||||
|
||||
Pour __supprimer un fichier__ dans l'archive, on utilise la syntaxe avec l'option **delete**
|
||||
|
||||
tar zvf archivedossier.tar.gz --delete your/path/to/delete
|
||||
|
||||
|
||||
|
||||
|
||||
===== tar.xz sous Liunx : compresser et décompresser =====
|
||||
|
||||
Pour __créer une archive__ compressée **tar.xz** __d'un ou plusieurs fichiers__, on utilise la syntaxe
|
||||
tar Jcvf archive.tar.xz fichier1 fichier2...
|
||||
|
||||
--
|
||||
|
||||
Pour __créer une archive__ compressées **tar.xz** __d'un dossier__, on utilise la syntaxe
|
||||
tar Jcvf archive.tar.xz dossier/
|
||||
|
||||
--
|
||||
|
||||
Pour __extraire les fichiers__ d'une archive compressée tar.xz, on utilise la syntaxe
|
||||
tar Jxvf archivedossier.tar.xz
|
||||
|
||||
|
||||
===== tar.bz2 sous Liunx : compresser et décompresser =====
|
||||
|
||||
Pour __créer une archive__ compressée **tar.bz2** __d'un ou plusieurs fichiers__, on utilise la syntaxe
|
||||
|
||||
<code>
|
||||
tar jcvf archive.tar.bz2 fichier1 fichier2…
|
||||
</code>
|
||||
|
||||
--
|
||||
|
||||
Pour __créer une archive__ compressées **tar.bz2** __d'un dossier__, on utilise la syntaxe
|
||||
|
||||
<code>
|
||||
tar jcvf archive.tar.gz dossier/
|
||||
</code>
|
||||
|
||||
--
|
||||
|
||||
Pour __afficher le contenu__ **tar.bz2** d'une archive, on utilise la syntaxe
|
||||
|
||||
|
||||
tar tvf archive.tar.bz2 '*.txt'
|
||||
|
||||
---
|
||||
|
||||
Pour __extraire les fichiers__ d'une archive compressée **tar.bz2**, on utilise la syntaxe
|
||||
tar Jxvf archivedossier.tar.bz2
|
||||
|
||||
29
data/pages/informatique/linux/commandes/tee.txt
Normal file
29
data/pages/informatique/linux/commandes/tee.txt
Normal file
@@ -0,0 +1,29 @@
|
||||
====== tee ======
|
||||
{{ informatique:linux:commandes:pasted:20200507-020553.png?75x75|tee}}
|
||||
|
||||
La commande ''tee'' est utilisée pour lire l'entrée standard d'une commande, écrire cette entrée à la fois sur la sortie standard et dans un ou plusieurs fichiers spécifiés. Pour ce faire, il suffit d'utiliser l'option ''-a'' pour ajouter la sortie à la fin du fichier spécifié, ou l'option ''> nom_fichier'' pour écraser le contenu du fichier spécifié.
|
||||
|
||||
Par exemple, pour exécuter la commande ''ls'' et écrire à la fois sa sortie dans le fichier ''sortie.txt'' et l'afficher à l'écran, vous pouvez utiliser la commande suivante :
|
||||
|
||||
<code BASH>
|
||||
ls | tee sortie.txt
|
||||
</code>
|
||||
|
||||
Cela affichera la sortie de la commande ''ls'' à l'écran, tout en écrivant la sortie dans le fichier ''sortie.txt''.
|
||||
|
||||
Si vous souhaitez ajouter la sortie de la commande ''ls'' à la fin du fichier ''sortie.txt'', vous pouvez utiliser l'option ''-a'' comme ceci :
|
||||
|
||||
<code BASH>
|
||||
ls | tee -a sortie.txt
|
||||
</code>
|
||||
|
||||
Cela ajoutera la sortie de la commande ls à la fin du fichier sortie.txt, sans écraser son contenu.
|
||||
|
||||
|
||||
Exemple :
|
||||
|
||||
<code BASH>
|
||||
ls . | tee output.txt | wc -l
|
||||
</code>
|
||||
|
||||
Cette commande affichera le nombre de fichiers et de répertoires dans le répertoire courant, tout en écrivant la liste des fichiers et des répertoires dans le fichier ''output.txt''.
|
||||
68
data/pages/informatique/linux/commandes/timedatectl.txt
Normal file
68
data/pages/informatique/linux/commandes/timedatectl.txt
Normal file
@@ -0,0 +1,68 @@
|
||||
====== timedatectl ======
|
||||
|
||||
Commande Linux qui contrôle les date et heure du système.
|
||||
|
||||
===== - Afficher les informations date et heure du système =====
|
||||
|
||||
<code>
|
||||
timedatectl status
|
||||
</code>
|
||||
|
||||
>> Exemple de réponse de timedatectl status
|
||||
|
||||
{{ informatique:linux:commandes:timedatectl_status.png |Exemple de réponse de timedatectl status}}
|
||||
|
||||
===== - Activer la synchronisation de l'heure =====
|
||||
|
||||
La synchronisation de l'heure s'effectue grâce au protocole NTP.
|
||||
|
||||
>> Pour **activer le synchronisation automatique de l'heure**, il faut activer l'option avec la commande **timedatectl**.
|
||||
|
||||
<code>
|
||||
$ sudo timedatectl set-ntp 1
|
||||
</code>
|
||||
|
||||
La liste des serveurs NTP sont renseignés dans le fichier ''/etc/timesyncd.conf'' :
|
||||
|
||||
<code>
|
||||
[Time]
|
||||
Servers=ntp.ovh.fr fr.pool.ntp.org 0.debian.pool.ntp.org 1.debian.pool.ntp.org 2.debian.pool.ntp.org 3.debian.pool.ntp.org
|
||||
</code>
|
||||
|
||||
>> La synchronisation à la demande de l'heure, s'effectuer avec le programme [[informatique:linux:programme:ntpdate]].
|
||||
|
||||
|
||||
===== - Modifier la date et l'heure manuelle =====
|
||||
|
||||
>> La **syntaxe** pour modifier la date et l'heure sont au choix, les suivantes :
|
||||
<code>
|
||||
$ sudo timedatectl set-time 'A:M:J HH:mm:ss'
|
||||
$ sudo timedatectl set-time 'A:M:J'
|
||||
$ sudo timedatectl set-time 'HH:mm:ss'
|
||||
</code>
|
||||
|
||||
Par exemple, pour modifier l'heure du système :
|
||||
<code>
|
||||
$ sudo timedatectl set-time '15:48:59'
|
||||
</code>
|
||||
|
||||
===== - Modifier le fuseau horaire de la machine =====
|
||||
|
||||
<code>
|
||||
$ sudo timedatectl set-timezone Europe/Paris
|
||||
</code>
|
||||
|
||||
>> La commande ''timedatectl'' modifie le fichier ''/etc/timezone'' en vérifiant la véracité de l’option transmise.
|
||||
|
||||
Si l'otpion n'est pas correcte, le programme génère une erreur :
|
||||
<code>
|
||||
$ sudo timedatectl set-timezone Europe/Grenoble
|
||||
Failed to set time zone: Invalid time zone 'Europe/Grenoble'
|
||||
</code>
|
||||
|
||||
===== - Autres ressources =====
|
||||
|
||||
|
||||
> Consulter la page [[tzselect]] pour obtenir la valeur d'un fuseau horaire
|
||||
|
||||
> Consulter la page [[informatique:applications:dpkg-reconfigure#tzdata]] pour modifier le fuseau horaire de manière interactive.
|
||||
@@ -0,0 +1,17 @@
|
||||
====== ls et tail : afficher les dernières lignes des 5 derniers fichiers modifiés d'un dossier ======
|
||||
{{tag>"script linux"}}
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
|
||||
En utilisant la ligne de commande de Linux, vous pouvez utiliser la commande suivante pour afficher le "tail" des 5 derniers fichiers modifiés d'un dossier:
|
||||
|
||||
ls -t | head -n 5 | xargs tail -n 10
|
||||
|
||||
Cette commande utilise les options suivantes:
|
||||
|
||||
* ''ls -t'' pour afficher la liste des fichiers dans l'ordre de modification (les plus récemment modifiés en premier)
|
||||
|
||||
* ''head -n 5'' pour sélectionner les 5 premiers fichiers de la liste
|
||||
|
||||
* ''xargs tail -n 10'' pour afficher les 5 dernières lignes de chaque fichier sélectionné.
|
||||
|
||||
--- //[[user:jeanserien]], [[user:cpt]]//
|
||||
@@ -0,0 +1,21 @@
|
||||
====== ls et tail : afficher les dernières lignes des 5 derniers fichiers modifiés des sous-dossiers ======
|
||||
{{tag>"script linux"}}
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
|
||||
En utilisant la ligne de commande de Linux, vous pouvez utiliser la commande suivante pour afficher le "tail" des 5 derniers fichiers modifiés des sous-dossiers d'un dossier donné:
|
||||
|
||||
find . -type f -print0 | xargs -0 ls -t | head -n 5 | xargs -I{} tail -n 10 "{}"
|
||||
|
||||
Cette commande utilise les options suivantes:
|
||||
|
||||
* ''find . -type f -print0'' pour trouver tous les fichiers dans le répertoire courant et ses sous-dossiers et imprimer leur chemin avec un caractère nul (''\0'') comme séparateur
|
||||
|
||||
* ''xargs -0 ls -t'' pour utiliser les chemins de fichier trouvés comme entrée pour la commande ''ls -t'' qui les affiche dans l'ordre de modification (les plus récemment modifiés en premier)
|
||||
|
||||
* ''head -n 5'' pour sélectionner les 5 premiers fichiers de la liste
|
||||
|
||||
* ''xargs -I{} tail -n 10 "{}"'' pour afficher les 10 dernières lignes de chaque fichier sélectionné, où ''{}'' est remplacé par le chemin de chaque fichier. Voir [[informatique:linux:commandes:xargs#xargs-i]]
|
||||
|
||||
--- //[[user:jeanserien]], [[user:cpt]]//
|
||||
|
||||
|
||||
22
data/pages/informatique/linux/commandes/tips/index.txt
Normal file
22
data/pages/informatique/linux/commandes/tips/index.txt
Normal file
@@ -0,0 +1,22 @@
|
||||
====== Trucs et astuces ======
|
||||
|
||||
===== Table des matières =====
|
||||
|
||||
* [[..:|introduction]]
|
||||
|
||||
==== Les pages ====
|
||||
|
||||
<nav stacked="true" fade="true">
|
||||
<nspages . -h1 -nbCol=1 -textNS=" " -textPages=" " -simpleList -exclude:cookie: -exclude:user: -exclude:playground: -exclude:[sidebar index start rightsidebar navbar topheader header help pageheader pagefooter legal-notices footer 404]>
|
||||
</nav>
|
||||
|
||||
==== Les sous-catégories ====
|
||||
|
||||
<nav stacked="true" fade="true">
|
||||
<nspages . -h1 -nbCol=1 -noPages -subns -textNS=" " -textPages=" " -simpleList -exclude:cookie: -exclude:user: -exclude:playground: -exclude:[sidebar index start rightsidebar navbar topheader header help pageheader pagefooter legal-notices footer 404]>
|
||||
</nav>
|
||||
|
||||
~~NOTOC~~
|
||||
~~NOCACHE~~
|
||||
|
||||
|
||||
70
data/pages/informatique/linux/commandes/tmux.txt
Normal file
70
data/pages/informatique/linux/commandes/tmux.txt
Normal file
@@ -0,0 +1,70 @@
|
||||
====== tmux ======
|
||||
{{ informatique:linux:commandes:pasted:20201024-215118.png?75x75|tmux}}
|
||||
|
||||
{{youtube>58RQDCwn2qI?medium}}
|
||||
|
||||
Voici quelques raccourcis pour débuter.
|
||||
|
||||
Lister les sessions
|
||||
$ tmux ls
|
||||
|
||||
Entrer dans une session
|
||||
$ tmux
|
||||
|
||||
Configurer tmux\\
|
||||
Il faut modifier le fichier ~/.tmux
|
||||
|
||||
|
||||
Créer une nouvelle fenêtre
|
||||
Ctrl + B
|
||||
c
|
||||
|
||||
Basculer d'une fenêtre à l'autre
|
||||
Ctrl + B
|
||||
n
|
||||
|
||||
Basculer d'une fenêtre à l'autre, sens inverse
|
||||
Ctrl + B
|
||||
p
|
||||
|
||||
Renommer le nom de la fenetre
|
||||
Ctrl+ B
|
||||
,
|
||||
|
||||
Basculer d'une fenêtre à l'autre par leur numéro
|
||||
Ctrl + B
|
||||
# <= numéro de la fenêtre
|
||||
|
||||
|
||||
Fermer une fenêtre
|
||||
Ctrl + B
|
||||
x
|
||||
|
||||
Créer un panneau verticalement
|
||||
Ctrl + B
|
||||
%
|
||||
|
||||
Créer un panneau horizontalement
|
||||
Ctrl + B
|
||||
"
|
||||
|
||||
Redimensionner la fenêtre
|
||||
Ctrl + B
|
||||
Alt + <-
|
||||
|
||||
Se déplacer d'un panneau à l'autre
|
||||
Ctrl + B
|
||||
o
|
||||
|
||||
|
||||
Se déplacer d'un panneau à l'autre avec ce numéro
|
||||
Ctrl + B
|
||||
q
|
||||
puis le numéro
|
||||
|
||||
Afficher en plein écran le panneau / minimiser
|
||||
Ctrl + B
|
||||
z
|
||||
|
||||
|
||||
|
||||
1
data/pages/informatique/linux/commandes/touch.txt
Normal file
1
data/pages/informatique/linux/commandes/touch.txt
Normal file
@@ -0,0 +1 @@
|
||||
====== touch ======
|
||||
12
data/pages/informatique/linux/commandes/trash-empty.txt
Normal file
12
data/pages/informatique/linux/commandes/trash-empty.txt
Normal file
@@ -0,0 +1,12 @@
|
||||
====== trash-empty ======
|
||||
{{ :dummy.png?75x75|Vider la corbeille}}
|
||||
|
||||
Cette commande est disponible dans le package [[informatique:linux:applications:trash-cli|trash-cli]].
|
||||
|
||||
Si vous souhaitez supprimer définitivement les fichiers de la corbeille, vous pouvez utiliser la commande ''trash-empty'' :
|
||||
|
||||
trash-empty
|
||||
|
||||
Cette commande supprime tous les fichiers de la corbeille de manière définitive.
|
||||
|
||||
|
||||
12
data/pages/informatique/linux/commandes/trash-list.txt
Normal file
12
data/pages/informatique/linux/commandes/trash-list.txt
Normal file
@@ -0,0 +1,12 @@
|
||||
====== trash-list ======
|
||||
{{ :dummy.png?75x75|Afficher une liste de tous les fichiers présents dans la corbeille}}
|
||||
|
||||
La commande ''trash-list'' est une commande du package [[informatique:linux:applications:trash-cli|trash-cli]] pour Linux. Elle permet d'afficher la liste des fichiers et répertoires présents dans la corbeille (ou le //trash// en anglais) de l'utilisateur actuel.
|
||||
|
||||
La commande ''trash-list'' affiche des informations sur les fichiers tels que leur nom, leur chemin absolu, leur date de suppression et leur taille. Par défaut, les fichiers sont triés par ordre alphabétique croissant du nom de fichier.
|
||||
|
||||
Voici un exemple de sortie de la commande ''trash-list'' :
|
||||
|
||||
{{ :informatique:linux:commandes:pasted:20230218-125145.png }}
|
||||
|
||||
Dans cet exemple, la commande ''trash-list'' affiche une liste de trois fichiers présents dans la corbeille de l'utilisateur actuel, avec leur date de suppression, leur chemin absolu et leur nom de fichier.
|
||||
26
data/pages/informatique/linux/commandes/trash-put.txt
Normal file
26
data/pages/informatique/linux/commandes/trash-put.txt
Normal file
@@ -0,0 +1,26 @@
|
||||
====== trash-put ======
|
||||
{{ :dummy.png?75x75|Mettre à la corbeille}}
|
||||
|
||||
Cette commande est disponible dans le package [[informatique:linux:applications:trash-cli|trash-cli]].
|
||||
|
||||
Vous pouvez utiliser la commande ''trash-put'' pour déplacer des fichiers ou des répertoires vers la corbeille. Voici un exemple :
|
||||
|
||||
trash-put mon_fichier.txt
|
||||
|
||||
Cette commande déplace le fichier ''mon_fichier.txt'' vers la corbeille au lieu de le supprimer définitivement.
|
||||
|
||||
Pour changer le nombre de jours après lesquels les fichiers supprimés sont automatiquement effacés de la corbeille, vous pouvez utiliser la commande ''trash-put'' avec l'option ''-t'' pour spécifier une durée en jours. Par exemple, pour définir la durée à 7 jours, vous pouvez utiliser la commande suivante :
|
||||
|
||||
trash-put -t 7 mon_fichier.txt
|
||||
|
||||
Pour déplacer un dossier vers la corbeille, utilisez la commande ''trash-put'' suivie du chemin absolu ou relatif du dossier que vous souhaitez déplacer vers la corbeille. Par exemple, pour déplacer un dossier nommé ''mon_dossier'' se trouvant dans le répertoire courant vers la corbeille, vous pouvez utiliser la commande suivante :
|
||||
|
||||
trash-put mon_dossier
|
||||
|
||||
Si le dossier contient des fichiers ou des sous-dossiers, ceux-ci seront également déplacés vers la corbeille en même temps que le dossier.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
11
data/pages/informatique/linux/commandes/trash-restore.txt
Normal file
11
data/pages/informatique/linux/commandes/trash-restore.txt
Normal file
@@ -0,0 +1,11 @@
|
||||
====== trash-restore ======
|
||||
{{ :dummy.png?75x75|Restaurer un fichier depuis la corbeille}}
|
||||
|
||||
Cette commande est disponible dans le package [[informatique:linux:applications:trash-cli|trash-cli]].
|
||||
|
||||
Pour restaurer le fichier depuis la corbeille, vous pouvez utiliser la commande ''trash-restore'' :
|
||||
|
||||
trash-restore mon_fichier.txt
|
||||
|
||||
Cette commande restaure le fichier ''mon_fichier.txt'' depuis la corbeille vers son emplacement d'origine.
|
||||
|
||||
65
data/pages/informatique/linux/commandes/type.txt
Normal file
65
data/pages/informatique/linux/commandes/type.txt
Normal file
@@ -0,0 +1,65 @@
|
||||
====== type ======
|
||||
{{ :informatique:1200px-gnulinux.jpg?75x75|Déterminer comment une commande est interprétée}}
|
||||
|
||||
La commande ''type'' sous Linux est utilisée pour déterminer comment une commande est interprétée par le shell. Elle peut être utilisée pour identifier si une commande est un alias, une fonction ou un exécutable binaire.
|
||||
|
||||
La syntaxe de base de la commande est la suivante :
|
||||
|
||||
<code BASH>
|
||||
type [options] [name]
|
||||
</code>
|
||||
|
||||
Où ''name'' est le nom de la commande que vous voulez vérifier. Si aucun nom de commande n'est fourni, la commande ''type'' affichera un message d'aide avec une liste de toutes les commandes internes du shell.
|
||||
|
||||
===== Les options =====
|
||||
|
||||
Voici une description des différentes options ''[-aftpP]'' disponibles avec la commande ''type'' sous Linux :
|
||||
|
||||
* L'option ''-a'' permet d'afficher toutes les interprétations possibles d'une commande, y compris les alias, les fonctions et les exécutables binaires. Si une commande a plusieurs interprétations possibles, elles seront affichées les unes après les autres.
|
||||
|
||||
* L'option ''-f'' permet d'afficher le chemin complet de l'exécutable binaire correspondant à une commande. Si la commande est un alias ou une fonction, cette option n'a pas d'effet.
|
||||
|
||||
* L'option ''-t'' permet d'afficher le type de la commande, c'est-à-dire si elle est un alias, une fonction ou un exécutable binaire. Cette option n'affiche que le premier type d'interprétation de la commande.
|
||||
|
||||
* L'option ''-p'' permet d'afficher le nom de la fonction ou de l'alias correspondant à une commande. Si la commande est un exécutable binaire, cette option n'a pas d'effet.
|
||||
|
||||
* L'option ''-P'' permet de spécifier un préfixe à utiliser pour l'affichage du résultat. Cette option peut être utile pour ajouter des informations supplémentaires à la sortie de la commande.
|
||||
===== Exemples =====
|
||||
|
||||
Voici quelques exemples d'utilisation :
|
||||
|
||||
-- Pour vérifier si une commande est un alias :
|
||||
|
||||
<code BASH>
|
||||
$ type ls
|
||||
ls est un alias vers « ls --color=auto »
|
||||
</code>
|
||||
|
||||
<code BASH>
|
||||
$ type -a ls
|
||||
ls est un alias vers « ls --color=auto »
|
||||
ls est /usr/bin/ls
|
||||
</code>
|
||||
|
||||
-- Pour vérifier si une commande est une primitive (builtin) / fonction :
|
||||
|
||||
<code BASH>
|
||||
$ type cd
|
||||
cd est une primitive du shell
|
||||
</code>
|
||||
|
||||
<code BASH>
|
||||
$ type -a cd
|
||||
cd est une primitive du shell
|
||||
cd est /usr/bin/cd
|
||||
</code>
|
||||
|
||||
-- Pour vérifier si une commande est un exécutable binaire :
|
||||
|
||||
<code BASH>
|
||||
$ type grep
|
||||
grep est /usr/bin/grep
|
||||
</code>
|
||||
|
||||
|
||||
En utilisant la commande ''type'', vous pouvez facilement déterminer comment une commande est interprétée par le shell, ce qui peut être utile pour comprendre le comportement d'une commande et déboguer les problèmes éventuels.
|
||||
23
data/pages/informatique/linux/commandes/tzselect.txt
Normal file
23
data/pages/informatique/linux/commandes/tzselect.txt
Normal file
@@ -0,0 +1,23 @@
|
||||
====== tzselect ======
|
||||
|
||||
Utilitaire Linux qui retourne le fuseau horaire d'une zone géographique choisie.
|
||||
|
||||
===== - Exemple d'utilisation de la commande =====
|
||||
|
||||
|
||||
<code>
|
||||
$ tzselect
|
||||
</code>
|
||||
|
||||
{{ informatique:linux:commandes:tzselect_exemple.png |exemple d’appel à tzselect}}
|
||||
|
||||
===== - Modifier le fuseau horaire d'un utilisateur =====
|
||||
|
||||
L'information retournée par ''tzselect'' peut être écrite dans le fichier ''~/.profile''. Par exemple :
|
||||
<code>
|
||||
TZ='Europe/Paris'; export TZ
|
||||
</code>
|
||||
|
||||
===== - Modifier le fuseau horaire de la machine =====
|
||||
|
||||
Pour modifier le fuseau horaire de la machine, il faut utiliser la commande [[informatique:applications:dpkg-reconfigure#tzdata|dpkg-reconfigure tzdata]]
|
||||
57
data/pages/informatique/linux/commandes/umask.txt
Normal file
57
data/pages/informatique/linux/commandes/umask.txt
Normal file
@@ -0,0 +1,57 @@
|
||||
====== umask ======
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
|
||||
La commande ''umask'' est utilisée pour définir les permissions par défaut pour les nouveaux fichiers et les nouveaux répertoires créés dans un système de fichiers UNIX/Linux.
|
||||
|
||||
===== Description =====
|
||||
|
||||
La valeur **umask** représente les bits de permission qui seront désactivés pour les nouveaux fichiers et les nouveaux répertoires. Par exemple, si la valeur umask est ''022'', cela signifie que le bit de permission ''write'' (écriture) sera désactivé pour le groupe et pour les autres utilisateurs. Par conséquent, les nouveaux fichiers auront des permissions de **644 (rw-r--r--)** et les nouveaux répertoires auront des permissions de **755 (rwxr-xr-x)** par défaut.
|
||||
|
||||
La commande **umask** est généralement utilisée dans le fichier de configuration du shell, tel que ''~/.bashrc'' ou ''~/.profile''. En modifiant la valeur **umask** dans le fichier de configuration du shell, vous pouvez modifier les permissions par défaut pour tous les nouveaux fichiers et les nouveaux répertoires créés dans les sessions de shell que vous ouvrez.
|
||||
|
||||
Il est important de noter que la valeur umask ne modifie pas les permissions des fichiers et des répertoires existants. Elle ne s'applique qu'aux nouveaux fichiers et aux nouveaux répertoires créés après avoir défini la nouvelle valeur umask.
|
||||
|
||||
--
|
||||
|
||||
La commande ''umask -S'' affiche la valeur umask actuelle sous forme de notation symbolique plus facile à comprendre que la notation numérique standard.
|
||||
|
||||
Par exemple, si la valeur **umask** est actuellement définie à **022**, la commande ''umask -S'' affichera :
|
||||
<code>
|
||||
u=rw,g=r,o=r
|
||||
</code>
|
||||
|
||||
Cela signifie que les nouveaux fichiers auront des permissions de ''rw-r--r--'' et les nouveaux répertoires auront des permissions de ''rwxr-xr-x'' par défaut. La notation symbolique affichée par la commande ''umask -S'' montre les permissions qui seront désactivées pour les nouveaux fichiers et les nouveaux répertoires, en utilisant les symboles ''r'' (read/lecture), ''w'' (write/écriture) et ''x'' (execute/exécution).
|
||||
|
||||
--
|
||||
|
||||
La commande ''umask -p'' affiche la valeur umask actuelle sous forme de notation numérique standard, où chaque chiffre représente les bits de permission qui seront désactivés pour les propriétaires, les groupes et les autres utilisateurs. Par exemple, si la valeur **umask** est actuellement définie à **022**, la commande ''umask -p'' affichera :
|
||||
|
||||
<code bash>
|
||||
022
|
||||
</code>
|
||||
|
||||
--
|
||||
|
||||
Pour afficher la valeur umask actuelle d'un autre utilisateur, vous pouvez utiliser la commande ''sudo -u <utilisateur> umask''. Cette commande permet d'exécuter la commande ''umask'' en tant qu'utilisateur spécifié par l'option "-u".
|
||||
|
||||
Par exemple, pour afficher la valeur umask actuelle de l'utilisateur ''user1'', vous pouvez utiliser la commande suivante :
|
||||
|
||||
<code>
|
||||
sudo -u user1 umask
|
||||
</code>
|
||||
|
||||
Cette commande affichera la valeur **umask** actuelle de l'utilisateur ''user1'' en notation numérique standard.
|
||||
===== Modification des permissions d'un fichier =====
|
||||
|
||||
Les permissions d'un fichier sont modifiables avec la commande [[informatique:linux:commandes:chmod]].
|
||||
|
||||
Par exemple :
|
||||
<code BASH>
|
||||
chmod -R 777 .
|
||||
</code>
|
||||
|
||||
===== Modification des droits d'accès par défaut pour d'un groupe pour un répertoire =====
|
||||
|
||||
Pour modifier les droits d'accès par défaut pour d'un groupe pour un répertoire, on utilise les ACLs (Access Control Lists) avec la commande [[informatique:linux:commandes:setfacl|setfacl]].
|
||||
|
||||
Plus précisément, la commande ''setfacl'' définit les ACLs pour les fichiers et les répertoires. Les ACLs sont des mécanismes de sécurité avancés qui permettent de définir des autorisations plus précises que les permissions de base UNIX (par exemple, en permettant à plusieurs utilisateurs ou groupes d'avoir des permissions différentes sur un même fichier).
|
||||
21
data/pages/informatique/linux/commandes/unzip.txt
Normal file
21
data/pages/informatique/linux/commandes/unzip.txt
Normal file
@@ -0,0 +1,21 @@
|
||||
====== unzip ======
|
||||
{{ :dummy.png?75x75|}}
|
||||
|
||||
La commande unzip est utile pour extraire rapidement le contenu de fichiers compressés ZIP sous Linux.
|
||||
|
||||
Le format ZIP est un format de compression de fichiers couramment utilisé sur les systèmes d'exploitation Windows, Mac et Linux. Il permet de regrouper plusieurs fichiers en un seul fichier compressé, afin de faciliter le transfert ou le stockage des données.
|
||||
|
||||
Lorsque vous utilisez la commande ''unzip'', elle extrait le contenu du fichier compressé dans le répertoire de travail actuel. Elle restaure également les permissions et les métadonnées des fichiers d'origine.
|
||||
|
||||
===== Extraire ZIP dans un dossier spécifique =====
|
||||
|
||||
|
||||
Pour extraire le contenu d'un fichier compressé ZIP dans un dossier spécifique sous Linux, vous pouvez utiliser la commande ''unzip'' avec l'option ''-d'' suivie du nom du dossier de ''destination''. Voici la syntaxe générale :
|
||||
|
||||
unzip fichier.zip -d dossier_de_destination
|
||||
|
||||
Par exemple, si vous avez un fichier compressé nommé ''monfichier.zip'' situé dans votre répertoire de travail actuel, et que vous souhaitez extraire son contenu dans un dossier appelé ''mon_dossier'', vous pouvez utiliser la commande suivante :
|
||||
|
||||
unzip monfichier.zip -d mon_dossier
|
||||
|
||||
Assurez-vous que le dossier de destination existe déjà avant d'exécuter cette commande, sinon vous risquez d'obtenir une erreur.
|
||||
109
data/pages/informatique/linux/commandes/useradd.txt
Normal file
109
data/pages/informatique/linux/commandes/useradd.txt
Normal file
@@ -0,0 +1,109 @@
|
||||
====== useradd ======
|
||||
{{ :dummy.png?75x75|Créer un nouveau compte utilisateur}}
|
||||
|
||||
La commande ''useradd'' est une commande sous Linux utilisée pour créer un nouveau compte utilisateur sur le système. Elle est généralement utilisée par les administrateurs système pour ajouter de nouveaux utilisateurs, tels que des utilisateurs réguliers ou des comptes de service, au système.
|
||||
|
||||
La syntaxe de base de la commande ''useradd'' est la suivante :
|
||||
|
||||
<code BASH>
|
||||
useradd [options] nom_utilisateur
|
||||
</code>
|
||||
|
||||
où ''nom_utilisateur'' est le nom du nouveau compte à créer, et ''[options]'' sont des options facultatives permettant de spécifier différents paramètres pour le nouveau compte. Parmi les options courantes, on trouve :
|
||||
|
||||
* ''-c'' commentaire : spécifie un commentaire pour le compte.
|
||||
|
||||
* ''-m'' : crée le répertoire personnel pour le compte s'il n'existe pas déjà.
|
||||
|
||||
* ''-s'' shell : spécifie le shell par défaut pour le compte.
|
||||
|
||||
* ''-g'' groupe : spécifie le groupe principal pour le compte.
|
||||
|
||||
* ''-G'' groupes : spécifie les groupes supplémentaires pour le compte (séparés par des virgules).
|
||||
|
||||
Par exemple, pour créer un nouveau compte utilisateur nommé [[informatique:linux:system:choix-du-nom-d-utilisateur#le-compte-alice|alice]] avec le shell Bash et le groupe principal ''users'', vous pouvez utiliser la commande suivante :
|
||||
|
||||
<code BASH>
|
||||
useradd -m -s /bin/bash -g users alice
|
||||
</code>
|
||||
|
||||
Il est important de noter que la commande ''useradd'' crée un compte utilisateur, mais ne définit pas de mot de passe pour ce compte. Il est donc recommandé de définir un mot de passe pour le compte dès que possible après sa création avec la commande [[.:passwd|passwd]].
|
||||
|
||||
===== Script de création de compte avancé =====
|
||||
|
||||
Voici un exemple de script Bash qui utilise la commande useradd pour créer un compte utilisateur nommé ''alice'' avec un mot de passe aléatoire et stocke l'adresse e-mail de l'utilisateur demandée au préalable, envoie un mail pour le mot de passe :
|
||||
|
||||
<code BASH>
|
||||
#!/bin/bash
|
||||
|
||||
# Définition des couleurs pour l'affichage de messages
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
YELLOW='\033[0;33m'
|
||||
NC='\033[0m' # No Color
|
||||
|
||||
# Fonction pour afficher un message d'erreur
|
||||
function print_error() {
|
||||
echo -e "${RED}[ERROR] $1${NC}"
|
||||
}
|
||||
|
||||
# Fonction pour afficher un message d'information
|
||||
function print_info() {
|
||||
echo -e "${YELLOW}[INFO] $1${NC}"
|
||||
}
|
||||
|
||||
# Fonction pour afficher un message de succès
|
||||
function print_success() {
|
||||
echo -e "${GREEN}[SUCCESS] $1${NC}"
|
||||
}
|
||||
|
||||
# Fonction pour ajouter un nouvel utilisateur avec la commande useradd
|
||||
function add_user() {
|
||||
local username=$1
|
||||
local realname=$2
|
||||
local homedir=$3
|
||||
local shell=$4
|
||||
local groups=$5
|
||||
local email=$6
|
||||
|
||||
# Vérifier si l'utilisateur existe déjà
|
||||
if id -u "$username" >/dev/null 2>&1; then
|
||||
print_error "L'utilisateur $username existe déjà."
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Créer un nouveau répertoire home pour l'utilisateur
|
||||
if [ ! -d "$homedir" ]; then
|
||||
mkdir -p "$homedir"
|
||||
chmod 700 "$homedir"
|
||||
chown "$username:$username" "$homedir"
|
||||
fi
|
||||
|
||||
# Générer un mot de passe aléatoire
|
||||
local password=$(pwgen -1 12)
|
||||
|
||||
# Envoyer le mot de passe à l'adresse e-mail de secours si fournie
|
||||
if [ -n "$email" ]; then
|
||||
echo "Le mot de passe pour l'utilisateur $username est : $password" | mail -s "Mot de passe utilisateur" "$email"
|
||||
fi
|
||||
|
||||
# Stocker l'adresse e-mail de secours
|
||||
echo "$email" > "$homedir/.email-secours"
|
||||
|
||||
# Ajouter l'utilisateur avec la commande useradd
|
||||
useradd -c "$realname" -d "$homedir" -s "$shell" -G "$groups" -m "$username"
|
||||
|
||||
# Définir le mot de passe de l'utilisateur
|
||||
echo "$username:$password" | chpasswd
|
||||
|
||||
# Inviter l'utilisateur à changer de mot de passe au prochain démarrage
|
||||
passwd -e $username
|
||||
|
||||
print_success "L'utilisateur $username a été ajouté avec succès."
|
||||
}
|
||||
</code>
|
||||
|
||||
Ce script génère un mot de passe avec la commande ''pwgen'' qui peut générer des mots de passe aléatoires sécurisés, utilise la commande ''useradd'' pour créer un nouveau compte utilisateur nommé ''alice'' avec le mot de passe aléatoire et stocke l'adresse e-mail de secours de l'utilisateur dans le fichier ''.email-secours'' du répertoire de l'utilisateur, puis envoie le nouveau mot de passe par courrier électronique à l'adresse e-mail de l'utilisateur à l'aide de la commande ''mail''.
|
||||
|
||||
Exemple d'utilisation de la fonction ''add_user'' :
|
||||
add_user "alice" "Alice Doe" "/home/alice" "/bin/bash" "sudo,www-data" "alice.doe@example.com"
|
||||
39
data/pages/informatique/linux/commandes/usermod.txt
Normal file
39
data/pages/informatique/linux/commandes/usermod.txt
Normal file
@@ -0,0 +1,39 @@
|
||||
====== usermod ======
|
||||
|
||||
La commande ''usermod'' sous Linux est utilisée pour modifier les paramètres d'un utilisateur existant dans le système. Elle permet à l'administrateur de modifier les informations de l'utilisateur comme le nom d'utilisateur, le groupe principal, le répertoire personnel, le shell, les privilèges, les dates d'expiration du compte, etc.
|
||||
|
||||
Voici quelques exemples d'utilisation de la commande ''usermod'' :
|
||||
|
||||
-- Pour changer le nom d'utilisateur d'un compte
|
||||
|
||||
usermod -l nouveau_nom_utilisateur ancien_nom_utilisateur
|
||||
|
||||
-- Pour changer le groupe principal d'un compte
|
||||
|
||||
usermod -g nouveau_groupe_utilisateur nom_utilisateur
|
||||
|
||||
-- Pour changer le répertoire personnel d'un compte
|
||||
|
||||
usermod -d nouveau_répertoire_utilisateur nom_utilisateur
|
||||
|
||||
-- Pour changer le shell par défaut d'un compte
|
||||
|
||||
usermod -s /chemin/vers/nouveau_shell nom_utilisateur
|
||||
|
||||
-- Pour ajouter un groupe à un compte
|
||||
|
||||
usermod -aG nouveau_groupe nom_utilisateur
|
||||
|
||||
''usermod'' est une commande réservée à l'administrateur du système. Les utilisateurs réguliers n'ont pas le droit de l'utiliser pour modifier les informations de leur propre compte ou des comptes d'autres utilisateurs.
|
||||
|
||||
===== Alternatives =====
|
||||
|
||||
Il est possible d'utiliser des alternatives à la commande ''usermod'' sous Linux pour modifier les paramètres d'un utilisateur. Cependant, il est important de noter que la commande ''usermod'' est largement utilisée et bien documentée, et elle est prise en charge par la plupart des distributions Linux. En général, il est recommandé d'utiliser la commande ''usermod'' chaque fois que cela est possible.
|
||||
|
||||
Cela étant dit, voici quelques alternatives à ''usermod'' :
|
||||
|
||||
-- La commande [[.:useradd]] : La commande ''useradd'' est utilisée pour créer de nouveaux utilisateurs, mais elle peut également être utilisée pour modifier les paramètres d'un utilisateur existant. Vous pouvez utiliser l'option ''-D'' pour spécifier les paramètres à modifier, comme le répertoire personnel ou le shell.
|
||||
|
||||
-- Éditer directement le fichier ''/etc/passwd'' : Vous pouvez éditer directement le fichier ''/etc/passwd'' pour modifier les paramètres d'un utilisateur. Cependant, cela peut être risqué car une erreur de syntaxe dans le fichier ''/etc/passwd'' peut rendre impossible la connexion de l'utilisateur au système. Avant de modifier manuellement le fichier ''/etc/passwd'', il est important de créer une sauvegarde et de comprendre la syntaxe du fichier.
|
||||
|
||||
-- Utiliser des outils d'administration des utilisateurs : De nombreuses distributions Linux proposent des outils graphiques d'administration des utilisateurs, tels que ''user-manager'' sous **KDE** ou ''gnome-system-tools'' sous **GNOME**. Ces outils offrent une interface utilisateur conviviale pour gérer les utilisateurs et leurs paramètres.
|
||||
20
data/pages/informatique/linux/commandes/wget.txt
Normal file
20
data/pages/informatique/linux/commandes/wget.txt
Normal file
@@ -0,0 +1,20 @@
|
||||
====== wget ======
|
||||
|
||||
**wget** est un outil en ligne de commande utilisé pour télécharger des fichiers à partir d'Internet. Il fonctionne sur divers systèmes d'exploitation, tels que Linux, Windows et macOS. **wget** utilise les protocoles de téléchargement standard, tels que ''HTTP'', ''HTTPS'' et ''FTP'', pour télécharger les fichiers. Il peut également continuer un téléchargement interrompu et prend en charge les connexions proxy. **wget** est souvent utilisé pour télécharger des sites Web, des fichiers distants et des archives en ligne.
|
||||
|
||||
===== Télécharger un fichier avec un nom spécifique =====
|
||||
|
||||
{{tag>wget}}
|
||||
|
||||
wget <url> -c -O <nom_du_fichier.zip>
|
||||
|
||||
par exemple
|
||||
|
||||
wget https://atom.io/download/deb -c -O atom.deb
|
||||
|
||||
|
||||
La ligne de commande ''wget https://atom.io/download/deb'' signifie que vous téléchargez un fichier à partir de l'URL ''https://atom.io/download/deb''.
|
||||
|
||||
Le option ''-c'' signifie que le téléchargement doit être repris à partir de l'endroit où il a été interrompu si possible.
|
||||
|
||||
L'option ''-O atom.deb'' signifie que le fichier téléchargé doit être enregistré sous le nom ''atom.deb''.
|
||||
22
data/pages/informatique/linux/commandes/wich.txt
Normal file
22
data/pages/informatique/linux/commandes/wich.txt
Normal file
@@ -0,0 +1,22 @@
|
||||
====== which ======
|
||||
{{ :dummy.png?75x75|Localiser l'emplacement d'un exécutable dans la variable d'environnement $PATH}}
|
||||
|
||||
La commande ''which'' est une commande utilisée dans les systèmes d'exploitation de type Unix (tel que Linux) pour localiser l'emplacement d'un exécutable dans la variable d'environnement [[informatique:linux:system:variables#path|$PATH]].
|
||||
|
||||
Lorsqu'un utilisateur entre une commande dans le terminal, le système recherche cette commande dans les répertoires répertoriés dans la variable ''$PATH''. La commande ''which'' permet à l'utilisateur de déterminer le chemin complet d'un exécutable en affichant le chemin du répertoire contenant la première occurrence de l'exécutable spécifié dans la variable ''$PATH''.
|
||||
|
||||
Par exemple, si vous tapez ''which python'' dans le terminal, la commande vous renverra le chemin complet de l'exécutable Python qui est utilisé par défaut sur votre système. Cela peut être utile pour vérifier quelle version d'un programme est en cours d'exécution ou pour diagnostiquer des problèmes liés aux chemins d'accès des programmes.
|
||||
|
||||
<code BASH>
|
||||
❯ which python
|
||||
/usr/bin/python
|
||||
</code>
|
||||
|
||||
Si la commande n'est pas dans le ''$PATH'', la commande ''which'' ne pourra pas la trouver et renverra un message indiquant que la commande est introuvable.
|
||||
|
||||
<code BASH>
|
||||
❯ which tot
|
||||
which: no tot in (/usr/lib64/ccache:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/var/lib/snapd/snap/bin:/home/cedric24c/.local/bin:/home/cedric24c/bin)
|
||||
|
||||
</code>
|
||||
|
||||
32
data/pages/informatique/linux/commandes/xargs.txt
Normal file
32
data/pages/informatique/linux/commandes/xargs.txt
Normal file
@@ -0,0 +1,32 @@
|
||||
====== xargs ======
|
||||
{{tag>"script linux"}}
|
||||
{{ :dummy.png?75x75|Nom de la section}}
|
||||
|
||||
===== xargs -I =====
|
||||
|
||||
''xargs -I{}'' est une option de la commande ''xargs'' qui permet de spécifier un "marqueur" (ou "placeholder" en anglais), ici ''{}'', pour représenter chaque entrée dans la liste d'arguments passée à **xargs**. La commande qui suit **xargs** est exécutée pour chaque entrée en remplaçant ''{}'' par l'entrée correspondante.
|
||||
|
||||
Par exemple, si la sortie de la commande précédente est:
|
||||
|
||||
<code>
|
||||
file1
|
||||
file2
|
||||
file3
|
||||
</code>
|
||||
|
||||
L'exécution de ''xargs -I{} tail -n 5 "{}"'' sera équivalente à exécuter les commandes suivantes:
|
||||
|
||||
<code>
|
||||
tail -n 5 "file1"
|
||||
tail -n 5 "file2"
|
||||
tail -n 5 "file3"
|
||||
</code>
|
||||
|
||||
Cette option de ''xargs'' est utile pour exécuter une commande pour chaque entrée d'une liste d'arguments, sans avoir à gérer les caractères spéciaux tels que les espaces ou les retours à la ligne dans les entrées.
|
||||
|
||||
--- //[[user:jeanserien]]//
|
||||
<php>
|
||||
setlocale(LC_TIME, 'fr_FR');
|
||||
echo strftime(' - Article paru en premier le Thursday 02 February 2023');
|
||||
</php>
|
||||
|
||||
Reference in New Issue
Block a user