Ops-automazione e script

1) Perché automatizzare le operazioni

Riduce MTTR/errori umani, accelera i rilasci e le reazioni.
Rende le azioni ripetibili e verificabili (completamento).
Libera il tempo degli ingegneri per migliorare, non la routine.

2) Principi di base

1. Idampotenza: reimpostare lo stesso risultato.
2. Ringhiere sicure: dry-run, conferme, limiti, autotrasportatori.
3. Osservabilità: loghi/metriche/trailer integrati in ogni script/pipline.
4. Configurazione> costanti nel codice: tutto attraverso parametri/manifesti.
5. GitOps/Docs-as-Code: il codice delle operazioni viene versionato, rivitalizzato, testato.
6. Piccoli passi: canaretti, batch, retrai con budget.
7. Nessun segreto nel repo, solo attraverso il magazzino segreto.

3) Classi attività di automazione

Rimediazioni e incidenti: rimborsi, cambi di provider, flag di flagellazione fich.
Operazioni di routine: rotazioni di certificati/chiavi, migrazioni di database (expand→migrate→contract).
Gestione dell'infrastruttura: IaC, configurazioni, manifesti K8s.
Dati e DataOps: backfill, ETL, convalida di qualità.
Esercitazioni Xaoc/DR - Simulazioni di guasti di protezione.

4) Come selezionare uno strumento

Bash - script glue brevi, orchestra CLI.
Python - logica/SDK, retrai, API, lavoro con JSON/YAML.
Ansable è una configurazione idempotente, non servono agenti.
Terraform è un'infrastruttura dichiarativa.
Kubernets Jobs/CronJobs - attività/pianificazione batch.
Argo/Airflow - dipendenti DAG-E e orchestrazione.
ChatOps è un avvio sicuro da una chat con un controllo.

5) Architettura automatica (arbitro)

CLI/ChatOps → Controller (GitOps/orchestratore) → Esecutori (Ancible/Terraform/K8s Job) → Monitoraggio (logi/metriche/trailer) → Controllo/ticketing → Docks (evidence).

6) Idampotenza e gestione dello stato

«Controlla, poi cambia»: detect-then-act (se già OK, non fare niente).
Memorizza i marchi di completamento per le procedure lunghe.
Le procedure vengono suddivise in passi atomici con possibilità di riprovazione.

7) Errori, retrai e rimborsi

Retrai con ritardo esponenziale e jitter.
Budget dell'operazione (SLA totale per attività).
I ripristini e il pulsante di arresto sono sempre disponibili.
Codici di restituzione chiari e errori strutturati.

8) Sicurezza e segreti

RBAC/ABAC, privilegi minimi, token temporanei (JIT/JEA).
I segreti di Vault/KMS/Cloud Secret Manager; le chiavi vengono rotate.
«Condivisione dei doveri»: chi scrive non è uno che approva e lancia in vendita.
Registro di controllo: chi/quando/cosa/con quale risultato.

9) GitOps и ChatOps

I test

I comandi in chat (ad esempio, '/ops deploy checkout --canary 5% ') richiamano i pipeline; I bot applicano evidence e riferimenti ai dashboard.

10) Pianificazione e orchestrazione

CronJobs/DAG con dipendenze e deadline.
Concorrenza: «Forbid», «Replace», «Allow» (K8s) a seconda dell'attività.
Regole di risorse/quote per non «mangiare» il prode.

11) Osservabilità automatica

Metriche: successo/errore, durata, retrai, oggetti interessati.
Fogli: strutturati, correlation-ID, stringa rossa su errore.
I passaggi delle lunghe operazioni sono visibili nei tracciati distribuiti.
Alert: per sintomi (SLO) e per metriche tecniche (deadline,% errori).

12) Test e simulazioni

Test unit di logica e parser degli artefatti.
Test di integrazione in sabbia e canarino.
«Maggini» (dry-run + provider fittizi), replay di script reali.
Obiettivi chiari, gate di sicurezza, AAR→RCA→CAPA.

13) Modelli di codice

Bash (scheletro con ringhiera)

bash
!/usr/bin/env bash set -Eeuo pipefail trap 'echo "[ERR] line $LINENO"; exit 1' ERR

log(){ printf '%s %s\n' "$(date -Iseconds)" "$"; }
DRY=${DRY_RUN--true}

