sexta-feira, 20 de março de 2026

Expandindo Horizontes: Minha Primeira Certificação Fortinet em Cibersegurança

Na área de tecnologia, a estagnação é o maior risco que um profissional pode correr. Durante anos, meu foco principal tem sido a arquitetura, alta disponibilidade e performance de bancos de dados de missão crítica (como IBM Informix e Oracle) e infraestrutura Linux.

No entanto, não podemos ignorar a realidade atual: os dados são o ativo mais valioso de qualquer empresa e o alvo principal dos cibercriminosos.

Não basta apenas garantir que o banco de dados seja rápido e tenha backups eficientes; é preciso entender profundamente o perímetro de rede que o protege. Por isso, decidi expandir meus horizontes e mergulhar no ecossistema de segurança da Fortinet, uma das líderes globais em cibersegurança.

Minha Primeira Certificação Fortinet

É com muita satisfação que compartilho a conquista da minha primeira certificação oficial da trilha de segurança: Introduction to the Threat Landscape 3.0.

Este módulo aprofunda o conhecimento sobre o cenário atual de ameaças, táticas de invasão, evolução dos malwares e como os cibercriminosos exploram vulnerabilidades na infraestrutura para chegar até o "pote de ouro": os servidores de banco de dados.



Introduction to the Threat Landscape 3.0

Emitido por Fortinet

Verificar Credencial no Credly

O que isso significa para os clientes da AJMSolutions?

A arquitetura de TI moderna exige uma visão holística. Quando um cliente confia a infraestrutura da sua empresa à AJMSolutions, ele não está contratando apenas um especialista em banco de dados ou Linux.

Ele está contando com um profissional que entende como as camadas de rede, firewalls (FortiGate) e políticas de segurança interagem com os servidores de dados. Isso nos permite desenhar topologias mais seguras, configurar auditorias (Audit Trails) de forma mais inteligente e garantir que a performance não comprometa a segurança (e vice-versa).

Este é apenas o primeiro passo na trilha da Fortinet. O aprendizado contínuo é a única forma de manter os ambientes de missão crítica verdadeiramente blindados.

quinta-feira, 12 de março de 2026

3 Segredos Obscuros do Linux que todo DBA e Sysadmin Sênior deveria conhecer

Mesmo que você administre servidores Linux há mais de uma década, o pinguim sempre guarda segredos nas profundezas do seu kernel e do seu shell. Muitas ferramentas que consideramos indispensáveis podem ser substituídas por recursos nativos que quase ninguém conhece.

Se você é um Sysadmin ou DBA Sênior lidando com ambientes de missão crítica, aqui estão 3 segredos obscuros do Linux que vão mudar a forma como você trabalha.

1. O Scanner de Portas Invisível (O segredo do /dev/tcp)

Você está em um servidor de produção extremamente restrito. O firewall bloqueia instalações, não há telnet, não há nc (netcat) e nem nmap. Você precisa testar urgentemente se a porta do banco de dados (ex: 1521 do Oracle ou 9088 do Informix) está aberta em outro servidor.

O que quase ninguém sabe é que o próprio Bash possui um pseudo-dispositivo de rede embutido. Você não precisa de nenhuma ferramenta externa para abrir sockets TCP/UDP.


# Testando se a porta 9088 está aberta no IP 192.168.1.50 usando apenas o Bash
if timeout 2 bash -c 'echo > /dev/tcp/192.168.1.50/9088' 2>/dev/null; then
    echo "🚨 Porta ABERTA e respondendo!"
else
    echo "❌ Porta FECHADA ou bloqueada por Firewall."
fi

Como funciona: O Bash intercepta qualquer redirecionamento para /dev/tcp/HOST/PORTA e tenta abrir um socket de rede real. É a ferramenta de troubleshooting perfeita para ambientes "pelados" (como containers Docker minimalistas).

2. A Jaula Temporária (systemd-run)

Imagine o cenário: você precisa rodar um script de backup massivo (como um tar gigante ou uma exportação de dados), mas o servidor está em horário de pico. Se o seu script consumir muita CPU ou estourar o I/O, o banco de dados vai sofrer.

A maioria dos administradores tenta usar o nice ou ionice, que são ineficientes em servidores modernos. O segredo moderno é usar o systemd-run para criar um Cgroup (Control Group) temporário e descartável, limitando os recursos do comando "on-the-fly", sem editar nenhum arquivo de configuração.


