Outra DBA MySQL

sábado, 21 de fevereiro de 2026

MySQL + Neo4j para Workloads de IA: Por Que Bancos de Dados Relacionais Ainda Importam

This article was originally published in English at AnotherMySQLDBA.

Então eu pensei que era hora de documentar como construir memória persistente para agentes de IA usando os bancos de dados que você já conhece. Não bancos de dados vetoriais - MySQL e Neo4j.

Isso não é teórico. Eu uso essa arquitetura diariamente, gerenciando memória de agente de IA em vários projetos. Aqui está o schema e os padrões de query que realmente funcionam.

A Arquitetura

Agentes de IA precisam de dois tipos de memória:

Memória estruturada - O que aconteceu, quando, por quê (MySQL)
Memória de padrões - O que se conecta a quê (Neo4j)

Bancos de dados vetoriais são para busca de similaridade. Eles não servem para rastrear estado de workflow ou histórico de decisões. Para isso, você precisa de transações ACID e relacionamentos adequados.

O Schema do MySQL

Aqui está o schema real para memória persistente de agente de IA:

-- Architecture decisions the AI made
CREATE TABLE architecture_decisions (
    id INT AUTO_INCREMENT PRIMARY KEY,
    project_id INT NOT NULL,
    title VARCHAR(255) NOT NULL,
    decision TEXT NOT NULL,
    rationale TEXT,
    alternatives_considered TEXT,
    status ENUM('accepted', 'rejected', 'pending') DEFAULT 'accepted',
    decided_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    tags JSON,
    INDEX idx_project_date (project_id, decided_at),
    INDEX idx_status (status)
) ENGINE=InnoDB;

-- Code patterns the AI learned
CREATE TABLE code_patterns (
    id INT AUTO_INCREMENT PRIMARY KEY,
    project_id INT NOT NULL,
    category VARCHAR(50) NOT NULL,
    name VARCHAR(255) NOT NULL,
    description TEXT,
    code_example TEXT,
    language VARCHAR(50),
    confidence_score FLOAT DEFAULT 0.5,
    usage_count INT DEFAULT 0,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    updated_at DATETIME ON UPDATE CURRENT_TIMESTAMP,
    INDEX idx_project_category (project_id, category),
    INDEX idx_confidence (confidence_score)
) ENGINE=InnoDB;

-- Work session tracking
CREATE TABLE work_sessions (
    id INT AUTO_INCREMENT PRIMARY KEY,
    session_id VARCHAR(255) UNIQUE NOT NULL,
    project_id INT NOT NULL,
    started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    ended_at DATETIME,
    summary TEXT,
    context JSON,
    INDEX idx_project_session (project_id, started_at)
) ENGINE=InnoDB;

-- Pitfalls to avoid (learned from mistakes)
CREATE TABLE pitfalls (
    id INT AUTO_INCREMENT PRIMARY KEY,
    project_id INT NOT NULL,
    category VARCHAR(50),
    title VARCHAR(255) NOT NULL,
    description TEXT,
    how_to_avoid TEXT,
    severity ENUM('critical', 'high', 'medium', 'low'),
    encountered_count INT DEFAULT 1,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    INDEX idx_project_severity (project_id, severity)
) ENGINE=InnoDB;

Chaves estrangeiras. Restrições de verificação. Indexação adequada. É isso que bancos de dados relacionais fazem bem.

Padrões de Query

Aqui está como você realmente faz query nisso para memória de agente de IA:

-- Get recent decisions for context
SELECT title, decision, rationale, decided_at
FROM architecture_decisions
WHERE project_id = ?
  AND decided_at > DATE_SUB(NOW(), INTERVAL 30 DAY)
ORDER BY decided_at DESC
LIMIT 10;

-- Find high-confidence patterns
SELECT category, name, description, code_example
FROM code_patterns
WHERE project_id = ?
  AND confidence_score >= 0.80
ORDER BY usage_count DESC, confidence_score DESC
LIMIT 20;

-- Check for known pitfalls before implementing
SELECT title, description, how_to_avoid
FROM pitfalls
WHERE project_id = ?
  AND category = ?
  AND severity IN ('critical', 'high')
ORDER BY encountered_count DESC;

-- Track session context across interactions
SELECT context
FROM work_sessions
WHERE session_id = ?
ORDER BY started_at DESC
LIMIT 1;

Essas são queries SQL diretas. EXPLAIN mostra uso de índices exatamente onde esperado. Sem surpresas.

A Camada Neo4j

MySQL lida com os dados estruturados. Neo4j lida com os relacionamentos:

// Create nodes for decisions
CREATE (d:Decision {
  id: 'dec_123',
  title: 'Use FastAPI',
  project_id: 1,
  embedding: [0.23, -0.45, ...]  // Vector for similarity
})

// Create relationships
CREATE (d1:Decision {id: 'dec_123', title: 'Use FastAPI'})
CREATE (d2:Decision {id: 'dec_45', title: 'Used Flask before'})
CREATE (d1)-[:SIMILAR_TO {score: 0.85}]->(d2)
CREATE (d1)-[:CONTRADICTS]->(d3:Decision {title: 'Avoid frameworks'})

// Query: Find similar past decisions
MATCH (current:Decision {id: $decision_id})
MATCH (current)-[r:SIMILAR_TO]-(similar:Decision)
WHERE r.score > 0.80
RETURN similar.title, r.score
ORDER BY r.score DESC

// Query: What outcomes followed this pattern?
MATCH (d:Decision)-[:LEADS_TO]->(o:Outcome)
WHERE d.title CONTAINS 'Redis'
RETURN d.title, o.type, o.success_rate

Como Eles Funcionam Juntos

O fluxo é assim:

O agente de IA gera conteúdo ou toma uma decisão
Armazena dados estruturados no MySQL (o quê, quando, por quê, contexto completo)
Gera embedding, armazena no Neo4j com relacionamentos para itens similares
Próxima sessão: Neo4j encontra decisões similares relevantes
MySQL fornece os detalhes completos dessas decisões

MySQL é a fonte da verdade. Neo4j é o descobridor de padrões.

Por Que Não Apenas Bancos de Dados Vetoriais?

Eu vi equipes tentarem construir memória de agente de IA apenas com Pinecone ou Weaviate. Não funciona bem porque:

Bancos de dados vetoriais são bons para:

Encontrar documentos similares a uma query
Busca semântica (RAG)
"Coisas como esta"

Bancos de dados vetoriais são ruins para:

"O que decidimos em 15 de março?"
"Mostre decisões que levaram a quedas"
"Qual é o status atual deste workflow?"
"Quais padrões têm confidence > 0.8 AND usage_count > 10?"

Essas queries precisam de filtragem estruturada, joins e transações. Isso é território de banco de dados relacional.

MCP e o Futuro

O Model Context Protocol (MCP) está padronizando como sistemas de IA lidam com contexto. Implementações iniciais de MCP estão descobrindo o que já sabíamos: você precisa de armazenamento estruturado e relacionamentos de grafo.

``````html

MySQL lida com o catálogo de "resources" e "tools" do MCP. Neo4j lida com as "relationships" entre itens de contexto. Embeddings vetoriais são apenas uma peça do quebra-cabeça.

Notas de Produção

Sistema atual executando esta arquitetura:

MySQL 8.0, 48 tables, ~2GB data
Neo4j Community, ~50k nodes, ~200k relationships
Query latency: MySQL <10ms, Neo4j <50ms
Backup: Standard mysqldump + neo4j-admin dump
Monitoring: Same Percona tools I've used for years

A complexidade operacional é baixa porque são bancos de dados maduros com padrões operacionais bem compreendidos.

Quando Usar Cada Um

Use Case	Database
Workflow state, decisions, audit trail	MySQL/PostgreSQL
Pattern detection, similarity, relationships	Neo4j
Semantic document search (RAG)	Vector DB (optional)

Comece com MySQL para estado. Adicione Neo4j quando precisar de reconhecimento de padrões. Só adicione vector DBs se você realmente estiver fazendo recuperação semântica de documentos.

Resumo

Agentes de IA precisam de memória persistente. Não apenas embeddings em um vector database - memória estruturada, relacional, temporal com reconhecimento de padrões.

MySQL lida com o estado estruturado. Neo4j lida com as relações de grafo. Juntos, eles fornecem o que vector databases sozinhos não podem.

Não abandone bancos de dados relacionais para cargas de trabalho de IA. Use a ferramenta certa para cada trabalho, que é usar ambos juntos.

Para mais sobre a perspectiva do agente de IA nesta arquitetura, veja o post complementar em 3k1o.

Funções JSON do MySQL 8.0: Exemplos Práticos e Indexação

This article was originally published in English at AnotherMySQLDBA.

Este post apresenta um guia prático sobre as funções JSON do MySQL 8.0. O suporte a JSON existe no MySQL desde a versão 5.7, mas a 8.0 trouxe um conjunto significativo de melhorias — estratégias de indexação melhores, novas funções e índices multi-valorizados — que tornam o trabalho com dados JSON consideravelmente mais prático. O conteúdo a seguir documenta vários padrões comumente necessários, incluindo saídas do EXPLAIN e observações de desempenho importantes.

Este não é um post de debate "JSON vs. relacional". Se você está armazenando JSON no MySQL, provavelmente já tem seus motivos. O objetivo aqui é garantir que você esteja usando as ferramentas disponíveis de forma eficaz.

Ambiente

mysql> SELECT @@version, @@version_comment\G
*************************** 1. row ***************************
        @@version: 8.0.36
@@version_comment: MySQL Community Server - GPL

Os testes foram realizados em uma VM com 8GB de RAM e innodb_buffer_pool_size configurado para 4G. Uma nota importante de configuração: query_cache_type é irrelevante no 8.0, pois o cache de consultas foi removido completamente. Se você migrou uma instância 5.7 e ainda tem essa variável no seu my.cnf, remova-a — o MySQL 8.0 gerará um erro de inicialização.

Configurando uma Tabela de Teste

A tabela de teste simula um padrão bastante comum — uma aplicação armazenando dados de perfil de usuário e metadados de eventos como blobs JSON:

CREATE TABLE user_events (
  id          INT UNSIGNED NOT NULL AUTO_INCREMENT,
  user_id     INT UNSIGNED NOT NULL,
  event_data  JSON NOT NULL,
  created_at  DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  INDEX idx_user (user_id)
) ENGINE=InnoDB;

INSERT INTO user_events (user_id, event_data) VALUES
(1, '{"action":"login","ip":"192.168.1.10","tags":["mobile","vpn"],"score":88}'),
(1, '{"action":"purchase","ip":"192.168.1.10","tags":["desktop"],"score":72,"amount":49.99}'),
(2, '{"action":"login","ip":"10.0.0.5","tags":["mobile"],"score":91}'),
(3, '{"action":"logout","ip":"10.0.0.9","tags":["desktop","vpn"],"score":65}'),
(2, '{"action":"purchase","ip":"10.0.0.5","tags":["mobile"],"score":84,"amount":129.00}');

Extração Básica: JSON_VALUE vs. JSON_EXTRACT

JSON_VALUE() foi introduzida no MySQL 8.0.21 e é a forma mais limpa de extrair valores escalares com conversão de tipo integrada. Antes disso, você usava JSON_EXTRACT() (ou a abreviação ->) e fazia a conversão manualmente, o que funciona, mas adiciona ruído às suas consultas.

-- Pre-8.0.21 approach
SELECT user_id,
       JSON_EXTRACT(event_data, '$.action') AS action,
       CAST(JSON_EXTRACT(event_data, '$.score') AS UNSIGNED) AS score
FROM user_events;

-- Cleaner 8.0.21+ approach
SELECT user_id,
       JSON_VALUE(event_data, '$.action') AS action,
       JSON_VALUE(event_data, '$.score' RETURNING UNSIGNED) AS score
