455 lines
21 KiB
YAML
455 lines
21 KiB
YAML
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: ""
|
|
|
|
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] }}
|
|
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
|
|
|
|
- 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}"
|
|
|
|
# Snapshot dello stato corrente PRIMA di sovrascrivere i file
|
|
ssh ${DEPLOY_USER}@${HOST} "
|
|
set -e
|
|
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=\$(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
|
|
|
|
# ─────────────────────────────────────────────────────────────
|
|
# 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}"
|
|
|
|
ssh ${DEPLOY_USER}@${HOST} "${CBASE} pull"
|
|
ssh ${DEPLOY_USER}@${HOST} "${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}"
|
|
|
|
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 ──"
|
|
ssh ${DEPLOY_USER}@${HOST} "${CBASE} ps"
|
|
|
|
# Verifica reale (non solo informativa): se un servizio non è "running"
|
|
# o risulta "unhealthy", lo step fallisce e innesca il rollback.
|
|
ssh ${DEPLOY_USER}@${HOST} "
|
|
set -e
|
|
ids=\$(${CBASE} ps -q)
|
|
if [ -z \"\$ids\" ]; then
|
|
echo 'ERRORE: nessun container in esecuzione dopo il deploy.'
|
|
exit 1
|
|
fi
|
|
fail=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.\"
|
|
fail=1
|
|
fi
|
|
if [ \"\$health\" = 'unhealthy' ]; then
|
|
echo \"ERRORE: servizio \$svc risulta unhealthy.\"
|
|
fail=1
|
|
fi
|
|
done
|
|
exit \$fail
|
|
"
|
|
|
|
# ─────────────────────────────────────────────────────────────
|
|
# 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} "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"
|
|
|
|
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
|
|
container_ok=0
|
|
ssh ${DEPLOY_USER}@${HOST} "
|
|
set -e
|
|
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...'
|
|
DOCKER_CONFIG=/tmp/.docker-ci docker compose -f ${COMPOSE} \$PIN ${ENVFLAG} up -d
|
|
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} "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." |