Regenere seu sitemap a partir do conjunto final de páginas públicas sempre que publicar e, em seguida, envie ambos juntos. Este fluxo de trabalho no Mac usa um pequeno script Python para incluir automaticamente as páginas adicionadas e remover as excluídas, com verificações do resultado público.

A tarefa aqui é manter um sitemap para um pequeno site estático exportado de um Mac. O exemplo usa páginas fictícias sobre cores. Ele pressupõe que seu processo de publicação existente pode enviar a pasta de exportação e remover arquivos obsoletos do site público.

Escolha onde a regeneração do sitemap deve ocorrer

Primeiro, verifique se o sistema de publicação já gera um sitemap. O Google observa que muitos sistemas de gerenciamento de conteúdo fornecem um automaticamente. Se o seu fizer isso, confira o sitemap depois de adicionar e remover uma página de teste, antes de introduzir outro gerador. Saiba mais sobre sitemaps.

Para uma exportação estática, use esta sequência: conclua a exportação das páginas, gere o sitemap a partir dessa exportação e publique a pasta resultante. Este é um padrão de implementação proposto: ele faz com que o sitemap descreva o mesmo conjunto de páginas recebido pelo sistema de publicação.

Gerar o sitemap durante a publicação também aplica uma regra consistente às inclusões e exclusões. Uma página presente na exportação final é incluída; uma página ausente dela é omitida. Não há uma lista separada que você precise lembrar de atualizar.

Escolha a integração que corresponde à sua configuração existente:

Configuração de publicação existente Onde a regeneração deve ocorrer
Um CMS já mantém o sitemap Mantenha esse gerador e teste como ele reage às alterações nas páginas
Um exportador estático aceita um comando após a exportação Execute o gerador nesse ponto, antes do envio
Um comando existente publica uma pasta finalizada Execute-o por meio do argumento opcional de publicação do gerador
Você faz o envio por uma interface de desktop Gere primeiro e, em seguida, envie a pasta completa; a atualização pública sem intervenção exige uma integração de publicação compatível

Um script local não pode alterar um site remoto por conta própria. O fluxo de trabalho abaixo automatiza a geração do sitemap e pode iniciar um comando de publicação existente. O envio propriamente dito continua sendo responsabilidade do sistema de publicação que você já usa.

Defina exatamente quais páginas pertencem ao sitemap

Para URLs de páginas comuns, o Google aceita um sitemap de texto com uma URL completa por linha. O XML é opcional para esta tarefa. Inclua a URL pública preferencial de cada página, em vez de várias versões da URL para o mesmo conteúdo. Crie e envie um sitemap.

O formato de texto exige codificação UTF-8 e contém apenas URLs, sem títulos ou comentários. Um único arquivo pode conter no máximo 50.000 URLs e 52.428.800 bytes. Coloque o sitemap deste exemplo na raiz do site para que ele abranja as páginas exportadas abaixo desse local. Protocolo Sitemaps: arquivos de texto e localização.

O gerador usa uma convenção de exportação deliberadamente simples:

Arquivo exportado URL pública ilustrativa
public/index.html https://example.com/
public/colors/blue.html https://example.com/colors/blue.html
public/tiles/index.html https://example.com/tiles/

Use esta convenção somente se seu host servir exatamente essas URLs. Se o sistema de publicação transformar blue.html em /colors/blue/ ou servir o site em um caminho como /collection/, use a lista de rotas dele ou adapte o mapeamento antes da publicação. A varredura dos nomes dos arquivos não consegue inferir roteamentos personalizados.

Mantenha na pasta de exportação apenas as páginas que devem ser incluídas. Este exemplo ignora caminhos iniciados por ponto e arquivos chamados 404.html; ele não inspeciona metadados das páginas, declarações canônicas nem regras de redirecionamento. Sites com essas condições adicionais devem gerar o sitemap com base no inventário de páginas elegíveis do sistema de publicação.

Continue mantendo também os links de navegação normais. O WHATWG define hiperlinks criados por elementos a com um atributo href, e o Google explica que páginas com links apropriados geralmente podem ser descobertas por meio da navegação. A atualização do sitemap deve acompanhar a atualização dos links que apontam para páginas adicionadas ou removidas. Padrão HTML do WHATWG: links, Saiba mais sobre sitemaps.

Crie o gerador no seu Mac

Você precisa do Python 3.8 ou posterior e de um editor de texto simples. No Terminal, execute python3 --version para verificar o interpretador disponível. Se precisar do Python, siga as instruções de instalação no macOS da Python Software Foundation. A documentação também explica como executar scripts com python3 pelo Terminal. Usar Python no macOS.

Crie uma pasta chamada sitemap-demo na Mesa. Salve nela o programa completo a seguir com o nome regenerate_sitemap.py. O programa usa a biblioteca padrão do Python e não exige pacotes adicionais.

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

Cada execução reconstrói a lista completa de URLs. O programa ordena e elimina duplicatas, codifica caracteres como espaços nos caminhos e grava um arquivo temporário antes de substituir sitemap.txt. Erros de geração interrompem o programa antes da execução do comando opcional de publicação.

Uma exportação vazia gera deliberadamente um erro e deixa o sitemap anterior intacto. Isso detecta uma pasta selecionada por engano ou incompleta. Remover intencionalmente todas as páginas exige uma decisão de publicação separada, em vez de passar uma exportação vazia por este fluxo de trabalho.

