Connexion Rejoindre
DevOps

Guides pratiques DevOps

Un ensemble de guides DevOps pragmatiques qui vont droit au but et proposent des solutions concrètes et applicables au monde réel.

Gmkziz 👓

• 26 min de lecture
Share
Guides pratiques DevOps
Photo par Cristina Gottardi / Unsplash

Stockage d'objets

Gestion des objets provenant de stockages compatibles S3

Nous allons utiliser la aws s3 Utilitaire en ligne de commande pour cela. Pour l'installer, consultez : Installer l'interface de ligne de commande AWS.

Pour lire ou écrire des objets/fichiers depuis/vers des espaces de stockage d'objets compatibles S3, vous devez d'abord vous authentifier. Vous pouvez vous authentifier avec votre compte utilisateur ou à l'aide de clés API.

Trouvez un moyen de générer une clé API auprès de votre fournisseur de stockage S3, puis définissez les variables d'environnement suivantes :

export AWS_ACCESS_KEY_ID=$MY_S3_ACCESS_KEY
export AWS_SECRET_ACCESS_KEY=$MY_S3_SECRET_KEY
export AWS_DEFAULT_REGION=$MY_S3_REGION
export AWS_ENDPOINT_URL=$MY_S3_ENDPOINT_URL

Pour plus d'informations sur les variables d'environnement que vous pouvez utiliser pour configurer l'utilitaire de ligne de commande « aws », consultez la documentation. variables d'environnement de configuration de l'interface de ligne de commande AWS.

Une fois les variables d'environnement ci-dessus correctement configurées, vous pourrez transférer des fichiers depuis et vers le stockage S3 si la clé API dispose des autorisations requises. Voici les commandes :

# Upload myfile into mybucket
aws s3 cp /tmp/myfile s3://mybucket/

# Upload myfile into mybucket at myfilerenamed
aws s3 cp /tmp/myfile s3://mybucket/myfilerenamed

# Upload myfile into mybucket inside the files directory
aws s3 cp /tmp/myfile s3://mybucket/files/

# Download myfile from mybucket
aws s3 cp s3://mybucket/myfile .

La commande « aws s3 » utilisera par défaut téléchargement en plusieurs parties Lors du chargement d'un fichier dans un compartiment S3, le comportement du chargement en plusieurs parties ne peut pas être configuré via les variables d'environnement. Vous pouvez utiliser la commande « aws configure set » pour ajouter les paramètres de configuration dans le fichier de configuration AWS par défaut (« ~/aws/config »). Voici des exemples :

# Minimum file size that triggers multipart upload
aws configure set multipart_threshold 64MB

# Size of the parts (chunks) of the multipart upload
# bigger size => less parts
aws configure set multipart_chunksize 16MB

Pour obtenir la liste et la description de tous les paramètres de configuration disponibles pour l'interface de ligne de commande AWS, consultez : Paramètres du fichier de configuration de l'interface de ligne de commande AWS.

Pour plus d'informations sur les limites de téléchargement en plusieurs parties, consultez limites de téléchargement multipartie AWS.

Linux

Configuration du poste de travail

Configuration de Tmux

Pour installer tmux:

sudo apt update && sudo apt install tmux

Pour lancer tmux :

tmux

La touche de préfixe à utiliser avant les raccourcis clavier tmux est Ctrl+b.

Vous pouvez également exécuter des commandes tmux depuis votre terminal ou dans une session tmux en activant la ligne de commande avec Ctrl+b :.

Voici un exemple de commande que vous pourriez exécuter :

:set synchronize-pane

pour que toutes les fenêtres d'une même zone reçoivent les mêmes frappes au clavier.

Pour obtenir de l'aide, exécutez « man tmux » et consultez les sections suivantes :

  • RACCORDEMENTS DE TOUCHES PAR DÉFAUT - pour les raccourcis clavier par défaut
  • COMMANDES - pour les commandes prises en charge par tmux
  • OPTIONS - pour les options permettant de configurer l'apparence et le comportement de tmux
  • FENÊTRES ET VITRES - pour les commandes relatives aux paramètres des fenêtres et des volets
  • LIAISONS CLÉS - Commandes pour définir, lister et supprimer les raccourcis clavier
  • HOOKS - pour les hooks tmux
  • MODES - pour les options que vous pouvez utiliser pour personnaliser le style de l'interface tmux
  • LIGNE DE STATUT - pour plus d'informations et d'options concernant la ligne d'état de tmux (affichée par défaut en bas)
  • EXEMPLES - pour divers exemples tmux

Pour rendre permanentes certaines configurations tmux, vous pouvez les ajouter dans le fichier '~/.tmux.conf' :

bind-key S set synchronize-panes

Si vous êtes dans tmux, vous pouvez le faire recharger son fichier de configuration sans redémarrer :

tmux source-file ~/.tmux.conf
Configuration de Powerline-shell

Pour installer coque de ligne électrique:

pip install powerline-shell

# or 

git clone https://github.com/b-ryan/powerline-shell
cd powerline-shell
python setup.py install

Ensuite, ajoutez ceci à votre fichier de configuration '~/.bashrc' :

function _update_ps1() {
    PS1=$(powerline-shell $?)
}

if [[ $TERM != linux && ! $PROMPT_COMMAND =~ _update_ps1 ]]; then
    PROMPT_COMMAND="_update_ps1; $PROMPT_COMMAND"
fi

Ensuite, rechargez votre shell :

exec $SHELL

Pour obtenir la configuration requise pour d'autres types de shells, consultez ceci..

Vous pouvez ensuite personnaliser l'apparence de votre shell avec l'exemple de fichier de configuration suivant :

{
  "segments": [
    "virtual_env",
    "username",
    "hostname",
    "cwd",
    "ssh",
    "git",
    "jobs",
    "root"
  ],
   "mode": "patched",
   "theme": "default",
   "cwd": {
     "max_depth": 3
    },
   "hostname": {
     "colorize": "True"
   }
}

Placez ce fichier dans '~/.config/powerline-shell/config.json', après avoir créé les dossiers requis comme suit :

mkdir -p ~/.config/powerline-shell

Périphériques de blocs et système de fichiers

Recherche de fichiers

Recherche de fichiers et de répertoires spécifiques à partir d'un chemin système de fichiers racine :

# Searching for the 'history.log.4.gz' file from /
$ sudo find / -type f -name history.log.4.gz
/var/log/apt/history.log.4.gz

# Searching for files in /var/log whose names match the '.*/.*log\.[0-9]+\.gz' regex 
$ find /var/log -type f -regextype posix-extended -regex '.*/.*log\.[0-9]+\.gz'
/var/log/apt/term.log.4.gz
/var/log/apt/history.log.5.gz
/var/log/apt/term.log.8.gz
/var/log/apt/history.log.11.gz
/var/log/apt/history.log.7.gz
(...)

