@noeva/etl-core 1.0.0-next.2 → 1.0.0-next.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (83) hide show
  1. package/README.md +10 -8
  2. package/deploy/deploy-ecr.sh +441 -0
  3. package/dist/cli.js +118 -117
  4. package/dist/connectors/sqlserver.js +1 -1
  5. package/dist/etl.config.js +13 -121
  6. package/dist/guida/404.html +2 -2
  7. package/dist/guida/GUIDA_SVILUPPO.html +4 -4
  8. package/dist/guida/TECHNICAL_OVERVIEW.html +4 -4
  9. package/dist/guida/assets/{app.BMz6ZZYF.js → app.lWZ5GK2m.js} +1 -1
  10. package/dist/guida/assets/chunks/@localSearchIndexroot.B5zFGbAC.js +1 -0
  11. package/dist/guida/assets/chunks/{VPLocalSearchBox.D8gO6gDY.js → VPLocalSearchBox.C0h2R-Ih.js} +1 -1
  12. package/dist/guida/assets/chunks/{theme.DV62mViB.js → theme.BYWumH0G.js} +2 -2
  13. package/dist/guida/assets/runbooks_deploy-ecr.md.6M67F85S.js +45 -0
  14. package/dist/guida/assets/runbooks_deploy-ecr.md.6M67F85S.lean.js +1 -0
  15. package/dist/guida/assets/{runbooks_deployment.md.DvIOOsoG.js → runbooks_deployment.md.CsIYRa_5.js} +7 -5
  16. package/dist/guida/assets/runbooks_deployment.md.CsIYRa_5.lean.js +1 -0
  17. package/dist/guida/assets/{runbooks_graph-server.md.BOXZqdXC.js → runbooks_graph-server.md.opGHnuzK.js} +2 -2
  18. package/dist/guida/assets/{runbooks_graph-server.md.BOXZqdXC.lean.js → runbooks_graph-server.md.opGHnuzK.lean.js} +1 -1
  19. package/dist/guida/connectors/README.html +4 -4
  20. package/dist/guida/connectors/file.html +4 -4
  21. package/dist/guida/connectors/http.html +4 -4
  22. package/dist/guida/connectors/imap.html +4 -4
  23. package/dist/guida/connectors/jira.html +4 -4
  24. package/dist/guida/connectors/noeva.html +4 -4
  25. package/dist/guida/connectors/oauth.html +4 -4
  26. package/dist/guida/connectors/postgres.html +4 -4
  27. package/dist/guida/connectors/process.html +4 -4
  28. package/dist/guida/connectors/sendgrid.html +4 -4
  29. package/dist/guida/connectors/smtp.html +4 -4
  30. package/dist/guida/connectors/sqlserver.html +4 -4
  31. package/dist/guida/conventions/node-columns.html +4 -4
  32. package/dist/guida/conventions/node-descriptor.html +4 -4
  33. package/dist/guida/conventions/run-report.html +4 -4
  34. package/dist/guida/conventions/run-trace.html +4 -4
  35. package/dist/guida/conventions/variabili-del-core.html +4 -4
  36. package/dist/guida/conventions/versioni-di-pipeline.html +4 -4
  37. package/dist/guida/guide/claude-code/index.html +4 -4
  38. package/dist/guida/guide/claude-code/prompt.html +4 -4
  39. package/dist/guida/guide/claude-code/strumenti.html +4 -4
  40. package/dist/guida/guide/grafo.html +4 -4
  41. package/dist/guida/guide/usare/app-desktop.html +4 -4
  42. package/dist/guida/guide/usare/esito-di-una-run.html +4 -4
  43. package/dist/guida/guide/usare/index.html +4 -4
  44. package/dist/guida/hashmap.json +1 -1
  45. package/dist/guida/index.html +3 -3
  46. package/dist/guida/nodes/README.html +4 -4
  47. package/dist/guida/nodes/action.html +4 -4
  48. package/dist/guida/nodes/ai.html +4 -4
  49. package/dist/guida/nodes/join.html +4 -4
  50. package/dist/guida/nodes/lookup.html +4 -4
  51. package/dist/guida/nodes/pipeline.html +4 -4
  52. package/dist/guida/nodes/route.html +4 -4
  53. package/dist/guida/nodes/sink.html +4 -4
  54. package/dist/guida/nodes/source.html +4 -4
  55. package/dist/guida/nodes/task.html +4 -4
  56. package/dist/guida/nodes/transform.html +4 -4
  57. package/dist/guida/nodes/try-catch.html +4 -4
  58. package/dist/guida/nodes/union.html +4 -4
  59. package/dist/guida/pagine.json +1 -0
  60. package/dist/guida/pipelines/README.html +4 -4
  61. package/dist/guida/pipelines/crm-leads-sync.html +4 -4
  62. package/dist/guida/pipelines/cross-workspace-csv-merge.html +4 -4
  63. package/dist/guida/pipelines/movimenti-per-conto.html +4 -4
  64. package/dist/guida/pipelines/orders-enriched-daily.html +4 -4
  65. package/dist/guida/pipelines/test-posta.html +4 -4
  66. package/dist/guida/runbooks/aggiornamento-pm2.html +5 -5
  67. package/dist/guida/runbooks/deploy-ecr.html +71 -0
  68. package/dist/guida/runbooks/deployment.html +11 -9
  69. package/dist/guida/runbooks/etl-worker.html +4 -4
  70. package/dist/guida/runbooks/graph-server.html +6 -6
  71. package/dist/guida/runbooks/mask-key.html +4 -4
  72. package/dist/guida/runbooks/oauth-google-posta.html +4 -4
  73. package/dist/guida/runbooks/rollback-di-pipeline.html +4 -4
  74. package/dist/guida/runbooks/scd2-rehash.html +4 -4
  75. package/dist/guida/runbooks/sql-task-truncate-swap.html +4 -4
  76. package/dist/guida/runbooks/stato-incrementale.html +4 -4
  77. package/dist/guida/sub-pipelines/README.html +4 -4
  78. package/dist/guida/sub-pipelines/riepilogo-ordini.html +4 -4
  79. package/docs/.vitepress/lib/published-docs.ts +0 -21
  80. package/package.json +1 -2
  81. package/dist/chunk-DFFLQC6T.js +0 -1
  82. package/dist/guida/assets/chunks/@localSearchIndexroot.B3bE99g8.js +0 -1
  83. package/dist/guida/assets/runbooks_deployment.md.DvIOOsoG.lean.js +0 -1
