2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Redis (RemoteDictionaryServer, type dictionnaire distant) est une base de données NoSQL open source écrite en langage C. Redis s'exécute sur la base de la mémoire et prend en charge la persistance. Il adopte une forme de stockage clé-valeur (paire clé-valeur) et constitue un élément indispensable de l'architecture distribuée actuelle.
NoSQL (NoSQL= Not Only SQL), qui signifie « pas seulement SQL », est le terme général désignant les bases de données non relationnelles. Les bases de données NoSQL grand public incluent Redis, MongBD, Hbase, CouhDB, etc. Les bases de données non relationnelles ci-dessus sont complètement différentes dans leurs méthodes de stockage, leurs structures de stockage et leurs scénarios d'utilisation. Nous pensons donc qu'il s'agit d'un ensemble de bases de données non relationnelles, et non d'un terme général comme les bases de données relationnelles. En d’autres termes, les bases de données autres que les bases de données relationnelles traditionnelles peuvent être considérées comme non relationnelles. La base de données NOSQL est considérée comme le produit de base de données de nouvelle génération en raison de ses avantages d'expansion non relationnelle, distribuée, open source et horizontale.
Une base de données relationnelle est une base de données structurée basée sur un modèle relationnel et généralement orientée vers les enregistrements. Il traite les données dans des bases de données à l'aide de concepts et de méthodes mathématiques telles que l'algèbre ensembliste. Le modèle relationnel fait référence au modèle de table bidimensionnelle, donc une base de données relationnelle est une organisation de données composée de tables bidimensionnelles et des relations entre elles. Dans le monde réel, diverses entités et diverses relations entre entités peuvent être représentées par des modèles relationnels. L'instruction SQL (Standard Data Query Language) est un langage basé sur une base de données relationnelle et est utilisée pour récupérer et exploiter des données dans une base de données relationnelle.
Avec l'essor des sites Web Web2.0, les bases de données relationnelles sont exposées lorsqu'il s'agit de sites Web Web2.0, en particulier les sites Web Web2.0 purement dynamiques avec des données massives et des SNS (Social Networking Services, c'est-à-dire des services de réseaux sociaux) à haute concurrence. difficiles à résoudre, comme le problème des trois hauteurs.
Les sites Web Web2.0 génèrent des pages dynamiques et fournissent des informations dynamiques en temps réel sur la base des informations personnalisées de l'utilisateur. La technologie statique des pages dynamiques ne peut donc pas être utilisée. Par conséquent, la charge simultanée de la base de données est très élevée, atteignant généralement plus de 10 000 requêtes de lecture et d’écriture/s. La base de données relationnelle peut encore à peine prendre en charge des dizaines de milliers de requêtes de requêtes, mais s'il y a des dizaines de milliers de requêtes d'écriture de données, le disque dur I0 ne peut plus les supporter. Pour les sites Web BBS ordinaires, les demandes d'écriture de données simultanées sont souvent élevées.
Les sites Web SNS comme Facebook et Friendfeed génèrent chaque jour une grande quantité d’informations dynamiques sur les utilisateurs. Par exemple, Friendfeed générera pas moins de 250 millions d'informations dynamiques utilisateur en un mois. Pour les bases de données relationnelles, l'efficacité des requêtes est très faible lors de l'exécution de requêtes SQL dans une table contenant 250 millions d'enregistrements.
Dans l'architecture Web, la base de données est la plus difficile à mettre à l'échelle horizontalement. Lorsque le nombre d'utilisateurs et de visites sur le système d'application augmente de jour en jour, la base de données ne peut pas simplement augmenter ses performances et sa capacité de charge en ajoutant du matériel et des nœuds de serveur tels que des services Web. En particulier pour certains sites Web qui doivent fournir des services 24 heures sur 24, les mises à niveau et les extensions de bases de données s'accompagnent souvent de temps d'arrêt de maintenance et de migration de données, et la charge de travail est très énorme.
Les bases de données relationnelles et non relationnelles ont leurs propres caractéristiques et scénarios d'application. La combinaison étroite des deux apportera de nouvelles idées au développement des bases de données Web2.0. Laissez les bases de données relationnelles se concentrer sur les relations et les bases de données non relationnelles se concentrer sur le stockage. Par exemple, dans un environnement de base de données MySQL où la lecture et l'écriture sont séparées, les données fréquemment consultées peuvent être stockées dans une base de données non relationnelle pour améliorer la vitesse d'accès.
Il a des vitesses de lecture et d'écriture de données extrêmement élevées. La vitesse de lecture des données peut atteindre jusqu'à 110 000 fois/s et la vitesse d'écriture des données peut atteindre jusqu'à 81 000 fois/s.
Prend en charge les types de données riches, prend non seulement en charge les données de type clé-valeur simples, mais prend également en charge les opérations de type de données telles que les chaînes, les listes, les hachages, les ensembles et les ensembles ordonnés.
Prend en charge la persistance des données. Les données en mémoire peuvent être enregistrées sur le disque et peuvent être chargées à nouveau pour être utilisées lors du redémarrage.
Atomique, toutes les opérations Redis sont atomiques.
Prend en charge la sauvegarde des données, c'est-à-dire la sauvegarde des données en mode maître-salve.
Redis est une base de données basée sur la mémoire et la mise en cache est l'un de ses scénarios d'application les plus courants. En outre, les scénarios d'application courants de Redis incluent également des opérations permettant d'obtenir les dernières données N, le classement des applications, les contre-applications, les relations de stockage, les systèmes d'analyse en temps réel et la journalisation.
[root@localhost ~]# systemctl stop firewalld //Dans l'environnement expérimental, la désactivation du pare-feu n'a aucun effet. Il n'est pas recommandé de le désactiver dans l'environnement de production. Essayez d'ajouter une stratégie de pare-feu.
[root@localhost ~]# setenforce 0 //Désactivez le noyau, ce qui bloquera l'exécution de l'application.
[root@localhost ~]# yum -y install gcc* zlib-devel //Téléchargez les outils nécessaires pour décompresser le package tar
[root@localhost ~]#tar xvzf redis-4.0.9.tar.gz //redis est une application open source et gratuite. Vous pouvez télécharger ce package sur le site officiel.
[root@localhost ~]#cd redis-4.0.9/
[root@localhost redis-4.0.9]# créer
Avis:
Lors de la création, le message d'erreur suivant peut apparaître :
Solution 1 : utiliserfaire MALLOC=libc spécifie l'allocateur de mémoire pour la libccompiler
Solution 2 : rendre propre && maje dissipe
[root@localhost redis-4.0.9]# make PREFIX=/usr/local/redis install
[root@localhost ~]# ln -s /usr/local/redis/bin/* /usr/local/bin/
[root@localhost redis-4.0.9]# cd /root/redis-4.0.9/utils/
[root@localhost utils]# ./install_server.sh
Remarque:
Fichier de configuration : /etc/redis/6379.conf //Chemin du fichier de configuration
Fichier journal : /var/log/redis_6379.log //Chemin du fichier journal
Répertoire de données : /var/lib/redis/6379 //Chemin du fichier de données
Exécutable : /usr/local/redis/bin/redis-server //chemin du fichier exécutable
Exécutable Cli : /usr/local/redis/bin/redis-cli //Outil de ligne de commande client
[utils root@localhost]# netstat -anpt | grep redis
[root@localhost ~]#/etc/init.d/redis_6379 arrêt
[root@localhost ~]#/etc/init.d/redis_6379 démarrer
[root@localhost ~]#/etc/init.d/redis_6379 redémarrage
[root@localhost ~]#/etc/init.d/redis_6379 état
[root@localhost ~]#vim /etc/redis/6379.conf
lier 127.0.0.1 192.168.10.101 //Adresse de l'hôte d'écoute
port 6379 //port
démoniser oui //Activer le processus démon
fichier pid /var/run/redis_6379.pid //Spécifiez le fichier PID
Avis de niveau de journalisation //niveau de journal
fichier journal /var/log/redis_6379.log // Spécifier le fichier journal
[root@localhost~]#/etc/init.d/redis_6379 redémarrage
[utils root@localhost]# netstat -anpt | grep redis
Ø redis-server : outil de démarrage de Redis ;
Ø redis-benchmark : utilisé pour détecter l'efficacité de fonctionnement de Redis sur cette machine ;
Ø redis-check-aof : Réparer le fichier de persistance AOF ;
Ø redis-check-rdb : Réparer les fichiers de persistance RDB ;
Ø redis-cli : outil de ligne de commande Redis.
[root@localhost ~]# redis-cli
127.0.0.1:6379>
127.0.0.1:6379> ping
PONG
[root@localhost ~]#redis-cli -h 192.168.10.101 -p 6379
Ø aide@<group> :Obtenir<group> liste de commandes dans ;
Ø aide<command> : obtenir de l'aide pour une commande ;
Ø aide<tab> : Obtenez une liste de sujets qui peuvent vous aider.
Remarque:
Ø aide<tab> : Obtenez une liste de sujets qui peuvent vous aider.
Après avoir tapé l'aide, appuyez sur la touche de tabulation
127.0.0.1:6379>aide @liste
127.0.0.1:6379>ensemble d'aide
redis-benchmark est l'outil officiel de test de performances Redis qui peut tester efficacement les performances des services Redis.
Ø -h : Spécifiez le nom d'hôte du serveur ;
Ø -p : Spécifiez le port du serveur ;
Ø -s : spécifiez le socket du serveur ;
Ø -c : Spécifiez le nombre de connexions simultanées ;
Ø -n : Préciser le nombre de requêtes ;
Ø -d : spécifiez la taille des données de la valeur SET/GET en octets ;
Ø -k：1=rester en vie 0=reconnecter；
Ø -r : SET/GET/INCR utilise des clés aléatoires, SADD utilise des valeurs aléatoires ;
Ø -P : Transmission par canalisations<numreq> demander;
Ø -q : Forcer la fermeture de Redis. Seules les valeurs de requête/s sont affichées ;
Ø --csv : sortie au format CSV ;
Ø -l : Générer une boucle et exécuter le test en permanence ;
Ø -t : exécutez uniquement une liste de commandes de test séparées par des virgules ;
Ø -I : Mode veille. Ouvrez uniquement N connexions inactives et attendez.
[root@localhost ~]#redis-benchmark -h 192.168.10.101 -p 6379 -c 100 -n 100000 //Envoyer 100 connexions simultanées et 100 000 tests de requêtes au serveur Redis avec l'adresse IP 192.168.10.101 et les performances du port 6379
Remarque:
Ø -h : Spécifiez le nom d'hôte du serveur ;
Ø -p : Spécifiez le port du serveur ;
Ø -c : Spécifiez le nombre de connexions simultanées ;
Ø -n : Préciser le nombre de requêtes ;
====== MSET (10 touches) ======
100 000 requêtes traitées en 1,02 seconde
100 clients parallèles ##100 connexions simultanées
Charge utile de 3 octets
garder en vie : 1
87,25 % <= 1 milliseconde ##87,25% des temps d'exécution des commandes sont inférieurs ou égaux à 1 milliseconde
99,90 % <= 2 millisecondes
100,00 % <= 2 millisecondes
97943,19 requêtes par seconde #Nombre de requêtes par seconde
[root@localhost ~]#redis-benchmark -h 192.168.10.101 -p 6379 -q -d 100
Remarque:
Ø -h : Spécifiez le nom d'hôte du serveur ;
Ø -p : Spécifiez le port du serveur ;
Ø -d : spécifiez la taille des données de la valeur SET/GET en octets ;
Ø -q : Forcer la fermeture de Redis. Seules les valeurs de requête/s sont affichées ;
PING_INLINE : 121 506,68 requêtes par seconde //Combien d'opérations PING sont effectuées par seconde
PING_BULK : 124 378,11 requêtes par seconde
SET : 121 654,50 requêtes par seconde //Combien de fois par seconde la valeur de la clé SET est terminée
GET : 1 22 100,12 requêtes par seconde //Combien de valeurs de clé GET complétées par seconde
INCR : 118 764,84 requêtes par seconde //Combien de comptages atomiques sont effectués par seconde
LPUSH : 112 612,61 requêtes par seconde
RPUSH : 118 623,96 requêtes par seconde
LPOP : 107 874,87 requêtes par seconde
RPOP : 114 416,48 requêtes par seconde
SADD : 123 304,56 requêtes par seconde
HSET : 122 249,38 requêtes par seconde
SPOP : 128 040,97 requêtes par seconde
LPUSH (nécessaire pour évaluer LRANGE) : 116 686,12 requêtes par seconde
LRANGE_100 (100 premiers éléments) : 40 016,00 requêtes par seconde
LRANGE_300 (300 premiers éléments) : 11 991,85 requêtes par seconde
LRANGE_500 (450 premiers éléments) : 7 381,71 requêtes par seconde
LRANGE_600 (600 premiers éléments) : 5 230,67 requêtes par seconde
MSET (10 clés) : 92 421,44 requêtes par seconde //Plusieurs clés v par secondelaueNombre de demandes
[root@localhost ~]# redis-benchmark -t set,lpush -n 100000 -q //Testez les performances du service Redis sur cette machine pendant les opérations set et lpush.
Remarque:
Ø -n : Préciser le nombre de requêtes ;
Ø -q : Forcer la fermeture de Redis. Seules les valeurs de requête/s sont affichées ;
Ø -t : exécutez uniquement une liste de commandes de test séparées par des virgules ;
SET : 121 951,22 requêtes par seconde
LPUSH : 127 226,46 requêtes par seconde
Ø ensemble: Stocker les données. Le format de commande de base est. définir la valeur clé。
Ø obtenir: Obtenez des données, le format de commande de base est Obtenir la clé。
exister Redis dans la base de données, avec clé Les commandes pertinentes incluent principalement les suivantes.
utiliser clés La commande peut prendre une liste de valeurs clés conformes aux règles. Habituellement, elle peut être combinée.* ,? options à utiliser.
127.0.0.1:6379>ensemble k1 1
D'ACCORD
127.0.0.1:6379>ensemble k2 2
D'ACCORD
127.0.0.1:6379>ensemble k3 3
D'ACCORD
127.0.0.1:6379>ensemble v1 4
D'ACCORD
127.0.0.1:6379>ensemble v5 5
D'ACCORD
127.0.0.1:6379>CLÉS *
1) "professeur"
2) "k1"
3) "k2"
4) "k3"
5) "v1"
6) "v5"
127.0.0.1:6379>ensemble v22 5
D'ACCORD
127.0.0.1:6379>CLÉS v*
1) "v1"
2) "v5"
3) "v22"
127.0.0.1:6379>CLÉS v?
1) "v1"
2) "v5"
127.0.0.1:6379>CLÉS v??
1) "v22"
existe La commande peut déterminer si la valeur clé existe
127.0.0.1:6379>existe enseignant
(entier) 1
Le résultat est 1, ce qui signifie professeur la clé existe
127.0.0.1:6379>existe du thé
(entier) 0
Le résultat est 0, ce qui signifie thé la clé n'existe pas
du La commande peut supprimer le spécifié clé
127.0.0.1:6379>clés *
1) "professeur"
2) "v1"
3) "v22"
4) "k3"
5) "k1"
6) "k2"
7) "v5"
127.0.0.1:6379> du v5
(entier) 1
127.0.0.1:6379>obtenir la v5
(néant)
utiliser taper La commande peut être obtenue clé correspondant valeur type de valeur
127.0.0.1:6379>type k1
chaîne
Remarque:
Types de données pris en charge par Redis
Renommer La commande concerne un existant clé Renommer
En utilisation réelle, il est recommandé d'utiliser existe Commande pour afficher la cible clé existe, puis décidez s'il faut exécuter Renommer commande pour éviter d'écraser les données importantes
127.0.0.1:6379>touches v*
1) "v1"
2) "v22"
127.0.0.1:6379>renommer v22 v2
D'ACCORD
127.0.0.1:6379>touches v*
1) "v1"
2) "v2"
127.0.0.1:6379>obtenir la v1
"4"
127.0.0.1:6379>obtenir la v2
"5"
127.0.0.1:6379>renommer v1 v2
D'ACCORD
127.0.0.1:6379>obtenir la v1
(néant)
127.0.0.1:6379>obtenir la v2
"4"
renamenx La fonction de la commande est de modifier l'existant clé Effectuez un changement de nom et vérifiez si le nouveau nom existe.
utiliserrenamenx Lorsque la commande est renommée, si la cible clé S'il existe, il ne sera pas renommé.
127.0.0.1:6379>clés *
1) "professeur"
2) "k3"
3) "k1"
4) "k2"
5) "v2"
127.0.0.1:6379>obtenir un professeur
"Zhanglong"
127.0.0.1:6379>obtenir la v2
"4"
127.0.0.1:6379>professeur renamenx v2
(entier) 0
127.0.0.1:6379>clés *
1) "professeur"
2) "k3"
3) "k1"
4) "k2"
5) "v2"
127.0.0.1:6379>obtenir un professeur
"Zhanglong"
127.0.0.1:6379>obtenir la v2
"4
taille de la base de données Le but de la commande est de visualiser la base de données actuelle clé Nombre de.
127.0.0.1:6379> taille de la base de données
(entier) 5
Redis Inclus par défaut sans aucune modification 16 base de données, le nom de la base de données est un nombre 0-15 être nommé dans l'ordre
（1）Passer au numéro de série 10 base de données
127.0.0.1:6379>sélectionnez 10
D'ACCORD
（2）Passer au numéro de série 15 base de données
127.0.0.1:6379[10]>sélectionnez 15
D'ACCORD
（3）Passer au numéro de série 0 base de données
127.0.0.1:6379[15]>sélectionner 0
Redis Les multiples bases de données sont relativement indépendantes dans une certaine mesure, par exemple dans la base de données 0 Magasin ci-dessus k1 données, dans d'autres 1-15 Il n'est pas visible sur la base de données.
127.0.0.1:6379>ensemble k1 100
D'ACCORD
127.0.0.1:6379>obtenir k1
"100"
127.0.0.1:6379>sélectionner 1
D'ACCORD
127.0.0.1:6379[1]>obtenir k1
(néant)
127.0.0.1:6379[1]>sélectionner 0 //Passer à la base de données cible 0
D'ACCORD
127.0.0.1:6379>obtenir k1 //Vérifiez si les données cibles existent
"100"
127.0.0.1:6379>déplacer k1 1 //base de données 0 milieu k1 Déplacer vers la base de données 1 milieu
(entier) 1
127.0.0.1:6379>sélectionner 1 //Passer à la base de données cible 1
D'ACCORD
127.0.0.1:6379[1]>obtenir k1 //Afficher les données déplacées
"100"
127.0.0.1:6379[1]> sélectionner 0
D'ACCORD
127.0.0.1:6379> obtenir k1 //dans la base de données 0 Ne peut pas être consulté dans k1 valeur
(néant)
Pour effacer les données actuelles de la base de données, utilisez FLUSHDB
Implémentation de la commande ; effacer toutes les données de la base de données, utiliser CHASSE D'EAU Implémentation des commandes
Redis Toutes les données sont stockées en mémoire, puis enregistrées de manière asynchrone sur le disque de temps en temps.(C'est appelé“Mode semi-persistant”); Vous pouvez également écrire chaque modification de données dans un ajouter uniquement le fichier (aof)dans(C'est appelé“Mode persistance complète”)。
Puisque les données Redis sont stockées en mémoire, si la persistance n'est pas configurée,Redis Après le redémarrage, toutes les données sont perdues.Il est donc nécessaire d'activerRedis La fonction de persistance enregistre les données sur le disque. Quand. Redis Après un redémarrage, les données peuvent être récupérées à partir du disque.Redis Deux méthodes sont fournies pour la persistance, l'une est RDB（Base de données Redis） Persistance (le principe est de ReidCalendrier de journalisation de la base de données en mémoire décharge sur le disque RDB persistance), l’autre est AOF（ajouter seulement déposer）Persistance (le principe est de Reid Le journal des opérations est écrit dans le fichier en annexe).
La méthode par défaut
La persistance RDB est le processus de génération d'un instantané des données de processus actuelles et de son enregistrement sur le disque dur. Le processus de déclenchement de la persistance RDB est divisé en déclenchement manuel et déclenchement automatique.
Mécanisme de déclenchement : Le déclenchement manuel correspond respectivement aux commandes save et bgsave.
Commande save : bloque le serveur Redis actuel jusqu'à ce que le processus RDB soit terminé. Pour les instances avec une grande quantité de mémoire, cela entraînera un blocage temporel. Non recommandé pour une utilisation dans des environnements en ligne.
Commande bgsave : le processus Redis exécute l'opération fork (fonction utilisée pour créer un processus) pour créer un processus enfant. Le processus de persistance RDB est responsable du processus enfant et se termine automatiquement une fois terminé. Le blocage ne se produit que pendant la phase de fork.
Avantages du RDB :
RDB est un fichier binaire compact et compressé qui représente un instantané des données Redis à un moment donné. Il est très approprié pour la sauvegarde, la copie complète et d'autres scénarios. Par exemple, effectuez une sauvegarde bgsave toutes les 6 heures et copiez le fichier RDB sur la machine distante ou le système de fichiers pour une reprise après sinistre.
Redis charge RDB et récupère les données beaucoup plus rapidement que la méthode AOF.
Inconvénients du RDB :
Les données en mode RDB ne peuvent pas atteindre la persistance en temps réel/persistance de deuxième niveau. Parce que chaque fois que bgsave est exécuté, une opération fork est effectuée pour créer un processus enfant, ce qui est une opération lourde et le coût d'une exécution fréquente est trop élevé.
Les fichiers RDB sont enregistrés dans un format binaire spécifique. Au cours de l'évolution des versions Redis, il existe plusieurs formats de versions RDB. Il existe un problème selon lequel l'ancienne version du service Redis n'est pas compatible avec la nouvelle version du format RDB.
Persistance AOF (append only file) : enregistrez chaque commande d'écriture dans un journal indépendant, puis réexécutez la commande dans le fichier AOF pour restaurer les données au redémarrage. La fonction principale d'AOF est de résoudre le problème de la persistance des données en temps réel. C'est désormais le courant dominant de la persistance Redis.
Critères de choix entre les deux :
Sacrifiez certaines performances en échange d'une plus grande cohérence du cache (AOF），
Lorsque les opérations d'écriture sont fréquentes, n'activez pas la sauvegarde en échange de performances supérieures et attendez une opération manuelle. sauvegarder quand, faites à nouveau une sauvegarde (RDB）
Remarque:
Si un fichier persistant doit être chargé après le redémarrage, les fichiers AOF seront sélectionnés.
Si RDB est activé en premier, puis AOF est activé et que RDB est conservé en premier, le contenu du fichier RDB sera écrasé par AOF.
[root@localhost ~]# vim /etc/redis/6379.conf
Ouvrez 6379.conf Après le fichier, recherchez sauvegarder, vous pouvez voir les informations de configuration comme indiqué ci-dessous.
exister Redis Il existe trois méthodes de synchronisation dans le fichier de configuration, elles sont :
toujours : persistance synchrone, chaque fois que les données changent, elles seront immédiatement écrites sur le disque
everysec : recommandé par défaut, enregistre de manière asynchrone toutes les secondes (valeur par défaut)
non : pas de synchronisation, laissant au système d'exploitation le soin de décider comment synchroniser
Ignorer la dernière instruction potentiellement problématique
[root@localhost ~]#/etc/init.d/redis_6379 redémarrage
pour résoudre AOF Si la taille du fichier continue d'augmenter, les utilisateurs peuvent signaler Redis envoyer BGREWRITEAOFCommande.BGREWRITEAOF La commande sera supprimée via AOF commandes redondantes dans le fichier à remplacer (récrire）AOFfichier, faire AOF Gardez la taille du fichier aussi petite que possible.
127.0.0.1:6379> bgrewriteaof
La réécriture du fichier d'ajout en arrière-plan uniquement a commencé
# Lorsque le journal est BGREWRITEAOF,sipas d'appendfsync lors de la réécritureDéfini sur yes, ce qui signifie que les nouvelles opérations d'écriture ne seront pas synchronisées avec fsync, mais ne seront que temporairement stockées dans le tampon. , pour éviter les conflits d'opération d'E/S disque, attendez que la réécriture soit terminée avant d'écrire. La valeur par défaut dans Redis est non
no-appendfsync-on-rewrite non
# Lorsque la taille actuelle du fichier AOF est deux fois supérieure à celle du fichier AOF lors de la dernière réécriture du journal, l'opération BGREWRITEAOF se produit.
pourcentage de réécriture automatique aof 100
Remarque:
100 fait référence àLe taux de croissance du fichier AOF fait référence au taux de croissance du fichier AOF actuel par rapport à la dernière réécriture.，100 c'est deux fois
#La valeur minimale du fichier AOF actuel pour exécuter la commande BGREWRITEAOF afin d'éviter des BGREWRITEAOF fréquents en raison de la petite taille du fichier au premier démarrage de Reids.
réécriture automatique aof taille minimale 64 Mo
192.168.9.236:7001> mémoire d'informations
used_memory:1210776 #La taille de la mémoire utilisée,en octets
used_memory_human:1.15M # Affichage avec unité,dans M
used_memory_rss:7802880 # Quelle quantité de mémoire Redis occupe-t-il du point de vue du système d'exploitation ?
used_memory_rss_human:7.44M # Affichage avec unité
maxmemory:1073741824 # Taille maximale de la mémoire
maxmemory_human:1.00G # Affichage avec unité
politique de mémoire maximale: Stratégie de recyclage
Ø volatile-lru: il permet Redis Choisissez le moins récemment utilisé dans l'ensemble des données clé Supprimer
Ø volatile-ttl：Supprimer en fonction du délai d'expiration de la clé
Ø volatile-aléatoire: Sélectionnez aléatoirement les données à éliminer de la collecte de données avec un délai d'expiration défini ;
Ø allkeys-lru:utiliser LRU Les algorithmes éliminent les données de tous les ensembles de données ;
Ø allkeys-aléatoire: Sélectionner au hasard les données à éliminer de la collecte de données ;
Ø pas d'éviction: Désactiver l'élimination des données (valeur par défaut)
Remarque:
Définir le délai d'expiration de la clé
expire v1 10
La v1 a un délai d'expiration de 10 secondes
Remarque:
quand Redis Besoin d'en récupérer un en raison de la pression de la mémoire clé heure,Redis La première considération n’est pas de recycler les données les plus anciennes, mais les données les moins récemment utilisées. clé ou sur le point d'expirer clé Choisissez-en un au hasard parmi clé, supprimé de l'ensemble de données
Recherchez le mot-clé requirepass, suivi du mot de passe. Il est commenté par défaut, c'est-à-dire qu'aucun mot de passe n'est requis par défaut, comme suit :
Ouvrez le commentaire, définissez-le comme votre propre mot de passe et redémarrez
Utilisez redis-cli pour vous connecter à redis et exécutez la commande suivante
ensemble de configuration requirepass 123456
Une fois l'exécution terminée, il n'est pas nécessaire de redémarrer. Vous devrez saisir votre mot de passe lorsque vous quitterez le client et vous reconnecterez.
[root@localhost bin]# ./redis-cli -a 123456
[root@localhost bin]# ./redis-cli127.0.0.1:6379> auth 123456
[root@localhost bin]# ./redis-cli -a 123456 arrêt
1) Le mot de passe défini en modifiant le fichier de configuration prendra effet de manière permanente ; le mot de passe défini en utilisant la commande prendra effet temporairement et deviendra invalide après le redémarrage.
2) La modification du mot de passe défini dans le fichier de configuration nécessite un redémarrage pour prendre effet ; utilisez le mot de passe défini par la commande pour prendre effet après vous être déconnecté et reconnecté, et il deviendra invalide après le redémarrage.
3) La priorité de la commande est supérieure à la priorité du fichier de configuration
Il se consacre à la recherche technologique depuis plus de 30 ans et maîtrise divers langages tels que java, linux, javascript, php, css, etc. Il a apporté de nombreuses contributions dans le domaine de l'open source. station de documentation pour les développeurs pour partager certains problèmes de développement technologique pour référence future.
