Wie kann man mit Redis in Django -Anwendungen zwischenstrichen

Dieses Tutorial zeigt, wie man Redis Caching nutzt, um die Leistung von Python -Anwendungen zu steigern, insbesondere innerhalb eines Django -Frameworks. Wir werden die Redis -Installation, die Django -Konfiguration und die Leistungsvergleiche behandeln, um die Vorteile von Caching hervorzuheben.

Einführung in Redis und Caching

Durchschnitt verbessert die Anwendungsgeschwindigkeit erheblich, indem häufig auf Daten an einem leicht verfügbaren Ort (Cache) zugegriffen wird, anstatt wiederholt langsamere Datenquellen wie Datenbanken abzufragen. Redis, eine Open-Source-, In-Memory-Datenstrukturspeicher, ist als Datenbank, Cache und Message Broker. Es reduziert die Datenbanklast dramatisch, indem Daten direkt aus seinem Cache bedient werden.

redis

installieren

Für Ubuntu -Benutzer umfasst die einfachste Installation die folgenden Befehle:

sudo apt-get update
sudo apt install redis

Überprüfen Sie die Installation mit:

redis-cli --version

Windows -Benutzer können das Windows -Subsystem für Linux (WSL2) verwenden. Aktivieren Sie zunächst WSL2 (Ausführen als Administrator):

Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux

Ubuntu aus dem Microsoft Store installieren, dann das Ubuntu -Terminal starten und ausführen:

sudo apt-add-repository ppa:redislabs/redis
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install redis-server
sudo service redis-server restart

django api Beispiel: Produktdaten zwischen den Produktdaten

Dieses Beispiel zeigt, dass Produktdaten in einer Django -Anwendung Caching -Produktdaten zeigen. Wir werden django-redis verwenden, um mit Redis zu interagieren.

Voraussetzungen:

• django
• django-redis
• Redis
• loadtest (für Leistungstests)

Projekt -Setup:

1. Erstellen Sie ein Projektverzeichnis und eine virtuelle Umgebung.
2. Aktivieren Sie die virtuelle Umgebung und installieren Sie Abhängigkeiten:

pip install django==1.9 django-redis djangorestframework

3. Erstellen Sie ein Django -Projekt und eine App:

django-admin startproject django_cache
cd django_cache
python manage.py startapp store

4. add store und rest_framework zu INSTALLED_APPS in settings.py.

5. Erstellen Sie das Product Modell in store/models.py:

from django.db import models

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 = models.DateTimeField(auto_now_add=True, blank=True)
    date_modified = models.DateTimeField(auto_now=True, blank=True)

    def __str__(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
        }

6. Migrationen ausführen:

python manage.py makemigrations store
python manage.py migrate

7. Erstellen Sie einen Superuser und füllen Sie die Datenbank mit Beispieldaten.

Redis in Django konfigurieren:

Folgendes zu settings.py:

Folgendes hinzufügen

CACHES = {
    'default': {
        'BACKEND': 'django_redis.cache.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379/',
        'OPTIONS': {
            'CLIENT_CLASS': 'django_redis.client.DefaultClient',
        }
    }
}

Erstellen von Ansichten und URLs:

erstellen store/views.py mit Endpunkten zum Abrufen von Produkten (mit und ohne Zwischenspeicherung):

from rest_framework.decorators import api_view
from rest_framework.response import Response
from django.core.cache import cache
from .models import Product

@api_view(['GET'])
def view_products(request):
    products = Product.objects.all()
    results = [p.to_json() for p in products]
    return Response(results)

@api_view(['GET'])
def view_cached_products(request):
    products = cache.get('products')
    if products:
        return Response(products)
    else:
        products = Product.objects.all()
        results = [p.to_json() for p in products]
        cache.set('products', results)
        return Response(results)

erstellen store/urls.py:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.view_products),
    path('cached/', views.view_cached_products),
]

integrieren store/urls in Ihr Haupt urls.py.

Leistungstests mit loadtest:

installieren loadtest: sudo npm install -g loadtest

Führen Sie Tests für beide Endpunkte aus, um die Leistung zu vergleichen. Der zwischengespeicherte Endpunkt sollte nach der anfänglichen Cache -Population erheblich verbesserte Anforderungen pro Sekunde zeigen.

Schlussfolgerung:

Dieses Tutorial zeigt die einfache Integration von Redis -Caching in eine Django -Anwendung, was zu erheblichen Leistungsgewinnen führt. Die in der Memory und Benutzerfreundlichkeit von Redis erhobene Art und Weise macht es zu einer ausgezeichneten Wahl zur Verbesserung der Anwendungsgeschwindigkeit und zur Reduzierung der Serverlast. Denken Sie daran, Strategien für Caching zu berücksichtigen, um die Leistung und Ressourcenauslastung Ihrer Anwendung zu optimieren.

(Post-Thumbnail-Bild erzeugt von OpenAI Dall-e.)

Das obige ist der detaillierte Inhalt vonWie kann man mit Redis in Django -Anwendungen zwischenstrichen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!