Récupération de données après un crash de serveur à l'aide de Redis

Étant donné que redis est stocké en mémoire et fournit des types de stockage de structure de données couramment utilisés dans les langages de programmation généraux, il est souvent utilisé pour le traitement de récupération de données lorsque les serveurs tombent en panne.

Le serveur peut stocker les données qui doivent être enregistrées dans Redis sous forme d'objets JSON lors de certains processus spécifiés, ce que nous appelons souvent des instantanés. Lorsque le serveur est en cours d'exécution, Redis est lu pour déterminer si. il doit être restauré. Les données continuent à être traitées.

Supprimez simplement les données Redis une fois le processus métier terminé.

Redis propose deux méthodes pour exporter les données de la mémoire vers le disque dur pour la sauvegarde des données :

Mode RDB (par défaut)

La persistance du mode RDB se fait par capture instantanée (instantané) Terminé, lorsque certaines conditions sont remplies, Redis capture automatiquement toutes les données de la mémoire et les stocke sur le disque dur. Les conditions de prise d'un instantané peuvent être personnalisées par l'utilisateur dans le fichier de configuration et sont constituées de deux paramètres : l'heure et le nombre de clés modifiées. Un instantané sera pris lorsque le nombre de clés modifiées dans le délai spécifié est supérieur à la valeur spécifiée. RDB est la méthode de persistance par défaut utilisée par redis. Trois conditions ont été prédéfinies dans le fichier de configuration :

save 900 1 # Si au moins 1 clé est modifiée dans les 900 secondes, un instantané sera pris

save 300 10 # Prenez un instantané si au moins 10 clés ont été modifiées dans les 300 secondes

save 60 10000 # Prenez un instantané si au moins 10 000 clés ont été modifiées dans les 60 secondes

Peut exister plusieurs fois. Il existe plusieurs conditions et il existe une relation « OU » entre les conditions. Tant qu'une des conditions est remplie, un instantané est pris. Si vous souhaitez désactiver les instantanés automatiques, supprimez simplement tous les paramètres de sauvegarde.

Redis stockera le fichier d'instantané dans le fichier dump.rdb dans le répertoire actuel (qui peut être consulté par CONFIG GET dir) par défaut. Vous pouvez spécifier le chemin de stockage et le nom du fichier d'instantané en configurant. les paramètres dir et dbfilename respectivement.

Le processus d'implémentation des instantanés par Redis

Redis utilise la fonction fork pour copier une copie (processus enfant) du processus actuel (processus parent)

Le processus parent continue ; pour recevoir et traiter les commandes des clients envoyées depuis le terminal, et le sous-processus commence à écrire les données en mémoire dans un fichier temporaire sur le disque dur

Lorsque le sous-processus écrit toutes les données, il remplacera l'ancien fichier RDB par le fichier temporaire, jusqu'à présent, une opération d'instantané est terminée.