# Searching for directories named 'log' from /
$ sudo find / -type d -name log
/usr/lib/python3/dist-packages/cloudinit/log
/var/log
/snap/core20/2717/run/log
/snap/core20/2717/usr/lib/python3/dist-packages/cloudinit/log
/snap/core20/2717/var/log
/snap/core20/2769/run/log
/snap/core20/2769/usr/lib/python3/dist-packages/cloudinit/log
/snap/core20/2769/var/log
/run/log

Exécution d'une commande spécifique sur les résultats :

# Find history.log.4.gz from / and execute the 'ls -lah' command on the findings
$ sudo find / -type f -name history.log.4.gz -exec ls -lah {} \;
-rw-r--r-- 1 root root 967 Feb 20 21:01 /var/log/apt/history.log.4.gz

Suppression des résultats :

# Find history.log.4.gz from / and delete it 
$ sudo find / -type f -name history.log.4.gz -delete

Date et heure

Synchronisation de l'horloge système via NTP

Assurez-vous que le paquet « systemd-timesyncd » est installé et que le service « systemd-timesyncd.service » est en cours d'exécution :

$ dpkg -l | grep systemd-timesyncd
ii  systemd-timesyncd                249.11-0ubuntu3.19                      amd64        minimalistic service to synchronize local time with NTP servers

$ systemctl status systemd-timesyncd.service 
● systemd-timesyncd.service - Network Time Synchronization
     Loaded: loaded (/lib/systemd/system/systemd-timesyncd.service; enabled; vendor preset: enabled)
     Active: active (running) since Thu 2026-06-25 23:20:42 CEST; 1 day 8h ago
       Docs: man:systemd-timesyncd.service(8)
   Main PID: 6354 (systemd-timesyn)
     Status: "Initial synchronization to time server 91.189.91.157:123 (ntp.ubuntu.com)."
      Tasks: 2 (limit: 2228)
     Memory: 1.3M
        CPU: 326ms
     CGroup: /system.slice/systemd-timesyncd.service
             └─6354 /lib/systemd/systemd-timesyncd

Vous pouvez ensuite lister les fuseaux horaires disponibles en exécutant la commande suivante :

timedatectl list-timezones

Pour définir le fuseau horaire, exécutez :

timedatectl set-timezone Africa/Abidjan

Vous pouvez ensuite vérifier en exécutant :

timedatectl status

Pour activer la synchronisation horaire via NTP, vous pouvez éventuellement définir des adresses personnalisées pour les serveurs NTP en exécutant :

timedatectl ntp-servers $network-interface $ntp-server-domain-name

Ensuite, activez la synchronisation de l'heure en exécutant :

timedatectl set-ntp true

Pour vérifier que NTP est correctement configuré, exécutez :

timedatectl status

Vous pouvez également afficher les serveurs NTP actuels et l'état de la synchronisation horaire en exécutant la commande suivante :

timedatectl timesync-status
timedatectl show-timesync

Systemd

Exécution d'un script personnalisé au démarrage

Voici le fichier d'unité systemd :

[Unit]
Description=Run my custom script at boot
After=network.target

[Service]
Type=oneshot
ExecStart="/path/to/myscript.sh"
RemainAfterExit=true

[Install]
WantedBy=multi-user.target

Pour en savoir plus sur systemd, consultez ceci..

Installation de programmes à partir de sources

Aperçu

Il faut d'abord s'assurer que les outils de développement, les en-têtes du noyau... nécessaires à la construction des paquets Linux sont installés (gcc, make...).

# Debian based distributions
sudo apt update && sudo apt install build-essential

# RedHat based distributions
yum groupinstall "Development Tools"

Une fois les prérequis installés et le code source téléchargé, la procédure de compilation et d'installation est identique quelle que soit la distribution. Dans le répertoire du code source, vous trouverez généralement les fichiers « configure » ​​et « Makefile ».

Configurer

Le script « configure » ​​sert à configurer le programme. Pour voir les options de personnalisation disponibles, exécutez :

./configure --help
Makefile

Le fichier « Makefile » contient les cibles « make » utilisées par le programme « make ». Ces cibles permettent aux développeurs de proposer aux utilisateurs certaines fonctionnalités de compilation de leurs programmes, par exemple compiler le programme avec les options par défaut (généralement avec la cible « all »), générer la documentation du programme dans différents formats, etc.

« Cibles de compilation » contient simplement une liste de commandes à exécuter pour obtenir une variante de compilation spécifique. Pour utiliser une cible de compilation spécifique pour la compilation du programme, il suffit d'exécuter :

make <target-name>

L'exécution de « make » est équivalente à celle de « make all » et suffit généralement à créer le fichier binaire du programme avec les options par défaut. Sinon, utilisez « configure » ​​avec les options de personnalisation souhaitées, puis exécutez « make » pour créer le fichier binaire.

Le fichier binaire du programme sera généralement créé dans le répertoire « src ». Vous pouvez l'utiliser directement depuis cet emplacement ou l'installer sur votre système à l'aide de la commande « make install ». Voici comment cela se passera la plupart du temps :

  • déployer le programme binaire à l'intérieur /usr/local/bin
  • déployer les bibliothèques de programmes à l'intérieur /usr/local/lib
  • déployer la documentation du programme à l'intérieur /usr/local/share
Exemple de contenu de Makefile

Voici un extrait de « Fixer des objectifs » tiré de boucle Code source du programme :

all:
        ./configure
        make

ssl:
        ./configure --with-openssl
        make

mingw32:
        $(MAKE) -C lib -f Makefile.m32
        $(MAKE) -C src -f Makefile.m32

mingw32-vclean mingw32-distclean:
        $(MAKE) -C lib -f Makefile.m32 vclean
        $(MAKE) -C src -f Makefile.m32 vclean
        $(MAKE) -C docs/examples -f Makefile.m32 vclean

(...)

cygwin:
        ./configure
        make

cygwin-ssl:
        ./configure --with-openssl
        make

amiga:
        cd ./lib && make -f makefile.amiga
        cd ./src && make -f makefile.amiga

netware:
        $(MAKE) -C lib -f Makefile.netware
        $(MAKE) -C src -f Makefile.netware

netware-clean:
        $(MAKE) -C lib -f Makefile.netware clean
        $(MAKE) -C src -f Makefile.netware clean
        $(MAKE) -C docs/examples -f Makefile.netware clean

(...)

netware-examples-%:
        $(MAKE) -C docs/examples -f Makefile.netware CFG=$@

netware-%:
        $(MAKE) -C lib -f Makefile.netware CFG=$@
        $(MAKE) -C src -f Makefile.netware CFG=$@

unix: all

unix-ssl: ssl

linux: all

linux-ssl: ssl

ca-bundle: lib/mk-ca-bundle.pl
        @echo "generate a fresh ca-bundle.crt"
        @perl $< -b -l -u lib/ca-bundle.crt

ca-firefox: lib/firefox-db2pem.sh
        @echo "generate a fresh ca-bundle.crt"
        ./lib/firefox-db2pem.sh lib/ca-bundle.crt

SSH

Proxy Jump

Configuration du client SSH pour le proxy jump

