Comment utiliser l'outil de ligne de commande Redis

Exécuter une seule commande

Lors de l'accès au serveur Redis, nous utilisons généralement redis-cli pour entrer en mode interactif, puis lisons et écrivons sur le serveur en posant et en répondant à des questions. Dans ce cas, nous utilisons son "mode interactif". . Il existe un autre "mode direct", qui exécute la commande et obtient les résultats de sortie en transmettant les paramètres de commande directement à redis-cli.

$ redis-cli incrby foo 5<br/>(integer) 5<br/>$ redis-cli incrby foo 5<br/>(integer) 10<br/>

Si le contenu de sortie est volumineux, vous pouvez également rediriger la sortie vers un fichier externe

$ redis-cli info > info.txt<br/>$ wc -l info.txt<br/>     120 info.txt<br/>

Le serveur pointé par la commande ci-dessus est l'adresse du serveur par défaut. Si vous souhaitez pointer vers un serveur spécifique, vous. peut faire ça

// -n 2 表示使用第2个库，相当于 select 2<br/>$ redis-cli -h localhost -p 6379 -n 2 ping<br/>PONG<br/>

Exécuter des commandes par lots

Dans le processus de développement en ligne quotidien, il est parfois inévitable de créer manuellement des données et de les importer dans Redis. Normalement, nous écrivions un script pour ce faire. Mais il existe un autre moyen plus pratique, qui consiste à utiliser directement redis-cli pour exécuter une série d'instructions par lots.

$ cat cmds.txt<br/>set foo1 bar1<br/>set foo2 bar2<br/>set foo3 bar3<br/>......<br/>$ cat cmds.txt | redis-cli<br/>OK<br/>OK<br/>OK<br/>...<br/>

La commande ci-dessus utilise des tubes Unix pour connecter la sortie standard de la commande cat à l'entrée standard de redis-cli. En fait, vous pouvez également utiliser directement la redirection d’entrée pour exécuter des instructions par lots.

$ redis-cli < cmds.txt<br/>OK<br/>OK<br/>OK<br/>...<br/>

set multi-line string

Si une chaîne comporte plusieurs lignes et que vous souhaitez la transmettre à la commande set, comment redis-cli le fait-il ? Vous pouvez utiliser l'option -x, qui utilise le contenu de l'entrée standard comme dernier argument.

$ cat str.txt<br/>Ernest Hemingway once wrote,<br/>"The world is a fine place and worth fighting for."<br/>I agree with the second part.<br/>$ redis-cli -x set foo < str.txt<br/>OK<br/>$ redis-cli get foo<br/>"Ernest Hemingway once wrote,\n\"The world is a fine place and worth fighting for.\"\nI agree with the second part.\n"<br/>

Exécution répétée des instructions

redis-cli prend également en charge l'exécution répétée des instructions plusieurs fois. Définissez un intervalle entre l'exécution de chaque instruction, afin que vous puissiez observer le contenu de sortie d'une certaine instruction changer au fil du temps.

// 间隔1s，执行5次，观察qps的变化<br/>$ redis-cli -r 5 -i 1 info | grep ops<br/>instantaneous_ops_per_sec:43469<br/>instantaneous_ops_per_sec:47460<br/>instantaneous_ops_per_sec:47699<br/>instantaneous_ops_per_sec:46434<br/>instantaneous_ops_per_sec:47216<br/>

Si vous définissez le nombre de fois sur -1, il sera répété un nombre incalculable de fois et exécuté pour toujours. Si le paramètre -i n'est pas fourni, il n'y aura pas d'intervalle et l'exécution sera répétée en continu. Vous pouvez également exécuter des instructions à plusieurs reprises en mode interactif. Le formulaire est plutôt bizarre Ajoutez le nombre de fois devant l'instruction

127.0.0.1:6379> 5 ping<br/>PONG<br/>PONG<br/>PONG<br/>PONG<br/>PONG<br/># 下面的指令很可怕，你的屏幕要愤怒了<br/>127.0.0.1:6379> 10000 info<br/>.......<br/>

Exporter csv

Bien que l'intégralité de la base de données Redis ne puisse pas être exportée seule au format CSV, le résultat d'un une seule commande peut être exportée au format CSV.

