Share
Een van de manieren om druk op een server te verlichten, is door gegevens in cache op te slaan. Dit gebeurt door gegevens in de cache te bewaren nadat deze zijn verwerkt en vervolgens de volgende keer dat deze wordt opgevraagd uit de cache te serveren. Deze tutorial geeft een gedetailleerde bespreking van Redis, waarin wordt uitgelegd hoe Redis en cachegegevens in Python-applicaties moeten worden geïnstalleerd.
Caching verwijst naar het opslaan van het serverantwoord in de client zelf, zodat een client niet steeds opnieuw een serververzoek hoeft te doen voor dezelfde resource. Een serverreactie moet informatie bevatten over hoe caching moet worden uitgevoerd, zodat een client het antwoord gedurende een periode in de cache opslaat of de serverrespons nooit in de cache opslaat.
Een cache daarentegen is een hardware- of softwarecomponent die wordt gebruikt om gegevens op te slaan, zodat toekomstige verzoeken om dezelfde gegevens sneller kunnen worden verwerkt.
In deze tijd waarin gebruikers binnen een seconde resultaten verwachten, is het verstandig om verzoeken uit te voeren door gegevens uit de cache te lezen, wat uiteindelijk sneller is dan het lezen van een langzamere gegevensopslag; De systeemprestaties hangen dus af van het aantal verzoeken dat vanuit de cache kan worden geserveerd.
Redis is een open-source datastructuurarchief in het geheugen, dat wordt gebruikt als database-, cache- en berichtenbroker. Het werkt door gegevens in een cache op te slaan en deze de volgende keer dat het wordt opgevraagd, te leveren in plaats van elke keer naar de database te vragen.
De eerste stap is om Redis lokaal op uw computer te laten werken. De eenvoudigste manier om Redis te installeren is via de pakketbeheerder van het besturingssysteem, zoals zo:
sudo apt-get install redis-server
U kunt ook de instructies van de officiële Redis-site volgen.
Download en extraheer Redis 4.0.6 tar als volgt:
$ 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
De binaries die nu zijn gecompileerd zijn beschikbaar in de src-directory. Redis uitvoeren met:
$ src / redis-server
U kunt communiceren met Redis met behulp van de ingebouwde client:
$ src / redis-cli redis set foo bar OK redis foo "bar" krijgen
Voer de volgende opdracht uit op de terminal om te controleren of de redis-server actief is:
$ sudo redis-server * Gereed om verbindingen te accepteren
Laten we ons Django-project maken. Ons project kan alle producten in een winkel opslaan, waardoor het gemakkelijk en snel is om gegevens in volgende zoekopdrachten op te halen.
Om Redis in onze app te gebruiken, moeten we het volgende doen:
Maak voordat u begint een map en installeer een virtuele omgeving. In een virtuele omgeving kunt u bibliotheekversies installeren die vereist zijn voor uw toepassing.
mkdir myprojects cd myprojects
Activeer vervolgens de virtuele omgeving en installeer de projectvereisten.
bron venv / bin / activeer pip installeer django == 1.9 pip installeer django-redis pip installeer djangorestframework
django-admin startproject django_cache
Maak een nieuwe app genaamd store, die productbeheer in onze winkel zal afhandelen.
cd django_cache python manage.py startapp winkel
Voeg de winkelapp en rest_framework toe aan de lijst met geïnstalleerde apps in de settings.py het dossier.
# settings.py INSTALLED_APPS = ['django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django. contrib.staticfiles ',' store ', # add here' rest_framework ', # hier ook toevoegen]
In opslag / models.py, we beginnen met het creëren van het productmodel voor het opslaan van de productdetails als volgt:
van __future__ import unicode_literals van django.db importeer modellen importeer datetime # Maak hier uw modellen. class Product (models.Model): name = models.CharField (max_length = 255) description = models.TextField (null = True, blank = True) price = models.IntegerField (null = True, blank = True) date_created = modellen. DateTimeField (auto_now_add = True, blank = True) date_modified = models.DateTimeField (auto_now = True, blank = True) def __unicode __ (self): return self.name def to_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
Maak een eerste migratie voor ons productmodel en synchroniseer de database voor de eerste keer.
python manage.py makemigratie winkel python manage.py migreren
Maak een superuser, meld u aan bij het admin-paneel en vul uw database met enkele voorbeeldgegevens die we zullen gebruiken om onze tests uit te voeren.
python manage.py maaktuperuser
Om Redis met een Django-applicatie te gebruiken, moeten we Redis instellen om de cachegegevens van de toepassing op te slaan. En het volgende voor uw settings.py het dossier:
CACHES = 'standaard': 'BACKEND': 'django_redis.cache.RedisCache', 'LOCATION': 'redis: //127.0.0.1: 6379 /', 'OPTIONS': 'CLIENT_CLASS': 'django_redis.client .DefaultClient ',
Vervolgens gaan we een eindpunt maken dat alle producten uit onze database ophaalt. We zullen eerst de prestaties van de applicatie testen in termen van hoe lang het duurt om gegevens uit de database op te halen zonder deze te cachen. Vervolgens implementeren we een ander eindpunt dat gegevens uit een cache ophaalt en de prestaties vergelijkt.
In opslag / views.py, voeg de volgende code toe die alle producten ophaalt die in de database aanwezig zijn.
from django.shortcuts import render van rest_framework.decorators importeer api_view van rest_framework.response import Antwoord van rest_framework importstatus # Maak hier uw views. @api_view (['GET']) def view_books (request): products = Product.objects.all () results = [product.to_json () voor product in producten] return Response (resultaten, status = status.HTTP_201_CREATED)
Maak een bestand opslag / urls.py en voeg de volgende code toe.
# store / urls.py van django.conf.urls import url van .views import view_books urlpatterns = [url (r '^ $', view_books),]
We moeten ook URL's van de gebruikersapp naar het hoofd importeren django_cache / urls.py het dossier.
Accentsconagua
# django_cache / urls.py van django.conf.urls import url, include van django.contrib import admin urlpatterns = [url (r '^ admin /', admin.site.urls), url (r '^ store /', include ('store.urls'))] Laten we een test doen en kijken of we op schema liggen. We zullen loadtest gebruiken. Als u niet bekend bent met loadtest, is dit een hulpmiddel om de prestaties te testen.
Loadtest installeren als root is eenvoudig:
sudo npm install -g loadtest
$ loadtest -n 100 -k http: // localhost: 8000 / store / # result INFO Verzoeken per seconde: 55
Zoals uit het bovenstaande blijkt, worden 55 verzoeken per seconde verwerkt.
Laten we een ander eindpunt maken voor het ophalen van gegevens na caching met Redis. Bewerk gebruikers / views.py overeenkomen met het volgende:
van rest_framework.decorators importeer api_view van rest_framework importeer status van rest_framework.response import Reactie van django.core.cache import cache van django.conf importeer instellingen van django.core.cache.backends.base import DEFAULT_TIMEOUT CACHE_TTL = getattr (instellingen, 'CACHE_TTL ', DEFAULT_TIMEOUT) van .models importeer product # Maak hier uw weergaven. @api_view (['GET']) def view_books (verzoek): # rest van de code @api_view (['GET']) def view_cached_books (request): if 'product' in cache: # krijg resultaten van cache producten = cache .get ('product') return Response (producten, status = status.HTTP_201_CREATED) else: products = Product.objects.all () results = [product.to_json () voor product in producten] # winkelgegevens in cache cache.set (product, resultaten, timeout = CACHE_TTL) return Response (resultaten, status = status.HTTP_201_CREATED) De bovenstaande code zal controleren of het sleutelproduct aanwezig is in de cache en indien gevonden, zullen de weergegeven gegevens worden teruggestuurd naar de browser. Als er geen gegevens aanwezig zijn in de cache, halen we eerst de gegevens uit de database op, slaan deze op in de cache en retourneren vervolgens de opgevraagde gegevens in de browser.
Bijwerken opslag / urls.py als volgt.
van django.conf.urls import url van .views import view_books, view_cached_books urlpatterns = [url (r '^ $', view_books), url (r '^ cache /', view_cached_books),]
Laten we de testen uitvoeren.
$ loadtest -n 100 -k http: // localhost: 8000 / store / cache / # results INFO Verzoeken per seconde: 233
De eerste keer dat u het eindpunt localhost: 8000 / store / cache raakt, zal de applicatie de database opvragen en gegevens retourneren, maar volgende aanroepen naar de URL zullen de database en query uit de cache omzeilen, aangezien de gegevens al in de cache beschikbaar zijn.
In deze tutorial gebruikten we Redis om een applicatie de illusie van snelheid te geven. We gebruiken het gebruik van RAM in Redis om de resultaten van query's op te slaan en die resultaten vervolgens uit de cache te retourneren in volgende query's in plaats van de ronde naar de database te maken.
Er zijn andere caching-tools beschikbaar, zoals Memcached, vergelijkbaar met Redis. Redis is echter populairder dan Memcached omdat het maar een paar minuten kost om in te stellen en aan de slag te gaan in applicaties. Redis heeft meer geavanceerde mechanismen omdat het is beschreven als een "datastructuuropslag", waardoor het krachtiger en flexibeler wordt. Redis heeft ook een groter voordeel omdat u gegevens in elke vorm kunt opslaan.
Hopelijk heeft deze tutorial je laten zien hoe gemakkelijk het is om een caching-laag toe te voegen aan je applicatie, en dus de prestaties te verbeteren. Caching moet iets zijn om over na te denken wanneer u laadtijden en serverkosten moet verlagen.