Teste uma inclusão e uma remoção antes de conectar a publicação

No Terminal, acesse sua pasta de demonstração:

cd "$HOME/Desktop/sitemap-demo"

Crie duas páginas fictícias com este comando de configuração completo. Use-o na nova pasta de demonstração; ele grava os dois arquivos de exemplo indicados.

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

Gere e inspecione o sitemap local. O domínio do exemplo é ilustrativo; esses comandos não publicam nada nele.

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

O arquivo esperado contém exatamente estas duas linhas:

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

Agora substitua a página fictícia azul por uma página 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

O resultado esperado é a URL inicial, seguida de https://example.com/colors/green.html. A URL azul desaparece porque o arquivo exportado correspondente foi removido. Isso verifica as duas direções da atualização sem depender de um mecanismo de busca para perceber a mudança.

Inclua a regeneração em cada publicação

Para seu site real, substitua a pasta e o domínio da demonstração pela pasta da exportação final e pelo domínio público reais. Execute o gerador somente após a conclusão da exportação e mantenha essa pasta inalterada até o fim da publicação. Execute as publicações em sequência.

Se você já tiver um script de publicação funcional chamado deploy-site.sh na pasta do projeto, o comando de integração a seguir gera o sitemap e depois executa esse script. Este exemplo exige o script existente; o gerador não o cria nem fornece a configuração de hospedagem.

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

Seu script de publicação deve enviar a mesma pasta public, incluindo sitemap.txt, e remover os arquivos públicos que desapareceram da exportação. Ele não deve reconstruir as páginas depois da geração do sitemap. Se o sistema de publicação também compilar o site, insira a geração entre as etapas de compilação e envio.

Se a geração falhar, o comando de publicação será ignorado. Se a publicação falhar, o Python informará a falha, mas o site remoto talvez já tenha sido alterado parcialmente. Confira o resultado público antes de tentar novamente. Se seu host permitir publicar uma versão completa de uma só vez, use o mecanismo documentado para isso.

Para um programa de envio por desktop, gere o sitemap antes de selecionar a pasta de exportação para envio. Confirme que o programa substitui o sitemap existente e trata as páginas removidas. Ainda será necessário iniciar o envio; a geração local automática, por si só, não permite publicação pública sem intervenção.

Verifique separadamente o sitemap público e a página removida

Após uma publicação bem-sucedida, abra no navegador a URL pública real de sitemap.txt. Confira se a página adicionada aparece e a removida não. Em seguida, acesse diretamente cada página afetada. Isso permite distinguir uma exportação local correta de uma publicação pública correta.

Excluir uma entrada do sitemap não determina a resposta HTTP no endereço antigo da página. Para uma página removida sem substituta, confira se o host retorna uma resposta adequada de página inexistente. A RFC 9110 define 404 para um recurso sem representação atual e 410 quando se sabe que sua indisponibilidade provavelmente é permanente. RFC 9110: semântica do HTTP.

Uma página que exibe uma mensagem de página inexistente, mas retorna 200, pode ser tratada como um 404 falso. O Google também documenta que URLs já indexadas que retornam respostas 4xx aplicáveis são removidas do índice ao longo do tempo. Portanto, remover a URL do sitemap é apenas uma parte da remoção da página. Como os códigos de status HTTP afetam os rastreadores do Google.

Use esta sequência de diagnóstico quando algo parecer errado:

Observação Próxima verificação
O sitemap local ainda lista uma página removida Procure um arquivo de exportação que sobrou ou a pasta de exportação errada
O sitemap local está correto, mas a cópia pública está diferente Verifique a pasta enviada, o destino e o cache
O sitemap público está correto, mas a página removida ainda abre Verifique se a publicação removeu o arquivo remoto antigo
Uma URL gerada abre a página errada Compare o mapeamento de rotas do host com a convenção dos nomes de arquivo
Uma URL nova está pública, mas não aparece nas buscas Considere a descoberta e a indexação pelos mecanismos de busca como processos separados

O cache pode explicar por que o sitemap público ainda parece inalterado. A RFC 9111 define como respostas armazenadas em cache permanecem atualizadas e são revalidadas. Se seu host permitir configurar cabeçalhos de resposta, Cache-Control: no-cache exige uma validação bem-sucedida antes que uma resposta armazenada seja reutilizada; alterar apenas um arquivo local não configura esse cabeçalho. RFC 9111: armazenamento em cache HTTP.

Mantenha um único endereço estável para o sitemap

Torne o sitemap público fácil de encontrar enviando sua URL estável pelo relatório Sitemaps do Search Console ou referenciando-o no arquivo robots.txt existente do site. O Google descreve os dois métodos e observa que o envio é uma sugestão. Crie e envie um sitemap.

Para o site ilustrativo, a linha de descoberta seria:

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

Mantenha o endereço do sitemap estável enquanto substitui seu conteúdo durante a publicação. A verificação prática de conclusão é confirmar que o sitemap público corresponde à exportação final, que a página adicionada abre na URL indicada e que a página removida apresenta a resposta desejada. Os mecanismos de busca processam essas alterações conforme seus próprios prazos; a inclusão no sitemap não garante rastreamento nem indexação. Saiba mais sobre sitemaps.

Fontes