Rigenera la sitemap a partire dall’insieme definitivo delle pagine pubbliche ogni volta che pubblichi, poi carica entrambi insieme. Questo flusso di lavoro su Mac usa un piccolo script Python per includere automaticamente le pagine aggiunte e rimuovere quelle eliminate, con verifiche del risultato pubblico.

Qui il compito consiste nel mantenere una sitemap per un piccolo sito web statico esportato da un Mac. L’esempio usa pagine fittizie sui colori. Presuppone che il processo di pubblicazione esistente possa caricare la cartella esportata e rimuovere dal sito pubblico i file obsoleti.

Scegliere dove inserire la rigenerazione della sitemap

Per prima cosa, verifica se il sistema di pubblicazione genera già una sitemap. Google segnala che molti sistemi di gestione dei contenuti ne forniscono una automaticamente. Se il tuo sistema lo fa, dopo aver aggiunto e rimosso una pagina di prova controlla la sitemap prima di introdurre un altro generatore. Informazioni sulle sitemap.

Per un’esportazione statica, segui questa sequenza: termina l’esportazione delle pagine, genera la sitemap a partire dall’esportazione e pubblica la cartella risultante. Questo è uno schema di implementazione proposto: fa sì che la sitemap descriva lo stesso insieme di pagine ricevuto dal sistema di pubblicazione.

Generare la sitemap durante la pubblicazione fornisce anche una regola coerente per aggiunte e rimozioni. Una pagina presente nell’esportazione completata viene inclusa; una pagina che non vi è presente viene omessa. Non c’è un elenco separato da ricordarsi di aggiornare.

Scegli l’integrazione adatta alla configurazione esistente:

Configurazione di pubblicazione esistente Dove inserire la rigenerazione
Un CMS gestisce già la sitemap Mantieni quel generatore e verifica come reagisce alle modifiche delle pagine
Un esportatore statico supporta un comando dopo l’esportazione Esegui lì il generatore, prima del caricamento
Un comando esistente pubblica una cartella completata Eseguilo tramite l’argomento di pubblicazione opzionale del generatore
Carichi i file tramite un’interfaccia desktop Genera prima la sitemap, poi carica l’intera cartella; per aggiornare il sito pubblico senza intervento manuale serve un’integrazione di pubblicazione supportata

Uno script locale non può modificare da solo un sito web remoto. Il flusso di lavoro seguente automatizza la generazione della sitemap e può avviare un comando di pubblicazione esistente. Il caricamento vero e proprio resta a carico del sistema di pubblicazione già in uso.

Definire esattamente quali pagine includere nella sitemap

Per i normali URL di pagina, Google accetta una sitemap di testo che contiene un URL completo per riga. Per questo compito il formato XML è facoltativo. Includi l’URL pubblico preferito per ogni pagina, anziché più versioni dello stesso URL per gli stessi contenuti. Creare e inviare una sitemap.

Il formato di testo richiede la codifica UTF-8 e contiene solo URL, senza intestazioni né commenti. Un singolo file può contenere al massimo 50.000 URL e 52.428.800 byte. Colloca la sitemap di questo esempio nella radice del sito, così da includere le pagine esportate nelle sottocartelle di quel percorso. Protocollo Sitemap: file di testo e posizione.

Il generatore usa una convenzione di esportazione volutamente semplice:

File esportato URL pubblico esemplificativo
public/index.html https://example.com/
public/colors/blue.html https://example.com/colors/blue.html
public/tiles/index.html https://example.com/tiles/

Usa questa convenzione solo se il tuo host pubblica proprio quegli URL. Se il sistema di pubblicazione trasforma blue.html in /colors/blue/ o pubblica il sito sotto un percorso come /collection/, usa l’elenco delle route oppure adatta la mappatura prima di pubblicare. Una scansione dei nomi dei file non può dedurre le route personalizzate.

Mantieni nella cartella di esportazione solo le pagine che devono essere incluse. Questo esempio esclude i percorsi che iniziano con un punto e i file chiamati 404.html; non esamina i metadati delle pagine, le dichiarazioni canonical né le regole di reindirizzamento. Per i siti con queste condizioni aggiuntive, genera la sitemap a partire dall’elenco delle pagine idonee fornito dal sistema di pubblicazione.

Continua anche a mantenere aggiornati i normali link di navigazione. WHATWG definisce i collegamenti ipertestuali creati dagli elementi a con un attributo href, mentre Google spiega che di solito le pagine collegate correttamente possono essere individuate tramite la navigazione. L’aggiornamento della sitemap dovrebbe accompagnare l’aggiornamento dei link che puntano alle pagine aggiunte o rimosse. Standard HTML WHATWG: link, Informazioni sulle sitemap.

Creare il generatore sul Mac

Servono Python 3.8 o versioni successive e un editor di testo semplice. In Terminale, esegui python3 --version per controllare l’interprete disponibile. Se ti serve Python, segui le istruzioni di installazione per macOS della Python Software Foundation. La documentazione spiega anche come eseguire script con python3 da Terminale. Usare Python su macOS.

Crea sulla Scrivania una cartella chiamata sitemap-demo. Al suo interno, salva il programma completo riportato di seguito con il nome regenerate_sitemap.py. Il programma usa la libreria standard di Python e non richiede pacchetti aggiuntivi.

import argparse
from pathlib import Path, PurePosixPath
import subprocess
import tempfile
from urllib.parse import quote, urlsplit


def make_sitemap(paths, origin):
    parsed = urlsplit(origin)
    if (parsed.scheme not in ("http", "https") or not parsed.hostname
            or parsed.netloc != parsed.hostname
            or parsed.path not in ("", "/")
            or parsed.query or parsed.fragment):
        raise ValueError("Use a site origin, such as https://example.com")
    base = origin.rstrip("/")
    urls = set()
    for relative in paths:
        path = PurePosixPath(relative)
        if path.name == "index.html":
            parent = path.parent.as_posix()
            route = "" if parent == "." else parent + "/"
        else:
            route = path.as_posix()
        urls.add(base + "/" + quote(route, safe="/"))
    if not urls:
        raise ValueError("No eligible pages; sitemap was not replaced")
    if len(urls) > 50000:
        raise ValueError("Split the sitemap: more than 50,000 URLs")
    data = ("\n".join(sorted(urls)) + "\n").encode("utf-8")
    if len(data) > 50 * 1024 * 1024:
        raise ValueError("Split the sitemap: larger than 50 MB")
    return data


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("folder")
    parser.add_argument("origin")
    parser.add_argument("publish", nargs=argparse.REMAINDER)
    args = parser.parse_args()
    root = Path(args.folder).resolve()
    if not root.is_dir():
        parser.error("The export folder must already exist")
    paths = []
    for file in root.rglob("*.html"):
        relative = file.relative_to(root)
        if (file.is_file() and file.name != "404.html"
                and not any(p.startswith(".") for p in relative.parts)):
            paths.append(relative.as_posix())
    data = make_sitemap(paths, args.origin)
    target = root / "sitemap.txt"
    temporary = None
    try:
        with tempfile.NamedTemporaryFile(dir=root, delete=False) as handle:
            temporary = Path(handle.name)
            handle.write(data)
        temporary.replace(target)
    finally:
        if temporary is not None:
            temporary.unlink(missing_ok=True)
    print(f"Wrote {len(data.splitlines())} URLs to {target}", flush=True)
    if args.publish:
        subprocess.run(args.publish, check=True)


if __name__ == "__main__":
    main()

A ogni esecuzione, l’intero elenco di URL viene ricostruito. Il risultato viene ordinato e deduplicato, i caratteri nei percorsi, come gli spazi, vengono codificati e viene scritto un file temporaneo prima di sostituire sitemap.txt. Gli errori di generazione interrompono il programma prima dell’esecuzione dell’eventuale comando di pubblicazione.

Un’esportazione vuota genera intenzionalmente un errore e lascia intatta la sitemap precedente. In questo modo viene rilevata un’eventuale selezione accidentale della cartella o un’esportazione incompleta. Per rimuovere intenzionalmente tutte le pagine serve una decisione di pubblicazione separata, anziché passare un’esportazione vuota attraverso questo flusso di lavoro.

Provare un’aggiunta e una rimozione prima di collegare la pubblicazione

In Terminale, entra nella cartella dimostrativa:

cd "$HOME/Desktop/sitemap-demo"

Crea due pagine fittizie con il seguente comando completo di configurazione. Usalo nella nuova cartella dimostrativa; scrive i due file di esempio specificati.

python3 - <<'PY'
from pathlib import Path

root = Path("public")
(root / "colors").mkdir(parents=True, exist_ok=True)
pages = {
    "index.html": "<!doctype html><title>Color collection</title><p>Color collection.</p>",
    "colors/blue.html": "<!doctype html><title>Blue tile</title><p>A blue tile.</p>",
}
for name, content in pages.items():
    (root / name).write_text(content, encoding="utf-8")
PY

Genera e controlla la sitemap locale. Il dominio di esempio è illustrativo; questi comandi non pubblicano nulla su di esso.

python3 regenerate_sitemap.py public https://example.com
cat public/sitemap.txt

Il file atteso contiene esattamente queste due righe:

https://example.com/
https://example.com/colors/blue.html

Ora sostituisci la pagina fittizia blu con una pagina verde:

python3 - <<'PY'
from pathlib import Path

root = Path("public")
(root / "colors/blue.html").unlink()
(root / "colors/green.html").write_text(
    "<!doctype html><title>Green tile</title><p>A green tile.</p>",
    encoding="utf-8",
)
PY
python3 regenerate_sitemap.py public https://example.com
cat public/sitemap.txt

Il risultato atteso è l’URL della home page seguito da https://example.com/colors/green.html. L’URL blu scompare perché il relativo file esportato non esiste più. In questo modo si verificano entrambi i tipi di modifica senza dover attendere che un motore di ricerca se ne accorga.

Integrare la rigenerazione in ogni pubblicazione

