Share
En av måtene å avlaste belastningen på en server er ved å cache data. Dette gjøres ved å cache data etter at den er behandlet og deretter betjene den fra hurtigbufferen neste gang den blir bedt om det. Denne opplæringen vil gi en detaljert diskusjon om Redis, forklarer hvordan du installerer Redis og cache data i Python applikasjoner.
Caching refererer til lagring av serverresponsen i klienten selv, slik at en klient ikke trenger å foreta en serverforespørsel for den samme ressursen igjen og igjen. Et serverrespons bør ha informasjon om hvordan caching skal gjøres, slik at en klient cacher svaret i en tidsperiode eller aldri caches serverresponsen.
En cache, derimot, er en maskinvare- eller programvarekomponent som brukes til å lagre data, slik at fremtidige forespørsler om de samme dataene kan serveres raskere.
I denne alderen der brukere forventer resultater innen et sekund, er det lurt å betjene forespørsler ved å lese data fra hurtigbufferen, noe som til slutt er raskere enn å lese fra en langsommere datalager. Systemets ytelse avhenger dermed av hvor mange forespørsler som kan betjenes fra hurtigbufferen.
Redis er en åpen kildekode, i minnet datastruktur butikk, brukt som en database, cache og melding megler. Det fungerer ved å lagre data i et cache og gi det neste gang det blir bedt om det, i stedet for å spørre databasen hver gang.
Det første trinnet er å få Redis opp og kjører lokalt på maskinen din. Den enkleste måten å installere Redis på er via operativsystemets pakkebehandling som:
sudo apt-get install redis-server
Du kan også følge instruksjonene fra den offisielle Redis-siden.
Last ned og ekstraher Redis 4.0.6 tar som følger:
$ 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ærfilene som nå er samlet, er tilgjengelige i src-katalogen. Kjør Redis med:
$ src / redis-server
Du kan samhandle med Redis ved hjelp av den innebygde klienten:
$ src / redis-cli redis sett foo bar OK redis få foo "bar"
For å sjekke om redis-serveren kjører, utsted følgende kommando på terminalen:
$ sudo redis-server * Klar til å godta tilkoblinger
La oss lage vårt Django-prosjekt. Prosjektet vårt vil kunne cache alle produktene i en butikk, noe som gjør det enkelt og raskt å hente data i etterfølgende søk.
For å gjøre bruk av Redis i appen vår, må vi gjøre følgende:
Før vi begynner, opprett en katalog og installer et virtuelt miljø. Et virtuelt miljø lar deg installere biblioteksversjoner som kreves av søknaden din.
mkdir myprojects cd myprojects
Deretter aktiverer du det virtuelle miljøet og installerer prosjektkravene.
kilde venv / bin / aktiver pip installasjon django == 1.9 pip installere django-redis pip installere djangorestframework
django-admin startprosjekt django_cache
Opprett en ny app som heter butikk, som håndterer produktstyring i butikken vår.
cd django_cache python manage.py startapp butikk
Legg til butikkprogrammet og rest_framework til listen over installerte apper 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 ', # legg til her' rest_framework ', # legg til her også]
I butikk / models.py, Vi starter med å lage produktmodellen for lagring av produktdetaljer som følger:
fra __future__ import unicode_literals fra django.db importmodeller importere datetime # Lag dine modeller her. klasse Produkt (models.Model): navn = 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 __ (selv): return self.name def to_json (selv): retur 'id': self.id, 'navn': self.name, 'desc': self.description, 'price': self.price, 'date_created': self.date_created, 'date_modified': self.date_modified
Opprett en innledende migrasjon for vår produktmodell, og synkroniser databasen for første gang.
python manage.py makemigration butikk python manage.py migrere
Opprett en superbruker, logg inn på administrasjonspanelet, og fyll inn databasen din med noen prøvedata som vi skal bruke til å gjøre testene våre.
python manage.py skaperupperuser
For å kunne bruke Redis med en Django-applikasjon, må vi sette opp Redis for å lagre programmets cachedata. Og følgende til 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 ',
Deretter skal vi lage et sluttpunkt som henter alle produktene fra vår database. Vi vil først teste ytelsen til applikasjonen med hensyn til hvor lang tid det tar å hente data fra databasen uten å cache den. Vi vil da implementere et annet sluttpunkt som henter data fra en cache og sammenligne ytelsen.
I butikk / views.py, legg til følgende kode som henter alle produktene som er til stede i databasen.
fra django.shortcuts import gjengi fra rest_framework.decorators importere api_view fra rest_framework.response import Svar fra rest_framework import status # Lag dine synspunkter her. @api_view (['GET']) def view_books (request): produkter = Product.objects.all () results = [produkt.to_json () for produkt i produkter] returnere Svar (resultater, status = status.HTTP_201_CREATED)
Lag en fil butikk / urls.py og legg til følgende kode.
# store / urls.py fra django.conf.urls importere url fra .views import view_books urlpatterns = [url (r '^ $', view_books),]
Vi må også importere nettadresser fra brukerprogrammet til hovedlisten django_cache / urls.py fil.
Accentsconagua
# django_cache / urls.py fra django.conf.urls import url, inkludere fra django.contrib import admin urlpatterns = [url (r '^ admin /', admin.site.urls), url (r '^ store /', inkludere ('store.urls'))] La oss gjøre en test og se om vi er på sporet. Vi bruker loadtest. Hvis du ikke er kjent med loadtest, er det et verktøy for testing av ytelse.
Installere loadtest som root er enkelt:
sudo npm installer -g loadtest
$ loadtest -n 100 -k http: / / localhost: 8000 / store / # result INFO Forespørsler per sekund: 55
Som sett fra ovenstående behandles 55 forespørsler per sekund.
La oss opprette et annet sluttpunkt for å hente data etter caching med Redis. Redigere brukere / views.py for å matche følgende:
fra rest_framework.decorators importere api_view fra rest_framework import status fra rest_framework.response import Svar fra django.core.cache import cache fra django.conf importinnstillinger fra django.core.cache.backends.base import DEFAULT_TIMEOUT CACHE_TTL = getattr (innstillinger, 'CACHE_TTL ', DEFAULT_TIMEOUT) fra .models import Produkt # Lag dine synspunkter her. @api_view (['GET']) def view_books (forespørsel): # resten av koden @api_view (['GET']) def view_cached_books (request): hvis 'produkt' i cachen: # få resultater fra cache products = cache .get (produkt) returnere Svar (produkter, status = status.HTTP_201_CREATED) annet: produkter = Product.objects.all () results = [product.to_json () for produkt i produkter] # lagre data i cache cache.set (produkt, resultater, timeout = CACHE_TTL) returnere Svar (resultater, status = status.HTTP_201_CREATED)
Koden ovenfor vil sjekke om nøkkelproduktet er tilstede i hurtigbufferen, og hvis funnet, vil dataene som er representert, bli returnert til nettleseren. I tilfelle at ingen data er tilstede i hurtigbufferen, henter vi først dataene fra databasen, lagrer den i hurtigbufferen, og returner deretter dataene som er forespurt i nettleseren.
Oppdater butikk / urls.py som følger.
fra django.conf.urls import url fra .views import view_books, view_cached_books urlpatterns = [url (r '^ $', view_books), url (r 'cache /', view_cached_books),]
La oss utføre testene.
$ loadtest -n 100 -k http: // localhost: 8000 / store / cache / # resultater INFO Forespørsler per sekund: 233
Første gang du treffer endepunktet localhost: 8000 / store / cache, vil applikasjonen spørre fra databasen og returnere data, men etterfølgende anrop til nettadressen vil omgå databasen og spørre fra hurtigbufferen siden dataene allerede er tilgjengelige i hurtigbufferen.
I denne opplæringen brukte vi Redis til å gi et program en illusjon av fart. Vi utnytter bruken av RAM i Redis for å lagre resultatene av spørringer og deretter returnere disse resultatene fra hurtigbufferen i etterfølgende søk i stedet for å gjøre rundturen til databasen.
Det finnes andre cachingverktøy, for eksempel Memcached, som ligner Redis. Men Redis er mer populært enn Memcached, fordi det tar bare noen få minutter å sette opp og få jobbe i applikasjoner. Redis har mer sofistikerte mekanismer som det har blitt beskrevet som en "datastrukturbutikk", noe som gjør den mer kraftig og fleksibel. Redis har også en større fordel fordi du kan lagre data i noen form.
Forhåpentligvis har denne opplæringen vist deg hvor enkelt det er å legge til et caching-lag i programmet, og dermed forbedre ytelsen. Caching må være noe å vurdere når du trenger å redusere belastningstider og serverkostnader.
