Maîtrisez les Commandes Linux pour

les Ingénieurs DevOps

Introduction
Si vous êtes un ingénieur DevOps, connaître des commandes Linux est
indispensable. Que vous utilisiez une machine Linux physique, une
machine virtuelle ou un terminal Linux en ligne, cet article vous
guidera à travers les commandes Linux essentielles pour un ingénieur
DevOps.

Commandes Linux pour les DevOps

Informations sur le Système

Pour commencer, il est crucial de connaître les commandes qui vous

fourniront des informations vitales sur le système sur lequel vous
travaillez. Ces commandes sont souvent le point de départ pour
toute tâche d'administration système en environnement DevOps. Voici
quelques-unes des commandes les plus utiles.
•hostname : Affiche le nom d'hôte du système, ce qui est crucial
pour l'identification réseau lors de la gestion de plusieurs
serveurs en environnement DevOps.
•hostid : Révèle l'ID d'hôte attribué par le système d'exploitation,
souvent utilisé dans des scripts d'automatisation pour identifier
de manière unique chaque machine.
•date : Montre la date et l'heure actuelles au format UTC,
essentielles pour la synchronisation des tâches planifiées et le
débogage temporel.
•whoami : Indique le nom d'utilisateur actuellement connecté au
terminal, ce qui est important pour les tâches d'administration et
pour éviter des actions non autorisées.
 •uptime : Affiche la durée depuis la dernière mise en marche du
système, une métrique clé pour le monitoring de la performance
et de la disponibilité du système.
•uname : Donne le nom UNIX du système, ce qui est important pour
la compatibilité des applications et pour s'assurer que les bons
environnements sont en place.
•clear : Nettoie l'écran du terminal, ce qui facilite la lisibilité et
permet une meilleure concentration sur les tâches en cours.
•history : Liste toutes les commandes précédemment exécutées,
ce qui est pratique pour retracer des actions, comprendre des
erreurs passées ou répéter des commandes complexes.
•sudo : Permet d'exécuter des commandes en tant que
superutilisateur, ce qui est souvent nécessaire pour des tâches
d'administration système en DevOps.
•echo $? : Affiche le statut de sortie de la dernière commande
exécutée, ce qui est utile pour les scripts d'automatisation et le
débogage.
En résumé, ces commandes vous aideront à obtenir des informations
vitales sur votre système, ce qui est souvent le premier pas dans
toute tâche d'administration système. Maîtriser ces commandes est
donc indispensable pour tout ingénieur DevOps.

Commandes de Répertoire

La navigation dans le système de fichiers est plus qu'une

simple compétence de base pour un ingénieur DevOps. C'est la
fondation sur laquelle repose la gestion efficace des déploiements,
des configurations et des automatisations. Voici comment ces
commandes peuvent être utilisées de manière optimale.
•pwd : Affiche le répertoire de travail actuel. Cette commande est
essentielle pour savoir où vous vous trouvez dans le système de
fichiers, ce qui est crucial lorsque vous travaillez avec des scripts
d'automatisation ou des tâches planifiées.
•cd : Change de répertoire. Cette commande est la pierre
angulaire de la navigation dans le système de fichiers. Elle est
souvent utilisée dans les scripts d'automatisation pour se
déplacer vers le répertoire approprié avant d'exécuter des
commandes spécifiques.
•mkdir : Crée un nouveau répertoire. Cette commande est utile
non seulement pour organiser vos fichiers, mais aussi pour créer
 des espaces isolés pour des projets ou des environnements de
test, ce qui est souvent nécessaire en DevOps.
•ls : Liste les fichiers et dossiers du répertoire actuel. Cette
commande est indispensable pour explorer le contenu d'un
répertoire, pour vérifier les résultats d'un script d'automatisation
ou même pour surveiller les changements dans un répertoire
spécifique.
En résumé, ces commandes ne sont pas seulement des outils de
navigation de base. Elles sont essentielles pour une gestion efficace
du système de fichiers, ce qui est un aspect fondamental de
l'ingénierie DevOps. Savoir comment et quand utiliser ces commandes
peut grandement améliorer votre efficacité dans des tâches allant de
l'automatisation à la surveillance.

