AIOps Platform (Deep-Dive)

​

Visão Geral do Pipeline

​

Componentes da Plataforma v2

​

REST API e Dashboard

​

Componentes Internos

​

1. WatcherBridge (watcher_bridge.go)

hash = SHA256(alertType | deployment | namespace)

• Sem componente temporal: Um problema contínuo (e.g. CrashLoopBackOff) gera apenas uma Anomaly
• TTL: 2 horas — hashes expirados são podados automaticamente
• Invalidação: Quando um Issue atinge estado terminal (Resolved/Escalated), as entradas de dedup para o recurso afetado são invalidadas, permitindo detecção imediata de recorrências
• Resultado: Evita duplicatas durante problema ativo; detecta recorrência após resolução

​

2. AnomalyReconciler (anomaly_controller.go)

​

3. CorrelationEngine (correlation.go)

Para cada nova anomalia:
  1. Gera incident_id = hash(resource_kind + resource_name + namespace + signal_type)
  2. Busca Issue existente com mesmo incident_id
  3. Se existe -> adiciona anomalia ao Issue, recalcula risk score
  4. Se não existe -> cria novo Issue

risk_score >= 80 -> Critical
risk_score >= 60 -> High
risk_score >= 40 -> Medium
risk_score <  40 -> Low

​

4. IssueReconciler (issue_controller.go)

• Cada retry dispara re-análise do AI com contexto de falhas anteriores
• O AI recebe previous_failure_context com evidência das tentativas que falharam
• O prompt instrui: “Não repita as mesmas ações. Análise por que falharam e sugira uma abordagem fundamentalmente diferente”
• Gera novo Runbook auto-gerado com estratégia diferente (nome inclui attempt)

1. Runbook manual existente (match tiered: SignalType+Severity+Kind -> Severity+Kind)
2. Runbook auto-gerado pela IA (materializado como CR reutilizável)
3. Escalonamento (último recurso)

​

5. AIInsightReconciler (aiinsight_controller.go)

• Resource Status: replicas, conditions, containers, images + resources (cada tipo tem context builder dedicado)
• StatefulSet: replicas, update strategy, partition, PodManagementPolicy, VolumeClaimTemplates
• DaemonSet: desired/current/ready/available/unavailable, nodeSelector, tolerations
• Job/CronJob: active/succeeded/failed, completions, parallelism, schedule, lastSuccessful
• HPA: min/max replicas, current/desired, target utilization, current metrics, maxed-out detection
• Pod Details (até 5 pods, unhealthy primeiro): phase, restart count, container states
• Recent Events (últimos 15): tipo, reason, message, count
• Revision History: Últimas 5 revisões (ReplicaSets) com diff de imagens

• Stack Trace Extraction: detecta e extrai stack traces de Java (Exception/Caused by), Go (panic/goroutine), Python (Traceback), Node.js (Error at)
• Error Pattern Detection: 24+ padrões críticos categorizados (crash, connectivity, dns, auth, storage, tls, database, cache, messaging)
• Structured Log Parsing: extrai error/warn entries de logs JSON (campos level, msg, error, timestamp, logger)
• Init Container Logs: analisa logs de init containers (revela falhas de startup)
• Sidecar Logs: analisa logs de sidecars (istio-proxy, envoy, datadog-agent, etc.)
• Critical Lines: extrai linhas FATAL/PANIC com 3 linhas de contexto antes/depois
• Temporal Window: busca logs por janela temporal (10min antes do incidente), não apenas tail

• CPU/Memory: usage trends 30min antes → durante → 15min depois do incidente
• Request/Error Rate: HTTP requests e 5xx por segundo
• Latency: P50, P95, P99 histogram percentiles
• HPA Metrics: current vs desired replicas, CPU target
• Network: receive/transmit bytes/s
• Trend Analysis: detecta spikes, drops, sustained_high/low com cálculo de % de mudança
• Habilitado via: PROMETHEUS_URL env var no operator

• Helm Releases: detecta via Secrets type helm.sh/release.v1, status (deployed/failed/pending-upgrade), chart version, revisão anterior para rollback
• ArgoCD Applications: sync status (Synced/OutOfSync), health (Healthy/Degraded), conditions, last sync result
• Flux Kustomizations: ready status, source ref, conditions, last applied

• Git Correlation: encontra commits nos 30min antes do incidente
• Suspected Commit: identifica o commit mais provável (score por proximidade temporal + volume de mudanças)
• Code Extraction: extrai trechos de código referenciados em stack traces (file path + line number → código fonte)
• Config Analysis: lê Dockerfile, values.yaml, Chart.yaml para contexto de deploy

• Dependency Graph: descobre dependências via Services + EndpointSlices
• Temporal Correlation: encontra issues ativos no mesmo namespace e cross-namespace em janela de 15-20min
• Cascade Chain: ordena serviços por tempo de detecção (primeiro = root cause)
• Root Cause Service: identifica o serviço origem do cascade

• PDB Check: verifica se a ação violaria PodDisruptionBudgets
• Quota Check: verifica ResourceQuotas (>90% usado = warning)
• Node Capacity: conta pods no node para ações de cordon/drain
• Affected Services: descobre quais Services seriam impactados
• Risk Level: classifica como low/medium/high/critical

​

6. RemediationReconciler (remediation_controller.go)