Le proxy SSH permet de se connecter de manière transparente à un serveur SSH final via un serveur SSH intermédiaire/proxy.

Voici un exemple de configuration client SSH permettant de se connecter au serveur 2 via le serveur 1. Vous pouvez ajouter d'autres configurations client SSH ici :

  • ~/.ssh/config - pour la configuration à portée utilisateur
  • /etc/ssh/ssh_config - pour la configuration à l'échelle du système

Nous ajoutons d'abord la configuration nécessaire pour se connecter au serveur intermédiaire/proxy (serveur1) :

Host server1
  Hostname 192.168.9.4    # hostname or IP address used to SSH into server1
  User didi             # username used to SSH into server1
  IdentityFile /home/didi/.ssh/id_rsa  # private key used to SSH into server1

Ensuite, nous ajoutons la configuration nécessaire pour se connecter au serveur final (serveur2) :

(...)

Host server2
  Hostname 10.2.3.4 
  ProxyCommand ssh -q -W %h:%p server1
  User dada  # username used for connecting to server2 from server1

La commande « ProxyCommand » dans la configuration ci-dessus indique au client SSH d'utiliser la configuration du serveur 1 pour se connecter à ce dernier avant de se connecter au serveur 2 depuis le serveur 1. Voici un aperçu détaillé du déroulement d'une connexion SSH au serveur 2 après la mise en place de cette configuration de proxy :

Connexion au serveur 1

Une fois la configuration du proxy en place, vous pouvez vous connecter au serveur 2 en exécutant :

ssh server2

Avant de vous connecter au serveur 2, assurez-vous :

  • L'utilisateur didi est présent sur le serveur 1.
  • Le serveur server1 est correctement configuré pour autoriser les connexions SSH avec la clé privée de l'utilisateur didi (« /home/didi/.ssh/id_rsa ») présente sur la machine à partir de laquelle la commande ssh est exécutée (machine locale).

Pour permettre à l'utilisateur didi de la machine locale de se connecter à server1 avec sa clé SSH privée, ajoutez la clé publique SSH associée dans server1, dans le répertoire personnel de l'utilisateur didi, dans le fichier des clés autorisées : ~/.ssh/authorized_keys.

Connexion au serveur 2

Se connecter au serveur 2 se fera avant de se connecter au serveur 1 en utilisant la configuration client SSH correspondante (hôte : serveur 1). Une connexion SSH sera ensuite établie depuis le serveur 1 après le transfert transparent de la clé privée requise.
('/home/didi/.ssh/id_rsa') vers server1.

La commande résultante sur server1 pour se connecter à server2 sera :

ssh -i <transferred-private-key> dada@10.2.3.4

