Share
Ett av sätten att lindra belastningen på en server är att cacha data. Detta görs genom att cache data efter att den har bearbetats och sedan betjänar den från cachen nästa gång den begärs. Denna handledning ger en detaljerad diskussion om Redis, förklarar hur man installerar Redis och cacherdata i Python-applikationer.
Caching avser att lagra serverns svar i klienten själv, så att en klient inte behöver göra en serverbegäran om samma resurs om och om igen. Ett serverns svar bör ha information om hur cachning ska göras, så att en klient cacher svaret under en tidsperiod eller caches aldrig serverns svar.
En cache är å andra sidan en hårdvara eller mjukvarukomponent som används för att lagra data så att framtida förfrågningar om samma data kan serveras snabbare.
I denna ålder där användarna förväntar sig resultat inom en sekund är det klokt att betjäna förfrågningar genom att läsa data från cacheminnet, vilket i slutändan är snabbare än att läsa från en långsammare datalager. Således beror systemets prestanda på hur många förfrågningar som kan serveras från cacheminnet.
Redis är en öppen källkod, i minnet datastruktur butik, som används som en databas, cache och meddelande mäklare. Det fungerar genom att lagra data i en cache och ge den nästa gång den begärs, istället för att fråga databasen varje gång.
Det första steget är att få Redis upp och springa lokalt på din maskin. Det enklaste sättet att installera Redis är via operativsystemets pakethanterare som så:
sudo apt-get install redis-server
Du kan också följa anvisningarna från den officiella Redis-webbplatsen.
Hämta och extrahera Redis 4.0.6 tjära enligt följande:
$ 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
Binärerna som nu sammanställs är tillgängliga i src-katalogen. Kör Redis med:
$ src / redis-server
Du kan interagera med Redis med hjälp av den inbyggda klienten:
$ src / redis-cli redis set foo bar OK redis få foo "bar"
För att kontrollera om redis-servern kör, ska du utfärda följande kommando på terminalen:
$ sudo redis-server * Klar för att acceptera anslutningar
Låt oss skapa vårt Django-projekt. Vårt projekt kommer att kunna cache alla produkter i en butik, vilket gör det enkelt och snabbt att hämta data i efterföljande frågor.
För att kunna använda Redis i vår app måste vi göra följande:
Innan vi börjar, skapa en katalog och installera en virtuell miljö. En virtuell miljö låter dig installera biblioteksversioner som krävs av din ansökan.
mkdir myprojects cd myprojects
Aktivera sedan den virtuella miljön och installera projektkraven.
källa venv / bin / aktivera pipinstallation django == 1.9 pip installera django-redis pip installera djangorestframework
django-admin startprojekt django_cache
Skapa en ny app som heter butik, som hanterar produkthantering i vår butik.
cd django_cache python manage.py startapp butik
Lägg till butiksprogrammet och rest_framework till listan över installerade appar i settings.py fil.
# settings.py INSTALLED_APPS = ['django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django. contrib.staticfiles ',' store ', # lägg till här' rest_framework ', # lägg till här också]
I butik / models.py, Vi börjar med att skapa produktmodellen för att lagra produktinformationen enligt följande:
från __future__ importera unicode_literals från django.db importmodeller importera datetime # Skapa dina modeller här. klass Produkt (models.Model): name = models.CharField (max_length = 255) description = models.TextField (null = True, blank = True) price = models.IntegerField (null = True, blank = True) date_created = models. DateTimeField (auto_now_add = True, blank = True) date_modified = models.DateTimeField (auto_now = True, blank = True) def __unicode __ (själv): returnera self.name def to_json (själv): returnera 'id' 'namn': self.name, 'desc': self.description, 'price': self.price, 'date_created': self.date_created, 'date_modified': self.date_modified
Skapa en initial migrering för vår produktmodell och synkronisera databasen för första gången.
python manage.py makemigration butik python manage.py migrera
Skapa en superanvändare, logga in på adminpanelen och fyll i din databas med några provdata som vi ska använda för att göra våra test.
python manage.py skapar uppkopplare
För att kunna använda Redis med en Django-applikation måste vi konfigurera Redis för att lagra programmets cacherdata. Och följande till din settings.py fil:
CACHES = 'default': 'BACKEND': 'django_redis.cache.RedisCache', 'LOCATION': 'redis: //127.0.0.1: 6379 /', 'OPTIONS': 'CLIENT_CLASS': 'django_redis.client .DefaultClient ',
Därefter kommer vi att skapa en slutpunkt som hämtar alla produkter från vår databas. Vi testar först programmets prestanda när det gäller hur lång tid det tar att hämta data från databasen utan att cacha den. Vi ska sedan implementera en annan slutpunkt som hämtar data från en cache och jämför prestanda.
I butik / views.py, lägg till följande kod som hämtar alla produkter som finns i databasen.
från django.shortcuts import gör från rest_framework.decorators importera api_view från rest_framework.response import Svar från rest_framework importstatus # Skapa dina åsikter här. @api_view (['GET']) def view_books (förfrågan): products = Product.objects.all () results = [product.to_json () för produkt i produkter] returnera svar (resultat, status = status.HTTP_201_CREATED)
Skapa en fil butik / urls.py och lägg till följande kod.
# store / urls.py från django.conf.urls importera url från .views import view_books urlpatterns = [url (r '^ $', view_books),]
Vi måste också importera webbadresser från användarprogrammet till huvudmenyn django_cache / urls.py fil.
Accentsconagua
# django_cache / urls.py från django.conf.urls import url, inkludera från django.contrib import admin urlpatterns = [url (r '^ admin /', admin.site.urls), url (r '^ store /', inkludera ("store.urls"))] Låt oss göra ett test och se om vi är på rätt spår. Vi använder loadtest. Om du inte är bekant med loadtest är det ett verktyg för att testa prestanda.
Installera loadtest som root är enkelt:
sudo npm installera -g loadtest
$ loadtest -n 100 -k http: // localhost: 8000 / store / # result INFO Begäran per sekund: 55
Som framgår av ovanstående behandlas 55 förfrågningar per sekund.
Låt oss skapa en annan slutpunkt för att hämta data efter caching med Redis. Redigera användare / views.py för att matcha följande:
från rest_framework.decorators importera api_view från rest_framework import status från rest_framework.response import Svar från django.core.cache import cache från django.conf import inställningar från django.core.cache.backends.base import DEFAULT_TIMEOUT CACHE_TTL = getattr (inställningar, "CACHE_TTL ', DEFAULT_TIMEOUT) från .models importera produkt # Skapa dina åsikter här. @api_view (['GET']) def view_books (begäran): # resten av koden @api_view (['GET']) def view_cached_books (request): om "produkt" i cachen: # få resultat från cacheprodukter = cache .get ("produkt") Retur (produkter, status = status.HTTP_201_CREATED) annat: produkter = Product.objects.all () results = [product.to_json () för produkt i produkter] # lagra data i cacheminne (produkt, resultat, timeout = CACHE_TTL) returnera svar (resultat, status = status.HTTP_201_CREATED) Koden ovan kommer att kontrollera om nyckelprodukten finns i cachen, och om den hittas kommer den representerade dataen att returneras till webbläsaren. I händelse av att inga data finns i cachen, hämtar vi först data från databasen, lagrar den i cacheminnet och returnerar sedan de uppgifter som frågades till webbläsaren.
Uppdatering butik / urls.py som följer.
från django.conf.urls import url från .views import view_books, view_cached_books urlpatterns = [url (r '^ $', view_books), url (r 'cache /', view_cached_books),]
Låt oss genomföra testerna.
$ loadtest -n 100 -k http: // localhost: 8000 / store / cache / # results INFO Förfrågningar per sekund: 233
Första gången du träffar endpoint localhost: 8000 / store / cache, kommer applikationen att fråga från databasen och returnera data, men efterföljande samtal till webbadressen kommer att omgå databasen och fråga från cacheminnet eftersom data finns redan i cachen.
I denna handledning använde vi Redis för att ge en ansökan en illusion av hastighet. Vi utnyttjar användningen av RAM i Redis för att lagra resultaten av frågor och sedan returnera dessa resultat från cacheminnet i efterföljande frågor i stället för att göra rundturen till databasen.
Det finns andra cacheverktyg tillgängliga, till exempel Memcached, vilket liknar Redis. Redis är dock mer populär än Memcached, eftersom det bara tar några minuter att installera och arbeta i applikationer. Redis har mer sofistikerade mekanismer som det har beskrivits som en "datastruktur butik", vilket gör den mer kraftfull och flexibel. Redis har också en större fördel eftersom du kan lagra data i någon form.
Förhoppningsvis har denna handledning visat dig hur lätt det är att lägga till ett cacheringslager i din applikation, vilket förbättrar prestanda. Caching måste vara något att tänka på när du behöver minska laddningstider och servern kostnader.