Commandes de Fichier

La gestion des fichiers est une tâche quotidienne incontournable pour

un ingénieur DevOps. Que vous soyez en train de configurer des
environnements, de gérer des déploiements ou de surveiller des
systèmes, ces commandes sont des outils indispensables dans votre
boîte à outils DevOps.
•touch : Crée un fichier vide ou met à jour le timestamp d'un
fichier existant. Cette commande est souvent utilisée dans des
scripts d'automatisation pour créer des fichiers de configuration
ou des indicateurs de verrouillage.
•cat : Concatène et affiche le contenu des fichiers. Cette
commande est utile pour lire rapidement des fichiers de
configuration ou des fichiers journaux sans avoir à ouvrir un
éditeur de texte.
•head : Affiche les premières lignes d'un fichier. Cette commande
est particulièrement utile pour avoir un aperçu rapide des
fichiers journaux ou des fichiers de configuration, ce qui peut
être crucial pour le débogage rapide.
•tail : Affiche les dernières lignes d'un fichier. Cette commande
est souvent utilisée pour le suivi en temps réel des fichiers
journaux, ce qui est essentiel pour la surveillance et le débogage
en temps réel.
•rm : Supprime des fichiers ou des répertoires. Cette commande
doit être utilisée avec prudence, surtout dans des scripts
d'automatisation, où une suppression erronée peut avoir des
conséquences graves.
 •cp : Copie des fichiers ou des répertoires. Cette commande est
souvent utilisée pour la sauvegarde de fichiers de configuration
avant de faire des modifications, ce qui est une bonne pratique
en DevOps.
•mv : Déplace ou renomme des fichiers et des répertoires. Cette
commande est essentielle pour l'organisation de vos fichiers, que
ce soit pour renommer des fichiers de configuration ou pour
déplacer des fichiers dans des répertoires plus appropriés.
En conclusion, ces commandes ne sont pas simplement des utilitaires
pour la gestion des fichiers; elles sont des composants essentiels de
toute stratégie de gestion de configuration et d'automatisation en
DevOps. Leur maîtrise vous permettra de manipuler vos fichiers et vos
systèmes avec une précision et une efficacité accrues.
Information
La commande rm -rf est puissante mais dangereuse. Elle supprime
de force le répertoire et tout son contenu sans demander de
confirmation.

Commandes de Permission de Fichier

La gestion des permissions est non seulement cruciale pour la

sécurité, mais aussi pour l'efficacité des flux de travail en DevOps.
Contrôler les permissions est souvent une étape préliminaire dans
l'automatisation et la configuration du système.
•ls -l : Affiche les permissions d'un fichier ou d'un répertoire.
Cette commande est souvent le point de départ pour évaluer les
niveaux de sécurité et d'accès, ce qui est essentiel pour la
conformité et l'audit.
•chmod : Modifie les permissions d'un fichier ou d'un répertoire.
Cette commande est cruciale pour la gestion de l'accès,
notamment pour définir des permissions spécifiques dans des
scripts d'automatisation.
•chown : Change le propriétaire d'un fichier ou d'un répertoire.
Cette commande est souvent utilisée dans des environnements
où plusieurs utilisateurs ou services doivent interagir avec les
mêmes fichiers.
•chgrp : Change le groupe d'un fichier ou d'un répertoire. Cette
commande est utile pour la gestion des groupes, notamment
dans des environnements où les équipes ont des niveaux d'accès
différents.
En somme, ces commandes vont au-delà de la simple gestion des
permissions. Elles sont des outils essentiels pour configurer et
sécuriser des environnements en DevOps, permettant une gestion fine
des accès et des rôles.

Commandes de Gestion des Utilisateurs

