Dans l'article de blog précédent, nous avons couvert 4 composants de gestion de base à l'aide du client de ligne de commande MaxCtrl. Dans cet article de blog, nous allons couvrir la partie restante des composants MaxScale qui sont couramment utilisés dans un cluster MariaDB :
- Gestion des filtres
- Gestion MaxScale
- Gestion de la journalisation
Toutes les commandes de ce billet de blog sont basées sur MaxScale 2.5.3.
Gestion des filtres
Le filtre est un module de MaxScale qui agit comme moteur de traitement et de routage pour un service MaxScale. Le filtrage se produit entre la connexion client à MaxScale et la connexion MaxScale aux serveurs de base de données principaux. Ce chemin (côté client de MaxScale vers les serveurs de base de données réels) peut être considéré comme un pipeline, des filtres peuvent ensuite être placés dans ce pipeline pour surveiller, modifier, copier ou bloquer le contenu qui le traverse.
De nombreux filtres peuvent être appliqués pour étendre les capacités de traitement d'un service MaxScale, comme indiqué dans le tableau suivant :
Nom du filtre | Description |
| Binlog | Replique sélectivement les événements du journal binaire sur des serveurs esclaves combinés avec un service binlogrouter. |
| Cache | Un cache simple capable de mettre en cache le résultat des SELECT, de sorte que les SELECT identiques suivants soient servis directement par MaxScale, sans que les requêtes soient acheminées vers aucun serveur. |
| Lecture critique cohérente | Permet d'effectuer des lectures critiques cohérentes via MaxScale tout en permettant la mise à l'échelle des lectures non critiques. |
| Pare-feu de base de données | Bloque les requêtes qui correspondent à un ensemble de règles. Ce filtre doit être considéré comme une solution optimale destinée à protéger contre les abus accidentels plutôt que contre les attaques malveillantes. |
| Astuce | Ajoute des conseils de routage à un service, demandant au routeur d'acheminer une requête vers un certain type de serveur. |
| Insérer un flux | Convertit les insertions en masse en flux de données CSV consommés par le serveur principal via le mécanisme LOAD DATA LOCAL INFILE |
| Lua | Appelle un ensemble de fonctions dans un script Lua. |
| Masquage | Obfusque la valeur renvoyée d'une colonne particulière |
| Maxrows | Restriction du nombre de lignes qu'un SELECT, une instruction préparée ou une procédure stockée peut renvoyer à l'application cliente. |
| Serveur nommé | Achemine les requêtes vers les serveurs en fonction des correspondances d'expressions régulières (regex). |
| Query Log All | Journalise le contenu de la requête dans un fichier au format CSV. |
| Regex | Réécrit le contenu de la requête à l'aide de correspondances d'expressions régulières et de substitution de texte. |
| Té | Faire des copies des requêtes du client et envoyer les copies à un autre service au sein de MariaDB MaxScale. |
| Accélérateur | Remplace et étend la fonctionnalité limit_queries du filtre Database Firewall |
| Haut | Surveille les performances de la requête de l'instruction SQL sélectionnée qui passe par le filtre. |
| Surveillance des performances des transactions | Surveille chaque instruction SQL qui passe par le filtre, regroupée par transaction, pour l'analyse des performances des transactions. |
Créer un filtre
Chaque filtre MaxScale a sa propre façon d'être configuré. Dans cet exemple, nous allons créer un filtre de masquage, pour masquer nos données sensibles pour la colonne "card_no" dans notre table "credit_cards". Le masquage nécessite un fichier de règles, écrit au format JSON. Tout d'abord, créez un répertoire pour héberger nos fichiers de règles :
$ mkdir /var/lib/maxscale/rulesEnsuite, créez un fichier texte :
$ vi /var/lib/maxscale/rules/masking.jsonSpécifiez les lignes comme ci-dessous :
{
"rules": [
{
"obfuscate": {
"column": "card_no"
}
}
]
}Les règles simples ci-dessus masqueront simplement la sortie de la colonne card_no pour toutes les tables, afin de protéger les données sensibles visibles par le client MariaDB.
Une fois le fichier de règles créé, nous pouvons créer le filtre à l'aide de la commande suivante :
maxctrl: create filter Obfuscates-card masking rules=/var/lib/maxscale/rules/masking.json
OKNotez que certains filtres nécessitent des paramètres différents. En ce qui concerne ce filtre de masquage, le paramètre de base est "règles", où nous devons spécifier le fichier de règles de masquage créé au format JSON.
Attacher un filtre à un service
Un filtre ne peut être activé qu'en le rattachant à un service. La modification d'un service existant à l'aide de MaxCtrl n'est prise en charge que par certains paramètres, et l'ajout d'un filtre n'en fait pas partie. Nous devons ajouter le composant de filtre sous le fichier de configuration de service de MaxScale pour attacher essentiellement le filtre. Dans cet exemple, nous allons appliquer le filtre "Obfuscates-card" à notre service round-robin existant appelé rr-service.
Accédez au répertoire /var/lib/maxscale/maxscale.cnf.d et recherchez rr-service.cnf, ouvrez-le avec un éditeur de texte, puis ajoutez la ligne suivante :
filters=Obfuscates-card
Un redémarrage de MaxScale est nécessaire pour charger la nouvelle modification :
$ systemctl restart maxscalePour tester le filtre, nous allons utiliser un client MariaDB et comparer la sortie en nous connectant à deux services différents. Notre rw-service est attaché à un listener écoutant sur le port 3306, sans aucun filtre configuré. Par conséquent, nous devrions voir la réponse non filtrée de MaxScale :
$ mysql -ucard_user -p -hmaxscale_host -p3306 -e "SELECT * FROM secure.credit_cards LIMIT 1"
+----+-----------+-----------------+-------------+-----------+---------+
| id | card_type | card_no | card_expiry | card_name | user_id |
+----+-----------+-----------------+-------------+-----------+---------+
| 1 | VISA | 425388910909238 | NULL | BOB SAGAT | 1 |
+----+-----------+-----------------+-------------+-----------+---------+Lors de la connexion à l'écouteur rr-service sur le port 3307, configuré avec notre filtre, notre valeur "card_no" est masquée par une sortie charabia :
$ mysql -ucard_user -p -hmaxscale_host -p3307 -e "SELECT * FROM secure.credit_cards LIMIT 1"
+----+-----------+-----------------+-------------+-----------+---------+
| id | card_type | card_no | card_expiry | card_name | user_id |
+----+-----------+-----------------+-------------+-----------+---------+
| 1 | VISA | ~W~p[=&^M~5f~~M | NULL | BOB SAGAT | 1 |
+----+-----------+-----------------+-------------+-----------+---------+Ce filtrage est effectué par MaxScale, en suivant les règles de correspondance dans masking.json que nous avons créées précédemment.
Liste des filtres
Pour répertorier tous les filtres créés, utilisez la commande "list filter" :
maxctrl: list filters
┌─────────────────┬────────────┬─────────────┐
│ Filter │ Service │ Module │
├─────────────────┼────────────┼─────────────┤
│ qla │ │ qlafilter │
├─────────────────┼────────────┼─────────────┤
│ Obfuscates-card │ rr-service │ masking │
├─────────────────┼────────────┼─────────────┤
│ fetch │ │ regexfilter │
└─────────────────┴────────────┴─────────────┘Dans les exemples ci-dessus, nous avons créé 3 filtres. Cependant, seul le filtre Obfuscates-card est lié à un service.
Pour afficher tous les services en détail :
maxctrl: show filtersOu si vous souhaitez afficher un service particulier :
maxctrl: show filter Obfuscates-card
┌────────────┬──────────────────────────────────────────────────────┐
│ Filter │ Obfuscates-card │
├────────────┼──────────────────────────────────────────────────────┤
│ Module │ masking │
├────────────┼──────────────────────────────────────────────────────┤
│ Services │ rr-service │
├────────────┼──────────────────────────────────────────────────────┤
│ Parameters │ { │
│ │ "check_subqueries": true, │
│ │ "check_unions": true, │
│ │ "check_user_variables": true, │
│ │ "large_payload": "abort", │
│ │ "prevent_function_usage": true, │
│ │ "require_fully_parsed": true, │
│ │ "rules": "/var/lib/maxscale/rules/masking.json", │
│ │ "treat_string_arg_as_field": true, │
│ │ "warn_type_mismatch": "never" │
│ │ } │
└────────────┴──────────────────────────────────────────────────────┘Supprimer un filtre
Pour supprimer un filtre, il faut d'abord se dissocier des services associés. Par exemple, considérez les filtres suivants dans MaxScale :
maxctrl: list filters
┌─────────────────┬────────────┬───────────┐
│ Filter │ Service │ Module │
├─────────────────┼────────────┼───────────┤
│ qla │ │ qlafilter │
├─────────────────┼────────────┼───────────┤
│ Obfuscates-card │ rr-service │ masking │
└─────────────────┴────────────┴───────────┘Pour le filtre qla, nous pouvons simplement utiliser la commande suivante pour le supprimer :
maxctrl: destroy filter qla
OKCependant, pour le filtre Obfuscates-card, il doit être dissocié avec rr-service et malheureusement, cela nécessite une modification du fichier de configuration et un redémarrage de MaxScale. Accédez au répertoire /var/lib/maxscale/maxscale.cnf.d et recherchez rr-service.cnf, ouvrez-le avec un éditeur de texte, puis supprimez la ligne suivante :
filters=Obfuscates-card
Vous pouvez également supprimer la chaîne "Obfuscates-card" de la ligne ci-dessus et laisser la ligne "filters" égale à une valeur vide. Ensuite, enregistrez le fichier et redémarrez le service MaxScale pour charger les modifications :
$ systemctl restart maxscaleCe n'est qu'alors que nous pourrons supprimer le filtre Obfuscates-card de MaxScale à l'aide de la commande "destroy filter" :
maxctrl: destroy filter Obfuscates-card
OKGestion MaxScale
Répertorier les utilisateurs
Pour lister tous les utilisateurs MaxScale, utilisez la commande "list users":
maxctrl: list users
┌───────┬──────┬────────────┐
│ Name │ Type │ Privileges │
├───────┼──────┼────────────┤
│ admin │ inet │ admin │
└───────┴──────┴────────────┘Créer un utilisateur MaxScale
Par défaut, un utilisateur créé est un utilisateur en lecture seule :
maxctrl: create user dev mySecret
OKPour créer un utilisateur administrateur, spécifiez la commande --type=admin :
maxctrl: create user dba mySecret --type=admin
OKSupprimer un utilisateur MaxScale
Pour supprimer un utilisateur, utilisez simplement la commande "destroy user" :
maxctrl: destroy user dba
OKLe dernier utilisateur administratif restant ne peut pas être supprimé. Créez un utilisateur administratif de remplacement avant de tenter de supprimer le dernier utilisateur administratif.
Afficher les paramètres MaxScale
Pour afficher tous les paramètres chargés pour l'instance MaxScale, utilisez la commande "show maxscale" :
maxctrl: show maxscale
┌──────────────┬──────────────────────────────────────────────────────────────────────┐
│ Version │ 2.5.3 │
├──────────────┼──────────────────────────────────────────────────────────────────────┤
│ Commit │ de3770579523e8115da79b1696e600cce1087664 │
├──────────────┼──────────────────────────────────────────────────────────────────────┤
│ Started At │ Mon, 21 Sep 2020 04:44:49 GMT │
├──────────────┼──────────────────────────────────────────────────────────────────────┤
│ Activated At │ Mon, 21 Sep 2020 04:44:49 GMT │
├──────────────┼──────────────────────────────────────────────────────────────────────┤
│ Uptime │ 1627 │
├──────────────┼──────────────────────────────────────────────────────────────────────┤
│ Parameters │ { │
│ │ "admin_auth": true, │
│ │ "admin_enabled": true, │
│ │ "admin_gui": true, │
│ │ "admin_host": "127.0.0.1", │
│ │ "admin_log_auth_failures": true, │
│ │ "admin_pam_readonly_service": null, │
│ │ "admin_pam_readwrite_service": null, │
│ │ "admin_port": 8989, │
│ │ "admin_secure_gui": true, │
│ │ "admin_ssl_ca_cert": null, │
│ │ "admin_ssl_cert": null, │
│ │ "admin_ssl_key": null, │
│ │ "auth_connect_timeout": 10000, │
│ │ "auth_read_timeout": 10000, │
│ │ "auth_write_timeout": 10000, │
│ │ "cachedir": "/var/cache/maxscale", │
│ │ "connector_plugindir": "/usr/lib/x86_64-linux-gnu/mysql/plugin", │
│ │ "datadir": "/var/lib/maxscale", │
│ │ "debug": null, │
│ │ "dump_last_statements": "never", │
│ │ "execdir": "/usr/bin", │
│ │ "language": "/var/lib/maxscale", │
│ │ "libdir": "/usr/lib/x86_64-linux-gnu/maxscale", │
│ │ "load_persisted_configs": true, │
│ │ "local_address": null, │
│ │ "log_debug": false, │
│ │ "log_info": false, │
│ │ "log_notice": false, │
│ │ "log_throttling": { │
│ │ "count": 0, │
│ │ "suppress": 0, │
│ │ "window": 0 │
│ │ }, │
│ │ "log_warn_super_user": false, │
│ │ "log_warning": false, │
│ │ "logdir": "/var/log/maxscale", │
│ │ "max_auth_errors_until_block": 10, │
│ │ "maxlog": true, │
│ │ "module_configdir": "/etc/maxscale.modules.d", │
│ │ "ms_timestamp": true, │
│ │ "passive": false, │
│ │ "persistdir": "/var/lib/maxscale/maxscale.cnf.d", │
│ │ "piddir": "/var/run/maxscale", │
│ │ "query_classifier": "qc_sqlite", │
│ │ "query_classifier_args": null, │
│ │ "query_classifier_cache_size": 0, │
│ │ "query_retries": 1, │
│ │ "query_retry_timeout": 5000, │
│ │ "rebalance_period": 0, │
│ │ "rebalance_threshold": 20, │
│ │ "rebalance_window": 10, │
│ │ "retain_last_statements": 0, │
│ │ "session_trace": 0, │
│ │ "skip_permission_checks": false, │
│ │ "sql_mode": "default", │
│ │ "syslog": true, │
│ │ "threads": 1, │
│ │ "users_refresh_interval": 0, │
│ │ "users_refresh_time": 30000, │
│ │ "writeq_high_water": 16777216, │
│ │ "writeq_low_water": 8192 │
│ │ } │
└──────────────┴──────────────────────────────────────────────────────────────────────┘Modifier les paramètres MaxScale
- auth_connect_timeout
- auth_read_timeout
- auth_write_timeout
- admin_auth
- admin_log_auth_failures
- passif
Le reste des paramètres doit être défini dans /etc/maxscale.conf, ce qui nécessite un redémarrage de MaxScale pour appliquer les nouvelles modifications.
Interface graphique MaxScale
MaxGUI est un nouvel outil basé sur un navigateur pour configurer et gérer MaxScale, introduit dans la version 2.5. Il est accessible via le port 8989 de l'hôte MaxScale sur l'interface localhost, 127.0.0.1. Par défaut, il est nécessaire de définir admin_secure_gui=true et de configurer les paramètres admin_ssl_key et admin_ssl_cert. Cependant, dans cet article de blog, nous allons autoriser la connectivité via HTTP simple en ajoutant la ligne suivante sous la directive [maxctrl] dans /etc/maxscale.cnf :
admin_secure_gui = falseRedémarrez le service MaxScale pour charger la modification :
$ systemctl restart maxscaleÉtant donné que l'interface graphique écoute sur l'interface localhost, nous pouvons utiliser le tunnel SSH pour accéder à l'interface graphique depuis notre poste de travail local :
$ ssh -L 8989:localhost:8989 [email protected]<Maxscale public IP address>Ensuite, ouvrez un navigateur Web, pointez l'URL vers http://127.0.0.1:8989/ et connectez-vous. MaxGUI utilise les mêmes informations d'identification que maxctrl, ainsi le mot de passe par défaut est "admin" avec le mot de passe "mariadb". Pour des raisons de sécurité, il convient de créer un nouvel utilisateur administrateur avec un mot de passe plus fort spécifiquement à cette fin. Une fois connecté, vous devriez voir le tableau de bord MaxGUI comme ci-dessous :
La plupart des commandes de gestion MaxCtrl que nous avons présentées dans cette série de blogs peuvent être effectuée directement à partir de cette interface graphique. Si vous cliquez sur le bouton "Créer nouveau", la boîte de dialogue suivante s'affichera :
Comme vous pouvez le voir, tous les composants MaxScale importants peuvent être gérés directement de l'interface graphique, avec un joli look épuré et intuitif, rend les choses beaucoup plus simples et plus simples à gérer. Par exemple, l'association d'un filtre peut être effectuée directement à partir de l'interface utilisateur, sans qu'il soit nécessaire de redémarrer le service MaxScale, comme indiqué dans la section "Attacher un filtre à un service" de cet article de blog.
Pour plus d'informations sur cette nouvelle interface graphique, consultez ce guide MaxGUI.
Gestion de la journalisation
Afficher les paramètres de journalisation
Pour afficher les paramètres de journalisation, utilisez la commande "show logging":
maxctrl: show logging
┌────────────────────┬────────────────────────────────┐
│ Current Log File │ /var/log/maxscale/maxscale.log │
├────────────────────┼────────────────────────────────┤
│ Enabled Log Levels │ alert │
│ │ error │
│ │ warning │
│ │ notice │
├────────────────────┼────────────────────────────────┤
│ Parameters │ { │
│ │ "highprecision": true, │
│ │ "log_debug": false, │
│ │ "log_info": false, │
│ │ "log_notice": true, │
│ │ "log_warning": true, │
│ │ "maxlog": true, │
│ │ "syslog": true, │
│ │ "throttling": { │
│ │ "count": 10, │
│ │ "suppress_ms": 10000, │
│ │ "window_ms": 1000 │
│ │ } │
│ │ } │
└────────────────────┴────────────────────────────────┘Modifier les paramètres de journalisation
Tous les paramètres de journalisation indiqués ci-dessus peuvent être configurés via la commande MaxCtrl au moment de l'exécution. Par exemple, nous pouvons activer le log_info en utilisant la commande "alter logging":
maxctrl: alter logging log_info trueFaire pivoter les journaux
Par défaut, MaxScale fournit un fichier de configuration de rotation des journaux sous /etc/logrotate.d/maxscale_logrotate. Sur la base de la configuration de rotation des journaux, le fichier journal fait l'objet d'une rotation mensuelle et utilise la commande "rotate logs" de MaxCtrl. Nous pouvons forcer la rotation des journaux à se produire immédiatement avec la commande suivante :
$ logrotate --force /etc/logrotate.d/maxscale_logrotateVérifiez avec la commande suivante :
$ ls -al /var/log/maxscale/
total 1544
drwxr-xr-x 2 maxscale maxscale 4096 Sep 21 05:53 ./
drwxrwxr-x 10 root syslog 4096 Sep 20 06:25 ../
-rw-r--r-- 1 maxscale maxscale 75 Sep 21 05:53 maxscale.log
-rw-r--r-- 1 maxscale maxscale 253250 Sep 21 05:53 maxscale.log.1
-rw-r--r-- 1 maxscale maxscale 1034364 Sep 18 06:25 maxscale.log.2
-rw-r--r-- 1 maxscale maxscale 262676 Aug 1 06:25 maxscale.log.3Conclusion
Nous avons atteint la fin de la série de déploiement et de gestion de MaxScale à l'aide du client MaxCtrl. Dans cette série de blogs, nous avons utilisé quelques versions différentes de MaxScale (par rapport à la date de rédaction) et nous avons constaté de nombreuses améliorations significatives dans chaque version.
Félicitations à l'équipe MariaDB MaxScale pour son travail acharné visant à faire de MaxScale l'un des meilleurs outils d'équilibrage de charge de base de données sur le marché.