package/README.md CHANGED
@@ -24,13 +24,13 @@ pnpm run docs:dev # la guida del core in locale con etl docs dev (ADR-0043, ADR
24
24
 
25
25
  # CLI: elenca ed esegui le pipeline (legge le env da .env)
26
26
  pnpm run etl list
27
- pnpm run etl run langfuse-sessions-daily
27
+ pnpm run etl run orders-enriched-daily
28
28
 
29
29
  # storico locale: ogni run conclusa lascia il suo report in .runs/ (ADR-0039),
30
30
  # consultabile senza UI e senza rete
31
31
  pnpm run etl runs list
32
32
  pnpm run etl runs show <runId> # basta un prefisso non ambiguo
33
- pnpm run etl runs list --pipeline langfuse-sessions-daily --limit 5
33
+ pnpm run etl runs list --pipeline orders-enriched-daily --limit 5
34
34
  pnpm run etl runs show <runId> --json # report grezzo, per comporre con jq
35
35
 
36
36
  # run tracciata: il percorso dei primi record di ogni source e dei loro derivati,
@@ -114,20 +114,22 @@ config arriva da variabili d'ambiente. Tre modi di avviarla:
114
114
  anche la traccia dei record ([La traccia di una run](docs/conventions/run-trace.md)).
115
115
 
116
116
  Il `Dockerfile` alla radice di questo repo costruisce ancora l'immagine del **core**, con tutte le
117
- sue pipeline, per il job interno che gira da ECR finché non migra al suo repo cliente:
117
+ sue pipeline, per i clienti che girano da ECR finché non migrano ai loro repo cliente:
118
118
 
119
119
  ```bash
120
120
  docker build -t noeva-etl .
121
121
  docker run --rm --env-file .env -p 3005:3005 noeva-etl # serve: grafi + worker
122
122
  docker run --rm noeva-etl list
123
- docker run --rm --env-file .env noeva-etl run langfuse-sessions-daily
123
+ docker run --rm --env-file .env noeva-etl run <pipeline>
124
124
  ```
125
125
 
126
- Deploy su **ECR** ed esecuzione rapida da ECR con gli script (solo worker):
126
+ Deploy su **ECR** di un cliente che ha ancora la sua `clienti/<cliente>/deploy-ecr.conf` nel core
127
+ (ADR-0104). Lo strumento è quello del pacchetto, che un repo cliente lancia con
128
+ `etl deploy-ecr <cliente>` ([runbook](docs/runbooks/deploy-ecr.md)):
127
129
 
128
130
  ```bash
129
- ./deploy-ecr.sh <cliente> # controlli + gate + build + push dell'immagine di un cliente (ADR-0104)
130
- ./run-ecr.sh langfuse-sessions-daily # pull da ECR ed esegui la pipeline (Docker Desktop)
131
+ ./deploy-ecr.sh <cliente> --dry-run # controlli; senza --dry-run anche gate, build, push e tag di deploy
132
+ pnpm run etl deploy-ecr <cliente> --dry-run # lo stesso, dalla CLI
131
133
  ```
132
134
 
133
135
  La UI (`noeva-etl-ui`) **non** passa da ECR: è un'app desktop Tauri, che si builda nel suo
@@ -164,7 +166,7 @@ Le transform pronte della libreria (`mapColumns`, `groupBy`, `dedup`, `explode`,
164
166
  `serialize`, `hashRow`, `surrogateKey`, `mask`, `profile`, `assert`), con la corrispondenza Talend, sono nel catalogo di