FROM user_events;

Saída da segunda consulta:

+---------+----------+-------+
| user_id | action   | score |
+---------+----------+-------+
|       1 | login    |    88 |
|       1 | purchase |    72 |
|       2 | login    |    91 |
|       3 | logout   |    65 |
|       2 | purchase |    84 |
+---------+----------+-------+
5 rows in set (0.00 sec)

A cláusula RETURNING é genuinamente útil. Ela elimina o padrão desajeitado de dupla conversão e torna a intenção mais clara ao ler o código da consulta posteriormente.

Índices Multi-Valorizados: A Verdadeira Revolução

É aqui que o 8.0 realmente fez a diferença para cargas de trabalho JSON. Os índices multi-valorizados, disponíveis desde o MySQL 8.0.17, permitem indexar elementos de array dentro de uma coluna JSON diretamente. Veja como isso funciona na prática:

ALTER TABLE user_events
  ADD INDEX idx_tags ((CAST(event_data->'$.tags' AS CHAR(64) ARRAY)));

Aqui está o que o EXPLAIN mostra antes e depois em uma consulta filtrando por valor de tag:

-- Without the multi-valued index:
EXPLAIN SELECT * FROM user_events
WHERE JSON_CONTAINS(event_data->'$.tags', '"vpn"')\G

*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: user_events
   partitions: NULL
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 5
     filtered: 100.00
        Extra: Using where

-- After adding the multi-valued index:
EXPLAIN SELECT * FROM user_events
WHERE JSON_CONTAINS(event_data->'$.tags', '"vpn"')\G

*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: user_events
   partitions: NULL
         type: range
possible_keys: idx_tags
          key: idx_tags
      key_len: 67
          ref: NULL
         rows: 2
     filtered: 100.00
        Extra: Using where

Varredura completa da tabela reduzida a uma varredura de intervalo. Em 5 linhas isso é trivial, mas em uma tabela com milhões de linhas e filtragem frequente por tags, essa diferença é significativa. A melhoria escala diretamente com o tamanho da tabela e a frequência das consultas.

Um ponto importante a observar: MEMBER OF() e JSON_OVERLAPS() também se beneficiam de índices multi-valorizados, mas JSON_SEARCH() não. Isso importa ao escolher o padrão da sua consulta no momento do design:

-- This WILL use the multi-valued index:
SELECT * FROM user_events
WHERE 'vpn' MEMBER OF (event_data->'$.tags');

-- This will NOT use it:
SELECT * FROM user_events
WHERE JSON_SEARCH(event_data->'$.tags', 'one', 'vpn') IS NOT NULL;

Aggregating and Transforming JSON

``````html

-- Build a JSON array of actions per user
SELECT user_id,
       JSON_ARRAYAGG(JSON_VALUE(event_data, '$.action')) AS actions
FROM user_events
GROUP BY user_id;

+---------+----------------------+
| user_id | actions              |
+---------+----------------------+
|       1 | ["login","purchase"] |
|       2 | ["login","purchase"] |
|       3 | ["logout"]           |
+---------+----------------------+
3 rows in set (0.01 sec)

-- Summarize into a JSON object keyed by action
SELECT user_id,
       JSON_OBJECTAGG(
         JSON_VALUE(event_data, '$.action'),
         JSON_VALUE(event_data, '$.score' RETURNING UNSIGNED)
       ) AS score_by_action
FROM user_events
GROUP BY user_id;

+---------+--------------------------------+
| user_id | score_by_action                |
+---------+--------------------------------+
|       1 | {"login": 88, "purchase": 72}  |
|       2 | {"login": 91, "purchase": 84}  |
|       3 | {"logout": 65}                 |
+---------+--------------------------------+
3 rows in set (0.00 sec)

JSON_OBJECTAGG() lançará um erro se houver chaves duplicadas dentro de um grupo. Isso vale a pena saber antes de encontrá-lo em um pipeline ETL de produção. Nesse caso, você precisará desduplicar upstream ou lidar com isso na lógica da aplicação antes que os dados cheguem a esta etapa de agregação.

Verificando SHOW STATUS Após Consultas Pesadas em JSON

Ao avaliar padrões de consultas, verificar as métricas de handler é um hábito útil:

FLUSH STATUS;

SELECT * FROM user_events
WHERE JSON_VALUE(event_data, '$.score' RETURNING UNSIGNED) > 80;

SHOW STATUS LIKE 'Handler_read%';

+----------------------------+-------+
| Variable_name              | Value |
+----------------------------+-------+
| Handler_read_first         | 1     |
| Handler_read_key           | 0     |
| Handler_read_last          | 0     |
| Handler_read_next          | 4     |
| Handler_read_prev          | 0     |
| Handler_read_rnd           | 0     |
| Handler_read_rnd_next      | 6     |
+----------------------------+-------+
7 rows in set (0.00 sec)

O valor de Handler_read_rnd_next confirma uma varredura completa — sem surpresa, já que não há índice funcional no valor da pontuação. Para filtragem baseada em pontuação em escala, uma coluna gerada com índice é a solução correta:

ALTER TABLE user_events
  ADD COLUMN score_val TINYINT UNSIGNED
    GENERATED ALWAYS AS (JSON_VALUE(event_data, '$.score' RETURNING UNSIGNED)) VIRTUAL,
  ADD INDEX idx_score (score_val);

Após adicionar isso, a mesma consulta cai para uma varredura de intervalo de índice adequada. Colunas geradas em campos JSON estão disponíveis tanto no MySQL 8.0 quanto no Percona Server 8.0, e permanecem sendo o caminho mais confiável para filtragem de campos JSON escalares em qualquer escala significativa.

Se você estiver executando Percona Server, o pt-query-digest do Percona Toolkit ainda é a maneira mais prática de identificar quais consultas pesadas em JSON estão realmente causando problemas em produção antes de começar a adicionar índices de forma especulativa.

Observações Práticas

Índices multi-valorados (8.0.17+) são uma melhoria há muito aguardada e funcionam bem quando seus padrões de consulta se alinham com JSON_CONTAINS() ou MEMBER OF()
JSON_VALUE() com RETURNING (8.0.21+) é mais limpo que o antigo padrão de conversão após extração e vale a pena adotar consistentemente
Colunas geradas mais índices permanecem sendo o caminho mais confiável para filtragem de campos JSON escalares em escala
Fique atento a erros de chaves duplicadas em JSON_OBJECTAGG() em dados agrupados — isso surge como um erro grave em pipelines ETL e pode ser fácil de perder em testes se seus dados de amostra acontecerem de estar limpos
Sempre verifique o uso de índices com EXPLAIN — o otimizador nem sempre detecta índices multi-valorados em cláusulas WHERE complexas, e vale a pena confirmar em vez de assumir

Resumo

As melhorias no JSON do MySQL 8.0 são genuinamente úteis, particularmente os índices multi-valorados e o JSON_VALUE() com conversão de tipo. Elas não substituem um bom design de esquema, mas para casos em que o armazenamento em JSON é apropriado ou herdado, agora você tem ferramentas reais para trabalhar em vez de apenas esperar que o otimizador descubra. O padrão de coluna gerada, em particular, vale a pena avaliar cedo se você souber que certos campos JSON serão usados regularmente em cláusulas WHERE.

Referências úteis:

quinta-feira, 3 de julho de 2025

Análise de MySQL: Com uma Ferramenta CLI Potencializada por IA

Como DBAs com MySQL, frequentemente vivemos numa janela de terminal Linux. Também gostamos de opções gratuitas quando disponíveis. Este post mostra uma abordagem que nos permite permanecer na nossa janela de terminal e ainda usar uma ferramenta potencializada por IA. Você pode atualizar para usar outros provedores diretos de IA, mas configurei este exemplo para usar aimlapi.com já que traz múltiplos modelos de IA para seu terminal gratuitamente com uso limitado ou custo muito baixo para mais testes.

Nota: Não sou um porta-voz pago da AIMLAPI nem nada do tipo - isto é apenas um exemplo simples para destacar a ideia.

O Problema

Você está olhando um banco de dados legado com centenas de tabelas, cada uma com relacionamentos complexos e decisões de design questionáveis feitas anos atrás. O processo usual envolve:

Inspeção manual do esquema
Referências cruzadas de documentação (se existir)
Executar múltiplas consultas EXPLAIN
Consultar guias de melhores práticas
Buscar segundas opiniões de colegas

Isso leva tempo e frequentemente deixamos coisas passar.

Uma Abordagem Baseada em CLI

Podemos aproveitar a IA diretamente do nosso CLI e fazer numerosas coisas. Ajudar com análise de MySQL é apenas um exemplo de como esta abordagem pode funcionar com nossas tarefas diárias de banco de dados. Ao combinar as capacidades nativas do MySQL com modelos de IA, tudo acessível através de uma interface de linha de comando simples, podemos obter insights sem sair do nosso terminal. AIMLAPI fornece acesso gratuito a mais de 100 modelos de IA com uso limitado, tornando esta abordagem acessível. Para testes mais intensivos, os custos permanecem muito razoáveis.

A Ferramenta: AIMLAPI CLI

Então aqui está um script bash que fornece acesso a mais de 100 modelos de IA através de uma única interface:

#!/bin/bash
# Ferramenta CLI AIMLAPI com acesso a mais de 100 modelos de IA
# Arquivo: ~/.local/bin/aiml

# Configuração
DEFAULT_MODEL=${AIMLAPI_DEFAULT_MODEL:-"gpt-4o"}
MAX_TOKENS=${AIMLAPI_MAX_TOKENS:-2000}
TEMPERATURE=${AIMLAPI_TEMPERATURE:-0.7}
BASE_URL="https://api.aimlapi.com"
ENDPOINT="v1/chat/completions"

# Códigos de cor para saída
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m' # Sem Cor

# Função para imprimir saída colorida
print_info() { echo -e "${BLUE}[INFO]${NC} $1"; }
print_success() { echo -e "${GREEN}[SUCESSO]${NC} $1"; }
print_warning() { echo -e "${YELLOW}[AVISO]${NC} $1"; }
print_error() { echo -e "${RED}[ERRO]${NC} $1"; }
print_model() { echo -e "${PURPLE}[MODELO]${NC} $1"; }

# Atalhos de modelos populares
declare -A MODEL_SHORTCUTS=(
    # Modelos OpenAI
    ["gpt4"]="gpt-4o"
    ["gpt4o"]="gpt-4o"
    ["gpt4mini"]="gpt-4o-mini"
    ["o1"]="o1-preview"
    ["o3"]="openai/o3-2025-04-16"
    
    # Modelos Claude  
    ["claude"]="claude-3-5-sonnet-20241022"
    ["claude4"]="anthropic/claude-sonnet-4"
    ["opus"]="claude-3-opus-20240229"
    ["haiku"]="claude-3-5-haiku-20241022"
    ["sonnet"]="claude-3-5-sonnet-20241022"
    
    # Modelos DeepSeek
    ["deepseek"]="deepseek-chat"
    ["deepseek-r1"]="deepseek/deepseek-r1"
    ["reasoner"]="deepseek-reasoner"
    
    # Modelos Google
    ["gemini"]="gemini-2.0-flash"
    ["gemini2"]="gemini-2.0-flash"
    ["gemini15"]="gemini-1.5-pro"
    
    # Modelos Meta Llama
    ["llama"]="meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo"
    ["llama405b"]="meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo"
    
    # Modelos Qwen
    ["qwen"]="qwen-max"
    ["qwq"]="Qwen/QwQ-32B"
    
    # Modelos Grok
    ["grok"]="x-ai/grok-beta"
    ["grok3"]="x-ai/grok-3-beta"
    
    # Modelos Especializados
    ["coder"]="Qwen/Qwen2.5-Coder-32B-Instruct"
)

