Panduan komprehensif untuk caching django

Takeaways Key

Memahami asas -asas: memahami konsep asas caching di Django, termasuk kepentingannya untuk mengurangkan beban pelayan dan meningkatkan pengalaman pengguna dengan mempercepatkan masa tindak balas.
Persediaan dan Konfigurasi: Ketahui cara menyediakan projek Django dan mengkonfigurasi pelbagai kaedah caching seperti memori tempatan, pangkalan data, pangkalan data, dan caching redis dalam fail `settings.py`.
Redis untuk Caching Lanjutan: Menyelam menggunakan Redis untuk caching di Django, yang menawarkan keupayaan pengambilan data yang cepat, menjadikannya sesuai untuk sistem berprestasi tinggi dan diedarkan.
• Pelaksanaan praktikal: Terokai teknik caching praktikal seperti melihat caching, caching serpihan templat, dan caching per tapak untuk mengoptimumkan prestasi aplikasi web dengan ketara.
• Manfaat Prestasi: Kenali peningkatan dramatik dalam kelajuan dan kecekapan aplikasi yang dapat dicapai dengan melaksanakan strategi caching Django, akhirnya membawa kepada pengalaman pengguna akhir yang lebih baik.
• Dalam artikel ini, anda akan mendapat pemahaman yang komprehensif mengenai caching dalam Django dan pembangunan web secara keseluruhan. Anda akan belajar tentang caching apa, manfaat caching, bagaimana untuk menubuhkan caching di Django, sistem backend yang menyokong Django, dan amalan terbaik caching.
Pada akhir artikel, sebagai pemaju web backend, anda akan mempunyai pemahaman yang kukuh tentang caching dan bagaimana anda boleh melaksanakannya dalam projek Django anda untuk prestasi terbaik.

Rangka Kerja Django adalah salah satu kerangka backend yang paling popular yang digunakan oleh pemaju web hari ini. Sebagai pemaju, membina aplikasi web dengan prestasi tinggi harus menjadi salah satu matlamat dalam senarai anda. Oleh itu, membina aplikasi web di Django untuk prestasi tinggi tidak seharusnya menjadi masalah, kerana Django dilengkapi dengan kerangka caching yang membolehkan anda menggunakan pelbagai backends seperti cache dalam memori, cache berasaskan fail, cache pangkalan data, dan banyak lagi.

Pengenalan kepada Django Caching

caching dalam pembangunan web adalah teknik yang digunakan oleh pemaju web untuk meningkatkan prestasi aplikasi web. Setiap aplikasi web mempunyai sumber yang digunakan oleh penggunanya secara konsisten untuk digunakan. Sumber boleh menjadi apa -apa dari laman web mudah ke data yang disimpan dalam pangkalan data. Caching memainkan peranan penting dalam memaksimumkan kelajuan di mana sumber diakses.

senario caching biasa dan menggunakan kes

Rangka kerja caching Django menyediakan pelbagai senario dan menggunakan kes -kes yang membolehkan pemaju untuk cache yang sering diakses data. Berikut adalah senario caching biasa:

• Page caching. Ini adalah satu senario di mana halaman yang sering dikunjungi di laman web sepenuhnya cache. Aplikasi ini mengambil versi cache halaman dan menjadikannya apabila permintaan dibuat, berbanding dengan mewujudkan kandungan halaman dari awal.

• Caching Query Database. Caching Query Database adalah pendekatan yang baik untuk aplikasi yang bergantung kepada kerap meminta pangkalan data untuk maklumat. Satu siri permintaan boleh dipenuhi oleh sekeping data cache yang sama tanpa perlu memukul pangkalan data, oleh itu menurunkan hits pangkalan data dan mempercepatkan masa tindak balas pelayan.

• Sesi dan Pengesahan Caching. Caching boleh digunakan untuk menawarkan pengalaman pengguna yang diselaraskan dan masa tindak balas yang lebih cepat. Oleh kerana data cache akan membolehkan pengguna bergerak dengan mudah merentasi bahagian aplikasi yang disahkan, pengesahan caching dan butiran sesi dapat membantu mengurangkan operasi pengesahan yang berlebihan.

Manfaat Django Caching

caching telah berkembang lebih berfaedah kepada pemaju web dalam persekitaran moden ini di mana data adalah intipati dan kelajuan lebih penting. Ini adalah beberapa manfaat caching:

• Prestasi yang lebih baik. Caching meningkatkan prestasi aplikasi web dengan mengurangkan beban pelayan. Apabila pelayan mendapat permintaan dari aplikasi, caching memastikan bahawa beberapa permintaan berpuas hati menggunakan data cache sebelumnya. Ini menghalang pelayan daripada menjalankan operasi tersebut dari awal. Akibatnya, pengalaman pengguna diperbaiki secara keseluruhan, dan masa tindak balas telah meningkat.

• Mengurangkan masa tindak balas. Caching meminimumkan masa tindak balas dengan mengurangkan hits pangkalan data. Caching membolehkan data diambil dari lokasi yang mudah dan bukan secara langsung dari pangkalan data setiap kali diperlukan. Oleh kerana sesetengah data memerlukan pengiraan mahal yang boleh mengambil sedikit masa untuk menyelesaikan, mengambil data setiap kali ia diperlukan dari pangkalan data mungkin bukan pilihan terbaik untuk semua data. Dengan menyimpan data dan segera menjadikannya tersedia apabila diperlukan, caching menyelamatkan hari.

Pengoptimuman sumber. Data atau sumber caching dalam aplikasi web, membolehkan sumber dapat diakses dan boleh diperolehi tanpa melakukan operasi berulang yang mengeluarkan sumber yang sama.
Menyediakan Projek Django

Tugas utama dalam bahagian ini adalah untuk mewujudkan persekitaran maya dan memasang modul yang diperlukan untuk projek tersebut. Untuk mewujudkan persekitaran maya, masukkan arahan ini di terminal anda:

Semua modul untuk projek akan dipasang di dalam persekitaran ini, jadi untuk mula menggunakannya, kita perlu mengaktifkannya.

$ python <span>-m venv project
</span>

pada Windows Gunakan ini:

dan pada macOS atau linux, gunakan ini:

$ .<span>\project\Scripts\activate
</span>

Sebelum kita melaksanakan caching, perkara pertama yang perlu dilakukan ialah menubuhkan projek Django. Jadi mari kita pasang Django terlebih dahulu. Buka terminal anda, dan jalankan arahan ini:

$ <span>source project/bin/activate
</span>

$ python <span>-m venv project
</span>

Selepas berjaya memasang Django, mari buat projek dan aplikasi Django. Untuk membuat projek Django berjalan:

$ .<span>\project\Scripts\activate
</span>

Navigasi ke dalam folder projek. Di sini, kami akan membuat aplikasi Django. Jalankan perintah ini:

$ <span>source project/bin/activate
</span>

dan kemudian jalankan ini:

$ pip <span>install django
</span>

Selepas berjaya membuat projek dan aplikasi, kami perlu mendaftarkan permohonan itu kepada projek tersebut. Buka fail tetapan.py, dan buat senarai yang dipasang_apps kelihatan seperti ini:

$ django-admin startproject cachedproject

Nota: Untuk menggunakan aplikasi dalam projek Django anda, ia mesti didaftarkan dalam senarai Pemasangan_Apps.

Sekarang, untuk mengesahkan bahawa rangka kerja Django telah dipasang dengan jayanya, mari kita uji. Di terminal, jalankan arahan ini:

$ <span>cd cachedproject
</span>

Pastikan anda mendapat output yang digambarkan di bawah.

Sekarang salin URL dan tampalkannya ke dalam pelayar web. Output yang diharapkan digambarkan di bawah.

NOTA: Anda boleh membaca lebih lanjut mengenai dengan cepat memulakan projek Django dan aplikasi Django di Sitepoint.

Mengkonfigurasi tetapan caching yang berbeza dalam tetapan.py

Untuk menggunakan caching, kita perlu mengkonfigurasinya dalam projek Django kita, jadi dalam bahagian ini, kita akan melihat bagaimana kita dapat mengkonfigurasi sistem caching yang berbeza yang terdapat di Django.

Caching Memori Tempatan

seperti namanya, cache memori tempatan, kadang -kadang disingkat sebagai locmem, menyimpan data cache dalam ram mesin hosting.

Django secara automatik menggunakan caching memori tempatan sebagai sistem caching lalai jika anda tidak menyediakan mekanisme caching alternatif dalam fail tetapan.py anda. Teknik caching yang selamat, cepat, dan responsifnya terkenal.

Cache memori tempatan kurang sesuai untuk digunakan dalam persekitaran pengeluaran, kerana ia termasuk mekanisme per-proses yang menghalang apa-apa jenis caching silang proses dan membuat proses individu mengekalkan contoh cache peribadi yang berasingan. Ia masih merupakan pilihan yang baik, bagaimanapun, untuk pembangunan.

Untuk mengkonfigurasi caching memori tempatan dalam permohonan anda, tambahkan kod berikut dalam fail tetapan.py:

Caching berasaskan fail

$ python manage.py startapp cachedapplication

Dalam caching berasaskan fail, setiap nilai cache bersiri dan disimpan secara berasingan dalam fail semasa caching. Ia berguna untuk aplikasi berskala kecil atau di mana caching berasaskan memori tidak praktikal.

Kelemahan sistem caching ini adalah bahawa ia agak perlahan berbanding dengan caching berasaskan memori.

Untuk mengkonfigurasi caching berasaskan fail dalam aplikasi anda, tambahkan kod berikut dalam fail tetapan.py:

Jika anda berada di tingkap, pastikan anda memulakan laluan lokasi dengan surat pemacu masing -masing seperti ini:

$ python <span>-m venv project
</span>

Caching pangkalan data

Selain menyimpan cache dalam fail dan menganjurkan RAM mesin, Django juga menyediakan keupayaan untuk menyimpan cache dalam pangkalan data.

Ini berfungsi dengan baik jika anda mempunyai pelayan pangkalan data yang cepat dan baik.

Untuk menggunakan caching pangkalan data dalam aplikasi anda, tambahkan kod berikut di dalam tetapan.py:

$ .<span>\project\Scripts\activate
</span>

Gunakan arahan berikut untuk membina jadual pangkalan data yang disebutkan dalam persediaan di atas sebelum menggunakan cache:

$ <span>source project/bin/activate
</span>

Perintah di atas membuat jadual dalam pangkalan data dalam format yang betul yang diharapkan oleh sistem cache pangkalan data Django. Nama jadual diambil dari lokasi. Dalam kes ini, nama meja akan menjadi my_cache_table.

Memcached Caching

Memcached adalah sistem caching dalam memori yang digunakan oleh pemaju web walaupun di beberapa syarikat popular untuk mengurangkan akses pangkalan data dan meningkatkan prestasi tapak.

Berbeza dengan cache locMem, memcached beroperasi sebagai daemon, yang menunjukkan bahawa pelayan memcached berjalan sebagai proses latar belakang, secara bebas dari mana -mana interaksi pengguna langsung. Oleh itu, Memcached mesti dipasang secara berasingan pada mesin anda. Kemudian dalam aplikasi Django anda, pasang dan konfigurasikan salah satu pengikatannya, seperti pylibmc atau pymemcache, untuk menggunakan memcached.

Aplikasi Django boleh dikaitkan dengan daemon memcached dengan menambahkan tetapan cache, lokasi, alamat IP, dan butiran lain, seperti yang ditunjukkan di bawah:

$ pip <span>install django
</span>

Teknologi Memcached sangat sesuai untuk aplikasi dengan beban baca atau pertanyaan yang tinggi, kerana ia direka untuk penyimpanan dan pengambilan data yang cepat.

Kelemahan memcached adalah, kerana data disimpan dalam ingatan, ia akan hilang jika pelayan anda terhempas.

redis

Redis adalah pangkalan data dalam memori yang boleh digunakan untuk caching. Ia cache data menggunakan penyimpanan data redis dalam memori. Redis terkenal dengan kepantasan dan kebolehsuaiannya, menjadikannya pilihan yang baik untuk sistem yang diedarkan dan caching berprestasi tinggi.

Untuk data cache menggunakan REDIS dalam aplikasi anda, anda memerlukan pelayan REDIS yang berjalan sama ada secara tempatan atau pada mesin jauh. Untuk menubuhkan Redis pada mesin anda, baca panduan Redis yang bermula.

Selepas menubuhkan pelayan Redis, anda perlu memasang pengikat python untuk Redis. Gunakan arahan ini untuk memasangnya:

$ django-admin startproject cachedproject

Antara muka Redis-Py adalah pengikatan yang disokong oleh Django atau menggunakan pakej Django-Redis dan Redis.

Untuk mengkonfigurasi Redis Caching dalam aplikasi anda, memandangkan pelayan Redis anda berjalan pada localhost (127.0.0.1), port = 6379, tambahkan kod berikut dalam tetapan.py:

$ python <span>-m venv project
</span>

redis 'kerumitan dan pergantungan pada perkhidmatan luar adalah perdagangannya. Pemasangan dan konfigurasi Redis boleh menjadi lebih rumit daripada dengan backend cache yang lain. Ia memerlukan pelayan kedua dan pemeliharaan apabila dalam talian. Penggunaan Redis mewujudkan pergantungan pada perkhidmatan luar. Keupayaan caching aplikasi anda mungkin terjejas jika redis mempunyai masalah atau turun.

melakukan caching di django menggunakan redis

Okay, itu teori yang cukup. Dalam bahagian ini, kami akan menunjukkan cara melakukan caching dalam aplikasi Django. Kami akan memberi tumpuan kepada tiga bentuk caching:

• Lihat caching
• Caching Fragment Template
• caching per tapak

Kami akan membuat, mendaftarkan, dan mengisi model, mengkonfigurasi URL aplikasi, membuat templat, pasang bar alat debug Django, dan konfigurasikannya.

Di dalam aplikasi cacheDapplication, buka fail model.py dan menjadikannya kelihatan seperti ini:

$ .<span>\project\Scripts\activate
</span>

Seterusnya, buka fail admin.py dan tampal kod ini:

$ <span>source project/bin/activate
</span>

Coretan kod ini mendaftarkan programmer model dalam papan pemuka admin Django.

Sebelum memaparkan model, mari kita lakukan beberapa migrasi. Di terminal, jalankan ini:

$ pip <span>install django
</span>

dan juga menjalankan ini:

$ django-admin startproject cachedproject

Di Django, kita boleh mengisi model kita dalam dua cara: melalui terminal, dan melalui papan pemuka admin. Tetapi demi kesederhanaan, kami akan menggunakan papan pemuka admin. Oleh kerana papan pemuka admin hanya untuk superuser, kita perlu membuatnya. Di terminal, jalankan arahan berikut:

$ <span>cd cachedproject
</span>

Perintah ini akan meminta anda memasukkan butiran superuser seperti nama pengguna, e -mel, dan dua kata laluan.

Selepas berjaya membuat superuser, api pelayan tempatan, dan dalam penyemak imbas anda masukkan URL ini: http://127.0.0.1:8000/admin/. Imej di bawah menunjukkan halaman yang akan dibawa ke.

untuk log masuk, memberikan kelayakan superuser, dan apabila anda masuk, mengisi model dengan data, seperti yang digambarkan di bawah.

