Na postagem anterior do blog, abordamos 4 componentes básicos de gerenciamento usando o cliente de linha de comando MaxCtrl. Nesta postagem do blog, abordaremos a parte restante dos componentes MaxScale que são comumente usados em um cluster MariaDB:
- Gerenciamento de filtros
- Gerenciamento MaxScale
- Gerenciamento de registros
Todos os comandos nesta postagem do blog são baseados no MaxScale 2.5.3.
Gerenciamento de filtros
O filtro é um módulo no MaxScale que atua como mecanismo de processamento e roteamento para um serviço MaxScale. A filtragem acontece entre a conexão do cliente com o MaxScale e a conexão do MaxScale com os servidores de banco de dados back-end. Esse caminho (o lado do cliente do MaxScale para os servidores de banco de dados reais) pode ser considerado um pipeline, os filtros podem ser colocados nesse pipeline para monitorar, modificar, copiar ou bloquear o conteúdo que flui por ele.
Há muitos filtros que podem ser aplicados para estender os recursos de processamento de um serviço MaxScale, conforme mostrado na tabela a seguir:
Nome do filtro | Descrição |
| Binlog | Replica seletivamente os eventos de log binários para servidores escravos combinados com um serviço binlogrouter. |
| Cache | Um cache simples capaz de armazenar em cache o resultado de SELECTs, para que SELECTs idênticos subsequentes sejam atendidos diretamente pelo MaxScale, sem que as consultas sejam roteadas para nenhum servidor. |
| Leitura crítica consistente | Permite que leituras críticas consistentes sejam feitas por meio de MaxScale enquanto ainda permite dimensionar leituras não críticas. |
| Firewall de banco de dados | Bloqueia consultas que correspondem a um conjunto de regras. Esse filtro deve ser visto como uma solução de melhor esforço destinada à proteção contra uso indevido acidental em vez de ataques maliciosos. |
| Dica | Adiciona dicas de roteamento a um serviço, instruindo o roteador a rotear uma consulta para um determinado tipo de servidor. |
| Inserir fluxo | Converte inserções em massa em fluxos de dados CSV que são consumidos pelo servidor de back-end por meio do mecanismo LOAD DATA LOCAL INFILE |
| Lua | Chama um conjunto de funções em um script Lua. |
| Mascaramento | Oculta o valor retornado de uma coluna específica |
| Maxrows | Restringindo o número de linhas que um SELECT, uma instrução preparada ou um procedimento armazenado podem retornar ao aplicativo cliente. |
| Servidor nomeado | Roteia consultas para servidores com base em correspondências de expressão regular (regex). |
| Log de consulta todos | Registra o conteúdo da consulta em um arquivo no formato CSV. |
| Regex | Reescreve o conteúdo da consulta usando correspondências de expressões regulares e substituição de texto. |
| T | Faça cópias das solicitações do cliente e envie as cópias para outro serviço dentro do MariaDB MaxScale. |
| Aceleração | Substitui e estende a funcionalidade limit_queries do filtro Database Firewall |
| Topo | Monitora o desempenho da consulta da instrução SQL selecionada que passa pelo filtro. |
| Monitoramento do desempenho da transação | Monitora cada instrução SQL que passa pelo filtro, agrupada por transação, para análise do desempenho da transação. |
Criar um filtro
Cada filtro MaxScale tem sua própria forma de configuração. Neste exemplo, vamos criar um filtro de mascaramento, para mascarar nossos dados confidenciais para a coluna "card_no" em nossa tabela "credit_cards". O mascaramento requer um arquivo de regra, escrito no formato JSON. Primeiramente, crie um diretório para hospedar nossos arquivos de regras:
$ mkdir /var/lib/maxscale/rulesEm seguida, crie um arquivo de texto:
$ vi /var/lib/maxscale/rules/masking.jsonEspecifique as linhas conforme abaixo:
{
"rules": [
{
"obfuscate": {
"column": "card_no"
}
}
]
}As regras simples acima irão simplesmente ofuscar a saída da coluna card_no para quaisquer tabelas, para proteger os dados confidenciais a serem vistos pelo cliente MariaDB.
Após a criação do arquivo de regras, podemos criar o filtro, usando o seguinte comando:
maxctrl: create filter Obfuscates-card masking rules=/var/lib/maxscale/rules/masking.json
OKObserve que alguns filtros requerem parâmetros diferentes. Quanto a este filtro de mascaramento, o parâmetro básico é "rules", onde precisamos especificar o arquivo de regra de mascaramento criado no formato JSON.
Anexar um filtro a um serviço
Um filtro só pode ser ativado anexando-o a um serviço. Modificar um serviço existente usando MaxCtrl é suportado apenas por alguns parâmetros, e adicionar um filtro não é um deles. Temos que adicionar o componente de filtro no arquivo de configuração de serviço do MaxScale para basicamente anexar o filtro. Neste exemplo, vamos aplicar o filtro "Obfuscates-card" ao nosso serviço round-robin existente chamado rr-service.
Vá para o diretório /var/lib/maxscale/maxscale.cnf.d e encontre rr-service.cnf, abra-o com um editor de texto e adicione a seguinte linha:
filters=Obfuscates-card
Uma reinicialização do MaxScale é necessária para carregar a nova alteração:
$ systemctl restart maxscalePara testar o filtro, usaremos um cliente MariaDB e compararemos a saída conectando-se a dois serviços diferentes. Nosso rw-service está conectado a um listener que escuta na porta 3306, sem nenhum filtro configurado. Portanto, devemos ver a resposta não filtrada do 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 |
+----+-----------+-----------------+-------------+-----------+---------+Ao se conectar ao ouvinte rr-service na porta 3307, que configurou com nosso filtro, nosso valor "card_no" é ofuscado com uma saída sem sentido:
$ 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 |
+----+-----------+-----------------+-------------+-----------+---------+Essa filtragem é realizada pelo MaxScale, seguindo as regras de correspondência dentro de masking.json que criamos anteriormente.
Filtros de lista
Para listar todos os filtros criados, use o comando "listar filtros":
maxctrl: list filters
┌─────────────────┬────────────┬─────────────┐
│ Filter │ Service │ Module │
├─────────────────┼────────────┼─────────────┤
│ qla │ │ qlafilter │
├─────────────────┼────────────┼─────────────┤
│ Obfuscates-card │ rr-service │ masking │
├─────────────────┼────────────┼─────────────┤
│ fetch │ │ regexfilter │
└─────────────────┴────────────┴─────────────┘Nos exemplos acima, criamos 3 filtros. No entanto, apenas o filtro Ofuscates-card está vinculado a um serviço.
Para mostrar todos os serviços em detalhes:
maxctrl: show filtersOu se você quiser mostrar um serviço específico:
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" │
│ │ } │
└────────────┴──────────────────────────────────────────────────────┘Excluir um filtro
Para excluir um filtro, primeiro é necessário desvincular os serviços associados. Por exemplo, considere os seguintes filtros em MaxScale:
maxctrl: list filters
┌─────────────────┬────────────┬───────────┐
│ Filter │ Service │ Module │
├─────────────────┼────────────┼───────────┤
│ qla │ │ qlafilter │
├─────────────────┼────────────┼───────────┤
│ Obfuscates-card │ rr-service │ masking │
└─────────────────┴────────────┴───────────┘Para o filtro qla, podemos simplesmente usar o seguinte comando para excluí-lo:
maxctrl: destroy filter qla
OKNo entanto, para o filtro Ofuscates-card, ele deve ser desvinculado do rr-service e, infelizmente, isso requer uma modificação no arquivo de configuração e reinicialização do MaxScale. Vá para o diretório /var/lib/maxscale/maxscale.cnf.d e encontre rr-service.cnf, abra-o com um editor de texto e remova a seguinte linha:
filters=Obfuscates-card
Você também pode remover a string "Obfuscates-card" da linha acima e deixar a linha "filters" igual a um valor vazio. Em seguida, salve o arquivo e reinicie o serviço MaxScale para carregar as alterações:
$ systemctl restart maxscaleSó então podemos remover o filtro Ofuscates-card do MaxScale usando o comando "destroy filter":
maxctrl: destroy filter Obfuscates-card
OKGerenciamento MaxScale
Lista de usuários
Para listar todos os usuários do MaxScale, use o comando "list users":
maxctrl: list users
┌───────┬──────┬────────────┐
│ Name │ Type │ Privileges │
├───────┼──────┼────────────┤
│ admin │ inet │ admin │
└───────┴──────┴────────────┘Criar um usuário MaxScale
Por padrão, um usuário criado é um usuário somente leitura:
maxctrl: create user dev mySecret
OKPara criar um usuário administrador, especifique o comando --type=admin:
maxctrl: create user dba mySecret --type=admin
OKExcluir um usuário MaxScale
Para excluir um usuário, basta usar o comando "destroy user":
maxctrl: destroy user dba
OKO último usuário administrativo restante não pode ser removido. Crie um usuário administrativo substituto antes de tentar remover o último usuário administrativo.
Mostrar parâmetros MaxScale
Para mostrar todos os parâmetros carregados para a instância MaxScale, use o comando "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 │
│ │ } │
└──────────────┴──────────────────────────────────────────────────────────────────────┘Alterar parâmetros MaxScale
- auth_connect_timeout
- auth_read_timeout
- auth_write_timeout
- admin_auth
- admin_log_auth_failures
- passivo
O restante dos parâmetros deve ser definido dentro de /etc/maxscale.conf, o que requer uma reinicialização do MaxScale para aplicar as novas alterações.
GUI MaxScale
MaxGUI é uma nova ferramenta baseada em navegador para configurar e gerenciar MaxScale, introduzida na versão 2.5. É acessível através da porta 8989 do host MaxScale na interface localhost, 127.0.0.1. Por padrão, é necessário definir admin_secure_gui=true e configurar os parâmetros admin_ssl_key e admin_ssl_cert. No entanto, nesta postagem do blog, permitiremos a conectividade via HTTP simples adicionando a seguinte linha na diretiva [maxctrl] dentro de /etc/maxscale.cnf:
admin_secure_gui = falseReinicie o serviço MaxScale para carregar a alteração:
$ systemctl restart maxscaleComo a GUI está ouvindo a interface localhost, podemos usar o encapsulamento SSH para acessar a GUI de nossa estação de trabalho local:
$ ssh -L 8989:localhost:8989 [email protected]<Maxscale public IP address>Em seguida, abra um navegador da Web, aponte a URL para http://127.0.0.1:8989/ e faça login. MaxGUI usa as mesmas credenciais que maxctrl, portanto, a senha padrão é "admin" com a senha "mariadb". Por motivos de segurança, deve-se criar um novo usuário administrador com uma senha mais forte especificamente para essa finalidade. Uma vez logado, você deverá ver o painel MaxGUI como abaixo:
A maioria dos comandos de gerenciamento MaxCtrl que mostramos nesta série de blogs pode ser executado diretamente a partir desta GUI. Se você clicar no botão "Criar novo", você verá a seguinte caixa de diálogo:
Como você pode ver, todos os componentes importantes do MaxScale podem ser gerenciados diretamente da GUI, com uma aparência limpa e intuitiva, torna as coisas muito mais simples e diretas de gerenciar. Por exemplo, a associação de um filtro pode ser feita diretamente da interface do usuário, sem a necessidade de reiniciar o serviço MaxScale, conforme mostrado na seção "Anexar um filtro a um serviço" nesta postagem do blog.
Para obter mais informações sobre essa nova GUI, confira este guia MaxGUI.
Gerenciamento de registros
Mostrar parâmetros de registro
Para exibir os parâmetros de log, use o comando "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 │
│ │ } │
│ │ } │
└────────────────────┴────────────────────────────────┘Editar parâmetros de registro
Todos os parâmetros de registro mostrados acima podem ser configurados por meio do comando MaxCtrl em tempo de execução. Por exemplo, podemos ativar o log_info usando o comando "alter logging":
maxctrl: alter logging log_info trueGirar registros
Por padrão, o MaxScale fornece um arquivo de configuração de rotação de log em /etc/logrotate.d/maxscale_logrotate. Com base na configuração de rotação de log, o arquivo de log é alternado mensalmente e usa o comando "rotate logs" do MaxCtrl. Podemos forçar a rotação do log a acontecer imediatamente com o seguinte comando:
$ logrotate --force /etc/logrotate.d/maxscale_logrotateVerifique com o seguinte comando:
$ 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.3Conclusão
Chegamos ao fim da série de implantação e gerenciamento do MaxScale usando o cliente MaxCtrl. Em toda esta série de blogs, usamos algumas versões mais recentes do MaxScale (relativas à data de gravação) e vimos muitas melhorias significativas em todas as versões.
Parabéns à equipe do MariaDB MaxScale por seu trabalho árduo em tornar o MaxScale uma das melhores ferramentas de balanceador de carga de banco de dados do mercado.
