Utiliser Redis pour implémenter le stockage partagé en PHP

Avec le développement continu des applications Internet, la demande de stockage et de traitement de données continue d'augmenter. Cependant, les bases de données relationnelles traditionnelles présentent certains goulots d'étranglement en termes de performances et d'évolutivité. Afin de résoudre ce problème, la base de données NoSQL a vu le jour. Parmi eux, Redis, en tant que base de données NoSQL à haut débit, est largement utilisé dans des domaines tels que la mise en cache, les files d'attente de messages et le stockage clé-valeur. Cet article présentera en détail comment utiliser PHP pour se connecter à Redis et implémenter le stockage fragmenté afin d'améliorer les performances et l'évolutivité en lecture et en écriture.

1. Connaissance de base de Redis

1. Structure de données Redis

Redis prend en charge une variété de structures de données, notamment des chaînes, des tables de hachage, des listes, des ensembles et des ensembles ordonnés, etc. Dans les applications, Redis est généralement utilisé comme cache pour réduire la pression du serveur en mettant en cache les données couramment utilisées.

2. Méthodes de persistance Redis

Redis prend en charge deux méthodes de persistance : RDB et AOF. RDB est implémenté en enregistrant régulièrement les données en mémoire dans des instantanés sur le disque, tandis que AOF enregistre toutes les opérations écrites sur Redis afin qu'elles puissent être réexécutées au redémarrage de Redis.

3. Réplication maître-esclave de Redis

Redis prend en charge la réplication maître-esclave, ce qui peut améliorer efficacement les performances de lecture et la disponibilité. La réplication maître-esclave permet au serveur maître de synchroniser les données avec plusieurs serveurs esclaves, réduisant ainsi la pression sur le serveur maître et améliorant la disponibilité du système. Lorsque le serveur maître tombe en panne, il passe automatiquement au serveur esclave afin que le système puisse récupérer rapidement.

2. PHP se connecte à Redis

Vous pouvez vous connecter à Redis via l'extension PECL ou l'extension Redis intégrée. Ensuite, l’utilisation des deux sera présentée en détail.

1. Extension PECL

L'extension PECL fournit des fonctionnalités plus avancées, telles que le cluster Redis et le mode sentinelle, mais nécessite une compilation et une installation manuelles.

1) Installez l'extension PECL

Vous devez d'abord télécharger l'extension Redis, puis entrer dans le répertoire de l'extension et exécuter la commande suivante :

phpize
./configure
make
make install

2) Connectez-vous à Redis

Pour vous connecter à Redis, vous devez définir le Adresse IP et port du serveur Redis. Une fois la connexion établie, les opérations associées peuvent être effectuées.

$redis = new Redis();
$redis->connect('127.0.0.1', 6379);
$redis->set('name', 'redis');
$name = $redis->get('name');
echo $name;

2. redis extension

redis extension est une extension officielle pour PHP 5.5 et supérieur. Elle est très simple à installer et à utiliser, et ne nécessite pas de compilation ni d'installation manuelle.

1) Installez l'extension redis

Vous pouvez l'installer via yum :

yum install php-redis

Vous pouvez également télécharger le package d'installation manuellement, puis décompresser et installer :

wget https://github.com/phpredis/phpredis/archive/5.2.3.tar.gz
tar -zxvf 5.2.3.tar.gz
cd phpredis-5.2.3
phpize
./configure
make && make install

2) Connectez-vous à Redis

La connexion à Redis nécessite également un paramétrage l'adresse IP et le port du serveur Redis. Une fois la connexion établie, les opérations associées peuvent être effectuées.

$redis = new Redis();
$redis->connect('127.0.0.1', 6379);
$redis->set('name', 'redis');
$name = $redis->get('name');
echo $name;

3. Stockage fragmenté de Redis

Lorsque la quantité de données Redis est très importante, les performances d'un seul nœud peuvent atteindre un goulot d'étranglement. Pour améliorer les performances et la disponibilité, le stockage partagé peut être mis en œuvre en répartissant les données sur plusieurs nœuds.

Le stockage partagé alloue des données à différents nœuds sous différentes formes, et chaque nœud stocke une partie des données. De cette manière, le client peut retrouver les données correspondantes sur chaque nœud en calculant la valeur de hachage de la clé.

1. Hachage cohérent

Le hachage cohérent est un algorithme utilisé pour résoudre le goulot d'étranglement des performances distribuées du cache ou de la base de données. En mappant la valeur de hachage de la clé sur l'anneau, le nœud le plus proche est trouvé dans le sens des aiguilles d'une montre sur l'anneau en tant que nœud de stockage de données. Lors de l'ajout ou de la suppression de nœuds, les nœuds adjacents seront affectés, mais les autres nœuds ne seront pas affectés.

2. Stockage fragmenté de Redis

Le stockage fragmenté de Redis peut être implémenté grâce à des algorithmes de hachage cohérents. Les étapes spécifiques sont les suivantes :

1) Calculez la valeur de hachage de la clé et trouvez le nœud correspondant.

$server = $nodes[crc32($key) % count($nodes)];

2) Connectez-vous au nœud correspondant et effectuez les opérations associées.

$redis = new Redis();
$redis->connect($server['host'], $server['port']);
$redis->set($key, $value);

3) Lorsqu'un nœud est ajouté ou supprimé, la valeur de hachage de la clé peut être recalculée et mappée via l'algorithme de hachage cohérent pour répartir uniformément les données vers les nouveaux nœuds et supprimer les données sur le nœud d'origine.

4. Processus de mise en œuvre

Ci-dessous, nous présenterons en détail comment utiliser PHP pour se connecter à Redis afin d'obtenir un stockage fragmenté.

1. Préparation de l'environnement

L'environnement utilisé dans cette expérience est le suivant :

• Système d'exploitation CentOS 7.6.1810
• PHP 7.2.22
• Redis 3.2.12

2. Télécharger et installer l'extension Redis

wget https://github.com/phpredis/phpredis/archive/5.2.3.tar.gz
tar -zxvf 5.2.3.tar.gz
cd phpredis-5.2.3
phpize
./configure
make && make install

3. Écrivez le code de stockage partagé

Le code pour connecter Redis et implémenter le stockage partagé est le suivant :

<?php

// Redis节点列表
$nodes = array(
    array('host' => '127.0.0.1', 'port' => 6379),
    array('host' => '127.0.0.1', 'port' => 6380),
);

// 计算键的散列值，并找到对应的节点
function getServer($key, $nodes)
{
    $server = $nodes[crc32($key) % count($nodes)];
    return $server;
}

// 连接对应的节点，进行相关操作
function redis($key, $value, $nodes)
{
    $server = getServer($key, $nodes);
    $redis = new Redis();
    $redis->connect($server['host'], $server['port']);
    $redis->set($key, $value);
    return true;
}

// 测试代码
$key = 'name';
$value = 'redis';
redis($key, $value, $nodes);
$name = redis->get($key);
echo $name;

?>

5 Résumé

Cet article explique comment utiliser PHP pour se connecter à Redis et utiliser un algorithme de hachage cohérent. mettre en œuvre un stockage fragmenté pour améliorer les performances et l’évolutivité en lecture et en écriture. En tant que base de données NoSQL à haut débit, Redis est largement utilisé et offre d'excellentes performances et disponibilité. Dans les applications réelles, il est nécessaire de choisir une solution de stockage partitionné appropriée en fonction de circonstances spécifiques et de prêter attention à la compatibilité et à la maintenabilité du problème.

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!