SGBDs Relacionais & In-Memory Debian 13 (Trixie) MariaDB, PostgreSQL & Redis Backups Lógicos & Rotação

Sistemas de Banco de Dados no Debian 13

Guia aprofundado para planejamento, instalação, ajuste fino e proteção de sistemas de gerenciamento de banco de dados (SGBDs) no Debian GNU/Linux 13 (Trixie). Domine a administração do MariaDB 11.4 com hardening de produção e tuning de InnoDB; implemente o PostgreSQL 17/16 com controle estrito de autenticação em pg_hba.conf, roles e pooling; acelere aplicações com cache em memória e persistência no Redis Server; e estabeleça rotinas robustas de backup automatizado a quente com mysqldump e pg_dump com compressão e retenção rotativa.

Arquitetura de Gerenciadores de Banco de Dados no Linux

Bancos de dados representam o núcleo de persistência e valor de qualquer infraestrutura corporativa. No Debian 13, a escolha da tecnologia deve equilibrar conformidade transacional estrita (ACID), capacidade de concorrência e velocidade de resposta:

1. Relacionais (RDBMS)

MariaDB e PostgreSQL garantem propriedades ACID completas, integridade referencial, transações concorrentes seguras (MVCC) e suporte avançado à linguagem SQL.

2. Cache em Memória

O Redis armazena estruturas em memória RAM com latência inferior a 1 milissegundo, aliviando até 80% das consultas aos bancos relacionais para sessões web e filas.

3. Buffer Pools & WAL

Mecanismos de Write-Ahead Logging (WAL) e alocação criteriosa de pools de memória (InnoDB Buffer Pool e Shared Buffers) garantem recuperação pós-falha e alto throughput.

4. Defesa e Resiliência

Autenticação forte com SCRAM-SHA-256, isolamento de rede por IP/Soquete, execução com contas de sistema sem privilégios e rotinas consistentes de backup.

Matriz Comparativa dos Sistemas de Banco de Dados
SGBD Modelo de Dados Porta Padrão Mecanismo Principal Concorrência Melhor Caso de Uso
MariaDB Relacional SQL TCP 3306 InnoDB / Aria Thread Pool / Conexões Aplicações Web (LAMP/LEMP), WordPress, e-commerces, sistemas corporativos gerais.
PostgreSQL Objeto-Relacional SQL TCP 5432 Motor Unificado / WAL MVCC (Process-per-connection) Sistemas complexos de ERP/CRM, dados geoespaciais (PostGIS), conformidade estrita e BI.
Redis Chave-Valor In-Memory TCP 6379 RAM + Snapshots RDB/AOF Event-Loop Assíncrono Gerenciamento de sessões, cache de páginas, filas de mensagens (Pub/Sub) e placares.
Índice dos Tutoriais de Banco de Dados

Navegue diretamente para cada um dos tutoriais práticos deste módulo técnico:

1 Instalação e Hardening do MariaDB / MySQL
MariaDB Versão 11.4+ (LTS) Hardening Defensivo • InnoDB Tuning • UTF8MB4
Fundamentação Teórica

O MariaDB é o sistema gerenciador de banco de dados relacional padrão no Debian desde o Debian 9 Stretch, atuando como um substituto totalmente compatível e aprimorado (*drop-in replacement*) do MySQL clássico.

Segurança e Arquitetura de Autenticação no Debian 13:

  • Autenticação por Socket Unix (unix_socket): Por padrão no Debian, a conta root do MariaDB não possui senha definida porque utiliza o plugin unix_socket. Isso significa que qualquer usuário com privilégios de sudo no terminal pode executar sudo mariadb e obter acesso administrativo imediato. Para aplicações e conexões remotas, deve-se criar usuários exclusivos com credenciais fortes e plugins de senha.
  • Hardening Pós-Instalação: Uma instalação virgem possui riscos potenciais que devem ser mitigados: usuários anônimos que permitem conexão sem identificador, banco de testes público (test) acessível por qualquer conexão e escuta desnecessária em interfaces de rede públicas.
  • Mecanismo de Armazenamento InnoDB: O InnoDB é o engine padrão compatível com ACID. O parâmetro mais crítico de desempenho é o innodb_buffer_pool_size, que define a quantidade de memória RAM dedicada a reter páginas de dados e índices em memória. Em servidores dedicados a banco de dados, recomenda-se alocar entre 60% e 70% da memória RAM física para o buffer pool.
