Python脚本之操作Redis Cluster【三】

最新推荐文章于 2024-05-15 09:41:37 发布
最新推荐文章于 2024-05-15 09:41:37 发布
阅读量730 收藏 9
点赞数 7
分类专栏： 中间件学习 文章标签： python redis
本文为博主原创，未经许可严禁转载。
本文链接：https://blog.csdn.net/zyooooxie/article/details/135485606
版权

本文为博主原创，未经授权，严禁转载及使用。
本文链接：https://blog.csdn.net/zyooooxie/article/details/135485606

之前写了2篇 操作redis集群的 https://blog.csdn.net/zyooooxie/article/details/123760358 、 https://blog.csdn.net/zyooooxie/article/details/112484045 ，这期再分享下 日常我咋用的。

【实际这篇博客推迟发布N个月】

个人博客：https://blog.csdn.net/zyooooxie

【以下所有内容仅为个人项目经历，如有不同，纯属正常】

代码 : redis-py

"""
@blog: https://blog.csdn.net/zyooooxie
@qq: 153132336
@email: zyooooxie@gmail.com
"""

import math
import time
import random

from deprecated import deprecated
from typing import Optional, Union, List

from redis.cluster import RedisCluster
from redis.cluster import ClusterNode
from redis.commands.core import BasicKeyCommands, ListCommands, SetCommands, HashCommands

from user_log import Log


# pip install redis==4.4.1

@deprecated(reason="不推荐使用")
def redis_connect(host: str, port: int, pwd: str):
    """

    :param host:
    :param port:
    :param pwd:
    :return:
    """

    Log.info(f'{host}, {port}, {pwd}')

    from redis import Redis

    r = Redis(host=host, port=port, decode_responses=True, password=pwd, db=0)
    Log.info(r)

    return r


@deprecated(reason="不推荐使用")
def get_cluster_info(host: str, port: int, pwd: str):
    """

    :param host:
    :param port:
    :param pwd:
    :return:
    """

    rc = redis_cluster_connect(host=host, port=port, pwd=pwd)
    Log.info(rc.cluster_nodes())

    master_list = [k for k, v in rc.cluster_nodes().items() if v.get('flags').find('master') != -1]
    Log.info(master_list)

    slots_dict = {k: v.get('slots')[0] for k, v in rc.cluster_nodes().items() if v.get('flags').find('master') != -1}
    Log.info(slots_dict)

    rc.close()

    return master_list, slots_dict, pwd


def get_redis_connection_info(redis_name: str):
    """

    :param redis_name:
    :return:
    """
    from xxx_use.common_functions import read_ini

    redis_config = read_ini('redis.ini').get(redis_name)
    redis_config_dict = dict(redis_config)

    host = redis_config_dict.get('host')
    port = redis_config_dict.get('port')
    pwd = redis_config_dict.get('pwd')

    return host, port, pwd


def redis_cluster_connect(host: str, port: int, pwd: str):
    """

    :param host:
    :param port:
    :param pwd:
    :return:
    """
    Log.info(f'{host}, {port}, {pwd}')

    if random.getrandbits(1):

        nodes = [ClusterNode(host, port)]
        rc = RedisCluster(startup_nodes=nodes, password=pwd, decode_responses=True)

    else:

        rc = RedisCluster(host=host, port=port, password=pwd, decode_responses=True)

    Log.info(rc)
    Log.debug(rc.__dict__)

    return rc


def cluster_get_key_Use_scan_iter(key_name: str, rc: RedisCluster, scan_count: int = 5000,
                                  key_type: str = 'string', only_need_name: bool = False):
    """

    :param key_name:
    :param rc:
    :param scan_count:
    :param key_type:
    :param only_need_name:
    :return:
    """
    assert key_type in ['string', 'hash', 'list', 'set']
    Log.info(key_name)

    res_dict = dict()

    names_generator = rc.scan_iter(match=key_name, count=scan_count)

    for names in names_generator:

        if only_need_name:  # 只要 key

            names_dict = {names: None}
            res_dict.update(names_dict)

        else:
            # key + value

            value = rc.get(names) if key_type == 'string' else (rc.hgetall(names) if key_type == 'hash' else
                                                                (rc.lrange(names, 0, -1) if key_type == 'list'
                                                                 else rc.smembers(names)))
            res_dict.update({names: value})

    Log.info('scan_iter 找到相关key的数量：{}'.format(len(res_dict)))

    # # 和keys命令的结果 做个校验
    # assert len(res_dict) == len(cluster_get_key_Use_KEYS(key_name=key_name, rc=rc))

    rd_copy = res_dict.copy()
    len_rd = 10 if len(rd_copy) > 10 else len(rd_copy)
    Log.info([rd_copy.popitem() for _ in range(len_rd)])

    return res_dict