$ redis-cli rpush lfoo a b c d e f g<br/>(integer) 7<br/>$ redis-cli --csv lrange lfoo 0 -1<br/>"a","b","c","d","e","f","g"<br/>$ redis-cli hmset hfoo a 1 b 2 c 3 d 4<br/>OK<br/>$ redis-cli --csv hgetall hfoo<br/>"a","1","b","2","c","3","d","4"<br/>

Bien sûr, cette fonction d'export est relativement faible, il s'agit juste d'un tas de chaînes séparées par des virgules. Cependant, vous pouvez combiner l'exécution par lots de commandes pour voir l'effet d'exportation de plusieurs instructions.

$ redis-cli --csv -r 5 hgetall hfoo<br/>"a","1","b","2","c","3","d","4"<br/>"a","1","b","2","c","3","d","4"<br/>"a","1","b","2","c","3","d","4"<br/>"a","1","b","2","c","3","d","4"<br/>"a","1","b","2","c","3","d","4"<br/>

Les lecteurs doivent comprendre après avoir vu cela que l'effet du paramètre --csv est de convertir la sortie une fois et de la séparer par des virgules, rien de plus.

Exécuter le script lua

Dans la section du script lua, nous utilisons l'instruction eval pour exécuter la chaîne de script à chaque fois, le contenu du script est compressé en une chaîne d'une seule ligne, puis l'instruction eval est appelée. et a une mauvaise lisibilité. redis-cli en tient compte et peut exécuter directement des fichiers de script.

127.0.0.1:6379> eval "return redis.pcall(&#39;mset&#39;, KEYS[1], ARGV[1], KEYS[2], ARGV[2])" 2 foo1 foo2 bar1 bar2<br/>OK<br/>127.0.0.1:6379> eval "return redis.pcall(&#39;mget&#39;, KEYS[1], KEYS[2])" 2 foo1 foo2<br/>1) "bar1"<br/>2) "bar2"<br/>

Ci-dessous, nous exécutons les instructions ci-dessus sous la forme d'un script. Le formulaire des paramètres est différent. KEY et ARGV doivent être séparés par des virgules, et il n'est pas nécessaire de fournir le nombre de paramètres KEY. Si votre script Lua est trop long, --eval sera utile.

Surveiller l'état du serveur

Nous pouvons utiliser le paramètre --stat pour surveiller l'état du serveur en temps réel et l'afficher en temps réel toutes les secondes.