Roteiro Prático: Instalação, Blindagem e Criação de Bases
terminal — Debian 13
# 1. Instalar o servidor e cliente MariaDB
sudo apt update && sudo apt install -y mariadb-server mariadb-client

# 2. Executar script de hardening automatizado (segurança essencial)
sudo mariadb-secure-installation
# Respostas recomendadas para ambiente corporativo:
# - Switch to unix_socket authentication: [N] (já ativo por padrão)
# - Change the root password: [Y] (defina uma senha administrativa forte)
# - Remove anonymous users: [Y] (remover usuários anônimos)
# - Disallow root login remotely: [Y] (proibir login remoto do root)
# - Remove test database and access to it: [Y] (remover base de testes)
# - Reload privilege tables now: [Y] (recarregar permissões)

# 3. Aplicar otimizações de produção em /etc/mysql/mariadb.conf.d/60-custom-tuning.cnf
sudo tee /etc/mysql/mariadb.conf.d/60-custom-tuning.cnf << 'END_CONF'
[mysqld]
# Escutar apenas localmente ou na interface interna de rede
bind-address            = 127.0.0.1

# Padronizacao rigorosa para caracteres Unicode completos (acentos e emojis)
character-set-server    = utf8mb4
collation-server        = utf8mb4_unicode_ci

# Limite de conexões e conexões simultâneas
max_connections         = 150
max_connect_errors      = 1000

# Tuning essencial do InnoDB (ajuste o buffer_pool_size para 60% da RAM da VM)
innodb_buffer_pool_size = 1G
innodb_log_file_size    = 256M
innodb_flush_log_at_trx_commit = 1
innodb_flush_method     = O_DIRECT
END_CONF

# 4. Reiniciar o serviço para carregar as otimizações
sudo systemctl restart mariadb

# 5. Criar banco de dados corporativo e usuário com privilégios restritos
sudo mariadb << 'END_SQL'
-- Criar banco com charset moderno
CREATE DATABASE app_corporativa CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

-- Criar usuário com senha forte para acesso local
CREATE USER 'usuario_app'@'localhost' IDENTIFIED BY 'SenhaForteApp2026!';

-- Conceder apenas os privilégios estritamente necessários para a aplicação
GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, INDEX, ALTER, LOCK TABLES 
ON app_corporativa.* TO 'usuario_app'@'localhost';

-- Aplicar mudanças de privilégios
FLUSH PRIVILEGES;
END_SQL
Validação e Verificação
validação — conexão e parâmetros
# Testar conexão com a conta restrita criada
mariadb -u usuario_app -p'SenhaForteApp2026!' -D app_corporativa -e "STATUS;"

# Inspecionar o tamanho alocado para o InnoDB Buffer Pool
mariadb -u usuario_app -p'SenhaForteApp2026!' -e "SHOW VARIABLES LIKE 'innodb_buffer_pool_size';"

# Confirmar a porta de escuta TCP 3306
ss -tlpn | grep 3306
2 Instalação e Configuração do PostgreSQL
PostgreSQL Versão 17 / 16 Autenticação pg_hba.conf • SCRAM-SHA-256 • Roles
Fundamentação Teórica

O PostgreSQL é amplamente consagrado como o sistema gerenciador de banco de dados relacional de código aberto mais avançado do mundo, possuindo suporte nativo a tipos JSONB, índices parciais, transações completas e conformidade estrita aos padrões SQL.

