Come servire in modo efficiente enormi sitemap in django

Question

Ho un sito con circa 150K pagine nella sua sitemap. Sto usando il generatore di indici Sitemap per creare le Sitemap, ma in realtà, ho bisogno di un modo per memorizzarlo nella cache, perché costruire le 150 Sitemap di 1.000 link ciascuna è brutale sul mio server. [1]

HO POTUTO memorizzare nella cache ciascuna di queste pagine Sitemap con memcached, che è quello che sto usando altrove sul sito ... tuttavia, questo è così tante sitemap che riempirebbe completamente memcached .... in modo che doesn ' lavoro.

Quello che penso di cui ho bisogno è un modo di usare il database come cache per questi e di generarli solo quando ci sono cambiamenti (che come risultato dell'indice sitemap significa solo cambiare l'ultima coppia di sitemap pagine, dato che il resto è sempre lo stesso.) [2] Ma, per quanto posso dire, posso usare solo un backend cache con django.

Come posso avere queste sitemap pronte per quando Google arriva-a-crawlin 'senza uccidere il mio database o memcached?

Qualche idea?

[1] L'ho limitato a 1.000 collegamenti per pagina Sitemap perché la generazione dei max. 50.000 collegamenti non stava accadendo.

[2] ad esempio, se ho sitemap.xml? Page = 1, page = 2 ... sitemap.xml? Page = 50, ho solo bisogno di cambiare sitemap.xml? Page = 50 fino a è pieno di 1.000 collegamenti, quindi posso farlo praticamente per sempre e concentrarsi sulla pagina 51 finché non è pieno, memorizzarlo per sempre, ecc.

EDIT, 2012-05-12: Questo ha continuato a essere un problema e alla fine ho abbandonato la struttura della sitemap di Django dopo averla usata con una cache di file per circa un anno. Invece ora sto usando Solr per generare i collegamenti di cui ho bisogno in una vista davvero semplice, e poi li sto passando al modello Django. Questo notevolmente ha semplificato le mie sitemap, le ha rese perfette, e al momento sono fino a circa 2.250.000 collegamenti. Se vuoi farlo, guarda il template della sitemap - è tutto molto ovvio da lì. È possibile vedere il codice per questo qui: https://bitbucket.org/mlissner/search-and-awareness-platform-courtlistener/src/tip/alert/casepage/sitemap.py

Answer 1

Avevo un problema simile e ho deciso di utilizzare django per scrivere i file Sitemap sul disco nel supporto statico e farli servire dal server web. Ho fatto la chiamata per rigenerare la sitemap ogni paio d'ore poiché il mio contenuto non cambiava più spesso di così. Ma dipenderà dal tuo contenuto quante volte hai bisogno di scrivere i file.

Ho usato un comando personalizzato django con un cron job, ma l'arricciatura con un cron job è più facile.

Ecco come io uso curl, e ho apache inviare /sitemap.xml come un file statico, non attraverso django:

curl -o /path/sitemap.xml http://example.com/generate/sitemap.xml 

Answer 2

Va bene - ho trovato un po 'più informazioni e che cosa stanno facendo amazon con i loro 6 milioni di URL.

Amazon semplicemente fare una mappa per ogni giorno e aggiungere ad essa:

1. nuovi URL
2. aggiornate le URL

Quindi questo significa che finiscono con un sacco di sito-maps - ma il bot di ricerca guarderà solo le ultime - poiché le date aggiornate sono recenti.Ero sotto la comprensione che si dovrebbe aggiornare una mappa e non includere un url più di una volta. Penso che questo sia vero. Ma, Amazon aggira questo come le mappe del sito sono più di un registro. Un url può apparire in una mappa del sito successiva, in quanto potrebbe essere aggiornato, ma Google non guarderà le mappe più vecchie perché non sono aggiornate, a meno che, naturalmente, non faccia un grande reindicatore. Questo approccio ha molto senso in quanto tutto ciò che fai è semplicemente costruire una nuova mappa, ad esempio ogni giorno di contenuti nuovi e aggiornati e eseguirne il ping su google, quindi Google deve solo indicizzare questi nuovi URL.

Questo approccio di registro è una sincronizzazione del codice: tutto ciò che serve è un modello di archivio dati statico che memorizza i dati XML per ciascuna mappa. il tuo cron job può costruire una mappa - giornaliera o settimanale e quindi memorizzare la pagina XML raw in un campo blob o cosa hai. puoi quindi pubblicare le pagine direttamente da un gestore e anche la mappa dell'indice.

Non sono sicuro di quello che pensano gli altri, ma questo sembra un approccio molto praticabile e un carico di un server - rispetto alla ricostruzione di un'enorme mappa solo perché alcune pagine potrebbero essere cambiate.

Ho anche pensato che potrebbe essere possibile scricchiolare una settimana di mappe in una settimana e 4 settimane in un mese, quindi alla fine ci sono mappe mensili, una mappa per ogni settimana nell'attuale mese e poi una mappa per gli ultimi 7 giorni. Supponendo che tutte le date siano mantenute, questo ridurrà il numero di mappe riordinando il processo - pensando in termini di riduzione di 365 mappe per ogni giorno dell'anno fino a 12.

Ecco un pdf sulle mappe del sito e il approcci usati da Amazon e CNN.

http://www2009.org/proceedings/pdf/p991.pdf

Answer 3

sto usando django-staticgenerator app per il caching sitemap.xml al filesystem e aggiornare il file quando i dati aggiornati.

settings.py:

STATIC_GENERATOR_URLS = (
    r'^/sitemap', 
) 
WEB_ROOT = os.path.join(SITE_ROOT, 'cache') 

models.py:

from staticgenerator import quick_publish, quick_delete 
from django.dispatch import receiver 
from django.db.models.signals import post_save, post_delete 
from django.contrib.sitemaps import ping_google 

@receiver(post_delete) 
@receiver(post_save) 
def delete_cache(sender, **kwargs): 
    # Check if a Page model changed 
    if sender == Page: 
     quick_delete('/sitemap.xml') 
     # You may republish sitemap file now 
     # quick_publish('/', '/sitemap.xml') 
     ping_google() 

Nella configurazione nginx ho reindirizzare sitemap.xml a cartella della cache e Django istanza per ripiego:

location /sitemap.xml { 
    root /var/www/django_project/cache; 

    proxy_set_header X-Real-IP $remote_addr; 
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; 
    proxy_set_header Host $http_host; 

    if (-f $request_filename/index.html) { 
     rewrite (.*) $1/index.html break; 
    } 
    # If file doesn't exist redirect to django 
    if (!-f $request_filename) { 
     proxy_pass http://127.0.0.1:8000; 
     break; 
    }  
} 

Con questo metodo, sitemap.xml verrà sempre aggiornato e i client (come google) ottengono il file xml sempre in modo statico. Fantastico, penso! :)

Answer 4

Per coloro che (per qualsiasi motivo) preferiscono mantenere le proprie sitemap generate dinamicamente (ad esempio, freschezza, pigrizia). Prova django-sitemaps. È una versione streaming delle sitemap standard. Sostituzione drop-in. Tempo di risposta molto più rapido e utilizza meno memoria.