> ## Documentation Index
> Fetch the complete documentation index at: https://chatcli.edilsonfreitas.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Auditoria e Compliance
> Audit trail imutável, RBAC granular com 4 roles, relatórios de compliance automatizados e integração com SIEM para rastreabilidade completa.
A plataforma AIOps do ChatCLI mantém um **audit trail imutável** de todas as ações — desde a detecção de uma anomalia até a execução de remediações. Combinado com RBAC granular e relatórios de compliance automatizados, o sistema atende requisitos de governança mesmo em ambientes regulados.
Cada AuditEvent é um CRD imutável (sem status). Uma vez criado, não pode ser
modificado ou deletado via controllers. Isso garante integridade do registro
para investigações e auditorias externas.
## Por que Audit Trail para AIOps
Quando uma plataforma toma decisões autônomas em infraestrutura de produção, a rastreabilidade deixa de ser opcional:
Quem aprovou a remediação? Qual IA recomendou a ação? Quando o circuit
breaker abriu? Toda decisão tem um rastro.
Reconstrua a timeline completa de um incidente — desde o primeiro sinal
até a resolução — com timestamps precisos.
SOC2, ISO 27001, PCI-DSS: demonstre controles sobre ações automatizadas
com registros imutáveis e RBAC documentado.
Métricas de MTTD, MTTR, taxa de sucesso e SLA calculadas automaticamente
a partir dos eventos de auditoria.
## AuditEvent CRD
O `AuditEvent` é um CRD **imutável** — ele possui apenas `spec`, sem `status`. Uma vez criado, seu conteúdo é permanente.
### Especificação Completa
```yaml theme={"system"}
apiVersion: platform.chatcli.io/v1alpha1
kind: AuditEvent
metadata:
name: audit-1710856200-a7f3b2
namespace: chatcli-system
labels:
platform.chatcli.io/event-type: RemediationExecuted
platform.chatcli.io/severity: high
platform.chatcli.io/correlation-id: inc-8f2a4b
annotations:
platform.chatcli.io/immutable: "true"
spec:
# Tipo do evento
eventType: RemediationExecuted
# Timestamp preciso
timestamp: "2026-03-19T14:30:00.123Z"
# Quem realizou a ação
actor:
type: controller # system | user | controller
name: remediation-reconciler
serviceAccount: chatcli-operator
# Recurso afetado
resource:
apiVersion: platform.chatcli.io/v1alpha1
kind: RemediationPlan
name: plan-rollback-api-server
namespace: production
# Detalhes específicos do evento
details:
action: Rollback
target: deployment/api-server
fromRevision: "6"
toRevision: "5"
confidence: "0.92"
decisionMode: auto-notify
duration: "12s"
result: success
# ID de correlação para agrupar eventos relacionados
correlationID: inc-8f2a4b
# Severidade do evento
severity: high
```
### Tipos de Evento (EventType)
A plataforma define **20+ tipos de evento** que cobrem todo o ciclo de vida do AIOps.
Os seguintes eventos são **registrados automaticamente** pelo operator:
* `issue_created` — quando uma nova Issue é detectada e transiciona para Analyzing
* `issue_resolved` — quando uma remediação resolve a Issue com sucesso
* `issue_escalated` — quando todas as tentativas de remediação falham
* `remediation_started` — quando um RemediationPlan inicia execução
* `remediation_completed` — quando a verificação de saúde confirma remediação bem-sucedida
* `remediation_failed` — quando uma remediação falha
| EventType | Descrição |
| ------------------------- | ------------------------------------------- |
| `AnomalyDetected` | Nova anomalia detectada pelo WatcherBridge |
| `AnomalyCorrelated` | Anomalia correlacionada com issue existente |
| `IssueCreated` | Nova issue criada pelo AnomalyReconciler |
| `IssueEscalated` | Issue escalada (severidade elevada) |
| `IssueResolved` | Issue marcada como resolvida |
| `CrossClusterCorrelation` | Correlação cross-cluster detectada |
| `CascadeDetected` | Cascata staging-produção detectada |
| EventType | Descrição |
| ------------------------ | ----------------------------------------------- |
| `AIInsightRequested` | Análise de IA solicitada |
| `AIInsightCompleted` | Análise de IA concluída com sucesso |
| `AIInsightFailed` | Falha na análise de IA |
| `PatternMatched` | Padrão encontrado no Pattern Store |
| `RCAEnrichmentCompleted` | Enriquecimento de causa raiz concluído |
| `ConfidenceCalculated` | Confiança final calculada pelo motor de decisão |
| EventType | Descrição |
| ------------------------- | -------------------------------- |
| `RemediationPlanned` | RemediationPlan criado |
| `RemediationExecuted` | Ação de remediação executada |
| `RemediationSucceeded` | Remediação concluída com sucesso |
| `RemediationFailed` | Remediação falhou |
| `AgenticStepExecuted` | Step do loop agêntico executado |
| `CircuitBreakerTriggered` | Circuit breaker ativado |
| EventType | Descrição |
| -------------------------- | ------------------------------- |
| `ApprovalRequested` | Aprovação solicitada |
| `ApprovalGranted` | Aprovação concedida |
| `ApprovalRejected` | Aprovação rejeitada |
| `ApprovalExpired` | Aprovação expirada sem resposta |
| `RoleGranted` | Role RBAC concedida a usuário |
| `RoleRevoked` | Role RBAC revogada de usuário |
| `ChaosExperimentStarted` | Experimento de chaos iniciado |
| `ChaosExperimentCompleted` | Experimento de chaos concluído |
### AuditActor
O campo `actor` identifica quem ou o que realizou a ação:
| Tipo | Descrição | Exemplo |
| ------------ | -------------------------------- | -------------------------------------------- |
| `system` | Ação automática do sistema | `watcher-bridge`, `correlation-engine` |
| `controller` | Controller do operator | `remediation-reconciler`, `issue-reconciler` |
| `user` | Ação humana (via kubectl ou API) | `john@company.com`, `admin` |
### AuditResource
O campo `resource` identifica o recurso Kubernetes afetado:
```go theme={"system"}
type AuditResource struct {
APIVersion string `json:"apiVersion"`
Kind string `json:"kind"`
Name string `json:"name"`
Namespace string `json:"namespace"`
}
```
### Formato de Nome
Cada AuditEvent segue o formato de nome:
```
audit-{unix-timestamp}-{random-6-chars}
```
Exemplos:
* `audit-1710856200-a7f3b2`
* `audit-1710856245-c9d4e1`
* `audit-1710856300-f2b8a6`
### Annotation de Imutabilidade
Todo AuditEvent é criado com a annotation `platform.chatcli.io/immutable: "true"`. Um admission webhook pode ser configurado para rejeitar updates/deletes em recursos com esta annotation.
## Audit Recorder
O `AuditRecorder` é o componente central que gera eventos de auditoria. Ele oferece **12 funções de conveniência** para os cenários mais comuns.
### Funções de Conveniência
```go theme={"system"}
type AuditRecorder struct {
client client.Client
namespace string
}
// Detecção
func (ar *AuditRecorder) RecordAnomalyDetected(anomaly *v1alpha1.Anomaly) error
func (ar *AuditRecorder) RecordIssueCreated(issue *v1alpha1.Issue) error
func (ar *AuditRecorder) RecordIssueResolved(issue *v1alpha1.Issue, resolution string) error
// Análise
func (ar *AuditRecorder) RecordAIInsightCompleted(insight *v1alpha1.AIInsight) error
func (ar *AuditRecorder) RecordConfidenceCalculated(issue string, confidence float64, factors map[string]float64) error
func (ar *AuditRecorder) RecordPatternMatched(fingerprint string, issue string) error
// Remediação
func (ar *AuditRecorder) RecordRemediationExecuted(plan *v1alpha1.RemediationPlan, action string) error
func (ar *AuditRecorder) RecordRemediationResult(plan *v1alpha1.RemediationPlan, success bool) error
func (ar *AuditRecorder) RecordCircuitBreakerTriggered(namespace string, failures int) error
// Governança
func (ar *AuditRecorder) RecordApprovalDecision(request *v1alpha1.ApprovalRequest, decision string) error
func (ar *AuditRecorder) RecordRoleChange(user string, role string, action string) error
func (ar *AuditRecorder) RecordChaosExperiment(experiment *v1alpha1.ChaosExperiment, phase string) error
```
### Geração Automática pelos Controllers
Os controllers geram AuditEvents automaticamente em pontos-chave do pipeline:
```go theme={"system"}
func (r *RemediationReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
plan := &v1alpha1.RemediationPlan{}
r.Get(ctx, req.NamespacedName, plan)
// Registra início da remediação
r.auditRecorder.RecordRemediationExecuted(plan, plan.Spec.Actions[0].Type)
// Executa a ação
err := r.executeAction(ctx, plan)
if err != nil {
// Registra falha
r.auditRecorder.RecordRemediationResult(plan, false)
return ctrl.Result{}, err
}
// Registra sucesso
r.auditRecorder.RecordRemediationResult(plan, true)
return ctrl.Result{}, nil
}
```
### Exemplo de Evento Gerado
```yaml theme={"system"}
apiVersion: platform.chatcli.io/v1alpha1
kind: AuditEvent
metadata:
name: audit-1710856200-a7f3b2
namespace: chatcli-system
annotations:
platform.chatcli.io/immutable: "true"
spec:
eventType: RemediationExecuted
timestamp: "2026-03-19T14:30:00.123Z"
actor:
type: controller
name: remediation-reconciler
serviceAccount: chatcli-operator
resource:
apiVersion: platform.chatcli.io/v1alpha1
kind: RemediationPlan
name: plan-rollback-api-server
namespace: production
details:
action: Rollback
target: deployment/api-server
fromRevision: "6"
toRevision: "5"
correlationID: inc-8f2a4b
severity: high
```
## Compliance Reporter
O `ComplianceReporter` gera relatórios automatizados a partir dos AuditEvents, calculando métricas operacionais essenciais.
### GenerateReport
```go theme={"system"}
func (cr *ComplianceReporter) GenerateReport(
ctx context.Context,
namespace string,
window time.Duration, // Ex: 7*24h para relatório semanal
) (*ComplianceReport, error)
```
### Métricas do Relatório
Métricas de incidentes que medem a velocidade de detecção e resolução.
| Métrica | Descrição | Cálculo |
| ------------------------------- | --------------------------------------------------- | ----------------------------------------- |
| **MTTD** (Mean Time to Detect) | Tempo médio entre o início do problema e a detecção | `avg(anomaly.detected - anomaly.started)` |
| **MTTR** (Mean Time to Resolve) | Tempo médio entre a detecção e a resolução | `avg(issue.resolved - issue.created)` |
| **MeanRemediationAttempts** | Número médio de tentativas de remediação por issue | `total_attempts / total_issues` |
```yaml theme={"system"}
incidentMetrics:
totalIncidents: 47
mttd: "2m15s"
mttr: "8m30s"
meanRemediationAttempts: 1.3
incidentsBySeverity:
critical: 2
high: 8
medium: 22
low: 15
```
Métricas de remediação que avaliam a eficácia das ações automáticas.
| Métrica | Descrição |
| ---------------- | ----------------------------------------------------------- |
| **SuccessRate** | Percentual de remediações bem-sucedidas |
| **ByActionType** | Breakdown por tipo de ação (Scale, Restart, Rollback, etc.) |
| **AutoVsManual** | Proporção de remediações automáticas vs manuais |
```yaml theme={"system"}
remediationMetrics:
totalRemediations: 52
successRate: 0.885 # 88.5%
byActionType:
Rollback:
total: 15
successful: 14
successRate: 0.933
Restart:
total: 18
successful: 17
successRate: 0.944
Scale:
total: 10
successful: 9
successRate: 0.900
AdjustResources:
total: 6
successful: 5
successRate: 0.833
DeletePod:
total: 3
successful: 3
successRate: 1.000
autoVsManual:
auto: 38
autoWithNotification: 8
manualApproved: 4
manualOnly: 2
autoPercentage: 0.885
```
Métricas de SLA que verificam conformidade com objetivos de nível de serviço.
| Métrica | Descrição |
| ------------------------ | --------------------------------------------- |
| **CompliancePercentage** | Percentual de issues resolvidas dentro do SLA |
| **Violations** | Lista de violações de SLA com detalhes |
```yaml theme={"system"}
slaMetrics:
totalIssuesInWindow: 47
resolvedWithinSLA: 44
compliancePercentage: 0.936 # 93.6%
slaTargets:
critical: 15m
high: 30m
medium: 2h
low: 8h
violations:
- issue: issue-database-connection-pool
severity: high
slaTarget: 30m
actualResolution: 45m
reason: "Aprovação manual demorou 20 minutos"
- issue: issue-cert-expiry-ingress
severity: medium
slaTarget: 2h
actualResolution: 3h15m
reason: "Remediação inicial falhou, segunda tentativa bem-sucedida"
- issue: issue-disk-pressure-node-5
severity: high
slaTarget: 30m
actualResolution: 1h10m
reason: "Circuit breaker aberto durante o incidente"
```
Métricas do sistema de aprovação que rastreiam a governança humana.
| Métrica | Descrição |
| ------------------ | --------------------------------------------- |
| **AutoApproved** | Ações executadas sem necessidade de aprovação |
| **ManualApproved** | Ações aprovadas por operadores |
| **Rejected** | Ações rejeitadas por operadores |
| **Expired** | Aprovações que expiraram sem resposta |
```yaml theme={"system"}
approvalMetrics:
totalApprovalRequests: 12
autoApproved: 0 # Não aplicável (auto não precisa de aprovação)
manualApproved: 8
rejected: 2
expired: 2
meanApprovalTime: "4m30s"
rejectionReasons:
- "Ação muito agressiva para horário de pico"
- "Prefiro investigar manualmente antes de rollback"
```
### Audit Summary
O relatório inclui um resumo dos eventos de auditoria gerados no período:
```yaml theme={"system"}
auditSummary:
totalEvents: 312
eventsByType:
AnomalyDetected: 89
IssueCreated: 47
AIInsightCompleted: 45
RemediationExecuted: 52
RemediationSucceeded: 46
RemediationFailed: 6
ApprovalRequested: 12
ApprovalGranted: 8
ApprovalRejected: 2
ApprovalExpired: 2
CircuitBreakerTriggered: 1
ChaosExperimentCompleted: 4
PatternMatched: 23
IssueResolved: 44
eventsBySeverity:
critical: 8
high: 45
medium: 156
low: 103
eventsByActor:
system: 134
controller: 166
user: 12
```
## RBAC Manager
O RBAC Manager implementa controle de acesso granular com **4 roles** predefinidas, mapeadas para ClusterRoles do Kubernetes.
### Definição de Roles
**Viewer** — Acesso somente leitura a todos os recursos AIOps.
| Recurso | Permissões |
| ------------------------- | ---------------------- |
| Anomaly, Issue, AIInsight | `get`, `list`, `watch` |
| RemediationPlan, Runbook | `get`, `list`, `watch` |
| AuditEvent | `get`, `list`, `watch` |
| PostMortem | `get`, `list`, `watch` |
| ChaosExperiment | `get`, `list`, `watch` |
| ApprovalRequest | `get`, `list`, `watch` |
```yaml theme={"system"}
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: chatcli-aiops-viewer
labels:
platform.chatcli.io/rbac-role: viewer
rules:
- apiGroups: ["platform.chatcli.io"]
resources: ["*"]
verbs: ["get", "list", "watch"]
```
**Operator** — Pode aprovar remediações e gerenciar incidentes.
| Recurso | Permissões adicionais (além de Viewer) |
| --------------- | ---------------------------------------------------------- |
| ApprovalRequest | `update`, `patch` |
| Issue | `update`, `patch` (mudar severidade, resolver manualmente) |
| RemediationPlan | `create` (criar planos manuais) |
| ChaosExperiment | `create` (em namespaces permitidos) |
```yaml theme={"system"}
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: chatcli-aiops-operator
labels:
platform.chatcli.io/rbac-role: operator
rules:
- apiGroups: ["platform.chatcli.io"]
resources: ["*"]
verbs: ["get", "list", "watch"]
- apiGroups: ["platform.chatcli.io"]
resources: ["approvalrequests", "issues"]
verbs: ["update", "patch"]
- apiGroups: ["platform.chatcli.io"]
resources: ["remediationplans", "chaosexperiments"]
verbs: ["create"]
```
**Admin** — Controle total sobre AIOps, incluindo Runbooks e configuração.
| Recurso | Permissões adicionais (além de Operator) |
| ----------------------- | ---------------------------------------- |
| Runbook | `create`, `update`, `delete` |
| ClusterRegistration | `create`, `update`, `delete` |
| Pattern Store ConfigMap | `update` |
| ChaosExperiment | `create`, `delete` (qualquer namespace) |
```yaml theme={"system"}
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: chatcli-aiops-admin
labels:
platform.chatcli.io/rbac-role: admin
rules:
- apiGroups: ["platform.chatcli.io"]
resources: ["*"]
verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
- apiGroups: [""]
resources: ["configmaps"]
resourceNames: ["chatcli-pattern-store"]
verbs: ["update", "patch"]
```
**SuperAdmin** — Acesso irrestrito, incluindo gestão de RBAC e AuditEvents.
| Recurso | Permissões adicionais (além de Admin) |
| -------------------------- | -------------------------------------------------- |
| RBAC (ClusterRoleBindings) | `create`, `update`, `delete` |
| AuditEvent | `delete` (apenas para retenção/cleanup programado) |
| Circuit Breaker | Reset manual via annotation |
| Federation | Gestão completa de clusters |
```yaml theme={"system"}
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: chatcli-aiops-superadmin
labels:
platform.chatcli.io/rbac-role: superadmin
rules:
- apiGroups: ["platform.chatcli.io"]
resources: ["*"]
verbs: ["*"]
- apiGroups: ["rbac.authorization.k8s.io"]
resources: ["clusterrolebindings"]
verbs: ["create", "update", "delete"]
resourceNames: ["chatcli-aiops-*"]
- apiGroups: [""]
resources: ["configmaps"]
resourceNames: ["chatcli-pattern-store"]
verbs: ["*"]
```
### EnsureRoles
O RBAC Manager garante que as ClusterRoles existem no cluster:
```go theme={"system"}
func (rm *RBACManager) EnsureRoles(ctx context.Context) error {
roles := []struct {
name string
rules []rbacv1.PolicyRule
}{
{name: "chatcli-aiops-viewer", rules: viewerRules},
{name: "chatcli-aiops-operator", rules: operatorRules},
{name: "chatcli-aiops-admin", rules: adminRules},
{name: "chatcli-aiops-superadmin", rules: superAdminRules},
}
for _, role := range roles {
cr := &rbacv1.ClusterRole{
ObjectMeta: metav1.ObjectMeta{Name: role.name},
Rules: role.rules,
}
_, err := controllerutil.CreateOrUpdate(ctx, rm.client, cr, func() error {
cr.Rules = role.rules
return nil
})
if err != nil {
return fmt.Errorf("falha ao criar/atualizar role %s: %w", role.name, err)
}
}
return nil
}
```
### GrantRole e RevokeRole
```go GrantRole theme={"system"}
func (rm *RBACManager) GrantRole(ctx context.Context, user string, role string) error {
binding := &rbacv1.ClusterRoleBinding{
ObjectMeta: metav1.ObjectMeta{
Name: fmt.Sprintf("chatcli-aiops-%s-%s", role, sanitize(user)),
},
RoleRef: rbacv1.RoleRef{
APIGroup: "rbac.authorization.k8s.io",
Kind: "ClusterRole",
Name: fmt.Sprintf("chatcli-aiops-%s", role),
},
Subjects: []rbacv1.Subject{
{Kind: "User", Name: user, APIGroup: "rbac.authorization.k8s.io"},
},
}
_, err := controllerutil.CreateOrUpdate(ctx, rm.client, binding, func() error { return nil })
if err != nil {
return err
}
// Registra no audit trail
return rm.auditRecorder.RecordRoleChange(user, role, "granted")
}
```
```go RevokeRole theme={"system"}
func (rm *RBACManager) RevokeRole(ctx context.Context, user string, role string) error {
binding := &rbacv1.ClusterRoleBinding{}
bindingName := fmt.Sprintf("chatcli-aiops-%s-%s", role, sanitize(user))
err := rm.client.Get(ctx, types.NamespacedName{Name: bindingName}, binding)
if err != nil {
return fmt.Errorf("binding não encontrado: %w", err)
}
err = rm.client.Delete(ctx, binding)
if err != nil {
return err
}
// Registra no audit trail
return rm.auditRecorder.RecordRoleChange(user, role, "revoked")
}
```
## API REST de Auditoria
A plataforma expõe endpoints REST para consulta e exportação de eventos de auditoria.
### GET /api/v1/audit
Consulta eventos com filtros.
**Parâmetros de query:**
| Parâmetro | Tipo | Descrição | Exemplo |
| ---------------- | -------- | ---------------------------------- | ---------------------- |
| `type` | string | Filtro por EventType | `RemediationExecuted` |
| `severity` | string | Filtro por severidade | `high` |
| `from` | ISO 8601 | Início da janela temporal | `2026-03-18T00:00:00Z` |
| `to` | ISO 8601 | Fim da janela temporal | `2026-03-19T23:59:59Z` |
| `actor` | string | Filtro por ator | `john@company.com` |
| `correlation_id` | string | Filtro por correlação | `inc-8f2a4b` |
| `limit` | int | Máximo de resultados (padrão: 100) | `50` |
| `offset` | int | Offset para paginação | `100` |
**Exemplo de requisição:**
```bash theme={"system"}
curl -s "https://chatcli.example.com/api/v1/audit?\
type=RemediationExecuted&\
severity=high&\
from=2026-03-18T00:00:00Z&\
to=2026-03-19T23:59:59Z&\
limit=10" | jq .
```
**Exemplo de resposta:**
```json theme={"system"}
{
"total": 15,
"returned": 10,
"events": [
{
"name": "audit-1710856200-a7f3b2",
"eventType": "RemediationExecuted",
"timestamp": "2026-03-19T14:30:00.123Z",
"actor": {
"type": "controller",
"name": "remediation-reconciler"
},
"resource": {
"kind": "RemediationPlan",
"name": "plan-rollback-api-server",
"namespace": "production"
},
"details": {
"action": "Rollback",
"target": "deployment/api-server",
"result": "success"
},
"correlationID": "inc-8f2a4b",
"severity": "high"
}
]
}
```
### GET /api/v1/audit/export
Exporta eventos em formato JSON para integração com SIEM. Retorna um arquivo `.json` com todos os eventos no período especificado.
```bash theme={"system"}
# Exportar últimas 24 horas
curl -s -o audit-export.json \
"https://chatcli.example.com/api/v1/audit/export?\
from=2026-03-18T14:00:00Z&\
to=2026-03-19T14:00:00Z"
# Verificar tamanho do export
wc -l audit-export.json
# 312 linhas (1 evento por linha, formato NDJSON)
```
**Formato do export (NDJSON):**
```json theme={"system"}
{"name":"audit-1710856200-a7f3b2","eventType":"RemediationExecuted","timestamp":"2026-03-19T14:30:00.123Z","actor":{"type":"controller","name":"remediation-reconciler"},"resource":{"kind":"RemediationPlan","name":"plan-rollback-api-server","namespace":"production"},"details":{"action":"Rollback"},"correlationID":"inc-8f2a4b","severity":"high"}
{"name":"audit-1710856245-c9d4e1","eventType":"RemediationSucceeded","timestamp":"2026-03-19T14:30:12.456Z","actor":{"type":"controller","name":"remediation-reconciler"},"resource":{"kind":"RemediationPlan","name":"plan-rollback-api-server","namespace":"production"},"details":{"duration":"12s"},"correlationID":"inc-8f2a4b","severity":"high"}
```
## Integração com SIEM
A plataforma suporta exportação de eventos para sistemas SIEM (Security Information and Event Management) como Splunk, Elastic e Datadog.
### Splunk
Crie um HEC token no Splunk para receber eventos da plataforma AIOps.
```yaml theme={"system"}
apiVersion: batch/v1
kind: CronJob
metadata:
name: audit-export-splunk
namespace: chatcli-system
spec:
schedule: "*/15 * * * *" # A cada 15 minutos
jobTemplate:
spec:
template:
spec:
containers:
- name: exporter
image: curlimages/curl:latest
command:
- /bin/sh
- -c
- |
# Exporta últimos 20 minutos (overlap de 5 min para segurança)
FROM=$(date -u -d '20 minutes ago' +%Y-%m-%dT%H:%M:%SZ)
TO=$(date -u +%Y-%m-%dT%H:%M:%SZ)
curl -s "http://chatcli-server.chatcli-system:8080/api/v1/audit/export?from=$FROM&to=$TO" | \
while IFS= read -r line; do
curl -s -X POST \
"https://splunk.example.com:8088/services/collector/event" \
-H "Authorization: Splunk $SPLUNK_HEC_TOKEN" \
-d "{\"event\": $line, \"sourcetype\": \"chatcli:audit\"}"
done
env:
- name: SPLUNK_HEC_TOKEN
valueFrom:
secretKeyRef:
name: splunk-credentials
key: hec-token
restartPolicy: OnFailure
```
Configure um index dedicado `chatcli_audit` no Splunk e crie dashboards
para visualizar eventos por tipo, severidade e ator.
### Elasticsearch
```yaml theme={"system"}
apiVersion: batch/v1
kind: CronJob
metadata:
name: audit-export-elastic
namespace: chatcli-system
spec:
schedule: "*/15 * * * *"
jobTemplate:
spec:
template:
spec:
containers:
- name: exporter
image: curlimages/curl:latest
command:
- /bin/sh
- -c
- |
FROM=$(date -u -d '20 minutes ago' +%Y-%m-%dT%H:%M:%SZ)
TO=$(date -u +%Y-%m-%dT%H:%M:%SZ)
curl -s "http://chatcli-server.chatcli-system:8080/api/v1/audit/export?from=$FROM&to=$TO" | \
while IFS= read -r line; do
curl -s -X POST \
"https://elastic.example.com:9200/chatcli-audit/_doc" \
-H "Content-Type: application/json" \
-u "$ELASTIC_USER:$ELASTIC_PASS" \
-d "$line"
done
env:
- name: ELASTIC_USER
valueFrom:
secretKeyRef:
name: elastic-credentials
key: username
- name: ELASTIC_PASS
valueFrom:
secretKeyRef:
name: elastic-credentials
key: password
restartPolicy: OnFailure
```
## Comandos kubectl
```bash theme={"system"}
# Listar todos os eventos de auditoria
kubectl get auditevents -n chatcli-system
# Filtrar por tipo de evento
kubectl get auditevents -n chatcli-system \
-l platform.chatcli.io/event-type=RemediationExecuted
# Filtrar por severidade
kubectl get auditevents -n chatcli-system \
-l platform.chatcli.io/severity=critical
# Filtrar por correlação (todos os eventos de um incidente)
kubectl get auditevents -n chatcli-system \
-l platform.chatcli.io/correlation-id=inc-8f2a4b \
--sort-by=.spec.timestamp
# Ver detalhes de um evento específico
kubectl get auditevent audit-1710856200-a7f3b2 -n chatcli-system -o yaml
# Contar eventos por tipo (últimas 24h)
kubectl get auditevents -n chatcli-system -o json | \
jq '[.items[].spec.eventType] | group_by(.) | map({type: .[0], count: length})'
# Verificar roles RBAC configuradas
kubectl get clusterroles -l platform.chatcli.io/rbac-role
# Listar bindings de um usuário
kubectl get clusterrolebindings -l platform.chatcli.io/rbac-role \
-o jsonpath='{range .items[*]}{.metadata.name}: {.subjects[*].name}{"\n"}{end}'
# Gerar relatório de compliance (via API)
curl -s "https://chatcli.example.com/api/v1/compliance/report?\
namespace=production&window=7d" | jq .
```
## Retenção de Eventos
AuditEvents são imutáveis mas não eternos. Configure uma política de retenção
para evitar acúmulo excessivo de CRs no etcd.
```yaml theme={"system"}
# CronJob para limpeza de eventos antigos (>90 dias)
apiVersion: batch/v1
kind: CronJob
metadata:
name: audit-retention
namespace: chatcli-system
spec:
schedule: "0 2 * * 0" # Todo domingo às 02:00
jobTemplate:
spec:
template:
spec:
serviceAccountName: chatcli-superadmin
containers:
- name: cleanup
image: bitnami/kubectl:latest
command:
- /bin/sh
- -c
- |
CUTOFF=$(date -u -d '90 days ago' +%Y-%m-%dT%H:%M:%SZ)
kubectl get auditevents -n chatcli-system -o json | \
jq -r ".items[] | select(.spec.timestamp < \"$CUTOFF\") | .metadata.name" | \
xargs -r kubectl delete auditevent -n chatcli-system
restartPolicy: OnFailure
```
## Próximos Passos
Veja como cada decisão do motor gera AuditEvents para rastreabilidade
completa.
AuditEvents cross-cluster com CorrelationID unificado.
Experimentos de chaos geram eventos de auditoria para compliance de game
days.
Retorne à visão geral da plataforma AIOps.