Lors de l'exécution de fork, le système d'exploitation (système d'exploitation de type Unix) utilisera la stratégie de copie sur écriture. Autrement dit, les processus parent et enfant partagent les mêmes données de mémoire au moment où la fonction fork se produit. . Lorsque le processus parent le souhaite Lorsqu'une certaine donnée est modifiée (comme l'exécution d'une commande d'écriture), le système d'exploitation copie la donnée pour s'assurer que les données du processus enfant ne sont pas affectées, donc le nouveau RDB. Le fichier stocke les données de la mémoire au moment où le fork est exécuté.

Redis ne modifiera pas le fichier RDB pendant le processus d'instantané. Il remplacera uniquement l'ancien fichier par un nouveau une fois l'instantané terminé, ce qui signifie que le fichier RDB est terminé à tout moment. Cela nous permet de mettre en œuvre la sauvegarde de la base de données Redis en sauvegardant régulièrement les fichiers RDB. Le fichier RDB est un format binaire compressé (le paramètre rdbcompression peut être configuré pour désactiver la compression afin d'économiser l'utilisation du processeur), de sorte que l'espace occupé sera inférieur à la taille des données dans la mémoire, ce qui facilitera la transmission.

En plus des instantanés automatiques, vous pouvez également envoyer manuellement la commande SAVE ou BGSAVE pour permettre à Redis d'exécuter l'instantané. La différence entre les deux commandes est que la première est exécutée par le processus principal et bloquera les autres requêtes. , tandis que cette dernière sera effectuée via fork Le processus enfant effectue des opérations d'instantané. Une fois Redis démarré, il lira le fichier d'instantané RDB et chargera les données du disque dur vers la mémoire. Ce temps varie en fonction de la taille et de la structure des données et des performances du serveur. Il faut généralement 20 à 30 secondes pour charger un fichier instantané de 1 Go qui enregistre 10 millions de clés de type chaîne en mémoire. La persistance est obtenue via RDB. Une fois Redis terminé anormalement, toutes les données modifiées après le dernier instantané seront perdues. Cela oblige les développeurs à contrôler les éventuelles pertes de données dans une plage acceptable en combinant et en définissant des conditions d'instantané automatique basées sur des scénarios d'application spécifiques. Si les données sont si importantes qu’elles ne peuvent permettre aucune perte, vous pouvez envisager d’utiliser la méthode AOF pour la persistance.

Mode AOF

Par défaut, Redis n'active pas la persistance AOF (ajout de fichier uniquement). Il peut être activé via le paramètre appendonly dans redis.conf :

appendonly yes.

Au démarrage, Redis exécutera les commandes du fichier AOF une par une pour charger les données du disque dur dans la mémoire. La vitesse de chargement sera plus lente que RDB.

Activer AOF. persistance. Chaque fois qu'une commande est exécutée qui modifie les données dans Redis, Redis écrira la commande dans le fichier AOF sur le disque dur. L'emplacement d'enregistrement du fichier AOF est le même que l'emplacement du fichier RDB, les deux sont définis via le paramètre dir. Le nom de fichier par défaut est appendonly.aof, qui peut être modifié via le paramètre appendfilename :

. appendfilename appendonly.aof

Configurer les conditions pour que Redis réécrive automatiquement les fichiers AOF

auto-aof-rewrite-percentage 100 # Lorsque la taille actuelle du fichier AOF dépasse le pourcentage de la taille du fichier AOF pendant la dernière réécriture, elle sera refaite. Réécriture, si elle n'a pas été réécrite auparavant, elle sera basée sur la taille du fichier AOF au démarrage

auto-aof-rewrite-min-size 64mb # L'AOF minimum taille du fichier pouvant être réécrite

Configurez le mécanisme qui oblige le système à actualiser le cache du disque dur après l'écriture d'un fichier AOF

# appendfsync toujours # La synchronisation sera effectuée à chaque fois qu'une écriture est effectuée, ce qui est le plus sûr et le plus lent

appendfsync everysec # Effectue une opération de synchronisation toutes les secondes

# appendfsync no # N'effectue pas activement les opérations de synchronisation, mais s'en remet entièrement au système d'exploitation (c'est-à-dire une fois toutes les 30 secondes), qui est le plus rapide et le plus dangereux

Redis permet d'ouvrir AOF et RDB en même temps, ce qui garantit non seulement la sécurité des données, mais rend également la sauvegarde et d'autres opérations très faciles. Après avoir redémarré Redis à ce moment-là, Redis utilisera le fichier AOF pour restaurer les données, car la persistance AOF peut perdre moins de données

redis = require('redis'),//导入js模块
RDS_PORT = ,        //端口号
RDS_HOST = '',    //服务器IP
RDS_OPTS = {},            //设置项
redisdb = redis.createClient(RDS_PORT, RDS_HOST, RDS_OPTS);//创建连接
 
redisdb.select(20);//指定分区库
 
redisdb.on('ready', function (res) {
    console.log('ready');
});
 
redisdb.on('connect', function () {
    console.log('connect');
});
exports.redisdb = redisdb;
 
function redis_opt(opt, key, value, callback) {
 
    if (opt == 'get') {
        redisdb.get(key, function (err, data) {
            if (err == null) {
                callback(data);
            }
            else {
                callback(err);
            }
        });
    }
    else if (opt == 'set')
    {
        redisdb.set(key,value, function (err,result) {
            if (err == null) {
                callback(result);
            }
            else {
                callback(err);
            }
        });
    }
    else if (opt == 'del')
    {
        redisdb.del(key, function (err, result) {
            if (err == null) {
                callback(result);
            }
            else {
                callback(err);
            }
        });
    }
    else
    {
        callback("error opt!");
    }
    
}
 
function update(key)
{
    redis_opt("get", key, null, function (data) {
        console.log("the redis data is " + data);
        if (data) {
            count = parseInt(data);
            redis_opt("set", key, ++count , function (data) {
                console.log("set " + count  + " " + data);
            });  
        }
        else {
            redis_opt("set", key, 10000, function (data) {
                console.log("set " + 10000 + " " + data);
            });  
        }
    });
 
 
 
 
 
    
 
 
   
 
 
}
 
function clear(key)
{
    redis_opt("del", key, null, function (ret) {
        console.log("del " + key + " " + ret);
    });  
}
 
 
 
function main()
{
 
    var key = "count_test";
 
    setInterval(function () { clear(key) }, 5000);
 
    setInterval(function () { update(key) }, 1000);
 
}
 
 
 
 
//testmain();
 
 
main();

Le code ci-dessus est une simple fonction de minuterie, c'est-à-dire qu'il est lu régulièrement après le Le serveur est démarré. Les données redis sont modifiées de manière cumulative si elles existent, et initialisées si elles n'existent pas. En même temps, pour faciliter l'explication, une minuterie est définie pour supprimer les données régulièrement.

Pour plus de connaissances sur Redis, veuillez faire attention à la colonne Tutoriel d'introduction à Redis.

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!