Segurança Granular no Arquivo pg_hba.conf:
A camada de Host-Based Authentication (HBA) do PostgreSQL define permissões de conexão com granularidade máxima. Cada linha especifica:

  • Tipo de Conexão: local (socket Unix local) ou host (TCP/IP com ou sem TLS).
  • Bancos de Dados & Usuários: Aplica a regra a bases específicas ou globais (all).
  • Origem de Rede: Endereço IP com máscara CIDR autorizada (ex: 127.0.0.1/32 ou 192.168.56.0/24).
  • Método Criptográfico: peer (valida o usuário do sistema operacional Linux que abriu o socket) e scram-sha-256 (o padrão moderno e seguro baseado em desafio e resposta criptográfica que substituiu o obsoleto MD5).

Parâmetros Fundamentais de Memória:

  • shared_buffers: Memória RAM compartilhada reservada para cache de páginas de tabelas e índices (recomenda-se entre 25% e 40% da memória RAM do sistema).
  • work_mem: Memória alocada para cada operação individual de ordenação interna (ORDER BY, DISTINCT) antes de recorrer ao disco temporário.
Roteiro Prático: Instalação, Configuração de Acesso e Criação de Roles
terminal — Debian 13
# 1. Instalar o PostgreSQL e pacote de extensões e módulos adicionais
sudo apt update && sudo apt install -y postgresql postgresql-contrib libpq-dev

# 2. Identificar a versão instalada e caminho do cluster
psql --version
# No Debian 13 os arquivos ficam tipicamente em /etc/postgresql/17/main/ (ou 16/main/)
PG_VER=$(pg_lsclusters -h | awk '{print $1}' | head -n1)

# 3. Configurar autenticação moderna SCRAM-SHA-256 no /etc/postgresql/${PG_VER}/main/pg_hba.conf
sudo tee /etc/postgresql/${PG_VER}/main/pg_hba.conf << 'END_HBA'
# TYPE  DATABASE        USER            ADDRESS                 METHOD
# Conexão administrativa local via socket Unix (usuário postgres do SO)
local   all             postgres                                peer

# Conexões locais locais de aplicações via socket Unix com senha
local   all             all                                     scram-sha-256

# Conexões locais via loopback TCP/IP IPv4 e IPv6
host    all             all             127.0.0.1/32            scram-sha-256
host    all             all             ::1/128                 scram-sha-256

# Conexões autorizadas da sub-rede local corporativa
host    all             all             192.168.56.0/24         scram-sha-256
END_HBA

# 4. Ajustar parâmetros essenciais de tuning no postgresql.conf
sudo sed -i "s/#listen_addresses = 'localhost'/listen_addresses = '127.0.0.1,192.168.56.10'/" /etc/postgresql/${PG_VER}/main/postgresql.conf
sudo sed -i "s/shared_buffers = 128MB/shared_buffers = 512MB/" /etc/postgresql/${PG_VER}/main/postgresql.conf
sudo sed -i "s/#work_mem = 4MB/work_mem = 16MB/" /etc/postgresql/${PG_VER}/main/postgresql.conf

# 5. Reiniciar o serviço para efetivar as configurações
sudo systemctl restart postgresql

# 6. Criar Role de aplicação e Banco de Dados com proprietário atribuído
sudo -u postgres psql << 'END_PSQL'
-- Criar role de login com senha forte criptografada em SCRAM-SHA-256
CREATE ROLE usuario_pg WITH LOGIN PASSWORD 'SenhaSeguraPG2026!';

-- Criar banco corporativo com encoding UTF-8
CREATE DATABASE banco_corporativo WITH OWNER = usuario_pg ENCODING = 'UTF8';

-- Conectar ao banco e habilitar extensão para suporte a UUID v4
\c banco_corporativo
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
CREATE EXTENSION IF NOT EXISTS "pgcrypto";
END_PSQL
Validação e Verificação
validação — psql e escuta
# Testar autenticação via TCP/IP informando a senha criada
PGPASSWORD='SenhaSeguraPG2026!' psql -U usuario_pg -d banco_corporativo -h 127.0.0.1 -c "\conninfo"