$ cat mset.txt<br/>return redis.pcall(&#39;mset&#39;, KEYS[1], ARGV[1], KEYS[2], ARGV[2])<br/>$ cat mget.txt<br/>return redis.pcall(&#39;mget&#39;, KEYS[1], KEYS[2])<br/>$ redis-cli --eval mset.txt foo1 foo2 , bar1 bar2<br/>OK<br/>$ redis-cli --eval mget.txt foo1 foo2<br/>1) "bar1"<br/>2) "bar2"<br/>

Si vous pensez que l'intervalle est trop long ou trop court, vous pouvez utiliser le paramètre -i pour ajuster l'intervalle de sortie.

Scan large KEY

Cette fonction est si pratique que je l'ai essayée en ligne d'innombrables fois. Chaque fois que vous rencontrez un problème de décalage occasionnel dans Redis, la première chose qui vous vient à l'esprit est de savoir s'il existe une grande clé dans l'instance. L'expansion de la mémoire et la libération de la grande clé entraîneront un retard du thread principal. Si vous savez s'il y a une grosse CLÉ à l'intérieur, vous pouvez écrire un programme pour la scanner vous-même, mais c'est trop fastidieux. redis-cli fournit le paramètre --bigkeys pour analyser rapidement les grandes clés dans la mémoire. Utilisez le paramètre -i pour contrôler l'intervalle d'analyse afin d'éviter que la commande scan ne provoque une augmentation soudaine de l'alarme opérationnelle du serveur.

$ redis-cli --stat<br/>------- data ------ --------------------- load -------------------- - child -<br/>keys       mem      clients blocked requests            connections<br/>2          6.66M    100     0       11591628 (+0)       335<br/>2          6.66M    100     0       11653169 (+61541)   335<br/>2          6.66M    100     0       11706550 (+53381)   335<br/>2          6.54M    100     0       11758831 (+52281)   335<br/>2          6.66M    100     0       11803132 (+44301)   335<br/>2          6.66M    100     0       11854183 (+51051)   335<br/>

redis-cli enregistrera la CLÉ avec la plus grande longueur pour chaque type d'objet, l'enregistrement le plus élevé sera affiché immédiatement une fois actualisé. Il peut garantir la sortie de clés d'une longueur de Top1, mais il n'y a aucune garantie que des clés telles que Top2 et Top3 puissent être analysées. Une approche courante consiste à effectuer plusieurs analyses ou à supprimer le mot-clé de priorité la plus élevée, puis à effectuer une nouvelle analyse pour déterminer s'il existe encore des mots-clés de priorité inférieure.

Instructions pour le serveur d'échantillonnage

Il existe désormais un serveur Redis en ligne dont l'OPS est trop élevé. De nombreux modules métiers utilisent ce Redis. Comment pouvons-nous déterminer quelle entreprise est à l'origine de l'OPS anormalement élevé ? À ce stade, vous pouvez échantillonner les instructions du serveur en ligne. En observant les instructions échantillonnées, vous pouvez analyser grossièrement les points commerciaux avec une forte proportion d'OPS. Utilisez la commande Monitor pour afficher toutes les instructions exécutées par le serveur en même temps. A noter que lors de son utilisation, même si l'on souhaite forcer une pause, il faut appuyer sur Ctrl+C, sinon trop d'instructions apparaîtront sur l'écran, qui sera éblouissant et crépitant en un instant.

$ redis-cli --host 192.168.x.x --port 6379 monitor<br/>1539853410.458483 [0 10.100.90.62:34365] "GET" "6yax3eb6etq8:{-7}"<br/>1539853410.459212 [0 10.100.90.61:56659] "PFADD" "growth:dau:20181018" "2klxkimass8w"<br/>1539853410.462938 [0 10.100.90.62:20681] "GET" "6yax3eb6etq8:{-7}"<br/>1539853410.467231 [0 10.100.90.61:40277] "PFADD" "growth:dau:20181018" "2kei0to86ps1"<br/>1539853410.470319 [0 10.100.90.62:34365] "GET" "6yax3eb6etq8:{-7}"<br/>1539853410.473927 [0 10.100.90.61:58128] "GET" "6yax3eb6etq8:{-7}"<br/>1539853410.475712 [0 10.100.90.61:40277] "PFADD" "growth:dau:20181018" "2km8sqhlefpc"<br/>1539853410.477053 [0 10.100.90.62:61292] "GET" "6yax3eb6etq8:{-7}"<br/>

诊断服务器时延

通常我们使用Unix的ping命令来测量两台计算机的延迟。Redis 也提供了时延诊断指令，不过它的原理不太一样，它是诊断当前机器和 Redis 服务器之间的指令(PING指令)时延，它不仅仅是物理网络的时延，还和当前的 Redis 主线程是否忙碌有关。如果你发现 Unix 的 ping 指令时延很小，而 Redis 的时延很大，那说明 Redis 服务器在执行指令时有微弱卡顿。

$ redis-cli --host 192.168.x.x --port 6379 --latency<br/>min: 0, max: 5, avg: 0.08 (305 samples)<br/>

时延单位是 ms。redis-cli 还能显示时延的分布情况，而且是图形化输出。

$ redis-cli --latency-dist<br/>

这个图形的含义作者没有描述，读者们可以尝试破解一下。

远程 rdb 备份

执行下面的命令就可以将远程的 Redis 实例备份到本地机器，远程服务器会执行一次bgsave操作，然后将 rdb 文件传输到客户端。远程 rdb 备份让我们有一种“秀才不出门，全知天下事”的感觉。

$ ./redis-cli --host 192.168.x.x --port 6379 --rdb ./user.rdb<br/>SYNC sent to master, writing 2501265095 bytes to &#39;./user.rdb&#39;<br/>Transfer finished with success.<br/>

模拟从库

如果你想观察主从服务器之间都同步了那些数据，可以使用 redis-cli 模拟从库。

$ ./redis-cli --host 192.168.x.x --port 6379 --slave<br/>SYNC with master, discarding 51778306 bytes of bulk transfer...<br/>SYNC done. Logging commands from master.<br/>...<br/>

从库连上主库的第一件事是全量同步，所以看到上面的指令卡顿这很正常，待首次全量同步完成后，就会输出增量的 aof 日志。

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!