Partir de zéro : comprendre les concepts de base et les usages de Redis

introduction

Redis (Remote Dictionary Server) est une base de données de stockage de paires clé-valeur open source hautes performances. Il est largement utilisé dans des scénarios tels que l'accélération du cache, la gestion des sessions et l'analyse des données en temps réel, et est populaire pour ses excellentes performances et ses diverses structures de données. Ce blog vous emmènera à partir de zéro pour explorer les concepts de base et les utilisations de Redis, y compris la structure des données, l'accélération du cache, la persistance, le déploiement de cluster, etc.

1. Le concept de base de Redis

Redis est un système de stockage de données en mémoire qui prend en charge diverses structures de données, notamment des chaînes, des hachages, des listes, des ensembles et des ensembles triés. Voici une brève introduction à ces structures de données :

1. Cordes

String est la structure de données la plus simple de Redis, elle peut stocker tout type de données, telles que du texte, des nombres, des objets sérialisés, etc. Voici quelques exemples courants de manipulation de chaînes :

# 设置一个键为"username"的字符串值
SET username "alice"

# 获取键为"username"的字符串值
GET username

2. Hachages

Un hachage est une collection de paires clé-valeur, adaptée au stockage des propriétés des objets. Chaque clé correspond à une table de hachage contenant plusieurs champs et valeurs. Voici un exemple:

# 设置一个键为"user:1"的哈希值
HSET user:1 name "Alice"
HSET user:1 age 30

# 获取键为"user:1"的哈希值的特定字段
HGET user:1 name

3. Listes

Une liste est une liste ordonnée de chaînes qui peuvent être insérées et supprimées aux deux extrémités de la liste. Ceci est très utile pour implémenter des scénarios tels que des files d'attente de messages. Voici un exemple:

# 在列表"messages"的右侧插入一条消息
RPUSH messages "Hello, World!"
RPUSH messages "How are you?"

# 从列表"messages"的左侧弹出一条消息
LPOP messages

4. Ensembles

Un ensemble est une collection de chaînes non ordonnées et non répétitives. Il convient au stockage d'un ensemble de valeurs uniques. Voici un exemple:

# 向集合"tags"添加一些标签
SADD tags "redis"
SADD tags "caching"
SADD tags "database"

# 获取集合"tags"中的所有标签
SMEMBERS tags

5. Ensembles triés

Un ensemble ordonné est similaire à un ensemble, mais chaque membre est associé à un score, qui peut être utilisé pour des choses comme les classements. Voici un exemple:

# 向有序集合"leaderboard"添加玩家得分
ZADD leaderboard 100 "Alice"
ZADD leaderboard 150 "Bob"
ZADD leaderboard 200 "Charlie"

# 获取前两名玩家和他们的得分
ZREVRANGE leaderboard 0 1 WITHSCORES

Deuxièmement, l'utilisation de Redis

1. Accélération du cache

L'une des utilisations les plus courantes de Redis est en tant que couche de mise en cache. Les applications peuvent stocker les données fréquemment consultées dans Redis pour augmenter la vitesse de lecture et réduire la charge sur la base de données. Lorsque l'application a besoin de certaines données, elle essaiera d'abord de les obtenir du cache Redis, si elles n'existent pas dans le cache, puis de les obtenir de la base de données et de stocker les données obtenues dans le cache pour une utilisation future. Cette méthode est particulièrement efficace dans les scénarios avec plus de lectures et moins d'écritures.

Étapes détaillées et exemples de code :

1.1 Initialiser la connexion Redis :

Une bibliothèque cliente Redis appropriée doit être utilisée pour se connecter au serveur Redis. En Java, cela peut être réalisé en utilisant la bibliothèque cliente Jedis.

import redis.clients.jedis.Jedis;

// 连接到本地的Redis服务器
Jedis jedis = new Jedis("localhost");

1.2 Cache de requête :

Avant d'essayer d'obtenir des données de la base de données, vérifiez si les données requises existent dans le cache.