def cluster_get_key_Use_SCAN(key_name: str, rc: RedisCluster, scan_count: int = 5000,
                             key_type: str = 'string', only_need_name: bool = False):
    """
    只要name时，返回的是 {key_name1：None, key_name2：None} ；要name + value时，返回的是 {key_name1：value1, key_name2：value2}
    :param key_name:
    :param rc:
    :param scan_count:
    :param key_type:
    :param only_need_name:
    :return:
    """
    assert key_type in ['string', 'hash', 'list', 'set']
    Log.info(key_name)

    primary_list = rc.get_primaries()

    res_dict = dict()

    for primary in primary_list:
        Log.debug(primary)

        prc = primary.redis_connection

        cur = 0

        while True:

            cur, names_list = prc.scan(cur, key_name, count=scan_count)

            if only_need_name:  # 只要 key
                names_dict = dict.fromkeys(names_list)
                res_dict.update(names_dict)

            else:  # key + value

                for names in names_list:
                    value = prc.get(names) if key_type == 'string' else (prc.hgetall(names) if key_type == 'hash' else
                                                                         (prc.lrange(names, 0, -1) if key_type == 'list'
                                                                          else prc.smembers(names)))
                    res_dict.update({names: value})

            if not cur:
                break

    Log.info('scan命令 找到相关key的数量：{}'.format(len(res_dict)))

    # # 和keys命令的结果 做个校验
    # assert len(res_dict) == len(cluster_get_key_Use_KEYS(key_name=key_name, rc=rc))

    rd_copy = res_dict.copy()
    len_rd = 10 if len(rd_copy) > 10 else len(rd_copy)
    Log.info([rd_copy.popitem() for _ in range(len_rd)])

    return res_dict


def cluster_get_key_Use_KEYS(key_name: str, rc: RedisCluster, target_nodes: str = RedisCluster.PRIMARIES):
    """

    :param key_name:
    :param rc:
    :param target_nodes:
    :return:
    """

    # keys命令 使用： 只能在测试环境 + 单独业务使用的集群
    data_list = rc.keys(key_name, target_nodes=target_nodes)

    Log.info(f'keys命令 查找到的所有key的数量:{len(data_list)}')
    Log.info(data_list[-10:])

    return data_list


def cluster_unlink_key_Use_SCAN(key_name: str, rc: RedisCluster, scan_count: int = 5000):
    """

    :param key_name:
    :param rc:
    :param scan_count:
    :return:
    """

    res_dict = cluster_get_key_Use_SCAN(key_name=key_name, scan_count=scan_count,
                                        rc=rc, only_need_name=True)

    res_list = list(res_dict.keys())

    cluster_for_execute_command(rc=rc, command='unlink', exe_nums=1000, data=res_list)


def cluster_for_execute_command(rc: RedisCluster, command: str, exe_nums: int, data: List,
                                unpacking: bool = True, **kwargs):
    """
    
    :param rc: 
    :param command: 
    :param exe_nums: 
    :param data: 
    :param unpacking: 
    :param kwargs: 
    :return: 
    """""

    # 集群 操作某个 | 某些 key时，先 计算slot，再 向target node推命令：具体操作命令 + 某个|某些key。

    # 想 直接在某节点 删掉SCAN出来在此节点的 key，报错：CLUSTER_REDIR_CROSS_SLOT

    method = list(BasicKeyCommands.__dict__.keys()) + list(HashCommands.__dict__.keys()) + list(
        ListCommands.__dict__.keys()) + list(SetCommands.__dict__.keys())

    assert command in [m for m in method if m.startswith('__') is False]

    Log.error(command)

    res = list()

    for i in range(math.ceil(len(data) / exe_nums)):
        start = i * exe_nums

        if exe_nums == 1:

            ele = data[start]  # 直接取这个元素

        else:

            ele = data[start: start + exe_nums]

        if unpacking:

            res.append(getattr(rc, command)(*ele, **kwargs))

        else:
            res.append(getattr(rc, command)(ele, **kwargs))

    else:

        Log.info('全部搞完: {}条'.format(len(data)))
        Log.info(res[-10:])

        time.sleep(1)

        return res


