Django persistente Datenbankverbindung

Bin ich mit django auch mit apache und mod_wsgi und PostgreSQL (alle auf dem selben Rechner), und ich brauche, um zu behandeln viele einfache dynamische Seite Anfragen (Hunderte pro Sekunde). Ich konfrontiert mit dem problem, dass der Flaschenhals ist, dass django nicht persistente Datenbank-Verbindung und verbindet sich dann wieder auf die einzelnen Anfragen (das dauert in der Nähe von 5ms).
Während eines benchmark-ich habe das mit der permanenten Internetverbindung kann ich mit fast 500 r/s und ohne nur bekomm ich 50 r/s.

Jemand einen Tipp? Wie ändern django zu verwenden persistente Verbindung? Oder speed-up-Verbindung von der python DB

Vielen Dank im Voraus.

InformationsquelleAutor der Frage HardQuestions | 2009-07-14

  1. 23

    Django 1.6 Hinzugefügt hat persistente verbindungen unterstützt (link zur doc für django 1.9):

    Persistente verbindungen, vermeiden Sie den Aufwand der re-Etablierung
    die Verbindung zur Datenbank, in der jede Anfrage. Sie sind gesteuert durch die
    CONN_MAX_AGE parameter definiert die maximale Lebensdauer eines
    - Verbindung. Es kann eingestellt werden, unabhängig für jede Datenbank.

    InformationsquelleAutor der Antwort Cesar Canassa

  2. 21

    Versuchen PgBouncer - eine leichte Verbindung pooler für PostgreSQL.
    Features:

    • Mehrere Ebenen der Brutalität bei der Rotation von verbindungen:
      • Sitzung pooling
      • Transaktion Bündelung
      • Statement pooling
    • Geringer Speicherbedarf (2k pro Verbindung standardmäßig).

    InformationsquelleAutor der Antwort

  3. 19

    In Django-trunk, Bearbeiten django/db/__init__.py und kommentieren Sie die Zeile:

    signals.request_finished.connect(close_connection)

    Dieser signal-handler bewirkt, dass es eine Verbindung mit der Datenbank nach jeder Anfrage. Ich weiß nicht, was alle Nebenwirkungen, dies zu tun sein wird, aber es macht keinen Sinn, zu beginnen, eine neue Verbindung nach jeder Anfrage; es zerstört performance, als Sie bemerkt habe.

    Ich bin mit diesem jetzt, aber ich havn ' T getan eine vollständige Reihe von tests, um zu sehen, wenn etwas bricht.

    Ich weiß nicht, warum jeder denkt, das muss ein neues backend oder eine Besondere Verbindung pooler oder sonstigen komplexen Lösungen. Dies scheint sehr einfach, obwohl ich nicht Zweifel, es gibt einige obskure Punkte dass Sie tun dies in Erster Linie--was sollten Sie auch behandelt werden mehr vernünftig; 5ms overhead für jeden request ist ziemlich viel für ein high-performance-service, wie Sie bemerkt haben. (Es nimmt mich 150mm--ich havn ' T herausgefunden, warum noch nicht.)

    Edit: eine weitere notwendige änderung ist in django/middleware/transaction.py; entfernen Sie die zwei Transaktion.is_dirty() prüft, und immer rufen Sie commit() oder rollback(). Ansonsten, es wird nicht ein commit für eine Transaktion, wenn es nur aus der Datenbank gelesen, die lassen Schlösser öffnen, die geschlossen werden sollten.

    InformationsquelleAutor der Antwort Glenn Maynard

  4. 14

    Habe ich ein kleines Django patch , implementiert das connection pooling von MySQL und PostgreSQL via pooling von sqlalchemy.

    Diese funktioniert perfekt auf die Produktion von http://grandcapital.net/ für eine lange Zeit.

    Dem patch geschrieben wurde nach googeln das Thema ein bisschen.

    InformationsquelleAutor der Antwort Igor Katson

  5. 3

    Disclaimer: ich habe nicht versucht, diese.

    Ich glaube, Sie brauchen, um zu implementieren eine benutzerdefinierte Datenbank-back-end. Es gibt ein paar Beispiele im web, die zeigt, wie zur Implementierung eines Datenbank-back-end mit Verbindungs-pooling.

    Verwendung eines verbindungspools wäre wahrscheinlich eine gute Lösung für den Fall, als die Netzwerk-verbindungen offen gehalten werden, wenn verbindungen an den pool zurückgegeben.

    • Dieser Beitrag erreicht dies durch patchen Django (einer der Kommentare weist darauf hin, dass es besser ist, die zum implementieren einer benutzerdefinierten back-end außerhalb der Kern-django-code)
    • Dieser Beitrag ist eine Implementierung einer benutzerdefinierten db back-end

    Beiden Beiträge von MySQL verwenden - vielleicht sind Sie in der Lage, ähnliche Techniken nutzen, mit Postgresql.

    Edit:

    • Die Django-Buch erwähnt Postgresql connection pooling, mit pgpool (tutorial).
    • Jemand geschrieben ein patch für den psycopg2 backend implementiert, dass Verbindungs-pooling. Ich schlage vor, erstellen Sie eine Kopie der vorhandenen back-end in Ihrem eigenen Projekt und patchen.

    InformationsquelleAutor der Antwort codeape

  6. 0

    Machte ich einige kleine benutzerdefinierte psycopg2 backend implementiert, dass dauerhafte Verbindung mit globalen Variablen.
    Mit diesem war ich in der Lage zu verbessern, die Menge der Anfragen, die pro Sekunde von 350 bis 1600 (auf sehr einfache Seite mit ein paar auswählt)
    Speichern Sie ihn einfach in die Datei namens base.py in ein beliebiges Verzeichnis (z.B. postgresql_psycopg2_persistent) und legen Sie in den Einstellungen

    DATABASE_ENGINE auf die projectname.postgresql_psycopg2_persistent

    BEACHTEN!!!!! der code ist nicht threadsicher sind - Sie können es nicht verwenden mit python-threads, weil der unexpectable Ergebnisse, im Falle von mod_wsgi verwenden Sie bitte prefork daemon-Modus mit-threads=1

    # Custom DB backend postgresql_psycopg2 based
# implements persistent database connection using global variable

from django.db.backends.postgresql_psycopg2.base import DatabaseError, DatabaseWrapper as BaseDatabaseWrapper, \
    IntegrityError
from psycopg2 import OperationalError

connection = None

class DatabaseWrapper(BaseDatabaseWrapper):
    def _cursor(self, *args, **kwargs):
        global connection
        if connection is not None and self.connection is None:
            try: # Check if connection is alive
                connection.cursor().execute('SELECT 1')
            except OperationalError: # The connection is not working, need reconnect
                connection = None
            else:
                self.connection = connection
        cursor = super(DatabaseWrapper, self)._cursor(*args, **kwargs)
        if connection is None and self.connection is not None:
            connection = self.connection
        return cursor

    def close(self):
        if self.connection is not None:
            self.connection.commit()
            self.connection = None

    Oder hier ist eine thread-sichere, aber python-threads nicht nutzen mehrere Kerne, so dass Sie nicht bekommen, wie performance-Schub, als mit der vorherigen. Verwenden Sie dieses mit multi-Prozess zu.

    # Custom DB backend postgresql_psycopg2 based
# implements persistent database connection using thread local storage
from threading import local

from django.db.backends.postgresql_psycopg2.base import DatabaseError, \
    DatabaseWrapper as BaseDatabaseWrapper, IntegrityError
from psycopg2 import OperationalError

threadlocal = local()

class DatabaseWrapper(BaseDatabaseWrapper):
    def _cursor(self, *args, **kwargs):
        if hasattr(threadlocal, 'connection') and threadlocal.connection is \
            not None and self.connection is None:
            try: # Check if connection is alive
                threadlocal.connection.cursor().execute('SELECT 1')
            except OperationalError: # The connection is not working, need reconnect
                threadlocal.connection = None
            else:
                self.connection = threadlocal.connection
        cursor = super(DatabaseWrapper, self)._cursor(*args, **kwargs)
        if (not hasattr(threadlocal, 'connection') or threadlocal.connection \
             is None) and self.connection is not None:
            threadlocal.connection = self.connection
        return cursor

    def close(self):
        if self.connection is not None:
            self.connection.commit()
            self.connection = None

    InformationsquelleAutor der Antwort HardQuestions

Schreibe einen Kommentar