Files
Alby96andClaude Opus 5.5 c8241a414e docs: keep 0.x versions until the user calls 1.0.0 (amendment E7)
The user wants the leading zero to keep signalling that Khaemhat is in
development, so M13 closes as v0.13.0 and M14 as v0.14.0+ instead of
v1.0.0 and v1.1.0+ from SPEC §20. The Gitea milestones were renamed to
match.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 10:09:29 +01:00

22 KiB

Deploy

Stato: bozza · Revisione 2026-11-10 · Fonte: SPEC §1.5, §5.3-§5.4, §6, §12.8-§12.9, §13, §16, Appendice C; ADR 0009, ADR 0010

Documento tecnico per chi sviluppa e per chi gestisce le installazioni: come è costruita l'immagine, quali file di deploy esistono, come si pubblica una versione, come si aggiorna, si torna indietro e si ruotano i segreti. Le istruzioni per l'utente finale sono nella wiki: Installazione-Unraid, Installazione-Docker, Aggiornamento, Backup-e-ripristino (sorgenti in docs/wiki/).

1. Principi

Regola Fonte
L'unico artefatto distribuito è l'immagine gitea.encke-hake.ts.net/balbosoft/khaemhat:<versione>. Niente installer, .msi/.exe/.deb/.rpm, binari self-contained, ZIP, servizi systemd/Windows ADR 0010
Il Dockerfile multi-stage è l'unico percorso di build di produzione; dotnet run serve solo allo sviluppo ADR 0010
Configurazione iniziale solo da variabili KHAEMHAT_*; il resto nel database di sistema SPEC §1.5, §6
Nessuna scrittura fuori da KHAEMHAT_DATA_DIR (/data); nessun file temporaneo con impostazioni o dati SPEC §1.5
Log su stdout (JSON, una riga per evento) e nel database di sistema; nessun file di log SPEC §9.5
Chiavi DataProtection nel database di sistema (sys_data_protection_keys) SPEC §1.5, §5.4
Un container serve tutte le aziende dell'istanza; nessuno scale-out orizzontale (Blazor Server) SPEC §2
In produzione si usa sempre un tag esplicito; latest è solo una comodità CLAUDE.md E1

2. Dockerfile (docker/Dockerfile)

2.1 Struttura

Stage Base Contenuto
build mcr.microsoft.com/dotnet/sdk:10.0 restore (layer separato per la cache), scripts/check-packages.sh, test opzionali con --build-arg RUN_TESTS=true, dotnet publish src/Khaemhat.Web -c Release -o /app /p:Version=$VERSION /p:SourceRevisionId=$GIT_SHA
runtime mcr.microsoft.com/dotnet/aspnet:10.0 postgresql-client-17 (repository PGDG), curl, tzdata; utente app non root; VOLUME /data; EXPOSE 8080; HEALTHCHECK; ENTRYPOINT ["/app/entrypoint.sh"]

Build argument: VERSION (SemVer senza v, es. 1.0.0), GIT_SHA (commit breve), RUN_TESTS (false). Architetture: linux/amd64 di default; linux/arm64 opzionale.

2.2 Bozza

Bozza di riferimento: il file definitivo nasce nella milestone M0 e va tenuto allineato a questa sezione.

# syntax=docker/dockerfile:1
ARG VERSION=0.0.0
ARG GIT_SHA=unknown

FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
ARG VERSION
ARG GIT_SHA
ARG RUN_TESTS=false
WORKDIR /src
COPY global.json Directory.Build.props Directory.Packages.props Khaemhat.sln ./
# semplificato: per la cache del restore copiare prima i soli .csproj mantenendo l'albero src/<Progetto>/
COPY src/ ./src/
RUN dotnet restore
COPY . .
RUN scripts/check-packages.sh
RUN if [ "$RUN_TESTS" = "true" ]; then dotnet test -c Release; fi
RUN dotnet publish src/Khaemhat.Web -c Release -o /app \
      /p:Version=$VERSION /p:SourceRevisionId=$GIT_SHA

FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS runtime
ARG VERSION
ARG GIT_SHA
RUN apt-get update \
 && apt-get install -y --no-install-recommends curl ca-certificates gnupg tzdata \
 && install -d /usr/share/postgresql-common/pgdg \
 && curl -fsSL https://www.postgresql.org/media/keys/ACCC4CF8.asc \
      -o /usr/share/postgresql-common/pgdg/apt.postgresql.org.asc \
 && . /etc/os-release \
 && echo "deb [signed-by=/usr/share/postgresql-common/pgdg/apt.postgresql.org.asc] https://apt.postgresql.org/pub/repos/apt ${VERSION_CODENAME}-pgdg main" \
      > /etc/apt/sources.list.d/pgdg.list \
 && apt-get update \
 && apt-get install -y --no-install-recommends postgresql-client-17 \
 && apt-get purge -y gnupg && apt-get autoremove -y && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY --from=build /app ./
COPY docker/entrypoint.sh /app/entrypoint.sh
ENV KHAEMHAT_DATA_DIR=/data \
    KHAEMHAT_URLS=http://0.0.0.0:8080 \
    TZ=Europe/Rome
VOLUME /data
EXPOSE 8080
HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
  CMD curl -fs http://localhost:8080/health/live || exit 1
LABEL org.opencontainers.image.title="Khaemhat" \
      org.opencontainers.image.description="Gestionale ERP + CRM per PMI italiane" \
      org.opencontainers.image.version="$VERSION" \
      org.opencontainers.image.revision="$GIT_SHA" \
      org.opencontainers.image.source="https://gitea.encke-hake.ts.net/BalboSoft/Khaemhat" \
      org.opencontainers.image.url="https://gitea.encke-hake.ts.net/BalboSoft/Khaemhat/wiki" \
      org.opencontainers.image.vendor="BalboSoft" \
      net.unraid.docker.icon="https://gitea.encke-hake.ts.net/BalboSoft/Khaemhat/raw/branch/main/assets/icon-v1.0-256.png" \
      net.unraid.docker.webui="http://[IP]:[PORT:8080]/"
ENTRYPOINT ["/app/entrypoint.sh"]

Note:

  • l'URL dell'icona nell'etichetta va calcolato da VERSION (icon-v<major>.<minor>-256.png, §6);
  • org.opencontainers.image.created si passa da CI (--label o build arg con la data del build);
  • gli strumenti di sistema (postgresql-client-17, curl, tzdata) sono ammessi da SPEC §1.2 perché non sono componenti dell'applicazione. pg_dump deve avere versione ≥ quella del server: client 17 → server 16 e 17. Per supportare PostgreSQL 18 si aggiorna il client nell'immagine.

2.3 Utente e PUID/PGID

Le immagini aspnet:10.0 includono già un utente non root app. SPEC chiede che i file in /data appartengano a PUID/PGID (99/100 per Unraid). Le due realizzazioni valutate; ADR 0013 sceglie la 1 (predefiniti 1654, l'utente app dell'immagine; la 2 resta possibile perché l'entrypoint salta la preparazione se non è root):

  1. avvio come root e cessione dei privilegi in entrypoint.sh: allinea UID/GID di app a PUID/PGID, esegue chown su /data solo se necessario e rilancia il processo come app con setpriv (util-linux, già nella base) — nessun pacchetto aggiuntivo;
  2. avvio direttamente come utente non root (USER app) e user: "99:100" nel compose: più semplice, ma PUID/PGID diventano inutili e la proprietà di /data va preparata sull'host.

La 1 rispetta alla lettera il template Unraid (variabili PUID/PGID); in entrambi i casi il processo .NET non gira mai come root.

2.4 docker/entrypoint.sh

Sequenza (SPEC §4, §5.4):

  1. legge KHAEMHAT_SYSTEM_DB (o KHAEMHAT_SYSTEM_DB_FILE) solo per ricavarne host e porta: le varianti _FILE le risolve l'applicazione, senza esportare segreti nell'ambiente (ADR 0014, §5);
  2. se previsto, allinea utente e permessi (§2.3);
  3. attende che KHAEMHAT_SYSTEM_DB sia raggiungibile (retry con backoff, timeout esplicito, messaggio chiaro);
  4. avvia l'applicazione (exec dotnet Khaemhat.Web.dll), che in StartupOrchestrator valida le opzioni (KhaemhatOptions.Validate()), migra il database di sistema, esegue il bootstrap al primo avvio (super utente, prima azienda, migrazioni azienda, seed base, seed demo se richiesto) e, se l'impostazione è attiva, migra le aziende.

Le migrazioni restano nel codice .NET (MigrationRunner), non nello script shell: l'entrypoint fa solo attesa, ambiente e exec. docker/postgres/init.sql è uno script di inizializzazione opzionale per il container PostgreSQL (montato in /docker-entrypoint-initdb.d/: imposta per il ruolo dell'applicazione fuso UTC e codifica UTF8).

