diff --git a/docs/books/admin_guide/11-tasks.fr.md b/docs/books/admin_guide/11-tasks.fr.md index 755c9f7f2f..350de6a022 100644 --- a/docs/books/admin_guide/11-tasks.fr.md +++ b/docs/books/admin_guide/11-tasks.fr.md @@ -146,7 +146,7 @@ Exemple : | ------ | ------------------------------------------------------------------------ | | `-e` | Modifier le fichier de planification avec vi | | `-l` | Affiche le contenu du fichier de planification | -| `- u` | Nom de l'utilisateur dont le fichier de planification doit être manipulé | +| `-u` | Nom de l'utilisateur dont le fichier de planification doit être manipulé | | `-r` | Supprime le fichier de planification | !!! Warning "Avertissement" diff --git a/docs/books/learning_ansible/01-basic.fr.md b/docs/books/learning_ansible/01-basic.fr.md new file mode 100644 index 0000000000..d6ca8a9af7 --- /dev/null +++ b/docs/books/learning_ansible/01-basic.fr.md @@ -0,0 +1,909 @@ +--- +title: Les bases d'Ansible +author: Antoine Le Morvan +contributors: Steven Spencer, tianci li, Aditya Putta, Ganna Zhyrnova +update: 15-Déc-2021 +--- + +# Les bases d'Ansible + +Dans ce chapitre, vous apprendrez à travailler avec Ansible. + +**** + +**Objectifs** : Dans ce chapitre, vous apprendrez à : + +:heavy_check_mark : Mettre en place Ansible ; +:heavy_check_mark : Appliquer des changements de configuration sur un serveur ; +:heavy_check_mark : Créer les premiers playbooks Ansible ; + +:checkered_flag: **ansible**, **module**, **playbook** + +**Connaissances**: :star : :star : :star : +**Complexité**: :star : :star : + +**Temps de lecture**: 30 minutes + +**** + +Ansible centralise et automatise les tâches d'administration. C'est un outil : + +* **sans agent** (il ne nécessite pas de déploiement spécifique sur les clients), +* **idempotent** (même effet à chaque fois qu'il est exécuté). + +Il utilise le protocole **SSH** pour configurer à distance les clients Linux ou le protocole **WinRM** pour travailler avec les clients Windows. Si aucun de ces protocoles n'est disponible, il est toujours possible pour Ansible d'utiliser une API, ce qui fait d'Ansible un véritable couteau suisse pour la configuration de serveurs, de postes de travail, de services Docker, d'équipements réseau, etc. (presque tout en fait). + +!!! warning "Avertissement" + + L'ouverture des flux SSH ou WinRM à tous les clients depuis le serveur Ansible en fait un élément critique de l'architecture qui doit être surveillé de près. + +Ansible étant principalement basé sur le push, il ne conservera pas l'état des serveurs ciblés entre chacune de ses exécutions. Au contraire, il effectuera de nouveaux contrôles d'état à chaque fois qu'il sera exécuté. Il est donc considéré stateless. + +Il vous sera utile pour : + +* le provisionnement (déploiement d'une nouvelle VM), +* les déploiements d'applications, +* la gestion de la configuration, +* l'automatisation, +* l'orchestration (lorsque plus d'une cible est utilisée). + +!!! note "Remarque" + + Ansible a été écrit à l'origine par Michael DeHaan, le fondateur d'autres outils tels que Cobbler. + + ![Michael DeHaan](images/Michael_DeHaan01.jpg) + + La première version la plus ancienne est la 0.0.1, publiée le 9 mars 2012. + + Le 17 octobre 2015, AnsibleWorks (la société à l'origine d'Ansible) a été rachetée par Red Hat pour 150 millions de dollars. + +![Les fonctionnalités d'Ansible](images/ansible-001.png) + +Pour offrir une interface graphique à votre utilisation quotidienne d'Ansible, vous pouvez installer des outils comme Ansible Tower (RedHat), qui n'est pas gratuit ou son homologue opensource Awx, d'autres projets comme Jenkins et l'excellent Rundeck peuvent également être utilisés. + +!!! abstract "Abstract" + + Pour suivre cette formation, vous aurez besoin d'au moins 2 serveurs sous Rocky : + + * la première sera la **machine de gestion**, Ansible y sera installé. + * le second sera le serveur à configurer et à gérer (un autre Linux que Rocky Linux fera tout aussi bien l'affaire). + + Dans les exemples ci-dessous, la station d'administration a l'adresse IP 172.16.1.10, la station gérée l’adresse IP 172.16.1.11. Il vous appartient d'adapter les exemples en fonction de votre plan d'adressage IP. + +## Le vocabulaire Ansible + +* La **machine de gestion** : la machine sur laquelle Ansible est installé. Ansible étant **sans agent**, aucun logiciel n'est déployé sur les serveurs gérés. +* Les **managed nodes** : les machines cibles gérées par Ansible sont aussi appelées "hôtes". Il peut s'agir de serveurs, composants du réseau ou n'importe quel autre ordinateur. +* L'**inventaire**: un fichier contenant des informations sur les serveurs gérés. +* Les **tâches** : une tâche est un bloc définissant une procédure à exécuter (par exemple, créer un utilisateur ou un groupe, installer un logiciel, etc.). +* Un **module** : un module représente une tâche. De nombreux modules sont fournis avec Ansible. +* Les **playbooks** : un simple fichier au format yaml définissant les serveurs cibles et les tâches à effectuer. +* Un **rôle** : un rôle permet d'organiser les playbooks et tous les autres fichiers nécessaires (modèles, scripts, etc.) pour faciliter le partage et la réutilisation du code. +* Une **collection** : une collection comprend un ensemble logique de playbooks, de rôles, de modules et de plugins. +* Les **faits (facts)** : il s'agit de variables globales contenant des informations sur le système (nom de la machine, version du système, interface et configuration du réseau, etc.) +* Les **handlers** : ils sont utilisés pour faire en sorte qu'un service soit arrêté ou redémarré en cas de modification. + +## Installation sur le serveur de gestion + +Ansible est disponible dans le dépôt _EPEL_, mais peut parfois être trop ancien pour la version actuelle, et vous voudrez travailler avec une version plus récente. + +Nous allons donc considérer deux types d'installation : + +* Celle basée sur les dépôts EPEL +* Celle basée sur le gestionnaire de paquets python, `pip` + +L'_EPEL_ est nécessaire pour les deux versions, vous pouvez donc l'installer dès maintenant : + +* Installation du dépôt EPEL : + +``` +sudo dnf install epel-release +``` + +### Installation depuis le dépôt EPEL + +Si nous installons Ansible à partir de _EPEL_, nous pouvons faire ce qui suit : + +``` +$ sudo dnf install ansible +``` + +Puis vérifiez l'installation : + +``` +$ ansible --version +ansible [core 2.14.2] + config file = /etc/ansible/ansible.cfg + configured module search path = ['/home/rocky/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules'] + ansible python module location = /usr/lib/python3.11/site-packages/ansible ansible collection location = /home/rocky/.ansible/collections:/usr/share/ansible/collections + executable location = /usr/bin/ansible + python version = 3.11.2 (main, Jun 22 2023, 04:35:24) [GCC 8.5.0 20210514 +(Red Hat 8.5.0-18)] (/usr/bin/python3.11) + jinja version = 3.1.2 + libyaml = True + +$ python3 --version +Python 3.6.8 +``` + +Veuillez noter qu’Ansible est livré avec sa propre version de python, différente de la version système de python (ici 3.11.2 vs 3.6.8). Vous devrez en tenir compte lors de l'installation par pip des modules python nécessaires à votre installation (par exemple `pip3.11 install PyVMomi`). + +### Installation à partir de python pip + +Comme nous voulons utiliser une version plus récente d'Ansible, nous l'installerons à partir de `python3-pip` : + +!!! note "Remarque" + + Supprimez Ansible si vous l'avez installé précédemment depuis _EPEL_. + +A ce stade, nous pouvons choisir d'installer ansible avec la version de python que nous souhaitons. + +``` +$ sudo dnf install python38 python38-pip python38-wheel python3-argcomplete rust cargo curl +``` + +!!! note "Remarque" + + `python3-argcomplete` est fourni par _EPEL_. Veuillez installer epel-release si ce n'est pas encore fait. + Ce paquetage vous aidera à compléter les commandes Ansible. + +Nous pouvons maintenant installer Ansible : + +``` +$ pip3.8 install --user ansible +$ activate-global-python-argcomplete --user +``` + +Vérifiez votre version d'Ansible : + +``` +$ ansible --version +ansible [core 2.13.11] + config file = None + configured module search path = ['/home/rocky/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules'] + ansible python module location = /home/rocky/.local/lib/python3.8/site-packages/ansible + ansible collection location = /home/rocky/.ansible/collections:/usr/share/ansible/collections + executable location = /home/rocky/.local/bin/ansible + python version = 3.8.16 (default, Jun 25 2023, 05:53:51) [GCC 8.5.0 20210514 (Red Hat 8.5.0-18)] + jinja version = 3.1.2 + libyaml = True +``` + +!!! note "Remarque" + + Dans notre cas, la version installée manuellement est plus ancienne que la version empaquetée par RPM parce que nous avons utilisé une version plus ancienne de Python. Cette observation variera avec le temps, l'âge de la distribution et la version de python bien sûr. + +## Fichiers de configuration + +La configuration du serveur se trouve sous `/etc/ansible`. + +Il existe deux fichiers de configuration principaux : + +* Le fichier de configuration principal `ansible.cfg` où se trouvent les commandes, les modules, les plugins et la configuration ssh ; +* Le fichier d'inventaire des machines clientes `hosts` où les clients et les groupes de clients sont indiqués. + +Le fichier de configuration sera automatiquement créé si Ansible est installé avec son paquetage RPM. Dans le cas d'une installation via `pip`, ce fichier n'existe pas. Nous allons devoir le créer à la main grâce à la commande `ansible-config` : + +``` +$ ansible-config -h +usage: ansible-config [-h] [--version] [-v] {list,dump,view,init} ... + +Visualiser la configuration d'Ansible. + +arguments positionnels : + {list,dump,view,init} + list Lister toutes les options de configuration + dump Afficher la configuration + view Afficher le fichier de configuration + init Créer la configuration initiale +``` + +Exemple : + +``` +ansible-config init --disabled > ; /etc/ansible/ansible.cfg +``` + +L'option `--disabled` permet de commenter l'ensemble des options en les faisant précéder d'un point-virgule `;`. + +!!! note "Remarque" + + Vous pouvez également choisir d'intégrer la configuration ansible dans votre référentiel de code, Ansible chargeant les fichiers de configuration qu'il trouve dans l'ordre suivant (en traitant le premier fichier qu'il rencontre et en ignorant les autres) : + + * si la variable d'environnement `$ANSIBLE_CONFIG` est définie, ouvrez le fichier spécifié. + * `ansible.cfg` s'il existe dans le répertoire courant. + * `~/.ansible.cfg` s'il existe (dans le répertoire personnel de l'utilisateur). + + Le fichier par défaut est chargé si aucun de ces trois fichiers n'est trouvé. + +### Le fichier d'inventaire `/etc/ansible/hosts` + +Comme Ansible devra travailler avec tous vos équipements à configurer, il est essentiel de lui fournir un (ou plusieurs) fichier(s) d'inventaire bien structuré(s) qui corresponde(nt) parfaitement à votre projet. + +Il est parfois nécessaire de bien réfléchir à la manière de construire ce fichier. + +Allez dans le fichier d'inventaire par défaut, qui se trouve sous `/etc/ansible/hosts`. Quelques exemples sont fournis et commentés : + +``` +# This is the default ansible 'hosts' file. +# +# It should live in /etc/ansible/hosts +# +# - Comments begin with the '#' character +# - Blank lines are ignored +# - Groups of hosts are delimited by [header] elements +# - You can enter hostnames or ip addresses +# - A hostname/ip can be a member of multiple groups + +# Ex 1: Ungrouped hosts, specify before any group headers: + +## green.example.com +## blue.example.com +## 192.168.100.1 +## 192.168.100.10 + +# Ex 2: A collection of hosts belonging to the 'webservers' group: + +## [webservers] +## alpha.example.org +## beta.example.org +## 192.168.1.100 +## 192.168.1.110 + +# If you have multiple hosts following a pattern, you can specify +# them like this: + +## www[001:006].example.com + +# Ex 3: A collection of database servers in the 'dbservers' group: + +## [dbservers] +## +## db01.intranet.mydomain.net +## db02.intranet.mydomain.net +## 10.25.1.56 +## 10.25.1.57 + +# Here's another example of host ranges, this time there are no +# leading 0s: + +## db-[99:101]-node.example.com +``` + +Comme vous pouvez le constater, le fichier fourni à titre d'exemple utilise le format INI, bien connu des administrateurs système. Notez que vous pouvez choisir un autre format de fichier (comme yaml par exemple), mais pour les premiers tests, le format INI est bien adapté à nos futurs exemples. + +L'inventaire peut être généré automatiquement en production, surtout si vous disposez d'un environnement de virtualisation comme VMware VSphere ou d'un environnement cloud (Aws, OpenStack, ou autre). + +* Création d'un groupe d'hôtes dans `/etc/ansible/hosts` : + +Comme vous l'avez peut-être remarqué, les groupes sont déclarés entre crochets. Viennent ensuite les éléments appartenant aux groupes. Vous pouvez créer, par exemple, un groupe `rocky8` en insérant le bloc suivant dans ce fichier : + +``` +[rocky8] +172.16.1.10 +172.16.1.11 +``` + +Les groupes peuvent être utilisés à l'intérieur d'autres groupes. Dans ce cas, il faut préciser que le groupe parent est composé de sous-groupes avec l'attribut `:children` comme ceci : + +``` +[linux:children] +rocky8 +debian9 + +[ansible:children] +ansible_management +ansible_clients + +[ansible_management] +172.16.1.10 + +[ansible_clients] +172.16.1.10 +``` + +Nous n'en dirons pas plus sur l'inventaire, mais si vous êtes intéressé, vous pouvez consulter [ce lien](https://docs.ansible.com/ansible/latest/user_guide/intro_inventory.html). + +Maintenant que notre serveur de gestion est installé et que notre inventaire est prêt, il est temps de lancer nos premières commandes `ansible`. + +## utilisation de la ligne de commande `ansible` + +La commande `ansible` lance une tâche sur un ou plusieurs hôtes cibles. + +``` +ansible [-m module_name] [-a args] [options] +``` + +Exemples : + +!!! warning "Avertissement" + + Comme nous n'avons pas encore configuré l'authentification sur nos deux serveurs de test, pas tous les exemples suivants ne fonctionneront. Ils sont donnés à titre d'exemple pour faciliter la compréhension et seront entièrement fonctionnels plus loin dans ce chapitre. + +* Liste les hôtes appartenant au groupe rocky8 : + +``` +ansible rocky8 --list-hosts +``` + +* Effectuer un test de connectivité auprès d'un groupe d'hôtes à l'aide du module `ping`: + +``` +ansible rocky8 -m ping +``` + +* Afficher les faits d'un groupe d'hôtes avec le module `setup` : + +``` +ansible rocky8 -m setup +``` + +* Exécuter une commande sur un groupe d'hôtes en invoquant le module `command` avec des arguments : + +``` +ansible rocky8 -m command -a 'uptime' +``` + +* Exécutez une commande avec les privilèges de l'administrateur root : + +``` +ansible ansible_clients --become -m command -a 'reboot' +``` + +* Exécuter une commande à l'aide d'un fichier d'inventaire personnalisé : + +``` +ansible rocky8 -i ./local-inventory -m command -a 'date' +``` + +!!! note "Remarque" + + Comme dans cet exemple, il est parfois plus simple de séparer la déclaration des périphériques gérés en plusieurs fichiers (par projet cloud par exemple) et de fournir à Ansible le chemin vers ces fichiers, plutôt que de maintenir un long fichier d'inventaire. + +| Option | Information | +| ------------------------ | ---------------------------------------------------------------------------------------------------------- | +| `-a 'arguments'` | Les arguments à transmettre au module. | +| `-b -K` | Demande un mot de passe et exécute la commande avec des privilèges plus élevés. | +| `--user=username` | Utilise cet utilisateur pour se connecter à l'hôte cible à la place de l'utilisateur actuel. | +| `--become-user=username` | Exécute l'opération en tant qu'utilisateur (par défaut : `root`). | +| `-C` | Simulation. N'apporte aucune modification à la cible, mais la teste pour voir ce qui devrait être modifié. | +| `-m module` | Exécute le module appelé | + +### Préparation du client + +Sur la machine de gestion et les clients, nous allons créer un utilisateur `ansible` dédié aux opérations effectuées par Ansible. Cet utilisateur devra utiliser les droits sudo, il devra donc être ajouté au groupe `wheel`. + +Cet utilisateur sera utilisé : + +* Du côté de la station d'administration : pour exécuter des commandes `ansible` et SSH vers les clients gérés. +* Sur les stations administrées (ici le serveur qui vous sert de station d'administration sert aussi de client, il est donc administré par lui-même) pour exécuter les commandes lancées depuis la station d'administration : il doit donc avoir les droits sudo. + +Sur les deux machines, créez un utilisateur `ansible`, dédié à Ansible : + +``` +$ sudo useradd ansible +$ sudo usermod -aG wheel ansible +``` + +Définir un mot de passe pour cet utilisateur : + +``` +$ sudo passwd ansible +``` + +Modifier la configuration de sudoers pour permettre aux membres du groupe `wheel` de faire du sudo sans mot de passe : + +``` +$ sudo visudo +``` + +Notre but ici est de commenter la valeur par défaut et de décommenter l'option NOPASSWD afin que ces lignes ressemblent à ceci lorsque nous aurons terminé : + +``` +## Allows people in group wheel to run all commands +# %wheel ALL=(ALL) ALL + +## Same thing without a password +%wheel ALL=(ALL) NOPASSWD: ALL +``` + +!!! warning "Avertissement" + + Si vous recevez le message d'erreur suivant lorsque vous entrez des commandes Ansible, cela signifie probablement que vous avez oublié cette étape sur l'un de vos clients : + `"msg" : "Missing sudo password` + +À partir de maintenant, lorsque vous utilisez le serveur de gestion, utilisez ce nouvel utilisateur : + +``` +$ sudo su - ansible +``` + +### Test avec le module ping + +Par défaut, la connexion par mot de passe n'est pas autorisée par Ansible. + +Décommentez la ligne suivante de la section `[defaults]` du fichier de configuration `/etc/ansible/ansible.cfg` et mettez-la à « True » : + +``` +ask_pass = True +``` + +Lancez un `ping` sur chaque serveur du groupe rocky8 : + +``` +# ansible rocky8 -m ping +SSH password: +172.16.1.10 | SUCCESS => { + "changed": false, + "ping": "pong" +} +172.16.1.11 | SUCCESS => { + "changed": false, + "ping": "pong" +} +``` + +!!! note "Remarque" + + On vous demande le mot de passe `ansible` des serveurs distants, ce qui constitue un problème de sécurité... + +!!! tip "Astuce" + + Si vous obtenez cette erreur `"msg" : "to use the 'ssh' connection type with passwords, you must install the sshpass program"`, vous pouvez simplement installer `sshpass` sur la station de gestion : + + ``` + sudo dnf install sshpass + ``` + +!!! abstract "Abstract" + + Vous pouvez maintenant tester les commandes qui n'ont pas fonctionné précédemment dans ce chapitre. + +## Clé d'authentification + +L'authentification par mot de passe sera remplacée par une authentification par clé privée/publique beaucoup plus sûre. + +### Création d'une clé SSH + +La double clé sera générée avec la commande `ssh-keygen` sur la station de gestion par l'utilisateur `ansible` : + +``` +[ansible]$ ssh-keygen +Generating public/private rsa key pair. +Saisissez le fichier dans lequel vous souhaitez enregistrer la clé (/home/ansible/.ssh/id_rsa) : +Saisir la phrase de passe (vide si aucune phrase de passe n'a été saisie) : +Saisissez à nouveau la même phrase de passe : +Votre identification a été sauvegardée dans /home/ansible/.ssh/id_rsa. +Votre clé publique a été enregistrée dans /home/ansible/.ssh/id_rsa.pub. +The key fingerprint is: +SHA256:Oa1d2hYzzdO0e/K10XPad25TA1nrSVRPIuS4fnmKr9g ansible@localhost.localdomain +The key's randomart image is: ++---[RSA 3072]----+ +| .o . +| +| o . =.| +| . . + +| +| o . = =.| +| S o = B.o| +| = + = =+| +| . + = o+B| +| o + o *@| +| . Eoo .+B| ++----[SHA256]-----+ + +``` + +La clé publique peut être copiée sur les serveurs : + +``` +# ssh-copy-id ansible@172.16.1.10 +# ssh-copy-id ansible@172.16.1.11 +``` + +Commentez la ligne suivante de la section `[defaults]` du fichier de configuration `/etc/ansible/ansible.cfg` pour empêcher l'authentification par mot de passe : + +``` +#ask_pass = True +``` + +### Test d'authentification par clé privée + +Pour le test suivant, le module `shell`, qui permet l'exécution de commandes à distance, est utilisé : + +``` +# ansible rocky8 -m shell -a "uptime" +172.16.1.10 | SUCCESS | rc=0 >> + 12:36:18 up 57 min, 1 user, load average: 0.00, 0.00, 0.00 + +172.16.1.11 | SUCCESS | rc=0 >> + 12:37:07 up 57 min, 1 user, load average: 0.00, 0.00, 0.00 +``` + +Aucun mot de passe n'est nécessaire, l'authentification par clé privée/publique fonctionne ! + +!!! note "Remarque" + + Dans un environnement de production, vous devez maintenant supprimer les mots de passe `ansible` précédemment définis pour renforcer votre sécurité (puisque maintenant un mot de passe d'authentification n'est pas nécessaire). + +## Utiliser Ansible + +Ansible peut être utilisé à partir du shell ou via des playbooks. + +### Les modules + +La liste des modules classés par catégorie se trouve [ici](https://docs.ansible.com/ansible/latest/collections/index_module.html). Ansible en offre plus de 750 ! + +Les modules sont désormais regroupés dans des collections de modules, dont la liste est disponible [ici](https://docs.ansible.com/ansible/latest/collections/index.html). + +Les collections sont un format de distribution pour le contenu Ansible qui peut inclure des playbooks, des rôles, des modules et des plugins. + +Un module est invoqué avec l'option `-m` de la commande `ansible`: + +``` +ansible [-m module_name] [-a args] [options] +``` + +There is a module for almost every need! Il est donc conseillé, au lieu d'utiliser le module shell, de rechercher un module adapté au besoin. + +Chaque catégorie de besoins a son propre module. En voici une liste non exhaustive : + +| Type | Exemples | +| ---------------------------- | ---------------------------------------------------------------------- | +| Gestion du Système | `user` (gestion des utilisateurs), `group` (gestion des groupes), etc. | +| Gestion des logiciels | `dnf`, `yum`, `apt`, `pip`, `npm` | +| Gestion de fichiers | `copy`, `fetch`, `lineinfile`, `template`, `archive` | +| Gestion des bases de données | `mysql`, `postgresql`, `redis` | +| Gestion de Cloud | `amazon S3`, `cloudstack`, `openstack` | +| Gestion des clusters | `consul`, `zookeeper` | +| Envoi de commandes | `shell`, `script`, `expect` | +| Téléchargements | `get_url` | +| Gestion de sources | `git`, `gitlab` | + +#### Exemple d'installation de logiciel + +Le module `dnf` permet d'installer des logiciels sur les clients cibles : + +``` +# ansible rocky8 --become -m dnf -a name="httpd" +172.16.1.10 | SUCCESS => { + "changed": true, + "msg": "", + "rc": 0, + "results": [ + ... + \n\nComplete!\n" + ] +} +172.16.1.11 | SUCCESS => { + "changed": true, + "msg": "", + "rc": 0, + "results": [ + ... + \n\nComplete!\n" + ] +} +``` + +Le logiciel installé étant un service, il faut maintenant le démarrer avec le module `systemd` : + +``` +# ansible rocky8 --become -m systemd -a "name=httpd state=started" +172.16.1.10 | SUCCESS => { + "changed": true, + "name": "httpd", + "state": "started" +} +172.16.1.11 | SUCCESS => { + "changed": true, + "name": "httpd", + "state": "started" +} +``` + +!!! tip "Astuce" + + Essayez de lancer ces deux dernières commandes deux fois. Vous observerez que la première fois, Ansible prendra des mesures pour atteindre l'état défini par la commande. La deuxième fois, il ne fera rien car il aura détecté que l'état est déjà atteint ! + +### Exercices + +Pour vous aider à découvrir Ansible et vous habituer à chercher dans la documentation Ansible, voici quelques exercices que vous pouvez faire avant de continuer : + +* Créer les groupes Paris, Tokio, NewYork +* Créer un utilisateur `supervisor` +* Modifier l'utilisateur pour qu'il ait un uid de 10000 +* Modifier l'utilisateur pour qu'il appartienne au groupe Paris +* Installer le logiciel tree +* Arrêter le service crond +* Créer un fichier vide avec les permissions `644` +* Mise à jour de la distribution client +* Redémarrez votre client + +!!! warning "Avertissement" + + Ne pas utiliser le module shell. Recherchez dans la documentation les modules appropriés ! + +#### module `setup`: introduction aux "facts" + +Les "facts" du système sont des variables récupérées par Ansible via son module `setup`. + +Jetez un coup d'œil aux différentes données "facts" de vos clients pour vous faire une idée de la quantité d'informations qui peuvent être facilement récupérées par le biais d'une simple commande. + +Nous verrons plus tard comment utiliser les "facts" dans nos playbooks et comment créer nos propres "facts". + +``` +# ansible ansible_clients -m setup | less +192.168.1.11 | SUCCESS => { + "ansible_facts": { + "ansible_all_ipv4_addresses": [ + "192.168.1.11" + ], + "ansible_all_ipv6_addresses": [ + "2001:861:3dc3:fcf0:a00:27ff:fef7:28be", + "fe80::a00:27ff:fef7:28be" + ], + "ansible_apparmor": { + "status": "disabled" + }, + "ansible_architecture": "x86_64", + "ansible_bios_date": "12/01/2006", + "ansible_bios_vendor": "innotek GmbH", + "ansible_bios_version": "VirtualBox", + "ansible_board_asset_tag": "NA", + "ansible_board_name": "VirtualBox", + "ansible_board_serial": "NA", + "ansible_board_vendor": "Oracle Corporation", + ... +``` + +Maintenant que nous avons vu comment configurer un serveur distant avec Ansible en ligne de commande, nous allons pouvoir introduire la notion de playbook. Les playbooks sont une autre façon d'utiliser Ansible, qui n'est pas beaucoup plus complexe, mais qui facilitera la réutilisation de votre code. + +## Playbooks + +Ansible's playbooks describe a policy to be applied to remote systems, to force their configuration. Les playbooks sont écrits dans un format textuel facilement compréhensible qui regroupe un ensemble de tâches : le format `yaml`. + +!!! note "Remarque" + + Cliquez [ici sur yaml] (https://docs.ansible.com/ansible/latest/reference_appendices/YAMLSyntax.html) pour en savoir plus + +``` +ansible-playbook ... [options] +``` + +Les options sont identiques à celles de la commande `ansible`. + +La commande renvoie les codes d'erreur suivants : + +| Code | Erreur | +| ----- | ---------------------------------------- | +| `0` | OK ou pas d'hôte correspondant | +| `1` | Erreur | +| `2` | Un ou plusieurs hôtes sont défaillants | +| `3` | Un ou plusieurs hôtes sont inaccessibles | +| `4` | Analyser l'erreur | +| `5` | Options erronées ou incomplètes | +| `99` | Exécution interrompue par l'utilisateur | +| `250` | Erreur inattendue | + +!!! note "Remarque" + + Notez que `ansible` renvoie Ok si aucun hôte ne correspond à votre cible, ce qui peut vous induire en erreur ! + +### Exemple de playbook pour Apache et MySQL + +Le playbook suivant nous permet d'installer Apache et MariaDB sur nos serveurs cibles. + +Créez un fichier `test.yml` avec le contenu suivant : + +``` +--- +- hosts: rocky8 <1> + become: true <2> + become_user: root + + tasks: + + - name: ensure apache is at the latest version + dnf: name=httpd,php,php-mysqli state=latest + + - name: ensure httpd is started + systemd: name=httpd state=started + + - name: ensure mariadb is at the latest version + dnf: name=mariadb-server state=latest + + - name: ensure mariadb is started + systemd: name=mariadb state=started +... +``` + +* <1> Le groupe ou le serveur ciblés doivent exister dans l'inventaire +* <2> Une fois connecté, l'utilisateur devient `root` (via `sudo` par défaut) + +L'exécution du playbook se fait avec la commande `ansible-playbook` : + +``` +$ ansible-playbook test.yml + +PLAY [rocky8] **************************************************************** + +TASK [setup] ****************************************************************** +ok: [172.16.1.10] +ok: [172.16.1.11] + +TASK [ensure apache is at the latest version] ********************************* +ok: [172.16.1.10] +ok: [172.16.1.11] + +TASK [ensure httpd is started] ************************************************ +changed: [172.16.1.10] +changed: [172.16.1.11] + +TASK [ensure mariadb is at the latest version] ********************************** +changed: [172.16.1.10] +changed: [172.16.1.11] + +TASK [ensure mariadb is started] *********************************************** +changed: [172.16.1.10] +changed: [172.16.1.11] + +PLAY RECAP ********************************************************************* +172.16.1.10 : ok=5 changed=3 unreachable=0 failed=0 +172.16.1.11 : ok=5 changed=3 unreachable=0 failed=0 +``` + +Pour plus de lisibilité, il est recommandé d'écrire vos playbooks strictement au format yaml. Dans l'exemple précédent, les arguments sont donnés sur la même ligne que le module, la valeur de l'argument suivant son nom séparé par un signe égal `=`. Regardez le même playbook en yaml strict : + +``` +--- +- hosts: rocky8 + become: true + become_user: root + + tasks: + + - name: ensure apache is at the latest version + dnf: + name: httpd,php,php-mysqli + state: latest + + - name: ensure httpd is started + systemd: + name: httpd + state: started + + - name: ensure mariadb is at the latest version + dnf: + name: mariadb-server + state: latest + + - name: ensure mariadb is started + systemd: + name: mariadb + state: started +... +``` + +!!! tip "Astuce" + + `dnf` est l'un des modules qui vous permet de lui donner une liste comme argument. + +Note sur les collections : Ansible propose désormais des modules sous forme de collections. Certains modules sont fournis par défaut dans la collection `ansible.builtin`, d'autres doivent être installés manuellement via l'option : + +``` +ansible-galaxy collection install [collectionname] +``` +où [collectionname] est le nom de la collection (les crochets sont utilisés pour souligner la nécessité de remplacer ce nom par un nom de collection réel et ne font PAS partie de la commande). + +L'exemple précédent devrait être rédigé comme suit : + +``` +--- +- hosts: rocky8 + become: true + become_user: root + + tasks: + + - name: ensure apache is at the latest version + ansible.builtin.dnf: + name: httpd,php,php-mysqli + state: latest + + - name: ensure httpd is started + ansible.builtin.systemd: + name: httpd + state: started + + - name: ensure mariadb is at the latest version + ansible.builtin.dnf: + name: mariadb-server + state: latest + + - name: ensure mariadb is started + ansible.builtin.systemd: + name: mariadb + state: started +... +``` + +Un playbook ne se limite pas à une seule cible : + +``` +--- +- hosts: webservers + become: true + become_user: root + + tasks: + + - name: ensure apache is at the latest version + ansible.builtin.dnf: + name: httpd,php,php-mysqli + state: latest + + - name: ensure httpd is started + ansible.builtin.systemd: + name: httpd + state: started + +- hosts: databases + become: true + become_user: root + + - name: ensure mariadb is at the latest version + ansible.builtin.dnf: + name: mariadb-server + state: latest + + - name: ensure mariadb is started + ansible.builtin.systemd: + name: mariadb + state: started +... +``` + +Vous pouvez vérifier la syntaxe de votre playbook : + +``` +$ ansible-playbook --syntax-check play.yml +``` + +Vous pouvez également utiliser un "linter" pour yaml : + +``` +$ dnf install -y yamllint +``` + +puis vérifiez la syntaxe yaml de vos playbooks : + +``` +$ yamllint test.yml +test.yml + 8:1 error syntax error: could not find expected ':' (syntax) +``` + +## Résultats des exercices + +* Créer les groupes Paris, Tokio, NewYork +* Créer l'utilisateur `supervisor` +* Modifier l'utilisateur pour qu'il ait un uid de 10000 +* Modifier l'utilisateur pour qu'il appartienne au groupe Paris +* Installer le logiciel tree +* Arrêter le service crond +* Créer un fichier vide avec les permissions `0644` +* Mise à jour de la distribution client +* Redémarrez votre client + +``` +ansible ansible_clients --become -m group -a "name=Paris" +ansible ansible_clients --become -m group -a "name=Tokio" +ansible ansible_clients --become -m group -a "name=NewYork" +ansible ansible_clients --become -m user -a "name=Supervisor" +ansible ansible_clients --become -m user -a "name=Supervisor uid=10000" +ansible ansible_clients --become -m user -a "name=Supervisor uid=10000 groups=Paris" +ansible ansible_clients --become -m dnf -a "name=tree" +ansible ansible_clients --become -m systemd -a "name=crond state=stopped" +ansible ansible_clients --become -m copy -a "content='' dest=/tmp/test force=no mode=0644" +ansible ansible_clients --become -m dnf -a "name=* state=latest" +ansible ansible_clients --become -m reboot +``` diff --git a/docs/books/learning_ansible/02-advanced.it.md b/docs/books/learning_ansible/02-advanced.it.md index 02cdcc4b3f..fd06a129cf 100644 --- a/docs/books/learning_ansible/02-advanced.it.md +++ b/docs/books/learning_ansible/02-advanced.it.md @@ -116,7 +116,7 @@ Per visualizzare una variabile, è necessario attivare il modulo `di debug` come ``` - ansible.builtin.debug: - var: "{{ service['debian'] }}" + var: service['debian'] ``` È anche possibile utilizzare la variabile all'interno di un testo: diff --git a/docs/gemstones/systemd_service_for_python_script.de.md b/docs/gemstones/systemd_service_for_python_script.de.md new file mode 100644 index 0000000000..c5dd5e9385 --- /dev/null +++ b/docs/gemstones/systemd_service_for_python_script.de.md @@ -0,0 +1,176 @@ +--- +title: Service `systemd` - Python Script +author: Antoine Le Morvan +contributors: Steven Spencer +tested_with: 8.6, 9.0 +tags: + - python + - systemd + - cron +--- + +# `systemd` Dienst für ein Python-Skript + +Wenn Sie wie viele Sysadmins ein Fan von Cron-Skripten sind, die mit `* * * * * * /I/launch/my/script.sh` gestartet werden, sollte dieser Artikel Sie an eine andere Möglichkeit erinnern, dies mit der ganzen Leichtigkeit des `systemd` zu tun. + +Wir schreiben ein Python-Skript, das eine Endlosschleife zur Ausführung der von Ihnen definierten Aktionen bereitstellt. + +Wir werden sehen, wie dieses Skript als `systemd` Dienst ausgeführt wird, wie die Protokolle in Journalctl anzeigt werden können, was passiert, wenn das Skript abstürzt. + +## Voraussetzungen + +Beginnen wir damit, einige Python-Abhängigkeiten zu installieren, die für das Skript benötigt werden, um das Kommando journalctl zu verwenden: + +``` +shell > sudo dnf install python36-devel systemd-devel +shell > sudo pip3 install systemd +``` + +## Skript entwerfen + +Lass uns das folgende Skript `my_service.py` anschauen: + +``` +""" +Sample script to run as script +""" +import time +import logging +import sys +from systemd.journal import JournaldLogHandler + +# Get an instance of the logger +LOGGER = logging.getLogger(__name__) + +# Instantiate the JournaldLogHandler to hook into systemd +JOURNALD_HANDLER = JournaldLogHandler() +JOURNALD_HANDLER.setFormatter(logging.Formatter( + '[%(levelname)s] %(message)s' +)) + +# Add the journald handler to the current logger +LOGGER.addHandler(JOURNALD_HANDLER) +LOGGER.setLevel(logging.INFO) + +class Service(): # pylint: disable=too-few-public-methods + """ + Launch an infinite loop + """ + def __init__(self): + + duration = 0 + + while True: + time.sleep(60) + duration += 60 + LOGGER.info("Total duration: %s", str(duration)) + # will failed after 4 minutes + if duration > 240: + sys.exit(1) + +if __name__ == '__main__': + + LOGGER.info("Starting the service") + Service() +``` + +Wir beginnen damit, die notwendigen Variablen zu instanziieren, um Logs dem Journal zu senden. Das Skript startet dann eine unendliche Schleife und pausiert für 60 Sekunden (was das Minimum einer Cron-Ausführung ist, so dass wir unter diese Grenze gehen können). + +!!! note "Anmerkung" + + Der Autor benutzt dieses Skript in einer fortgeschrittenen Form, die kontinuierlich eine Datenbank abfragt und Jobs basierend auf den über die Rundeck API abgerufenen Informationen ausführt + +## Integration in Systemd + +Jetzt, da wir ein Skript haben, das als Grundlage für Ihre Phantasie dienen kann, können wir es als System-Dienst installieren. + +Lass uns die Datei `my_service.service` erstellen und sie nach `/etc/systemd/system/` kopieren. + +``` +[Unit] +Description=My Service +After=multi-user.target + +[Service] +Type=simple +Restart=always +ExecStart=/usr/bin/python3 my_service.py +WorkingDirectory=/opt/my_service/ + +StandardOutput=syslog +StandardError=syslog +SyslogIdentifier=my_service + +[Install] +WantedBy=multi-user.target +``` + +Wie Sie sehen können, wird das Skript von `/opt/my_service/` gestartet. Denken Sie daran, den Pfad an Ihr Skript und die Syslog-Kennung anzupassen. + +Neuen Dienst aktivieren und starten: + +``` +shell > sudo systemctl daemon-reload +shell > sudo systemctl enable my_service.service +shell > sudo systemctl start my_service.service +``` + +## Tests + +Wir können die Protokolle jetzt via journalctl anzeigen: + +``` +shell > journalctl -f -u my_service +oct. 14 11:07:48 rocky8 systemd[1]: Started My Service. +oct. 14 11:07:49 rocky8 __main__[270267]: [INFO] Starting the service +oct. 14 11:08:49 rocky8 __main__[270267]: [INFO] Total duration: 60 +oct. 14 11:09:49 rocky8 __main__[270267]: [INFO] Total duration: 120 +``` + +Lass uns nun sehen, was passiert, wenn das Skript abgestürzt ist: + +``` +shell > ps -elf | grep my_service +4 S root 270267 1 0 80 0 - 82385 - 11:07 ? 00:00:00 /usr/bin/python3 my_service.py +shell > sudo kill -9 270267 +``` + +``` +shell > journalctl -f -u my_service +oct. 14 11:10:49 rocky8 __main__[270267]: [INFO] Total duration: 180 +oct. 14 11:11:49 rocky8 __main__[270267]: [INFO] Total duration: 240 +oct. 14 11:12:19 rocky8 systemd[1]: my_service.service: Main process exited, code=killed, status=9/KILL +oct. 14 11:12:19 rocky8 systemd[1]: my_service.service: Failed with result 'signal'. +oct. 14 11:12:19 rocky8 systemd[1]: my_service.service: Service RestartSec=100ms expired, scheduling restart. +oct. 14 11:12:19 rocky8 systemd[1]: my_service.service: Scheduled restart job, restart counter is at 1. +oct. 14 11:12:19 rocky8 systemd[1]: Stopped My Service. +oct. 14 11:12:19 rocky8 systemd[1]: Started My Service. +oct. 14 11:12:19 rocky8 __main__[270863]: [INFO] Starting the service +``` + +Wir können auch 5 Minuten warten, bis das Skript selbst abstürzt (entfernen Sie dies für Ihre Produktion): + +``` +oct. 14 11:16:02 rocky8 systemd[1]: Started My Service. +oct. 14 11:16:03 rocky8 __main__[271507]: [INFO] Starting the service +oct. 14 11:17:03 rocky8 __main__[271507]: [INFO] Total duration: 60 +oct. 14 11:18:03 rocky8 __main__[271507]: [INFO] Total duration: 120 +oct. 14 11:19:03 rocky8 __main__[271507]: [INFO] Total duration: 180 +oct. 14 11:20:03 rocky8 __main__[271507]: [INFO] Total duration: 240 +oct. 14 11:21:03 rocky8 __main__[271507]: [INFO] Total duration: 300 +oct. 14 11:21:03 rocky8 systemd[1]: my_service.service: Main process exited, code=exited, status=1/FAILURE +oct. 14 11:21:03 rocky8 systemd[1]: my_service.service: Failed with result 'exit-code'. +oct. 14 11:21:03 rocky8 systemd[1]: my_service.service: Service RestartSec=100ms expired, scheduling restart. +oct. 14 11:21:03 rocky8 systemd[1]: my_service.service: Scheduled restart job, restart counter is at 1. +oct. 14 11:21:03 rocky8 systemd[1]: Stopped My Service. +oct. 14 11:21:03 rocky8 systemd[1]: Started My Service. +oct. 14 11:21:03 rocky8 __main__[271993]: [INFO] Starting the service +``` + +Wie Sie sehen können, ist die Neustartfunktion von systemd sehr nützlich. + +## Fazit + +`systemd` und `journald` stellen uns die Werkzeuge zur Verfügung, um robuste und leistungsstarke Skripte so einfach wie möglich zu machen, dass sie unsere alten zuverlässigen Crontab-Skripte ersetzen. + +Wir hoffen, dass dieser Vorschlag für Sie nützlich sein wird. diff --git a/docs/gemstones/view_kernel_conf.de.md b/docs/gemstones/view_kernel_conf.de.md new file mode 100644 index 0000000000..1b4ea866ba --- /dev/null +++ b/docs/gemstones/view_kernel_conf.de.md @@ -0,0 +1,158 @@ +--- +title: Aktuelle Kernelkonfiguration anzeigen +author: David Hensley +contributors: Steven Spencer +tested_with: 8.5 +tags: + - kernel + - config + - modules + - kmod +--- + +# Aktuelle Kernelkonfiguration anzeigen + +Der Linux-Kernel speichert laufende Kernelinformationen an zwei Stellen durch spezielle Dateisysteme: ([Eine Zusammenfassung von ihnen](https://www.landoflinux.com/linux_procfs_sysfs.html)) + + - Der ältere [procfs](https://man7.org/linux/man-pages/man5/procfs.5.html), der `/proc` mountet (vergewissern Sie sich über `mount -l -t proc`) + - Die neueren [sysfs](https://man7.org/linux/man-pages/man5/sysfs.5.html) die `/sys` mountet (überprüfen mit `mount -l -t sysfs`) + +!!! warning "Warnhinweis" + + Seien Sie vorsichtig, wenn Sie die hier genannten Dateien untersuchen, Änderungen können das Verhalten des aktuellen Kernels ändern! + + +Diese beiden Schnittstellen erlauben es Ihnen, die Parameter des aktuell laufenden Kernels anzuzeigen und zu ändern. + +Beachten Sie, dass, wenn Sie auf einigen Dateien ein [`ls`](https://man7.org/linux/man-pages/man1/ls.1.html) -l ausführen, wird von diesen Dateien die Länge „0“ angezeigt, wenn Sie sie jedoch mit [`cat`](https://man7.org/linux/man-pages/man1/cat.1.html), enthalten sie tatsächlich Daten. Die meisten davon sind ASCII und editierbar, einige sind jedoch binär. In beiden Fällen Befehle wie [`file`](https://man7.org/linux/man-pages/man1/file.1.html) oder `stat` gibt normalerweise nur „leere Datei“ oder „0“ für Längen zurück, obwohl sie Ihnen andere Informationen anzeigen. + +Bevorzugte und Standardprogramme für die Interaktion mit diesen Funktionen sind [`lsmod`](https://man7.org/linux/man-pages/man8/lsmod.8.html), [`modinfo`](https://man7.org/linux/man-pages/man8/modinfo.8.html), und [`sysctl`](https://man7.org/linux/man-pages/man8/sysctl.8.html), unter anderem. + +```bash +sysctl -a | grep -i +``` + +```bash +lsmod | grep -i +``` + +```bash +modinfo +``` + +Ihre aktuelle "Kernel-Release" Version ist: + +`uname -r` und ersetze den Rückgabewert in Befehlen durch `$(uname -r)` + +RHEL und Derivate (Fedora, CentOS Stream, Scientific Linux, RockyLinux, Almalinux, et. al.) speichert auch die Konfiguration, die für bootbare installierte Kernel im Verzeichnis `/boot` verwendet wird, das Grub2 als ASCII-Dateien verwendet: + +```bash +/boot/config- +``` + +Um die aktuell laufende Kernelkonfiguration auf einen bestimmten Wert zu überprüfen: + +```bash +cat /boot/config-$(uname -r) | grep -i +``` + +Ergebnisse werden angezeigt: + + - "=m" wenn als Kernelmodul kompiliert + - "=y" wenn statisch in den Kernel kompiliert + - "is not set", wenn diese Einstellung auskommentiert wurde + - numerischer Wert + - String-Wert + +Einige Distributionen, wie Gentoo und Arch, verwenden das `configs` Kernelmodul um `/proc/config.gz` standardmäßig bereitzustellen: + +```bash +zcat /proc/config.gz | grep -i +zgrep /proc/config.gz +``` + +Für jede Distribution, wenn Ihr laufender Kernel sowohl `CONFIG_IKCONFIG` als auch `CONFIG_IKCONFIG_PROC` gesetzt hat und wenn + +```bash +ls -lh /sys/module/configs +``` + +existiert und ist ausführbar (durchsuchbar bei einem Verzeichnis), dann können Sie `/proc/config.gz` mit diesem Befehl generieren, wenn er nicht vorhanden ist: + +```bash +modprobe configs +``` + +!!! note "aktivierte Repos" + + Dieses Dokument deckt derzeit keine Kernel-Pakete ab, die möglicherweise von Nicht-Standard-Repos stammen, wie z.B.: + + appstream-debug, appstream-source, baseos-debug, baseos-source oder devel + + +Die `kernel-devel` Pakete installieren die Konfigurationsdatei, die verwendet wird, um jedes installierte Standard-Kernel-Paket als ASCII-Datei an der folgenden Stelle zu kompilieren: + +```bash +/usr/src/kernels//.config +``` + +Diese Datei wird häufiger durch einen symlinked Pfad aufgerufen, der von den `kernel-core` Paketen bereitgestellt wird: + +```bash +/lib/modules//build/ -> /usr/src/kernels// +``` + +Wenn Sie `kernel-debug-devel` Pakete installiert haben, haben Sie auch dieses Verzeichnis: + +```bash + /usr/src/kernels/+debug/ +``` + +Sie können in jedem der folgenden Informationen zu den Konfigurationswerten durchsuchen, die zum Erstellen eines installierten Kernels verwendet werden: + +```bash +/lib/modules//config +/lib/modules//build/.config +/usr/src/kernels//.config +/usr/src/kernels/+debug/.config +``` + +Konfigurierte Module für den aktuell laufenden Kernel, ob kompiliert wie eingebaut (i.e., statisch in den Kernel selbst) oder ein ladbares Modul, werden von Unterverzeichnissen mit dem Namen des Moduls aufgelistet: + +```bash +/sys/module/ +``` + +Für jede installierte Kernel-Veröffentlichung können Sie diese Dateien überprüfen, um zu sehen, welche Werte in diesem Kernel kompiliert wurden, und welche Version von [GCC](https://man7.org/linux/man-pages/man1/gcc.1.html) verwendet wurde, um es zu kompilieren: + +```bash +cat /lib/modules/$(uname -r)/config | grep -i +``` + +```bash +cat /lib/modules/$(uname -r)/build/.config | grep -i +``` + +```bash +cat /usr/src/kernels/$(uname -r)/.config | grep -i +``` + +```bash +cat /usr/src/kernels/$(uname -r)+debug/.config | grep -i +``` + +```bash +ls -lh /sys/module/ | grep -i +``` + +Sie können in der Datei nach Abhängigkeiten des Kernelmoduls suchen: + +```bash +/lib/modules//modules.dep +``` + +aber es ist einfacher, die Ausgabe des Feldes "Used-by" in [`lsmod`](https://man7.org/linux/man-pages/man8/lsmod.8.html) zu lesen oder zu parsen. + +## Referenzen: + +[depmod](https://man7.org/linux/man-pages/man8/depmod.8.html), [ls](https://man7.org/linux/man-pages/man1/ls.1.html), [lsmod](https://man7.org/linux/man-pages/man8/lsmod.8.html), [modinfo](https://man7.org/linux/man-pages/man8/modinfo.8.html), [modprobe](https://man7.org/linux/man-pages/man8/modprobe.8.html), [modules.dep](https://man7.org/linux/man-pages/man5/modules.dep.5.html), [namespaces](https://man7.org/linux/man-pages/man7/namespaces.7.html), [procfs](https://man7.org/linux/man-pages/man5/procfs.5.html), [sysctl](https://man7.org/linux/man-pages/man8/sysctl.8.html), [sysfs](https://man7.org/linux/man-pages/man5/sysfs.5.html), [uname](https://man7.org/linux/man-pages/man8/uname26.8.html) diff --git a/docs/gemstones/view_kernel_conf.fr.md b/docs/gemstones/view_kernel_conf.fr.md new file mode 100644 index 0000000000..c3eba9d759 --- /dev/null +++ b/docs/gemstones/view_kernel_conf.fr.md @@ -0,0 +1,158 @@ +--- +title: Analyser la configuration actuelle du noyau +author: David Hensley +contributors: Steven Spencer +tested_with: 8.5 +tags: + - kernel + - config + - modules + - kmod +--- + +# Analyser la configuration actuelle du noyau + +Le noyau Linux stocke ses informations en deux endroits via des systèmes de fichiers spéciaux : ([Un résumé](https://www.landoflinux.com/linux_procfs_sysfs.html)) + + - Les [procfs plus anciens](https://man7.org/linux/man-pages/man5/procfs.5.html) qui montent `/proc` (vérifier via `mount -l -t proc`) + - Les [sysfs plus récents](https://man7.org/linux/man-pages/man5/sysfs.5.html) qui montent `/sys` (vérifiez via `mount -l -t sysfs`) + +!!! warning "Attention" + + Soyez prudent si vous examinez les fichiers mentionnés ici, les modifier peut changer le comportement du noyau en cours d'exécution ! + + +Ces deux interfaces vous permettent de visualiser et de modifier les paramètres du noyau en cours d'exécution. + +Notez que si vous exécutez un [`ls`](https://man7.org/linux/man-pages/man1/ls.1.html) -l sur certains de ces fichiers, ils apparaissent comme ayant une longueur "0", mais si vous les extrayez avec [` cat`](https://man7.org/linux/man-pages/man1/cat.1.html), ils contiennent en fait des données. La plupart d'entre eux sont ASCII et modifiables, mais certains sont binaires. Dans les deux cas, des commandes comme [`file`](https://man7.org/linux/man-pages/man1/file.1.html) ou [`stat`](https://man7.org/linux/man-pages/man2/lstat.2.html) renvoient généralement simplement "fichier vide" ou "0" pour la taille, bien qu'ils afficheront d'autres informations. + +Les programmes prédestinés et standards pour interagir avec ces fonctions sont [`lsmod`](https://man7.org/linux/man-pages/man8/lsmod.8.html), [`modinfo`](https://man7.org/linux/man-pages/man8/modinfo.8.html), et [`sysctl`](https://man7.org/linux/man-pages/man8/sysctl.8.html), entre autres. + +```bash +sysctl -a | grep -i +``` + +```bash +lsmod | grep -i +``` + +```bash +modinfo +``` + +Voyez ce que vous utilisez actuellement avec la version "kernel release" : + +`uname -r` et remplacer sa valeur retournée dans les commandes en utilisant `$(uname -r)` + +RHEL et distributions dérivées (Fedora, CentOS Stream, Scientific Linux, RockyLinux, Almalinux, et autres) stocke également la configuration utilisée pour amorcer les noyaux installés dans le répertoire `/boot` utilisé par Grub2 comme fichiers ASCII : + +```bash +/boot/config- +``` + +Pour vérifier la configuration du noyau en cours d'exécution pour une valeur particulière: + +```bash +cat /boot/config-$(uname -r) | grep -i +``` + +Les résultats suivants devraient être affichés : + + - "=m" si compilé en tant que module de noyau + - "=y" si compilé statiquement dans le noyau + - "is not set" si ce paramètre a été commenté + - une valeur numérique + - une valeur de chaîne entre guillemets + +Certaines distributions, comme Gentoo et Arch, utilisent le module du noyau `configs` pour fournir par défaut `/proc/config.gz` : + +```bash +zcat /proc/config.gz | grep -i +zgrep /proc/config.gz +``` + +Pour toute distribution, si votre noyau en cours d'exécution a défini à la fois `CONFIG_IKCONFIG` et `CONFIG_IKCONFIG_PROC` et si + +```bash +ls -lh /sys/module/configs +``` + +existe et est exécutable (interrogeable dans le cas d'un répertoire), vous pouvez alors créer `/proc/config.gz` avec cette commande si elle n'est pas présente : + +```bash +modprobe configs +``` + +!!! note "Dépôts activés" + + Ce document ne couvre pas actuellement les paquets du noyau qui pourraient provenir de repos non par défaut tels que : + + appstream-debug, appstream-source, baseos-debug, baseos-source ou devel + + +Les paquets `kernel-devel` installent le fichier de configuration utilisé pour compiler chaque paquet de noyau standard installé en tant que fichier ASCII à l'emplacement suivant : + +```bash +/usr/src/kernels//.config +``` + +Ce fichier est plus couramment accédé par un chemin symbolique fourni par les paquets `kernel-core` : + +```bash +/lib/modules//build/ -> /usr/src/kernels// +``` + +Si vous avez des paquets `kernel-debug-devel` installés, vous aurez également ce répertoire : + +```bash + /usr/src/kernels/+debug/ +``` + +Vous pouvez regarder dans l'un des éléments suivants pour plus de détails sur les valeurs de configuration utilisées pour construire un noyau installé : + +```bash +/lib/modules//config +/lib/modules//build/.config +/usr/src/kernels//.config +/usr/src/kernels/+debug/.config +``` + +Les modules configurés pour le noyau en cours d'exécution, s'ils sont compilés comme internes (i.e. statiquement dans le noyau lui-même) ou dans un module chargeable, sont listés par sous-répertoires nommés comme nom de module dans : + +```bash +/sys/module/ +``` + +Pour chaque version du noyau installée, vous pouvez examiner ces fichiers pour voir quelles sont les valeurs compilées dans ce noyau, et quelle version de [GCC](https://man7.org/linux/man-pages/man1/gcc.1.html) a été utilisée pour la compiler : + +```bash +cat /lib/modules/$(uname -r)/config | grep -i +``` + +```bash +cat /lib/modules/$(uname -r)/build/.config | grep -i +``` + +```bash +cat /usr/src/kernels/$(uname -r)/.config | grep -i +``` + +```bash +cat /usr/src/kernels/$(uname -r)+debug/.config | grep -i +``` + +```bash +ls -lh /sys/module/ | grep -i +``` + +Vous pouvez vérifier les dépendances du module de noyau dans le fichier : + +```bash +/lib/modules//modules.dep +``` + +mais il est plus facile de lire ou d'analyser la sortie du champ "Used-by" dans [`lsmod`](https://man7.org/linux/man-pages/man8/lsmod.8.html). + +## Références : + +[depmod](https://man7.org/linux/man-pages/man8/depmod.8.html), [ls](https://man7.org/linux/man-pages/man1/ls.1.html), [lsmod](https://man7.org/linux/man-pages/man8/lsmod.8.html), [modinfo](https://man7.org/linux/man-pages/man8/modinfo.8.html), [modprobe](https://man7.org/linux/man-pages/man8/modprobe.8.html), [modules.dep](https://man7.org/linux/man-pages/man5/modules.dep.5.html), [namespaces](https://man7.org/linux/man-pages/man7/namespaces.7.html), [procfs](https://man7.org/linux/man-pages/man5/procfs.5.html), [sysctl](https://man7.org/linux/man-pages/man8/sysctl.8.html), [sysfs](https://man7.org/linux/man-pages/man5/sysfs.5.html), [uname](https://man7.org/linux/man-pages/man8/uname26.8.html) diff --git a/docs/guides/automation/cron_jobs_howto.it.md b/docs/guides/automation/cron_jobs_howto.it.md index 497364ef12..e6791a2c6f 100644 --- a/docs/guides/automation/cron_jobs_howto.it.md +++ b/docs/guides/automation/cron_jobs_howto.it.md @@ -4,12 +4,12 @@ author: Steven Spencer contributors: Ezequiel Bruni, Ganna Zhyrnova tested on: 8.5 tags: - - automazione del lavoro - - automazione + - job automation + - automation - cron --- -# Automatizzare i Processi con `cron` e `crontab` +# Automazione dei processi con `cron` e `crontab` ## Prerequisiti @@ -19,8 +19,8 @@ tags: ## Presupposto * Conoscenza di base di bash, python o altri strumenti di scripting o programmazione, e si desidera che uno script venga eseguito automaticamente -* Che si stia eseguendo come utente root o che si sia passati a root con `sudo -s` - **(È possibile eseguire alcuni script nelle proprie directory come utente personale. In questo caso, il passaggio a root non è necessario)** +* Che si stia operando come utente root o che si abbia la possibilità di `sudo -s` + **(È possibile eseguire alcuni script nelle proprie directory come proprio utente. In questo caso, il passaggio a root non è necessario)** ## Introduzione @@ -28,11 +28,11 @@ Linux fornisce il sistema _cron_, un job scheduler basato sul tempo, per automat La _crontab_ è essenzialmente un elenco in cui gli utenti aggiungono le proprie attività e i propri lavori automatizzati, con molte opzioni che possono semplificare ulteriormente le cose. Questo documento ne esplorerà alcuni. È un buon ripasso per chi ha un po' di esperienza e i nuovi utenti possono aggiungere il sistema `cron` alla loro dotazione di strumenti. -`anacron` è discusso brevemente qui in riferimento alle directory `cron` "dot". `cron` viene eseguito da `anacron` ed è utile per le macchine che non sono sempre attive, come le workstation e i notebook. Il motivo è che mentre `cron` esegue i lavori in base a una pianificazione, se la macchina è spenta quando il lavoro è pianificato, il lavoro non viene eseguito. Con `anacron` il lavoro verrà eseguito quando la macchina è di nuovo accesa, anche se l'esecuzione programmata è avvenuta in passato. `anacron`, tuttavia, utilizza un approccio più randomizzato per eseguire compiti in cui la tempistica non è esatta. Questo ha senso per le workstation e i notebook, ma non per i server. Questo può essere un problema per cose come i backup dei server, ad esempio, che richiedono l'esecuzione di un lavoro a un'ora specifica. È qui che `cron` fornisce la soluzione migliore per gli amministratori di server. Tuttavia, gli amministratori di server e gli utenti di workstation o notebook possono trarre vantaggio da entrambi gli approcci. È possibile combinarli in base alle proprie esigenze. Per ulteriori informazioni su `anacron`, vedere [anacron - Automazione dei comandi](anacron.md). +`anacron` è discusso brevemente qui in riferimento alle directory `cron` "dot". `cron` viene eseguito da `anacron` ed è utile per le macchine che non sono sempre attive, come le workstation e i notebook. Il motivo è che mentre `cron` esegue i lavori in base a una pianificazione, se la macchina è spenta all'ora prevista, il lavoro non verrà eseguito. Con `anacron` il lavoro verrà eseguito quando la macchina è di nuovo accesa, anche se l'esecuzione programmata è avvenuta in passato. `anacron`, tuttavia, utilizza un approccio più randomizzato per eseguire compiti in cui la tempistica non è esatta. Questo ha senso per le workstation e i notebook, ma non per i server. Questo può essere un problema per cose come i backup dei server, ad esempio, che richiedono l'esecuzione di un lavoro a un'ora specifica. È qui che `cron` fornisce la soluzione migliore per gli amministratori di server. Tuttavia, gli amministratori di server e gli utenti di workstation o notebook possono trarre vantaggio da entrambi gli approcci. È possibile combinarli in base alle proprie esigenze. Per ulteriori informazioni su `anacron`, vedere [anacron - Automazione dei comandi](anacron.md). ### Iniziare in modo semplice: le directory dot di `cron` -Incorporate in ogni sistema Linux da molte versioni, le directory `cron` "dot" aiutano ad automatizzare i processi rapidamente. Queste appaiono come directory che il sistema `cron` chiama in base alle loro convenzioni di denominazione. Tuttavia, vengono eseguiti in modo diverso, a seconda del processo assegnato per chiamarli, `anacron` o `cron`. Il comportamento predefinito prevede l'uso di `anacron`, ma può essere modificato dall'amministratore del server, della workstation o del notebook. +Incorporate in ogni sistema Linux da molte versioni, le directory `cron` "dot" aiutano ad automatizzare i processi rapidamente. Queste appaiono come directory che il sistema `cron` chiama in base alle loro convenzioni di denominazione. Questi vengono eseguiti in modo diverso, tuttavia, in base al processo assegnato per richiamarli, `anacron` o `cron`. Il comportamento predefinito prevede l'uso di `anacron`, ma può essere modificato dall'amministratore del server, della workstation o del notebook. #### Per i Server @@ -66,9 +66,9 @@ Questo si traduce in quanto segue: #### Per le workstations -Se si desidera eseguire gli script su una workstation o un notebook nelle directory `cron` "dot", non è necessario nulla di particolare. È sufficiente copiare il file di script nella directory in questione e assicurarsi che sia eseguibile. Ecco le directory: +Se si desidera eseguire gli script su una workstation o un notebook nelle directory `cron` "dot", non è necessario eseguire nulla di complicato. Copiate il file di script nella directory in questione e assicuratevi che sia eseguibile. Ecco le directory: -* `/etc/cron.hourly` - Gli script inseriti qui verranno eseguiti un minuto dopo l'ora ogni ora (questo viene eseguito da `cron`, indipendentemente dal fatto che `anacron` sia installato o meno) +* `/etc/cron.hourly` - Gli script inseriti qui verranno eseguiti un minuto dopo l'ora ogni ora (eseguiti da `cron` indipendentemente dal fatto che `anacron` sia installato o meno) * `/etc/cron.daily` - Gli script messi qui saranno eseguiti ogni giorno. `anacron` regola la tempistica di queste operazioni (vedere il suggerimento) * `/etc/cron.weekly` - Gli script inseriti qui verranno eseguiti ogni 7 giorni, in base al giorno del calendario dell'ultima esecuzione (vedi suggerimento) * `/etc/cron.monthly` - Gli script inseriti qui verranno eseguiti mensilmente in base al giorno di calendario dell'ultima esecuzione (vedi suggerimento) @@ -89,7 +89,7 @@ Se gli orari automatici e randomizzati non funzionano bene in [Per le postazioni `crontab -e` -Questo tirerà fuori il `crontab` dell'utente root così come esiste in questo momento nell'editor scelto, e potrebbe essere qualcosa di simile a questo. Leggete questa versione commentata, poiché contiene le descrizioni di ogni campo che utilizzerete successivamente: +In questo modo si recupera il `crontab` dell'utente root, così come si trova in questo momento, nell'editor scelto, e potrebbe avere un aspetto simile a questo. Leggete questa versione commentata, poiché contiene le descrizioni di ogni campo che utilizzerete successivamente: ``` # Edit this file to introduce tasks to be run by cron. @@ -137,17 +137,17 @@ Per aggiungere il lavoro, eseguire: `crontab -e` -`crontab` è l'acronimo di "cron table" e il formato del file è, di fatto, un layout di tabella libera. Ora che siete nella `crontab`, andate in fondo al file e aggiungete la vostra nuova voce. Se si utilizza `vi` come editor di sistema predefinito, ciò avviene con i seguenti tasti: +`crontab` è l'acronimo di "cron table" e il formato del file è, di fatto, un layout di tabella libera. Ora che siete nel `crontab`, andate in fondo al file e aggiungete la vostra voce. Se si utilizza `vi` come editor di sistema predefinito, lo si farà con i seguenti tasti: -`Shift : $` +SHIFT+:+$ Ora che siete in fondo al file, inserite una riga e un breve commento per descrivere la vostra voce. A questo scopo si aggiunge un "#" all'inizio della riga: `# Backing up the system every night at 10PM` -Premere invio. Dovreste essere ancora nella modalità di inserimento, quindi il passo successivo è aggiungere la voce. Come mostrato nella nostra `crontab` vuota e commentata (sopra), questo è **m** per minuti, **h** per ore, **dom** per giorno della settimana, **mon** per mese, e **dow** giorno della settimana. +Premere INVIO. Dovreste essere ancora nella modalità di inserimento, quindi il passo successivo è aggiungere la voce. Come mostrato nella nostra `crontab` vuota e commentata (sopra), questo è **m** per minuti, **h** per ore, **dom** per giorno della settimana, **mon** per mese, e **dow** giorno della settimana. -Per eseguire il nostro script di backup ogni giorno alle 10:00, la voce avrebbe il seguente aspetto: +Per eseguire il nostro script di backup ogni giorno alle 10:00, la voce si presenta così: `00 22 * * * /usr/local/sbin/backup` @@ -174,7 +174,7 @@ Per il nostro esempio di script di backup, se si usa l'opzione @daily per esegui ### Opzioni più complesse -Finora le soluzioni utilizzate sono state piuttosto semplicistiche, ma che dire di tempistiche più complesse? Supponiamo di voler eseguire lo script di backup ogni 10 minuti durante il giorno (probabilmente non è una cosa pratica da fare, ma è un esempio!). Per fare questo, il crontab dovrebbe essere : +Finora le soluzioni utilizzate sono state piuttosto semplicistiche, ma che dire di tempistiche più complesse? Supponiamo di voler eseguire lo script di backup ogni 10 minuti durante il giorno (probabilmente non è una cosa pratica da fare, ma è un esempio!). Per fare questo il crontab è: `*/10 * * * * /usr/local/sbin/backup` diff --git a/docs/guides/automation/cron_jobs_howto.uk.md b/docs/guides/automation/cron_jobs_howto.uk.md index 13445a6e85..5dbfe1b912 100644 --- a/docs/guides/automation/cron_jobs_howto.uk.md +++ b/docs/guides/automation/cron_jobs_howto.uk.md @@ -139,13 +139,13 @@ MAILTO=root `crontab` розшифровується як "cron table", а формат файлу фактично є розкладним макетом таблиці. Тепер, коли ви перебуваєте в `crontab`, перейдіть у нижню частину файлу та додайте новий запис. Якщо ви використовуєте `vi` як системний редактор за замовчуванням, це робиться за допомогою наступних клавіш: -`Shift : $` +SHIFT+:+$ Тепер, коли ви знаходитесь у нижній частині файлу, вставте рядок і введіть короткий коментар, щоб описати, що відбувається з вашим записом. Це можна зробити, додавши "#" на початку рядка: `# Backing up the system every night at 10PM` -Натисніть Enter. Ви все ще маєте бути в режимі вставки, тому наступним кроком є додавання вашого запису. Як показано в `crontab` з порожнім коментарем (вище), це **m** для хвилин, **h** для годин, **dom** для дня місяця, **mon** для місяця та **dow** для дня тижня. +Натисніть ENTER. Ви все ще маєте бути в режимі вставки, тому наступним кроком є додавання вашого запису. Як показано в `crontab` з порожнім коментарем (вище), це **m** для хвилин, **h** для годин, **dom** для дня місяця, **mon** для місяця та **dow** для дня тижня. Щоб запускати наш сценарій резервного копіювання щодня о 10:00, запис повинен мати наступний вигляд: diff --git a/docs/guides/desktop/kde_installation.fr.md b/docs/guides/desktop/kde_installation.fr.md new file mode 100644 index 0000000000..9a73fe2ead --- /dev/null +++ b/docs/guides/desktop/kde_installation.fr.md @@ -0,0 +1,106 @@ +--- +title: Installation de KDE +author: Steven Spencer +contributors: Ezequiel Bruni, Ganna Zhyrnova +tested_with: 9.0 +tags: + - bureau + - kde +--- + +# Introduction + +Grâce à l'équipe de développement de Rocky Linux, il y a maintenant des images live pour plusieurs installations de bureau, dont KDE. Pour ceux qui ne savent peut-être pas ce qu'est une image live, elle permet de démarrer le système d'exploitation et l'environnement de bureau en utilisant le support d'installation et vous donnera un aperçu avant de l'installer. + +!!! note + + Cette procédure est spécifique à Rocky Linux 9.0. Il n'y a actuellement aucune procédure décrite pour installer KDE pour les autres versions de Rocky Linux. + N'hésitez pas à écrire une description ! + +## Prérequis + +* Une machine, compatible avec Rocky Linux 9.0, (bureau, ordinateur portable ou serveur) sur laquelle vous voulez utiliser le bureau KDE. +* Maîtriser la ligne de commande de manière à pouvoir réaliser certaines tâches, par exemple tester les sommes de contrôle de l'image. +* La connaissance de la façon d'écrire une image amorçable sur DVD ou une clé USB. + +## Obtenir, vérifier et créer une image Live de KDE + +Avant l'installation, la première étape consiste à télécharger l'image live et à l'enregistrer sur un DVD ou une clé USB. Comme indiqué précédemment, l'image autonome sera amorçable, tout comme tout autre support d'installation pour Linux. Vous pouvez trouver la dernière image KDE dans la section de téléchargement pour Rocky Linux 9 [images lives](https://dl.rockylinux.org/pub/rocky/9.0/live/x86_64/). + +Notez que ce lien particulier suppose que x86_64 est l'architecture de votre processeur. Si vous avez une architecture aarch64, vous pouvez utiliser l'image correspondante à la place. Téléchargez à la fois l'image live et les fichiers de somme de contrôle. + +Maintenant vérifiez l'image avec le fichier CHECKSUM en utilisant la commande suivante (note : c'est un exemple ! Assurez-vous que le nom de votre image et les fichiers CHECKSUM correspondent) : + +``` +sha256sum -c CHECKSUM --ignore-missing Rocky-9-KDE-x86_64-latest.iso.CHECKSUM +``` + +Si tout se passe bien, vous devriez obtenir ce message : + +``` +Rocky-9-KDE-x86_64-latest.iso: OK +``` + +Si la somme de contrôle du fichier retourne OK, vous êtes maintenant prêt à enregistrer votre image ISO sur votre support de stockage. Nous supposons ici que vous savez enregistrer l'image sur votre support de stockage. Cette procédure est différente suivant l'OS que vous utilisez, les supports de stockage et les outils logiciels. + +## Démarrage + +Là encore, cela diffère selon la machine, le BIOS, le système d'exploitation, etc. Vous devez vous assurer que votre machine est configurée pour démarrer avec n'importe quel support (DVD ou USB) comme premier périphérique de démarrage. Vous verrez cet écran si vous réussissez : + +![kde_boot](images/kde_boot.png) + +Si c'est le cas, vous êtes sur la bonne voie ! Si vous voulez tester le média, vous pouvez d'abord sélectionner cette option ou bien vous pouvez simplement taper **S** pour **Start Rocky Linux KDE 9.x**. + +N'oubliez pas qu'il s'agit d'une image live. Le lancement jusqu'au premier écran prend un certain temps. Pas de panique, il suffit d'attendre ! Lorsque l'image live est lancée, vous verrez cet écran : + +![kde_live](images/kde_live.png) + +## Installation de KDE + +À ce stade, vous pouvez utiliser l'environnement KDE et voir si il vous convient. Une fois que vous avez décidé de l'utiliser de manière permanente, double-cliquez sur l'option **Install to Hard Drive**. + +Cela lancera un processus d'installation assez familier pour ceux qui ont déjà installé Rocky Linux. Le premier écran vous donnera la possibilité de changer la langue qui correspond à votre région : + +![kde_language](images/kde_language.png) + +Une fois que vous avez sélectionné votre langue et cliqué sur **Continue**, l'installation passera à l'écran suivant. Nous avons mis en évidence les choses que vous *pouvez* vouloir modifier et vérifier : + +![kde_install](images/kde_install.png) + +1. **Keyboard** - Jetez un coup d'œil à cette option et assurez-vous qu'elle correspond bien à la disposition du clavier que vous utilisez. +2. **Heure & Date** - Assurez-vous que l'affichage correspond à votre fuseau horaire. +3. **Installation Destination** - Vous devrez cliquer sur cette option, même si c'est juste pour accepter ce qui est déjà indiqué. +4. **Network & Hostname** - Vérifiez que vous avez ce dont vous avez besoin ici. À condition que le réseau soit activé, vous pouvez toujours modifier plus tard si vous le souhaitez. +5. **Root Password** Allez-y et définissez un mot de passe root. Pensez à le sauvegarder dans un endroit sûr (gestionnaire de mots de passe), surtout si vous ne l'utilisez pas souvent. +6. **User Creation** Créer au moins un utilisateur. Si vous voulez qu'il dispose de droits d'administration, n'oubliez pas de définir cette option lors de la création de l'utilisateur. +7. **Begin Installation** - une fois que vous avez choisi et vérifié tous les paramètres, cliquez sur cette option. + +Une fois que vous avez lancé l'étape 7, le processus d'installation devrait commencer à installer des paquets, comme dans la capture d'écran ci-dessous : + +![kde_install_2](images/kde_install_2.png) + +Une fois l'installation sur le disque dur terminée, vous devriez voir l'écran suivant : + +![kde_install_final](images/kde_install_final.png) + +Allez-y et cliquez sur **Finish Installation**. + +À ce stade, vous devrez redémarrer le système et retirer votre support d'amorçage. Quand l'OS est relancé pour la première fois, l'écran de configuration suivant apparaît : + +![kde_config](images/kde_config.png) + +Cliquez sur l’option **Licencing Information** et acceptez l'EULA comme indiqué ici : + +![eula](images/eula.png) + +Et finissez la configuration : + +![kde_finish_config](images/kde_finish_config.png) + +Une fois cette étape terminée, le nom d'utilisateur que vous avez créé précédemment s'affiche. Entrez le mot de passe que vous avez créé pour l'utilisateur et appuyez sur ENTER. Cela devrait vous montrer un écran de bureau KDE : + +![kde_screen](images/kde_screen.png) + +## Conclusion + +Grâce à l'équipe de développement de Rocky Linux, il y a plusieurs environnements de bureau que vous pouvez installer à partir d'images en direct pour Rocky Linux 9.0. Pour ceux qui n'aiment pas trop le bureau GNOME par défaut, KDE est une autre option et peut facilement être installé avec l'image live. diff --git a/docs/labs/networking/lab5-nfs.it.md b/docs/labs/networking/lab5-nfs.it.md index 6521cfa50f..102dc429bd 100644 --- a/docs/labs/networking/lab5-nfs.it.md +++ b/docs/labs/networking/lab5-nfs.it.md @@ -118,7 +118,7 @@ SYNOPSIS ```bash systemctl status nfs-server ``` - **RISULTATO** + **RISULTATO** ```bash ● nfs-server.service - NFS server and services Loaded: loaded (/usr/lib/systemd/system/nfs-server.service; disabled; vendor preset: disabled) @@ -354,5 +354,9 @@ ESEGUIRE L'ESERCIZIO DAL SISTEMA PARTNER !!! Tip "Suggerimento" - È necessario disabilitare il trattamento speciale di NFS per i file di proprietà di root. Questo si ottiene specificando una certa opzione che "slega" il superutente nel file "/etc/exports". + È necessario disabilitare il trattamento speciale di NFS per i file di proprietà di root. Questo si ottiene specificando un'opzione speciale che "svincola" il superutente nel file "/etc/exports". L'opzione speciale è chiamata `no_root_squash`. Si noti che l'uso dell'opzione `no_root_squash` è considerata una cattiva pratica e un rischio per la sicurezza. Una voce di esempio per ottenere questo risultato per qualsiasi host che corrisponda a `localhost` in `/etc/exports` avrà l'aspetto seguente: + + ```bash + /mnt/nfs 172.16.99.0/24(rw) localhost(rw,no_root_squash) + ``` diff --git a/docs/labs/systems_administration_I/lab7-software_management.it.md b/docs/labs/systems_administration_I/lab7-software_management.it.md index 0b905d5c73..7424fdc48b 100644 --- a/docs/labs/systems_administration_I/lab7-software_management.it.md +++ b/docs/labs/systems_administration_I/lab7-software_management.it.md @@ -499,7 +499,7 @@ Le opzioni più comuni utilizzate con l'utilità `dnf` sono: #### Per utilizzare `dnf` per l'installazione dei pacchetti -Supponendo che abbiate già disinstallato l'utilità `wget` da un esercizio, nei passi seguenti useremo DNF per installare il pacchetto. Il processo di 2-3 passi che abbiamo richiesto in precedenza quando abbiamo installato `wget` tramite `rpm` dovrebbe essere ridotto a un solo passo utilizzando `dnf`. `dnf` risolverà tranquillamente qualsiasi dipendenza. +Supponendo che abbiate già disinstallato l'utilità `wget` da un esercizio, nei passi seguenti useremo DNF per installare il pacchetto. Il processo in 2-3 fasi richiesto in precedenza per l'installazione di `wget` tramite `rpm` dovrebbe essere ridotto a un unico processo utilizzando `dnf`. `dnf` risolverà tranquillamente qualsiasi dipendenza. 1. Per prima cosa, assicuriamoci che `wget` e `libmetalink` siano disinstallati dal sistema. Digitare: diff --git a/docs/labs/systems_administration_II/lab7-the_linux_kernel.it.md b/docs/labs/systems_administration_II/lab7-the_linux_kernel.it.md index f3c971e4c5..5dfe0b4331 100644 --- a/docs/labs/systems_administration_II/lab7-the_linux_kernel.it.md +++ b/docs/labs/systems_administration_II/lab7-the_linux_kernel.it.md @@ -107,7 +107,7 @@ In questo esercizio si aggiornerà direttamente il kernel utilizzando l'applicaz 4. Usare `dnf` per scaricare l'ultimo pacchetto del kernel disponibile dal repository ufficiale dei pacchetti Rocky Linux. Digitare: ```bash - [root@localhost ~]# dnf list kernel + [root@localhost ~]# dnf download kernel ``` Ora si dovrebbe avere un pacchetto RPM con un nome simile a kernel-*.x86_64.rpm salvato nella propria PWD. @@ -120,7 +120,7 @@ In questo esercizio si aggiornerà direttamente il kernel utilizzando l'applicaz 6. Usare `rpm` per fare un'installazione di prova del kernel*.rpm scaricato per assicurarsi che tutte le sue dipendenze siano soddisfatte. Digitare: ```bash - [root@localhost ~]# rpm --test -Uvh kernel-*.x86_64.rpm + [root@localhost ~]# rpm --test -ivh kernel-*.x86_64.rpm error: Failed dependencies: kernel-core-uname-r = *.x86_64 is needed by kernel-*.x86_64 @@ -129,7 +129,7 @@ In questo esercizio si aggiornerà direttamente il kernel utilizzando l'applicaz Dall'output si può vedere che il pacchetto ha dipendenze non soddisfatte. -7. Usare `dnf` per scaricare le dipendenze necessarie. Digitare: +7. Utilizzare `dnf` per scaricare le dipendenze necessarie segnalate nel precedente messaggio di errore. Digitare: ```bash [root@localhost ~]# dnf download kernel-core-uname-r kernel-modules-uname-r @@ -226,13 +226,13 @@ In questo esercizio si costruirà un nuovo kernel dai sorgenti, configurandolo, 2. Installare gli strumenti di sviluppo necessari. Digitare: ```bash - [root@localhost linux-6.5.7]# sudo dnf -y groupinstall 'Development Tools' + [root@localhost linux-6.5.7]# dnf -y groupinstall 'Development Tools' ``` -3. Installare le librerie necessarie. Digitare: +3. Installare le librerie e gli strumenti necessari. Digitare: ```bash - [root@localhost linux-6.*]# dnf -y install ncurses-devel openssl-devel elfutils-libelf-devel python3 dwarves + [root@localhost linux-6.*]# dnf -y install ncurses-devel bc openssl-devel elfutils-libelf-devel python3 dwarves ``` 4. Scaricare l'ultimo sorgente del kernel digitando: