Cara Cache Menggunakan Redis dalam Aplikasi Django

Tutorial ini menunjukkan cara memanfaatkan caching redis untuk meningkatkan prestasi aplikasi python, khususnya dalam rangka kerja Django. Kami akan meliputi pemasangan Redis, konfigurasi Django, dan perbandingan prestasi untuk menyerlahkan manfaat caching.

Pengenalan kepada redis dan caching

caching dengan ketara meningkatkan kelajuan aplikasi dengan menyimpan data yang sering diakses di lokasi yang tersedia (cache) dan bukannya berulang kali menanyakan sumber data yang lebih perlahan seperti pangkalan data. Redis, sumber terbuka, kedai data dalam memori, cemerlang sebagai pangkalan data, cache, dan broker mesej. Ia secara dramatik mengurangkan beban pangkalan data dengan melayani data secara langsung dari cache.

Memasang Redis

untuk pengguna Ubuntu, pemasangan paling mudah melibatkan arahan ini:

sudo apt-get update
sudo apt install redis

Sahkan pemasangan dengan:

redis-cli --version

Pengguna Windows boleh menggunakan subsistem Windows untuk Linux (WSL2). Pertama, aktifkan WSL2 (dijalankan sebagai pentadbir):

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

Pasang Ubuntu dari kedai Microsoft, kemudian lancarkan terminal Ubuntu dan laksanakan:

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

Contoh API Django API Django: Data Produk Caching

Contoh ini menunjukkan data produk caching dalam aplikasi Django. Kami akan menggunakan untuk berinteraksi dengan redis.

django-redis Prasyarat:

django

redis
• django-redis
(untuk ujian prestasi)
• loadtest Persediaan Projek:

Buat direktori projek dan persekitaran maya.

mengaktifkan persekitaran maya dan memasang kebergantungan:

Buat projek Django dan aplikasi:

pip install django==1.9 django-redis djangorestframework

tambah

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

dan

ke
4. dalam

   . store rest_framework INSTALLED_APPS settings.py Buat model

   dalam
:

5. Product store/models.py

Jalankan Migrasi:

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
        }

Buat superuser dan mengisi pangkalan data dengan data sampel.

python manage.py makemigrations store
python manage.py migrate

7. Mengkonfigurasi Redis di Django:

tambahkan yang berikut ke

:

Mewujudkan pandangan dan URL: settings.py

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

membuat

dengan titik akhir untuk mendapatkan produk (dengan dan tanpa caching):

Buat

: store/views.py

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)

termasuk

di utama anda store/urls.py.

from django.urls import path
from . import views

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

ujian prestasi dengan store/urls: urls.py

Pasang : loadtest

Jalankan ujian untuk kedua -dua titik akhir untuk membandingkan prestasi. Titik akhir cache harus menunjukkan permintaan yang lebih baik per saat selepas populasi cache awal.

Kesimpulan:

Tutorial ini menggambarkan integrasi langsung Redis caching ke dalam aplikasi Django, menghasilkan keuntungan prestasi yang besar. Sifat dalam memori Redis dan kemudahan penggunaan menjadikannya pilihan yang sangat baik untuk meningkatkan kelajuan aplikasi dan mengurangkan beban pelayan. Ingatlah untuk mempertimbangkan strategi caching untuk mengoptimumkan prestasi aplikasi dan penggunaan sumber aplikasi anda.

(pasca imej kecil yang dihasilkan oleh Openai Dall-e.)

Atas ialah kandungan terperinci Cara Cache Menggunakan Redis dalam Aplikasi Django. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!