La gestion des utilisateurs est au cœur de toute stratégie de sécurité

et d'administration en DevOps. Ces commandes vous permettent non
seulement de gérer les accès, mais aussi d'automatiser la création et
la suppression de comptes utilisateurs.
•useradd : Crée un compte utilisateur. Cette commande est
souvent utilisée dans des scripts d'automatisation pour
configurer de nouveaux environnements ou ajouter des
utilisateurs en masse.
•passwd : Établit ou modifie un mot de passe pour un utilisateur.
Cette commande est cruciale pour la sécurité des comptes et
peut être intégrée dans des processus d'automatisation pour la
réinitialisation des mots de passe.
•userdel : Supprime un compte utilisateur. Cette commande est
importante pour la gestion des accès, surtout dans des
environnements dynamiques où les besoins en ressources
peuvent changer rapidement.
•usermod : Modifie un compte utilisateur. Cette commande est
utile pour ajuster les rôles et les permissions, ce qui est souvent
nécessaire dans des environnements DevOps complexes.
En conclusion, ces commandes sont des éléments clés pour la gestion
sécurisée et efficace des utilisateurs et des groupes dans un
environnement DevOps. Elles permettent une administration fine et
peuvent être intégrées dans des scripts pour l'automatisation des
tâches administratives.

Commandes de Recherche et de Filtrage

La recherche et le filtrage sont des compétences essentielles pour

tout ingénieur DevOps, notamment pour l'analyse des logs, la gestion
des fichiers de configuration et le débogage. Voici quelques
commandes indispensables pour ces tâches.
•locate : Utilisé pour rechercher rapidement des fichiers ou des
répertoires par leur nom. Cette commande est souvent utilisée
dans des scripts d'automatisation ou pour localiser des fichiers
de configuration.
 •grep : Indispensable pour trouver des motifs textuels dans des
fichiers. Cette commande est cruciale pour l'analyse des logs, le
filtrage des données et la recherche dans des fichiers de
configuration.
•find : Extrêmement flexible, cette commande permet de trouver
des fichiers et des répertoires en fonction de divers critères
comme la taille, la date de modification, et plus encore. Elle est
souvent utilisée dans des tâches de maintenance et de
nettoyage.
En résumé, ces commandes sont des outils puissants pour la
recherche et le filtrage, des tâches qui sont souvent automatisées en
DevOps pour améliorer l'efficacité et la précision.

Commandes d'Information sur le Matériel

La surveillance du matériel est une composante clé de la gestion des

performances et de la fiabilité en DevOps. Voici quelques commandes
pour vous aider à garder un œil sur l'état de votre matériel.
•free -h : Affiche des informations sur la mémoire du système
dans un format facilement lisible, ce qui est crucial pour le
monitoring des ressources.
•df -h : Fournit des détails sur l'utilisation de l'espace disque, ce
qui est essentiel pour la gestion des ressources et la
planification de l'espace disque.
•du : Donne des informations sur l'utilisation du disque pour des
fichiers ou des répertoires spécifiques, utile pour le dépannage
et l'optimisation du stockage.
En conclusion, ces commandes sont indispensables pour la
surveillance et la gestion du matériel, ce qui peut avoir un impact
direct sur la performance et la disponibilité des services.

Commandes Réseau

La gestion du réseau est une autre facette cruciale du rôle d'un

ingénieur DevOps. Ces commandes vous permettent de diagnostiquer
des problèmes de réseau, de tester la connectivité et même de
récupérer des fichiers à distance.
•ping : Utilisé pour vérifier la connectivité réseau avec un autre
hôte. Cette commande est souvent le premier pas dans le
dépannage des problèmes de réseau.
 •dig : Affiche des informations DNS, ce qui est utile pour le
