Files
Studio_Grasso/deploy/gitea-deploy.yml.example
T
Alby96andClaude Sonnet 5.5 31ac5b7f68
CI / Verifica (lint, build, test, Lighthouse, pacchetto) (push) Canceled after 40m56s
CI / Link esterni (non bloccante) (push) Canceled after 0s
ci: Gitea Actions, release con il solo zip del sito e documentazione senza Forgejo
Il progetto vive in modo definitivo su Gitea: i workflow passano da .forgejo/ a
.gitea/workflows/ e la documentazione non nomina più la piattaforma precedente.

- ci.yml: i controlli di npm run verify sono passi separati (si vede subito quale è
  fallito) e alla fine la CI crea lo zip di rilascio e ne verifica il contenuto, così un
  errore di pacchetto emerge prima del tag. Runner ubuntu-latest, azioni da github.com con
  URL completo, upload-artifact@v3 (la v4 non funziona su Gitea).
- release.yml: a ogni tag vX.Y.Z verifica tutto, crea lo zip e lo pubblica nella Release
  con scripts/release-upload.sh e l'API di Gitea, senza action esterne di release.
- La release contiene un solo file, sito-studio-grasso-vX.Y.Z.zip (contenuto di dist/ alla
  radice, .htaccess compreso): tolti tar.gz, SHA256SUMS.txt e BUILD-INFO.txt da
  package.mjs, check-package.mjs e dalla documentazione.
- release-upload.sh: variabili GITEA_*, si ferma su errori diversi da 404 invece di
  provare a creare la release, rifiuta una cartella vuota; provato su una finta API Gitea.
- deploy/gitea-deploy.yml.example convertito per Gitea (resta disattivato).
- Versione 1.0.1 pronta (package.json, CHANGELOG, D-056 e D-057 in DECISIONS.md); il tag
  v1.0.1 non è stato creato.

Verifica: npm run verify completo (lint, formato, tipi, build, HTML, link, e2e 39,
a11y 51, conformità 1455, Lighthouse) e npm run package eseguiti in una copia fuori da
.claude/. I workflow non sono ancora stati eseguiti su un runner Gitea.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 11:15:08 +02:00

215 lines
12 KiB
Plaintext