# Executa o script de backup limitando-o a usar no máximo 1 CPU core (100%) 
# e no máximo 2GB de RAM. Se passar de 2GB, o Linux mata apenas o script.
systemd-run --scope -p CPUQuota=100% -p MemoryMax=2G ./meu_backup_pesado.sh

O resultado: O seu script roda em uma "jaula" invisível. O banco de dados continua com acesso total ao resto do servidor, e assim que o script termina, a jaula deixa de existir automaticamente.

3. O Reboot de 5 Segundos (Bypass de BIOS/Hardware com kexec)

Se você administra servidores bare-metal parrudões (com 96 CPUs, múltiplos nós NUMA e centenas de Gigabytes de RAM), sabe que um simples reboot pode demorar de 10 a 15 minutos. O servidor perde um tempo enorme fazendo a checagem de memória (POST), inicializando controladoras RAID e placas HBA.

E se você pudesse reiniciar o Linux sem reiniciar o hardware?

Isso é possível com o kexec (Kernel Execution). Ele permite que o kernel atual carregue um novo kernel diretamente na memória e passe o controle para ele, ignorando completamente a BIOS/UEFI.


# 1. Instale a ferramenta (se não tiver)
sudo apt install kexec-tools  # Ubuntu/Debian
sudo yum install kexec-tools  # RHEL/Oracle Linux

# 2. Carregue o kernel atual na memória para o próximo boot
sudo kexec -l /boot/vmlinuz-$(uname -r) \
           --initrd=/boot/initrd.img-$(uname -r) \
           --reuse-cmdline

# 3. Execute o "Reboot Quente" (Aviso: O servidor vai reiniciar IMEDIATAMENTE)
sudo systemctl kexec

O impacto: O tempo de downtime do seu servidor cai de 15 minutos para cerca de 10 a 15 segundos. Para ambientes de alta disponibilidade, isso é um divisor de águas na hora de aplicar patches de segurança no kernel.

Conclusão

O Linux é um ecossistema vasto. Dominar o /dev/tcp para troubleshooting de rede, o systemd-run para isolamento de recursos e o kexec para reboots ultrarrápidos são habilidades raras que separam os usuários avançados dos verdadeiros mestres do sistema operacional.

Qual desses três recursos você não conhecia e vai testar hoje mesmo?

Maximizando a Performance do IBM Informix em Servidores Multi-Core com Afinidade de CPU e NUMA

Quando migramos bancos de dados de missão crítica para servidores modernos de grande porte, um erro comum é acreditar que "mais CPUs" significa automaticamente "mais performance". Na realidade, sem a configuração correta, adicionar processadores pode até piorar o desempenho do seu IBM Informix.

O grande vilão invisível em servidores multi-core modernos chama-se Latência NUMA (Non-Uniform Memory Access). Neste artigo, vamos entender como a Afinidade de CPU (CPU Affinity) no Informix pode resolver esse problema e extrair 100% do poder do seu hardware.

O Problema da Arquitetura NUMA

Em servidores com múltiplos processadores físicos (sockets), a memória RAM é dividida e conectada diretamente a cada processador. Isso cria os chamados "Nós NUMA".

Se uma thread do Informix (um Virtual Processor - VP) está rodando na CPU do Nó 0, mas precisa acessar dados que estão na memória RAM conectada ao Nó 1, ocorre o Cross-Node Memory Access. Esse tráfego passa pelo barramento de interconexão da placa-mãe, gerando latência e destruindo a performance de consultas pesadas.

Mapeando a Topologia do Servidor (Linux)

Antes de configurar o banco, precisamos entender o hardware. Vamos usar como exemplo um servidor robusto com 96 CPUs lógicas (2 sockets, 24 cores físicos por socket, com Hyper-Threading habilitado).

O primeiro passo é rodar o comando lscpu no Linux para mapear quais CPUs pertencem a quais nós NUMA:


# Verificando a topologia NUMA no Linux
lscpu | grep NUMA

Exemplo de Saída:


NUMA node(s):          2
NUMA node0 CPU(s):     0-23,48-71
NUMA node1 CPU(s):     24-47,72-95

