Comment se cacher en utilisant Redis dans les applications Django

Ce tutoriel montre comment tirer parti de la mise en cache Redis pour augmenter les performances des applications Python, en particulier dans un cadre Django. Nous couvrirons l'installation redis, la configuration de Django et les comparaisons de performances pour mettre en évidence les avantages de la mise en cache.

Introduction à Redis et mise en cache

La mise en cache améliore considérablement la vitesse d'application en stockant des données fréquemment consultées dans un emplacement facilement disponible (le cache) plutôt que de remettre à plusieurs reprises des sources de données plus lentes comme les bases de données. Redis, un magasin de structure de données open-source et en mémoire, excelle sous forme de base de données, de cache et de courtier de messages. Il réduit considérablement la charge de la base de données en servant des données directement à partir de son cache.

Installation de redis

Pour les utilisateurs d'Ubuntu, l'installation la plus simple implique ces commandes:

sudo apt-get update
sudo apt install redis

Vérifiez l'installation avec:

redis-cli --version

Les utilisateurs de Windows peuvent utiliser le sous-système Windows pour Linux (WSL2). Tout d'abord, activez WSL2 (exécuter en tant qu'administrateur):

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

Installez Ubuntu à partir de la boutique Microsoft, puis lancez le terminal Ubuntu et exécutez:

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 Exemple: Cacheing Data du produit

Cet exemple démontre la mise en cache des données du produit dans une application Django. Nous utiliserons django-redis pour interagir avec Redis.

Prérequis:

• django
• django-redis
• redis
• loadtest (pour les tests de performances)

Configuration du projet:

1. Créer un répertoire de projet et un environnement virtuel.
2. Activez l'environnement virtuel et installez les dépendances:

pip install django==1.9 django-redis djangorestframework

3. Créer un projet et une application Django:

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

4. Ajouter store et rest_framework à INSTALLED_APPS dans settings.py.

5. Créez le modèle Product dans 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. exécuter les migrations:

python manage.py makemigrations store
python manage.py migrate

7. Créez un superutilisateur et remplissez la base de données avec des exemples de données.

Configuration de redis dans django:

Ajouter ce qui suit à settings.py:

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

Création de vues et d'URL:

Créer store/views.py avec des points de terminaison pour la récupération des produits (avec et sans mise en cache):

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)

Créer store/urls.py:

from django.urls import path
from . import views

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

inclure store/urls dans votre principal urls.py.

Test de performance avec loadtest:

installer loadtest: sudo npm install -g loadtest

Exécutez des tests pour les deux points de terminaison pour comparer les performances. Le critère d'évaluation mis en cache devrait afficher des demandes considérablement améliorées par seconde après la population de cache initiale.

Conclusion:

Ce tutoriel illustre l'intégration simple de la mise en cache Redis dans une application Django, entraînant des gains de performance substantiels. La nature en mémoire de Redis et la facilité d'utilisation en font un excellent choix pour améliorer la vitesse d'application et réduire la charge du serveur. N'oubliez pas d'envisager des stratégies de mise en cache pour optimiser les performances et l'utilisation des ressources de votre application.

(Image de miniatures post-greffe générée par Openai Dall-E.)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!