# =============================================================================
# DEPLOY AUTOMATICO (DISATTIVATO) — esempio per Gitea Actions.
#
# Per attivarlo: copiare questo file in .gitea/workflows/deploy.yml, scegliere UNA delle
# varianti qui sotto (rsync su SSH, FTPS con lftp, object storage con rclone), decommentarla
# e creare i segreti del repository indicati (Impostazioni → Actions → Segreti). I nomi dei
# segreti non possono iniziare con GITEA_ o GITHUB_.
# Istruzioni complete in docs/DEPLOY.md, sezione «Deploy automatico».
#
# Pubblica il contenuto dello zip della release, sito-studio-grasso-vX.Y.Z.zip: l'unico file
# allegato da release.yml (i due archivi «Source code» che Gitea aggiunge da solo sono il
# codice sorgente, non il sito). Dopo il download ne controlla l'integrità (unzip -t) e la
# presenza di index.html e .htaccess.
#
# Si avvia quando release.yml pubblica una release stabile oppure a mano (workflow_dispatch,
# indicando il tag: serve anche per tornare a una versione precedente).
# - Evento: per «release» Gitea supporta i tipi published (release non in bozza creata) ed
# edited (release modificata); una bozza non genera alcun evento. release.yml e
# scripts/release-upload.sh creano la release in bozza, caricano lo zip e solo allora la
# pubblicano: Gitea notifica questo passaggio come modifica, non come «published». Per questo
# si ascoltano entrambi i tipi, e il job «controllo» procede solo per una release stabile che
# sia l'ultima pubblicata e, per le modifiche, solo se lo zip è stato caricato nell'ultima ora
# (cioè è la pubblicazione fatta da release.yml o da scripts/release-upload.sh). Modificare
# in seguito titolo o note di una release, anche l'ultima, non avvia il deploy. Dopo un
# ritorno manuale a una versione precedente segnare come pre-release la versione ritirata.
# - Token: Gitea non avvia workflow in risposta a ciò che fa il token automatico di un altro
# workflow (per evitare cicli). L'avvio automatico funziona quindi solo se release.yml
# pubblica la release con un token personale (segreto RELEASE_TOKEN). Senza il segreto,
# avviarlo a mano dalla scheda Actions del repository.
# - File: per gli eventi di release Gitea legge il workflow dal commit del tag, quindi questo
# file deve già essere nel commit su cui è messo il tag. Per una release uscita prima di
# aggiungerlo, usare l'avvio manuale.
# I file gestiti dall'hosting (.well-known/, .user.ini, cgi-bin/) sono esclusi dalla
# sincronizzazione, quindi non vengono cancellati.
# RUNNER: `runs-on: ubuntu-latest`, il label predefinito di act_runner, come negli altri
# workflow: sostituirlo se il runner ne usa un altro.
# =============================================================================
name: Deploy
on:
release:
types: [published, edited]
workflow_dispatch:
inputs:
tag:
description: 'Tag della release da pubblicare (es. v1.0.1)'
required: true
jobs:
controllo:
name: Release da pubblicare
runs-on: ubuntu-latest # label del runner: adattare se diverso
container:
image: debian:stable-slim
outputs:
tag: ${{ steps.scelta.outputs.tag }}
steps:
- name: Scegli la release
id: scelta
env:
EVENTO: ${{ github.event_name }}
AZIONE: ${{ github.event.action }}
TAG_MANUALE: ${{ github.event.inputs.tag }}
TAG_RELEASE: ${{ github.event.release.tag_name }}
BOZZA: ${{ github.event.release.draft }}
PRERELEASE: ${{ github.event.release.prerelease }}
TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
set -eu
if [ "$EVENTO" = workflow_dispatch ]; then
# il tag finisce in un indirizzo di download: solo vX.Y.Z (o vX.Y.Z-suffisso)
printf '%s' "$TAG_MANUALE" | grep -Eq '^v[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.]+)?$' \
|| { echo "tag non valido: $TAG_MANUALE (atteso vX.Y.Z)" >&2; exit 1; }
echo "tag=$TAG_MANUALE" >> "$GITHUB_OUTPUT"
exit 0
fi
if [ "$BOZZA" = true ] || [ "$PRERELEASE" = true ]; then
echo "$TAG_RELEASE è una bozza o una pre-release: nessun deploy."
exit 0
fi
apt-get update -qq && apt-get install -y -qq --no-install-recommends ca-certificates curl jq >/dev/null
# modifica anziché prima pubblicazione: si procede solo se lo zip è appena stato
# caricato, cioè se è la pubblicazione fatta da release.yml o da release-upload.sh
if [ "$AZIONE" != published ]; then
ULTIMO_FILE="$(jq -r '[(.release.assets // [])[].created_at] | max // empty' "$GITHUB_EVENT_PATH")"
if [ -z "$ULTIMO_FILE" ] || [ $(( $(date +%s) - $(date -d "$ULTIMO_FILE" +%s) )) -gt 3600 ]; then
echo "$TAG_RELEASE: modifica di una release già pubblicata, nessun deploy (per ripubblicarla usare l'avvio manuale)."
exit 0
fi
fi
# chiamata separata dal parsing: se l'API non risponde lo step fallisce (set -e) invece
# di saltare il deploy in silenzio
RISPOSTA="$(curl -fsS -H "Authorization: token ${TOKEN}" \
"${{ github.server_url }}/api/v1/repos/${{ github.repository }}/releases/latest")"
ULTIMA="$(printf '%s' "$RISPOSTA" | jq -r .tag_name)"
if [ -z "$ULTIMA" ] || [ "$ULTIMA" = null ]; then
echo "risposta inattesa da /releases/latest" >&2
exit 1
fi
if [ "$ULTIMA" != "$TAG_RELEASE" ]; then
echo "$TAG_RELEASE non è l'ultima release pubblicata ($ULTIMA): nessun deploy."
exit 0
fi
echo "tag=$TAG_RELEASE" >> "$GITHUB_OUTPUT"
deploy:
needs: controllo
if: needs.controllo.outputs.tag != ''
runs-on: ubuntu-latest # label del runner: adattare se diverso
container:
image: debian:stable-slim
steps:
- name: Strumenti
run: apt-get update && apt-get install -y --no-install-recommends ca-certificates curl unzip
# aggiungere: rsync openssh-client (variante A) · lftp (variante B) · rclone (variante C)
- name: Scarica e controlla lo zip della release
env:
TAG: ${{ needs.controllo.outputs.tag }}
TOKEN: ${{ secrets.GITHUB_TOKEN }} # token automatico del workflow
run: |
set -eu
VERSION="${TAG#v}"
curl -fsSL -H "Authorization: token ${TOKEN}" -o pacchetto.zip \
"${{ github.server_url }}/${{ github.repository }}/releases/download/${TAG}/sito-studio-grasso-v${VERSION}.zip"
unzip -tq pacchetto.zip # integrità: si ferma se lo zip è danneggiato o incompleto
mkdir sito && unzip -q pacchetto.zip -d sito
for f in index.html .htaccess; do
[ -f "sito/$f" ] || { echo "manca $f nel pacchetto: non è lo zip del sito" >&2; exit 1; }
done
# ---------------------------------------------------------------------------
# Variante A — rsync su SSH (VPS o hosting con accesso SSH)
# Segreti: DEPLOY_HOST, DEPLOY_USER, DEPLOY_PATH, DEPLOY_SSH_KEY (chiave privata)
# DEPLOY_PATH = cartella pubblica del sito (es. /var/www/studio-grasso): con --delete
# tutto ciò che contiene e non è nel pacchetto viene cancellato. Prima del primo deploy
# creare sul server il file di conferma: touch <DEPLOY_PATH>/.deploy-studio-grasso
# Senza quel file lo step si ferma: un percorso sbagliato (la home, /var/www…) non viene
# mai sincronizzato.
# ---------------------------------------------------------------------------
# - name: Pubblica con rsync
# env:
# DEPLOY_HOST: ${{ secrets.DEPLOY_HOST }}
# DEPLOY_USER: ${{ secrets.DEPLOY_USER }}
# DEPLOY_PATH: ${{ secrets.DEPLOY_PATH }}
# DEPLOY_SSH_KEY: ${{ secrets.DEPLOY_SSH_KEY }}
# run: |
# set -eu
# # un segreto mancante vale "": senza questo controllo la destinazione sarebbe «/»
# : "${DEPLOY_PATH:?segreto DEPLOY_PATH mancante o vuoto}"
# case "$DEPLOY_PATH" in
# /|'~'|'~/'|.|./|/home|/home/|/root|/root/) echo "DEPLOY_PATH non sicuro: $DEPLOY_PATH" >&2; exit 1 ;;
# esac
# mkdir -p ~/.ssh && chmod 700 ~/.ssh
# printf '%s\n' "$DEPLOY_SSH_KEY" > ~/.ssh/id_deploy && chmod 600 ~/.ssh/id_deploy
# ssh-keyscan -H "$DEPLOY_HOST" >> ~/.ssh/known_hosts
# # la cartella deve essere quella del sito, confermata dal file creato a mano
# ssh -i ~/.ssh/id_deploy "$DEPLOY_USER@$DEPLOY_HOST" "test -f '$DEPLOY_PATH/.deploy-studio-grasso'" \
# || { echo "manca $DEPLOY_PATH/.deploy-studio-grasso: cartella del sito non confermata" >&2; exit 1; }
# rsync -az --delete --exclude '.well-known/' --exclude '.user.ini' --exclude 'cgi-bin/' \
# --exclude '.deploy-studio-grasso' \
# -e "ssh -i ~/.ssh/id_deploy" sito/ "$DEPLOY_USER@$DEPLOY_HOST:$DEPLOY_PATH/"
# ---------------------------------------------------------------------------
# Variante B — FTPS con lftp (hosting condivisi: cPanel, Plesk, Aruba, Register…)
# Segreti: FTP_HOST, FTP_USER, FTP_PASSWORD, FTP_PATH (es. /public_html)
# FTP_PATH = cartella pubblica del sito, MAI la radice dell'account quando questa è la home
# (cPanel): mirror --delete cancellerebbe posta, configurazioni e altri siti.
# ---------------------------------------------------------------------------
# - name: Pubblica via FTPS
# env:
# FTP_HOST: ${{ secrets.FTP_HOST }}
# FTP_USER: ${{ secrets.FTP_USER }}
# FTP_PASSWORD: ${{ secrets.FTP_PASSWORD }}
# FTP_PATH: ${{ secrets.FTP_PATH }}
# run: |
# set -eu
# : "${FTP_PATH:?segreto FTP_PATH mancante o vuoto}"
# lftp -u "$FTP_USER","$FTP_PASSWORD" -e "set ftp:ssl-force true; set ssl:verify-certificate yes; \
# mirror -R --delete --verbose --exclude-glob .well-known/ --exclude-glob .user.ini \
# --exclude-glob cgi-bin/ sito/ $FTP_PATH; quit" "$FTP_HOST"
# ---------------------------------------------------------------------------
# Variante C — object storage S3 compatibile con rclone
# Segreti: RCLONE_CONFIG (contenuto di rclone.conf con il remote «sito»), RCLONE_DEST (es. sito:bucket)
# ---------------------------------------------------------------------------
# - name: Pubblica su object storage
# env:
# RCLONE_CONFIG_CONTENT: ${{ secrets.RCLONE_CONFIG }}
# RCLONE_DEST: ${{ secrets.RCLONE_DEST }}
# run: |
# set -eu
# : "${RCLONE_DEST:?segreto RCLONE_DEST mancante o vuoto}"
# mkdir -p ~/.config/rclone && printf '%s\n' "$RCLONE_CONFIG_CONTENT" > ~/.config/rclone/rclone.conf
# rclone sync sito/ "$RCLONE_DEST" --checksum --exclude '.htaccess'
- name: Controllo dopo la pubblicazione
env:
SITE_URL: ${{ vars.SITE_URL }}
run: |
set -eu
# dominio per cui è stato costruito il pacchetto: la riga «Sitemap:» del robots.txt
# (scritto in build da src/pages/robots.txt.ts), se la variabile del repository SITE_URL
# non è impostata
if [ -z "$SITE_URL" ]; then
SITE_URL="$(tr -d '\r' < sito/robots.txt | sed -n 's|^Sitemap: \(.*\)/sitemap-index\.xml$|\1|p' | head -n 1)"
fi
SITE_URL="${SITE_URL%/}"
: "${SITE_URL:?dominio del sito non trovato (riga Sitemap: di robots.txt nel pacchetto)}"
for p in / /servizi/ /contatti/ /sitemap-index.xml /robots.txt; do
code=$(curl -s -o /dev/null -w '%{http_code}' "${SITE_URL}${p}")
echo "${p} → ${code}"; [ "$code" = 200 ]
done
code=$(curl -s -o /dev/null -w '%{http_code}' "${SITE_URL}/pagina-inesistente/"); echo "404 → ${code}"; [ "$code" = 404 ]