Vous devez donc veiller à ce que :

  • L'utilisateur dada est présent sur le serveur2 (10.2.3.4).
  • Le serveur server2 est correctement configuré pour autoriser les connexions SSH avec la clé privée transférée (clé privée de l'utilisateur didi sur la machine locale).

Pour permettre à l'utilisateur dada de se connecter au serveur2 avec la clé privée transférée, ajoutez la clé publique SSH associée dans le fichier des clés autorisées du serveur2, dans le répertoire personnel de l'utilisateur dada : ~/.ssh/authorized_keys.

Passage par proxy sans configuration du client SSH
ssh -i local-private-key -J [intermediate-user@]intermediate-ssh-server [final-user@]final-ssh-server

Avant d'exécuter la commande, assurez-vous :

  • La machine locale peut se connecter au serveur SSH intermédiaire en utilisant la clé privée locale et l'utilisateur intermédiaire.

    • Cela signifie que la clé publique locale correspondante à la clé privée locale est présente sur le serveur SSH intermédiaire, dans le fichier `/home/intermediate-user/.ssh/authorized_keys`.

  • La machine locale peut se connecter à 'final-ssh-server' en utilisant 'local-private-key' et l'utilisateur 'final-user'.

    • Cela signifie que la clé publique locale correspondante à la clé privée locale est présente dans le serveur SSH final, dans le fichier `/home/final-user/.ssh/authorized_keys`.

  • Il n'est pas nécessaire de transférer la clé privée locale au serveur SSH intermédiaire ; cette opération est effectuée de manière sécurisée et transparente lors de l'utilisation de l'option « -J » pour le saut de proxy.

Bloquer l'accès shell des utilisateurs au proxy SSH

Configurez leurs entrées de clés publiques dans le fichier de clés autorisées (~/.ssh/authorized_keys) comme suit :

<username>:command="/sbin/nologin",no-pty ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCmSIZR/MBampHYZ7y9mVfxa.....

Transférer des fichiers

Synchronisation de fichiers via SSH avec rsync

Voici un exemple de script que vous pouvez utiliser pour synchroniser périodiquement des fichiers depuis des serveurs distants via SSH à l'aide de rsync :

#!/bin/bash

logger -t My data sync started
rsync -avr --exclude="file_to_exclude.cfg" -e "ssh -i /rsync_ssh_private_key -p $remote_server_ssh_port" mydata@${remote_server_ip}:/data/mydata_remote_src_dir/ /data/myapp_local_dst_dir/ > rsync_log_dir/mydata-$(date +%F-%Hh%M).txt
logger -t My data sync finished

Avant d'exécuter le script, assurez-vous que la clé SSH publique associée à la clé SSH privée '/rsync_ssh_private_key' est autorisée à se connecter au serveur distant et que le flux réseau du port SSH local vers le serveur distant est ouvert.

Exemple de configuration cron

Voici le contenu d'un exemple de fichier de configuration cron. Cette configuration cron exécutera le script rsync toutes les 6 heures à la minute 30.

30 */6 * * *   root    bash   /root/mydata_sync.sh

Bases de données relationnelles

MySQL

Installation du client et du serveur

Pour installer uniquement le client MySQL :

apt update && apt install mysql-client

Pour installer le serveur MySQL :

apt update && apt install mysql-server
Sécuriser l'installation
$ sudo mysql_secure_installation

Securing the MySQL server deployment.

Connecting to MySQL using a blank password.

VALIDATE PASSWORD COMPONENT can be used to test passwords
and improve security. It checks the strength of password
and allows the users to set only those passwords which are
secure enough. Would you like to setup VALIDATE PASSWORD component?

Press y|Y for Yes, any other key for No: y

There are three levels of password validation policy:

LOW    Length >= 8
MEDIUM Length >= 8, numeric, mixed case, and special characters
STRONG Length >= 8, numeric, mixed case, special characters and dictionary                  file

Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG: 1

Skipping password set for root as authentication with auth_socket is used by default.
If you would like to use password authentication instead, this can be done with the "ALTER_USER" command.
See https://dev.mysql.com/doc/refman/8.0/en/alter-user.html#alter-user-password-management for more information.

By default, a MySQL installation has an anonymous user,
allowing anyone to log into MySQL without having to have
a user account created for them. This is intended only for
testing, and to make the installation go a bit smoother.
You should remove them before moving into a production
environment.

Remove anonymous users? (Press y|Y for Yes, any other key for No) : y
Success.


Normally, root should only be allowed to connect from
'localhost'. This ensures that someone cannot guess at
the root password from the network.

Disallow root login remotely? (Press y|Y for Yes, any other key for No) : y
Success.

By default, MySQL comes with a database named 'test' that
anyone can access. This is also intended only for testing,
and should be removed before moving into a production
environment.


Remove test database and access to it? (Press y|Y for Yes, any other key for No) : y
 - Dropping test database...
Success.

 - Removing privileges on test database...
Success.

Reloading the privilege tables will ensure that all changes
made so far will take effect immediately.

Reload privilege tables now? (Press y|Y for Yes, any other key for No) : y
Success.

All done!
Authentification de l'utilisateur root
$ mysql -u root
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 12
Server version: 8.0.46-0ubuntu0.22.04.2 (Ubuntu)

Copyright (c) 2000, 2026, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> SELECT user, host, plugin FROM mysql.user;
+------------------+-----------+-----------------------+
| user             | host      | plugin                |
+------------------+-----------+-----------------------+
| debian-sys-maint | localhost | caching_sha2_password |
| mysql.infoschema | localhost | caching_sha2_password |
| mysql.session    | localhost | caching_sha2_password |
| mysql.sys        | localhost | caching_sha2_password |
| root             | localhost | auth_socket           |
+------------------+-----------+-----------------------+
5 rows in set (0.00 sec)

Sur Ubuntu, comme nous pouvons le voir ci-dessus, par défaut, l'utilisateur « root » de MySQL utilise le plugin « auth_socket » pour l'authentification et est configuré pour se connecter uniquement depuis la machine serveur (localhost).

Le socket d'authentification réussit à authentifier l'utilisateur « root » sans demander de mot de passe, à condition que l'utilisateur système exécutant le client MySQL soit « root » et qu'il existe un utilisateur MySQL portant le même nom et le même hôte (« root »@« localhost »).

Le principe sous-jacent est le suivant : si vous pouvez devenir l'utilisateur root Linux, vous contrôlez déjà la machine, donc exiger le mot de passe de l'utilisateur « root » MySQL est redondant.

Si vous souhaitez toujours passer de l'authentification par socket à l'authentification par mot de passe :

mysql> ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'MySuperPa@ssW0rd!';
Query OK, 0 rows affected (0.06 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.04 sec)

Maintenant, lorsque nous nous connectons sans mot de passe, nous obtenons une erreur :

$ mysql -u root
ERROR 1045 (28000): Access denied for user 'root'@'localhost' (using password: NO)

La connexion avec le mot de passe configuré fonctionne :

mysql -u root -p
Enter password: 
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 14
Server version: 8.0.46-0ubuntu0.22.04.2 (Ubuntu)

Copyright (c) 2000, 2026, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

Pour revenir à 'auth_socket' :

mysql> ALTER USER 'root'@'localhost' IDENTIFIED WITH auth_socket;
Query OK, 0 rows affected (0.02 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.06 sec)
Connexion aux bases de données

Pour se connecter à une instance de base de données MySQL sur l'hôte « host » avec le nom d'utilisateur et le mot de passe :

mysql -u username -h host -p password

Pour éviter de transmettre le mot de passe dans la commande pour des raisons de sécurité :

mysql -u username -h host -p

Pour utiliser un fichier contenant des informations d'authentification :

mysql -u username -h host --defaults-extra-file=credentials_file

Voici un exemple de contenu pour credentials_file :

[client]
user = "username"
password = "password"
host = "localhost"
Affichage de la configuration du serveur

Pour afficher les paramètres de configuration du serveur MySQL actuellement en cours d'exécution :

mysqld --verbose --help | less

Pour définir un paramètre spécifique pour le serveur, utilisez 'my_param' (avec un trait de soulignement) dans le fichier de configuration ou '--my-param' sur la ligne de commande.

Gérer les utilisateurs

Voici Déclarations de gestion de compte MySQL Pour en savoir plus, consultez la documentation.

Pour créer un utilisateur :

mysql> CREATE USER 'username'@'host' IDENTIFIED BY 'password';
mysql> FLUSH PRIVILEGES;

Pour en savoir plus, consultez Création d'utilisateurs.

Pour supprimer un utilisateur :

mysql> DROP USER 'username'@'host';
mysql> FLUSH PRIVILEGES;

Pour en savoir plus, consultez Suppression d'utilisateurs.

Dans les commandes précédentes, « host » représente l’adresse IP ou le nom d’hôte de la machine source à partir de laquelle la connexion est initiée. Cela peut prendre la forme de localhost (pour les connexions initiées directement depuis le serveur) ou de 10.2.3.4. Pour correspondre à n’importe quelle adresse IP source, utilisez %.

Pour accorder un privilège spécifique à un utilisateur :

mysql> GRANT SELECT ON database.* TO 'username'@'%';
mysql> FLUSH PRIVILEGES;

La commande précédente accorde le privilège « SELECT » sur toutes les tables de la base de données à l'utilisateur « username ». Le caractère générique (*) peut être remplacé par le nom d'une table spécifique pour accorder le privilège uniquement à cette table. Plusieurs privilèges peuvent également être spécifiés en les séparant par une virgule. Voici la liste : privilèges MySQL disponibles.

Pour révoquer des privilèges spécifiques :

mysql> REVOKE ALL PRIVILEGES, GRANT OPTION FROM 'username'@'host';
mysql> FLUSH PRIVILEGES;

Pour en savoir plus, consultez Révocation de privilège

Pour que les modifications apportées aux utilisateurs et aux privilèges prennent effet immédiatement :

mysql> FLUSH PRIVILEGES;

Cela garantit que MySQL actualise son cache en mémoire pour les tables 'mysql.*' (utilisateurs, privilèges, rôles) à partir du disque.

Gestion des sauvegardes

Pour créer une sauvegarde de 'mydb' :

mysqldump -u username mydb -p > mydb_backup.sql

Pour restaurer la sauvegarde :

mysql -u username mydb -p < mydb_backup.sql

Python

Gérer Python avec Pyenv

Configuration de Pyenv

En utilisant pyenv, nous pouvons installer les dernières versions de Python sur les distributions Linux qui ne les fournissent pas via leurs dépôts officiels.

Avant de suivre les instructions d'installation suivantes, installez le paquets prérequis.

Pour installer pyenv, exécutez :

$ curl https://pyenv.run | bash

Pour configurer votre shell afin qu'il charge automatiquement pyenv (exemple bash), ajoutez
Ajoutez les éléments suivants à '~/.bash_profile' s'il existe, sinon à '~/.profile' (pour les shells de connexion) ou à '~/.bashrc' (pour les shells interactifs) :

export PYENV_ROOT="$HOME/.pyenv"
[[ -d $PYENV_ROOT/bin ]] && export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init -)"

Redémarrez votre terminal pour que les modifications soient prises en compte :

exec $SHELL

Pour mettre à jour pyenv, ses plugins, y compris la liste des versions Python disponibles :

