onboard: niente piu' esiti verdi su passi falliti, git e AWS verificati davvero
- configura.sh e progetti.sh escono 1 se un passo non riesce (scrittura di ~/.ssh/config, chiave SSH, clone, chiave AWS), e lo dicono in rosso; - git: per l'indirizzo di Gitea si usa solo il gestore "store", e un token vecchio rimasto in ~/.git-credentials si sostituisce (prima si aggiungeva solo se mancava: API buona e git clone rotto). verifica.sh chiede a git la credenziale che userebbe davvero, invece di accontentarsi di un gestore qualsiasi; - AWS: la chiave si controlla PRIMA di salvarla, e deve essere l'utente della persona nell'account di OTO (ARN completo, non solo il nome). Senza Gitea il passo si salta e verifica.sh non da' piu' verde a una chiave qualsiasi. Avviso se AWS_PROFILE o AWS_ACCESS_KEY_ID... fanno usare un'altra chiave; - API di Gitea: codice HTTP controllato, "Gitea non risponde" distinto da "token non valido", elenco dei progetti interrotto solo su una pagina vuota vera; token passato a curl da stdin; JSON letto anche con gli spazi; - progetti.sh: nomi confrontati in modo esatto, accetta organizzazione/nome e dice quando un nome corto e' ambiguo; - la chiave ~/.ssh/oto_ed25519 viene collegata anche ai nomi che cercano i deploy dei progetti (oto_staging_ed25519, oto_production_ed25519): su un PC preparato da qui il primo deploy si fermava con "Chiave privata non trovata"; - verifica.sh --senza-vpn, per chi non ha la VPN: staging giallo e non rosso. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Fabio
+152
-53
@@ -8,11 +8,18 @@
|
||||
# con l'input nascosto, e un assistente AI non puo' rispondere al posto tuo.
|
||||
# Si puo' rilanciare: quello che e' gia' a posto non viene toccato.
|
||||
# Non crea accessi: quelli li crea un amministratore, qui si usano.
|
||||
# Esce 0 se e' andato tutto, 1 se qualcosa resta da sistemare (detto in rosso).
|
||||
|
||||
set -u
|
||||
cd "$(dirname "$0")" || exit 1
|
||||
. ./comune.sh
|
||||
|
||||
# Un passo non riuscito non ferma gli altri (la chiave SSH serve anche senza
|
||||
# AWS), ma si conta: alla fine "Fatto" si dice solo se non ce ne sono, e
|
||||
# l'uscita e' 1, cosi' chi lo lancia da uno script non va avanti alla cieca.
|
||||
ERRORI=0
|
||||
errore () { male "$@" ; ERRORI=$((ERRORI + 1)) ; }
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
titolo "1. Gitea"
|
||||
# --------------------------------------------------------------------------
|
||||
@@ -22,15 +29,21 @@ titolo "1. Gitea"
|
||||
# chi amministra (nella mail non c'e', apposta): dal 07/10/2026 Gitea non
|
||||
# obbliga piu' a cambiarla. Chi e' stato creato prima invece deve ancora
|
||||
# cambiarla nel browser, e Gitea gli risponde 403: lo si dice sotto.
|
||||
UTENTE="$(utente_gitea)"
|
||||
UTENTE="$(utente_gitea)" ; ESITO_GITEA=$?
|
||||
# Gitea che non risponde non vuol dire token sbagliato: chiedere la password e
|
||||
# creare un altro token non servirebbe a niente. Ci si ferma qui, perche' tutto
|
||||
# il resto (chi e' la persona, dove va la chiave SSH) lo dice Gitea.
|
||||
if [ "$ESITO_GITEA" = "2" ] ; then
|
||||
male "Gitea ($GITEA_URL) non risponde: controlla la connessione a internet e rilancia."
|
||||
exit 1
|
||||
fi
|
||||
# I token creati prima del 07/10/2026 hanno read:organization e non
|
||||
# write:organization, che serve a creare i progetti nell'organizzazione oto.
|
||||
# Lo si chiede a Gitea con una creazione volutamente incompleta (senza nome):
|
||||
# a un token senza lo scope risponde 403 citandolo, a uno giusto 422, e in
|
||||
# nessuno dei due casi crea niente. Il token vecchio si mette da parte e se ne
|
||||
# crea uno nuovo qui sotto; quello vecchio si cancella dal proprio profilo.
|
||||
if [ -n "$UTENTE" ] && curl -s --max-time 10 -X POST -H "Authorization: token $(token_gitea)" \
|
||||
-H 'Content-Type: application/json' -d '{}' "$GITEA_URL/api/v1/orgs/oto/repos" \
|
||||
if [ -n "$UTENTE" ] && api_gitea /orgs/oto/repos -X POST -H 'Content-Type: application/json' -d '{}' \
|
||||
| grep -q 'write:organization' ; then
|
||||
mv "$TOKEN_GITEA_FILE" "$TOKEN_GITEA_FILE.vecchio"
|
||||
attento "il token Gitea salvato non puo' creare progetti nell'organizzazione: ne creo uno nuovo"
|
||||
@@ -57,37 +70,58 @@ else
|
||||
"$GITEA_URL/api/v1/users/$UTENTE_DATO/tokens")"
|
||||
unset PASSWORD PASSWORD_CURL
|
||||
CODICE="${RISPOSTA##*$'\n'}"
|
||||
TOKEN="$(printf '%s' "${RISPOSTA%$'\n'*}" | sed -n 's/.*"sha1":"\([^"]*\)".*/\1/p')"
|
||||
TOKEN="$(printf '%s' "${RISPOSTA%$'\n'*}" | campo_json sha1)"
|
||||
if [ "$CODICE" = "201" ] && [ -n "$TOKEN" ] ; then
|
||||
mkdir -p "$(dirname "$TOKEN_GITEA_FILE")"
|
||||
chmod 700 "$(dirname "$TOKEN_GITEA_FILE")"
|
||||
( umask 077 ; printf '%s\n' "$TOKEN" > "$TOKEN_GITEA_FILE" )
|
||||
chmod 600 "$TOKEN_GITEA_FILE"
|
||||
unset TOKEN
|
||||
UTENTE="$(utente_gitea)"
|
||||
ok "accesso Gitea salvato in $TOKEN_GITEA_FILE (utente $UTENTE)"
|
||||
if [ -n "$UTENTE" ] ; then
|
||||
ok "accesso Gitea salvato in $TOKEN_GITEA_FILE (utente $UTENTE)"
|
||||
else
|
||||
errore "Gitea ha creato l'accesso ma non lo riconosce: rilancia, e se si ripete avvisa l'amministratore."
|
||||
fi
|
||||
elif [ "$CODICE" = "403" ] ; then
|
||||
male "Gitea chiede prima di cambiare la password: entra su $GITEA_URL (Sign in), scegline una nuova, salvala su LastPass e rilancia."
|
||||
errore "Gitea chiede prima di cambiare la password: entra su $GITEA_URL (Sign in), scegline una nuova, salvala su LastPass e rilancia."
|
||||
elif [ "$CODICE" = "401" ] ; then
|
||||
male "utente o password sbagliati: rilancia e riprova."
|
||||
errore "utente o password sbagliati: rilancia e riprova."
|
||||
else
|
||||
male "Gitea non ha creato l'accesso (HTTP ${CODICE:-nessuna risposta}): rilancia, o chiedi all'amministratore."
|
||||
errore "Gitea non ha creato l'accesso (HTTP ${CODICE:-nessuna risposta}): rilancia, o chiedi all'amministratore."
|
||||
fi
|
||||
fi
|
||||
|
||||
# git: chi sei, e come si ricorda le credenziali. Il token vale anche come
|
||||
# password per git: lo si scrive una volta in ~/.git-credentials.
|
||||
# git: chi sei, e come entra su Gitea. Il token vale anche come password per
|
||||
# git, e lo tiene il gestore "store" (il file ~/.git-credentials) per il solo
|
||||
# indirizzo di Gitea: un gestore gia' configurato per tutto il resto (quello di
|
||||
# Windows o del Mac, per dire) non si tocca, ma per Gitea non viene interrogato,
|
||||
# cosi' non risponde con un accesso vecchio o con una finestra di login.
|
||||
if [ -n "$UTENTE" ] ; then
|
||||
[ -n "$(git config --global user.name)" ] || git config --global user.name "$UTENTE"
|
||||
if [ -z "$(git config --global user.email)" ] ; then
|
||||
read -r -p " La tua email di lavoro, quella @oto.agency (firma le tue modifiche al codice): " EMAIL
|
||||
[ -n "$EMAIL" ] && git config --global user.email "$EMAIL"
|
||||
fi
|
||||
[ -n "$(git config --global credential.helper)" ] || git config --global credential.helper store
|
||||
CREDENZIALI="$HOME/.git-credentials"
|
||||
if ! grep -q "@$GITEA_HOST" "$CREDENZIALI" 2> /dev/null ; then
|
||||
( umask 077 ; printf 'https://%s:%s@%s\n' "$UTENTE" "$(token_gitea)" "$GITEA_HOST" >> "$CREDENZIALI" )
|
||||
# La riga vuota azzera, per questo indirizzo, i gestori configurati prima.
|
||||
git config --global --unset-all "credential.$GITEA_URL.helper" 2> /dev/null
|
||||
git config --global --add "credential.$GITEA_URL.helper" ""
|
||||
git config --global --add "credential.$GITEA_URL.helper" store
|
||||
# Se git ha ancora il token di prima (rinnovato qui sopra, o revocato), la
|
||||
# credenziale si sostituisce: prima si aggiungeva solo se mancava, e restava
|
||||
# quella vecchia, con l'API che funzionava e git clone che no. Passa da git,
|
||||
# su stdin, e tocca la sola voce di Gitea.
|
||||
if [ "$(password_git_gitea)" != "$(token_gitea)" ] ; then
|
||||
printf 'protocol=https\nhost=%s\n\n' "$GITEA_HOST" | git credential reject
|
||||
printf 'protocol=https\nhost=%s\nusername=%s\npassword=%s\n\n' "$GITEA_HOST" "$UTENTE" "$(token_gitea)" \
|
||||
| git credential approve
|
||||
fi
|
||||
[ -f "$HOME/.git-credentials" ] && chmod 600 "$HOME/.git-credentials"
|
||||
if [ "$(password_git_gitea)" = "$(token_gitea)" ] ; then
|
||||
ok "git configurato ($(git config --global user.name) <$(git config --global user.email)>)"
|
||||
else
|
||||
errore "git non riesce a ricordare l'accesso a Gitea: avvisa l'amministratore, con il messaggio qui sopra."
|
||||
fi
|
||||
ok "git configurato ($(git config --global user.name) <$(git config --global user.email)>)"
|
||||
fi
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
@@ -103,11 +137,21 @@ titolo "2. AWS"
|
||||
# Viene dopo Gitea apposta: e' Gitea, con la password, a dire chi e' la
|
||||
# persona. Una chiave gia' presente sul PC non basta a dirlo: puo' essere
|
||||
# rimasta da chi lo usava prima, o copiata da un collega, e allora tutto
|
||||
# quello che la persona fa su AWS risulterebbe fatto da un altro.
|
||||
# quello che la persona fa su AWS risulterebbe fatto da un altro. Per questo
|
||||
# senza Gitea il passo si salta, invece di dare per buona una chiave qualsiasi.
|
||||
#
|
||||
# La chiave si scrive nel profilo "default" e si controlla con quello: se
|
||||
# AWS_PROFILE o le variabili AWS_ACCESS_KEY_ID... sono impostate, la AWS CLI
|
||||
# userebbe altro, e lo si dice.
|
||||
AWS_OPZ=(--profile default --cli-connect-timeout 10 --cli-read-timeout 15)
|
||||
identita_aws () {
|
||||
AWS_MAX_ATTEMPTS=1 aws sts get-caller-identity "${AWS_OPZ[@]}" --query Arn --output text 2> /dev/null
|
||||
}
|
||||
|
||||
chiedi_chiave_aws () {
|
||||
echo " Serve la tua chiave di accesso AWS, due pezzi: Access key ID e Secret access key."
|
||||
# Il nome della scheda e' quello per esteso: sara.locatelli -> Sara Locatelli.
|
||||
SCHEDA_AWS="AWS > $(printf '%s' "${UTENTE:-nome.cognome}" | awk -F. '{for (i = 1; i <= NF; i++) printf "%s%s", (i > 1 ? " " : ""), toupper(substr($i, 1, 1)) substr($i, 2)}')"
|
||||
SCHEDA_AWS="AWS > $(printf '%s' "$UTENTE" | awk -F. '{for (i = 1; i <= NF; i++) printf "%s%s", (i > 1 ? " " : ""), toupper(substr($i, 1, 1)) substr($i, 2)}')"
|
||||
echo " Non sono nella mail: li trovi su LastPass, nella scheda \"$SCHEDA_AWS\" che ti"
|
||||
echo " ha condiviso chi amministra, nel campo di testo (righe Access key ID e Secret"
|
||||
echo " access key). Se li' non c'e', la crei tu nella console AWS:"
|
||||
@@ -125,35 +169,63 @@ chiedi_chiave_aws () {
|
||||
CHIAVE_ID="$(printf '%s' "$CHIAVE_ID" | tr -d '[:space:]')"
|
||||
CHIAVE_SEGRETA="$(printf '%s' "$CHIAVE_SEGRETA" | tr -d '[:space:]')"
|
||||
if [ -z "$CHIAVE_ID" ] || [ -z "$CHIAVE_SEGRETA" ] ; then
|
||||
male "chiave non inserita: rilancia quando ce l'hai." ; unset CHIAVE_SEGRETA ; return 1
|
||||
errore "chiave non inserita: rilancia quando ce l'hai." ; unset CHIAVE_SEGRETA ; return 1
|
||||
fi
|
||||
aws configure set aws_access_key_id "$CHIAVE_ID"
|
||||
aws configure set aws_secret_access_key "$CHIAVE_SEGRETA"
|
||||
aws configure set region "$AWS_REGIONE"
|
||||
# Si prova PRIMA di salvarla, passandola per variabili d'ambiente (che non
|
||||
# si vedono con ps): una chiave sbagliata, o di un altro, non deve prendere
|
||||
# il posto di quella che c'era.
|
||||
local nuova
|
||||
nuova="$(env -u AWS_PROFILE -u AWS_SESSION_TOKEN -u AWS_SHARED_CREDENTIALS_FILE \
|
||||
AWS_ACCESS_KEY_ID="$CHIAVE_ID" AWS_SECRET_ACCESS_KEY="$CHIAVE_SEGRETA" AWS_MAX_ATTEMPTS=1 \
|
||||
aws sts get-caller-identity --cli-connect-timeout 10 --cli-read-timeout 15 --query Arn --output text 2> /dev/null)"
|
||||
if [ -z "$nuova" ] ; then
|
||||
unset CHIAVE_SEGRETA
|
||||
errore "AWS non accetta questa chiave: controlla di aver copiato i due pezzi interi, senza scambiarli, e rilancia. Non l'ho salvata."
|
||||
return 1
|
||||
fi
|
||||
if ! aws_e_di "$nuova" "$UTENTE" ; then
|
||||
unset CHIAVE_SEGRETA
|
||||
errore "questa chiave e' di ${nuova#arn:aws:iam::}, non tua ($UTENTE nell'account OTO $AWS_ACCOUNT): usa quella della tua scheda LastPass \"$SCHEDA_AWS\", e rilancia. Non l'ho salvata."
|
||||
return 1
|
||||
fi
|
||||
# aws configure set la vuole come argomento: per l'attimo in cui gira si
|
||||
# vede con ps. Non c'e' un'alternativa da stdin, e su un PC personale e'
|
||||
# un rischio accettato.
|
||||
aws configure set aws_access_key_id "$CHIAVE_ID" --profile default \
|
||||
&& aws configure set aws_secret_access_key "$CHIAVE_SEGRETA" --profile default \
|
||||
&& aws configure set region "$AWS_REGIONE" --profile default
|
||||
local esito=$?
|
||||
unset CHIAVE_SEGRETA
|
||||
if ! IDENTITA="$(aws sts get-caller-identity --query Arn --output text 2> /dev/null)" ; then
|
||||
male "AWS non accetta questa chiave: controlla di aver copiato i due pezzi interi, senza scambiarli, e rilancia."
|
||||
elif [ -n "$UTENTE" ] && [ "${IDENTITA##*/}" != "$UTENTE" ] ; then
|
||||
male "questa chiave e' di ${IDENTITA##*/}, non tua ($UTENTE): usa quella della tua scheda LastPass \"$SCHEDA_AWS\", e rilancia."
|
||||
else
|
||||
ok "accesso AWS: ${IDENTITA##*/}"
|
||||
[ -f "$HOME/.aws/credentials" ] && chmod 600 "$HOME/.aws/credentials"
|
||||
if [ "$esito" != "0" ] ; then
|
||||
errore "non riesco a salvare la chiave in ~/.aws/credentials: avvisa l'amministratore, con il messaggio qui sopra."
|
||||
return 1
|
||||
fi
|
||||
ok "accesso AWS: $UTENTE"
|
||||
}
|
||||
|
||||
if ! c_e aws ; then
|
||||
male "AWS CLI non installata: installala e rilancia questo script."
|
||||
elif IDENTITA="$(aws sts get-caller-identity --query Arn --output text 2> /dev/null)" ; then
|
||||
if [ -z "$UTENTE" ] || [ "${IDENTITA##*/}" = "$UTENTE" ] ; then
|
||||
ok "accesso AWS: ${IDENTITA##*/}"
|
||||
errore "AWS CLI non installata: installala e rilancia questo script."
|
||||
elif [ -z "$UTENTE" ] ; then
|
||||
errore "AWS saltato: prima deve funzionare Gitea (passo 1), che dice chi sei. Sistemato quello, rilancia."
|
||||
else
|
||||
CONFLITTI="$(aws_variabili_in_conflitto)"
|
||||
if [ -n "$CONFLITTI" ] ; then
|
||||
attento "nel terminale sono impostate $CONFLITTI: la AWS CLI usera' quelle e non la chiave salvata qui. Se non sai perche' ci sono, dillo all'amministratore."
|
||||
fi
|
||||
if IDENTITA="$(identita_aws)" && [ -n "$IDENTITA" ] ; then
|
||||
if aws_e_di "$IDENTITA" "$UTENTE" ; then
|
||||
ok "accesso AWS: $UTENTE"
|
||||
else
|
||||
attento "su questo PC c'e' gia' una chiave AWS, ma e' di ${IDENTITA#arn:aws:iam::}, non tua ($UTENTE)."
|
||||
echo " Usandola, tutto quello che fai su AWS risulterebbe fatto da un altro."
|
||||
echo " La sostituisco con la tua. Avvisa l'amministratore: quella chiave e' uscita"
|
||||
echo " dal PC del suo proprietario e va disattivata."
|
||||
chiedi_chiave_aws
|
||||
fi
|
||||
else
|
||||
attento "su questo PC c'e' gia' una chiave AWS, ma e' di ${IDENTITA##*/}, non tua ($UTENTE)."
|
||||
echo " Usandola, tutto quello che fai su AWS risulterebbe fatto da ${IDENTITA##*/}."
|
||||
echo " La sostituisco con la tua. Avvisa l'amministratore: quella chiave e' uscita"
|
||||
echo " dal PC di ${IDENTITA##*/} e va disattivata."
|
||||
chiedi_chiave_aws
|
||||
fi
|
||||
else
|
||||
chiedi_chiave_aws
|
||||
fi
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
@@ -164,26 +236,38 @@ if [ -f "$CHIAVE_SSH" ] ; then
|
||||
else
|
||||
mkdir -p "$HOME/.ssh" && chmod 700 "$HOME/.ssh"
|
||||
COMMENTO="${UTENTE:-$(whoami)}@oto"
|
||||
ssh-keygen -q -t ed25519 -f "$CHIAVE_SSH" -C "$COMMENTO" -N "" \
|
||||
&& ok "chiave creata: $CHIAVE_SSH"
|
||||
if ssh-keygen -q -t ed25519 -f "$CHIAVE_SSH" -C "$COMMENTO" -N "" ; then
|
||||
ok "chiave creata: $CHIAVE_SSH"
|
||||
else
|
||||
errore "non riesco a creare la chiave SSH: avvisa l'amministratore, con il messaggio qui sopra."
|
||||
fi
|
||||
fi
|
||||
# Gli script dei progetti la cercano con altri nomi (staging e produzione):
|
||||
# sono collegamenti a questa, non chiavi nuove. Un file che c'e' gia' con
|
||||
# quel nome e' una chiave tua di prima, e non si tocca.
|
||||
if [ -f "$CHIAVE_SSH" ] ; then
|
||||
for ALTRA in $CHIAVI_SSH_PROGETTI ; do
|
||||
[ -e "$ALTRA" ] && continue
|
||||
ln -s "$(basename "$CHIAVE_SSH")" "$ALTRA" 2> /dev/null || cp -p "$CHIAVE_SSH" "$ALTRA" \
|
||||
|| errore "non riesco a creare $ALTRA: i deploy dei progetti non troverebbero la chiave."
|
||||
done
|
||||
fi
|
||||
# La parte pubblica va sul proprio profilo Gitea: e' da li' che
|
||||
# l'amministratore la prende per metterla sui server, senza che la persona
|
||||
# debba mandarla a nessuno.
|
||||
if [ -f "$CHIAVE_SSH.pub" ] && [ -n "$UTENTE" ] ; then
|
||||
PUBBLICA="$(awk '{print $1" "$2}' "$CHIAVE_SSH.pub")"
|
||||
if curl -s --max-time 10 -H "Authorization: token $(token_gitea)" "$GITEA_URL/api/v1/user/keys" \
|
||||
| grep -qF "${PUBBLICA#* }" ; then
|
||||
CHIAVI="$(api_gitea /user/keys)"
|
||||
if [ "${CHIAVI##*$'\n'}" = "200" ] && printf '%s' "$CHIAVI" | grep -qF "${PUBBLICA#* }" ; then
|
||||
ok "chiave pubblica gia' sul tuo profilo Gitea"
|
||||
else
|
||||
CODICE="$(curl -s -o /dev/null --max-time 10 -w '%{http_code}' -X POST \
|
||||
-H "Authorization: token $(token_gitea)" -H 'Content-Type: application/json' \
|
||||
-d "{\"title\":\"oto $(hostname | tr -dc 'A-Za-z0-9-')\",\"key\":\"$PUBBLICA\"}" \
|
||||
"$GITEA_URL/api/v1/user/keys")"
|
||||
CODICE="$(api_gitea /user/keys -o /dev/null -X POST -H 'Content-Type: application/json' \
|
||||
-d "{\"title\":\"oto $(hostname | tr -dc 'A-Za-z0-9-')\",\"key\":\"$PUBBLICA\"}")"
|
||||
CODICE="${CODICE##*$'\n'}"
|
||||
if [ "$CODICE" = "201" ] ; then
|
||||
ok "chiave pubblica caricata sul tuo profilo Gitea: l'amministratore la prende da li'"
|
||||
else
|
||||
attento "non riesco a caricare la chiave su Gitea (HTTP $CODICE). Manda all'amministratore questa riga, e' la parte pubblica:"
|
||||
errore "non riesco a caricare la chiave su Gitea (HTTP $CODICE). Manda all'amministratore questa riga, e' la parte pubblica:"
|
||||
echo " $(cat "$CHIAVE_SSH.pub")"
|
||||
fi
|
||||
fi
|
||||
@@ -197,6 +281,7 @@ titolo "4. Nomi dei server in ~/.ssh/config"
|
||||
# un server basta rilanciare. Un nome gia' definito fuori dal blocco non si
|
||||
# tocca (e' una configurazione tua).
|
||||
CONFIG="$HOME/.ssh/config"
|
||||
mkdir -p "$HOME/.ssh" && chmod 700 "$HOME/.ssh"
|
||||
touch "$CONFIG" && chmod 600 "$CONFIG"
|
||||
INIZIO="# >>> OTO (scritto da _OTO_IT_onboard/configura.sh) >>>"
|
||||
FINE_BLOCCO="# <<< OTO <<<"
|
||||
@@ -225,9 +310,13 @@ Host $1
|
||||
done
|
||||
BLOCCO="$BLOCCO$FINE_BLOCCO"
|
||||
|
||||
{ printf '%s\n' "$FUORI" | sed -e :a -e '/^\n*$/{$d;N;ba' -e '}' ; echo ; printf '%s\n' "$BLOCCO" ; } > "$CONFIG.nuovo" \
|
||||
&& mv "$CONFIG.nuovo" "$CONFIG" && chmod 600 "$CONFIG"
|
||||
ok "ssh $STAGING_NOME, ssh $PRODUZIONE_NOME e ssh $PRODUZIONE_VECCHIA_NOME: configurati"
|
||||
if { printf '%s\n' "$FUORI" | sed -e :a -e '/^\n*$/{$d;N;ba' -e '}' ; echo ; printf '%s\n' "$BLOCCO" ; } > "$CONFIG.nuovo" \
|
||||
&& mv "$CONFIG.nuovo" "$CONFIG" && chmod 600 "$CONFIG" ; then
|
||||
ok "ssh $STAGING_NOME, ssh $PRODUZIONE_NOME e ssh $PRODUZIONE_VECCHIA_NOME: configurati"
|
||||
else
|
||||
rm -f "$CONFIG.nuovo"
|
||||
errore "non riesco a scrivere $CONFIG: i nomi dei server non sono configurati."
|
||||
fi
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
titolo "5. Chiavi dei server in ~/.ssh/known_hosts"
|
||||
@@ -237,16 +326,26 @@ titolo "5. Chiavi dei server in ~/.ssh/known_hosts"
|
||||
# e la risposta non dipende da chi e' in mezzo alla rete quel giorno. Quelle
|
||||
# che c'erano per gli stessi nomi si tolgono prima (ssh-keygen ne lascia una
|
||||
# copia in known_hosts.old): una vecchia rimasta li' farebbe dire a ssh che
|
||||
# il server e' cambiato.
|
||||
# il server e' cambiato. Quando un server cambia chiave davvero, la nuova si
|
||||
# legge sulla macchina e si scrive in server.known_hosts, in questo
|
||||
# repository: e' l'unico posto da cui la prendono i PC.
|
||||
NOTI="$HOME/.ssh/known_hosts"
|
||||
touch "$NOTI" && chmod 600 "$NOTI"
|
||||
for H in $(grep -v '^#' server.known_hosts | awk 'NF {print $1}' | sort -u) ; do
|
||||
ssh-keygen -R "$H" -f "$NOTI" > /dev/null 2>&1
|
||||
done
|
||||
grep -v '^#' server.known_hosts | awk 'NF' >> "$NOTI"
|
||||
ok "chiavi di $STAGING_NOME, $PRODUZIONE_NOME e $PRODUZIONE_VECCHIA_NOME registrate"
|
||||
if grep -v '^#' server.known_hosts | awk 'NF' >> "$NOTI" ; then
|
||||
ok "chiavi di $STAGING_NOME, $PRODUZIONE_NOME e $PRODUZIONE_VECCHIA_NOME registrate"
|
||||
else
|
||||
errore "non riesco a scrivere $NOTI: ssh chiedera' conferma al primo collegamento."
|
||||
fi
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
titolo "Fatto"
|
||||
# --------------------------------------------------------------------------
|
||||
echo " Ora: se su LastPass hai la scheda \"OTO > VPN HK ${UTENTE:-nome.cognome}\", accendi la VPN (file e credenziali sono li'); poi torna da Claude."
|
||||
if [ "$ERRORI" != "0" ] ; then
|
||||
if [ "$ERRORI" = "1" ] ; then male "una cosa non e' andata (sopra, in rosso): sistemala e rilancia ./configura.sh."
|
||||
else male "$ERRORI cose non sono andate (sopra, in rosso): sistemale e rilancia ./configura.sh." ; fi
|
||||
exit 1
|
||||
fi
|
||||
echo " Ora: se su LastPass hai la scheda \"OTO > VPN HK $UTENTE\", accendi la VPN (file e credenziali sono li'); poi torna da Claude."
|
||||
|
||||
Reference in New Issue
Block a user