Di dalam aplikasi, buat folder templat, dan di dalamnya buat fail list_all.html. Buat masa ini, tinggalkan fail HTML kosong. Buka fail views.py dan buatnya kelihatan seperti ini:

Sekarang mari kita mendaftarkan paparan rumah dalam fail urls.py projek. Di dalam folder CachedProject, buka fail urls.py dan tampal kod ini:

$ python manage.py startapp cachedapplication

Sekarang buka fail list_all.html dan tampal kod berikut:

INSTALLED_APPS <span>= [
</span>    <span>'django.contrib.admin',
</span>    <span>'django.contrib.auth',
</span>    <span>'django.contrib.contenttypes',
</span>    <span>'django.contrib.sessions',
</span>    <span>'django.contrib.messages',
</span>    <span>'django.contrib.staticfiles',
</span>    <span># new application added
</span>    <span>'cachedapplication',
</span><span>]
</span>

$ python <span>-m venv project
</span>

Mari pasang bar alat debug Django. Ini adalah pakej Python yang membantu pemaju memantau prestasi aplikasi Django mereka, memberikan maklumat terperinci mengenai pertanyaan pangkalan data, permintaan HTTP, masa rendering templat, dan banyak lagi. Jadi di terminal anda, masukkan arahan ini:

$ .<span>\project\Scripts\activate
</span>

Untuk mengkonfigurasi Django-Debug-Toolbar, buka fail tetapan.py dan edit senarai yang dipasang_apps untuk kelihatan seperti ini:

$ <span>source project/bin/activate
</span>

Tambahkan bar alat debug ke senarai middleware:

$ pip <span>install django
</span>

Buat middleware bar alat debug datang tepat selepas ini:

$ django-admin startproject cachedproject

ia juga harus datang sebelum ini:

$ <span>cd cachedproject
</span>

Tambahkan konfigurasi cache Redis seperti berikut:

$ python manage.py startapp cachedapplication

Juga, tambahkan kod ini ke fail tetapan.py:

INSTALLED_APPS <span>= [
</span>    <span>'django.contrib.admin',
</span>    <span>'django.contrib.auth',
</span>    <span>'django.contrib.contenttypes',
</span>    <span>'django.contrib.sessions',
</span>    <span>'django.contrib.messages',
</span>    <span>'django.contrib.staticfiles',
</span>    <span># new application added
</span>    <span>'cachedapplication',
</span><span>]
</span>

Akhirnya, mari kita konfigurasi URL alat debug dalam fail urls.py. Hanya di bawah import, tambahkan baris kod ini:

$ python manage.py runserver

di dalam senarai urlpatterns Tambahkan kod ini:

<span># CACHES dictionary which contains caching configurations.
</span>CACHES <span>= {
</span>    <span># a cache alias or name. In this case, we use "default" as the alias.
</span>    <span>"default": {
</span>        <span># Here, we're using the in-memory cache backend.
</span>        <span>"BACKEND": "django.core.cache.backends.locmem.LocMemCache",
</span>
        <span># LOCATION parameter gives a unique name or identifier to this cache instance.
</span>        <span>"LOCATION": "unique-snowflake",
</span>    <span>}
</span><span>}
</span>

Setelah mencapai sejauh ini, kami baik untuk pergi. Jalankan pelayan dan tampal URL ini ke dalam penyemak imbas anda: http://127.0.0.1:8000/home/. Imej di bawah menunjukkan halaman yang kami dapat.

Setiap kali anda menjalankan aplikasi menggunakan pandangan ini, ia akan membuat pertanyaan SQL. Dalam kes ini, tiga pertanyaan telah mengambil 2.60ms. Jadi untuk mengelakkan membuat pertanyaan SQL untuk data yang sama setiap kali, kami akan melaksanakan caching paparan.

Lihat caching

Seperti namanya, lihat caching caching melibatkan caching hasil pandangan Django individu. Dalam bahagian ini, kami akan melaksanakan caching paparan. Untuk melakukan ini, kami akan membuat beberapa pengubahsuaian ke fail View.py. Buka dan tambahkan import ini:

<span># A CACHES dictionary, which contains caching configurations.
</span>CACHES <span>= {
</span>    <span># we use "default" as the alias.
</span>    <span>"default": {
</span>        <span># Here, we're using the file-based cache backend.
</span>        <span>"BACKEND": "django.core.cache.backends.filebased.FileBasedCache",
</span>
        <span># LOCATION parameter to specify the file system path where cached data will be stored.
</span>        <span>"LOCATION": "/var/tmp/django_cache",
</span>    <span>}
</span><span>}
</span>

betul -betul di atas pandangan, juga tambahkan penghias ini:

CACHES <span>= {
</span>    <span>"default": {
</span>        <span>"BACKEND": "django.core.cache.backends.filebased.FileBasedCache",
</span>        <span>"LOCATION": "C:/my/path-to/file",
</span>    <span>}
</span><span>}
</span>

(60*15) adalah argumen yang diluluskan kepada @cache_page. Ia mewakili tamat masa cache dalam beberapa saat. Pandangan rumah akan di -cache selama 15 minit.

Sekarang lawati pandangan yang sama dan muat semula halaman. Kami akan mendapat hasil yang digambarkan di bawah.

Dalam imej di atas, kita dapat melihat bahawa terdapat 0 pertanyaan SQL yang dilakukan, kerana data sedang diambil dari cache. Ini membantu mengurangkan beban pada pelayan dengan melayani kandungan cache kepada pengguna.

Caching Fragment Template

caching ini melibatkan bahagian -bahagian khusus templat dalam projek anda. Apabila templat anda mempunyai bahagian dengan pengiraan berat, caching serpihan templat berguna. Untuk melaksanakan caching ini, kami menggunakan tag ini: { % beban cache %}, { % cache %}, dan { % endCache %}. Tag { % cache %} mengambil dua argumen: tamat masa cache, dan kunci cache yang unik untuk mengenal pasti serpihan cache tertentu.

Sekarang cuba menjalankan projek sebelum melaksanakan teknik caching ini. Imej di bawah menunjukkan apa yang akan kita dapat.

Jumlah masa adalah 220.26ms, dan tiga pertanyaan SQL dilakukan dalam 7.75ms.

Sekarang mari kita melaksanakan teknik caching. Kami akan cache bahagian

template. Buka templat/list_all.html, dan ubah suai untuk kelihatan seperti ini:

$ python <span>-m venv project
</span>

Di atas fail, kami memuatkan cache melalui { % beban cache %} dan kami telah melampirkan bahagian div dengan { % cache 500 pengaturcara %} dan { % endcache %}.

Jika anda menjalankan projek lagi, anda akan mendapat hasil yang digambarkan di bawah.

Dalam imej di atas, kita dapat melihat bahawa hasilnya telah bertambah baik selepas caching telah dilaksanakan.

caching per tapak

caching per tapak juga dikenali sebagai caching seluruh tapak. Ia melibatkan caching seluruh halaman tapak. Untuk melaksanakannya, anda perlu menambah konfigurasi middleware ini dalam fail tetapan.py:

dan juga menambah baris ini:

$ .<span>\project\Scripts\activate
</span>

Kesimpulan

$ <span>source project/bin/activate
</span>

Kesimpulannya, memahami caching di Django adalah penting bagi pemaju web yang ingin membuat aplikasi web berprestasi tinggi. Artikel ini telah menyediakan panduan komprehensif untuk caching di Django, yang meliputi topik seperti manfaat caching, menubuhkan caching di Django, dan amalan terbaik untuk pelaksanaan. Bersenjata dengan pengetahuan ini, pemaju web backend dengan yakin dapat memasukkan caching ke dalam projek Django mereka untuk mengoptimumkan prestasi.

Jika anda menikmati artikel ini, lihat beberapa artikel Django di Sitepoint.

Atas ialah kandungan terperinci Panduan komprehensif untuk caching django. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!