# Validar se as extensões UUID estão instaladas e operacionais
PGPASSWORD='SenhaSeguraPG2026!' psql -U usuario_pg -d banco_corporativo -h 127.0.0.1 -c "SELECT uuid_generate_v4();"

# Confirmar escuta da porta TCP 5432
ss -tlpn | grep 5432
3 Servidor Redis Cache em Memória
Redis In-Memory Key-Value Despejo LRU • Persistência AOF/RDB • requirepass
Fundamentação Teórica

O Redis (Remote Dictionary Server) é um armazenamento de estrutura de dados em memória de altíssimo desempenho, frequentemente utilizado como cache intermediário de consultas, gerenciador de sessões de usuários web e broker de mensageria (Pub/Sub e Streams).

Parâmetros Críticos de Estabilidade e Segurança:

  • Controle de Memória e Política de Despejo (Eviction): Sem um limite configurado, o Redis pode consumir toda a memória RAM física da máquina, acionando o temido *OOM Killer* do kernel que pode derrubar o sistema. O parâmetro maxmemory define um teto rígido e o maxmemory-policy allkeys-lru instrui o Redis a descartar automaticamente as chaves menos recentemente utilizadas (LRU) quando o limite for atingido, funcionando como um cache perfeito.
  • Persistência Dupla (RDB vs AOF):
    • RDB (Snapshots Pontuais): Grava imagens compactadas de todo o banco em intervalos de tempo configuráveis (baixo impacto de I/O em tempo de execução).
    • AOF (Append Only File): Grava cada comando de escrita recebido em um arquivo sequencial contínuo, assegurando durabilidade máxima de dados caso ocorra uma reinicialização não programada.
  • Ajustes de Kernel no Linux: O Redis executa o processo BGSAVE para gravação de snapshots em segundo plano utilizando a chamada fork(). O kernel Linux deve estar ajustado com vm.overcommit_memory = 1 para permitir a duplicação virtual do espaço de endereçamento sem erros de falta de memória.
Roteiro Prático: Instalação, Tuning de Kernel e Autenticação
terminal — Debian 13
# 1. Instalar o servidor e ferramentas de linha de comando do Redis
sudo apt update && sudo apt install -y redis-server redis-tools

# 2. Configurar os parâmetros do Kernel Linux em /etc/sysctl.d/99-redis.conf
sudo tee /etc/sysctl.d/99-redis.conf << 'END_SYSCTL'
# Permite overcommit de memória para operações seguras de fork do Redis
vm.overcommit_memory = 1

# Aumenta a fila de conexões pendentes para absorver picos de tráfego
net.core.somaxconn = 65535
END_SYSCTL
sudo sysctl --system

# 3. Ajustar segurança, senhas e limites no arquivo /etc/redis/redis.conf
sudo tee -a /etc/redis/redis.conf << 'END_REDIS'

# ==============================================================================
# CONFIGURAÇÕES DE PRODUÇÃO - MORAIS.ETI.BR
# ==============================================================================
# Escutar apenas localmente
bind 127.0.0.1 ::1
protected-mode yes

# Autenticação obrigatória com senha complexa
requirepass SenhaSeguraRedisCache2026!

# Limite máximo de memória RAM e política de expiração automática
maxmemory 512mb
maxmemory-policy allkeys-lru

# Persistência híbrida AOF (Append Only File a cada segundo)
appendonly yes
appendfsync everysec
END_REDIS

# 4. Reiniciar e habilitar o serviço Redis
sudo systemctl restart redis-server
sudo systemctl enable redis-server
Validação e Verificação
validação — redis-cli
# 1. Testar autenticação e comando PING
redis-cli -a 'SenhaSeguraRedisCache2026!' ping
# Saída esperada: PONG