pyenv update
Gestion des versions Python

Pour lister les versions de Python disponibles qui peuvent être installées :

pyenv install --list

Pour installer/désinstaller une version spécifique de Python :

pyenv install <python_version>
pyenv uninstall <python_version>

Exemple :

pyenv install 3.14.5

Pour définir une version spécifique de Python installée via pyenv comme version par défaut pour l'ensemble du système :

pyenv global <python_version>

Pour afficher la configuration Python actuelle pour l'ensemble du système :

$ pyenv global
system

« System » signifie que nous utilisons la version Python installée par défaut sur le système. Pour définir la version Python sur 3.14.5 par exemple pour l'ensemble du système :

pyenv global 3.14.5

Vérifier:

$ pyenv global
3.14.5

Rétablir la version Python par défaut du système :

pyenv global system
Gestion des environnements virtuels

Nous pouvons également gérer les environnements virtuels Python avec pyenv. Pour créer un environnement virtuel, exécutez :

pyenv virtualenv myvenv

Pour lister les environnements virtuels existants :

$ pyenv virtualenvs
3.14.5/envs/test (created from /home/gmkziz/.pyenv/versions/3.14.5)
test --> /home/gmkziz/.pyenv/versions/3.14.5/envs/test

Pour activer un environnement virtuel :

source /home/gmkziz/.pyenv/versions/3.14.5/envs/test/bin/activate

or

virtualenv_name=test
eval $(pyenv sh-activate $virtualenv_name)

Pour désactiver un environnement virtuel :

deactivate

or

virtualenv_name=test
eval $(pyenv sh-deactivate $virtualenv_name)

Enfin, pour supprimer un environnement virtuel :

$ virtualenv_name=test
$ pyenv virtualenv-delete $virtualenv_name
pyenv-virtualenv: remove /home/gmkziz/.pyenv/versions/3.14.5/envs/test? (y/N) y

Installation des outils DevOps

Ansible

Si vous devez installer l'une des dernières versions de Ansible, assurez-vous d'utiliser les dernières versions versions Python.

Même si vous utilisez un système d'exploitation qui ne fournit pas nativement les dernières versions de Python, vous pouvez les installer avec pyenv Voir Gestion des versions Python pour cela.

Ensuite, suivez les instructions d'installation sur Installation d'Ansible.

Helm

Suivez les instructions d'installation sur Installation de Helm.

Helmfile

Suivez les instructions d'installation sur Installation de Helmfile.

Kubectl et les plugins

Suivez les instructions d'installation et de configuration à l'adresse suivante :

Git

Initialisation

Créez un dossier et accédez-y. Exécutez ensuite la commande suivante pour indiquer à Git de commencer à suivre toutes les modifications apportées à ce dossier :

git init

Si vous souhaitez enregistrer les modifications dans un dépôt Git distant, assurez-vous d'en avoir créé un. Gitlab, Github ou votre plateforme préférée. Ensuite, copiez l'URL Git SSH ou HTTPS du dépôt distant et exécutez la commande suivante pour connecter votre dossier local à celui-ci :

git remote add origin https://gitlab.com/username/project-name.git

Le dépôt Git distant est désormais connecté au dossier local et est désigné par l'alias « origin », ce qui signifie simplement que nous pourrons utiliser « origin » pour faire référence à ce dépôt lors de l'exécution de commandes Git afin d'enregistrer des modifications à distance, par exemple.

Pour afficher les alias configurés, vous pouvez exécuter :

git remote -v

Gestion des modifications

État de Git

Toute modification effectuée dans un dossier suivi par Git sera enregistrée. Créons un nouveau fichier :

touch myfile.md
echo "Setting up a Git repository" > myfile.md

Git sait qu'un fichier a été créé. Nous pouvons le constater en exécutant la commande suivante :

git status
Git ajouter et valider

Pour enregistrer une modification effectuée dans un dépôt Git, il faut d'abord l'ajouter à la zone de préparation Git en exécutant la commande suivante :

git add myfile.md

Ensuite, nous pouvons créer l'enregistrement (un commit) en exécutant la commande suivante :

git commit -m "Initial commit"

Nous utilisons l'option '-m' pour spécifier un message pour l'enregistrement de modification.

Git journal et push

Pour consulter l'historique des commits, exécutez :

git log

Pour que les commits présents uniquement dans le dossier local soient également disponibles dans le dépôt Git distant, nous pouvons exécuter la commande suivante :

git push origin main

Cela téléchargera les enregistrements dans le dépôt distant représenté par l'alias « origin », dans la branche appelée « main ».

Gestion des branches et des étiquettes

Pour créer une branche :

git branch mybranch

Pour créer une branche et basculer directement vers cette branche :

git checkout -b mybranch

Pour créer une étiquette :

git tag mytag

Pour basculer uniquement vers une branche ou une étiquette existante :

git checkout mybranch

# or

git checkout mytag

Une étiquette (ou tag) est un instantané d'une branche à un point de commit précis. Normalement, elle ne devrait pas être modifiée et un push classique vers une étiquette ne fonctionnera pas. Cependant, si pour une raison particulière vous devez un jour mettre à jour une étiquette, c'est possible.

Commencez par consulter l'étiquette :

git checkout mytag

Ensuite, effectuez les modifications, indexez-les et validez-les (git add + git commit). Vous pourrez ensuite mettre à jour le contenu de l'étiquette dans le dépôt distant en exécutant :

git push origin HEAD:mytag --force
Extraction de données depuis des dépôts distants

sans affecter les modifications locales existantes

Pour récupérer les modifications du dépôt distant, exécutez :

git pull

Si vous avez déjà des modifications locales qui n'ont pas encore été validées (dans l'espace de travail Git), vous pouvez les mettre de côté avant de les récupérer en utilisant :

git stash

Ensuite, après l'extraction, utilisez la commande suivante pour restaurer les modifications précédemment mises de côté dans la zone de travail Git :

git stash pop
Suppression des commits

Pour supprimer le dernier commit tout en conservant les modifications dans la zone de travail (modifications non indexées) :

git reset --mixed HEAD~1

Pour supprimer le dernier commit tout en conservant les modifications dans la zone de préparation (modifications préparées) :

git reset --soft HEAD~1

Pour supprimer complètement le dernier commit :

git reset --hard HEAD~1

Vous pouvez également utiliser un sha de commit spécifique au lieu de 'HEAD~1', ce qui signifie le commit précédent HEAD.

Si la modification a déjà été envoyée au dépôt distant, vous pouvez utiliser la commande suivante pour également réécrire l'historique des modifications distantes :

git push --force

Récupération des commits d'autres branches

Pour sélectionner un commit spécifique d'une autre branche :

git cherry-pick <COMMIT_SHA>

Si vous avez des conflits à résoudre, résolvez-les, ajoutez-les à la zone de préparation avec « git add », puis continuez :

git chery-pick --continue

Gestion des sous-modules

Ajout d'un sous-module au projet
git submodule add git@git.example.com:my-project/ansible-role.git roles/ansible-role

