Régénérez votre sitemap à partir de l’ensemble final des pages publiques à chaque publication, puis téléversez les deux ensemble. Ce processus sur Mac utilise un petit script Python pour inclure automatiquement les pages ajoutées et supprimer celles qui ont été retirées, avec des vérifications du résultat public.

Il s’agit ici de maintenir un sitemap pour un petit site web statique exporté depuis un Mac. L’exemple utilise des pages fictives sur les couleurs. Il suppose que votre processus de publication existant peut téléverser le dossier d’export et supprimer les fichiers obsolètes du site public.

Choisir où intégrer la régénération du sitemap

Vérifiez d’abord si votre système de publication génère déjà un sitemap. Google indique que de nombreux systèmes de gestion de contenu en fournissent un automatiquement. Si c’est le cas du vôtre, vérifiez comment ce sitemap réagit à l’ajout et au retrait d’une page de test avant d’introduire un autre générateur. En savoir plus sur les sitemaps.

Pour un export statique, suivez cette séquence : terminez l’export des pages, générez le sitemap à partir de cet export, puis publiez le dossier obtenu. Il s’agit d’un modèle de mise en œuvre proposé : il garantit que le sitemap décrit le même ensemble de pages que celui transmis au système de publication.

La génération au moment de la publication applique également une règle cohérente aux ajouts et aux retraits. Une page présente dans l’export final est incluse ; une page qui en est absente est omise. Il n’y a pas de liste séparée à penser à mettre à jour.

Choisissez l’intégration qui correspond à votre configuration actuelle :

Système de publication actuel Emplacement de la régénération
Un CMS gère déjà le sitemap Conservez ce générateur et testez sa réaction aux changements de pages
Un outil d’export statique permet d’exécuter une commande après l’export Exécutez le générateur à cet endroit, avant le téléversement
Une commande existante publie un dossier finalisé Exécutez-la à l’aide de l’argument de publication facultatif du générateur
Vous téléversez via une interface de bureau Générez d’abord le sitemap, puis téléversez le dossier complet ; la mise à jour publique sans intervention nécessite une intégration de publication compatible

Un script local ne peut pas modifier à lui seul un site web distant. Le processus ci-dessous automatise la génération du sitemap et peut lancer une commande de publication existante. Le téléversement proprement dit reste du ressort de votre outil de publication habituel.

Définir précisément les pages à inclure dans le sitemap

Pour les URL de pages ordinaires, Google accepte un sitemap texte contenant une URL complète par ligne. Le format XML est facultatif pour cette tâche. Incluez l’URL publique de référence de chaque page plutôt que plusieurs versions de l’URL pour un même contenu. Créer et envoyer un sitemap.

Le format texte exige un encodage UTF-8 et ne contient que des URL, sans titres ni commentaires. Un seul fichier peut contenir au maximum 50 000 URL et occuper 52 428 800 octets. Placez le sitemap de cet exemple à la racine du site afin qu’il couvre les pages exportées situées en dessous. Protocole Sitemaps : fichiers texte et emplacement.

Le générateur utilise une convention d’export volontairement simple :

Fichier exporté Exemple d’URL publique
public/index.html https://example.com/
public/colors/blue.html https://example.com/colors/blue.html
public/tiles/index.html https://example.com/tiles/

N’utilisez cette convention que si votre hébergeur sert ces URL exactes. Si votre système de publication transforme blue.html en /colors/blue/, ou sert le site sous un chemin tel que /collection/, utilisez sa liste de routes ou adaptez la correspondance avant la publication. L’analyse des noms de fichiers ne permet pas de déduire un routage personnalisé.

Ne conservez dans le dossier d’export que les pages destinées à y figurer. Cet exemple ignore les chemins commençant par un point et les fichiers nommés 404.html ; il n’inspecte pas les métadonnées des pages, les déclarations canoniques ni les règles de redirection. Pour les sites qui comportent ces conditions supplémentaires, générez le sitemap à partir de l’inventaire des pages admissibles fourni par votre système de publication.

Continuez également à maintenir les liens de navigation habituels. Le WHATWG définit les hyperliens créés par les éléments a dotés d’un attribut href, et Google explique que les pages correctement reliées entre elles peuvent généralement être découvertes grâce à la navigation. La mise à jour d’un sitemap doit s’accompagner de la mise à jour des liens pointant vers les pages ajoutées ou retirées. Norme HTML du WHATWG : liens, En savoir plus sur les sitemaps.

Créer le générateur sur votre Mac

Vous avez besoin de Python 3.8 ou d’une version ultérieure et d’un éditeur de texte brut. Dans Terminal, exécutez python3 --version pour vérifier l’interpréteur dont vous disposez. Si vous avez besoin de Python, suivez les instructions d’installation sur macOS de la Python Software Foundation. Sa documentation explique également comment exécuter des scripts avec python3 depuis Terminal. Utiliser Python sur macOS.

Créez sur votre bureau un dossier nommé sitemap-demo. Enregistrez-y le programme complet suivant sous le nom regenerate_sitemap.py. Le programme utilise la bibliothèque standard de Python et ne nécessite aucun paquet supplémentaire.

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()

À chaque exécution, le programme reconstruit la liste complète des URL. Il trie et déduplique le résultat, encode les caractères tels que les espaces dans les chemins et écrit un fichier temporaire avant de remplacer sitemap.txt. Les erreurs de génération interrompent le programme avant l’exécution de la commande de publication facultative.

Un export vide provoque délibérément une erreur et laisse le sitemap précédent intact. Cela permet de détecter la sélection accidentelle d’un mauvais dossier ou d’un dossier incomplet. La suppression intentionnelle de toutes les pages nécessite une décision de publication distincte plutôt que de transmettre un export vide à ce processus.