# Função para resolver atalhos de modelos
resolve_model() {
    local model="$1"
    if [[ -n "${MODEL_SHORTCUTS[$model]}" ]]; then
        echo "${MODEL_SHORTCUTS[$model]}"
    else
        echo "$model"
    fi
}

# Função para criar payload JSON usando jq para escape adequado
create_json_payload() {
    local model="$1"
    local prompt="$2"
    local system_prompt="$3"
    
    local temp_file=$(mktemp)
    echo "$prompt" > "$temp_file"
    
    if [ -n "$system_prompt" ]; then
        jq -n --arg model "$model" \
              --rawfile prompt "$temp_file" \
              --arg system "$system_prompt" \
              --argjson max_tokens "$MAX_TOKENS" \
              --argjson temperature "$TEMPERATURE" \
              '{
                model: $model,
                messages: [{role: "system", content: $system}, {role: "user", content: $prompt}],
                max_tokens: $max_tokens,
                temperature: $temperature
              }'
    else
        jq -n --arg model "$model" \
              --rawfile prompt "$temp_file" \
              --argjson max_tokens "$MAX_TOKENS" \
              --argjson temperature "$TEMPERATURE" \
              '{
                model: $model,
                messages: [{role: "user", content: $prompt}],
                max_tokens: $max_tokens,
                temperature: $temperature
              }'
    fi
    
    rm -f "$temp_file"
}

# Função para chamar AIMLAPI
call_aimlapi() {
    local prompt="$1"
    local model="$2"
    local system_prompt="$3"
    
    if [ -z "$AIMLAPI_API_KEY" ]; then
        print_error "AIMLAPI_API_KEY não está configurada"
        return 1
    fi
    
    model=$(resolve_model "$model")
    
    local json_file=$(mktemp)
    create_json_payload "$model" "$prompt" "$system_prompt" > "$json_file"
    
    local response_file=$(mktemp)
    local http_code=$(curl -s -w "%{http_code}" -X POST "${BASE_URL}/${ENDPOINT}" \
        -H "Content-Type: application/json" \
        -H "Authorization: Bearer $AIMLAPI_API_KEY" \
        --data-binary @"$json_file" \
        -o "$response_file")
    
    if [ "$http_code" -ne 200 ] && [ "$http_code" -ne 201 ]; then
        print_error "Erro HTTP $http_code"
        cat "$response_file" >&2
        rm -f "$json_file" "$response_file"
        return 1
    fi
    
    local content=$(jq -r '.choices[0].message.content // empty' "$response_file" 2>/dev/null)
    
    if [ -z "$content" ]; then
        content=$(jq -r '.choices[0].text // .message.content // .content // empty' "$response_file" 2>/dev/null)
    fi
    
    if [ -z "$content" ]; then
        local error_msg=$(jq -r '.error.message // .error // empty' "$response_file" 2>/dev/null)
        if [ -n "$error_msg" ]; then
            echo "Erro da API: $error_msg"
        else
            echo "Erro: Não é possível analisar a resposta da API"
        fi
    else
        echo "$content"
    fi
    
    rm -f "$json_file" "$response_file"
}

# Função principal com análise de argumentos
main() {
    local model="$DEFAULT_MODEL"
    local system_prompt=""
    local prompt=""
    local piped_input=""
    
    if [ -p /dev/stdin ]; then
        piped_input=$(cat)
    fi
    
    # Analisar argumentos
    while [[ $# -gt 0 ]]; do
        case $1 in
            -m|--model)
                model="$2"
                shift 2
                ;;
            -s|--system)
                system_prompt="$2"
                shift 2
                ;;
            *)
                prompt="$*"
                break
                ;;
        esac
    done
    
    # Manipular entrada
    if [ -n "$piped_input" ] && [ -n "$prompt" ]; then
        prompt="$prompt

Aqui estão os dados para analisar:
$piped_input"
    elif [ -n "$piped_input" ]; then
        prompt="Por favor analise estes dados:

$piped_input"
    elif [ -z "$prompt" ]; then
        echo "Uso: aiml [opções] \"prompt\""
        echo "       comando | aiml [opções]"
        exit 1
    fi
    
    local resolved_model=$(resolve_model "$model")
    print_info "Consultando $resolved_model..."
    
    local response=$(call_aimlapi "$prompt" "$model" "$system_prompt")
    
    echo ""
    print_model "Resposta de $resolved_model:"
    echo "----------------------------------------"
    echo "$response" 
    echo "----------------------------------------"
}

# Verificar dependências
check_dependencies() {
    command -v curl >/dev/null 2>&1 || { print_error "curl requerido mas não instalado."; exit 1; }
    command -v jq >/dev/null 2>&1 || { print_error "jq requerido mas não instalado."; exit 1; }
}

check_dependencies
main "$@"

Este script fornece acesso a vários modelos de IA através de atalhos simples como claude4, gpt4, grok3, etc. AIMLAPI oferece acesso gratuito com uso limitado a todos estes modelos, com custos razoáveis para testes adicionais. Bom para DBAs que querem experimentar sem estourar o orçamento.

Recursos do Script

O script inclui ajuda abrangente. Aqui está o que aiml --help mostra:

Ferramenta CLI AIMLAPI - Acesso a mais de 100 Modelos de IA
============================================================
Uso: aiml [OPÇÕES] "prompt"
     comando | aiml [OPÇÕES]
Opções Principais:
  -m, --model MODELO        Modelo a usar (padrão: gpt-4o)
  -t, --tokens NÚMERO       Tokens máximos (padrão: 2000)
  -T, --temperature FLOAT   Temperatura 0.0-2.0 (padrão: 0.7)
  -s, --system PROMPT       Prompt do sistema para comportamento do modelo
Opções de Entrada/Saída:
  -f, --file ARQUIVO        Ler prompt de arquivo
  -o, --output ARQUIVO      Salvar resposta em arquivo
  -r, --raw                 Saída bruta (sem formatação/cores)
Opções de Informação:
  -l, --list               Listar atalhos de modelos populares
  --get-models             Buscar todos os modelos disponíveis da API
  -c, --config             Mostrar configuração atual
  -v, --verbose            Habilitar saída detalhada
  -d, --debug              Mostrar informações de depuração
  -h, --help               Mostrar esta ajuda
Exemplos Básicos:
  aiml "explique computação quântica"
  aiml -m claude "revise este código"
  aiml -m deepseek-r1 "resolva este problema matemático passo a passo"
  aiml -m grok3 "quais são os últimos desenvolvimentos em IA?"
  aiml -m coder "otimize esta função Python"
Exemplos com Pipe:
  ps aux | aiml "analise estes processos"
  netstat -tuln | aiml "explique estas conexões de rede"
  cat error.log | aiml -m claude "diagnostique estes erros"
  git diff | aiml -m coder "revise estas mudanças de código"
  df -h | aiml "analise o uso do disco e sugira limpeza"
Operações com Arquivos:
  aiml -f prompt.txt -o response.txt
  aiml -f large_dataset.csv -m llama405b "analise estes dados"
  cat script.py | aiml -m coder -o review.md "revisão de código"
Categorias de Modelos e Atalhos:
  OpenAI:     gpt4, gpt4mini, o1, o3
  Claude:     claude, opus, haiku, sonnet, claude4
  DeepSeek:   deepseek, deepseek-r1, reasoner
  Google:     gemini, gemini2, gemma
  Meta:       llama, llama3, llama4, llama405b
  Qwen:       qwen, qwen2, qwq
  Grok:       grok, grok3, grok3mini
  Codificação: coder, codestral
Uso Avançado:
  aiml -m claude -s "Você é um especialista em segurança" "audite este código"
  aiml -m deepseek-r1 -t 3000 "tarefa de raciocínio complexo"
  aiml -v -m grok3 "consulta detalhada com logging detalhado"
  aiml -d "modo de depuração para solucionar problemas da API"
Descoberta de Modelos:
  aiml -l                   # Mostrar atalhos populares
  aiml --get-models         # Buscar todos os modelos disponíveis da API
  aiml --config             # Mostrar configuração atual
Variáveis de Ambiente:
  AIMLAPI_API_KEY          - Sua chave AIMLAPI (obrigatória)
  AIMLAPI_DEFAULT_MODEL    - Modelo padrão (opcional)
  AIMLAPI_MAX_TOKENS       - Tokens máximos padrão (opcional)
  AIMLAPI_TEMPERATURE      - Temperatura padrão (opcional)
Dicas Profissionais:
  • Use coder para tarefas de programação e revisões de código
  • Use deepseek-r1 para raciocínio complexo e problemas matemáticos
  • Use claude4 para análise detalhada e conteúdo de formato longo
  • Use grok3 para eventos atuais e informações em tempo real
  • Use gpt4mini para perguntas rápidas para economizar nos custos da API
  • Envie saída de comandos diretamente: comando | aiml "analise isto"
  • Use -v para saída detalhada para ver qual modelo está sendo usado
  • Use --get-models para ver todos os mais de 100 modelos disponíveis

Acesso a mais de 100 modelos de IA através de uma interface simples!

Exemplo: A Tabela City