Neste cenário, sabemos exatamente quais IDs de CPU pertencem a cada processador físico. Também sabemos que as CPUs de 48 a 95 são threads virtuais (Hyper-Threading), que geralmente evitamos para os VPs principais de CPU do banco de dados para garantir ciclos de clock dedicados.

Configurando a Afinidade no Informix (onconfig)

O IBM Informix (especialmente nas versões mais recentes, como a 14.10) possui um controle granular excelente sobre onde seus Virtual Processors vão rodar. Isso é feito através do parâmetro VPCLASS no arquivo onconfig.

Em vez de deixar o sistema operacional (Linux) jogar os processos do Informix de um lado para o outro (causando context switching e perda de cache L3), nós "amarramos" (pin) os VPs a CPUs específicas.

Exemplo Prático de Configuração:
Vamos alocar 24 VPs de CPU para o Informix, distribuindo a carga de forma inteligente e usando apenas núcleos físicos reais. Vamos definir a afinidade para usar as CPUs de 0 a 11 (Nó 0) e de 24 a 35 (Nó 1).


# Configuração no arquivo onconfig
# num=24 : Cria 24 Virtual Processors da classe CPU
# aff=(0-11,24-35) : Amarra os VPs aos núcleos físicos específicos
VPCLASS cpu,num=24,aff=(0-11,24-35)

Por que essa configuração é um divisor de águas?

  1. Isolamento de Cache L3: Como o VP do Informix nunca muda de CPU, os dados que ele processa permanecem quentes no cache L3 do processador, acelerando leituras subsequentes.
  2. Redução de Context Switching: O Linux não gasta recursos tentando balancear os processos do banco de dados entre os núcleos.
  3. Previsibilidade: Em ambientes de alta concorrência, você garante que o Informix sempre terá aqueles 24 núcleos físicos dedicados a ele, imunes a picos de processamento de outras aplicações (como agentes de backup ou monitoramento).

Conclusão

Afinidade de CPU não é "micro-otimização", é arquitetura básica para servidores de grande porte. Se você roda IBM Informix em máquinas com dezenas de núcleos e não configurou o parâmetro aff= no seu VPCLASS, seu banco de dados está deixando performance na mesa.

Sempre mapeie sua topologia com lscpu, isole os núcleos físicos dos lógicos (HT) e amarre seus VPs. O tempo de resposta das suas queries vai agradecer.

segunda-feira, 9 de março de 2026

O Fim do "A culpa é do Banco" (Foco em Linux + Performance)

Todo DBA Sênior já participou daquela clássica "sala de guerra" (War Room). O sistema está lento, os usuários estão reclamando e a primeira frase que se ouve é: "A culpa é do banco de dados, olha lá!".

Você analisa as métricas da sua instância (seja IBM Informix, Oracle ou PostgreSQL) e nota um alto índice de esperas por I/O (I/O Waits). No entanto, a equipe de infraestrutura abre o painel do Storage e afirma categoricamente: "Nosso storage está entregando latência de 1ms, o problema não é aqui".

Como sair desse impasse de "achismos"? A resposta não está no iostat ou no sar. A resposta definitiva está dentro do próprio kernel do Linux, utilizando a tecnologia eBPF.

O que é o eBPF e o bcc-tools?

O eBPF (Extended Berkeley Packet Filter) é uma das maiores revoluções recentes do Linux. Ele permite que você execute programas em um ambiente seguro (sandbox) diretamente dentro do kernel do sistema operacional, sem precisar recompilar o kernel ou carregar módulos perigosos.

Para facilitar a vida dos administradores, foi criado o pacote bcc-tools (BPF Compiler Collection), que traz dezenas de scripts prontos para extrair métricas de performance com precisão de microssegundos, com impacto quase zero na CPU.

Instalando as ferramentas

A instalação é simples e está disponível nos repositórios oficiais das principais distribuições Linux corporativas:


# Em sistemas baseados em Debian/Ubuntu
sudo apt-get update
sudo apt-get install bpfcc-tools linux-headers-$(uname -r)

# Em sistemas baseados em RHEL/CentOS/Oracle Linux
sudo yum install bcc-tools kernel-devel-$(uname -r)

Nota: Dependendo da distribuição, os comandos ganham o sufixo -bpfcc (ex: biolatency-bpfcc).