Per il sito effettivo, sostituisci la cartella dimostrativa e il dominio con la cartella dell’esportazione completata e il dominio pubblico reali. Esegui il generatore solo al termine dell’esportazione e non modificare la cartella finché la pubblicazione non è terminata. Esegui le pubblicazioni una alla volta.

Se nella cartella del progetto hai già uno script di pubblicazione funzionante chiamato deploy-site.sh, il seguente comando di integrazione genera la sitemap e poi esegue lo script. Questo esempio presuppone che lo script esistente sia già presente; il generatore non lo crea né fornisce la configurazione di hosting.

python3 regenerate_sitemap.py public https://example.com sh ./deploy-site.sh

Lo script di pubblicazione deve caricare la stessa cartella public, compreso sitemap.txt, e rimuovere i file pubblici che non sono più presenti nell’esportazione. Non deve ricostruire le pagine dopo la generazione della sitemap. Se il sistema di pubblicazione crea anche il sito, inserisci la generazione tra la fase di compilazione e quella di caricamento.

Se la generazione fallisce, il comando di pubblicazione non viene eseguito. Se la pubblicazione fallisce, Python segnala l’errore, ma il sito remoto potrebbe essere già stato modificato in parte. Controlla il risultato pubblico prima di riprovare. Se l’host supporta la pubblicazione di un’intera versione in un’unica operazione, usa il meccanismo documentato.

Con un programma di caricamento desktop, genera la sitemap prima di selezionare la cartella di esportazione da caricare. Verifica che il programma sostituisca la sitemap esistente e gestisca le pagine rimosse. Questa procedura richiede comunque l’azione di caricamento: la generazione locale automatica da sola non permette di pubblicare sul sito pubblico senza intervento manuale.

Verificare separatamente la sitemap pubblica e la pagina rimossa

Dopo aver completato la pubblicazione, apri nel browser il vero URL pubblico di sitemap.txt. Controlla che la pagina aggiunta sia presente e che quella rimossa non lo sia. Poi visita direttamente ciascuna pagina interessata. Questo permette di distinguere un’esportazione locale corretta da una pubblicazione corretta.

Eliminare una voce dalla sitemap non determina la risposta HTTP all’indirizzo precedente della pagina. Per una pagina rimossa senza sostituto, verifica che l’host restituisca una risposta appropriata per una pagina non trovata. La RFC 9110 definisce 404 per una risorsa senza una rappresentazione corrente e 410 quando è probabile che l’indisponibilità sia permanente. RFC 9110: semantica HTTP.

Una pagina che mostra un messaggio di pagina non trovata ma restituisce 200 può essere considerata un 404 soft. Google documenta inoltre che gli URL precedentemente indicizzati che restituiscono risposte 4xx pertinenti vengono rimossi dal suo indice nel tempo. Rimuovere l’URL dalla sitemap è quindi solo una parte del processo di rimozione della pagina. In che modo i codici di stato HTTP influiscono sui crawler di Google.

Se qualcosa non sembra corretto, usa questa sequenza diagnostica:

Osservazione Controllo successivo
La sitemap locale elenca ancora una pagina rimossa Cerca un file di esportazione residuo o verifica di aver scelto la cartella di esportazione corretta
La sitemap locale è corretta, ma la copia pubblica è diversa Controlla la cartella caricata, la destinazione e la cache
La sitemap pubblica è corretta, ma la pagina rimossa si apre ancora Controlla se la pubblicazione ha rimosso il vecchio file remoto
Un URL generato apre la pagina sbagliata Confronta la mappatura delle route dell’host con la convenzione dei nomi dei file
Un nuovo URL è pubblico ma non compare nei risultati di ricerca Considera la scoperta e l’indicizzazione da parte dei motori di ricerca come processi separati

La cache può spiegare perché la sitemap pubblica sembri invariata. La RFC 9111 definisce come le risposte memorizzate nella cache rimangano aggiornate e vengano convalidate di nuovo. Se il tuo host consente di configurare le intestazioni di risposta, Cache-Control: no-cache richiede una convalida riuscita prima che una risposta memorizzata venga riutilizzata; modificare solo un file locale non configura quell’intestazione. RFC 9111: HTTP Caching.

Mantenere stabile un unico indirizzo per la sitemap

Rendi la sitemap pubblica individuabile inviando il suo URL stabile tramite il rapporto Sitemaps di Search Console oppure indicandolo nel file robots.txt già presente sul sito. Google descrive entrambi i metodi e precisa che l’invio è un suggerimento. Creare e inviare una sitemap.

Per il sito illustrativo, la riga di indicazione sarebbe:

Sitemap: https://example.com/sitemap.txt

Mantieni stabile l’indirizzo della sitemap sostituendone i contenuti durante la pubblicazione. La verifica pratica finale consiste nell’accertarsi che la sitemap pubblica corrisponda all’esportazione completata, che la pagina aggiunta si apra all’URL indicato e che la pagina rimossa restituisca la risposta prevista. I motori di ricerca elaborano queste modifiche secondo i propri tempi; l’inclusione nella sitemap non garantisce la scansione né l’indicizzazione. Informazioni sulle sitemap.

Fonti