dépannage des problèmes de résolution de noms.
•wget : Permet de télécharger des fichiers depuis le web, souvent
utilisé dans des scripts pour récupérer des ressources ou des
fichiers de configuration.
•curl : Similaire à wget, mais avec plus d'options pour récupérer
ou envoyer des données à travers divers protocoles.
En résumé, ces commandes réseau sont des outils essentiels pour
tout ingénieur DevOps, permettant une gestion efficace et un
dépannage rapide des problèmes de réseau.

Commandes d'Information sur les Processus

La gestion et la surveillance des processus sont des aspects

fondamentaux du rôle d'un ingénieur DevOps. Ces commandes vous
permettent de suivre, de contrôler et d'optimiser les processus en
cours d'exécution sur votre système.
•ps : Cette commande affiche les processus actuellement en cours
d'exécution, ce qui est vital pour le monitoring et le dépannage.
•top : Fournit une vue en temps réel des processus en cours, ce
qui est crucial pour l'analyse des performances et la détection
des goulots d'étranglement.
•kill : Permet de terminer un processus spécifique, ce qui est
souvent nécessaire pour gérer les ressources et résoudre les
problèmes.
En somme, ces commandes sont des outils essentiels pour la gestion
des processus, un aspect souvent négligé mais crucial pour la stabilité
et la performance du système.

Conclusion

Les commandes Linux sont le pilier de la boîte à outils d'un ingénieur

DevOps. Elles couvrent un large éventail de tâches, allant de la
gestion des fichiers et des répertoires à la surveillance des ressources
matérielles et des processus. En devenant compétent dans l'utilisation
de ces commandes, vous vous armerez des compétences nécessaires
pour naviguer avec succès dans le paysage complexe et en constante
évolution du DevOps.
AUTRES RECHERCHES

Les ingénieurs DevOps utilisent fréquemment un large éventail de commandes Linux pour
automatiser des tâches, gérer des serveurs, déployer des applications, surveiller des systèmes, et
plus encore. Voici une liste de certaines commandes Linux couramment utilisées par les ingénieurs
DevOps :

1. Navigation dans le système de fichiers :

• cd : Changer de répertoire.
• ls : Lister le contenu d'un répertoire.
• pwd : Afficher le chemin du répertoire actuel.
2. Gestion des fichiers :

• cp : Copier des fichiers.

• mv : Déplacer ou renommer des fichiers.
• rm : Supprimer des fichiers.
• touch : Créer des fichiers vides.
3. Gestion des répertoires :

• mkdir : Créer des répertoires.

• rmdir : Supprimer des répertoires vides.
4. Manipulation de fichiers textuels :

• cat : Afficher le contenu d'un fichier.

• grep : Rechercher des motifs dans des fichiers.
• sed : Éditer des fichiers textuels.
5. Gestion des processus :

• ps : Afficher les processus en cours d'exécution.

• top : Afficher les processus en temps réel.
• kill : Terminer des processus.
6. Gestion des utilisateurs et des groupes :

• useradd : Créer un nouvel utilisateur.

 • userdel : Supprimer un utilisateur.
• passwd : Changer le mot de passe d'un utilisateur.
• groupadd : Créer un nouveau groupe.
• usermod : Modifier les paramètres d'un utilisateur.
7. Gestion des droits de fichiers :

• chmod : Modifier les permissions d'un fichier.

• chown : Modifier le propriétaire d'un fichier.
• chgrp : Modifier le groupe d'un fichier.
8. Réseau :

• ifconfig : Afficher ou configurer les interfaces réseau.

• netstat : Afficher des informations sur les connexions réseau.
• ssh : Se connecter à des serveurs distants de manière sécurisée.
• scp : Copier des fichiers entre machines distantes.
9. Archivage et compression :

• tar : Créer et extraire des archives.

• zip et unzip : Compresser et décompresser des fichiers.
10.Gestion de paquets :

• apt ou yum : Gérer les paquets (selon la distribution Linux).

11.Automatisation de tâches :

• cron : Planifier des tâches récurrentes.

• at : Planifier des tâches ponctuelles.
12.Journalisation et surveillance :

