Aegis Sentinel | Python

Aegis Sentinel

Resumo Executivo

Aegis Sentinel é um mecanismo de monitoramento de infraestrutura e recuperação automática de alta confiabilidade projetado para garantir a continuidade dos negócios e a resiliência da infraestrutura em ambientes corporativos. Este sistema implementa algoritmos avançados de detecção de anomalias e mecanismos de recuperação automatizados para evitar tempos de inatividade catastróficos em serviços digitais.

A plataforma demonstra princípios de engenharia avançados adequados aos padrões internacionais, particularmente alinhados com os requisitos EB-2 NIW para demonstrar capacidade excepcional em engenharia de sistemas e automação de infraestrutura.

Especificações de engenharia

Arquitetura Técnica

Aegis Sentinel emprega uma arquitetura modular orientada a serviços com três componentes principais:

1. Monitorar serviço: Coleta de métricas do sistema em tempo real
2. Detecção de anomalias de ML: Identificação de anomalias baseada em aprendizado de máquina
3. Mecanismo de recuperação: Ações automatizadas de remediação e cura

Tecnologias principais

• Python 3.11+ com dicas de tipo estrita
• Registro JSON estruturado para auditabilidade empresarial
• Floresta de Isolamento e detecção estatística de anomalias
• Gerenciamento de contêineres Docker para recuperação automatizada
• Testes abrangentes com estrutura pytest

Fluxo de trabalho visual

graph LR
    A[Metrics Collection] --> B[ML Detection]
    B --> C{Anomaly?}
    C -- No --> A
    C -- Yes --> D[Recovery Engine]
    D --> E[Self-Healing Action]

Requisitos do sistema

• Python 3.11 ou superior
• Docker (para ações de recuperação em contêineres)
• Bibliotecas padrão Python: psutil, numpy, scikit-learn
• Opcional: Redis para cache distribuído

Contexto de Interesse Nacional

Na economia digital atual, a fiabilidade da infraestrutura é fundamental para a manutenção de serviços essenciais. Aegis Sentinel aborda o interesse nacional ao:

• Evitando paralisações catastróficas em infraestrutura digital crítica
• Reduzindo o impacto econômico de falhas do sistema por meio de rápida recuperação automatizada
• Melhorar a resiliência da cibersegurança através da detecção proativa de anomalias
• Demonstrando liderança tecnológica em automação de infraestrutura

Métricas de Impacto de Engenharia

A capacidade do sistema de detectar e remediar problemas antes que se transformem em interrupções de serviço contribui directamente para a estabilidade e fiabilidade dos serviços digitais que são essenciais para a sociedade moderna.

Instalação

git clone https://github.com/PkLavc/aegis-sentinel.git
cd aegis-sentinel
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install -r requirements.txt

Uso

Uso Básico

from src.main import AegisSentinel

# Initialize the system with default configuration
sentinel = AegisSentinel()

# Start monitoring
await sentinel.start()

# The system will automatically detect anomalies and trigger recovery
# Monitor runs in the background and logs all activities

Configuração avançada

from src.main import AegisSentinel
from src.monitor import MonitoringConfig
from src.detector import DetectionConfig
from src.healer import RecoveryConfig

# Custom configuration
monitoring_config = MonitoringConfig(
    collection_interval=5.0,  # Check every 5 seconds
    api_endpoints=["https://api.example.com/health"],
    enable_network_monitoring=True,
    enable_disk_monitoring=True
)

detection_config = DetectionConfig(
    isolation_contamination=0.1,
    statistical_threshold_multiplier=3.0,
    min_samples_for_detection=50
)

recovery_config = RecoveryConfig(
    enable_docker_recovery=True,
    enable_cache_recovery=True,
    max_concurrent_actions=3
)

# Initialize with custom configuration
sentinel = AegisSentinel(
    monitoring_config=monitoring_config,
    detection_config=detection_config,
    recovery_config=recovery_config
)

# Start monitoring
await sentinel.start()

# Get service status
status = sentinel.get_status()
print(f"Service running: {status['service_status']}")
print(f"Anomalies detected: {status['anomalies_detected']}")
print(f"Recovery success rate: {status['success_rate']:.1f}%")

Uso programático

import asyncio
from src.main import aegis_sentinel_context

async def main():
    # Use context manager for automatic cleanup
    async with aegis_sentinel_context() as sentinel:
        print("Aegis Sentinel is running...")
        
        # Monitor for 60 seconds
        await asyncio.sleep(60)
        
        # Get current status
        status = sentinel.get_status()
        print(f"Uptime: {status['uptime_seconds']} seconds")

if __name__ == "__main__":
    asyncio.run(main())

Opções de configuração

Configuração de monitoramento

• collection_interval: Tempo entre coletas de métricas (padrão: 5,0 segundos)
• api_endpoints: lista de endpoints API para monitorar latência e disponibilidade
• enable_network_monitoring: ativar a coleta de métricas de rede
• enable_disk_monitoring: Habilita o monitoramento de uso do disco

Configuração de detecção

• isolation_contamination: Proporção esperada de anomalias nos dados (padrão: 0,1)
• isolation_n_estimators: Número de árvores na Floresta de Isolamento (padrão: 100)
• statistical_threshold_multiplier: Multiplicador de desvio padrão para detecção estatística (padrão: 3,0)
• min_samples_for_detection: Amostras mínimas necessárias antes do início da detecção (padrão: 50)

Configuração de recuperação

• enable_docker_recovery: Habilite a recuperação de reinicialização do contêiner Docker
• enable_cache_recovery: Habilita recuperação de limpeza de cache
• enable_service_recovery: Habilite a recuperação de reinicialização do serviço do sistema
• max_concurrent_actions: Máximo de ações de recuperação simultâneas (padrão: 3)
• action_timeout: Tempo limite padrão para ações de recuperação (padrão: 120,0 segundos)

Teste

Execute o conjunto de testes:

# Using the simple test runner
python run_tests.py

# Using pytest (if available)
pytest tests/

# Run specific test modules
pytest tests/test_monitor.py
pytest tests/test_detector.py

Registro

Aegis Sentinel usa registro JSON estruturado para auditabilidade empresarial:

{
  "timestamp": "2026-02-18T10:15:30Z",
  "level": "WARNING",
  "event": "anomaly_detected",
  "metric": "memory_usage",
  "value": 92.5,
  "action": "docker_container_restart",
  "target": "api_gateway_v1"
}

import logging

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

# Log files are automatically created as 'aegis_sentinel.log'

Níveis de registro:

• INFO: Status geral de operação e ações de recuperação
• WARNING: Eventos de detecção de anomalias
• ERROR: Erros do sistema e ações de recuperação com falha
• DEBUG: Coleta detalhada de métricas e informações de detecção

Contribuindo

Este projeto segue rígidos padrões profissionais. Todas as contribuições devem incluir:

• Testes de unidade abrangentes
• Digite anotações para todas as funções
• Logs estruturados para todas as operações
• Documentação para novos recursos

Licença

Licença MIT - consulte o arquivo LICENSE para obter detalhes.

Autor

Patrick Araujo - Engenheiro de Computação Para visualizar outros projetos e detalhes do portfólio, visite: https://pklavc.com/projects/

Este projeto faz parte de um portfólio profissional que demonstra capacidades avançadas de engenharia de sistemas para infraestrutura de alta disponibilidade.