3. File in deploy/

File Scopo Note
deploy/docker-compose.yml host Docker generico: app + postgres:17 + redis:7 (profilo redis) volumi nominati, porta DB non pubblicata
deploy/docker-compose.sqlite.yml demo autonoma SQLite, un solo container KHAEMHAT_SEED_DEMO=true, KHAEMHAT_LICENSE_MODE=test; usato dalla checklist manuale di SPEC §18
deploy/docker-compose.unraid.yml Unraid con il plugin Compose (o qualunque host) volumi in /mnt/user/appdata/khaemhat, PUID 99/PGID 100, etichette net.unraid.docker.managed/webui/icon, rete khaemhat-net
deploy/.env.example modello del file .env dei compose mai committare .env
deploy/unraid/khaemhat.xml template Community Applications <Repository>, <Icon>, <WebUI>, <TemplateURL>, <ExtraParams> con health check, variabili mascherate

Tutti i file puntano a gitea.encke-hake.ts.net/balbosoft/khaemhat:<versione> con tag esplicito. Il template è importabile dall'URL raw https://gitea.encke-hake.ts.net/BalboSoft/Khaemhat/raw/branch/main/deploy/unraid/khaemhat.xml.

A ogni rilascio si aggiornano insieme il tag in docker-compose*.yml e in khaemhat.xml e, se cambia major.minor, l'URL dell'icona (§6).

4. Registro pacchetti Gitea

Voce Valore
Registro gitea.encke-hake.ts.net
Immagine gitea.encke-hake.ts.net/balbosoft/khaemhat (owner in minuscolo, come richiesto dal protocollo OCI)
Tag <major>.<minor>.<patch> per ogni versione (senza v); latest sull'ultima versione stabile
Visibilità pubblica (il repository BalboSoft/Khaemhat è pubblico); il pacchetto va collegato al repository
Pagina del pacchetto https://gitea.encke-hake.ts.net/BalboSoft/-/packages/container/khaemhat
Push token con permesso write:package (segreto Actions REGISTRY_TOKEN, o GITEA_TOKEN in locale)
Pull di un pacchetto privato docker login gitea.encke-hake.ts.net con token read:package

4.1 Controllo aggiornamenti (GiteaPackagesClient)

UpdateCheckService (SPEC §12.8, mockup 085) usa GiteaPackagesClient:

  • GET {KHAEMHAT_UPDATE_FEED} con KHAEMHAT_UPDATE_FEED = https://gitea.encke-hake.ts.net/api/v1/packages/BalboSoft?type=container&q=khaemhat;
  • header Authorization: token {KHAEMHAT_UPDATE_TOKEN} solo se la variabile è valorizzata;
  • la risposta è un array di pacchetti, uno per versione (name, version, created_at, html_url): si tengono i record con name == "khaemhat" e version SemVer valida (si scartano latest e digest), si ordina per SemVer e si confronta con la versione in esecuzione;
  • paginazione con page/limit finché la pagina è piena;
  • nessun aggiornamento automatico; l'esito (versione disponibile, link alle note) compare nella riga Aggiornamenti di Stato sistema; errori di rete → stato "non verificabile", mai errore bloccante;
  • test con risposte registrate dell'API Gitea (ADR 0009).

5. Variabili e segreti

L'elenco completo e normativo delle variabili è SPEC §6 con le modifiche di E1; la tabella per l'utente è nella wiki Installazione-Docker. Punti rilevanti per il deploy:

  • KHAEMHAT_SECRET_KEY è obbligatoria (≥ 32 byte base64): cifra con AES-256-GCM i segreti in sys_companies, sys_settings ecc. e i file di backup. Senza chiave l'app non parte.
  • KHAEMHAT_SUPERUSER*, KHAEMHAT_COMPANY_* sono lette solo se le tabelle corrispondenti sono vuote.
  • Varianti _FILE (Docker secrets): SPEC le prevede per KHAEMHAT_SYSTEM_DB e KHAEMHAT_SUPERUSER_*. Deciso con ADR 0014: sono supportate per tutte le variabili sensibili (KHAEMHAT_SECRET_KEY, KHAEMHAT_SECRET_KEY_NEW, KHAEMHAT_DB_SERVER, KHAEMHAT_REDIS, KHAEMHAT_LICENSE, KHAEMHAT_SMTP_PASSWORD, KHAEMHAT_UPDATE_TOKEN) con una sola regola in EnvironmentConfigurationReader: se esiste X_FILE, il valore è il contenuto del file senza il fine riga finale; X e X_FILE insieme sono un errore di configurazione.
  • KHAEMHAT_TEST_PG, KHAEMHAT_TEST_REDIS esistono solo per i test e non compaiono nei file di deploy/.

