Share
Eine der Möglichkeiten, einen Server zu entlasten, ist das Zwischenspeichern von Daten. Dazu werden die Daten nach der Verarbeitung zwischengespeichert und dann bei der nächsten Anforderung aus dem Cache bereitgestellt. In diesem Lernprogramm werden Redis ausführlich erläutert. Außerdem wird erläutert, wie Redis installiert und Daten in Python-Anwendungen zwischengespeichert werden.
Caching bezieht sich auf das Speichern der Serverantwort im Client selbst, sodass ein Client nicht immer wieder eine Serveranfrage für dieselbe Ressource stellen muss. Eine Serverantwort sollte Informationen darüber enthalten, wie das Caching ausgeführt werden soll, sodass ein Client die Antwort für einen bestimmten Zeitraum im Cache speichert oder niemals die Serverantwort im Cache speichert.
Ein Cache hingegen ist eine Hardware- oder Softwarekomponente, die zum Speichern von Daten verwendet wird, damit zukünftige Anforderungen für dieselben Daten schneller bedient werden können.
In einer Zeit, in der Benutzer innerhalb einer Sekunde Ergebnisse erwarten, ist es ratsam, Anforderungen durch Lesen von Daten aus dem Cache zu bedienen, was letztendlich schneller ist als das Lesen aus einem langsameren Datenspeicher. Daher hängt die Systemleistung davon ab, wie viele Anforderungen vom Cache bedient werden können.
Redis ist ein Open-Source-Speicher für die Datenstruktur im Arbeitsspeicher, der als Datenbank, Cache und Message Broker verwendet wird. Es speichert Daten in einem Cache und stellt sie bei der nächsten Anforderung zur Verfügung, anstatt die Datenbank jedes Mal abzufragen.
Der erste Schritt besteht darin, Redis lokal auf Ihrem Computer zu installieren. Redis lässt sich am einfachsten über den Paketmanager des Betriebssystems installieren:
sudo apt-get install redis-server
Sie können auch den Anweisungen auf der offiziellen Redis-Site folgen.
Laden Sie Redis 4.0.6 tar wie folgt herunter und extrahieren Sie es:
$ wget http://download.redis.io/releases/redis-4.0.6.tar.gz $ tar xzf redis-4.0.6.tar.gz $ cd redis-4.0.6 $ make
Die jetzt kompilierten Binärdateien stehen im Verzeichnis src zur Verfügung. Redis ausführen mit:
$ src / redis-server
Sie können mit Redis mit dem integrierten Client interagieren:
$ src / redis-cli redis set foo bar OK redis erhalten foo "bar"
Geben Sie den folgenden Befehl auf dem Terminal ein, um zu überprüfen, ob der Redis-Server ausgeführt wird:
$ sudo redis-server * Bereit, Verbindungen anzunehmen
Lassen Sie uns unser Django-Projekt erstellen. Unser Projekt wird in der Lage sein, alle Produkte in einem Geschäft zwischenzuspeichern, sodass Daten in nachfolgenden Abfragen einfach und schnell abgerufen werden können.
Um Redis in unserer App nutzen zu können, müssen wir Folgendes tun:
Bevor Sie beginnen, erstellen Sie ein Verzeichnis und installieren Sie eine virtuelle Umgebung. In einer virtuellen Umgebung können Sie Bibliotheksversionen installieren, die für Ihre Anwendung erforderlich sind.
mkdir myprojects cd meine Projekte
Aktivieren Sie anschließend die virtuelle Umgebung und installieren Sie die Projektanforderungen.
source venv / bin / enable pip installieren django == 1.9 pip installieren django-redis pip install djangorestframework
django-admin startprojekt django_cache
Erstellen Sie eine neue App namens Store, die die Produktverwaltung in unserem Store übernimmt.
cd django_cache python manage.py startapp store
Fügen Sie die Store-Anwendung und rest_framework der Liste der installierten Apps im hinzu einstellungen.py Datei.
# settings.py INSTALLED_APPS = ['django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django. contrib.staticfiles ',' store ', # hier hinzufügen' rest_framework ', # hier auch hinzufügen]
Im Store / models.py, Wir beginnen mit der Erstellung des Produktmodells zum Speichern der Produktdetails wie folgt:
von __future__ import unicode_literals von django.db import models import datetime # Hier können Sie Ihre Modelle erstellen. Klasse Produkt (models.Model): name = models.CharField (max_length = 255) description = models.TextField (null = True, leer = True) price = models.IntegerField (null = True, blank = True) date_created = models. DateTimeField (auto_now_add = True, leer = True) date_modified = models.DateTimeField (auto_now = True, leer = True) def __unicode __ (self): return self.name def an_json (self): return 'id': self.id, 'name': self.name, 'desc': self.description, 'price': self.price, 'date_created': self.date_created, 'date_modified': self.date_modified
Erstellen Sie eine anfängliche Migration für unser Produktmodell und synchronisieren Sie die Datenbank zum ersten Mal.
python manage.py makemigration store python manage.py migrieren
Erstellen Sie einen Superuser, melden Sie sich im Admin-Panel an und füllen Sie Ihre Datenbank mit Beispieldaten auf, die wir für unsere Tests verwenden werden.
python manage.py erstellt einen Superuser
Um Redis mit einer Django-Anwendung verwenden zu können, müssen Sie Redis so einrichten, dass die Cache-Daten der Anwendung gespeichert werden. Und das Folgende zu Ihrem einstellungen.py Datei:
CACHES = 'default': 'BACKEND': 'django_redis.cache.RedisCache', 'LOCATION': 'redis: //127.0.0.1: 6379 /', 'OPTIONS': 'CLIENT_CLASS': 'django_redis.client .DefaultClient ',
Als Nächstes erstellen wir einen Endpunkt, der alle Produkte aus unserer Datenbank abruft. Wir werden zunächst die Leistung der Anwendung dahingehend testen, wie lange es dauert, Daten aus der Datenbank abzurufen, ohne sie zu speichern. Wir implementieren dann einen anderen Endpunkt, der Daten aus einem Cache abruft, und vergleichen die Leistung.
Im speichern / ansichten.py, Fügen Sie den folgenden Code hinzu, der alle in der Datenbank vorhandenen Produkte abruft.
import django.shortcuts import render von rest_framework.decorators import api_view von rest_framework.response import Antwort von rest_framework import status # Erstellen Sie hier Ihre Ansichten. @api_view (['GET']) def view_books (request): products = Product.objects.all () results = [product.to_json () für Produkt in Produkten] geben Antwort zurück (Ergebnisse, Status = Status.HTTP_201_CREATED)
Erstellen Sie eine Datei store / urls.py und fügen Sie den folgenden Code hinzu.
# store / urls.py aus django.conf.urls import url aus .views import view_books urlpatterns = [url (r '^ $', view_books),]
Außerdem müssen URLs aus der Benutzeranwendung in die Hauptanwendung importiert werden django_cache / urls.py Datei.
Accentsconagua
# django_cache / urls.py von django.conf.urls import url, enthalten von django.contrib import admin urlpatterns = [url (r '^ admin /'), admin.site.urls), url (r '^ store /', include ('store.urls'))]] Lassen Sie uns einen Test machen und sehen, ob wir auf Kurs sind. Wir werden loadtest verwenden. Wenn Sie mit loadtest nicht vertraut sind, ist dies ein Tool zum Testen der Leistung.
Die Installation von loadtest als root ist einfach:
sudo npm install -g loadtest
$ loadtest -n 100 -k http: // localhost: 8000 / store / # result INFO Anfragen pro Sekunde: 55
Wie aus dem Obigen ersichtlich, werden pro Sekunde 55 Anforderungen verarbeitet.
Lassen Sie uns einen weiteren Endpunkt zum Abrufen von Daten nach dem Zwischenspeichern mit Redis erstellen. Bearbeiten Benutzer / Ansichten.py um Folgendes zu finden:
von rest_framework.decorators importieren api_view aus rest_framework importieren Status von rest_framework.response import Antwort von django.core.cache importieren Sie den Cache aus django.conf importieren Sie die Einstellungen von django.core.cache.backends.base ', DEFAULT_TIMEOUT) aus .models importieren Produkt # Erstellen Sie hier Ihre Ansichten. @api_view (['GET']) def view_books (request): # Rest des Codes @api_view (['GET']) def view_cached_books (request): wenn 'product' im Cache: # Ergebnisse von Cache-Produkten abrufen = Cache .get ('product') gibt Antwort zurück (products, status = status.HTTP_201_CREATED) else: products = Product.objects.all () result = [product.to_json () für Produkt in Produkten] # speichert Daten im Cache-Cache.set (Produkt, Ergebnisse, Timeout = CACHE_TTL) Antwort zurückgeben (Ergebnisse, Status = Status.HTTP_201_CREATED) Der obige Code prüft, ob das Schlüsselprodukt im Cache vorhanden ist. Falls gefunden, werden die dargestellten Daten an den Browser zurückgegeben. Falls keine Daten im Cache vorhanden sind, rufen wir zuerst die Daten aus der Datenbank ab, speichern sie im Cache und geben die abgefragten Daten dann an den Browser zurück.
Aktualisieren store / urls.py wie folgt.
aus django.conf.urls import url aus .views import view_books, view_cached_books urlpatterns = [url (r '^ $', view_books), url (r '^ cache /', view_cached_books),]
Lassen Sie uns die Tests durchführen.
$ loadtest -n 100 -k http: // localhost: 8000 / store / cache / # führt zu INFO-Anfragen pro Sekunde: 233
Wenn Sie das erste Mal auf den Endpunkt localhost: 8000 / store / cache zugreifen, fragt die Anwendung die Datenbank ab und gibt Daten zurück. Die nachfolgenden Aufrufe der URL umgehen jedoch die Datenbank und die Abfrage aus dem Cache, da die Daten bereits im Cache verfügbar sind.
In diesem Tutorial haben wir Redis verwendet, um einer Anwendung die Illusion von Geschwindigkeit zu vermitteln. Wir nutzen die Verwendung von RAM in Redis, um die Ergebnisse von Abfragen zu speichern, und geben diese Ergebnisse anschließend in nachfolgenden Abfragen aus dem Cache zurück, anstatt den Roundtrip zur Datenbank durchzuführen.
Es gibt andere Caching-Tools, wie beispielsweise Memcached, das Redis ähnelt. Redis ist jedoch beliebter als Memcached, da das Einrichten und das Arbeiten in Anwendungen nur wenige Minuten dauert. Redis verfügt über ausgefeiltere Mechanismen, da es als "Datenstrukturspeicher" bezeichnet wird, wodurch es leistungsfähiger und flexibler wird. Redis hat auch einen größeren Vorteil, da Sie Daten in beliebiger Form speichern können.
Hoffentlich hat Ihnen dieses Tutorial gezeigt, wie einfach es ist, Ihrer Anwendung eine Zwischenspeicherungsschicht hinzuzufügen und somit die Leistung zu verbessern. Caching muss zu berücksichtigen sein, wenn Ladezeiten und Serverkosten reduziert werden müssen.