165
167
  [`docs/nodes/transform.md`](docs/nodes/transform.md#transform-pronte).
166
168
 
167
- Esempio end-to-end (dati reali Postgres): [`src/pipelines/langfuse-sessions-daily/`](src/pipelines/langfuse-sessions-daily/).
169
+ Esempio end-to-end (join, ramo `catch`, sub-pipeline): [`src/pipelines/orders-enriched-daily/`](src/pipelines/orders-enriched-daily/).
168
170
 
169
171
  ## Regole del progetto (da leggere)
170
172
 
@@ -0,0 +1,441 @@
1
+ #!/usr/bin/env bash
2
+ # ============================================================================
3
+ # deploy-ecr.sh — mette in servizio il runner ETL di UN cliente (ADR-0104).
4
+ #
5
+ # Ogni cliente ha la sua immagine su ECR, il suo `.env` nel bucket S3 del suo
6
+ # servizio e il suo servizio ECS. Lo script porta l'immagine su ECR con i due
7
+ # tag che la CodePipeline del servizio si aspetta (noeva-terraform,
8
+ # modules/ecs_service): il tag di deploy (`latest` in produzione, `staging` in
9
+ # staging) e un tag di rilascio immutabile `AAAAMMGG-hhmmss-<sha7>`. Il push del
10
+ # tag di deploy fa partire la CodePipeline, che aggiorna il servizio ECS.
11
+ #
12
+ # Questo file è la parte CORE: uguale per tutti i clienti, non ne nomina
13
+ # nessuno, e arriva col pacchetto (ETL-216). Lavora sulla cartella da cui si
14
+ # lancia, la radice del repo cliente. Ciò che è del cliente sta nella sua
15
+ # `deploy-ecr.conf` alla radice (nel core, finché ci sono clienti, in
16
+ # `clienti/<cliente>/deploy-ecr.conf`): repository ECR, servizio e bucket per
17
+ # ambiente, pipeline del suo catalogo, variabili obbligatorie o vietate,
18
+ # submodule che l'immagine copia. L'immagine si costruisce col Dockerfile alla
19
+ # radice se il repo l'ha preso (`unmanaged`), altrimenti con quello del
20
+ # pacchetto, accanto a questo file.
21
+ #
22
+ # Uso:
23
+ # etl deploy-ecr <cliente> [opzioni]
24
+ #
25
+ # Opzioni:
26
+ # --ambiente production|staging default production
27
+ # --env <file> carica questo .env nel bucket del servizio, dopo i
28
+ # controlli e una conferma (default: si usa quello già lì)
29
+ # --solo-env aggiorna solo il .env (con --env) e riavvia il servizio,
30
+ # senza build
31
+ # --attendi aspetta la fine della CodePipeline e un servizio stabile
32
+ # --solo-ecr pubblica l'immagine senza guardare servizio ECS e bucket:
33
+ # per pushare prima che il servizio esista. Con --env il
34
+ # file si controlla soltanto, non si carica
35
+ # --dry-run solo i controlli: niente gate, build, push né upload
36
+ # --skip-check salta il gate, `pnpm run check` o `etl ci` (sconsigliato)
37
+ # --no-cache build senza cache
38
+ # --platform <p> amd64, arm64 o all (default: quella del cliente, o amd64)
39
+ # -h, --help
40
+ #
41
+ # Esempi:
42
+ # etl deploy-ecr acme --dry-run
43
+ # etl deploy-ecr acme --env ~/segreti/acme-production.env --attendi
44
+ # etl deploy-ecr acme --solo-env --env ~/segreti/acme-production.env
45
+ # etl deploy-ecr acme --solo-ecr --env ~/segreti/acme-production.env
46
+ #
47
+ # Override da ambiente: AWS_PROFILE (default `default`), AWS_REGION (default
48
+ # eu-west-1). Requisiti: AWS CLI v2, Docker con buildx, jq, git, pnpm.
49
+ # Nessun segreto nell'immagine: la configurazione arriva a runtime dal .env.
50
+ # ============================================================================
51
+ set -euo pipefail
52
+
53
+ RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[1;33m'; BLUE='\033[0;34m'; NC='\033[0m'
54
+ errore() { echo -e "${RED}❌ $*${NC}" >&2; exit 1; }
55
+ avviso() { echo -e "${YELLOW}⚠️ $*${NC}"; }
56
+ passo() { echo -e "${YELLOW}▶ $*${NC}"; }
57
+ ok() { echo -e "${GREEN}✅ $*${NC}"; }
58
+
59
+ # La cartella dello script, nel pacchetto installato o nel repo del core: lì
60
+ # accanto c'è il Dockerfile dell'artefatto. La radice del repo è la cwd.
61
+ DIR_SCRIPT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
62
+
63
+ # Regole del core: quale tag fa partire la CodePipeline e da che branch si
64
+ # deploya, per ambiente. Lo stesso repository ECR serve staging e produzione,
65
+ # che si distinguono solo per il tag di deploy (noeva-terraform, NW-656).
66
+ # Funzioni e non array associativi: il bash di macOS è il 3.2.
67
+ tag_deploy() { case "$1" in production) echo latest ;; staging) echo staging ;; esac; }
68
+ branch_ammesso() { case "$1" in production) echo main ;; staging) echo staging ;; esac; }
69
+ # Variabili senza cui `etl serve` non parte, per ogni cliente.
70
+ ENV_CORE=(NOEVA_API_BASE_URL NOEVA_API_KEY)
71
+ ATTESA_PIPELINE_S=1200
72
+
73
+ # La configurazione del cliente: quella del repo cliente alla radice o, nel
74
+ # core, quella in clienti/<cliente>/.
75
+ conf_del_cliente() {
76
+ if [ -f deploy-ecr.conf ]; then echo deploy-ecr.conf
77
+ elif [ -f "clienti/$1/deploy-ecr.conf" ]; then echo "clienti/$1/deploy-ecr.conf"
78
+ else errore "Manca deploy-ecr.conf alla radice del repo: il cliente dichiara lì il suo deploy (lancia il comando dalla radice)"
79
+ fi
80
+ }
81
+
82
+ # La conf di un repo cliente sta alla radice e vale qualunque cliente si passi:
83
+ # con CLIENTE_SLUG dichiara di chi è, e uno slug sbagliato si ferma qui invece
84
+ # di finire nella label dell'immagine e nel tag git del deploy.
85
+ verifica_slug() {
86
+ [ -z "${CLIENTE_SLUG:-}" ] || [ "${CLIENTE_SLUG}" = "$1" ] \
87
+ || errore "${CONF} è di ${CLIENTE_SLUG}, non di $1"
88
+ }
89
+
90
+ # Il gate prima della build: quello del core, o `etl ci` in un repo cliente.
91
+ gate_del_repo() {
92
+ if jq -e '.scripts.check' package.json >/dev/null 2>&1; then echo "pnpm run check"
93
+ else echo "pnpm exec etl ci"
94
+ fi
95
+ }
96
+
97
+ # Il Dockerfile alla radice se il repo l'ha preso, altrimenti quello del pacchetto.
98
+ dockerfile_del_repo() {
99
+ if [ -f Dockerfile ]; then echo Dockerfile; else echo "${DIR_SCRIPT}/Dockerfile"; fi
100
+ }
101
+
102
+ uso() { sed -n '/^# Uso:/,/^# Override/p' "$0" | sed 's/^# \{0,1\}//' | sed '$d'; }
103
+
104
+ # --- Argomenti --------------------------------------------------------------
105
+ CLIENTE=""; AMBIENTE="production"; ENV_FILE=""; SOLO_ENV=false; SOLO_ECR=false; ATTENDI=false
106
+ DRY_RUN=false; SKIP_CHECK=false; NO_CACHE=(); PIATTAFORMA_ARG=""
107
+ while [[ $# -gt 0 ]]; do
108
+ case "$1" in
109
+ --ambiente) AMBIENTE="${2:-}"; shift 2 ;;
110
+ --env) ENV_FILE="${2:-}"; shift 2 ;;
111
+ --solo-env) SOLO_ENV=true; shift ;;
112
+ --solo-ecr) SOLO_ECR=true; shift ;;
113
+ --attendi) ATTENDI=true; shift ;;
114
+ --dry-run) DRY_RUN=true; shift ;;
115
+ --skip-check) SKIP_CHECK=true; shift ;;
116
+ --no-cache) NO_CACHE=(--no-cache); shift ;;
117
+ --platform) PIATTAFORMA_ARG="${2:-}"; shift 2 ;;
118
+ -h|--help) uso; exit 0 ;;
119
+ --*) errore "Opzione sconosciuta: $1 (vedi --help)" ;;
120
+ *) [ -z "${CLIENTE}" ] || errore "Un solo cliente per volta"; CLIENTE="$1"; shift ;;
121
+ esac
122
+ done
123
+ [ -n "${CLIENTE}" ] || { uso; errore "Manca il cliente: etl deploy-ecr <cliente>"; }
124
+ [[ "${CLIENTE}" =~ ^[a-z0-9][a-z0-9-]*$ ]] || errore "Nome cliente non valido: ${CLIENTE}"
125
+ [ -n "$(tag_deploy "${AMBIENTE}")" ] || errore "Ambiente sconosciuto: ${AMBIENTE} (production o staging)"
126
+ TAG="$(tag_deploy "${AMBIENTE}")"
127
+ if [ "${SOLO_ENV}" = true ] && [ -z "${ENV_FILE}" ]; then errore "--solo-env vuole --env <file>"; fi
128
+ if [ "${SOLO_ECR}" = true ] && { [ "${SOLO_ENV}" = true ] || [ "${ATTENDI}" = true ]; }; then
129
+ errore "--solo-ecr non tocca il servizio: non si combina con --solo-env né con --attendi"
130
+ fi
131
+
132
+ # --- Configurazione del cliente --------------------------------------------
133
+ CONF="$(conf_del_cliente "${CLIENTE}")"
134
+ CLIENTE_NOME=""; CLIENTE_SLUG=""; ECR_REPOSITORY=""; AWS_ACCOUNT_ATTESO=""; PIATTAFORME=""
135
+ PIPELINE=(); ENV_OBBLIGATORIE=(); ENV_VIETATE=(); SUBMODULE=()
136
+ # shellcheck source=/dev/null
137
+ source "${CONF}"
138
+ verifica_slug "${CLIENTE}"
139
+ [ -n "${ECR_REPOSITORY}" ] || errore "${CONF}: manca ECR_REPOSITORY"
140
+
141
+ var_ambiente() { local nome="${1}_${AMBIENTE}"; echo "${!nome:-}"; }
142
+ ECS_CLUSTER="$(var_ambiente ECS_CLUSTER)"
143
+ ECS_SERVICE="$(var_ambiente ECS_SERVICE)"
144
+ ENV_BUCKET="$(var_ambiente ENV_BUCKET)"
145
+ if [ -n "${ECS_SERVICE}" ] && { [ -z "${ECS_CLUSTER}" ] || [ -z "${ENV_BUCKET}" ]; }; then
146
+ errore "${CONF}: con ECS_SERVICE_${AMBIENTE} servono anche ECS_CLUSTER_${AMBIENTE} ed ENV_BUCKET_${AMBIENTE}"
147
+ fi
148
+ # Un cliente con dei servizi ECS non pubblica immagini per un ambiente in cui non ne ha:
149
+ # il tag di deploy finirebbe su ECR senza una CodePipeline che lo aspetta.
150
+ if [ -z "${ECS_SERVICE}" ] && compgen -v ECS_SERVICE_ >/dev/null; then
151
+ errore "${CLIENTE} non ha un servizio in ${AMBIENTE}: dichiaralo in ${CONF} (ECS_SERVICE_${AMBIENTE})"
152
+ fi
153
+ # Con --solo-ecr il servizio non si guarda: lo script si comporta come per un cliente
154
+ # senza servizio, ma il tag di deploy resta quello dell'ambiente.
155
+ if [ "${SOLO_ECR}" = true ]; then
156
+ ECS_SERVICE=""; ECS_CLUSTER=""; ENV_BUCKET=""
157
+ fi
158
+ if [ -z "${ECS_SERVICE}" ] && { { [ -n "${ENV_FILE}" ] && [ "${SOLO_ECR}" = false ]; } || [ "${ATTENDI}" = true ]; }; then
159
+ errore "${CLIENTE} non ha un servizio ECS in ${AMBIENTE}: --env e --attendi non si applicano"
160
+ fi
161
+
162
+ case "${PIATTAFORMA_ARG:-${PIATTAFORME:-amd64}}" in
163
+ amd64|linux/amd64) PIATTAFORME="linux/amd64" ;;
164
+ arm64|linux/arm64) PIATTAFORME="linux/arm64" ;;
165
+ all|linux/amd64,linux/arm64) PIATTAFORME="linux/amd64,linux/arm64" ;;
166
+ *) errore "Piattaforma non supportata: ${PIATTAFORMA_ARG:-${PIATTAFORME}}" ;;
167
+ esac
168
+
169
+ AWS_PROFILE="${AWS_PROFILE:-default}"
170
+ AWS_REGION="${AWS_REGION:-eu-west-1}"
171
+ aws_() { aws --profile "${AWS_PROFILE}" --region "${AWS_REGION}" "$@"; }
172
+
173
+ echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
174
+ echo -e "${BLUE}🚀 Deploy runner ETL — ${CLIENTE_NOME:-${CLIENTE}} (${AMBIENTE})${NC}"
175
+ echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
176
+ echo -e " Repository: ${GREEN}${ECR_REPOSITORY}${NC}"
177
+ echo -e " Servizio: ${GREEN}${ECS_SERVICE:-$([ "${SOLO_ECR}" = true ] && echo "non controllato (--solo-ecr)" || echo "nessuno, solo immagine")}${ECS_CLUSTER:+ su ${ECS_CLUSTER}}${NC}"
178
+ echo -e " Bucket .env: ${GREEN}${ENV_BUCKET:-nessuno}${NC}"
179
+ echo -e " Piattaforme: ${GREEN}${PIATTAFORME}${NC}"
180
+ [ "${DRY_RUN}" = true ] && echo -e " Modalità: ${YELLOW}dry-run, nessuna modifica${NC}"
181
+ echo ""
182
+
183
+ # --- Controlli sul .env -----------------------------------------------------
184
+ # Il testo del .env resta in memoria: si leggono le chiavi, e il valore delle
185
+ # sole variabili non segrete che servono ai controlli. Il formato è quello degli
186
+ # `environmentFiles` di ECS, che non toglie virgolette né `export`.
187
+ chiavi_env() { awk -F= '/^[A-Za-z_][A-Za-z0-9_]*=/{print $1}' <<<"$1" | sort -u; }
188
+ valore_env() { awk -v k="$2" 'index($0, k "=") == 1 {print substr($0, length(k) + 2); exit}' <<<"$1"; }
189
+
190
+ controlla_env() {
191
+ local testo="$1" origine="$2" problemi=() chiave valore voce
192
+ for chiave in "${ENV_CORE[@]}" ${ENV_OBBLIGATORIE[@]+"${ENV_OBBLIGATORIE[@]}"}; do
193
+ [ -n "$(valore_env "${testo}" "${chiave}")" ] || problemi+=("manca ${chiave}")
194
+ done
195
+ if [ -z "$(valore_env "${testo}" NOEVA_WORKSPACE_ID)" ] && [ -z "$(valore_env "${testo}" NOEVA_WORKSPACE_IDS)" ]; then
196
+ problemi+=("manca NOEVA_WORKSPACE_ID (o NOEVA_WORKSPACE_IDS)")
197
+ fi
198
+ for chiave in ${ENV_VIETATE[@]+"${ENV_VIETATE[@]}"}; do
199
+ grep -q "^${chiave}=" <<<"${testo}" && problemi+=("${chiave} non va impostata qui: il default giusto è nell'immagine")
200
+ done
201
+ valore="$(valore_env "${testo}" NOEVA_API_BASE_URL)"
202
+ if [[ "${valore}" =~ ://(localhost|127\.0\.0\.1|host\.docker\.internal)([:/]|$) ]]; then
203
+ problemi+=("NOEVA_API_BASE_URL punta a una macchina locale (${valore})")
204
+ fi
205
+ # L'immagine porta anche le pipeline degli altri clienti: il catalogo del
206
+ # deploy si restringe alle sue con ETL_PIPELINE_WORKSPACES (ADR-0049).
207
+ if [ ${#PIPELINE[@]} -gt 0 ]; then
208
+ valore="$(valore_env "${testo}" ETL_PIPELINE_WORKSPACES)"
209
+ if [ -z "${valore}" ]; then
210
+ problemi+=("manca ETL_PIPELINE_WORKSPACES: il deploy vedrebbe le pipeline di tutti i clienti")
211
+ else
212
+ for voce in ${valore//,/ }; do
213
+ [[ " ${PIPELINE[*]:-} " == *" ${voce%%:*} "* ]] || problemi+=("ETL_PIPELINE_WORKSPACES assegna ${voce%%:*}, che non è di ${CLIENTE}")
214
+ done
215
+ for chiave in ${PIPELINE[@]+"${PIPELINE[@]}"}; do
216
+ [[ ",${valore}" == *",${chiave}:"* ]] || problemi+=("ETL_PIPELINE_WORKSPACES non assegna ${chiave}")
217
+ done
218
+ fi
219
+ fi
220
+ grep -qE '^export[[:space:]]' <<<"${testo}" && problemi+=("righe con «export»: ECS non le legge")
221
+ grep -qE "^[A-Za-z_][A-Za-z0-9_]*=[\"']" <<<"${testo}" && problemi+=("valori fra virgolette: ECS le terrebbe nel valore")
222
+ if [ ${#problemi[@]} -gt 0 ]; then
223
+ echo -e "${RED}❌ Il .env (${origine}) non va bene per ${CLIENTE}:${NC}" >&2
224
+ printf ' - %s\n' "${problemi[@]}" >&2
225
+ return 1
226
+ fi
227
+ ok ".env (${origine}): $(chiavi_env "${testo}" | wc -l | tr -d ' ') variabili, controlli superati"
228
+ }
229
+
230
+ # --- Git: si deploya un commit pubblicato, dal branch dell'ambiente ---------
231
+ controlla_git() {
232
+ local branch atteso
233
+ atteso="$(branch_ammesso "${AMBIENTE}")"
234
+ branch="$(git rev-parse --abbrev-ref HEAD)"
235
+ [ "${branch}" = "${atteso}" ] || errore "In ${AMBIENTE} si deploya solo da '${atteso}' (sei su '${branch}')"
236
+ [ -z "$(git status --porcelain --ignore-submodules=all)" ] || errore "Working tree non pulito: committa prima di deployare"
237
+ git fetch --quiet --no-tags origin "${atteso}"
238
+ [ "$(git rev-parse HEAD)" = "$(git rev-parse "origin/${atteso}")" ] \
239
+ || errore "HEAD non coincide con origin/${atteso}: si deploya solo un commit pubblicato (git pull o push)"
240
+ ok "Git: ${atteso} @ $(git rev-parse --short=12 HEAD)"
241
+ }
242
+
243
+ # L'immagine copia il submodule così com'è sul disco: dev'essere al commit che
244
+ # HEAD registra e senza modifiche, o porterebbe codice diverso da quello del
245
+ # piano (per Canossa la run lo riverifica con l'impronta, ADR-0097).
246
+ verifica_submodule() {
247
+ local percorso="$1" registrato attuale
248
+ registrato="$(git rev-parse --verify --quiet "HEAD:${percorso}" || true)"
249
+ [ -n "${registrato}" ] || errore "${percorso} non è un submodule registrato in HEAD"
250
+ [ -e "${percorso}/.git" ] || errore "Manca il submodule ${percorso}: git submodule update --init ${percorso}"
251
+ attuale="$(git -C "${percorso}" rev-parse HEAD)"
252
+ [ "${attuale}" = "${registrato}" ] \
253
+ || errore "${percorso} è a ${attuale:0:12}, HEAD registra ${registrato:0:12}: git submodule update --init ${percorso}"
254
+ [ -z "$(git -C "${percorso}" status --porcelain)" ] || errore "Il submodule ${percorso} ha modifiche locali"
255
+ ok "Submodule ${percorso} @ $(git -C "${percorso}" describe --tags --always)"
256
+ }
257
+
258
+ # --- AWS --------------------------------------------------------------------
259
+ controlla_aws() {
260
+ local account stato
261
+ command -v aws >/dev/null 2>&1 || errore "AWS CLI non installata"
262
+ command -v jq >/dev/null 2>&1 || errore "jq non installato"
263
+ account="$(aws_ sts get-caller-identity --query Account --output text 2>/dev/null)" \
264
+ || errore "AWS CLI non configurata per il profilo ${AWS_PROFILE}"
265
+ if [ -n "${AWS_ACCOUNT_ATTESO}" ] && [ "${account}" != "${AWS_ACCOUNT_ATTESO}" ]; then
266
+ errore "Account AWS ${account}, ma ${CLIENTE} sta su ${AWS_ACCOUNT_ATTESO}"
267
+ fi
268
+ ECR_REGISTRY="${account}.dkr.ecr.${AWS_REGION}.amazonaws.com"
269
+ ECR_URI="${ECR_REGISTRY}/${ECR_REPOSITORY}"
270
+ ok "AWS: account ${account}, regione ${AWS_REGION}"
271
+ # Repository, servizio e bucket esistono prima del deploy: lo script non li crea.
272
+ aws_ ecr describe-repositories --repository-names "${ECR_REPOSITORY}" >/dev/null 2>&1 \
273
+ || errore "Repository ECR ${ECR_REPOSITORY} assente: va creato prima del deploy (runbook deployment.md)"
274
+ if [ -n "${ECS_SERVICE}" ]; then
275
+ stato="$(aws_ ecs describe-services --cluster "${ECS_CLUSTER}" --services "${ECS_SERVICE}" \
276
+ --query 'services[0].status' --output text 2>/dev/null || true)"
277
+ [ "${stato}" = "ACTIVE" ] \
278
+ || errore "Servizio ECS ${ECS_SERVICE} non attivo su ${ECS_CLUSTER} (${stato:-assente}): va creato in noeva-terraform"
279
+ ok "Servizio ${ECS_SERVICE}: ACTIVE"
280
+ fi
281
+ }
282
+
283
+ ENV_REMOTO=""
284
+ leggi_env_remoto() { ENV_REMOTO="$(aws_ s3 cp "s3://${ENV_BUCKET}/.env" - 2>/dev/null || true)"; }
285
+
286
+ carica_env() {
287
+ local locale="$1" aggiunte tolte risposta
288
+ [ -f "${locale}" ] || errore "File .env non trovato: ${locale}"
289
+ controlla_env "$(cat "${locale}")" "${locale}" || exit 1
290
+ leggi_env_remoto
291
+ if [ -n "${ENV_REMOTO}" ]; then
292
+ aggiunte="$(comm -13 <(chiavi_env "${ENV_REMOTO}") <(chiavi_env "$(cat "${locale}")") | tr '\n' ' ')"
293
+ tolte="$(comm -23 <(chiavi_env "${ENV_REMOTO}") <(chiavi_env "$(cat "${locale}")") | tr '\n' ' ')"
294
+ echo " Rispetto al .env nel bucket: aggiunte [${aggiunte% }], tolte [${tolte% }] (i valori non si mostrano)"
295
+ else
296
+ echo " Nel bucket non c'è ancora un .env"
297
+ fi
298
+ if [ "${DRY_RUN}" = true ]; then avviso "dry-run: il .env non viene caricato"; return; fi
299
+ [ -t 0 ] || errore "Il caricamento del .env chiede conferma: lancia lo script da un terminale"
300
+ read -r -p "Carico ${locale} in s3://${ENV_BUCKET}/.env (${AMBIENTE})? [s/N] " risposta
301
+ [[ "${risposta}" =~ ^[sS]$ ]] || errore "Caricamento annullato"
302
+ aws_ s3 cp "${locale}" "s3://${ENV_BUCKET}/.env" --only-show-errors
303
+ ok ".env caricato (il bucket lo cifra con la sua chiave KMS)"
304
+ }
305
+
306
+ # --- Attesa del deploy ------------------------------------------------------
307
+ # `<id>\t<stato>` dell'esecuzione più recente. Con `--max-items` la CLI
308
+ # aggiungerebbe una riga col token di paginazione (`None`), che il chiamante
309
+ # leggerebbe come stato (ETL-281): una chiamata sola con `--max-results`, e
310
+ # comunque solo la prima riga.
311
+ ultima_esecuzione() {
312
+ aws_ codepipeline list-pipeline-executions --pipeline-name "${ECS_SERVICE}" \
313
+ --max-results 1 --no-paginate \
314
+ --query 'pipelineExecutionSummaries[0].[pipelineExecutionId,status]' --output text 2>/dev/null \
315
+ | head -n 1 || true
316
+ }
317
+
318
+ attendi_deploy() {
319
+ local prima="$1" ora id stato inizio=${SECONDS}
320
+ passo "Attendo la CodePipeline ${ECS_SERVICE}..."
321
+ while :; do
322
+ ora="$(ultima_esecuzione)"; id="${ora%%[[:space:]]*}"; stato="${ora##*[[:space:]]}"
323
+ if [ -n "${id}" ] && [ "${id}" != "${prima}" ]; then
324
+ case "${stato}" in
325
+ Succeeded) ok "CodePipeline: Succeeded (${id})"; break ;;
326
+ Failed|Stopped|Superseded) errore "CodePipeline: ${stato} (${id})" ;;
327
+ esac
328
+ fi
329
+ (( SECONDS - inizio < ATTESA_PIPELINE_S )) || errore "La CodePipeline non ha finito in ${ATTESA_PIPELINE_S}s"
330
+ sleep 15
331
+ done
332
+ passo "Attendo che ${ECS_SERVICE} sia stabile..."
333
+ aws_ ecs wait services-stable --cluster "${ECS_CLUSTER}" --services "${ECS_SERVICE}"
334
+ ok "Servizio stabile"
335
+ }
336
+
337
+ # Un'immagine porta esattamente due tag: la CodeBuild del servizio ricava il tag
338
+ # di rilascio per esclusione dal tag di deploy, e un terzo la rompe.
339
+ verifica_tag() {
340
+ local tag
341
+ tag="$(aws_ ecr describe-images --repository-name "${ECR_REPOSITORY}" \
342
+ --image-ids "imageTag=${TAG}" --query 'imageDetails[0].imageTags' --output json)"
343
+ [ "$(jq length <<<"${tag}")" = "2" ] \
344
+ || errore "L'immagine ${TAG} ha i tag ${tag}: devono essere due, o la CodePipeline si rompe"
345
+ ok "Tag su ECR: $(jq -r 'join(", ")' <<<"${tag}")"
346
+ }
347
+
348
+ # ============================================================================
349
+ controlla_aws
350
+ if [ "${SOLO_ENV}" = true ]; then
351
+ carica_env "${ENV_FILE}"
352
+ [ "${DRY_RUN}" = true ] && exit 0
353
+ passo "Riavvio ${ECS_SERVICE} col .env nuovo (stessa immagine)..."
354
+ aws_ ecs update-service --cluster "${ECS_CLUSTER}" --service "${ECS_SERVICE}" --force-new-deployment >/dev/null
355
+ if [ "${ATTENDI}" = true ]; then aws_ ecs wait services-stable --cluster "${ECS_CLUSTER}" --services "${ECS_SERVICE}"; fi
356
+ ok "Riavvio richiesto"
357
+ exit 0
358
+ fi
359
+
360
+ controlla_git
361
+ for percorso in ${SUBMODULE[@]+"${SUBMODULE[@]}"}; do verifica_submodule "${percorso}"; done
362
+ if [ -n "${ENV_FILE}" ] && [ "${SOLO_ECR}" = true ]; then
363
+ [ -f "${ENV_FILE}" ] || errore "File .env non trovato: ${ENV_FILE}"
364
+ controlla_env "$(cat "${ENV_FILE}")" "${ENV_FILE}" || exit 1
365
+ avviso "--solo-ecr: il .env è solo controllato, non caricato nel bucket"
366
+ elif [ -n "${ENV_FILE}" ]; then
367
+ carica_env "${ENV_FILE}"
368
+ elif [ -n "${ECS_SERVICE}" ]; then
369
+ leggi_env_remoto
370
+ [ -n "${ENV_REMOTO}" ] || errore "Nel bucket ${ENV_BUCKET} manca il .env: passalo con --env <file>"
371
+ controlla_env "${ENV_REMOTO}" "s3://${ENV_BUCKET}/.env" || exit 1
372
+ fi
373
+ ENV_REMOTO=""
374
+
375
+ if [ "${DRY_RUN}" = true ]; then
376
+ echo ""; ok "Dry-run completato: si può deployare"; exit 0
377
+ fi
378
+
379
+ command -v docker >/dev/null 2>&1 || errore "Docker non installato"
380
+ docker info >/dev/null 2>&1 || errore "Docker non è in esecuzione"
381
+
382
+ if [ "${SKIP_CHECK}" = true ]; then
383
+ avviso "--skip-check: gate saltato"
384
+ else
385
+ GATE="$(gate_del_repo)"
386
+ passo "Quality gate (${GATE})..."
387
+ pnpm install --frozen-lockfile
388
+ # Il gate delle versioni di pipeline confronta con origin/dev e origin/main.
389
+ git fetch --quiet --no-tags origin dev main
390
+ ${GATE}
391
+ fi
392
+
393
+ passo "Login ECR..."
394
+ aws_ ecr get-login-password | docker login --username AWS --password-stdin "${ECR_REGISTRY}" >/dev/null
395
+
396
+ docker buildx inspect etl-builder >/dev/null 2>&1 \
397
+ || docker buildx create --name etl-builder --platform linux/amd64,linux/arm64 >/dev/null
398
+ docker buildx use etl-builder
399
+
400
+ SHA="$(git rev-parse HEAD)"
401
+ ISTANTE="$(date +%Y%m%d-%H%M%S)"
402
+ TAG_RILASCIO="${ISTANTE}-${SHA:0:7}"
403
+ PRIMA=""
404
+ if [ -n "${ECS_SERVICE}" ]; then PRIMA="$(ultima_esecuzione)"; PRIMA="${PRIMA%%[[:space:]]*}"; fi
405
+
406
+ # La release che finisce nel report di ogni run (ADR-0086). Le label legano
407
+ # l'immagine al cliente e cambiano il digest a ogni build: un digest già su ECR
408
+ # riceverebbe un terzo tag.
409
+ passo "Build & push ${ECR_URI} (${TAG}, ${TAG_RILASCIO})..."
410
+ docker buildx build \
411
+ --platform "${PIATTAFORME}" \
412
+ -t "${ECR_URI}:${TAG}" \
413
+ -t "${ECR_URI}:${TAG_RILASCIO}" \
414
+ --build-arg "ETL_RELEASE=git:${SHA:0:12}" \
415
+ --label "ai.noeva.etl.cliente=${CLIENTE}" \
416
+ --label "ai.noeva.etl.ambiente=${AMBIENTE}" \
417
+ --label "org.opencontainers.image.revision=${SHA}" \
418
+ --label "org.opencontainers.image.created=${ISTANTE}" \
419
+ ${NO_CACHE[@]+"${NO_CACHE[@]}"} \
420
+ -f "$(dockerfile_del_repo)" \
421
+ --push \
422
+ .
423
+ verifica_tag
424
+
425
+ TAG_GIT="deploy/${CLIENTE}/${AMBIENTE}/${TAG_RILASCIO}"
426
+ git tag -a "${TAG_GIT}" -m "Deploy ${CLIENTE} (${AMBIENTE}): ${ECR_URI}:${TAG_RILASCIO}"
427
+ git push --quiet origin "${TAG_GIT}" && ok "Tag git ${TAG_GIT}" || avviso "Tag ${TAG_GIT} creato ma non pushato"
428
+
429
+ if [ -n "${ECS_SERVICE}" ] && [ "${ATTENDI}" = true ]; then attendi_deploy "${PRIMA}"; fi
430
+
431
+ echo ""
432
+ ok "Immagine pubblicata: ${ECR_URI}:${TAG_RILASCIO}"
433
+ if [ -n "${ECS_SERVICE}" ]; then
434
+ echo " La CodePipeline ${ECS_SERVICE} la porta su ECS:"
435
+ echo " https://${AWS_REGION}.console.aws.amazon.com/codesuite/codepipeline/pipelines/${ECS_SERVICE}/view"
436
+ elif [ "${SOLO_ECR}" = true ]; then
437
+ echo " --solo-ecr: nessun servizio controllato. Se la CodePipeline del servizio esiste già,"
438
+ echo " il tag ${TAG} l'ha appena fatta partire; altrimenti la prenderà alla sua creazione."
439
+ else
440
+ echo " Nessun servizio ECS: si lancia con docker run ${ECR_URI}:${TAG_RILASCIO} run <pipeline>"
441
+ fi