Pending -> Snapshot -> Executing -> (checkpoint + ação, para cada ação)
  -> Verifying (90s timeout) -> Completed
  -> Se ação falha -> Rollback automático -> RolledBack
  -> Se verificação falha -> Rollback automático -> RolledBack
  -> Se rollback falha -> Failed

Pending -> Executing -> (loop agentico: AI decide -> executa -> observa -> repeat)
  -> Verifying -> Completed | Failed

Cada reconcile = 1 step do loop agentico:
  1. Refresh contexto K8s (KubernetesContextBuilder)
  2. Envia histórico + contexto -> AgenticStep RPC
  3. AI responde: {reasoning, resolved, next_action}
  4. Se resolved=true -> Verifying (+ annotations com dados do PostMortem)
  5. Se next_action -> executa -> registra observação -> requeue 5s
  6. Se observation-only -> registra -> requeue 10s
  Safety: max 10 steps, timeout 10 minutos

​

7. ServerClient (grpc_client.go)

​

Interação Server e Operator

​

GetAlerts RPC

rpc GetAlerts(GetAlertsRequest) returns (GetAlertsResponse);

message AlertInfo {
  string alert_type = 1;    // HighRestartCount, OOMKilled, PodNotReady, DeploymentFailing
  string deployment = 2;
  string namespace = 3;
  string message = 4;
  string severity = 5;
  int64 timestamp = 6;
}

​

AnalyzeIssue RPC

rpc AnalyzeIssue(AnalyzeIssueRequest) returns (AnalyzeIssueResponse);

message SuggestedAction {
  string name = 1;
  string action = 2;
  string description = 3;
  map<string, string> params = 4;
}

message AnalyzeIssueResponse {
  string analysis = 1;
  float confidence = 2;
  repeated string recommendations = 3;
  string provider = 4;
  string model = 5;
  repeated SuggestedAction suggested_actions = 6;
}

1. Contexto do Issue (nome, namespace, recurso, severidade, risk score, descrição)
2. Lista de 19 ações disponíveis organizadas por categoria (Workload, GitOps, Autoscaling, Infra, Storage, Security, Networking, Advanced)
3. Instruções para retornar JSON estruturado com campos analysis, confidence, recommendations e actions

1. Remove markdown codeblocks (```json ... ```)
2. Parseia JSON em analysisResult
3. Clamp confidence entre 0.0 e 1.0
4. Se parsing falhar → usa resposta raw como analysis com confidence 0.5

​

AgenticStep RPC

rpc AgenticStep(AgenticStepRequest) returns (AgenticStepResponse);

message AgenticStepRequest {
  string issue_name = 1;
  string namespace = 2;
  string resource_kind = 3;
  string resource_name = 4;
  string signal_type = 5;
  string severity = 6;
  string description = 7;
  int32 risk_score = 8;
  string provider = 9;
  string model = 10;
  string kubernetes_context = 11;   // refreshado a cada step
  repeated AgenticHistoryEntry history = 12;
  int32 max_steps = 13;
  int32 current_step = 14;
}

message AgenticStepResponse {
  string reasoning = 1;              // raciocínio da IA (registrado no histórico)
  bool resolved = 2;                 // true = problema resolvido
  SuggestedAction next_action = 3;   // null quando resolved=true
  // Campos abaixo só populados quando resolved=true:
  string postmortem_summary = 4;
  string root_cause = 5;
  string impact = 6;
  repeated string lessons_learned = 7;
  repeated string prevention_actions = 8;
}

1. Role + Issue details: contexto do incidente (tipo, severidade, recurso)
2. Kubernetes context: estado real do cluster (refreshado a cada step via KubernetesContextBuilder)
3. Tool definitions: 18 ações mutantes disponíveis + “Observe” (sem ação, espera próximo contexto)
4. Conversation history: cada step anterior formatado com reasoning → action → observation
5. Instructions: respond JSON, budget (step N of M), regras de segurança

​

PostMortem Generation

​

PostMortem CR

• Trending: detecção de incidentes recorrentes (contagem nos últimos 30 dias, PostMortems relacionados)
• Cascade Chain: cadeia de cascade failure se houver issues correlacionados cross-service
• Git Correlation: commit suspeito (SHA, autor, arquivos alterados, confiança)
• GitOps Context: estado do Helm/ArgoCD/Flux no momento do incidente

​

Runbook Auto-gerado (Agentic)

• Nome: agentic-{signal}-{severity}-{kind} (sanitizado)
• Steps: apenas os passos com ação bem-sucedida
• Labels: auto-generated=true, source=agentic
• Usa CreateOrUpdate (reutilizado para incidentes futuros do mesmo tipo)

​

Prometheus Metrics do Operator

​

Testes

​

Executar Testes

cd operator
go test ./... -v

​

Diagrama de Ownership (Garbage Collection)

• Instance e owner de todos os recursos Kubernetes que cria (Deployment, Service, ConfigMap, SA, PVC)
• Issue e owner de AIInsight, RemediationPlan e PostMortem (cascade delete)
• Anomalies são independentes (não tem owner) para preservar histórico

​

Checklist de Implantação AIOps

helm install chatcli-operator \
  oci://ghcr.io/diillson/charts/chatcli-operator \
  --namespace chatcli-system --create-namespace

​

Próximo Passo