String userId = "123";
String cachedData = jedis.get("user:" + userId);
if (cachedData != null) {
    
    
    // 数据存在于缓存中，直接返回
    return cachedData;
}

1.3 Interrogez la base de données :

Si les données n'existent pas dans le cache, les données sont interrogées à partir de la base de données.

String userData = fetchDataFromDatabase(userId);

1.4 Stocker dans le cache :

Stockez les données extraites de la base de données dans le cache Redis pour une utilisation future.

jedis.setex("user:" + userId, 3600, userData);

2. Persistance

En ce qui concerne la persistance Redis, il existe deux méthodes principales : RDB (base de données Redis) et AOF (fichier d'ajout uniquement). L'objectif principal de la persistance est de restaurer les données et d'empêcher la perte de données après le redémarrage du serveur Redis. Ce qui suit présentera ces deux méthodes de persistance et les méthodes de configuration en détail.

2.1 Persistance RDB (base de données Redis)

La persistance RDB est obtenue en écrivant périodiquement des instantanés d'ensembles de données Redis sur le disque. Ces instantanés contiennent une copie des données à un certain moment. Vous pouvez configurer la persistance RDB dans le fichier de configuration Redis.

Voici un exemple de configuration pour la persistance RDB :

# 使用RDB持久化
save 900 1        # 在900秒内，如果至少有1个键被更改，则进行快照
save 300 10       # 在300秒内，如果至少有10个键被更改，则进行快照
save 60 10000     # 在60秒内，如果至少有10000个键被更改，则进行快照

Dans la configuration ci-dessus, savela directive définit que dans l'intervalle de temps spécifié, si au moins le nombre de clés spécifié est modifié, l'opération d'instantané sera effectuée. Ces instantanés seront enregistrés dans le système de fichiers du serveur Redis afin qu'ils puissent être chargés après le redémarrage du serveur.

2.2 Persistance d'AOF (Fichier Append-Only)

La persistance AOF est obtenue en enregistrant chaque opération d'écriture. Toutes les écritures sur Redis sont ajoutées à un fichier qui enregistre toutes les écritures qui se sont produites depuis le démarrage du serveur. Lorsque le serveur doit être redémarré, il peut récupérer les données en ré-exécutant ces écritures.

Voici un exemple de configuration de persistance AOF :

# 使用AOF持久化
appendonly yes

Dans la configuration ci-dessus, vous avez activé la persistance AOF en appendonlydéfinissant l'élément de configuration sur .yes

3. Haute disponibilité et déploiement de cluster

Redis peut atteindre une haute disponibilité grâce à la réplication maître-esclave, où un nœud agit en tant que nœud maître pour accepter les opérations d'écriture, et un ou plusieurs nœuds esclaves répliquent les données du nœud maître. De plus, Redis prend également en charge le partage et le mode cluster pour fournir une expansion horizontale et une haute disponibilité. Voici un exemple simple de réplication maître-esclave :

# 主节点配置
bind 127.0.0.1
port 6379
...

# 从节点配置
bind 127.0.0.1
port 6380
slaveof 127.0.0.1 6379

3. Étapes de fonctionnement

Dans cette section, nous détaillerons comment installer, démarrer et faire fonctionner Redis, et comment implémenter l'accélération du cache dans votre application.

1. Installez Redis

L'installation de Redis est très simple, selon votre système d'exploitation, vous pouvez choisir différentes méthodes pour l'installer.

Les étapes d'installation de Redis sont différentes pour les différents systèmes d'exploitation. Voici les étapes d'installation détaillées pour différents systèmes :

Linux (par exemple Ubuntu)

1. Ouvrez un terminal.
2. Mettre à jour la liste des packages :

sudo apt-get update

3. Installez Redis :

sudo apt-get install redis-server

4. Une fois l'installation terminée, Redis démarrera automatiquement en tant que service système.

macOS

1. Ouvrez un terminal.
2. Si vous n'avez pas installé Homebrew, exécutez la commande suivante pour installer Homebrew :

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

3. Installez Redis :

brew install redis

4. Une fois l'installation terminée, vous pouvez démarrer Redis avec la commande suivante :

brew services start redis

les fenêtres

1. Rendez-vous sur la page de téléchargement du site officiel de Redis : https://redis.io/download
2. Dans la section "Programme d'installation MSI pour Windows", téléchargez le programme d'installation MSI approprié pour votre système.
3. Exécutez le programme d'installation téléchargé et suivez les instructions d'installation.
4. Une fois l'installation terminée, vous pouvez trouver le dossier "Redis" dans le menu Démarrer et exécuter "Redis Server" pour démarrer le serveur Redis.

Veuillez choisir la méthode d'installation appropriée en fonction du système d'exploitation que vous utilisez et suivez les étapes ci-dessus. Une fois l'installation terminée, vous pouvez continuer à utiliser Redis en suivant les étapes décrites précédemment.

2. Démarrez le serveur Redis

Ouvrez une fenêtre de terminal et exécutez la commande suivante pour démarrer le serveur Redis :

redis-server

3. Connectez-vous à Redis

Dans une autre fenêtre de terminal, exécutez la commande suivante pour vous connecter au serveur Redis démarré :

redis-cli

4. Essayez différentes opérations de structure de données

Sur la ligne de commande Redis, vous pouvez expérimenter diverses opérations de structure de données telles que les chaînes, les hachages, les listes, les ensembles et les ensembles triés. Voici quelques exemples d'actions :

# 设置一个字符串键值对
SET username "alice"

# 获取字符串键的值
GET username

# 设置一个哈希键的字段和值
HSET user:1 name "Alice"
HSET user:1 age 30

# 获取哈希键的字段值
HGET user:1 name

# 在列表中添加元素
RPUSH messages "Hello, World!"
RPUSH messages "How are you?"

# 弹出列表左侧的元素
LPOP messages

# 向集合中添加元素
SADD tags "redis"
SADD tags "caching"
SADD tags "database"

# 获取集合中的所有元素
SMEMBERS tags

# 向有序集合中添加元素
ZADD leaderboard 100 "Alice"
ZADD leaderboard 150 "Bob"
ZADD leaderboard 200 "Charlie"

# 获取有序集合中的前几名元素
ZREVRANGE leaderboard 0 1 WITHSCORES

5. Persistance de la configuration

Dans le fichier de configuration Redis (généralement redis.conf), vous pouvez configurer la persistance RDB et AOF. En fonction de vos besoins, vous pouvez ajuster la stratégie de sauvegarde du RDB ou permettre à AOF de consigner chaque opération d'écriture. Après avoir modifié le fichier de configuration, assurez-vous de redémarrer le serveur Redis pour que les modifications prennent effet.

6. Réaliser l'accélération du cache

Dans votre application, vous pouvez utiliser la bibliothèque cliente Redis pour vous connecter au serveur Redis et utiliser SET, GET et d'autres commandes, le cas échéant, pour obtenir une accélération du cache de données. En fonction de votre langage de programmation, vous devez choisir une bibliothèque client appropriée, telle que Jedis (Java), redis-py (Python), StackExchange.Redis (C#), etc.

Ce qui précède est une série d'étapes détaillées sur l'installation, le démarrage, la connexion et l'utilisation de Redis. Grâce à une opération pratique, vous aurez une compréhension plus approfondie des concepts de base et de l'utilisation de Redis.

4. Conclusion

En tant que base de données de stockage de mémoire hautes performances, Redis fournit des structures et des fonctions de données riches et convient à divers scénarios d'application. En apprenant les structures de données et les opérations de base et en acquérant une compréhension approfondie de concepts tels que l'accélération du cache, la persistance et la haute disponibilité, vous pouvez mieux utiliser Redis pour améliorer les performances et la fiabilité des applications. J'espère que ce blog pourra vous aider à comprendre les bases et les utilisations de Redis, et à appliquer ce que vous avez appris dans des projets réels.