# 2. Testar gravação de chave com tempo de expiração (TTL de 60 segundos)
redis-cli -a 'SenhaSeguraRedisCache2026!' set chave_teste "Debian 13 Cache OK" EX 60
redis-cli -a 'SenhaSeguraRedisCache2026!' get chave_teste
redis-cli -a 'SenhaSeguraRedisCache2026!' ttl chave_teste

# 3. Inspecionar o consumo de memória RAM do Redis
redis-cli -a 'SenhaSeguraRedisCache2026!' info memory | grep -E '(used_memory_human|maxmemory_human)'
4 Rotinas de Backup Automatizado (mysqldump / pg_dump)
Backups Automação com Cron Consistência Transacional • Compressão gzip • Retenção Rotativa
Fundamentação Teórica

A integridade de um banco de dados reside na confiabilidade de suas cópias de segurança. Backups efetuados sem garantias de consistência transacional podem gerar dumps corrompidos com tabelas incompletas e estados inconsistentes.

Princípios Técnicos para Cópias Lógicas Confiáveis:

  • Consistência sem Bloqueio (--single-transaction no MariaDB): Cria um instantâneo (*snapshot*) isolado através do motor InnoDB antes de iniciar a extração. Permite que as aplicações continuem gravando e alterando dados normalmente sem travar o banco e sem paralisar o sistema.
  • Formato Customizado do PostgreSQL (pg_dump -Fc): Exporta os dados em formato binário comprimido e proprietário do PostgreSQL. Além de economizar espaço, permite restauração paralela multi-thread rápida através do pg_restore -j e restauração seletiva de tabelas individuais.
  • Segurança das Credenciais de Backup: Senhas nunca devem ser expostas na linha de comando ou em processos visíveis pelo ps aux. Devem ser confinadas em arquivos de credenciais com permissões estritas (/root/.my.cnf com permissão 600 para MariaDB e /root/.pgpass para PostgreSQL).
  • Política de Retenção e Expiração Rotativa: A automação deve realizar limpeza periódica das cópias antigas com o comando find -mtime +7 -delete, evitando que o crescimento desenfreado dos arquivos esgote o espaço em disco do servidor.
Roteiro Prático: Scripts de Backup e Agendamento no Cron
terminal — Debian 13
# 1. Criar o diretório de destino com permissões restritas exclusivas de root
sudo mkdir -p /var/backups/bancos/mariadb
sudo mkdir -p /var/backups/bancos/postgres
sudo chmod -R 700 /var/backups/bancos

# 2. Criar script de backup do MariaDB em /usr/local/bin/backup-mariadb.sh
sudo tee /usr/local/bin/backup-mariadb.sh << 'END_SCRIPT_MYSQL'
#!/usr/bin/env bash
set -euo pipefail

DEST_DIR="/var/backups/bancos/mariadb"
DATA=$(date +%Y%m%d_%H%M%S)
RETENCAO_DIAS=7

mkdir -p "${DEST_DIR}"

# Listar todas as bases excluindo esquemas do sistema
BANCOS=$(mariadb -Bse "SHOW DATABASES;" | grep -Ev "(information_schema|performance_schema|sys)")

for DB in ${BANCOS}; do
    ARQUIVO="${DEST_DIR}/${DB}_${DATA}.sql.gz"
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Iniciando backup da base MariaDB: ${DB}"
    mariadb-dump --single-transaction --quick --routines --triggers "${DB}" | gzip -9 > "${ARQUIVO}"
done

# Remocao automatica de backups com mais de 7 dias
find "${DEST_DIR}" -name "*.sql.gz" -type f -mtime +${RETENCAO_DIAS} -delete
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Rotina MariaDB concluída com sucesso."
END_SCRIPT_MYSQL
sudo chmod +x /usr/local/bin/backup-mariadb.sh

# 3. Criar script de backup do PostgreSQL em /usr/local/bin/backup-postgres.sh
sudo tee /usr/local/bin/backup-postgres.sh << 'END_SCRIPT_PG'
#!/usr/bin/env bash
set -euo pipefail