if __name__ == '__main__':
    Log.error('🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀')

    rc_m = redis_cluster_connect(*get_redis_connection_info('xie'))

    nums_m = random.randint(10000, 99999)
    insert_nums = 19
    for_ = range(nums_m, nums_m + insert_nums)

    Log.error('🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀')

    # cluster_for_execute_command(rc=rc_m, command='set',
    #                             data=[('TEST_xie_s' + str(i), 'String_value' + str(i)) for i in for_],
    #                             exe_nums=1, ex=3600 * 24 * 7)
    #
    # cluster_for_execute_command(rc=rc_m, command='get',
    #                             data=['TEST_xie_s' + str(i) for i in for_],
    #                             exe_nums=1, unpacking=False)
    #
    # Log.error('🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀')
    #
    # # hset() 执行时，默认 传的是key、value；
    #
    # cluster_for_execute_command(rc=rc_m, command='hset',
    #                             data=[('TEST_xie_h' + str(i), 'h_field', 'Hash_value' + str(i)) for i in for_],
    #                             exe_nums=1)
    #
    # cluster_for_execute_command(rc=rc_m, command='hset',
    #                             data=['TEST_xie_h' + str(i) for i in for_],
    #                             exe_nums=1, unpacking=False, key='h_field相同的', value='h_value相同的')
    #
    # cluster_for_execute_command(rc=rc_m, command='hset',
    #                             data=['TEST_xie_h' + str(i) for i in for_],
    #                             exe_nums=1, unpacking=False,
    #                             mapping={'h_field相同的': 'h_value相同的', 'h_field1': 'h_value1'})
    #
    # cluster_for_execute_command(rc=rc_m, command='hset',
    #                             data=[('TEST_xie_h' + str(i), 'h_field' + str(i), 'H_value' + str(i)) for i in for_],
    #                             exe_nums=1, mapping={'h_field相同的': 'h_value相同的'})
    #
    # Log.info('🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀')
    #
    # # 若是 多个field ，建议:直接对所有key做个循环，使用hset，传mapping。
    # for i in for_:
    #     h_dict = {'hash__' + str(i): 'value__1' + str(i), 'hash' + str(i): 'value' + str(i)}
    #     cluster_for_execute_command(rc=rc_m, command='hset', data=['TEST_xie_h' + str(i)],
    #                                 exe_nums=1, unpacking=False, mapping=h_dict)
    #
    #     cluster_for_execute_command(rc=rc_m, command='hgetall',
    #                                 data=['TEST_xie_h' + str(i)],
    #                                 exe_nums=1, unpacking=False)
    #
    # Log.info('🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀')
    #
    # cluster_for_execute_command(rc=rc_m, command='hgetall',
    #                             data=['TEST_xie_h' + str(i) for i in for_],
    #                             exe_nums=1, unpacking=False)
    #
    # cluster_for_execute_command(rc=rc_m, command='hget',
    #                             data=[('TEST_xie_h' + str(i), 'h_field') for i in for_], exe_nums=1)
    #
    # Log.error('🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀')
    #
    # cluster_for_execute_command(rc=rc_m, command='rpush',
    #                             data=[('TEST_xie_l' + str(i), 'List_value' + str(i), 'lv1', 'lv2') for i in for_],
    #                             exe_nums=1)
    #
    # cluster_for_execute_command(rc=rc_m, command='lrange',
    #                             data=['TEST_xie_l' + str(i) for i in for_],
    #                             exe_nums=1, unpacking=False, start=0, end=-1)
    #
    # cluster_for_execute_command(rc=rc_m, command='lrange',
    #                             data=[('TEST_xie_l' + str(i), 0, -1) for i in for_],
    #                             exe_nums=1)

    # Log.error('🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀')
    #
    # cluster_for_execute_command(rc=rc_m, command='sadd',
    #                             data=[('TEST_xie_set' + str(i), 'sv_' + str(i), 'sv1', 'sv2', 'sv3') for i in for_],
    #                             exe_nums=1)
    #
    # cluster_for_execute_command(rc=rc_m, command='smembers',
    #                             data=['TEST_xie_set' + str(i) for i in for_],
    #                             exe_nums=1, unpacking=False)
    #
    # cluster_for_execute_command(rc=rc_m, command='unlink',
    #                             data=['TEST_xie_set' + str(i) for i in for_],
    #                             exe_nums=50)
    #
    # Log.error('🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀')


    kn_m = 'TEST_xie*'
    cluster_unlink_key_Use_SCAN(key_name=kn_m, rc=rc_m)

    # cluster_get_key_Use_SCAN(key_name=kn_m, rc=rc_m, only_need_name=True)
    # cluster_get_key_Use_scan_iter(key_name=kn_m, rc=rc_m, only_need_name=True)
    #
    # cluster_get_key_Use_SCAN(key_name=kn_m, rc=rc_m)
    # cluster_get_key_Use_scan_iter(key_name=kn_m, rc=rc_m)
    #
    # cluster_get_key_Use_SCAN(key_name=kn_m, rc=rc_m, key_type='hash')
    # cluster_get_key_Use_scan_iter(key_name=kn_m, rc=rc_m, key_type='hash')
    #
    # cluster_get_key_Use_SCAN(key_name=kn_m, rc=rc_m, key_type='list')
    # cluster_get_key_Use_scan_iter(key_name=kn_m, rc=rc_m, key_type='list')
    #
    # cluster_get_key_Use_SCAN(key_name=kn_m, rc=rc_m, key_type='set')
    # cluster_get_key_Use_scan_iter(key_name=kn_m, rc=rc_m, key_type='set')

    rc_m.close()

    Log.error('🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀')

