@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.
- package/README.md +10 -8
- package/deploy/deploy-ecr.sh +441 -0
- package/dist/cli.js +118 -117
- package/dist/connectors/sqlserver.js +1 -1
- package/dist/etl.config.js +13 -121
- package/dist/guida/404.html +2 -2
- package/dist/guida/GUIDA_SVILUPPO.html +4 -4
- package/dist/guida/TECHNICAL_OVERVIEW.html +4 -4
- package/dist/guida/assets/{app.BMz6ZZYF.js → app.lWZ5GK2m.js} +1 -1
- package/dist/guida/assets/chunks/@localSearchIndexroot.B5zFGbAC.js +1 -0
- package/dist/guida/assets/chunks/{VPLocalSearchBox.D8gO6gDY.js → VPLocalSearchBox.C0h2R-Ih.js} +1 -1
- package/dist/guida/assets/chunks/{theme.DV62mViB.js → theme.BYWumH0G.js} +2 -2
- package/dist/guida/assets/runbooks_deploy-ecr.md.6M67F85S.js +45 -0
- package/dist/guida/assets/runbooks_deploy-ecr.md.6M67F85S.lean.js +1 -0
- package/dist/guida/assets/{runbooks_deployment.md.DvIOOsoG.js → runbooks_deployment.md.CsIYRa_5.js} +7 -5
- package/dist/guida/assets/runbooks_deployment.md.CsIYRa_5.lean.js +1 -0
- package/dist/guida/assets/{runbooks_graph-server.md.BOXZqdXC.js → runbooks_graph-server.md.opGHnuzK.js} +2 -2
- package/dist/guida/assets/{runbooks_graph-server.md.BOXZqdXC.lean.js → runbooks_graph-server.md.opGHnuzK.lean.js} +1 -1
- package/dist/guida/connectors/README.html +4 -4
- package/dist/guida/connectors/file.html +4 -4
- package/dist/guida/connectors/http.html +4 -4
- package/dist/guida/connectors/imap.html +4 -4
- package/dist/guida/connectors/jira.html +4 -4
- package/dist/guida/connectors/noeva.html +4 -4
- package/dist/guida/connectors/oauth.html +4 -4
- package/dist/guida/connectors/postgres.html +4 -4
- package/dist/guida/connectors/process.html +4 -4
- package/dist/guida/connectors/sendgrid.html +4 -4
- package/dist/guida/connectors/smtp.html +4 -4
- package/dist/guida/connectors/sqlserver.html +4 -4
- package/dist/guida/conventions/node-columns.html +4 -4
- package/dist/guida/conventions/node-descriptor.html +4 -4
- package/dist/guida/conventions/run-report.html +4 -4
- package/dist/guida/conventions/run-trace.html +4 -4
- package/dist/guida/conventions/variabili-del-core.html +4 -4
- package/dist/guida/conventions/versioni-di-pipeline.html +4 -4
- package/dist/guida/guide/claude-code/index.html +4 -4
- package/dist/guida/guide/claude-code/prompt.html +4 -4
- package/dist/guida/guide/claude-code/strumenti.html +4 -4
- package/dist/guida/guide/grafo.html +4 -4
- package/dist/guida/guide/usare/app-desktop.html +4 -4
- package/dist/guida/guide/usare/esito-di-una-run.html +4 -4
- package/dist/guida/guide/usare/index.html +4 -4
- package/dist/guida/hashmap.json +1 -1
- package/dist/guida/index.html +3 -3
- package/dist/guida/nodes/README.html +4 -4
- package/dist/guida/nodes/action.html +4 -4
- package/dist/guida/nodes/ai.html +4 -4
- package/dist/guida/nodes/join.html +4 -4
- package/dist/guida/nodes/lookup.html +4 -4
- package/dist/guida/nodes/pipeline.html +4 -4
- package/dist/guida/nodes/route.html +4 -4
- package/dist/guida/nodes/sink.html +4 -4
- package/dist/guida/nodes/source.html +4 -4
- package/dist/guida/nodes/task.html +4 -4
- package/dist/guida/nodes/transform.html +4 -4
- package/dist/guida/nodes/try-catch.html +4 -4
- package/dist/guida/nodes/union.html +4 -4
- package/dist/guida/pagine.json +1 -0
- package/dist/guida/pipelines/README.html +4 -4
- package/dist/guida/pipelines/crm-leads-sync.html +4 -4
- package/dist/guida/pipelines/cross-workspace-csv-merge.html +4 -4
- package/dist/guida/pipelines/movimenti-per-conto.html +4 -4
- package/dist/guida/pipelines/orders-enriched-daily.html +4 -4
- package/dist/guida/pipelines/test-posta.html +4 -4
- package/dist/guida/runbooks/aggiornamento-pm2.html +5 -5
- package/dist/guida/runbooks/deploy-ecr.html +71 -0
- package/dist/guida/runbooks/deployment.html +11 -9
- package/dist/guida/runbooks/etl-worker.html +4 -4
- package/dist/guida/runbooks/graph-server.html +6 -6
- package/dist/guida/runbooks/mask-key.html +4 -4
- package/dist/guida/runbooks/oauth-google-posta.html +4 -4
- package/dist/guida/runbooks/rollback-di-pipeline.html +4 -4
- package/dist/guida/runbooks/scd2-rehash.html +4 -4
- package/dist/guida/runbooks/sql-task-truncate-swap.html +4 -4
- package/dist/guida/runbooks/stato-incrementale.html +4 -4
- package/dist/guida/sub-pipelines/README.html +4 -4
- package/dist/guida/sub-pipelines/riepilogo-ordini.html +4 -4
- package/docs/.vitepress/lib/published-docs.ts +0 -21
- package/package.json +1 -2
- package/dist/chunk-DFFLQC6T.js +0 -1
- package/dist/guida/assets/chunks/@localSearchIndexroot.B3bE99g8.js +0 -1
- 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
|
|
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
|
|
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
|
|
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
|
|
123
|
+
docker run --rm --env-file .env noeva-etl run <pipeline>
|
|
124
124
|
```
|
|
125
125
|
|
|
126
|
-
Deploy su **ECR**
|
|
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>
|
|
130
|
-
|
|
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 (
|
|
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
|