6. Icona versionata

File Uso
assets/icon.svg icona ufficiale (favicon, manifest, marca, pagina di accesso, e-mail)
assets/icon-v1.0.svg modello versionato con la fascia "v 1.0"
assets/icon-v<major.minor>-256.png icona per Unraid (template <Icon> ed etichetta net.unraid.docker.icon)
assets/icon-mono.svg, favicon.ico, PNG 16-512 favicon e varianti

Regole (SPEC §16.6, E1):

  • la variante versionata mostra solo major.minor; scripts/build.sh genera icon-v<major.minor>.svg sostituendo il testo v 1.0 nel modello (semplice sostituzione di stringa);
  • l'icona per Unraid è servita come file raw dal repository pubblico: https://gitea.encke-hake.ts.net/BalboSoft/Khaemhat/raw/branch/main/assets/icon-v<major.minor>-256.png; il file deve quindi essere committato su main prima del rilascio che lo referenzia;
  • la conversione SVG → PNG richiede un rasterizzatore che l'applicazione non contiene (né deve contenere): si esegue sulla macchina di sviluppo con uno strumento di sistema e il PNG si committa. Strumenti accettati: rsvg-convert, inkscape, magick (ADR 0016);
  • finché manca la variante della nuova versione si usa icon-256.png (non versionata).

7. Versioning

  • SemVer major.minor.patch; tag git vX.Y.Z (con v), tag immagine X.Y.Z (senza v).
  • La versione nasce dal tag: Directory.Build.props la legge, il Dockerfile la riceve con --build-arg VERSION (/p:Version) insieme a GIT_SHA (/p:SourceRevisionId, mostrato come +sha).
  • Dove compare (SPEC §16.5): barra superiore (major.minor), barra di stato (completa), Stato sistema, manifest.webmanifest, etichette OCI, icona versionata.
  • Milestone: v0.0.1 (M0) … v0.12.0 (M12), v0.13.0 (M13), v0.14.0+ (M14). La 1.0.0 si crea solo quando l'utente lo decide (emendamento E7 in CLAUDE.md, che modifica SPEC §20).
  • Le migrazioni non si riscrivono mai dopo un rilascio: una correzione è una migrazione nuova.

8. Endpoint di salute

Endpoint Scopo Stato
GET /health/live liveness: il processo risponde. Usato da HEALTHCHECK, dal compose e da <ExtraParams> del template. Non deve dipendere dal database, altrimenti un DB lento fa riavviare il container previsto da SPEC (§16.1, App. C)
GET /health endpoint di base introdotto in M0 previsto da SPEC (§20, M0)
readiness (proposta GET /health/ready) database di sistema raggiungibile, migrazioni di sistema applicate, bootstrap concluso; 503 durante l'avvio ADR 0012: in M0 sempre 200, i controlli arrivano in M1-M2
metriche (MetricsEndpoint) formato e percorso da definire