Aqui está como isto funciona com uma análise real de tabela MySQL. Vou analisar uma tabela City do clássico banco de dados World (de https://dev.mysql.com/doc/index-other.html Bancos de Dados de Exemplo) usando três modelos de IA diferentes.

O Comando

mysql --login-path=klarson world -e "show create table City\G" | \
aiml --model claude4 "Usando um ponto de vista especialista em MySQL analise esta tabela"

Este comando:

Extrai a estrutura da tabela do MySQL
Envia por pipe para nossa ferramenta de IA
Obtém análise do Claude Sonnet 4

Resultados

Análise do Claude Sonnet 4

Claude 4 forneceu uma análise bem organizada:

Pontos Fortes:

Chave primária AUTO_INCREMENT adequada para eficiência do InnoDB
Restrições de chave estrangeira mantendo integridade referencial
Estratégia de indexação apropriada para consultas comuns

Problemas Encontrados:

Ineficiência de Armazenamento: Usar CHAR(35) para nomes de cidades de comprimento variável desperdiça espaço
Limitação do Conjunto de Caracteres: charset latin1 inadequado para nomes de cidades internacionais
Indexação Subótima: o índice name_key cobre apenas os primeiros 5 caracteres

Melhorias Sugeridas:

-- Estrutura otimizada sugerida pelo Claude
CREATE TABLE `City` (
  `ID` int NOT NULL AUTO_INCREMENT,
  `Name` VARCHAR(35) NOT NULL,
  `CountryCode` CHAR(3) NOT NULL,
  `District` VARCHAR(20) NOT NULL,
  `Population` int UNSIGNED NOT NULL DEFAULT '0',
  PRIMARY KEY (`ID`),
  KEY `CountryCode` (`CountryCode`),
  KEY `name_idx` (`Name`),
  KEY `country_name_idx` (`CountryCode`, `Name`),
  KEY `population_idx` (`Population`),
  CONSTRAINT `city_ibfk_1` FOREIGN KEY (`CountryCode`) 
    REFERENCES `Country` (`Code`) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=4080 
  DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

Análise do Grok 3 Beta

mysql --login-path=klarson world -e "show create table City\G" | \
aiml --model grok3 "Usando um ponto de vista especialista em MySQL analise esta tabela"

Grok 3 forneceu uma análise exaustiva e detalhada cobrindo:

Análise Técnica Profunda:

Análise de Impacto na Performance: Avaliou a limitação do índice parcial em detalhes
Benefícios do Motor de Armazenamento: Confirmou a escolha do InnoDB para integridade transacional
Otimização de Tipos de Dados: Recomendações detalhadas de economia de espaço com exemplos

Considerações Avançadas:

Recomendações de indexação de texto completo para buscas de nomes de cidades
Procedimentos de migração de conjunto de caracteres com comandos específicos
Estratégias de particionamento para conjuntos de dados grandes

Diretrizes de Implementação:

-- Sugestão de migração de conjunto de caracteres do Grok
ALTER TABLE City CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

-- Recomendação de índice de texto completo
ALTER TABLE City ADD FULLTEXT INDEX name_fulltext (Name);

Análise do GPT-4o

mysql --login-path=klarson world -e "show create table City\G" | \
aiml --model gpt4 "Usando um ponto de vista especialista em MySQL analise esta tabela"

GPT-4o focou em melhorias práticas e diretamente acionáveis:

Avaliação Pragmática:

Validou o design da chave primária AUTO_INCREMENT
Confirmou os benefícios das restrições de chave estrangeira para integridade de dados
Identificou limitações do conjunto de caracteres para aplicações globais

Sugestões Prontas para Implementar:

Comandos ALTER TABLE específicos para otimização imediata
Recomendações de análise de padrões de consulta
Critérios de avaliação de efetividade de índices

O Poder da Análise Multi-Modelo

O que torna esta abordagem valiosa é obter três perspectivas distintas:

Claude 4: Fornece análise detalhada e estruturada com soluções de código concretas
Grok 3: Oferece cobertura abrangente com estratégias de otimização avançadas
GPT-4o: Entrega recomendações práticas e diretamente acionáveis

Cada modelo traz pontos fortes únicos:

Pontos focais diferentes: Otimização de armazenamento vs. performance vs. manutenibilidade
Níveis de profundidade variados: De vitórias rápidas a melhorias arquiteturais
Estilos de análise diversos: Estruturado vs. abrangente vs. prático

Além do MySQL: Outros Exemplos de CLI

Como podemos enviar por pipe qualquer saída de comando para a ferramenta de IA, aqui estão alguns outros exemplos úteis:

Administração do Sistema

# Analisar processos do sistema
ps aux | aiml "que processos estão usando mais recursos?"

# Verificar uso de disco
df -h | aiml "analise o uso do disco e sugira limpeza"

# Conexões de rede
netstat -tuln | aiml "explique estas conexões de rede"

# Logs do sistema
tail -50 /var/log/syslog | aiml "há erros preocupantes nestes logs?"

Análise de Arquivos e Diretórios

# Arquivos grandes
find /var -size +100M | aiml "organize estes arquivos grandes por tipo"

# Problemas de permissões
ls -la /etc/mysql/ | aiml "verifique estas permissões de arquivo para segurança"

# Revisão de configuração
cat /etc/mysql/my.cnf | aiml "revise esta configuração do MySQL"

Análise de Logs

# Logs do Apache
tail -100 /var/log/apache2/error.log | aiml "resuma estes erros do servidor web"

# Logs de autenticação
grep "Failed password" /var/log/auth.log | aiml "analise estas tentativas de login falhadas"

O ponto é que você pode enviar por pipe quase qualquer coisa para obter análise rápida sem sair do seu terminal.

Implementando o Fluxo de Trabalho

Instruções de Configuração

1. Instalar Dependências:

# Instalar ferramentas necessárias
sudo apt install curl jq mysql-client

# Criar o diretório do script
mkdir -p ~/.local/bin

# Tornar o script executável
chmod +x ~/.local/bin/aiml

2. Configurar Acesso à API:

# Obtenha sua chave gratuita AIMLAPI de https://aimlapi.com (nível gratuito com uso limitado)
export AIMLAPI_API_KEY="sua-chave-api-gratuita-aqui"
echo 'export AIMLAPI_API_KEY="sua-chave-api-gratuita-aqui"' >> ~/.bashrc

3. Testar a Configuração:

# Verificar configuração
aiml --config

# Testar funcionalidade básica
echo "SELECT VERSION();" | aiml "explique este SQL"

Padrões de Uso Prático

Análise Rápida de Tabela

# Analisar uma tabela específica
mysql -e "SHOW CREATE TABLE usuarios\G" meubd | \
aiml -m claude4 "Analise esta estrutura de tabela MySQL"

Comparar Diferentes Perspectivas de Modelos

# Obter múltiplos pontos de vista sobre a mesma tabela
TABLE_DDL=$(mysql -e "SHOW CREATE TABLE pedidos\G" ecommerce)

echo "$TABLE_DDL" | aiml -m claude4 "análise de tabela MySQL"
echo "$TABLE_DDL" | aiml -m grok3 "revisão de otimização de performance" 
echo "$TABLE_DDL" | aiml -m gpt4 "sugestões de melhoria prática"

Analisar Múltiplas Tabelas

# Análise rápida de todas as tabelas em um banco de dados
mysql -e "SHOW TABLES;" meubd | \
while read tabela; do
  echo "=== Analisando $tabela ==="
  mysql -e "SHOW CREATE TABLE $tabela\G" meubd | \
  aiml -m gpt4mini "avaliação rápida desta tabela"
done

Análise de Índices

# Revisar uso e otimização de índices
mysql -e "SHOW INDEX FROM nometabela;" bancodedados | \
aiml -m deepseek "sugira otimizações de índices para esta tabela MySQL"

Análise de Performance de Consultas

# Analisar consultas lentas
mysql -e "SHOW PROCESSLIST;" | \
aiml -m grok3 "identifique problemas potenciais de performance nestes processos MySQL"

Por Que AIMLAPI Torna Isto Possível para DBAs

Acesso Gratuito com Custos Razoáveis: AIMLAPI fornece acesso gratuito com uso limitado a mais de 100 modelos de IA, com preços muito razoáveis para testes adicionais. Isto o torna perfeito para DBAs que querem experimentar sem se comprometer com assinaturas caras.

Diversidade de Modelos: Acesso a modelos de diferentes provedores (OpenAI, Anthropic, Google, Meta, etc.) significa que você obtém perspectivas variadas e áreas de expertise.

Sem Aprisionamento de Fornecedor: Você pode experimentar com diferentes modelos para encontrar o que funciona melhor para suas necessidades específicas sem compromissos de longo prazo.

Nativo do Terminal: Permanece no seu ambiente confortável do Linux onde você já está fazendo seu trabalho MySQL.

Guia de Seleção de Modelos

Diferentes modelos se destacam em diferentes aspectos da análise MySQL:

# Para análise estrutural detalhada
aiml -m claude4 "revisão abrangente de estrutura de tabela"

# Para análise focada em performance  
aiml -m grok3 "recomendações de otimização de performance"

# Para sugestões rápidas e práticas
aiml -m gpt4 "melhorias imediatas e acionáveis"

# Para raciocínio complexo sobre trade-offs
aiml -m deepseek-r1 "análise de trade-offs de otimização complexa"

# Para verificações rápidas e econômicas
aiml -m gpt4mini "avaliação breve de tabela"

Técnicas Avançadas

Prompts de Sistema Personalizados

Adapte a análise ao seu contexto específico:

# Foco em e-commerce
aiml -m claude4 -s "Você está analisando tabelas para um site de e-commerce de alto tráfego" \
"Revise esta tabela para escalabilidade"

# Foco em segurança
aiml -m grok3 -s "Você é um analista de banco de dados focado em segurança" \
"Avaliação de segurança desta estrutura de tabela"

# Foco em sistema legado
aiml -m gpt4 -s "Você está ajudando a migrar um sistema legado para MySQL moderno" \
"Recomendações de modernização para esta tabela"

Relatórios Automatizados

# Gerar um relatório abrangente de análise de banco de dados
DB_NAME="banco_producao"
REPORT_FILE="analise_$(date +%Y%m%d).md"

echo "# Relatório de Análise de Banco de Dados para $DB_NAME" > "$REPORT_FILE"
echo "Gerado em $(date)" >> "$REPORT_FILE"

for tabela in $(mysql -Ns -e "SHOW TABLES;" "$DB_NAME"); do
  echo "" >> "$REPORT_FILE"
  echo "## Tabela: $tabela" >> "$REPORT_FILE"
  
  mysql -e "SHOW CREATE TABLE $tabela\G" "$DB_NAME" | \
  aiml -m claude4 "Forneça análise concisa desta tabela MySQL" >> "$REPORT_FILE"
done

Fluxo de Trabalho de Otimização de Performance

# Análise abrangente de performance
mysql -e "SHOW CREATE TABLE tabela_pesada\G" bd | \
aiml -m grok3 "análise de gargalos de performance"

# Acompanhar com sugestões de índices
mysql -e "SHOW INDEX FROM tabela_pesada;" bd | \
aiml -m deepseek "estratégia de otimização de índices"

# Obter plano de implementação
aiml -m gpt4 "Crie plano de implementação passo a passo para estas otimizações"

Benefícios Reais desta Abordagem

Velocidade: Obtenha análise de nível especialista em segundos em vez de horas
Múltiplas Perspectivas: Diferentes modelos capturam diferentes problemas
Ferramenta de Aprendizado: Cada análise ensina algo novo sobre otimização MySQL
Custo-Efetivo: Graças ao nível gratuito e preços razoáveis da AIMLAPI, esta análise poderosa é acessível
Consistência: Análise repetível em diferentes tabelas e bancos de dados
Documentação: Fácil de gerar relatórios e compartilhar descobertas com equipes

Dicas para Melhores Resultados

Comece com Estrutura: Sempre comece com SHOW CREATE TABLE para análise abrangente
Use Prompts Específicos: Quanto mais específica sua solicitação, melhor a análise
Compare Modelos: Diferentes modelos se destacam em diferentes aspectos - use múltiplas perspectivas
Valide Sugestões: Sempre teste recomendações de IA em ambientes de desenvolvimento primeiro
Itere: Use perguntas de acompanhamento para aprofundar em recomendações específicas

Começando Hoje

A beleza desta abordagem é sua simplicidade e custo-benefício. Com apenas alguns comandos, você pode:

Obter sua chave gratuita AIMLAPI de https://aimlapi.com (inclui nível gratuito)
Instalar o script (5 minutos)
Começar a analisar suas tabelas MySQL imediatamente
Experimentar com diferentes modelos para ver quais funcionam melhor para suas necessidades
Usar o nível gratuito para análise regular, pagar apenas por testes intensivos

Usuários Windows (Opção Rápida)

Não sou uma pessoa Windows, mas se você precisa executar isto no Windows, a abordagem mais simples é:

Instalar WSL2 (Subsistema Windows para Linux)
Instalar Ubuntu da Microsoft Store
Seguir a configuração Linux acima dentro do WSL2

Isto lhe dá um ambiente Linux adequado onde o script funcionará exatamente como projetado.

Isto não é sobre substituir expertise de DBA - é sobre aumentá-la enquanto permanece no seu ambiente de terminal. A IA fornece análise rápida e captura coisas que você pode perder, enquanto você fornece o contexto e toma as decisões finais.

Seja trabalhando com uma única tabela ou um banco de dados complexo com centenas de tabelas, este fluxo de trabalho escala para atender suas necessidades. E como AIMLAPI fornece acesso gratuito com custos razoáveis para uso adicional, você pode experimentar e encontrar a combinação perfeita para seus casos de uso específicos sem preocupações orçamentárias.

A combinação das poderosas capacidades de introspecção do MySQL com análise de IA cria um fluxo de trabalho que é tanto prático quanto custo-efetivo para DBAs. Experimente no seu próximo projeto de otimização de banco de dados - você pode se surpreender com os insights que emergem, tudo enquanto permanece no seu ambiente confortável de terminal.

terça-feira, 15 de abril de 2025

LABORATÓRIO EM CASA

https://anothermysqldba.blogspot.com/2025/04/homelab.html

Só por diversão...

Existem inúmeras opções para testar instâncias de bancos de dados MySQL e gerais.

Este é apenas um exemplo de como você pode usar o Proxmox para ter uma configuração rápida e simples para testes e acesso repetíveis.

Este exemplo é uma opção boa e barata para ter um laboratório em casa para MySQL e qualquer outra coisa que você queira.

A virtualização de homelab que escolhi foi Proxmox e Openmediavaul para armazenamento NFS estendido (não estou 100% convencido do Openmediavault , o Debian sozinho poderia fazer isso)

Hardware Escolhi uma configuração simples e compacta:

Essa virtualização também permite que você tenha um ambiente que pode ser executado conforme necessário, desligado ou até mesmo desligado e retornado quando quiser.

Permite também clonar cada instância para instâncias adicionais e testes, se desejado, após a configuração.

Esta será uma configuração direta muito simples em todos eles.

Você pode criar dispositivos de bloco para cada diretório de dados ou NFS se preferir, mas tudo isso será instalação direta local para demonstração.

Objetivo de testar e demonstrar:

Instalar
Monitoramento
Rotação de senha do cofre

Debian BASE

Configurei uma instância do Debian 12 com 4 GB e 4 CPUs.
Em seguida, converti isso como um modelo para poder vincular todas as outras instâncias a partir dele.
Isso torna a configuração de outras instâncias muito mais rápida, além de ter a mesma base para começar.

┌──(root㉿debian12-server)-[~]
└─# uname -a
Linux debian12-server 6.1.0-32-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.129-1 (06/03/2025) x86_64 GNU/Linux

apt install unzip
cd /usr/local/src/
wget https://releases.hashicorp.com/vault/1.4.2/vault_1.4.2_linux_amd64.zip
descompacte o vault_1.4.2_linux_amd64.zip
mv cofre /usr/bin/
setcap cap_ipc_lock=+ep /usr/bin/vault
# cofre -v
Cofre v1.4.2

MariaDB 11 Rolling

vi /etc/rede/interfaces
auto ens18
iface ens18 inet estático
    endereço 192.168.3.100
    máscara de rede 255.255.255.0
    portal 192.168.3.1
    servidores de nomes DNS 8.8.8.8 8.8.4.4

# nome do host
mariadb1.sqlhjalp.com

sudo apt-get install apt-transport-https curl
sudo mkdir -p /etc/apt/keyrings
sudo curl -o /etc/apt/keyrings/mariadb-keyring.pgp 'https://mariadb.org/mariadb_release_signing_key.pgp'
vi /etc/apt/sources.list.d/mariadb.sources

┌──(raiz㉿mariadb1)-[~]
└─# cat /etc/apt/sources.list.d/mariadb.sources
# MariaDB 11 Lista de repositórios contínuos - criada em 2025-04-01 15:13 UTC
# https://mariadb.org/download/
X-Repolib-Nome: MariaDB
Tipos: deb
# deb.mariadb.org é um espelho dinâmico caso o seu espelho preferido fique offline. Consulte https://mariadb.org/mirrorbits/ para obter detalhes.
# URIs: https://deb.mariadb.org/11/debian
URIs: https://mirror.its.dal.ca/mariadb/repo/11.rolling/debian
Suítes: leitor ávido
Componentes: principal
Assinado por: /etc/apt/keyrings/mariadb-keyring.pgp

┌──(raiz㉿mariadb1)-[~]
└─# apt-get update

┌──(raiz㉿mariadb1)-[~]
└─# apt-get install mariadb-server -y

┌──(raiz㉿mariadb1)-[~]
└─# mariadb
Bem-vindo ao monitor MariaDB. Os comandos terminam com ; ou \g.
Seu ID de conexão MariaDB é 32
Versão do servidor: 11.7.2-MariaDB-deb12 distribuição binária mariadb.org

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab e outros.

Digite 'help;' ou '\h' para obter ajuda. Digite '\c' para limpar a instrução de entrada atual.

MariaDB [(nenhum)]>
MariaDB [(nenhum)]> saída
Tchau

┌──(raiz㉿mariadb1)-[~]
└─# systemctl stop mariadb.service

Só para esclarecer. Sim, com um servidor vinculado ao Proxmox, você pode reiniciar e ele mantém todos os seus valores e configurações.

┌──(raiz㉿mariadb1)-[~]
└─# tempo de atividade
 10:27:29, 1 min, 2 usuários, carga média: 0,15, 0,11, 0,04

┌──(raiz㉿mariadb1)-[~]
└─# mariadb
Bem-vindo ao monitor MariaDB. Os comandos terminam com ; ou \g.
Seu ID de conexão MariaDB é 33
Versão do servidor: 11.7.2-MariaDB-deb12 distribuição binária mariadb.org

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab e outros.

Digite 'help;' ou '\h' para obter ajuda. Digite '\c' para limpar a instrução de entrada atual.

MariaDB [(nenhum)]> status
--------------
mariadb de 11.7.2-MariaDB, cliente 15.2 para debian-linux-gnu (x86_64) usando wrapper EditLine

ID de conexão: 33
Banco de dados atual:
Usuário atual: root@localhost
SSL: A cifra em uso é TLS_AES_256_GCM_SHA384, o certificado está OK
Pager atual: stdout
Usando outfile: ''
Usando delimitador: ;
Servidor: MariaDB
Versão do servidor: 11.7.2-MariaDB-deb12 distribuição binária mariadb.org
Versão do protocolo: 10
Conexão: Localhost via soquete UNIX
Conjunto de caracteres do servidor: utf8mb4
Conjunto de caracteres do banco de dados: utf8mb4
Conjunto de caracteres do cliente: utf8mb3
Conjunto de caracteres de conexão: utf8mb3
Soquete UNIX: /run/mysqld/mysqld.sock
Tempo de atividade: 1 min 45 s

Tópicos: 1 Perguntas: 61 Consultas lentas: 0 Aberturas: 33 Tabelas abertas: 26 Consultas por segundo em média: 0,580
--------------

Inovação MySQL

vi /etc/rede/interfaces
auto ens18
iface ens18 inet estático
    endereço 192.168.3.101
    máscara de rede 255.255.255.0
    portal 192.168.3.1
    servidores de nomes DNS 8.8.8.8 8.8.4.4


# apt install gnupg -y
# cd /usr/local/src/
# wget https://dev.mysql.com/get/mysql-apt-config_0.8.33-1_all.deb
# dpkg -i mysql-apt-config_0.8.33-1_all.deb

│ Qual versão do servidor você deseja receber? │
  mysql-8.0  
  mysql-innovation <-- Escolhi isso
  mysql-8.4-lts    
  mysql-cluster-8.0   
  inovação em cluster mysql    
  mysql-cluster-8.4-lts    
  Nenhum

 Qual produto MySQL você deseja configurar?                                                                                                                           
 Servidor e cluster MySQL (atualmente selecionado: mysql-innovation)
 Conectores MySQL (Atualmente selecionado: Habilitado)
 OK

# apt-get atualização
# apt-get install mysql-server -y

─# mysql -u root -p
Digite a senha:
Bem-vindo ao monitor MySQL. Os comandos terminam com ; ou \g.
Seu ID de conexão MySQL é 9
Versão do servidor: 9.2.0 MySQL Community Server - GPL

Copyright (c) 2000, 2025, Oracle e/ou suas afiliadas.

Oracle é uma marca registrada da Oracle Corporation e/ou seus
afiliadas. Outros nomes podem ser marcas registradas de seus respectivos
proprietários.

Digite 'help;' ou '\h' para obter ajuda. Digite '\c' para limpar a instrução de entrada atual.

mysql> estado
--------------
mysql Ver 9.2.0 para Linux em x86_64 (MySQL Community Server - GPL)

ID de conexão: 9
Banco de dados atual:
Usuário atual: root@localhost
SSL: Não em uso
Pager atual: stdout
Usando outfile: ''
Usando delimitador: ;
Versão do servidor: 9.2.0 MySQL Community Server - GPL
Versão do protocolo: 10
Conexão: Localhost via soquete UNIX
Conjunto de caracteres do servidor: utf8mb4
Conjunto de caracteres do banco de dados: utf8mb4
Conjunto de caracteres do cliente: utf8mb4
Conjunto de caracteres de conexão: utf8mb4
Soquete UNIX: /var/run/mysqld/mysqld.sock
Dados binários como: Hexadecimal
Tempo de atividade: 47 seg

Tópicos: 2 Perguntas: 6 Consultas lentas: 0 Aberturas: 119 Tabelas de limpeza: 3 Tabelas abertas: 38 Consultas por segundo em média: 0,127

MySQL Innovation NDB CLuster

gato /etc/rede/interfaces
auto ens18
iface ens18 inet estático
    endereço 192.168.3.102
    máscara de rede 255.255.255.0
    portal 192.168.3.1
    servidores de nomes DNS 8.8.8.8 8.8.4.4

auto ens18
iface ens18 inet estático
    endereço 192.168.3.103
    máscara de rede 255.255.255.0
    portal 192.168.3.1
    servidores de nomes DNS 8.8.8.8 8.8.4.4

auto ens18
iface ens18 inet estático
    endereço 192.168.3.103
    máscara de rede 255.255.255.0
    portal 192.168.3.1
    servidores de nomes DNS 8.8.8.8 8.8.4.4

# apt install gnupg -y
# cd /usr/local/src/
# wget https://dev.mysql.com/get/mysql-apt-config_0.8.33-1_all.deb
# dpkg -i mysql-apt-config_0.8.33-1_all.deb

│ Qual versão do servidor você deseja receber?                                                                                                                            
 mysql-8.0  
 mysql-inovação     
 mysql-8.4-lts        
 mysql-cluster-8.0       
 mysql-cluster-innovation <-- Escolhi isso    
 mysql-cluster-8.4-lts   
 Nenhum

 Qual produto MySQL você deseja configurar?                                                                             
  Servidor e cluster MySQL (atualmente selecionado: mysql-cluster-innovation)  
  Conectores MySQL (Atualmente selecionado: Habilitado)     
  OK

# apt-get atualização
# apt-get install mysql-cluster-community-server -y
# apt-get install mysql-cluster-community-management-server <-- podemos escolher mais tarde qual usar
# apt-get install mysql-cluster-community-data-node -y

# vi /etc/mysql/conf.d/mysql.cnf

[mysqld]
# Opções para o processo mysqld:
ndbcluster # executa o mecanismo de armazenamento NDB

[mysql_cluster]
# Opções para processos de cluster NDB:
ndb-connectstring=192.168.3.102 # localização do servidor de gerenciamento

# mkdir /var/lib/mysql-cluster
# cd /var/lib/mysql-cluster
# vi config.ini
[ndbd padrão]
# Opções que afetam os processos ndbd em todos os nós de dados:
NoOfReplicas=2 # Número de réplicas de fragmentos
DataMemory=98M # Quanta memória alocar para armazenamento de dados

[ndb_mgmd]
# Opções do processo de gerenciamento:
HostName=192.168.3.102 # Nome do host ou endereço IP do nó de gerenciamento
DataDir=/var/lib/mysql-cluster # Diretório para arquivos de log do nó de gerenciamento

[não especificado]
# Opções para o nó de dados "A":
                                # (uma seção [ndbd] por nó de dados)
HostName=192.168.3.103 # Nome do host ou endereço IP
NodeId=2 # ID do nó para este nó de dados
DataDir=/var/lib/mysql/data # Diretório para os arquivos de dados deste nó de dados

[não especificado]
# Opções para o nó de dados "B":
HostName=192.168.3.104 # Nome do host ou endereço IP
NodeId=3 # ID do nó para este nó de dados
DataDir=/var/lib/mysql/data # Diretório para os arquivos de dados deste nó de dados

[mysqld]
# Opções do nó SQL:
HostName=192.168.3.102 # Nome do host ou endereço IP
                                # (conexões mysqld adicionais podem ser
                                # especificado para este nó para vários
                                # finalidades como executar ndb_restore)


┌──(root㉿ndb1)-[/var/lib/mysql-cluster]
└─# ndb_mgmd --initial -f /var/lib/mysql-cluster/config.ini
Servidor de gerenciamento de cluster MySQL mysql-9.2.0 ndb-9.2.0
AVISO: --ndb-connectstring é ignorado quando mgmd é iniciado com -f ou config-file.

┌──(root㉿ndb2)-[/var/lib/mysql-cluster]
└─# ndbd
2025-04-01 11:53:11 [ndbd] INFO -- Angel conectado a '192.168.3.102:1186'
2025-04-01 11:53:12 [ndbd] INFO -- Angel alocou nodeid: 2

┌──(root㉿ndb3)-[/var/lib/mysql-cluster]
└─# ndbd
2025-04-01 11:53:19 [ndbd] INFO -- Angel conectado a '192.168.3.102:1186'
2025-04-01 11:53:20 [ndbd] INFO -- ID de nó alocado pelo Angel: 3


┌──(root㉿ndb1)-[/var/lib/mysql-cluster]
└─# ndb_mgm
-- Cluster NDB -- Cliente de gerenciamento --
ndb_mgm> mostrar
Conectado ao servidor de gerenciamento na porta 1186 192.168.3.102 (usando texto não criptografado)
Configuração de cluster
---------------------
[ndbd(NDB)] 2 nó(s)
id=2 @192.168.3.103 (mysql-9.2.0 ndb-9.2.0, Grupo de nós: 0, *)
id=3 @192.168.3.104 (mysql-9.2.0 ndb-9.2.0, Grupo de nós: 0)

[ndb_mgmd(MGM)] 1 nó(s)
id=1 @192.168.3.102 (mysql-9.2.0 ndb-9.2.0)

[mysqld(API)] 1 nó(s)
id=4 (não conectado, aceitando conexão de 192.168.3.102)

┌──(root㉿ndb1)-[/var/lib/mysql-cluster]
└─# mysql -u root -p -e "selecione @@nomedohost"
Digite a senha:
+-------------------+
| @@nome do host |
+-------------------+
| ndb1.sqlhjalp.com |
+-------------------+

┌──(root㉿ndb2)-[/var/lib/mysql-cluster]
└─# mysql -u root -p -e "selecione @@nomedohost"
Digite a senha:
+-------------------+
| @@nome do host |
+-------------------+
| ndb2.sqlhjalp.com |
+-------------------+

┌──(root㉿ndb3)-[/var/lib/mysql-cluster]
└─# mysql -u root -p -e "selecione @@nomedohost"
Digite a senha:
+-------------------+
| @@nome do host |
+-------------------+
| ndb3.sqlhjalp.com |
+-------------------+

Servidor Percona

# cat /etc/rede/interfaces
 
auto ens18
iface ens18 inet estático
    endereço 192.168.3.105
    máscara de rede 255.255.255.0
    portal 192.168.3.1
    servidores de nomes DNS 8.8.8.8 8.8.4.4

# apt install curl gnupg gnupg2 lsb-release -y
# cd /usr/local/src/
# curl -O https://repo.percona.com/apt/percona-release_latest.generic_all.deb
# dpkg -i percona-release_latest.generic_all.deb
# percona-release enable-only ps-84-lts release
# percona-release habilitar ferramentas de liberação
# apt install percona-server-server

┌──(root㉿ps1)-[/usr/local/src]
└─# ps -ef |grep mysql
mysql 5832 1 0 11:58? 00:00:03 /usr/sbin/mysqld
raiz 5924 501 0 12:04 pts/1 00:00:00 grep --color=auto mysql

┌──(root㉿ps1)-[/usr/local/src]
└─# mysql -u root -p
Digite a senha:
Bem-vindo ao monitor MySQL. Os comandos terminam com ; ou \g.
Seu ID de conexão MySQL é 9
Versão do servidor: 8.4.4-4 Percona Server (GPL), versão '4', revisão '844fde07'

Copyright (c) 2009-2025 Percona LLC e/ou suas afiliadas
Copyright (c) 2000, 2025, Oracle e/ou suas afiliadas.

Oracle é uma marca registrada da Oracle Corporation e/ou seus
afiliadas. Outros nomes podem ser marcas registradas de seus respectivos
proprietários.

Digite 'help;' ou '\h' para obter ajuda. Digite '\c' para limpar a instrução de entrada atual.

Aglomerado Percona

# cat /etc/rede/interfaces
iface ens18 inet estático
    endereço 192.168.3.106
    máscara de rede 255.255.255.0
    portal 192.168.3.1
    servidores de nomes DNS 8.8.8.8 8.8.4.4

iface ens18 inet estático
    endereço 192.168.3.106
    máscara de rede 255.255.255.0
    portal 192.168.3.1
    servidores de nomes DNS 8.8.8.8 8.8.4.4

iface ens18 inet estático
    endereço 192.168.3.106
    máscara de rede 255.255.255.0
    portal 192.168.3.1
    servidores de nomes DNS 8.8.8.8 8.8.4.4

# apt install curl gnupg gnupg2 lsb-release -y
# cd /usr/local/src/
# curl -O https://repo.percona.com/apt/percona-release_latest.generic_all.deb
# dpkg -i percona-release_latest.generic_all.deb
# atualização do apt
# configuração percona-release pxc80
# apt install -y percona-xtradb-cluster

 
gato /etc/meu.cnf
[cliente]
soquete=/var/run/mysqld/mysqld.sock

[backup extra]
limite de arquivos abertos = 1000000

[mysqld]
id do servidor=1
datadir=/var/lib/mysql
soquete=/var/run/mysqld/mysqld.sock
log-error=/var/log/mysql/error.log
arquivo pid=/var/run/mysqld/mysqld.pid
caminho-de-log-seguro=/var/lib/arquivos-mysql/
# O período de expiração do log binário é de 604.800 segundos, o que equivale a 7 dias
binlog_expire_logs_seconds=604800

userstat = 1

 └─# cat /etc/my.cnf | grep criptografar
pxc-encrypt-cluster-traffic = DESLIGADO
 
┌──(raiz㉿pxc1)-[/]
└─# cat /etc/my.cnf | endereço grep
wsrep_cluster_address = gcomm://192.168.3.106,192.168.3.107,192.168.3.108
# Endereço IP do nó
wsrep_node_address=192.168.3.106

┌──(root㉿pxc1)-[/etc/mysql/conf.d]
└─# systemctl start mysql@bootstrap

mysql> mostrar status como 'wsrep_c%';
+--------------------------------------+--------------------------------------+
| Nome_da_variável | Valor |
+--------------------------------------+--------------------------------------+
| wsrep_cert_deps_distance | 0 |
| wsrep_commit_oooe | 0 |
| wsrep_commit_oool | 0 |
| janela_de_confirmação_do_wsrep | 0 |
| tamanho_do_índice_do_certificado_do_wsrep | 0 |
| contagem_de_bucket_de_certificação_wsrep | 1 |
| wsrep_causal_reads | 0 |
| intervalo_cert_wsrep | 0 |
| wsrep_cluster_weight | 1 |
| capacidades_do_cluster_do_wsrep | |
| ID de configuração do cluster wsrep | 1 |
| tamanho_do_cluster_wsrep | 1 |
| uuid_de_estado_do_cluster_wsrep | 71a6ebf4-0f20-11f0-b4eb-0a0f463a7185 |
| wsrep_cluster_status | Primário |
| wsrep_connected | LIGADO |
+--------------------------------------+--------------------------------------+
15 linhas em conjunto (0,00 seg)

┌──(root㉿pxc2)-[/etc]
└─# cat /etc/my.cnf | endereço grep
wsrep_cluster_address = gcomm://192.168.3.106,192.168.3.107,192.168.3.108
# Endereço IP do nó
wsrep_node_address=192.168.3.107

┌──(raiz㉿pxc2)-[/var/lib/mysql]
└─# rm -Rf *

┌──(raiz㉿pxc2)-[/var/lib/mysql]
└─# ls -tla
total 8
drwxr-x--- 2 mysql mysql 4096 1 de abr 13:36 .
drwxr-xr-x 26 root root 4096 1 de abr 12:34 ..

┌──(raiz㉿pxc2)-[/var/lib/mysql]
└─# systemctl iniciar mysql

┌──(root㉿pxc2)-[/etc]
└─# cat /etc/my.cnf | endereço grep
wsrep_cluster_address = gcomm://192.168.3.106,192.168.3.107,192.168.3.108
# Endereço IP do nó
wsrep_node_address=192.168.3.107
 ┌──(raiz㉿pxc3)-[/var/lib/mysql]
└─# rm -Rf *

┌──(raiz㉿pxc3)-[/var/lib/mysql]
└─# systemctl iniciar mysql


mysql> mostrar status como 'wsrep_c%';
+--------------------------------------+--------------------------------------+
| Nome_da_variável | Valor |
+--------------------------------------+--------------------------------------+
| wsrep_cert_deps_distance | 0 |
| wsrep_commit_oooe | 0 |
| wsrep_commit_oool | 0 |
| janela_de_confirmação_do_wsrep | 0 |
| tamanho_do_índice_do_certificado_do_wsrep | 0 |
| contagem_de_bucket_de_certificação_wsrep | 1 |
| wsrep_causal_reads | 0 |
| intervalo_cert_wsrep | 0 |
| wsrep_cluster_weight | 3 |
| capacidades_do_cluster_do_wsrep | |
| ID de configuração do cluster wsrep | 3 |
| tamanho_do_cluster_wsrep | 3 |
| uuid_de_estado_do_cluster_wsrep | 71a6ebf4-0f20-11f0-b4eb-0a0f463a7185 |
| wsrep_cluster_status | Primário |
| wsrep_connected | LIGADO |
+--------------------------------------+--------------------------------------+
15 linhas em conjunto (0,00 seg)

Configurar exportadores MySQL e Prometheus

por cada máquina...

apt install -y prometheus-mysqld-exporter
 
CRIAR USUÁRIO SE NÃO EXISTIR 'prometheus'@'localhost' IDENTIFICADO POR '<SENHAAQUI>'; 
mysql> mostrar concessões para 'prometheus'@'localhost';
+--------------------------------------------------------------------------------------------+
| Subsídios para prometheus@localhost |
+--------------------------------------------------------------------------------------------+
| CONCEDER SELEÇÃO, PROCESSO, REPLICAÇÃO CLIENTE EM *.* PARA `prometheus`@`localhost` |
+--------------------------------------------------------------------------------------------+
1 linha no conjunto (0,00 seg)

┌──(raiz㉿pxc1)-[~]
└─# ls -ltr /etc/mysql/debian.cnf
-rw-r--r-- 1 root root 50 1 de abril 16:52 /etc/mysql/debian.cnf

# vi /etc/default/prometheus-mysqld-exporter

systemctl reiniciar prometheus-mysqld-exporter.service

# systemctl restart prometheus-mysqld-exporter.service

Servidor Prometheus

root@prometheus:/etc/prometheus# vi prometheus.yml


  - nome_da_tarefa: mysqld-exporter
    configurações_estáticas:
      - alvos:
          - 'mysql1.sqlhjalp.com:9104'
          - 'mariadb1.sqlhjalp.com:9104'
          - 'ps1.sqlhjalp.com:9104'
          - 'pxc1.sqlhjalp.com:9104'
          - 'pxc2.sqlhjalp.com:9104'
          - 'pxc3.sqlhjalp.com:9104'
          - 'ndb1.sqlhjalp.com:9104'
          - 'ndb2.sqlhjalp.com:9104'
          - 'ndb3.sqlhjalp.com:9104'
        rótulos:
          país: EUA
          db_env: 'casa'
          ambiente: "demo"
          Linux: Debian
          nodeuse: servidor


mysql_up{ambiente="demonstração"}

Valor do Elemento
mysql_up{país="EUA",db_env="home",ambiente="demo",instância="mariadb1.sqlhjalp.com:9104",job="mysqld-exporter",linux="debian",nodeuse="servidor"} 1
mysql_up{país="EUA",db_env="home",ambiente="demo",instância="mysql1.sqlhjalp.com:9104",job="mysqld-exporter",linux="debian",nodeuse="servidor"} 1
mysql_up{país="EUA",db_env="home",ambiente="demo",instância="ndb1.sqlhjalp.com:9104",job="mysqld-exporter",linux="debian",nodeuse="servidor"} 1
mysql_up{país="EUA",db_env="home",ambiente="demo",instância="ndb2.sqlhjalp.com:9104",job="mysqld-exporter",linux="debian",nodeuse="servidor"} 1
mysql_up{país="EUA",db_env="home",ambiente="demo",instância="ndb3.sqlhjalp.com:9104",job="mysqld-exporter",linux="debian",nodeuse="servidor"} 1
mysql_up{país="EUA",db_env="home",ambiente="demo",instância="ps1.sqlhjalp.com:9104",job="mysqld-exporter",linux="debian",nodeuse="servidor"} 1
mysql_up{país="EUA",db_env="home",ambiente="demo",instância="pxc1.sqlhjalp.com:9104",job="mysqld-exporter",linux="debian",nodeuse="servidor"} 1
mysql_up{país="EUA",db_env="home",ambiente="demo",instância="pxc2.sqlhjalp.com:9104",job="mysqld-exporter",linux="debian",nodeuse="servidor"} 1
mysql_up{país="EUA",db_env="home",ambiente="demo",instância="pxc3.sqlhjalp.com:9104",job="mysqld-exporter",linux="debian",nodeuse="servidor"} 1

CONFIGURAÇÃO DA CONTA DO Vault

mysql> CRIAR FUNÇÃO SE NÃO EXISTIR vaultaccess;
mysql> GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, RELOAD, PROCESS, FILE, REFERENCES, INDEX, ALTER, SHOW DATABASES, SUPER, CREATE TEMPORARY BASES, LOCK TABLES, EXECUTE, CREATE VIEW, SHOW VIEW, CREATE USER, EVENT, TRIGGER, CREATE TABLESPACE, CREATE ROLE, DROP ROLE ON *.* TO `vaultaccess`@`%` WITH GRANT OPTION;
 
CRIAR USUÁRIO `vaultadmin`@`%` IDENTIFICADO POR '<PASSWORDHERE>' FUNÇÃO PADRÃO `vaultaccess`@`%` NÃO EXIGE NENHUMA SENHA EXPIRAR CONTA PADRÃO DESBLOQUEAR HISTÓRICO DE SENHAS INTERVALO DE REUTILIZAÇÃO DE SENHA PADRÃO SENHA PADRÃO EXIGE PADRÃO ATUAL ;
mysql> mostrar concessões para vaultadmin;

CRIE A FUNÇÃO SE NÃO EXISTIR SOMENTE LEITURA;
CONCEDER SELEÇÃO, EXECUTAR EM *.* PARA `READONLY`@`%` ;

Mariadb

MariaDB [(none)]> CRIAR USUÁRIO `vaultadmin`@`%` IDENTIFICADO POR '<SENHAAQUI>'; 
MariaDB [(none)]> CONCEDER SELECIONAR, INSERIR, ATUALIZAR, EXCLUIR, CRIAR, REMOVER, RECARREGAR, PROCESSAR, ARQUIVAR, REFERÊNCIAS, INDEXAR, ALTERAR, MOSTRAR BANCOS DE DADOS, SUPER, CRIAR TABELAS TEMPORÁRIAS, BLOQUEAR TABELAS, EXECUTAR, CRIAR VISUALIZAÇÃO, MOSTRAR VISUALIZAÇÃO, CRIAR USUÁRIO, EVENTO, GATILHO, CRIAR ESPAÇO DE TABELA EM *.* PARA `vaultadmin`@`%` COM OPÇÃO DE CONCESSÃO;

Mecanismo de banco de dados Vault - repetido por instância de banco de dados

vault escreve banco de dados/configuração/plugin MYSQL nome_do_plugin=mysql-database-plugin url_de_conexão="{{nome_de_usuário}}:{{senha}}@tcp(mysql1.sqlhjalp.com:3306)/" funções_permitidas="minha-função" nome_de_usuário="vaultadmin" senha="<SENHA AQUI>"

leitura do cofre banco de dados/configuração/MYSQL
Valor-chave
--- -----
funções_permitidas []
mapa de detalhes da conexão [backend: url_de_conexão_do_banco_de_dados: {{nome_de_usuário}}: {{senha}} @ tcp (mysql1.sqlhjalp.com:3306) / tempo_de_vida_máximo_da_conexão: 0 s conexões_ociosas_máximas: 0 conexões_abertas_máximas: 4 nome_de_usuário: administrador_do_cofre]
desabilitar_rotação_automatizada falso
política_de_senha n/a
nome_do_plugin plugin-de-banco-de-dados-mysql
versão_do_plugin n/a
credenciais_raiz_rotação_de_instruções []
período_de_rotação 0s
programação de rotação n/a
janela_de_rotação 0
skip_static_role_import_rotation falso
verificar_conexão verdadeiro

 leitura do cofre banco de dados/funções/DEMOREADONLY
Valor-chave
--- -----
creation_statements [CRIAR USUÁRIO '{{name}}'@'%' IDENTIFICADO POR '{{password}}';
CONCEDER SELEÇÃO EM *.* PARA '{{name}}'@'%';]
credencial_tipo senha
nome_do_banco_de_dados MYSQL
default_ttl 1h
max_ttl 24h
renovar_declarações []
declarações_de_revocação [EXCLUIR USUÁRIO SE EXISTIR '{{name}}'@'%';]
instruções de rollback []

Exemplo de usuário dinâmico do Vault

leitura do cofre banco de dados/credenciais/DEMOREADONLY
Valor-chave
--- -----
lease_id banco de dados/creds/DEMOREADONLY/1SACMdnTGXseMewbA6ek1T42
duração do arrendamento 1h
lease_renewable verdadeiro
senha -piWu8YfOFxUkAqR347a
nome de usuário v-userpass-k-DEMOREADON-HFRYaNGE


mysql> mostrar concessões para 'v-userpass-k-DEMOREADON-HFRYaNGE'@'%';
+--------------------------------------------------------------------------+
| Subsídios para v-userpass-k-DEMOREADON-HFRYaNGE@% |
+--------------------------------------------------------------------------+
| CONCEDER SELEÇÃO EM *.* PARA `v-userpass-k-DEMOREADON-HFRYaNGE`@`%` |
+--------------------------------------------------------------------------+
1 linha no conjunto (0,00 seg)

Além disso.....

POSTGRESQL

https://docs.vultr.com/how-to-install-postgresql-on-debian-12

# apt install -y postgresql-common
# /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh
# atualização do apt
# política apt-cache postgresql
# apt install postgresql -y
# systemctl iniciar postgresql
# status do sistema ctl postgresql
# sudo -u postgres psql sudo -u postgres psql
# postgres=# ALTER ROLE postgres COM SENHA CRIPTOGRAFADA '<senha>';
ALTERAR PAPEL
#

Banco de Dados Oracle XE

wget https://download.oracle.com/otn-pub/otn_software/db-express/oracle-database-xe-21c-1.0-1.ol8.x86_64.rpm
wget https://yum.oracle.com/repo/OracleLinux/OL8/appstream/x86_64/getPackage/oracle-database-preinstall-21c-1.0-1.el8.x86_64.rpm

# yum install ./oracle-database-xe-21c-1.0-1.ol8.x86_64.rpm ./oracle-database-preinstall-21c-1.0-1.el8.x86_64.rpm

# /etc/init.d/oracle-xe-21c configure

$ exportar ORACLE_SID=XE
$ export ORAENV_ASK=NO
$ . /opt/oracle/produto/21c/dbhomeXE/bin/oraenv

ORACLE_HOME = [] ? /opt/oracle/produto/21c/dbhomeXE
A base Oracle foi definida como /opt/oracle


[root@localhost ~]# echo $ORACLE_HOME
/opt/oracle/produto/21c/dbhomeXE
[root@localhost ~]# cd $ORACLE_HOME
[root@localhost dbhomeXE]# senha
/opt/oracle/produto/21c/dbhomeXE

[root@localhost dbhomeXE]# cd bin

[root@localhost bin]# sqlplus /nolog

SQL*Plus: Versão 21.0.0.0.0 - Produção em qui, 3 de abr de 2025, 10:35:15
Versão 21.3.0.0.0

Copyright (c) 1982, 2021, Oracle. Todos os direitos reservados.

SQL>

SQL> CONECTAR SYS COMO SYSDBA
Digite a senha:
Conectado.
SQL>

SQL> definir tamanho da linha 1500
SQL> selecione nome de usuário, status_da_conta de DBA_USERS;

STATUS_DA_CONTA_DE_NOME_DE_USUÁRIO
-------------------------------------------------------------------------------------------------------------------------------- --------------------------------
SISTEMA ABERTO
SISTEMA ABERTO
XS$NULL BLOQUEADO
OJVMSYS BLOQUEADO
LBACSYS BLOQUEADO
OUTLN BLOQUEADO
DBSNMP BLOQUEADO
APPQOSSYS BLOQUEADO
DBSFWUSER BLOQUEADO
GGSYS BLOQUEADO
ANÔNIMO BLOQUEADO
 
SQL> SAIR
Desconectado do Oracle Database 21c Express Edition Release 21.0.0.0.0 - Produção
Versão 21.3.0.0.0

SQLSERVER

# curl -o /etc/yum.repos.d/mssql-server.repo https://packages.microsoft.com/config/rhel/8/mssql-server-2022.repo
# yum install -y mssql-server
# /opt/mssql/bin/mssql-conf configuração
# status do sistema ctl mssql-server

curl https://packages.microsoft.com/config/rhel/8/prod.repo | sudo tee /etc/yum.repos.d/mssql-release.repo

# yum install -y mssql-tools18 unixODBC-devel

# yum check-update
# yum update mssql-tools18

eco 'exportar PATH="$PATH:/opt/mssql-tools18/bin"' >> ~/.bash_profile
fonte ~/.bash_profile

# /opt/mssql/bin/mssql-conf definir-sa-senha
Digite a senha do administrador do sistema do SQL Server:
Confirme a senha do administrador do sistema do SQL Server:
Configurando o SQL Server...

# sqlcmd -S localhost -No -U sa

# sqlcmd -S localhost -No -U sa
Senha:
1> CRIAR BANCO DE DADOS TestDB;
2> SELECIONE Nome DE sys.databases;
3> VAI
Nome
--------------------------------------------------------------------------------------------------------------------------------
mestre
banco de dados temporário
modelo
msdb
TestDB

(5 linhas afetadas)


USE TestDB;

CRIAR TABELA dbo.Inventory
(
    id INT, nome NVARCHAR (50), quantidade INT, CHAVE PRIMÁRIA (id)
);
POXA

INSERIR EM dbo.Inventory VALORES (1, 'banana', 150);
INSERIR EM dbo.Inventory VALORES (2, 'laranja', 154);

IR


SELECIONE * DE dbo.Inventory ONDE quantidade > 152;
IR

1> SELECIONE * DE dbo.Inventory;
2> VAI
id nome quantidade
----------- -------------------------------------------------- -----------
          1 banana 150
          2 laranja 154

MONGODB - PERCONA

https://docs.percona.com/percona-server-for-mongodb/8.0/install/apt.html

# apt install -y gnupg2 gnupg curl
# wget https://repo.percona.com/apt/percona-release_latest.$(lsb_release -sc)_all.deb
# dpkg -i percona-release_latest.$(lsb_release -sc)_all.deb
# percona-release --help | grep psmdb
psmdb36 psmdb40 psmdb42 psmdb44 psmdb60 psmdb50 psmdb70 psmdb80 psmdb40
psmdb60pro psmdb70pro
psmdb-70-pro psmdb-60-pro
psmdb-36 psmdb-40 psmdb-42 psmdb-44 psmdb-60 psmdb-50 psmdb-70 psmdb-80 psmdb40
psmdb-60-pro psmdb-70-pro
psmdb-70-pro psmdb-60-pro

# percona-release habilita a liberação do psmdb-80
# atualização do apt
# apt install percona-server-mongodb
# apt-cache madison percona-server-mongodb
# ls -ltr /etc/mongod.conf
-rw-r--r-- 1 root root 1403 11 de fev 23:56 /etc/mongod.conf

# vi /etc/systemd/system/enable-transparent-huge-pages.service
# cat /etc/systemd/system/enable-transparent-huge-pages.service
[Unidade]
Descrição=Habilitar páginas enormes transparentes (THP)
DependênciasPadrão=não
Depois=sysinit.target local-fs.target
Antes=mongod.service

[Serviço]
Tipo=one-shot
ExecStart=/bin/sh -c 'echo sempre | tee /sys/kernel/mm/transparent_hugepage/enabled > /dev/null && echo defer+madvise | tee /sys/kernel/mm/transparent_hugepage/defrag > /dev/null && echo 0 | tee /sys/kernel/mm/transparent_hugepage/khugepaged/max_ptes_none > /dev/null && echo 1 | tee /proc/sys/vm/overcommit_memory > /dev/null'

[Instalar]
ProcuradoPor=básico.alvo

# systemctl daemon-reload
# systemctl start habilitar-páginas-enormes-transparentes
# cat /sys/kernel/mm/transparent_hugepage/enabled && cat /sys/kernel/mm/transparent_hugepage/defrag && cat /sys/kernel/mm/transparent_hugepage/khugepaged/max_ptes_none && cat /proc/sys/vm/overcommit_memory
[sempre] madvise nunca
sempre adiar [adiar+madvise] madvise nunca
0
1

# systemctl enable habilitar-páginas-enormes-transparentes
# ls -lr /var/lib/mongodb/
total 0


# systemctl start mongod
# status do sistema ctl mongod
# mongosh
ID de registro atual do Mongosh: 67ed4eb0cd874b942d98ebcf
Conectando a: mongodb://127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+2.3.2
MongoNetworkError: conectar ECONNREFUSED 127.0.0.1:27017

MONGODB

https://www.mongodb.com/docs/manual/tutorial/install-mongodb-on-debian/

 
# apt-get install gnupg curl
# curl -fsSL https://www.mongodb.org/static/pgp/server-8.0.asc | \
   sudo gpg -o /usr/share/keyrings/mongodb-server-8.0.gpg \
  --querido
# echo "deb [ assinado-por=/usr/share/keyrings/mongodb-server-8.0.gpg ] http://repo.mongodb.org/apt/debian bookworm/mongodb-org/8.0 main" | sudo tee /etc/apt/sources.list.d/mongodb-org-8.0.list
# apt-get atualização
# apt-get install -y mongodb-org
# systemctl daemon-reload
# ulimit -c ilimitado
# ulimit -n 64000
# ulimit -f ilimitado
# ulimit -t ilimitado
# ulimit -l ilimitado
# ulimit -m ilimitado
# ulimit -u 64000
# ulimit -a
tempo não bloqueador em tempo real (microssegundos, -R) ilimitado
tamanho do arquivo principal (blocos, -c) ilimitado
tamanho do segmento de dados (kbytes, -d) ilimitado
prioridade de agendamento (-e) 0
tamanho do arquivo (blocos, -f) ilimitado
sinais pendentes (-i) 15471
memória máxima bloqueada (kbytes, -l) ilimitada
tamanho máximo de memória (kbytes, -m) ilimitado
abrir arquivos (-n) 64000
tamanho do tubo (512 bytes, -p) 8
Filas de mensagens POSIX (bytes, -q) 819200
prioridade em tempo real (-r) 0
tamanho da pilha (kbytes, -s) 8192
tempo de CPU (segundos, -t) ilimitado
máximo de processos de usuário (-u) 64000
memória virtual (kbytes, -v) ilimitada
bloqueios de arquivo (-x) ilimitados

# systemctl start mongod

# wget https://repo.percona.com/apt/percona-release_latest.$(lsb_release -sc)_all.deb
# dpkg -i percona-release_latest.$(lsb_release -sc)_all.deb
# percona-release --help | grep psmdb
psmdb36 psmdb40 psmdb42 psmdb44 psmdb60 psmdb50 psmdb70 psmdb80 psmdb40
psmdb60pro psmdb70pro
psmdb-70-pro psmdb-60-pro
psmdb-36 psmdb-40 psmdb-42 psmdb-44 psmdb-60 psmdb-50 psmdb-70 psmdb-80 psmdb40
psmdb-60-pro psmdb-70-pro
psmdb-70-pro psmdb-60-pro

# percona-release habilita a liberação do psmdb-80
# atualização do apt
# apt install percona-server-mongodb
# apt-cache madison percona-server-mongodb
# ls -ltr /etc/mongod.conf
-rw-r--r-- 1 root root 1403 11 de fev 23:56 /etc/mongod.conf

# vi /etc/systemd/system/enable-transparent-huge-pages.service
# cat /etc/systemd/system/enable-transparent-huge-pages.service
[Unidade]
Descrição=Habilitar páginas enormes transparentes (THP)
DependênciasPadrão=não
Depois=sysinit.target local-fs.target
Antes=mongod.service

[Serviço]
Tipo=one-shot
ExecStart=/bin/sh -c 'echo sempre | tee /sys/kernel/mm/transparent_hugepage/enabled > /dev/null && echo defer+madvise | tee /sys/kernel/mm/transparent_hugepage/defrag > /dev/null && echo 0 | tee /sys/kernel/mm/transparent_hugepage/khugepaged/max_ptes_none > /dev/null && echo 1 | tee /proc/sys/vm/overcommit_memory > /dev/null'

[Instalar]
ProcuradoPor=básico.alvo

# systemctl daemon-reload
# systemctl start habilitar-páginas-enormes-transparentes
# cat /sys/kernel/mm/transparent_hugepage/enabled && cat /sys/kernel/mm/transparent_hugepage/defrag && cat /sys/kernel/mm/transparent_hugepage/khugepaged/max_ptes_none && cat /proc/sys/vm/overcommit_memory
[sempre] madvise nunca
sempre adiar [adiar+madvise] madvise nunca
0
1

# systemctl enable habilitar-páginas-enormes-transparentes
# ls -lr /var/lib/mongodb/
total 0


# systemctl start mongod
# status do sistema ctl mongod
# mongosh
ID de registro atual do Mongosh: 67ed4eb0cd874b942d98ebcf
Conectando a: mongodb://127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+2.3.2
MongoNetworkError: conectar ECONNREFUSED 127.0.0.1:27017

CASSANDRA

https://docs.vultr.com/how-to-install-apache-cassandra-on-debian-12

# atualização do apt
# cat /etc/apt/source.list
deb https://deb.debian.org/debian bookworm principal firmware não livre
deb http://deb.debian.org/debian bookworm-updates principal
deb http://deb.debian.org/debian-security bookworm-security principal
deb http://deb.debian.org/debian instável principal não livre contrib

# atualização do apt
# apt install curl
# apt install openjdk-17-jdk
# java --versão
openjdk 17.0.14 21/01/2025
Ambiente de execução OpenJDK (compilação 17.0.14+7-Debian-1deb12u1)
VM do servidor OpenJDK de 64 bits (compilação 17.0.14+7-Debian-1deb12u1, modo misto, compartilhamento)

# echo "deb [assinado por=/etc/apt/keyrings/apache-cassandra.asc] https://debian.cassandra.apache.org 41x main" | sudo tee -a /etc/apt/sources.list.d/cassandra.sources.list
# curl -o /etc/apt/keyrings/apache-cassandra.asc https://downloads.apache.org/cassandra/KEYS
# atualização do apt
# apt install cassandra

# ls -lr /etc/cassandra/cassandra.yaml
-rw-r--r-- 1 root root 91468 27 de janeiro 07:28 /etc/cassandra/cassandra.yaml

# vi /etc/cassandra/cassandra.yaml
# systemctl reiniciar cassandra

# ls -lr /var/log/cassandra/
total 0

# status do systemctl cassandra
# status do nodetool
nodetool: Falha ao conectar a '127.0.0.1:7199' - ConnectException: 'Conexão recusada'.

# cqlsh -u cassandra -p cassandra

Aviso: Usar uma senha na interface de linha de comando pode ser inseguro.
Recomendação: use o arquivo de credenciais para fornecer a senha com segurança.

Erro de conexão: ('Não foi possível conectar a nenhum servidor', {'127.0.0.1:9042': ConnectionRefusedError(111, "Tentativa de conectar a [('127.0.0.1', 9042)]. Último erro: Conexão recusada")})

Pages

sábado, 21 de fevereiro de 2026

MySQL + Neo4j para Workloads de IA: Por Que Bancos de Dados Relacionais Ainda Importam

A Arquitetura

O Schema do MySQL

Padrões de Query

A Camada Neo4j

Como Eles Funcionam Juntos

Por Que Não Apenas Bancos de Dados Vetoriais?

MCP e o Futuro

Notas de Produção

Quando Usar Cada Um

Resumo

Funções JSON do MySQL 8.0: Exemplos Práticos e Indexação

Ambiente

Configurando uma Tabela de Teste

Extração Básica: JSON_VALUE vs. JSON_EXTRACT

Índices Multi-Valorizados: A Verdadeira Revolução

Aggregating and Transforming JSON

Verificando SHOW STATUS Após Consultas Pesadas em JSON

Observações Práticas

Resumo

quinta-feira, 3 de julho de 2025

Análise de MySQL: Com uma Ferramenta CLI Potencializada por IA

Análise de MySQL: Com uma Ferramenta CLI Potencializada por IA

O Problema

Uma Abordagem Baseada em CLI

A Ferramenta: AIMLAPI CLI

Recursos do Script

Exemplo: A Tabela City

O Comando

Resultados

Análise do Claude Sonnet 4

Análise do Grok 3 Beta

Análise do GPT-4o

O Poder da Análise Multi-Modelo

Além do MySQL: Outros Exemplos de CLI

Administração do Sistema

Análise de Arquivos e Diretórios

Análise de Logs

Implementando o Fluxo de Trabalho

Instruções de Configuração

Padrões de Uso Prático

Análise Rápida de Tabela

Comparar Diferentes Perspectivas de Modelos

Analisar Múltiplas Tabelas

Análise de Índices

Análise de Performance de Consultas

Por Que AIMLAPI Torna Isto Possível para DBAs

Guia de Seleção de Modelos

Técnicas Avançadas

Prompts de Sistema Personalizados

Relatórios Automatizados

Fluxo de Trabalho de Otimização de Performance

Benefícios Reais desta Abordagem

Dicas para Melhores Resultados

Começando Hoje

Usuários Windows (Opção Rápida)

terça-feira, 15 de abril de 2025

LABORATÓRIO EM CASA

Debian BASE

MariaDB 11 Rolling

Inovação MySQL

MySQL Innovation NDB CLuster

Servidor Percona

Aglomerado Percona

Configurar exportadores MySQL e Prometheus

Servidor Prometheus

CONFIGURAÇÃO DA CONTA DO Vault

Mecanismo de banco de dados Vault - repetido por instância de banco de dados

Exemplo de usuário dinâmico do Vault

POSTGRESQL

Banco de Dados Oracle XE

SQLSERVER

MONGODB - PERCONA

MONGODB

CASSANDRA