Selon la version de Git que vous utilisez, il peut être nécessaire d'exécuter les commandes suivantes :

git submodule init
git submodule update

Pour plus de détails sur les commandes, exécutez :

git help submodule 

# or 

man git-submodule
Changement de branche du sous-module pour suivre les mises à jour

La branche suivie pour la mise à jour des sous-modules est la branche par défaut « master » ou « main ».

Pour mettre à jour votre sous-module avec les modifications d'une autre branche, ajoutez ce qui suit dans la section de configuration du sous-module du fichier '.gitmodules' :

branch = <BRANCH_NAME>

Ensuite, exécutez la commande suivante pour récupérer les modifications de la branche nouvellement configurée :

git submodule update --remote
Mise à jour des sous-modules du projet
git submodule init
git submodule update
git pull --recurse-submodule && git submodule update --remote

Pour plus de détails sur les commandes exécutées :

git help submodule

# and

git help pull
Suppression des sous-modules du projet

Commencez par supprimer les références au sous-module dans le fichier '.git/config' :

git submodule deinit <path_to_submodule>

Supprimer les fichiers sources du sous-module :

git rm <path_to_submodule>

Validation des modifications et nettoyage final :

git commit -m "Remove submodule"
rm -rf .git/modules/<path_to_submodule>

Gestion des secrets

Chiffrement de fichiers avec l'âge

Vous pouvez utiliser âge Pour chiffrer des fichiers, utilisez votre gestionnaire de paquets préféré pour installer age. Consultez documentation d'installation de l'âge Pour en savoir plus. Voici un exemple :

apt update && apt install age

Avant de chiffrer un fichier, je dois d'abord générer une paire de clés d'âge :

$ age-keygen 
# created: 2026-07-08T08:04:47+02:00
# public key: age14vda95227jg0j9e99phktkcp6yh7w5c47xs9pyzs2a7nxv5wvggs4xty6r
AGE-SECRET-KEY-1TLN540QJAGHCXV4J40V6C6PTTK5U2ZVDGQSR98Y4EDMKP6XDAP5SX0PGSA

ou avec la commande suivante pour enregistrer le résultat dans un fichier :

$ age-keygen -o age.key
Public key: age133k7cuausk7wy0tg34rtwsauyavzgtc59acflcmtqartjhqw6swq0hx67a

# Result

$ cat age.key 
# created: 2026-07-08T08:05:26+02:00
# public key: age133k7cuausk7wy0tg34rtwsauyavzgtc59acflcmtqartjhqw6swq0hx67a
AGE-SECRET-KEY-1YRJDQ363ELM57NZ4NXTKFGYLY50GWZ026UXS986M82ALTKQNF4DS778DXE

Le hashtag sert aux commentaires. La clé publique est commentée dans ce fichier, et les commentaires sont ignorés par age. Par conséquent, transmettre ce fichier à age ne fournira que la clé privée.

Voici un exemple de fichier que je souhaite chiffrer :

$ cat hello.txt 
hello

Je peux chiffrer ce fichier en utilisant ma clé privée d'âge comme suit :