Regole: risposte senza autenticazione e senza dati sensibili (niente versioni dei componenti, connection string o nomi di aziende); la modalità manutenzione di un'azienda non rende l'istanza unhealthy (le API dell'azienda rispondono 503, la liveness resta 200).

9. Pubblicazione

9.1 Percorso normale: release.yml sui tag

.gitea/workflows/release.yml (Gitea Actions, act_runner self-hosted in modalità Docker, etichetta ubuntu-latest, un job alla volta):

  • trigger: push di tag v* e workflow_dispatch (input: versione, arm64 facoltativo);
  • checkout con git (niente actions/checkout, come in Chronos);
  • docker buildx build -f docker/Dockerfile --build-arg VERSION=<X.Y.Z> --build-arg GIT_SHA=<sha> per linux/amd64 (più linux/arm64 se richiesto);
  • smoke test: avvio del container con la configurazione SQLite della demo e curl -fs /health/live entro un timeout; se fallisce, niente push;
  • docker login gitea.encke-hake.ts.net con il segreto REGISTRY_TOKEN (write:package);
  • push di :<X.Y.Z> e :latest;
  • creazione della release Gitea per il tag con le note estratte dalla sezione corrispondente di CHANGELOG.md (nessun binario allegato, ADR 0010).

Il runner deve poter usare Docker (socket dell'host montato nel job o Docker-in-Docker): requisito di configurazione di act_runner, da documentare in docs/DEVELOPMENT.md.

9.2 Alternativa locale: scripts/publish-image.sh

Per pubblicare quando il runner non è disponibile. Bozza (versione Gitea dello script di SPEC Appendice D):

#!/usr/bin/env bash
set -euo pipefail
TAG="${1:?uso: publish-image.sh vX.Y.Z [--arm64]}"
PLATFORMS="linux/amd64"; [[ "${2:-}" == "--arm64" ]] && PLATFORMS="linux/amd64,linux/arm64"
REGISTRY="${GITEA_URL:-gitea.encke-hake.ts.net}"; REGISTRY="${REGISTRY#https://}"
OWNER="$(echo "${GITEA_OWNER:-BalboSoft}" | tr '[:upper:]' '[:lower:]')"
IMAGE="$REGISTRY/$OWNER/khaemhat"
VERSION="${TAG#v}"; SHA="$(git rev-parse --short HEAD)"
echo "${GITEA_TOKEN:?}" | docker login "$REGISTRY" -u "${GITEA_USER:-$OWNER}" --password-stdin
docker buildx build --platform "$PLATFORMS" -f docker/Dockerfile \
  --build-arg VERSION="$VERSION" --build-arg GIT_SHA="$SHA" \
  -t "$IMAGE:$VERSION" -t "$IMAGE:latest" --push .
echo "Pubblicata $IMAGE:$VERSION"

Differenze rispetto all'Appendice D (ADR 0009): registro pacchetti di Gitea, variabili GITEA_URL/GITEA_OWNER/ GITEA_TOKEN, tag immagine senza v. La rigenerazione dell'icona sta in scripts/build.sh (§6).

Tag git e doppio build. Se lo script creasse e spingesse anche il tag vX.Y.Z, il push farebbe partire release.yml e l'immagine verrebbe costruita due volte. Deciso con ADR 0015: lo script non crea tag; il tag si crea alla chiusura della milestone (E6). In più release.yml controlla prima del build se la versione esiste già nel registro (GET /api/v1/packages/BalboSoft/container/khaemhat/<X.Y.Z> → 200) e in quel caso salta build e push e crea solo la release.

10. Checklist di rilascio

  1. Milestone chiusa: Definition of Done (SPEC §20) verificata, scripts/test.sh e check-packages.sh verdi.
  2. CHANGELOG.md: sezione [X.Y.Z] - AAAA-MM-GG con aggiunte, modifiche, correzioni e migrazioni (elenco o "nessuna"); note su eventuali cambiamenti incompatibili.
  3. Wiki: pagine delle funzioni consegnate da bozza a completa; docs/STATUS.md aggiornato.
  4. Se cambia major.minor: assets/icon-v<major.minor>.svg e -256.png generati e committati.
  5. Tag dell'immagine aggiornato in deploy/docker-compose*.yml e deploy/unraid/khaemhat.xml (e URL dell'icona).
  6. Build locale: docker build e avvio di deploy/docker-compose.sqlite.yml da zero; login e checklist manuale di SPEC §18.
  7. Prova di aggiornamento da versione precedente con dati demo su PostgreSQL: migrazioni applicate, Stato sistema verde.
  8. Tag vX.Y.Z e push → release.yml (o publish-image.sh).
  9. Verifica nel registro: tag X.Y.Z e latest presenti; docker pull da un host pulito; Stato sistema di un'istanza precedente segnala la nuova versione.
  10. Release Gitea con le note.

11. Aggiornamento e rollback (gestione)

  • Aggiornamento: tag esplicito nel compose → docker compose pull && docker compose up -d. All'avvio MigrationRunner migra il database di sistema; le aziende all'avvio o dal pannello, secondo impostazione, con modalità manutenzione per azienda (SPEC §5.3, §12.1).
  • MigrationRunner rifiuta di partire se trova in schema_version versioni non note: il downgrade non è supportato.
  • Rollback: tag precedente; se la versione nuova ha applicato migrazioni, prima si ripristinano database di sistema (/app/scripts/restore-system.sh nell'immagine, ADR 0017, istanza ferma) e aziende dai backup fatti prima dell'aggiornamento.
  • Per questo ogni voce del changelog dichiara se contiene migrazioni.

Procedura per l'utente: wiki Aggiornamento.

12. Backup (riferimento)

SPEC §13 e wiki Backup-e-ripristino. Per il deploy contano:

  • pg_dump/pg_restore 17 nell'immagine; i processi esterni si avviano solo da Infrastructure/Backup (test di architettura: nessun Process.Start altrove);
  • file in /data/backups/<db>/bk-<db>-<timestamp>.dump + sha256, cifratura AES-256-GCM con chiave da KHAEMHAT_SECRET_KEY, copie S3 (SigV4 in casa) e WebDAV;
  • scripts/restore-system.sh (M12) ripristina khaemhat_system con l'istanza ferma; deve gestire anche i backup cifrati (decifratura con KHAEMHAT_SECRET_KEY) e documentare i parametri nell'intestazione;
  • strategia consigliata: backup applicativo + copia remota + snapshot del volume (plugin appdata su Unraid, snapshot del disco nei cloud).

13. Rotazione dei segreti

Segreto Dove vive Rotazione
KHAEMHAT_SECRET_KEY env del container procedura guidata (SPEC §12.9): nuova chiave in KHAEMHAT_SECRET_KEY_NEW → Impostazioni → SecretRotationService ri-cifra tutti i segreti e verifica → la nuova chiave diventa KHAEMHAT_SECRET_KEY, si rimuove _NEW. Solo super utente, registrata in sys_security_audit
Password PostgreSQL env (POSTGRES_PASSWORD, KHAEMHAT_SYSTEM_DB, KHAEMHAT_DB_SERVER) e connection string cifrate in sys_companies ALTER ROLE khaemhat PASSWORD … → aggiornare env → aggiornare le connection string delle aziende dal pannello (Istanza e database → Connessione) → riavvio
Password Redis env (REDIS_PASSWORD, KHAEMHAT_REDIS) cambiare entrambe e ricreare i container; Redis non è persistente
REGISTRY_TOKEN segreto Gitea Actions nuovo token write:package in Gitea, aggiornare il segreto, revocare il vecchio
KHAEMHAT_UPDATE_TOKEN env nuovo token di sola lettura, ricreare il container
Password SMTP/PEC/S3/WebDAV, token intermediari sys_settings cifrati dal pannello Impostazioni
Chiavi API kh_… api_keys/sys_api_keys (hash) dal pannello Chiavi API e MCP: nuova chiave, aggiornamento del client, revoca
Password super utente sys_users (hash) da Il mio profilo; le variabili KHAEMHAT_SUPERUSER_* non sono più lette

Backup cifrati e rotazione. I backup già prodotti restano cifrati con la chiave precedente. Finché non si decide diversamente con un ADR (ri-cifratura dei backup locali, o registro delle chiavi storiche per BackupEncryptor), la documentazione utente chiede di conservare la vecchia chiave per tutta la retention.

14. Punti aperti

Punto Proposta Quando
PUID/PGID con utente non root avvio root + setpriv nell'entrypoint (§2.3) deciso: ADR 0013
Elenco delle variabili con _FILE tutte le sensibili (§5) deciso: ADR 0014; implementazione in M1-M2
Endpoint di readiness e metriche /health/ready (ADR 0012); metriche da definire (§8) M2
Doppio build tag + script lo script non crea tag (§9.2) deciso: ADR 0015
Rasterizzazione dell'icona versionata strumento di sistema sulla macchina di sviluppo, PNG committato (§6) deciso: ADR 0016
Backup cifrati dopo la rotazione della chiave registro delle chiavi storiche o ri-cifratura (§13) M12
Connection string delle aziende e rotazione della password PostgreSQL per le aziende create su KHAEMHAT_DB_SERVER, salvare un riferimento "credenziali del server" invece della stringa completa M1/M2
Decifratura dei backup fuori dall'applicazione comando in restore-system.sh o sottocomando dedicato M12