Dans cet article, vous obtiendrez une compréhension complète de la mise en cache dans Django et le développement Web dans son ensemble. Vous découvrirez ce qu'est la mise en cache, les avantages de la mise en cache, comment mettre en place la mise en cache à Django, les systèmes backend que Django soutient et les meilleures pratiques de mise en cache.
À la fin de l'article, en tant que développeur Web backend, vous aurez une solide compréhension de la mise en cache et comment vous pouvez la mettre en œuvre dans vos projets Django pour les meilleures performances.
Le framework Django est l'un des frameworks backend les plus populaires utilisés par les développeurs Web ces jours-ci. En tant que développeur, la création d'applications Web avec des performances élevées devrait être l'un des objectifs de votre liste. Ainsi, la construction d'une application Web à Django pour des performances élevées ne devrait pas être un problème, car Django est livré avec un cadre de mise en cache qui vous permet d'utiliser divers backends de mise en cache comme le cache en mémoire, le cache basé sur des fichiers, le cache de base de données, et plus encore.
La mise en cache dans le développement Web est une technique utilisée par les développeurs Web pour améliorer les performances des applications Web. Chaque application Web possède des ressources que ses utilisateurs souhaitent constamment utiliser. Une ressource pourrait être n'importe quoi, d'une page Web simple aux données stockées dans une base de données. La mise en cache joue un rôle important dans la maximisation de la vitesse à laquelle les ressources sont accessibles.
Le framework de mise en cache Django fournit une large gamme de scénarios et de cas d'utilisation qui permettent à un développeur de mettre en cache les données fréquemment accessibles. Voici les scénarios de mise en cache communs:
Cache de page. Il s'agit d'un scénario où les pages fréquemment visitées sur un site sont entièrement mises en cache. L'application récupère les versions en cache des pages et les rend lorsqu'une demande est faite, au lieu de créer le contenu de la page à partir de zéro.
La mise en cache de requête de la base de données. La mise en cache de requête de la base de données est une bonne approche pour les applications qui dépendent de la demande de base de données fréquemment pour obtenir des informations. Une série de demandes peut être satisfaite par le même morceau de données en cache sans avoir à appuyer sur la base de données, réduisant ainsi la base de données et accélérer le temps de réponse du serveur.
Session et mise en cache d'authentification. La mise en cache peut être utilisée pour offrir une expérience utilisateur rationalisée et un temps de réponse plus rapide. Étant donné que les données en cache permettra aux utilisateurs de se déplacer facilement à travers les sections authentifiées d'une application, l'authentification de mise en cache et les détails de session peuvent aider à réduire les opérations d'authentification redondantes.
La mise en cache est devenue plus avantageuse pour les développeurs Web dans cet environnement moderne où les données sont de l'essence et la vitesse est plus essentielle. Ce sont quelques-uns des avantages de la mise en cache:
Performances améliorées. La mise en cache améliore les performances des applications Web en réduisant la charge du serveur. Lorsque le serveur obtient des demandes de l'application, la mise en cache garantit que certaines demandes sont satisfaites à l'aide de données précédemment mises en cache. Cela empêche le serveur d'avoir à effectuer ces opérations à partir de zéro. En conséquence, l'expérience des utilisateurs est globalement améliorée et les temps de réaction sont accélérés.
Réduction du temps de réponse. La mise en cache minimise le temps de réponse en réduisant les tubes de base de données. La mise en cache permet de récupérer les données à partir d'un emplacement pratique plutôt que directement à partir de la base de données à chaque fois qu'il est nécessaire. Étant donné que certaines données nécessitent des calculs chers qui peuvent prendre un certain temps à compléter, récupérer les données à chaque fois qu'il est nécessaire dans la base de données pourrait ne pas être le meilleur choix pour toutes les données. En enregistrant les données et en les rendant rapidement disponibles chaque fois que cela est nécessaire, la mise en cache sauve la journée.
Optimisation des ressources. La mise en cache de données ou des ressources dans une application Web, permet aux ressources d'être accessibles et récupérables sans effectuer des opérations répétitives qui émanent les mêmes ressources.
Les principales tâches de cette section sont de créer l'environnement virtuel et d'installer les modules requis pour le projet. Pour créer l'environnement virtuel, entrez cette commande dans votre terminal:
$ python <span>-m venv project </span>
Tous les modules du projet seront installés dans cet environnement, donc pour commencer à l'utiliser, nous devons l'activer.
sur Windows Utilisez ceci:
$ .<span>\project\Scripts\activate </span>
et sur macOS ou Linux, utilisez ceci:
$ <span>source project/bin/activate </span>
Avant d'implémenter la mise en cache, la première chose à faire est de configurer un projet Django. Installons donc d'abord Django. Ouvrez votre terminal et exécutez cette commande:
$ python <span>-m venv project </span>
Après avoir réussi à installer Django, créons un projet et une application Django. Pour créer un projet Django exécuté:
$ .<span>\project\Scripts\activate </span>
Naviguez dans le dossier du projet. Ici, nous allons créer une application Django. Exécutez cette commande:
$ <span>source project/bin/activate </span>
puis exécutez ceci:
$ pip <span>install django </span>
Après avoir réussi à créer le projet et l'application, nous devons enregistrer l'application au projet. Ouvrez le fichier Settings.py et faites en sorte que la liste installée_apps ressemble à ceci:
$ django-admin startproject cachedproject
Remarque: Pour utiliser l'application dans votre projet Django, il doit être enregistré dans la liste installée_apps.
Maintenant, pour vérifier que le framework Django a été installé avec succès, testons-le. Dans le terminal, exécutez cette commande:
$ <span>cd cachedproject </span>
Assurez-vous d'obtenir la sortie illustrée ci-dessous.
Copiez maintenant l'URL et collez-le dans le navigateur Web. La sortie attendue est représentée ci-dessous.
Remarque: Vous pouvez en savoir plus sur le démarrage rapidement d'un projet Django et d'une application Django sur SitePoint.
Pour utiliser la mise en cache, nous devons le configurer dans notre projet Django, donc dans cette section, nous examinerons comment nous pouvons configurer différents systèmes de mise en cache disponibles dans Django.
Comme son nom l'indique, le cache de mémoire local, parfois abrégé sous forme de locmem, stocke des données mises en cache dans la RAM de la machine d'hébergement.
Django utilise automatiquement la mise en cache de mémoire locale comme système de mise en cache par défaut si vous ne fournissez pas un autre mécanisme de mise en cache dans votre fichier Settings.py. Sa technique de mise en cache enfile, rapide et réactive est notable.
Le cache de mémoire local est moins approprié pour une utilisation dans les environnements de production, car il comprend un mécanisme par processus qui empêche tout type de mise en cache transversale et fait que les processus individuels maintiennent des instances de cache privé distinctes. C'est toujours un bon choix, néanmoins, pour le développement.
Pour configurer la mise en cache de mémoire locale dans votre application, ajoutez le code suivant dans le fichier Settings.py:
$ python manage.py startapp cachedapplication
Dans la mise en cache basée sur des fichiers, chaque valeur de cache est sérialisée et maintenue séparément dans un fichier lors de la mise en cache. Il est utile pour les applications à petite échelle ou lorsque la mise en cache basée sur la mémoire n'est pas pratique.
L'inconvénient de ce système de mise en cache est qu'il est relativement plus lent par rapport à la mise en cache basée sur la mémoire.
Pour configurer la mise en cache basée sur des fichiers dans votre application, ajoutez le code suivant dans le fichier Settings.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>
Si vous êtes sous Windows, assurez-vous de démarrer le chemin de l'emplacement avec la lettre de lecteur respective comme ceci:
$ python <span>-m venv project </span>
En plus du stockage des caches dans des fichiers et de l'hébergement de la RAM de la machine, Django offre également la possibilité de stocker le cache dans une base de données.
Cela fonctionne mieux si vous avez un serveur de base de données rapide et bien indexé.
Pour utiliser la mise en cache de base de données dans votre application, ajoutez le code suivant dans les paramètres.py:
$ .<span>\project\Scripts\activate </span>
Utilisez la commande suivante pour construire la table de base de données mentionnée dans la configuration ci-dessus avant d'utiliser le cache:
$ <span>source project/bin/activate </span>
La commande ci-dessus crée une table dans la base de données dans un format approprié que le système de cache de base de données de Django attend. Le nom de la table est tiré de l'emplacement. Dans ce cas, le nom de la table sera my_cache_table.
Memcached est un système de mise en cache en mémoire utilisé par les développeurs Web, même dans plusieurs entreprises populaires, pour réduire l'accès à la base de données et augmenter les performances du site.
Contrairement au cache LocMem, Memcached fonctionne comme un démon, ce qui implique que le serveur memcached s'exécute comme un processus d'arrière-plan, indépendamment de toute interaction utilisateur direct. Memcached doit donc être installé séparément sur votre machine. Ensuite, dans votre application Django, installez et configurez l'une de ses liaisons, telles que Pylibmc ou PymemCache, pour utiliser Memcached.
Une application Django peut être liée à un démon Memcached en ajoutant les paramètres de cache, l'emplacement, l'adresse IP et d'autres détails, comme indiqué ci-dessous:
$ pip <span>install django </span>
La technologie Memcached est particulièrement adaptée aux applications avec des charges de lecture ou de requête élevées, car elle a été conçue pour le stockage et la récupération de données rapides.
L'inconvénient de Memcached est que, puisque les données sont stockées en mémoire, elle sera perdue si votre serveur se bloque.
redis est une base de données en mémoire qui peut être utilisée pour la mise en cache. Il cache des données à l'aide du stockage de données Redis en mémoire. Redis est réputé pour sa rapidité et son adaptabilité, ce qui en fait une excellente option pour les systèmes distribués et la mise en cache haute performance.
Pour mettre en cache les données à l'aide de Redis dans votre application, vous avez besoin d'un serveur Redis en cours d'exécution localement ou sur une machine distante. Pour configurer Redis sur votre machine, lisez le guide de démarrage de Redis.
Après la configuration du serveur Redis, vous devrez installer des liaisons Python pour redis. Utilisez cette commande pour l'installer:
$ django-admin startproject cachedproject
L'interface redis-py est la liaison prise en charge nativement par Django ou en utilisant les packages Django-Redis et Redis.
Pour configurer la mise en cache Redis dans votre application, étant donné que votre serveur Redis s'exécute sur localhost (127.0.0.1), port = 6379, ajoutez le code suivant dans les paramètres.py:
$ python <span>-m venv project </span>
La complexité et la dépendance de Redis envers les services extérieurs sont ses compromis. L'installation et la configuration de Redis pourraient être plus difficiles qu'avec certains autres backends de cache. Il a besoin d'un deuxième serveur et d'un entretien en ligne. L'utilisation de Redis crée une dépendance à un service extérieur. Les capacités de mise en cache de votre application peuvent être affectées si Redis a des problèmes ou des baisses.
D'accord, c'est assez de théorie. Dans cette section, nous montrerons comment effectuer la mise en cache dans une application Django. Nous nous concentrerons sur trois formes de mise en cache:
Mais avant d'effectuer chaque formulaire de mise en cache en détail, configurons d'abord le projet correctement. Nous allons créer, enregistrer et remplir les modèles, configurer les URL de l'application, créer un modèle, installer la barre d'outils Django Debug et la configurer.
À l'intérieur de l'application CachedApplication, ouvrez le fichier Models.py et faites-le ressembler à ceci:
$ .<span>\project\Scripts\activate </span>
Ensuite, ouvrez le fichier admin.py et collez ce code:
$ <span>source project/bin/activate </span>
Cet extrait de code enregistre le programmeur modèle dans le tableau de bord Django Admin.
Avant de remplir les modèles, faisons quelques migrations. Dans le terminal, exécutez ceci:
$ pip <span>install django </span>
et aussi exécuter ceci:
$ django-admin startproject cachedproject
Dans Django, nous pouvons remplir nos modèles de deux manières: via le terminal et via le tableau de bord administratif. Mais pour la simplicité, nous utiliserons le tableau de bord de l'administrateur. Étant donné que le tableau de bord administratif est réservé au superutilisateur, nous devons en créer un. Dans le terminal, exécutez la commande suivante:
$ <span>cd cachedproject </span>
Cette commande vous invitera à saisir les détails des superutilisateurs comme le nom d'utilisateur, le courrier électronique et les deux mots de passe.
Après avoir réussi à créer le superutilisateur, lancez le serveur local et, dans votre navigateur, entrez cette URL: http://127.0.0.1:8000/admin/. L'image ci-dessous montre la page à laquelle vous serez emmené.
pour vous connecter, fournissez les informations d'identification des superutilisateurs, et une fois que vous êtes, remplissez les modèles avec des données, comme illustré ci-dessous.
À l'intérieur de l'application, créez un dossier de modèles et à l'intérieur, créez un fichier list_all.html. Pour l'instant, laissez le fichier HTML vide. Ouvrez le fichier Views.py et faites-le ressembler à ceci:
$ python manage.py startapp cachedapplication
Enregistrons maintenant la vue à domicile dans le fichier URLS.py du projet. À l'intérieur du dossier CachedProject, ouvrez le fichier URLS.py et collez ce code:
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>
Ouvrez maintenant le fichier list_all.html et collez le code suivant:
$ python <span>-m venv project </span>
Installons une barre d'outils de débogage Django. Il s'agit d'un package Python qui aide les développeurs à surveiller les performances de leurs applications Django, fournissant des informations détaillées sur les requêtes de base de données, les demandes HTTP, les temps de rendu de modèle, etc. Donc, dans votre terminal, entrez cette commande:
$ .<span>\project\Scripts\activate </span>
Pour configurer le django-debug-toolbar, ouvrez le fichier Settings.py et modifiez la liste installée_apps pour ressembler à ceci:
$ <span>source project/bin/activate </span>
Ajouter la barre d'outils de débogage à la liste des middleware:
$ pip <span>install django </span>
faire venir la barre d'outils de débogage juste après cela:
$ django-admin startproject cachedproject
cela devrait également être précédé:
$ <span>cd cachedproject </span>
Ajouter les configurations de cache redis comme suit:
$ python manage.py startapp cachedapplication
Aussi, ajoutez ce code au fichier Settings.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>
Enfin, configurons les URL de la barre d'outils de débogage dans le fichier url.py. Juste en dessous des importations, ajoutez cette ligne de code:
$ python manage.py runserver
à l'intérieur de la liste UrlPatterns Ajoutez ce code:
<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>Ayant atteint aussi loin, nous sommes prêts à partir. Exécutez le serveur et collez cette URL dans votre navigateur: http://127.0.0.1:8000/home/. L'image ci-dessous montre la page que nous obtenons.
Chaque fois que vous exécutez l'application en utilisant cette vue, elle fera des requêtes SQL. Dans ce cas, trois requêtes ont pris 2,60 ms. Donc, pour éviter de faire des requêtes SQL pour les mêmes données à chaque fois, nous implémenterons la mise en cache de vue.
Comme son nom l'indique, la mise en cache de la mise en cache implique la mise en cache des résultats des vues de Django individuelles. Dans cette section, nous implémenterons la mise en cache de vue. Pour ce faire, nous apporterons quelques modifications au fichier View.py. Ouvrez-le et ajoutez cette importation:
<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>juste au-dessus de la vue, ajoutez également ce décorateur:
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) est l'argument transmis à @cache_page. Il représente le délai d'expiration du cache en secondes. La vue à la maison sera mise en cache pendant 15 minutes.
Visitez maintenant la même vue et actualisez la page. Nous obtiendrons le résultat illustré ci-dessous.
Dans l'image ci-dessus, nous pouvons voir qu'il y a 0 requêtes SQL effectuées, car les données sont récupérées à partir du cache. Cela permet de réduire la charge sur le serveur en servant du contenu mis en cache aux utilisateurs.
Cette mise en cache implique la mise en cache de parties spécifiques d'un modèle dans votre projet. Lorsque votre modèle a des portions avec des calculs lourds, la mise en cache des fragments de modèle est utile. Pour implémenter cette mise en cache, nous utilisons ces balises: {% Charge Cache%}, {% cache%} et {% Endcache%}. La balise {% cache%} prend deux arguments: le délai d'expiration du cache et une clé de cache unique pour identifier un fragment mis en cache spécifique.
Essayez maintenant d'exécuter le projet avant de mettre en œuvre cette technique de mise en cache. L'image ci-dessous montre ce que nous obtiendrons.
Le temps total est de 220,26 ms et trois requêtes SQL sont effectuées en 7,75 ms.
MAINTENANT IMPLATIONS LA TECHNIQUE DE CACHING. Nous mettrons en cache la partie
$ python <span>-m venv project </span>
En haut du fichier, nous chargeons le cache via {% de chargement de chargement%} et nous avons enfermé la divor avec {% cache 500 programmeurs%} et {% endcache%}.
Si vous exécutez à nouveau le projet, vous obtiendrez le résultat illustré ci-dessous.
Dans l'image ci-dessus, nous pouvons voir que les résultats se sont améliorés après la mise en œuvre de la mise en œuvre.
La mise en cache par site est également connue sous le nom de mise en cache de site entier. Cela implique la mise en cache des pages du site. Pour l'implémenter, vous devez ajouter ces configurations de middleware dans le fichier Settings.py:
$ .<span>\project\Scripts\activate </span>
et ajoutez également ces lignes:
$ <span>source project/bin/activate </span>
En conclusion, la compréhension de la mise en cache à Django est essentielle pour les développeurs Web qui cherchent à créer des applications Web haute performance. Cet article a fourni un guide complet de mise en cache à Django, couvrant des sujets tels que les avantages de la mise en cache, la mise en place de la mise en cache à Django et les meilleures pratiques de mise en œuvre. Armés de ces connaissances, les développeurs Web backend peuvent intégrer en toute confiance la mise en cache dans leurs projets Django pour optimiser les performances.
Si vous avez apprécié cet article, consultez quelques autres articles Django sur SitePoint.
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!
Comment utiliser l'instruction insert dans MySQL
fonction de balise span
Comment utiliser des milliers pour gagner des centaines de milliers dans le cercle monétaire
Comment utiliser la fonction de ligne
tutoriel de balançoire
Comment utiliser la commande find pour rechercher des fichiers sous Linux
Formules de permutation et de combinaison couramment utilisées
Comment ouvrir le fichier iso
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