$ age -e -i age.key hello.txt > hello.txt.age
$ cat hello.txt.age 
age-encryption.org/v1
-> X25519 hekluD+srYJz+DqP0ybJ3zKR1Yv2s2nV8ulUl1o1/0Q
sjC+4a4kizLTYILo4uqC7XK8BBqNt8nyXNovigx5sR0
--- 7Lo3Vt3MQvgWQC6xoU41VZhTuSs/tCh+/XpIHGu84t8
ϒ(8L$
:+Z  6U1

La commande `age` affiche toujours le résultat sur la sortie standard (stdout) par défaut. Il est donc nécessaire de rediriger les sorties vers des fichiers. Voici le résultat obtenu en exécutant la commande de chiffrement ci-dessus sans redirection :

$ age -e -i age.key hello.txt
age: error: refusing to output binary to the terminal
age: hint: did you mean to use -a/--armor?
age: hint: force anyway with "-o -"
age: report unexpected or unhelpful errors at https://filippo.io/age/report

Refus d'afficher du texte binaire dans le terminal. On peut également utiliser un format encodé en PEM pour la sortie en utilisant l'option « -a ». Avec ce format, age n'empêche pas l'affichage dans le terminal.

$ age -e -i age.key -a hello.txt
-----BEGIN AGE ENCRYPTED FILE-----
YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSBBeStMemd2dVRvckxXckZG
UFFjK2VDOVE2VWl6V3crbjJKcVlzNTllM0RRClgzd1FhaGFoU3JSRnlaWm1lYjR1
dTRjck5FZ2NOOGFzK3pDak1aOGJyaG8KLS0tIFhGaS9pTVZGTVZoWHA3TE9GTEhY
NWRCdTlpSFlVK1RNc2xoMmQrK29RYUUKOxhDYAqR0aqKlajbG0xhBSehC+X47Xic
GJMWBVskjvewt3/E35Q=
-----END AGE ENCRYPTED FILE-----

Pour déchiffrer le fichier, que ce soit au format binaire ou PEM, exécutez :

$ age -d -i age.key hello.txt.age
hello

Google Cloud

DNS en nuage

Créez un enregistrement CNAME DNS dans Cloud DNS
gcloud dns --project=myproject record-sets create _acme-challenge.mydomain.com. --zone="my-clouddns-zone" --type="CNAME" --ttl="300" --rrdatas="9yy23a46-90e1-55f7-a4tv-2zb1a21774bb.5.authorize.certificatemanager.goog."

Gestionnaire de certificat

Créer des certificats à partir de fichiers de certificats et de clés existants
gcloud certificate-manager certificates create mycert --private-key-file=key.pem --certificate-file=cert.pem --location=europe-west1
Liste des certificats

Pour lister les certificats :

gcloud certificate-manager certificates list

La commande ci-dessus est équivalente à :

gcloud certificate-manager certificates list --location=global

Pour afficher les certificats qui ne possèdent pas de localisation globale, utilisez :

gcloud certificate-manager certificates list --location=$region
Générer des certificats gérés via un défi DNS

Demande d'autorisation DNS pour le certificat '*.mydomain.com' :

gcloud certificate-manager dns-authorizations create wildcard-mydomain-com --domain="mydomain.com"

Afficher l'entrée DNS à créer pour la vérification de la propriété du domaine :

gcloud certificate-manager dns-authorizations describe wildcard-mydomain-com

Une fois l'entrée DNS de défi créée, demandez la génération du certificat :

gcloud certificate-manager certificates create wildcard-mydomain-com --domains="*.mydomain.com,mydomain.com" --dns-authorizations=wildcard-mydomain-com

Afficher l'état de la génération du certificat :

gcloud certificate-manager certificates describe wildcard-mydomain-com

Moteur de calcul (machines virtuelles)

Cloner une machine virtuelle

Créer une image système de la machine virtuelle :

gcloud beta compute machine-images create my-vm-copy --project=my-project 
--source-instance=my-vm --source-instance-zone=europe-west1-b 
--storage-location=europe-west1

Pour créer une nouvelle machine virtuelle à partir de l'image système, il suffit de créer une machine virtuelle avec l'option '--source-machine-image=my-vm-copy', indiquant l'image système à utiliser pour créer la machine.

Planifiez l'arrêt et le démarrage des machines virtuelles.

Avec Terraform, Utilisez l' google_compute_resource_policy ressource pour créer la stratégie de planification d'instance. Supposons que nous appelions cette ressource my_schedule_policy par exemple.

Ensuite, associez la stratégie de planification nommée my_schedule_policy à la ressource du moteur de calcul :

resource "google_compute_instance" "instance" {
  (...)
  resource_policies = google_compute_resource_policy.my_schedule_policy.self_link
  (...)
}

Cloud SQL

Planifiez l'arrêt et le démarrage des instances CloudSQL avec Cloud Scheduler.

GCP Cloud Scheduler peut être utilisé pour planifier des tâches qui s'exécutent à des heures précises et interagir avec certaines ressources GCP comme Cloud Pub/Sub et App Engine.

Ces tâches peuvent également effectuer des requêtes HTTP et, par conséquent, interagir avec d'autres ressources GCP, comme Cloud SQL, via leurs API. Il est possible d'authentifier les requêtes HTTP avec un compte de service GCP.

Avec Terraform, Utilisez l' ressource google_cloud_scheduler_job Pour créer la tâche planifiée, voici des exemples de définitions de ressources pour arrêter et démarrer une base de données Cloud SQL :

resource "google_cloud_scheduler_job" "stop_cloud_sql_instance" {
  name        = var.stop_cloud_sql_instance_job_name
  description = var.stop_cloud_sql_instance_job_description
  schedule    = var.stop_cloud_sql_instance_job_schedule
  time_zone   = var.jstop_cloud_sql_instance_job_time_zone

  http_target {
    http_method = "PATCH"
    uri         = "https://sqladmin.googleapis.com/sql/v1beta4/projects/${var.project_id}/instances/${var.cloud_sql_instance_name}"
    headers = {
      "Content-Type"  = "application/json"
    }
    body = base64encode(jsonencode({
      settings = {
        activationPolicy = "NEVER" # Use "NEVER" to stop and "ALWAYS" to start the Cloud SQL instance
      }
    }))
    oauth_token {
      service_account_email = google_service_account.cloud_scheduler_service_account.email
    }
  }
  
  retry_config {
    retry_count          = 3
    max_retry_duration   = "600s"
    min_backoff_duration = "5s"
    max_backoff_duration = "60s"
  }
}

Le compte de service `cloud_scheduler_service_account` utilisé dans l'exemple précédent doit être ajouté au projet hébergeant l'instance Cloud SQL, avec le rôle `cloudscheduler.jobRunner`. Voici un extrait de code Terraform permettant de créer ce compte de service et de l'ajouter au projet cible avec le rôle approprié :

  • Créez un compte de service pour la tâche planifiée :
resource "google_service_account" "scheduler_service_account" {
  account_id   = var.service_account.name
  display_name = var.service_account.name
}

(...)
  • Ajoutez le compte de service du planificateur à my_gcp_project avec le rôle 'cloudscheduler.jobRunner' :
(...)

resource "google_project_iam_member" "roles" {
  project = "my_gcp_project"
  role    = "roles/cloudscheduler.jobRunner"
  member  = "serviceAccount:${resource.google_service_account.scheduler_service_account.email}"
}
restauration de base de données d'instance à instance

  • La version de l'instance de base de données à restaurer doit être identique à ou
    supérieure à la version de l'instance de base de données de sauvegarde

  • Toutes les bases de données contenues dans l'instance de restauration seront écrasées.
    (y compris la base de données des utilisateurs utilisée pour la connexion à l'instance)

export BACKUP_INSTANCE=""
export BACKUP_PROJECT=""

# Optionally create a backup on backup database instance
gcloud sql backups create -i $BACKUP_INSTANCE --project $BACKUP_PROJECT

# To list existing backups and asociated
# backup run IDs on backup instance
gcloud sql backups list -i $BACKUP_INSTANCE --project $BACKUP_PROJECT --limit 3

# Set BACKUP_ID
export BACKUP_ID=""

# Optionally set the value of BACKUP_ID 
# to the latest backup run ID
export BACKUP_ID="$(gcloud sql backups list -i $BACKUP_INSTANCE \
  --project $BACKUP_PROJECT --limit 1 \
  --format json | jq -r '.[].id' )"

# Set RESTORE_PROJECT and RESTORE_INSTANCE
export RESTORE_PROJECT=""
export RESTORE_INSTANCE=""
restauration d'instance à instance du même projet
gcloud sql backups restore $BACKUP_ID \
  --backup-instance=$BACKUP_INSTANCE \
  --restore-instance=$RESTORE_INSTANCE \
  --project=$RESTORE_PROJECT # project where backup and restore 
                         # instances reside
restauration d'instance à instance entre projets
gcloud sql backups restore $BACKUP_ID \
  --backup-instance=$BACKUP_INSTANCE \
  --backup-project=$BACKUP_PROJECT \
  --restore-instance=$RESTORE_INSTANCE \
  --project=$RESTORE_PROJECT
Restauration d'instance à instance via l'API
# restore_request.tpl file content

{     
    "restoreBackupContext": {         
        "backupRunId": $BACKUP_ID, 
        "project": "$BACKUP_PROJECT",
        "instanceId": "$BACKUP_INSTANCE"    
    } 
}

# Create request.json file
export TEMPLATE=restore_request.tpl
export BACKUP_ID=""
export BACKUP_PROJECT=""
export BACKUP_INSTANCE=""

cat $TEMPLATE | envsubst > request.json

# Restore instance settings
export RESTORE_INSTANCE=""
export RESTORE_PROJECT="" 

# Restore choosen BACKUP_ID to restore instance
curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json; charset=utf-8" \
  -d @request.json "https://sqladmin.googleapis.com/v1/projects/$RESTORE_PROJECT/instances/$RESTORE_INSTANCE/restoreBackup" | tee -a result.json

# See operation status
export OPERATION_NAME=$(cat result.json | jq -r '.name')
gcloud sql operations wait $OPERATION_NAME --project $RESTORE_PROJECT --timeout=1800

Kit de développement logiciel (SDK) Gcloud

  • Pour l'installation du SDK Google Cloud, consultez la documentation. ceci.

  • Pour l'installation des paquets snap sous Ubuntu, consultez : ceci.Cette méthode permet des mises à jour automatiques.

Versions et mises à niveau du SDK et de ses composants

Afficher la version du SDK et l'état des composants :

gcloud components list

Afficher les versions du SDK et des composants installés :

gcloud version

Installer ou supprimer des composants pour la version actuelle du SDK :

gcloud components install $component_id
gcloud components remove $component_id

Mise à jour du SDK et des versions des composants installés :

gcloud components update [--version=$version]

Restaurer le SDK ou ses composants à la version précédente :

gcloud components update --version=$previous_version

Conteneurs

Se connecter aux registres

Connexion Docker au registre d'artefacts Google Cloud

Avec compte utilisateur :

gcloud auth configure-docker gcr.io

Avec la clé du compte de service :

cat sac.json | docker login -u _json_key --password-stdin https://gcr.io

Les

Ajout d'un seul fichier au système de fichiers conteneurisé à l'aide de volumes
(...)
      volumes:
        - name: app-config
          configMap:
            name: app-config
            items: # we want the file inside the container to be called .env
            - key: config.env
              path: .env
      containers:
      - name: app
        volumeMounts:
          - name: app-config
            mountPath: /app/config/.env
            subPath: .env # this creates the /app/config/.env and keep the old files

Voici le résultat:

#----------------------#
# With 'subPath: .env' #
#----------------------#

/app $ ls -lah config/
total 24K
drwxr-xr-x    1 www-data www-data    4.0K Oct 10 14:59 .
drwxr-xr-x    1 www-data www-data    4.0K Oct  9 15:07 ..
-rw-r--r--    1 root     www-data     377 Oct 10 14:59 .env # <= a file
-rwxr-xr-x    1 www-data www-data    3.0K Oct  9 15:07 config.inc.php
-rwxr-xr-x    1 www-data www-data     629 Oct  9 15:07 config_env.php

# Accessing the mounted file 
/app $ cat config/.env
MYVAR=VALUE

#-------------------------#
# Without 'subPath: .env' #
#-------------------------#

/app $ ls -lah config/
total 24K    
drwxr-xr-x    1 www-data www-data    4.0K Oct 10 15:13 .
drwxr-xr-x    1 www-data www-data    4.0K Oct  9 15:07 ..
drwxrwsrwx    3 root     www-data    4.0K Oct 10 15:13 .env # <= a directory
-rwxr-xr-x    1 www-data www-data    3.0K Oct  9 15:07 config.inc.php
-rwxr-xr-x    1 www-data www-data     629 Oct  9 15:07 config_env.php

# Accessing the mounted file
/app $ cat config/.env/.env
MYVAR=VALUE

Le Monitoring

Surveillance des machines virtuelles

Règles d'alerte Prometheus pour le processeur, la RAM et les disques

Prérequis : déployer Prometheus exportateur de nœuds Exportateur sur les machines cibles.

- name: MyApp # alerting rules group name
  rules:
  - alert: "Warning on servers filesystem"
    expr: (100 - ((node_filesystem_avail_bytes{fstype=~"ext4",instance=~"machine-name.*"} * 100) / node_filesystem_size_bytes{fstype=~"ext4",instance=~"machine-name.*"})) > 75
    for: 5m
    labels:
      severity: warning
    annotations:
      alert: "Servers FS Warning"
      value: "Filesystem {{ $labels.mountpoint }} usage is {{ $value }}%"

  - alert: "Warning on servers RAM"
    expr: (node_memory_MemAvailable_bytes{instance=~"machine-name.*"} / node_memory_MemTotal_bytes{instance=~"machine-name.*"}) * 100 < 20 # Available RAM under 20%
    for: 5m
    labels:
      severity: warning
    annotations:
      alert: "Servers RAM pressure Warning" 
      value: "Available RAM is under 20%. Current value is : {{ $value }}%"

  - alert: "Warning on servers CPU load"
    expr: 100 - (avg by(gce_instance) (rate(node_cpu_seconds_total{instance=~"machine-name.*", mode="idle"}[5m])) * 100) > 85
    for: 5m
    labels:
      severity: warning
    annotations:
      alert: "Servers CPU load Warning"
      value: "CPU load > 85%. Current value is : {{ $value }}%"
Règles d'alerte Prometheus pour les processus

Conditions préalables:

  • déployer le Prométhée exportateur de processus exportateur sur machines cibles

  • créer le fichier de configuration de l'exportateur de processus ' /config.yml'

# Process exporter config file used to select 
# the processes whose metrics will be exported
process_names:
  # One way
  - comm:
    - mysqld # name of the process found in /proc/<PID>/comm
  # Another way
  - name: ".pm2" # custom process name that will be visible in exported metrics 
    cmdline:
    - 'PM2.*God Daemon.*' # command line used by the process printed by
                          # the ps aux | grep -i "pattern" command
  • Exécutez le binaire de l'exportateur avec '-config.path' /config.yml' pour indiquer le chemin d'accès au fichier de configuration à utiliser

Voici un exemple de série temporelle exportée que nous pourrions utiliser pour envoyer des alertes lorsqu'un des processus configurés n'est pas en cours d'exécution :

namedprocess_namegroup_num_procs{groupname="mysqld"} 1

Voici un exemple de règle d'alerte Prometheus :

- name: MyApp # alerting rules group name
  rules:
  - alert: "Mysqld process is missing"
    expr: namedprocess_namegroup_num_procs{instance=~"machine-name.*",groupname="mysqld"} < 1
    for: 5m
    labels:
      severity: critical
    annotations:
      alert: "Mysqld process is missing"
      value: "No process {{ $labels.groupname }} running : {{ $value }}"

Surveillance des applications Kubernetes

Par le biais de kube-state-metrics

Il peut être utile d'avoir métriques-état-kube déployés au sein de votre cluster afin de pouvoir obtenir les métriques listées à Métriques exposées par kube-state-metrics pour des ressources Kubernetes spécifiques.

Voici quelques idées de surveillance minimales que vous pouvez utiliser pour superviser vos applications Kubernetes, avec des requêtes PromQL/MetricsSQL associées. métriques-état-kube métrique:

  • Surveillez le nombre de vos pods de réplication : recevez une alerte lorsque le nombre de pods de réplication pour votre déploiement ou ressource StatefulSet est inférieur à la valeur attendue.
# Monitor deployment replicas
kube_deployment_status_replicas_available{exported_namespace="myapp"} < kube_deployment_spec_replicas{exported_namespace="myapp"}
  • Surveiller les redémarrages des conteneurs Pods : recevoir une alerte lorsqu’un conteneur à l’intérieur de votre Pod a redémarré.
# Monitor Pods containers restarts
kube_pod_container_status_restarts_total{exported_namespace="myapp"} > 0
  • Surveillance des CrashLoopBackOffs : alerte lorsqu’un conteneur Pod est en état CrashLoopBackOff :
# Monitor CrashLoopBackOff
kube_pod_container_status_waiting_reason{exported_namespace="myapp",reason="CrashLoopBackOff"} > 0

Voici quelques exemples de métriques qu'il peut être utile de visualiser à l'aide de tableaux de bord de métriques :

  • kube_pod_container_status_running: le nombre de conteneurs de votre application en cours d'exécution (kube-state-metrics)

  • kube_pod_container_status_restarts_total: le nombre de conteneurs de votre application qui ont redémarré (kube-state-metrics)

Inscrivez-vous à la newsletter

Entrez votre e-mail
Rejoindre