• tail : Afficher les dernières lignes d'un fichier journal.

• dmesg : Afficher les messages du noyau.
• top et htop : Surveiller les ressources système en temps réel.
• syslog : Gérer les journaux système.
13.Manipulation de variables d'environnement :
 • export : Définir des variables d'environnement.
• env : Afficher les variables d'environnement.
14.Gestion de conteneurs :

• docker : Gérer des conteneurs Docker.

• kubectl : Interagir avec des clusters Kubernetes.
15.Automatisation de scripts et de déploiements :

• bash : Exécuter des scripts shell.

• ansible : Automatiser la configuration et le déploiement.

Ces commandes Linux sont essentielles pour les ingénieurs DevOps et

constituent la base de nombreuses opérations courantes de gestion et
d'automatisation des infrastructures et des applications.

donnez des exemples d ' utilisation de ces commandes

Bien sûr, voici quelques exemples d'utilisation de certaines des commandes

Linux mentionnées précédemment :

1. cd - Changer de répertoire :

• cd /var/www : Change le répertoire de travail actuel en

"/var/www".
2. ls - Lister le contenu d'un répertoire :

• ls : Liste les fichiers et répertoires dans le répertoire actuel.

• ls -l : Liste les fichiers avec des informations détaillées, y
compris les permissions, les propriétaires, les tailles, etc.
3. cp - Copier des fichiers :

• cp fichier.txt /destination : Copie "fichier.txt" vers

le répertoire de destination.
4. mv - Déplacer ou renommer des fichiers :
 • mv fichier.txt nouveau-nom.txt : Renomme
"fichier.txt" en "nouveau-nom.txt".
• mv fichier.txt /destination : Déplace "fichier.txt" vers
le répertoire de destination.
5. rm - Supprimer des fichiers :

• rm fichier.txt : Supprime le fichier "fichier.txt".

6. mkdir - Créer des répertoires :

• mkdir mon_repertoire : Crée un répertoire nommé

"mon_repertoire".
7. ps - Afficher les processus en cours d'exécution :

• ps aux : Affiche tous les processus en cours d'exécution avec des

informations détaillées.
8. useradd - Créer un nouvel utilisateur :

• useradd nouveau_utilisateur : Crée un nouvel

utilisateur nommé "nouveau_utilisateur".
9. chmod - Modifier les permissions d'un fichier :

• chmod 755 mon_script.sh : Définit les permissions pour

que le fichier "mon_script.sh" soit exécutable.
10.ifconfig - Afficher ou configurer les interfaces réseau :

• ifconfig : Affiche les informations sur les interfaces réseau.

11.ssh - Se connecter à des serveurs distants :

• ssh utilisateur@adresse_ip : Se connecte à un serveur

distant en utilisant SSH.
12.tar - Créer et extraire des archives :

• tar -czvf mon_archive.tar.gz dossier_source :

Crée une archive compressée de "dossier_source".
• tar -xzvf mon_archive.tar.gz : Extrait une archive.
 13.cron - Planifier des tâches récurrentes :

• crontab -e : Édite la table des tâches cron pour planifier des

tâches périodiques.
14.tail - Afficher les dernières lignes d'un fichier journal :

• tail -n 20 /var/log/syslog : Affiche les 20 dernières

lignes du fichier journal syslog.
15.docker - Gérer des conteneurs Docker :

• docker run -d -p 80:80 nginx : Démarre un conteneur

Nginx en arrière-plan.
16.bash - Exécuter des scripts shell :

• ./mon_script.sh : Exécute un script shell appelé

"mon_script.sh".

Ces exemples vous montrent comment utiliser certaines des commandes Linux de base pour
effectuer des tâches courantes en tant qu'ingénieur DevOps. Bien sûr, la façon dont vous utiliserez
ces commandes dépendra de vos besoins spécifiques et de votre infrastructure.

Bien sûr, voici quelques exemples d'utilisation de plus de commandes Linux couramment utilisées
par les ingénieurs DevOps :