1. biolatency: O Raio-X do seu Disco

O iostat mostra médias. E médias mentem. Se você tem 99 operações levando 1ms e 1 operação levando 1000ms, a média parecerá aceitável, mas aquela única operação lenta pode estar travando um checkpoint crítico do seu banco de dados.

O comando biolatency rastreia o tempo exato que o dispositivo de bloco (disco) levou para responder ao sistema operacional e gera um histograma visual.


# Medindo a latência de I/O em milissegundos por 10 segundos
sudo biolatency-bpfcc -m 10

Exemplo de Saída:


msecs               : count     distribution
    0 -> 1          : 3245     |****************************************|
    2 -> 3          : 453      |*****                                   |
    4 -> 7          : 12       |                                        |
    8 -> 15         : 3        |                                        |
   16 -> 31         : 0        |                                        |
   32 -> 63         : 0        |                                        |
   64 -> 127        : 1        |                                        |
  128 -> 255        : 150      |**                                      |

Como ler isso na reunião: "Equipe de Infra, a maioria das operações realmente ocorre em 1ms. Porém, observem o pico bimodal no final do histograma. Tivemos 150 operações que levaram entre 128ms e 255ms para serem concluídas no nível do bloco. O gargalo existe e está afetando o banco."

2. ext4slower / xfs_slower: A "Arma Fumegante"

Se o biolatency prova que o disco está lento, as ferramentas da família slower provam quem está sofrendo com isso e qual arquivo está sendo lido ou gravado no momento da lentidão.

Se o seu banco de dados está em um sistema de arquivos XFS, você pode pedir ao kernel para mostrar apenas as operações de I/O que demoraram mais de 10 milissegundos:


# Rastreando operações no XFS mais lentas que 10ms
sudo xfsslower-bpfcc 10

Exemplo de Saída:


TIME     COMM           PID    T BYTES   OFF_KB   LAT(ms) FILENAME
14:32:12 oninit         4512   W 8192    124000     15.23 rootdbs.000
14:32:15 oninit         4512   R 16384   854120     42.10 datadbs1.000
14:32:18 oracle         8921   W 8192    512000     85.50 redo01.log

O xeque-mate: Com esse comando, você entrega o relatório exato. Você mostra o horário, o processo do banco de dados (oninit, oracle, etc.), se era leitura (R) ou gravação (W), a latência exata em milissegundos e, o mais importante, o nome do arquivo físico que sofreu a lentidão (ex: um dbspace ou um redo log).

Conclusão

A administração de bancos de dados de missão crítica exige observabilidade avançada. Quando você para de usar ferramentas baseadas em médias e passa a usar o eBPF para analisar eventos no nível do kernel, o diagnóstico deixa de ser uma opinião e passa a ser um fato matemático.

Se o seu ambiente de banco de dados apresenta lentidões misteriosas, travamentos de aplicação ou picos de I/O inexplicáveis, não tente adivinhar. Meça com as ferramentas certas.

domingo, 8 de março de 2026

Dominando o journalctl: Log Management Avançado para Sysadmins e DBAs

A transição do tradicional syslog para o systemd-journald mudou drasticamente a forma como gerenciamos logs no Linux. Para analistas de infraestrutura e DBAs que lidam com bancos de dados de missão crítica, como IBM Informix e PostgreSQL, o journalctl não é apenas um leitor de logs, mas uma ferramenta de diagnóstico de alta precisão.

Como o journald armazena logs em formato binário e indexado, ele permite consultas complexas, correlação de eventos e formatação estruturada que seriam impossíveis com arquivos de texto puro perdidos em /var/log.

Abaixo, exploramos técnicas avançadas para extrair o máximo do journalctl em ambientes de produção.

1. Filtragem Cirúrgica de Eventos

Em servidores com alta carga (dezenas de CPUs e alto I/O), ler logs sequencialmente é inviável. O verdadeiro poder do journalctl está nos seus metadados indexados.

Por Unidade de Serviço (Unit): Isole completamente os logs de um serviço específico, ignorando o ruído do sistema operacional.


# Acompanha em tempo real (tail) apenas os logs do banco
journalctl -u postgresql.service -f

Por Janela de Tempo: Evite o excesso de dados filtrando por períodos exatos. O journalctl entende linguagem natural e timestamps absolutos.