客户端：RedisInsight

https://redis.com/redis-enterprise/redis-insight/

在这里插入图片描述

本文链接：https://blog.csdn.net/zyooooxie/article/details/135485606

个人博客 https://blog.csdn.net/zyooooxie

zyooooxie
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Python 操作Redis集群
未来来
08-21 516
Python 的 Redis 库是不支持集群操作的，推荐库：redis-py-cluster 安装 pip install redis-py-cluster 连接集群并操作set from rediscluster import StrictRedisCluster class RedisCluster(object): # 连接redis集群 def __init__(self, conn_list): self.conn_list = conn_list # 连接列表
python操作redis数据库的三种方法
09-14
主要介绍了python操作redis数据库的三种方法，帮助大家更好的理解和使用python，感兴趣的朋友可以了解下
Python连接redis集群方法
一样学一点
07-18 1912
【代码】Python连接redis集群方法。
推荐使用：redis-py-cluster - 高效的Redis集群客户端
最新发布
gitblog_00007的博客
05-15 457
推荐使用：redis-py-cluster - 高效的Redis集群客户端 项目地址:https://gitcode.com/Grokzen/redis-py-cluster 项目介绍 redis-py-cluster 是一个专为Python设计的高效Redis集群客户端库。它从版本 4.1.0 开始被上游项目 redis-py 吸收并纳入主分支，这意味着如果你正在使用 4.1.0 或更高版本，你...
Python RedisCluster
liqingbing12的专栏
05-17 2264
检查Python 的redis库 pip3 list | grep redis redis 3.5.3 redis-py-cluster 2.1.0 连接Redis集群示例：2.1.0的版本没有StrictRedisCluster #!/home/deploy/.pyenv/shims/python3 #coding = utf-8 from rediscluster import RedisCluster import random def random_str(.
Python脚本之操作Redis Cluster【二】
zyooooxie的博客
01-24 1176
使用 redis-py-cluster 操作集群的key
python 操作redis集群
热门推荐
shykevin的博客
05-23 1万+
python 操作redis集群 一、连接redis集群 python的redis库是不支持集群操作的，推荐库：redis-py-cluster，一直在维护。还有一个rediscluster库，看GitHub上已经很久没更新了。 安装 pip3 install redis-py-cluster 连接redis集群 #...
Python脚本之操作Redis Cluster【一】
zyooooxie的博客
04-01 4278
Redis集群命令、使用 redis-py 操作集群的key
Python库 | rediscluster-0.2.6.tar.gz
03-10
`rediscluster`库允许Python开发者方便地连接到Redis集群，并执行各种操作，如读写数据、执行事务、管理键空间等。在`rediscluster-0.2.6.tar.gz`这个压缩包中，包含了该库的源代码，版本为0.2.6，供开发者们下载和...
python redis 删除key脚本的实例
09-09
from rediscluster import StrictRedisCluster import sys redis_nodes = [ {'host':'192.168.1.63','port':7000}, {'host':'192.168.1.63','port':7001}, {'host':'192.168.1.63','port':7002} ] try: redis...
redis-py-cluster-1.3.5.tar.gz
12-22
from rediscluster import RedisCluster rc = RedisCluster(startup_nodes=[{'host': 'node1', 'port': 7000}], decode_responses=True) rc.set('key', 'value') print(rc.get('key')) ``` 这里，`decode_...
redis-py-cluster:官方redis集群的Python集群客户端。 Redis 3.0+
04-28
redis-py-cluster 该客户端提供了Redis 3.0中添加的Redis集群客户端。 该项目是antirez的redis-rb-cluster的移植版，具有许多附加功能。 原始资源可以在找到 分支master将始终包含已从Pull Requests中合并的最新不稳定/开发代码。 使用master分支上的最新提交需要您自担风险，不能保证master分支上未标记的提交的兼容性或稳定性。 只有master分支上的标记发行版才被认为可以稳定使用。 Python 2兼容性说明 该库遵循我们上游软件包redis-py宣布的更改。 因此，我们将遵循此处所述的相同的python 2.7弃用时间表。 redis-py-cluster 2.1.x将是支持Python 2.7的最后一个主要版本。 2.1.x系列将继续获得支持Python 2的错误修复和安全补丁，直到2020年8月1日。red
redis in action， java+python
04-11
- Redis-Python的高级功能：Pipeline批量操作、Redis模dules（如Redis-Search、Redis-Graph）的使用等。 4. Redis在缓存中的应用 - HTTP缓存：使用Redis缓存动态生成的网页，减少数据库压力，提高响应速度。 - ...
python 连接redis cluster集群使用方法
Robert_27的博客
11-08 1205
redis rediscluster python
python操作Redis集群
qq_15821487的博客
03-02 859
集群介绍 https://www.cnblogs.com/theboy/p/10690838.html 方法一、第三方包实现 参考文档： https://redis-py-cluster.readthedocs.io/en/master/ 参考rep: https://github.com/Grokzen/redis-py-cluster >>> from rediscluster import RedisCluster >>> # Requires at least
python之redis-cluster
zt3032的博客
08-24 1万+
redis有2种部署方式，单点和cluster。 生产中为避免单点故障丢失数据都会部署为cluster，最近有用到python开发涉及到操作redis的操作。简单封装了下，可以在传参的时候确定是连接哪种模式。 需要安装的python插件： redis-2.10.6 （redis-2.10.3 ） redis-py-cluster-1.3.4 详见代码： class myRedis(ob
python rediscluster连接池_利用python操作redis-cluster
weixin_39939904的博客
12-15 1346
In [8]: def redis_cluster():...: redis_nodes = [{'host':'192.168.100.60','port':7000},...: {'host':'192.168.100.60','port':7001},...: {'host':'192.168.100.60'...
REDIS 如何利用python 操作redis 集群 (投稿文章)
sql server的专栏
08-17 964
注明: 此篇文章为投稿文字, 投稿人 闫树爽, (资深程序员, 目前从事REDIS ,MONGODB ,以及数据库运维自动化代码工作)在NOSQL 数据库中的操作,与关系型数据库不同的是,...
PYTHON PIP 安装RedisCluster
05-26
要在Python中使用RedisCluster，你需要先安装RedisPy和RedisClusterPy模块。你可以使用pip安装这两个模块： ``` pip install redis pip install redis-py-cluster ``` 在安装完成之后，你可以在Python中导入Redis...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值