DEST_DIR="/var/backups/bancos/postgres"
DATA=$(date +%Y%m%d_%H%M%S)
RETENCAO_DIAS=7

mkdir -p "${DEST_DIR}"

# 1. Backup de Roles e Permissoes Globais do Cluster
su - postgres -c "pg_dumpall --globals-only" | gzip -9 > "${DEST_DIR}/globals_${DATA}.sql.gz"

# 2. Backup de cada banco em formato Custom comprimido (-Fc)
BANCOS=$(su - postgres -c "psql -At -c "SELECT datname FROM pg_database WHERE NOT datistemplate AND datname != 'postgres';"")

for DB in ${BANCOS}; do
    ARQUIVO="${DEST_DIR}/${DB}_${DATA}.dump"
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Iniciando backup da base PostgreSQL: ${DB}"
    su - postgres -c "pg_dump -Fc -d "${DB}"" > "${ARQUIVO}"
done

# Remocao automatica de backups antigos
find "${DEST_DIR}" -name "*.dump" -type f -mtime +${RETENCAO_DIAS} -delete
find "${DEST_DIR}" -name "globals_*.sql.gz" -type f -mtime +${RETENCAO_DIAS} -delete
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Rotina PostgreSQL concluída com sucesso."
END_SCRIPT_PG
sudo chmod +x /usr/local/bin/backup-postgres.sh

# 4. Agendar a execução automática diária de madrugada no Cron
sudo tee /etc/cron.d/backups-bancos << 'END_CRON'
# M H Dom Mon Dow User Command
00 02 * * * root /usr/local/bin/backup-mariadb.sh >> /var/log/backup-bancos.log 2>&1
30 02 * * * root /usr/local/bin/backup-postgres.sh >> /var/log/backup-bancos.log 2>&1
END_CRON
sudo chmod 644 /etc/cron.d/backups-bancos
Validação e Verificação
validação — teste de execução manual
# 1. Executar os scripts manualmente para validar ausência de erros
sudo /usr/local/bin/backup-mariadb.sh
sudo /usr/local/bin/backup-postgres.sh

# 2. Inspecionar os arquivos de backup gerados
sudo ls -lh /var/backups/bancos/mariadb/
sudo ls -lh /var/backups/bancos/postgres/

# 3. Testar a integridade dos arquivos compactados
sudo gzip -t /var/backups/bancos/mariadb/*.sql.gz
# Se nenhum erro for exibido, as cópias de segurança estão íntegras e prontas para restauração
Módulo Anterior: Servidor Web Próximo Módulo: FTP

Privacidade e preferências

Responsável: Nathaniel Simch de Morais. Contato: nathaniel@morais.eti.br.

Preferência essencial: guardamos neste navegador a sua escolha por até 180 dias, para respeitá-la nas páginas deste mesmo endereço. Esse registro não é enviado ao Google.

Estatísticas opcionais: após sua aceitação, o Google Analytics 4 recebe informações de navegação, como páginas visitadas, origem do acesso, interações e informações técnicas do navegador e dispositivo, para produzir relatórios de uso. Utiliza identificadores em cookies, como _ga. Nesta integração, os cookies de análise têm duração configurada de até 180 dias, renovável com o uso autorizado.

A tag de análise não é carregada antes da aceitação nem quando você recusa. As opções de publicidade e personalização de anúncios desta integração permanecem desativadas.

Você pode retirar sua autorização aqui a qualquer momento. A retirada interrompe novas coletas neste navegador e remove os cookies de análise acessíveis a este site; não apaga automaticamente dados já enviados. Para solicitações sobre seus dados, utilize o contato acima.

O Google pode processar dados em servidores fora do seu país. Consulte a Política de Privacidade do Google. Recursos externos utilizados pelas páginas, como bibliotecas e fontes, e os registros técnicos da hospedagem são independentes desta preferência de Analytics.