# Busca incidentes em uma janela específica de ontem
journalctl -u informix.service --since "2023-10-25 14:00:00" --until "2023-10-25 15:30:00"

# Busca o que aconteceu na última hora
journalctl --since "1 hour ago"

Por PID ou UID: Se você identificou um processo problemático (ex: um worker consumindo muita CPU), pode rastrear apenas o que aquele PID registrou.


journalctl _PID=4598
journalctl _UID=1001

2. Rastreamento de Boots e Kernel (Post-Mortem)

Quando um servidor reinicia inesperadamente, a primeira ação de um analista sênior é verificar o log do boot anterior e os eventos do kernel (OOM Killer, falhas de disco, etc).


# Lista todos os boots registrados no sistema com seus IDs
journalctl --list-boots

# Exibe os logs do boot que falhou (o boot anterior ao atual)
journalctl -b -1

# Exibe apenas mensagens do Kernel (similar ao dmesg) do boot atual
journalctl -k -b

3. Formatação de Saída para Automação e SIEM

Se você precisa integrar a análise de logs com scripts em Python, Bash ou enviar dados para um SIEM (como Splunk, ELK ou Datadog), a saída padrão em texto não é a ideal.


# Exporta todos os metadados do log em formato JSON estruturado
journalctl -u sshd.service -o json-pretty

# Mostra todos os campos indexados (excelente para descobrir variáveis para filtros)
journalctl -o verbose -n 5

4. Gerenciamento de Espaço e Retenção (Vacuuming)

Logs binários podem crescer rapidamente. Um administrador proativo não espera o disco encher; ele gerencia a retenção.


# Verifica o uso atual de disco pelo journal
journalctl --disk-usage

# Força a rotação e exclusão até que o diretório ocupe no máximo 1GB
journalctl --vacuum-size=1G

# Remove qualquer entrada de log mais antiga que 30 dias
journalctl --vacuum-time=30d

Dica de Ouro: Para tornar a retenção persistente, edite o arquivo /etc/systemd/journald.conf e ajuste os parâmetros SystemMaxUse= e SystemKeepFree=, reiniciando o serviço em seguida.

5. Bônus Prático: Automação de Alertas com Bash

Como DBAs seniores, não ficamos olhando para a tela esperando o erro acontecer; nós automatizamos a detecção. Abaixo, apresento modelos de scripts em Bash que utilizam o journalctl para buscar erros críticos nos últimos 10 minutos.

Estes scripts são ideais para serem agendados no cron e integrados com APIs de comunicação (como Slack ou Teams).

Monitorando PostgreSQL (Erros Fatais)

Queremos ser alertados imediatamente caso ocorram erros do tipo FATAL ou PANIC, que geralmente indicam queda de conexão em massa ou corrupção.


#!/bin/bash
# check_pg_errors.sh

# Busca logs dos últimos 10 minutos, remove paginação e filtra erros críticos
CRITICAL_EVENTS=$(journalctl -u postgresql.service --since "10 minutes ago" --no-pager | grep -iE "FATAL|PANIC")

if [ -n "$CRITICAL_EVENTS" ]; then
    echo "🚨 ALERTA CRÍTICO: Erros detectados no PostgreSQL!"

    # Exemplo de integração via Webhook com o Slack
    PAYLOAD=$(jq -n --arg text "🚨 *Erro Crítico no PostgreSQL:*\n$CRITICAL_EVENTS" '{text: $text}')
    curl -X POST -H 'Content-type: application/json' --data "$PAYLOAD" https://hooks.slack.com/services/SEU/WEBHOOK/AQUI
fi

Monitorando IBM Informix (Asserts e Logical Logs)

Para ambientes rodando Informix (como a versão 14.10), os pesadelos de qualquer DBA envolvem Assert Failed (falhas internas do motor) ou o esgotamento do espaço de logs lógicos.


#!/bin/bash
# check_ifx_errors.sh

# Filtra o journal do serviço Informix buscando falhas críticas
IFX_ALERTS=$(journalctl -u informix.service --since "10 minutes ago" --no-pager | grep -iE "Assert Failed|Logical Log Files are Full")