17.grep - Rechercher des motifs dans des fichiers :

• grep "motif" fichier.txt : Recherche le motif spécifié

dans le fichier "fichier.txt".
18.sed - Éditer des fichiers textuels :

• sed 's/ancien_motif/nouveau_motif/g'
fichier.txt : Remplace toutes les occurrences de
"ancien_motif" par "nouveau_motif" dans "fichier.txt".
19.groupadd - Créer un nouveau groupe :
 • groupadd mon_groupe : Crée un groupe nommé
"mon_groupe".
20.passwd - Changer le mot de passe d'un utilisateur :

• passwd utilisateur : Permet à l'utilisateur de changer son

mot de passe.
21.netstat - Afficher des informations sur les connexions réseau :

• netstat -tuln : Affiche les ports ouverts et les connexions

réseau.
22.scp - Copier des fichiers entre machines distantes :

• scp fichier.txt utilisateur@serveur

distant:/destination : Copie "fichier.txt" depuis la
machine locale vers un serveur distant.
23.top - Afficher les processus en temps réel :

• top : Affiche une liste en temps réel des processus en cours

d'exécution, triée par utilisation CPU.
24.syslog - Gérer les journaux système :

• tail -f /var/log/syslog : Affiche en temps réel les

entrées du journal système.
25.export - Définir des variables d'environnement :

• export NOM_VARIABLE=valeur : Définit une variable

d'environnement.
26.env - Afficher les variables d'environnement :

• env : Affiche toutes les variables d'environnement actuellement

définies.
27.kubectl - Interagir avec des clusters Kubernetes :

• kubectl get pods : Affiche la liste des pods dans un cluster

Kubernetes.
28.ansible - Automatiser la configuration et le déploiement :
 • ansible-playbook mon_playbook.yml : Exécute un
playbook Ansible pour automatiser des tâches de configuration et
de déploiement.
29.apt - Gérer les paquets (sur les systèmes basés sur Debian) :

• sudo apt update : Met à jour la liste des paquets disponibles.

• sudo apt install nom_paquet : Installe un paquet.
• sudo apt remove nom_paquet : Supprime un paquet.
30.yum - Gérer les paquets (sur les systèmes basés sur Red Hat) :

• sudo yum update : Met à jour la liste des paquets disponibles.

• sudo yum install nom_paquet : Installe un paquet.
• sudo yum remove nom_paquet : Supprime un paquet.

Ces exemples montrent comment utiliser certaines commandes Linux supplémentaires pour
effectuer diverses tâches de gestion, de surveillance, d'automatisation et de déploiement dans un
environnement DevOps. Il est important de noter que la syntaxe précise de ces commandes peut
varier en fonction de votre système d'exploitation Linux et de la configuration de votre
environnement.

EXERCICES ET SOLUTIONS

Exercice 1 : Navigation et gestion des fichiers

1. Créez un répertoire appelé "mon_dossier" dans votre répertoire personnel.

2. Accédez à ce répertoire.
3. Créez un fichier vide nommé "mon_fichier.txt" à l'intérieur de "mon_dossier".
4. Liste le contenu de "mon_dossier".
5. Renommez "mon_fichier.txt" en "nouveau_fichier.txt".
6. Supprimez "nouveau_fichier.txt".
7. Revenez à votre répertoire personnel.

SOLUTIONS
Exercice 2 : Manipulation de fichiers texte

1. Créez un fichier texte appelé "mon_texte.txt" dans votre répertoire personnel.

2. Écrivez "Hello, World!" dans ce fichier en utilisant un éditeur de texte ou une commande.
3. Affichez le contenu de "mon_texte.txt" en utilisant la commande cat .
4. Recherchez le mot "Hello" dans le fichier en utilisant grep .
5. Remplacez "World" par "Linux" dans le fichier en utilisant sed .

