629 lines
30 KiB
YAML
629 lines
30 KiB
YAML
# ═══════════════════════════════════════════════════════════════════
|
|
# Secret richiesti (a livello repo/org, ereditati con `secrets: inherit`):
|
|
# DEPLOY_SSH_KEY, MAVEN_USERNAME, MAVEN_PASSWORD
|
|
# INFISICAL_CLIENT_ID, INFISICAL_CLIENT_SECRET, INFISICAL_PROJECT_ID
|
|
#
|
|
# INFISICAL: i secret applicativi vengono iniettati a runtime dalla CLI
|
|
# infisical installata SUL SERVER di deploy (nessun file di secret viene
|
|
# scritto su disco). L'environment Infisical coincide con il nome ambiente
|
|
# ricavato dai file (docker-compose-<env>.yml / .env_<env>).
|
|
# Il file .env_<env> del repo resta la base: le variabili iniettate da
|
|
# Infisical hanno precedenza, perché per docker compose l'ambiente della
|
|
# shell vince sui valori di --env-file.
|
|
# Se i secret INFISICAL_* non sono configurati il workflow si comporta
|
|
# esattamente come prima (nessuna iniezione).
|
|
# ═══════════════════════════════════════════════════════════════════
|
|
name: Deploy Environment (reusable)
|
|
|
|
on:
|
|
workflow_call:
|
|
inputs:
|
|
environment:
|
|
description: "Nome ambiente (test, prod, development, ...)"
|
|
required: true
|
|
type: string
|
|
host-var:
|
|
description: "Nome della variabile org che contiene l'host target (es. TEST_HOST, PROD_HOST)"
|
|
required: true
|
|
type: string
|
|
compose-opts:
|
|
description: "Opzioni aggiuntive per docker compose up (es. --force-recreate)"
|
|
required: false
|
|
type: string
|
|
default: ""
|
|
pre-deploy-cmd:
|
|
description: "Comando da eseguire sul server prima del deploy (es. backup)"
|
|
required: false
|
|
type: string
|
|
default: ""
|
|
post-deploy-cmd:
|
|
description: "Comando da eseguire sul server dopo il deploy (es. reload apache)"
|
|
required: false
|
|
type: string
|
|
default: ""
|
|
health-timeout-seconds:
|
|
description: "Secondi massimi di attesa che tutti i container diventino running/healthy dopo il deploy"
|
|
required: false
|
|
type: string
|
|
default: "180"
|
|
|
|
jobs:
|
|
deploy:
|
|
runs-on: ubuntu-latest
|
|
env:
|
|
ENV_NAME: ${{ inputs.environment }}
|
|
DEPLOY_USER: ${{ vars.DEPLOY_USER }}
|
|
DEPLOY_BASE_PATH: ${{ vars.DEPLOY_BASE_PATH }}
|
|
TARGET_HOST: ${{ vars[inputs.host-var] }}
|
|
INFISICAL_DOMAIN: ${{ vars.INFISICAL_HOST }}
|
|
steps:
|
|
- uses: actions/checkout@v6
|
|
|
|
- name: Verifica configurazione
|
|
run: |
|
|
missing=0
|
|
for v in DEPLOY_USER DEPLOY_BASE_PATH; do
|
|
eval "val=\${$v}"
|
|
if [ -z "$val" ]; then echo "MANCANTE: $v"; missing=1; else echo "OK: $v"; fi
|
|
done
|
|
if [ -z "${{ vars[inputs.host-var] }}" ]; then
|
|
echo "MANCANTE: variabile org '${{ inputs.host-var }}'"
|
|
missing=1
|
|
else
|
|
echo "OK: ${{ inputs.host-var }} = ${{ vars[inputs.host-var] }}"
|
|
fi
|
|
[ "$missing" -eq 0 ] || { echo "Imposta le Variables mancanti a livello org."; exit 1; }
|
|
|
|
- name: Verifica file ambiente
|
|
run: |
|
|
COMPOSE="docker-compose-${ENV_NAME}.yml"
|
|
ENV_FILE=".env_${ENV_NAME}"
|
|
|
|
if [ ! -f "$COMPOSE" ]; then
|
|
echo "ERRORE: $COMPOSE non trovato nel repo"
|
|
exit 1
|
|
fi
|
|
echo "Compose: $COMPOSE"
|
|
|
|
if [ -f "$ENV_FILE" ]; then
|
|
echo "Env file: $ENV_FILE"
|
|
else
|
|
echo "WARNING: $ENV_FILE non trovato, il deploy procede senza env file"
|
|
fi
|
|
|
|
APACHE="apache-${ENV_NAME}.conf"
|
|
if [ -f "$APACHE" ]; then
|
|
echo "Apache config: $APACHE"
|
|
fi
|
|
|
|
- name: Setup SSH
|
|
run: |
|
|
mkdir -p ~/.ssh
|
|
echo "${{ secrets.DEPLOY_SSH_KEY }}" > ~/.ssh/id_ed25519
|
|
chmod 600 ~/.ssh/id_ed25519
|
|
ssh-keyscan -H "${{ vars[inputs.host-var] }}" >> ~/.ssh/known_hosts 2>/dev/null
|
|
|
|
# ─────────────────────────────────────────────────────────────
|
|
# INFISICAL: login con machine identity (universal auth) sul
|
|
# server di deploy, dove la CLI è installata. Il login restituisce
|
|
# un access token a vita breve: è l'UNICA credenziale che viaggia
|
|
# negli step successivi, mentre client id/secret non escono da qui.
|
|
# Le credenziali sono passate via stdin e non come argomenti, così
|
|
# non compaiono nella process list del server (`ps`).
|
|
# ─────────────────────────────────────────────────────────────
|
|
- name: Login Infisical
|
|
run: |
|
|
HOST="${{ vars[inputs.host-var] }}"
|
|
CID="${{ secrets.INFISICAL_CLIENT_ID }}"
|
|
CSEC="${{ secrets.INFISICAL_CLIENT_SECRET }}"
|
|
PID="${{ vars.INFISICAL_PROJECT_ID }}"
|
|
|
|
if [ -z "$CID" ] || [ -z "$CSEC" ] || [ -z "$PID" ]; then
|
|
echo "Secret INFISICAL_* non configurati: deploy senza iniezione dei secret (comportamento legacy)."
|
|
echo "IRUN_ENV=INFISICAL_TOKEN=" >> $GITHUB_ENV
|
|
exit 0
|
|
fi
|
|
|
|
if ! ssh ${DEPLOY_USER}@${HOST} "command -v infisical >/dev/null 2>&1"; then
|
|
echo "ERRORE: CLI 'infisical' non trovata su ${HOST}."
|
|
echo "Installala sul server oppure rimuovi i secret INFISICAL_* per tornare al deploy legacy."
|
|
exit 1
|
|
fi
|
|
|
|
TOKEN=$(printf '%s\n%s\n%s\n' "$CID" "$CSEC" "$INFISICAL_DOMAIN" | ssh ${DEPLOY_USER}@${HOST} '
|
|
read -r cid
|
|
read -r csec
|
|
read -r dom
|
|
export INFISICAL_UNIVERSAL_AUTH_CLIENT_ID="$cid"
|
|
export INFISICAL_UNIVERSAL_AUTH_CLIENT_SECRET="$csec"
|
|
export INFISICAL_DOMAIN="$dom"
|
|
export INFISICAL_DISABLE_UPDATE_CHECK=true
|
|
infisical login --method=universal-auth --silent --plain
|
|
')
|
|
|
|
TOKEN=$(echo "$TOKEN" | tr -d '\r' | tail -n 1)
|
|
if [ -z "$TOKEN" ]; then
|
|
echo "ERRORE: login Infisical fallito su ${INFISICAL_DOMAIN}."
|
|
exit 1
|
|
fi
|
|
echo "::add-mask::$TOKEN"
|
|
|
|
# Prefisso di ambiente riusato da tutti gli ssh successivi: viene
|
|
# letto da .irun.sh sul server per decidere se e come iniettare i
|
|
# secret. Il token è mascherato nei log.
|
|
echo "IRUN_ENV=INFISICAL_TOKEN='${TOKEN}' INFISICAL_PROJECT_ID='${PID}' INFISICAL_ENV='${ENV_NAME}' INFISICAL_DOMAIN='${INFISICAL_DOMAIN}' INFISICAL_DISABLE_UPDATE_CHECK=true" >> $GITHUB_ENV
|
|
echo "Login Infisical OK (${INFISICAL_DOMAIN}) - environment '${ENV_NAME}', path '/' ricorsivo."
|
|
|
|
- name: Docker login sul server
|
|
run: |
|
|
HOST="${{ vars[inputs.host-var] }}"
|
|
REGISTRY="${{ vars.DOCKER_REGISTRY }}"
|
|
AUTH=$(echo -n "${{ secrets.MAVEN_USERNAME }}:${{ secrets.MAVEN_PASSWORD }}" | base64 -w0)
|
|
|
|
# Scrive config.json direttamente, senza passare per docker login / credential helper
|
|
ssh ${DEPLOY_USER}@${HOST} "mkdir -p /tmp/.docker-ci && echo '{\"auths\":{\"${REGISTRY}\":{\"auth\":\"${AUTH}\"}}}' > /tmp/.docker-ci/config.json"
|
|
|
|
# ─────────────────────────────────────────────────────────────
|
|
# SNAPSHOT: prima di sovrascrivere qualsiasi cosa, salviamo lo
|
|
# stato attuale (compose/env + immagini in esecuzione) così da
|
|
# poter ripristinare la versione precedente in caso di errore.
|
|
# ─────────────────────────────────────────────────────────────
|
|
- name: Prepara server (snapshot rollback + copia file)
|
|
run: |
|
|
HOST="${{ vars[inputs.host-var] }}"
|
|
REMOTE_PATH="${DEPLOY_BASE_PATH}/${{ github.repository_owner }}/${{ github.event.repository.name }}"
|
|
COMPOSE="docker-compose-${ENV_NAME}.yml"
|
|
ENV_FILE=".env_${ENV_NAME}"
|
|
APACHE="apache-${ENV_NAME}.conf"
|
|
|
|
ENVFLAG=""
|
|
[ -f "$ENV_FILE" ] && ENVFLAG="--env-file ${ENV_FILE}"
|
|
|
|
ssh ${DEPLOY_USER}@${HOST} "mkdir -p ${REMOTE_PATH}"
|
|
|
|
# Wrapper unico per TUTTI i comandi che devono vedere i secret
|
|
# (docker compose pull/up/ps e gli script .wait-healthy.sh /
|
|
# .sync-fe-hosts.sh, che a loro volta invocano docker compose).
|
|
# Va copiato per primo: viene usato già dallo snapshot qui sotto
|
|
# e dallo step di rollback.
|
|
cat > /tmp/irun.sh << 'EOF'
|
|
#!/bin/sh
|
|
# Esegue il comando ricevuto iniettando i secret di Infisical come
|
|
# variabili d'ambiente del processo. Per docker compose l'ambiente
|
|
# della shell ha precedenza su --env-file: il file .env_<ambiente>
|
|
# del repo resta quindi la base e Infisical sovrascrive/integra.
|
|
# Se INFISICAL_TOKEN non e' valorizzato il comando viene eseguito
|
|
# tale e quale: comportamento legacy invariato.
|
|
set -e
|
|
CMD="$*"
|
|
|
|
if [ -z "${INFISICAL_TOKEN}" ]; then
|
|
exec sh -c "${CMD}"
|
|
fi
|
|
|
|
if ! command -v infisical >/dev/null 2>&1; then
|
|
echo "ERRORE: CLI 'infisical' non installata su questo server." >&2
|
|
exit 1
|
|
fi
|
|
|
|
# --recursive non e' presente su tutte le versioni della CLI: lo si
|
|
# usa solo se supportato, evitando un "unknown flag" in produzione.
|
|
RFLAG=""
|
|
if infisical run --help 2>/dev/null | grep -q -- "--recursive"; then
|
|
RFLAG="--recursive"
|
|
fi
|
|
|
|
exec infisical run \
|
|
--projectId="${INFISICAL_PROJECT_ID}" \
|
|
--env="${INFISICAL_ENV}" \
|
|
--path=/ \
|
|
$RFLAG \
|
|
--command="${CMD}"
|
|
EOF
|
|
scp /tmp/irun.sh ${DEPLOY_USER}@${HOST}:${REMOTE_PATH}/.irun.sh
|
|
|
|
# Snapshot dello stato corrente PRIMA di sovrascrivere i file
|
|
ssh ${DEPLOY_USER}@${HOST} "
|
|
set -e
|
|
export ${IRUN_ENV:-INFISICAL_TOKEN=}
|
|
cd ${REMOTE_PATH}
|
|
# Se esiste già uno .rollback, non cancellarlo: potrebbe essere l'unica
|
|
# traccia di un deploy precedente il cui rollback non è andato a buon
|
|
# fine. Lo archiviamo invece di distruggerlo.
|
|
if [ -d .rollback ]; then
|
|
rm -rf .rollback.bak
|
|
mv .rollback .rollback.bak
|
|
echo 'Trovato uno .rollback preesistente: archiviato in .rollback.bak.'
|
|
fi
|
|
mkdir -p .rollback
|
|
if [ -f ${COMPOSE} ]; then
|
|
cp -f ${COMPOSE} .rollback/${COMPOSE}
|
|
[ -f ${ENV_FILE} ] && cp -f ${ENV_FILE} .rollback/${ENV_FILE} || true
|
|
ids=\$(sh .irun.sh \"docker compose -f ${COMPOSE} ${ENVFLAG} ps -q\" 2>/dev/null || true)
|
|
if [ -n \"\$ids\" ]; then
|
|
echo 'services:' > .rollback/pin.yml
|
|
for cid in \$ids; do
|
|
svc=\$(docker inspect -f '{{ index .Config.Labels \"com.docker.compose.service\" }}' \$cid 2>/dev/null || true)
|
|
img=\$(docker inspect -f '{{ .Image }}' \$cid 2>/dev/null || true)
|
|
if [ -n \"\$svc\" ] && [ -n \"\$img\" ]; then
|
|
printf ' %s:\n image: \"%s\"\n' \"\$svc\" \"\$img\" >> .rollback/pin.yml
|
|
fi
|
|
done
|
|
echo 'Snapshot immagini correnti salvato (.rollback/pin.yml).'
|
|
fi
|
|
else
|
|
echo 'Nessun deploy precedente: snapshot non necessario.'
|
|
fi
|
|
"
|
|
|
|
# Copia i nuovi file sul server
|
|
FILES_TO_COPY="${COMPOSE}"
|
|
[ -f "$ENV_FILE" ] && FILES_TO_COPY="${FILES_TO_COPY} ${ENV_FILE}"
|
|
[ -f "$APACHE" ] && FILES_TO_COPY="${FILES_TO_COPY} ${APACHE}"
|
|
scp ${FILES_TO_COPY} ${DEPLOY_USER}@${HOST}:${REMOTE_PATH}/
|
|
|
|
# Script di sync FE -> /etc/hosts, usato sia dopo un deploy riuscito
|
|
# sia dal rollback: la stessa logica in un unico posto evita che le
|
|
# due strade si disallineino (es. il fix di un bug fatto solo in uno
|
|
# dei due punti). Aggiorna sempre l'IP se cambiato, non solo se assente:
|
|
# il container FE viene ricreato ad ogni deploy (o rollback) e riceve
|
|
# quasi certamente un IP diverso sulla bridge network di Docker.
|
|
cat > /tmp/sync-fe-hosts.sh << 'EOF'
|
|
#!/bin/sh
|
|
set -e
|
|
COMPOSE="$1"
|
|
ENV_FILE="$2"
|
|
|
|
ENVFLAG=""
|
|
[ -n "$ENV_FILE" ] && [ -f "$ENV_FILE" ] && ENVFLAG="--env-file $ENV_FILE"
|
|
|
|
FE_CID=""
|
|
for cid in $(docker compose -f "$COMPOSE" $ENVFLAG ps -q); do
|
|
t=$(docker inspect -f '{{ index .Config.Labels "type" }}' "$cid" 2>/dev/null || true)
|
|
if [ "$t" = "FE" ]; then
|
|
FE_CID="$cid"
|
|
break
|
|
fi
|
|
done
|
|
|
|
if [ -z "$FE_CID" ]; then
|
|
echo "Nessun container con label type=FE trovato: /etc/hosts non modificato."
|
|
exit 0
|
|
fi
|
|
|
|
SVC_NAME=$(docker inspect -f '{{ index .Config.Labels "com.docker.compose.service" }}' "$FE_CID")
|
|
FE_IP=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$FE_CID")
|
|
|
|
if [ -z "$SVC_NAME" ] || [ -z "$FE_IP" ]; then
|
|
echo "ATTENZIONE: impossibile determinare nome servizio o IP del container FE."
|
|
exit 0
|
|
fi
|
|
|
|
echo "Container FE trovato: servizio=$SVC_NAME ip=$FE_IP"
|
|
|
|
CURRENT_IP=$(awk -v s="$SVC_NAME" '$2==s{print $1; exit}' /etc/hosts)
|
|
if [ "$CURRENT_IP" = "$FE_IP" ]; then
|
|
echo "Voce gia' aggiornata in /etc/hosts per '$SVC_NAME' ($FE_IP), nessuna modifica."
|
|
else
|
|
if [ -n "$CURRENT_IP" ]; then
|
|
echo "IP cambiato per '$SVC_NAME': $CURRENT_IP -> $FE_IP. Aggiorno /etc/hosts."
|
|
sed -i "/[[:space:]]$SVC_NAME\$/d" /etc/hosts
|
|
fi
|
|
echo "$FE_IP $SVC_NAME" >> /etc/hosts
|
|
echo "Voce in /etc/hosts aggiornata: $FE_IP $SVC_NAME"
|
|
fi
|
|
EOF
|
|
scp /tmp/sync-fe-hosts.sh ${DEPLOY_USER}@${HOST}:${REMOTE_PATH}/.sync-fe-hosts.sh
|
|
|
|
# Script di attesa "running/healthy", usato sia da "Verifica container"
|
|
# dopo un deploy riuscito sia dal rollback prima di risincronizzare
|
|
# /etc/hosts: dopo un "up -d" (nuovo deploy o rollback) i container
|
|
# impiegano tempo a diventare healthy, quindi non basta lanciare
|
|
# "up -d" e proseguire subito - va aspettato che si stabilizzino,
|
|
# altrimenti (come nel caso del rollback) si rischia di leggere
|
|
# l'IP del FE prima che sia pronto o mentre sta ancora ripartendo.
|
|
cat > /tmp/wait-healthy.sh << 'EOF'
|
|
#!/bin/sh
|
|
set -e
|
|
COMPOSE="$1"
|
|
ENV_FILE="$2"
|
|
TIMEOUT="$3"
|
|
INTERVAL=5
|
|
|
|
ENVFLAG=""
|
|
[ -n "$ENV_FILE" ] && [ -f "$ENV_FILE" ] && ENVFLAG="--env-file $ENV_FILE"
|
|
|
|
elapsed=0
|
|
while true; do
|
|
ids=$(DOCKER_CONFIG=/tmp/.docker-ci docker compose -f "$COMPOSE" $ENVFLAG ps -q)
|
|
if [ -z "$ids" ]; then
|
|
echo "ERRORE: nessun container in esecuzione."
|
|
exit 1
|
|
fi
|
|
fail=0
|
|
pending=0
|
|
for cid in $ids; do
|
|
svc=$(docker inspect -f '{{ index .Config.Labels "com.docker.compose.service" }}' "$cid" 2>/dev/null)
|
|
[ -z "$svc" ] && svc="$cid"
|
|
status=$(docker inspect -f '{{.State.Status}}' "$cid")
|
|
health=$(docker inspect -f '{{if .State.Health}}{{.State.Health.Status}}{{else}}n/a{{end}}' "$cid")
|
|
echo "Servizio $svc: status=$status health=$health"
|
|
if [ "$status" != "running" ]; then
|
|
echo "ERRORE: servizio $svc non e' in stato running (status=$status)."
|
|
fail=1
|
|
elif [ "$health" = "unhealthy" ]; then
|
|
echo "ERRORE: servizio $svc risulta unhealthy."
|
|
fail=1
|
|
elif [ "$health" = "starting" ]; then
|
|
pending=1
|
|
fi
|
|
done
|
|
|
|
if [ "$fail" -eq 1 ]; then
|
|
DOCKER_CONFIG=/tmp/.docker-ci docker compose -f "$COMPOSE" $ENVFLAG ps
|
|
exit 1
|
|
fi
|
|
|
|
if [ "$pending" -eq 0 ]; then
|
|
echo "Tutti i servizi sono running e (se previsto) healthy."
|
|
exit 0
|
|
fi
|
|
|
|
if [ "$elapsed" -ge "$TIMEOUT" ]; then
|
|
echo "ERRORE: timeout (${TIMEOUT}s) in attesa che tutti i servizi diventino healthy."
|
|
DOCKER_CONFIG=/tmp/.docker-ci docker compose -f "$COMPOSE" $ENVFLAG ps
|
|
exit 1
|
|
fi
|
|
|
|
echo "In attesa che i servizi diventino healthy... (${elapsed}s/${TIMEOUT}s)"
|
|
sleep "$INTERVAL"
|
|
elapsed=$((elapsed + INTERVAL))
|
|
done
|
|
EOF
|
|
scp /tmp/wait-healthy.sh ${DEPLOY_USER}@${HOST}:${REMOTE_PATH}/.wait-healthy.sh
|
|
|
|
# ─────────────────────────────────────────────────────────────
|
|
# APACHE: sostituiamo il file di config SOLO se è cambiato.
|
|
# Il backup timestamped viene creato solo in caso di differenza.
|
|
# Il reload avviene dopo un deploy andato a buon fine (post-deploy),
|
|
# così non c'è downtime né rischio se il deploy fallisce.
|
|
# ─────────────────────────────────────────────────────────────
|
|
- name: Applica config Apache (solo se cambiata)
|
|
run: |
|
|
HOST="${{ vars[inputs.host-var] }}"
|
|
REMOTE_PATH="${DEPLOY_BASE_PATH}/${{ github.repository_owner }}/${{ github.event.repository.name }}"
|
|
APACHE="apache-${ENV_NAME}.conf"
|
|
SITE="${{ github.event.repository.name }}.site-ssl"
|
|
|
|
if [ ! -f "$APACHE" ]; then
|
|
echo "Nessun ${APACHE} nel repo: gestione Apache saltata."
|
|
exit 0
|
|
fi
|
|
|
|
ssh ${DEPLOY_USER}@${HOST} "
|
|
set -e
|
|
ACTIVE=/etc/apache2/sites-available/${SITE}.conf
|
|
NEW=${REMOTE_PATH}/${APACHE}
|
|
MARK=${REMOTE_PATH}/.apache-rollback
|
|
if cmp -s \"\$NEW\" \"\$ACTIVE\"; then
|
|
echo 'Config Apache invariata: nessun backup, nessuna modifica.'
|
|
rm -f \"\$MARK\"
|
|
else
|
|
if [ -f \"\$ACTIVE\" ]; then
|
|
BK=\"\${ACTIVE}_\$(date +%s)\"
|
|
cp -v \"\$ACTIVE\" \"\$BK\"
|
|
echo \"\$BK\" > \"\$MARK\"
|
|
else
|
|
# Prima installazione: nessun file precedente da ripristinare
|
|
echo '' > \"\$MARK\"
|
|
fi
|
|
cp -v \"\$NEW\" \"\$ACTIVE\"
|
|
echo 'Config Apache aggiornata (reload dopo il deploy).'
|
|
fi
|
|
"
|
|
|
|
- name: Pre-deploy (comando custom)
|
|
if: ${{ inputs.pre-deploy-cmd != '' }}
|
|
run: |
|
|
HOST="${{ vars[inputs.host-var] }}"
|
|
ssh ${DEPLOY_USER}@${HOST} "${{ inputs.pre-deploy-cmd }}"
|
|
|
|
- name: Deploy
|
|
run: |
|
|
HOST="${{ vars[inputs.host-var] }}"
|
|
REMOTE_PATH="${DEPLOY_BASE_PATH}/${{ github.repository_owner }}/${{ github.event.repository.name }}"
|
|
COMPOSE="docker-compose-${ENV_NAME}.yml"
|
|
ENV_FILE=".env_${ENV_NAME}"
|
|
|
|
CBASE="cd ${REMOTE_PATH} && DOCKER_CONFIG=/tmp/.docker-ci docker compose -f ${COMPOSE}"
|
|
[ -f "$ENV_FILE" ] && CBASE="${CBASE} --env-file ${ENV_FILE}"
|
|
|
|
# I comandi passano da .irun.sh: i secret Infisical vengono iniettati
|
|
# nel processo docker compose (interpolazione ${VAR} nel compose file
|
|
# e blocchi "environment:"), senza mai finire su disco.
|
|
ssh ${DEPLOY_USER}@${HOST} "${IRUN_ENV} sh ${REMOTE_PATH}/.irun.sh '${CBASE} pull'"
|
|
ssh ${DEPLOY_USER}@${HOST} "${IRUN_ENV} sh ${REMOTE_PATH}/.irun.sh '${CBASE} up -d ${{ inputs.compose-opts }}'"
|
|
|
|
- name: Post-deploy
|
|
run: |
|
|
HOST="${{ vars[inputs.host-var] }}"
|
|
REMOTE_PATH="${DEPLOY_BASE_PATH}/${{ github.repository_owner }}/${{ github.event.repository.name }}"
|
|
SITE="${{ github.event.repository.name }}.site-ssl"
|
|
|
|
# Deploy OK: attiva il sito e ricarica Apache con la nuova config
|
|
ssh ${DEPLOY_USER}@${HOST} "a2ensite ${SITE} -q"
|
|
ssh ${DEPLOY_USER}@${HOST} "service apache2 reload"
|
|
|
|
# NB: lo snapshot di rollback (.rollback, .apache-rollback) e le immagini
|
|
# precedenti NON vengono ripulite qui. Il comando post-deploy-cmd qui sotto
|
|
# può ancora fallire (es. uno smoke test/health-check): se il rollback
|
|
# dovesse servire, deve trovare ancora tutti i dati intatti. La pulizia
|
|
# avviene solo nello step dedicato "Cleanup rollback", eseguito per ultimo
|
|
# e solo se l'intero job è andato a buon fine.
|
|
|
|
# Comando custom (solo se fornito)
|
|
if [ -n "${{ inputs.post-deploy-cmd }}" ]; then
|
|
ssh ${DEPLOY_USER}@${HOST} "${{ inputs.post-deploy-cmd }}"
|
|
fi
|
|
|
|
- name: Verifica container
|
|
run: |
|
|
HOST="${{ vars[inputs.host-var] }}"
|
|
REMOTE_PATH="${DEPLOY_BASE_PATH}/${{ github.repository_owner }}/${{ github.event.repository.name }}"
|
|
COMPOSE="docker-compose-${ENV_NAME}.yml"
|
|
ENV_FILE=".env_${ENV_NAME}"
|
|
TIMEOUT="${{ inputs.health-timeout-seconds }}"
|
|
|
|
CBASE="cd ${REMOTE_PATH} && DOCKER_CONFIG=/tmp/.docker-ci docker compose -f ${COMPOSE}"
|
|
[ -f "$ENV_FILE" ] && CBASE="${CBASE} --env-file ${ENV_FILE}"
|
|
|
|
echo "── Container status (iniziale) ──"
|
|
ssh ${DEPLOY_USER}@${HOST} "${IRUN_ENV} sh ${REMOTE_PATH}/.irun.sh '${CBASE} ps'"
|
|
|
|
# Attende che tutti i container siano "running" e, se hanno un
|
|
# healthcheck definito, "healthy" (vedi .wait-healthy.sh, creato
|
|
# nello step "Prepara server" e condiviso con il rollback).
|
|
ssh ${DEPLOY_USER}@${HOST} "${IRUN_ENV} sh ${REMOTE_PATH}/.irun.sh 'cd ${REMOTE_PATH} && sh .wait-healthy.sh ${COMPOSE} ${ENV_FILE} ${TIMEOUT}'"
|
|
|
|
echo "── Container status (finale) ──"
|
|
ssh ${DEPLOY_USER}@${HOST} "${IRUN_ENV} sh ${REMOTE_PATH}/.irun.sh '${CBASE} ps'"
|
|
|
|
# ─────────────────────────────────────────────────────────────
|
|
# HOSTS: dopo un deploy riuscito, recuperiamo l'IP del container
|
|
# FE (label type=FE) e ci assicuriamo che /etc/hosts sul server
|
|
# abbia una voce "IP nome_servizio" aggiornata. A differenza della
|
|
# versione precedente, se il container viene ricreato con un IP
|
|
# diverso la voce ESISTENTE viene aggiornata (non solo aggiunta se
|
|
# assente) — logica delegata a .sync-fe-hosts.sh, che viene
|
|
# richiamato anche dallo step di Rollback per rimanere coerente
|
|
# con qualunque versione (nuova o ripristinata) finisca in esecuzione.
|
|
# ─────────────────────────────────────────────────────────────
|
|
- name: Aggiorna /etc/hosts con IP container FE
|
|
run: |
|
|
HOST="${{ vars[inputs.host-var] }}"
|
|
REMOTE_PATH="${DEPLOY_BASE_PATH}/${{ github.repository_owner }}/${{ github.event.repository.name }}"
|
|
COMPOSE="docker-compose-${ENV_NAME}.yml"
|
|
ENV_FILE=".env_${ENV_NAME}"
|
|
|
|
ssh ${DEPLOY_USER}@${HOST} "${IRUN_ENV} sh ${REMOTE_PATH}/.irun.sh 'cd ${REMOTE_PATH} && sh .sync-fe-hosts.sh ${COMPOSE} ${ENV_FILE}'"
|
|
|
|
# ─────────────────────────────────────────────────────────────
|
|
# CLEANUP: eseguito SOLO se tutti gli step precedenti sono andati
|
|
# a buon fine (compreso post-deploy-cmd e la verifica container).
|
|
# Solo a questo punto è sicuro eliminare gli snapshot di rollback:
|
|
# se questa pulizia venisse fatta prima (come accadeva nel vecchio
|
|
# step "Post-deploy"), un fallimento successivo lascerebbe il
|
|
# rollback senza dati con cui operare.
|
|
# Rimuove solo l'immagine precedente pinnata (non un prune globale):
|
|
# su un host condiviso da più progetti un "docker image prune -a -f"
|
|
# cancellerebbe anche snapshot di rollback di ALTRI progetti.
|
|
# ─────────────────────────────────────────────────────────────
|
|
- name: Cleanup rollback (deploy riuscito)
|
|
if: success()
|
|
run: |
|
|
HOST="${{ vars[inputs.host-var] }}"
|
|
REMOTE_PATH="${DEPLOY_BASE_PATH}/${{ github.repository_owner }}/${{ github.event.repository.name }}"
|
|
|
|
ssh ${DEPLOY_USER}@${HOST} "
|
|
cd ${REMOTE_PATH}
|
|
if [ -f .rollback/pin.yml ]; then
|
|
for img in \$(grep 'image:' .rollback/pin.yml | awk '{print \$2}' | tr -d '\"'); do
|
|
docker rmi \"\$img\" >/dev/null 2>&1 || true
|
|
done
|
|
fi
|
|
rm -rf .rollback .rollback.bak .apache-rollback
|
|
"
|
|
ssh ${DEPLOY_USER}@${HOST} "rm -rf /tmp/.docker-ci" || true
|
|
|
|
# ─────────────────────────────────────────────────────────────
|
|
# ROLLBACK: eseguito SOLO se uno step precedente è fallito.
|
|
# 1) ripristina la config Apache precedente e riabilita il sito
|
|
# 2) riporta i container alla versione precedente (immagini pinnate)
|
|
# 3) risincronizza /etc/hosts con l'IP del container FE ripristinato
|
|
# ─────────────────────────────────────────────────────────────
|
|
- name: Rollback (deploy fallito)
|
|
if: failure()
|
|
run: |
|
|
HOST="${{ vars[inputs.host-var] }}"
|
|
REMOTE_PATH="${DEPLOY_BASE_PATH}/${{ github.repository_owner }}/${{ github.event.repository.name }}"
|
|
COMPOSE="docker-compose-${ENV_NAME}.yml"
|
|
ENV_FILE=".env_${ENV_NAME}"
|
|
SITE="${{ github.event.repository.name }}.site-ssl"
|
|
TIMEOUT="${{ inputs.health-timeout-seconds }}"
|
|
|
|
ENVFLAG=""
|
|
[ -f "$ENV_FILE" ] && ENVFLAG="--env-file ${ENV_FILE}"
|
|
|
|
echo "Deploy fallito: avvio rollback."
|
|
|
|
# 1) Ripristino config Apache (con apache2ctl configtest come gate prima del reload)
|
|
apache_ok=0
|
|
ssh ${DEPLOY_USER}@${HOST} "
|
|
set -e
|
|
ACTIVE=/etc/apache2/sites-available/${SITE}.conf
|
|
MARK=${REMOTE_PATH}/.apache-rollback
|
|
if [ -f \"\$MARK\" ]; then
|
|
BK=\$(cat \"\$MARK\")
|
|
if [ -n \"\$BK\" ] && [ -f \"\$BK\" ]; then
|
|
echo \"Ripristino config Apache da \$BK\"
|
|
cp -v \"\$BK\" \"\$ACTIVE\"
|
|
a2ensite ${SITE} -q
|
|
else
|
|
echo 'Nessuna config precedente: rimuovo e disabilito il sito.'
|
|
rm -f \"\$ACTIVE\"
|
|
a2dissite ${SITE} -q || true
|
|
fi
|
|
rm -f \"\$MARK\"
|
|
else
|
|
echo 'Config Apache non modificata: riabilito il sito corrente.'
|
|
a2ensite ${SITE} -q
|
|
fi
|
|
apache2ctl configtest
|
|
service apache2 reload
|
|
" || apache_ok=1
|
|
|
|
# 2) Rollback dei container alla versione precedente, poi attesa che
|
|
# siano running/healthy (stesso script .wait-healthy.sh usato in
|
|
# "Verifica container"): "up -d" ritorna appena i container sono
|
|
# avviati, non quando sono pronti. Senza questa attesa, il punto 3)
|
|
# rischia di leggere l'IP del FE prima che sia stabile o mentre sta
|
|
# ancora ripartendo, risincronizzando /etc/hosts con un valore errato.
|
|
container_ok=0
|
|
ssh ${DEPLOY_USER}@${HOST} "
|
|
set -e
|
|
export ${IRUN_ENV:-INFISICAL_TOKEN=}
|
|
cd ${REMOTE_PATH}
|
|
if [ -f .rollback/${COMPOSE} ]; then
|
|
cp -f .rollback/${COMPOSE} ${COMPOSE}
|
|
[ -f .rollback/${ENV_FILE} ] && cp -f .rollback/${ENV_FILE} ${ENV_FILE} || true
|
|
PIN=''
|
|
[ -f .rollback/pin.yml ] && PIN='-f .rollback/pin.yml'
|
|
echo 'Ripristino container alla versione precedente...'
|
|
sh .irun.sh \"DOCKER_CONFIG=/tmp/.docker-ci docker compose -f ${COMPOSE} \$PIN ${ENVFLAG} up -d\"
|
|
echo 'Attendo che i container ripristinati siano running/healthy...'
|
|
sh .irun.sh \"sh .wait-healthy.sh ${COMPOSE} ${ENV_FILE} ${TIMEOUT}\"
|
|
else
|
|
echo 'Nessuno snapshot disponibile: nessun rollback container (probabile primo deploy).'
|
|
fi
|
|
" || container_ok=1
|
|
|
|
# 3) Risincronizza /etc/hosts con l'IP del container FE dopo il rollback.
|
|
# Non si ripristina un vecchio valore salvato: il container viene
|
|
# ricreato da "docker compose up -d" e riceve quasi certamente un IP
|
|
# diverso (anche restando sulla stessa immagine precedente), quindi
|
|
# si usa lo stesso script di sync usato dopo un deploy riuscito.
|
|
# Prima di questa fix, un rollback lasciava /etc/hosts con l'IP del
|
|
# deploy fallito (o, se prima non c'era una voce, nessuna voce),
|
|
# puntando a un container che non esiste più.
|
|
hosts_ok=0
|
|
ssh ${DEPLOY_USER}@${HOST} "${IRUN_ENV:-INFISICAL_TOKEN=} sh ${REMOTE_PATH}/.irun.sh 'cd ${REMOTE_PATH} && sh .sync-fe-hosts.sh ${COMPOSE} ${ENV_FILE}'" || hosts_ok=1
|
|
|
|
# Cleanup config temporaneo (best-effort, non deve mascherare l'esito del rollback)
|
|
ssh ${DEPLOY_USER}@${HOST} "rm -rf /tmp/.docker-ci" || true
|
|
|
|
if [ "$apache_ok" -ne 0 ] || [ "$container_ok" -ne 0 ] || [ "$hosts_ok" -ne 0 ]; then
|
|
echo "ERRORE: rollback automatico NON riuscito (apache_ok=$apache_ok, container_ok=$container_ok, hosts_ok=$hosts_ok). E' necessario un intervento manuale immediato."
|
|
exit 1
|
|
fi
|
|
|
|
echo "Rollback completato con successo: sistema ripristinato alla versione precedente." |