Tester un ajout et un retrait avant de connecter la publication

Dans Terminal, accédez à votre dossier de démonstration :

cd "$HOME/Desktop/sitemap-demo"

Créez deux pages fictives à l’aide de cette commande de configuration complète. Utilisez-la dans le nouveau dossier de démonstration ; elle crée les deux fichiers d’exemple nommés.

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

Générez le sitemap local et examinez-le. L’origine de l’exemple est illustrative ; ces commandes ne publient rien à cette adresse.

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

Le fichier attendu contient exactement ces deux lignes :

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

Remplacez maintenant la page bleue fictive par une page verte :

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

Le résultat attendu est l’URL d’accueil, suivie de https://example.com/colors/green.html. L’URL bleue disparaît puisque son fichier exporté n’existe plus. Cela vérifie les deux sens de la mise à jour sans dépendre d’un moteur de recherche pour détecter le changement.

Intégrer la régénération à chaque publication

Pour votre véritable site, remplacez le dossier et l’origine de démonstration par le dossier d’export final et l’origine publique de votre site. N’exécutez le générateur qu’une fois l’export terminé, et ne modifiez pas ce dossier avant la fin de la publication. Exécutez les publications l’une après l’autre.

Si vous avez déjà dans le dossier du projet un script de publication fonctionnel nommé deploy-site.sh, la commande d’intégration suivante génère le sitemap, puis exécute ce script. Cet exemple nécessite le script existant ; le générateur ne le crée pas et ne fournit pas de configuration d’hébergement.

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

Votre script de publication doit téléverser le même dossier public, y compris sitemap.txt, et supprimer les fichiers publics qui ont disparu de l’export. Il ne doit pas reconstruire les pages après la génération du sitemap. Si votre système de publication construit également le site, placez la génération entre ses étapes de construction et de téléversement.

En cas d’échec de la génération, la commande de publication n’est pas exécutée. En cas d’échec de la publication, Python signale l’erreur, mais le site distant peut déjà avoir été partiellement modifié. Vérifiez le résultat public avant de réessayer. Si votre hébergeur permet de publier une version complète en une seule fois, utilisez le mécanisme documenté à cet effet.

Avec un outil de téléversement de bureau, générez le sitemap avant de sélectionner le dossier d’export à téléverser. Vérifiez que l’outil remplace le sitemap existant et gère les pages retirées. L’action de téléversement reste nécessaire : la génération locale automatique ne permet pas à elle seule une publication publique sans intervention.

Vérifier séparément le sitemap public et la page retirée

Après une publication réussie, ouvrez dans un navigateur l’URL publique réelle de votre sitemap.txt. Vérifiez que la page ajoutée apparaît et que la page retirée n’y figure pas. Accédez ensuite directement à chacune des pages concernées. Cela permet de distinguer un export local correct d’une publication publique correcte.

La suppression d’une entrée du sitemap ne détermine pas la réponse HTTP à l’ancienne adresse de cette page. Pour une page retirée qui n’a pas de remplacement, vérifiez que l’hébergeur renvoie une réponse appropriée indiquant que la page est introuvable. La RFC 9110 définit le code 404 pour une ressource sans représentation actuelle et le code 410 lorsque son indisponibilité est connue comme probablement permanente. RFC 9110 : sémantique HTTP.

Une page qui affiche un message indiquant qu’elle est introuvable tout en renvoyant 200 peut être considérée comme une erreur 404 déguisée. Google indique également que les URL précédemment indexées qui renvoient des réponses 4xx pertinentes sont retirées de son index au fil du temps. La suppression de l’URL du sitemap n’est donc qu’une étape du retrait de la page. Incidence des codes d’état HTTP sur les robots d’exploration de Google.

Si quelque chose semble incorrect, suivez cette séquence de diagnostic :

Observation Vérification suivante
Le sitemap local répertorie toujours une page retirée Recherchez un fichier d’export restant ou un mauvais dossier d’export
Le sitemap local est correct, mais sa copie publique diffère Vérifiez le dossier téléversé, sa destination et la mise en cache
Le sitemap public est correct, mais la page retirée s’ouvre toujours Vérifiez si la publication a supprimé l’ancien fichier distant
Une URL générée ouvre la mauvaise page Vérifiez que le routage de l’hébergeur correspond à la convention de nommage des fichiers
Une nouvelle URL est publique, mais absente des résultats de recherche Considérez la découverte et l’indexation par les moteurs de recherche comme un processus distinct

La mise en cache peut expliquer pourquoi le sitemap public semble inchangé. La RFC 9111 définit la manière dont les réponses mises en cache restent fraîches et sont revalidées. Si votre hébergeur permet de configurer les en-têtes de réponse, Cache-Control: no-cache exige une validation réussie avant la réutilisation d’une réponse stockée ; modifier un fichier local ne configure pas cet en-tête. RFC 9111 : mise en cache HTTP.

Conserver une adresse de sitemap stable

Rendez le sitemap public accessible en envoyant son URL stable via le rapport Sitemaps de la Search Console ou en la référençant dans le fichier robots.txt existant du site. Google décrit ces deux méthodes et précise que l’envoi constitue une indication. Créer et envoyer un sitemap.

Pour le site illustratif, la ligne de découverte serait :

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

Conservez une adresse de sitemap stable en remplaçant son contenu lors de la publication. Pour vérifier que tout est terminé, assurez-vous que le sitemap public correspond à l’export final, que la page ajoutée s’ouvre à l’URL indiquée et que la page retirée renvoie la réponse prévue. Les moteurs de recherche traitent ces changements selon leur propre calendrier ; la présence dans le sitemap ne garantit ni l’exploration ni l’indexation. En savoir plus sur les sitemaps.

Sources