solution
********************************************************************************
Exercice 3 : Gestion des utilisateurs et des groupes
1. Créez un nouvel utilisateur appelé "nouvel_utilisateur".
2. Créez un groupe appelé "mon_groupe".
3. Ajoutez l'utilisateur "nouvel_utilisateur" au groupe "mon_groupe".
4. Changez le mot de passe de "nouvel_utilisateur".
5. Vérifiez que l'utilisateur a été correctement ajouté au groupe.

Solution

********************************************************************************
**** Exercice 4 : Gestion des processus
 1. Lancez un processus en arrière-plan, par exemple, une commande sleep pour attendre
quelques secondes.
2. Utilisez la commande ps pour afficher la liste des processus en cours d'exécution.
3. Utilisez la commande kill pour arrêter le processus que vous avez lancé.

Solution 4 :

********************************************************************************
******

Exercice 6 : Archivage et compression de fichiers

1. Créez un répertoire contenant plusieurs fichiers.

2. Utilisez la commande tar pour créer une archive de ce répertoire.
3. Utilisez la commande tar pour extraire l'archive dans un répertoire différent.

Solution 6 :
*************************************************************
Exercice 6 : Archivage et compression de fichiers

1. Créez un répertoire contenant plusieurs fichiers.

2. Utilisez la commande tar pour créer une archive de ce répertoire.
3. Utilisez la commande tar pour extraire l'archive dans un répertoire différent.

Solution 6 :

********************************************************************************
*
*****************************************************************
c est la suite des textes dans l image****le propriétaire (lecture et écriture) et pour les autres
(lecture seulement)

********************************************************************
Exercice 10 : Gestion de conteneurs Docker

1. Installez Docker si ce n'est pas déjà fait.

2. Téléchargez et lancez un conteneur Nginx en arrière-plan.
3. Vérifiez que le conteneur Nginx est en cours d'exécution.
4. Arrêtez et supprimez le conteneur Nginx.
*
**

************************
***********
Exercice 13 : Création de scripts Bash

1. Créez un script Bash qui affiche la date et l'heure actuelles.

2. Assurez-vous que le script est exécutable.
3. Exécutez le script pour vérifier qu'il fonctionne correctement.

**
Exercice 14 : Automatisation avec Ansible

1. Installez Ansible si ce n'est pas déjà fait.

2. Créez un fichier de playbook Ansible pour installer un paquet (par exemple, nginx ) sur un
serveur distant.
3. Exécutez le playbook pour effectuer l'installation.

Solution 14 :

Créez un fichier de playbook Ansible nommé install_nginx.yml avec le contenu suivant :

*
****
Bien sûr, voici quelques exercices supplémentaires et leurs solutions pour vous permettre de
continuer à explorer et à approfondir vos compétences en utilisant des commandes Linux
couramment utilisées en DevOps.

**Exercice 15 : Surveillance système avec `htop`**

1. Installez le moniteur système interactif `htop` sur votre système.

2. Lancez `htop` pour afficher les informations sur les processus en cours d'exécution.
3. Explorez les fonctionnalités de `htop`, telles que le tri, la recherche, et la gestion des processus.

**Solution 15 :**

Sur un système basé sur Debian (comme Ubuntu) avec `apt` :

**Exercice 16 : Utilisation de `curl`**

1. Utilisez la commande `curl` pour effectuer une requête HTTP GET à une URL de votre choix et
affichez la réponse.

**Solution 16 :**

**Exercice 17 : Gestion des variables d'environnement**

1. Créez une variable d'environnement personnalisée appelée `MON_ENV_VAR` avec une valeur
de votre choix.
2. Affichez la valeur de la variable d'environnement que vous avez créée.

**Solution 17 :**

**Exercice 18 : Gestion des journaux système**

1. Utilisez la commande `journalctl` pour afficher les entrées du journal système.

2. Recherchez des entrées spécifiques dans le journal.

**Solution 18 :**

`journalctl` est utilisé pour accéder aux journaux système sur les systèmes Linux basés sur systemd.