if [ -n "$IFX_ALERTS" ]; then
    echo "🚨 ALERTA CRÍTICO: Anomalia detectada no motor do Informix!"

    # Dispara coleta de dados de diagnóstico automaticamente antes que o ambiente trave
    /opt/informix/bin/onstat -a > /tmp/onstat_assert_$(date +%Y%m%d_%H%M).out

    # Aqui você pode adicionar o mesmo curl do Slack mostrado acima
fi

Por que usar o journalctl no script e não ler o arquivo online.log direto?
Porque o journalctl lida nativamente com a janela de tempo (--since "10 minutes ago"). Se você fizesse um grep direto em um arquivo de texto, teria que criar uma lógica complexa com awk ou sed para isolar apenas as linhas geradas recentemente. O systemd faz esse trabalho pesado para você com precisão absoluta.

terça-feira, 26 de agosto de 2025

Restaurando uma Tabela Específica no IBM Informix com o Archecker

 Em ambientes corporativos, a perda ou corrupção de dados em uma tabela específica pode gerar grande impacto operacional. Uma das vantagens do IBM Informix é a possibilidade de restaurar apenas uma tabela, sem necessidade de restaurar todo o banco de dados. Para isso, utilizamos a ferramenta archecker.

Neste artigo, vou demonstrar passo a passo como restaurar uma única tabela com segurança, incluindo boas práticas e exemplos de configuração.

sábado, 5 de outubro de 2024

Explorando o Comando bc no Linux

 O comando bc (Basic Calculator) é uma ferramenta poderosa no Linux para realizar cálculos matemáticos com precisão arbitrária. Ele pode ser usado tanto de forma interativa quanto em scripts. Neste artigo, vamos explorar desde os exemplos mais básicos até os mais avançados.


Exemplos Básicos

1. Operações Aritméticas Simples

O bc pode ser usado para realizar operações aritméticas básicas como adição, subtração, multiplicação e divisão.


echo "12 + 5" | bc

# Saída: 17


echo "10 - 3" | bc

# Saída: 7


echo "4 * 7" | bc

# Saída: 28


echo "20 / 4" | bc

# Saída: 5


2. Uso de Variáveis

Você pode armazenar resultados em variáveis para uso posterior.


x=$(echo "12 + 5" | bc)

echo $x

# Saída: 17


3. Operações com Decimais

Para trabalhar com números decimais, você pode definir a escala (número de casas decimais).


echo "scale=2; 5 / 3" | bc

# Saída: 1.66


Exemplos Intermediários

1. Operadores de Incremento e Decremento

O bc suporta operadores de incremento (++var) e decremento (--var).


echo "var=10; ++var" | bc

# Saída: 11


echo "var=10; var++" | bc

# Saída: 10 (incrementa após a operação)


2. Operadores de Comparação

Você pode usar operadores de comparação para verificar condições.


echo "5 > 3" | bc

# Saída: 1 (verdadeiro)


echo "5 < 3" | bc

# Saída: 0 (falso)


3. Funções Matemáticas

O bc inclui várias funções matemáticas, como seno, cosseno e exponenciação.


echo "scale=4; s(1)" | bc -l

# Saída: 0.8415 (seno de 1 radiano)


echo "scale=4; e(1)" | bc -l

# Saída: 2.7182 (exponencial de 1)


Exemplos Avançados

1. Scripts com bc

Você pode criar scripts complexos usando bc para cálculos avançados.


echo "define f(x) { return x^3 + 2*x^2 + x + 1 } ; f(3)" | bc

# Saída: 49


2. Loops e Condicionais

O bc permite o uso de loops e condicionais para cálculos iterativos.


echo "for (i=0; i<5; i++) i^2" | bc

# Saída: 0 1 4 9 16


echo "if (5 > 3) 1 else 0" | bc

# Saída: 1


3. Conversão de Bases

Você pode converter números entre diferentes bases, como decimal para hexadecimal.


echo "obase=16; 255" | bc

# Saída: FF


echo "ibase=16; FF" | bc

# Saída: 255


Conclusão

O comando bc é uma ferramenta versátil e poderosa para cálculos matemáticos no Linux. Desde operações básicas até scripts complexos, ele oferece uma ampla gama de funcionalidades que podem ser extremamente úteis para desenvolvedores e administradores de sistemas. Experimente os exemplos acima e explore ainda mais as capacidades do bc!