ensure_dep(){ command -v "$1" >/dev/null          { echo "need $1"; exit 2; }; }

apply_change(){
local target="$1"
if [[ "$DRY" == "true" ]]; then log "[DRY] would update $target"
else kubectl apply -f "$target"
fi
}

main(){
ensure_dep kubectl for f in manifests/.yaml; do apply_change "$f"
done log "done"
}
main "$@"

Python (retrai + idampotenza)

python import argparse, time, json, sys from pathlib import Path import requests

def with_retries(fn, attempts=5, base=0. 2):
for i in range(attempts):
try:
return fn()
except Exception as e:
sleep = base (2i)
time. sleep(sleep)
raise

def already_done(marker):
return Path(marker). exists()

def mark_done(marker):
Path(marker). write_text("ok")

def main():
ap = argparse. ArgumentParser()
ap. add_argument("--endpoint", required=True)
ap. add_argument("--marker", default="/tmp/op. marker")
args = ap. parse_args()

if already_done(args. marker):
print("idempotent: nothing to do"); return

def call():
r = requests. post(args. endpoint, json={"action":"rotate"})
r. raise_for_status()
return r. json()

resp = with_retries(call)
print(json. dumps(resp))
mark_done(args. marker)

if __name__ == "__main__":
sys. exit(main())

Ansibile (attività idipotente)

yaml
- hosts: web become: true tasks:
- name: Ensure nginx present and enabled ansible. builtin. package:
name: nginx state: present
- name: Deploy config ansible. builtin. template:
src: nginx. conf. j2 dest: /etc/nginx/nginx. conf mode: '0644'
notify: restart nginx handlers:
- name: restart nginx ansible. builtin. service:
name: nginx state: restarted

Kubernets CronJob (rotazione programmata)

yaml apiVersion: batch/v1 kind: CronJob metadata:
name: cert-rotate spec:
schedule: "0 3  "
concurrencyPolicy: Forbid jobTemplate:
spec:
template:
spec:
serviceAccountName: ops-automation restartPolicy: OnFailure containers:
- name: rotator image: registry/ops/rotator:1. 2. 3 args: ["--rotate", "--budget-ms=60000"]
envFrom:
- secretRef: { name: rotator-secrets }

GitHub Action (trigger ChatOps)

yaml name: ops-deploy on:
workflow_dispatch:
inputs:
service: {required: true}
canary: {required: false, default: "5"}
jobs:
deploy:
runs-on: ubuntu-latest steps:
- uses: actions/checkout@v4
- run:./scripts/deploy. sh "${{ inputs. service }}" --canary "${{ inputs. canary }}"

14) Assegno foglio di implementazione

• Per ogni operazione è selezionato uno strumento e viene descritto il runbook.
• Ci sono dry-run, conferme e limiti (ringhiera).
• I loghi sono strutturati, le metriche e gli alert sono collegati.
• I segreti dal magazzino sono disponibili minimi e temporanei.
• I test (unit/integrazione/canarino) e le simulazioni sono stati eseguiti.
• I gitOps/PR sono obbligatori, c'è un controllo.
• Il piano di recupero e i criteri di successo sono documentati.
• L'automazione è collegata a SLO/budget degli errori.

15) Anti-pattern

Script senza idepotenza o rimborsi.
«Segreti nel codice», insegne superadimine su tutto.
Modifiche manuali in vendita senza controllo.
Un Bash Zoo di pezzi, invece di un IaC.
Opzioni cucite nel codice - Nessun riutilizzo.
Niente dry-run/canarini per grandi esplosioni.
Loghi umani senza struttura o corellazione.

16) Metriche di maturità Ops-automazione

Coverage:% di operazioni di automazione e runbook.
Success rate/Retry rate attività automatiche.
Mean time to execute (durata media) e on-time (deadline).
Change failure rate prima/dopo l'automazione.
Controllo completo:% delle attività con evidence completa.
Security: tempo di rotazione chiavi/certificati, quota di disponibilità JIT.

17) Totale

L'automazione dell'ops non è un insieme di script dislocati, ma un sistema: azioni idropotenti, ringhiere sicure, osservabilità, segreti e accessibilità sotto controllo, test e esercitazioni. In questo sistema, le operazioni diventano veloci, prevedibili e audibili - e le imprese ottengono rapporti stabili e un basso rischio di incidenti.