标签 redis 下的文章

2024-09-06

所有,数据库

MySQL、Redis 和 SQLite 是三种不同类型的数据库，它们各自有自己的特点和用途。

MySQL: MySQL 是一个关系型数据库管理系统，被广泛应用于企业级应用开发。它支持复杂的操作和Join查询，提供了良好的事务处理、备份和恢复功能。
Redis: Redis 是一个开源的内存中数据结构存储系统，它可以用作数据库、缓存和消息中间件。Redis 支持丰富的数据类型，如字符串、列表、集合、有序集合和哈希表，并提供了持久化选项。
SQLite: SQLite 是一个开源的嵌入式数据库引擎，它实现了多数SQL92标准，非常适合单机应用和小型网络应用。SQLite 主要以文件形式存储数据，并且操作简单，学习成本低。

对比MySQL与Redis：

MySQL支持复杂的事务处理和表连接，而Redis主要是键值对存储和简单操作。
MySQL支持SQL查询，而Redis提供了一种类似于Lua的脚本语言进行操作。
MySQL需要额外的硬件资源，而Redis通常运行在内存中。

对比MySQL与SQLite：

MySQL支持大型数据处理和复杂操作，而SQLite主要适合小型设备和单机应用。
MySQL需要额外的硬件资源和管理，而SQLite通常操作简单，学习成本低。

对比Redis与SQLite：

Redis支持更复杂的数据结构和分布式处理，而SQLite主要适合单机应用。
Redis需要额外的内存资源，而SQLite数据存储在单个文件中。
Redis提供了持久化机制，而SQLite需要手动管理事务。

在选择数据库时，需要考虑应用需求、数据量、可靠性要求、性能要求等因素。

docker安装启动redis 说说那些年遇到的坑

2024-09-06

在使用Docker安装并启动Redis时，可能会遇到的一些常见问题及解决方法如下：

容器启动后立即停止：
- 原因：Redis容器启动后，默认会执行redis-server命令并运行服务，如果没有持久化配置文件或者其他配置问题，可能会导致Redis服务启动后立即停止。
- 解决方法：确保你的Redis配置文件（通常是redis.conf）已正确挂载到容器内部，并且Redis容器的端口映射正确。
无法访问Redis服务：
- 原因：可能是Redis服务没有正确监听在容器的端口上，或者防火墙设置阻止了访问。
- 解决方法：检查容器端口映射是否正确，使用docker ps查看端口映射，确保Redis服务正确监听在内部端口上。如果是防火墙问题，需要开放对应的端口。
配置文件挂载不当：
- 原因：如果你在启动Redis容器时挂载了配置文件，但是路径不正确或者文件权限问题，Redis可能无法正确读取配置文件。
- 解决方法：确保你挂载的配置文件路径正确，并且本地配置文件的权限允许Docker读取。
容器内部无法启动redis-server：
- 原因：可能是因为Docker镜像问题，或者是Redis配置错误。
- 解决方法：检查Docker镜像是否完整，确保Redis配置文件没有错误，可以尝试不挂载配置文件运行Redis容器看是否能正常启动。
容器内部无法访问Redis服务：
- 原因：可能是Redis服务没有正确启动，或者配置的端口不是在监听状态。
- 解决方法：进入容器内部检查Redis服务状态，查看日志，确保Redis服务正常运行，端口监听正确。

以下是一个基本的使用Docker命令启动Redis的例子：




docker run --name myredis -d redis

如果你有自定义的redis.conf，可以使用如下命令挂载配置文件：




docker run --name myredis -v /path/to/your/redis.conf:/usr/local/etc/redis/redis.conf -d redis redis-server /usr/local/etc/redis/redis.conf

请根据实际情况调整命令中的路径和配置。

使用Docker搭建Redis Cluster集群

2024-09-06

以下是使用Docker搭建Redis Cluster的基本步骤和示例配置：

创建docker-compose.yml文件，用于定义Redis Cluster的服务。




version: '3'
 
services:
  redis-node1:
    image: redis:6.0.9
    container_name: redis-node1
    ports:
      - "7001:6379"
    command: redis-server --cluster-enabled yes --cluster-config-file nodes.conf --cluster-node-timeout 5000 --appendonly yes
 
  redis-node2:
    image: redis:6.0.9
    container_name: redis-node2
    ports:
      - "7002:6379"
    command: redis-server --cluster-enabled yes --cluster-config-file nodes.conf --cluster-node-timeout 5000 --appendonly yes
 
  redis-node3:
    image: redis:6.0.9
    container_name: redis-node3
    ports:
      - "7003:6379"
    command: redis-server --cluster-enabled yes --cluster-config-file nodes.conf --cluster-node-timeout 5000 --appendonly yes
 
  redis-node4:
    image: redis:6.0.9
    container_name: redis-node4
    ports:
      - "7004:6379"
    command: redis-server --cluster-enabled yes --cluster-config-file nodes.conf --cluster-node-timeout 5000 --appendonly yes
 
  redis-node5:
    image: redis:6.0.9
    container_name: redis-node5
    ports:
      - "7005:6379"
    command: redis-server --cluster-enabled yes --cluster-config-file nodes.conf --cluster-node-timeout 5000 --appendonly yes
 
  redis-node6:
    image: redis:6.0.9
    container_name: redis-node6
    ports:
      - "7006:6379"
    command: redis-server --cluster-enabled yes --cluster-config-file nodes.conf --cluster-node-timeout 5000 --appendonly yes

在包含docker-compose.yml的目录下运行以下命令来启动Redis Cluster：




docker-compose up -d

使用redis-cli创建Cluster：




docker exec -it redis-node1 redis-cli --cluster create redis-node1:7001 redis-node2:7002 redis-node3:7003 redis-node4:7004 redis-node5:7005 redis-node6:7006 --cluster-replicas 1

确保替换redis-node1:7001, redis-node2:7002, redis-node3:7003, redis-node4:7004, redis-node5:7005, redis-node6:7006为实际的容器名称和端口。--cluster-replicas 1表示为每个主节点创建一个副本。

以上步骤将会启动一个由6个Redis节点组成的Cluster，其中3个主节点和3个副本。

注意：确保Docker和Docker Compose已经安装在您的系统上。

【Redis】Redis使用和RedisTemplate的方法介绍

2024-09-06

在Spring框架中使用Redis，可以通过StringRedisTemplate或RedisTemplate来操作Redis。以下是一些常用方法的示例代码：




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
 
@Component
public class RedisService {
 
    @Autowired
    private StringRedisTemplate redisTemplate;
 
    // 设置键值对
    public void setKey(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }
 
    // 获取键对应的值
    public String getValue(String key) {
        return redisTemplate.opsForValue().get(key);
    }
 
    // 删除键
    public void deleteKey(String key) {
        redisTemplate.delete(key);
    }
 
    // 设置键的过期时间
    public void expireKey(String key, long timeout) {
        redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
    }
 
    // 查询键是否存在
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }
}

在这个例子中，我们定义了一个RedisService组件，它使用StringRedisTemplate来操作Redis。setKey方法用于设置键值对，getValue用于获取键对应的值，deleteKey用于删除键，expireKey用于设置键的过期时间，hasKey用于检查键是否存在。

注意：RedisTemplate可以用于操作其他类型的对象，不仅限于字符串。通过redisTemplate.opsForXxx()方法，你可以获取到对应数据类型的操作对象，如opsForValue()用于字符串操作，opsForList()用于列表操作，opsForSet()用于集合操作，opsForZSet()用于有序集合操作，opsForHash()用于哈希操作等。

Redis的数据加密和解密策略

2024-09-06




#include <stdio.h>
#include <stdlib.com>
#include <string.h>
 
// 假设的密钥，实际应用中需要保管好
#define KEY "secret-key-123"
 
// 加密函数
char* encrypt(char* data) {
    // 这里使用简单的异或加密，实际应用中应该使用更安全的加密算法
    int key_length = strlen(KEY);
    int data_length = strlen(data);
    char* encrypted_data = malloc(data_length + 1); // 加1为了存储空终止符
    for (int i = 0; i < data_length; i++) {
        encrypted_data[i] = data[i] ^ KEY[i % key_length];
    }
    encrypted_data[data_length] = '\0'; // 添加空终止符
    return encrypted_data;
}
 
// 解密函数
char* decrypt(char* encrypted_data) {
    // 解密即为加密的逆运算
    int key_length = strlen(KEY);
    int data_length = strlen(encrypted_data);
    char* data = malloc(data_length + 1); // 加1为了存储空终止符
    for (int i = 0; i < data_length; i++) {
        data[i] = encrypted_data[i] ^ KEY[i % key_length];
    }
    data[data_length] = '\0'; // 添加空终止符
    return data;
}
 
int main() {
    // 测试数据
    char* original_data = "Hello, World!";
    printf("Original data: %s\n", original_data);
 
    // 加密
    char* encrypted_data = encrypt(original_data);
    printf("Encrypted data: %s\n", encrypted_data);
 
    // 解密
    char* decrypted_data = decrypt(encrypted_data);
    printf("Decrypted data: %s\n", decrypted_data);
 
    // 释放内存
    free(encrypted_data);
    free(decrypted_data);
 
    return 0;
}

这段代码提供了一个简单的数据加密和解密的例子。它使用了一个简单的异或算法进行加密和解密，实际应用中应该使用更安全的加密算法，如AES。注意，密钥（KEY）应该保管好，不应该在代码中硬编码。

linux进行redis的安装并使用RDB进行数据迁移

2024-09-06

在Linux上安装Redis并使用RDB进行数据迁移的步骤如下：

安装Redis：




# 更新包管理器的仓库列表
sudo apt-get update
 
# 安装Redis
sudo apt-get install redis-server

确认Redis是否正在运行：




# 检查Redis服务状态
sudo systemctl status redis-server

使用RDB进行数据迁移：

停止Redis服务：




sudo systemctl stop redis-server

拷贝RDB文件到新的位置（例如：/var/lib/redis/dump.rdb）：




sudo cp /path/to/your/dump.rdb /var/lib/redis/dump.rdb

修改文件权限（如果需要）：




sudo chown redis:redis /var/lib/redis/dump.rdb

重新启动Redis服务：




sudo systemctl start redis-server

验证数据迁移是否成功：
- 连接到Redis CLI：
```
redis-cli
```
- 检查键值：
```
keys *
get your_key
```

请根据你的Linux发行版（如Debian、Ubuntu、CentOS等）和Redis版本调整安装命令。如果你需要使用特定版本的Redis或者更详细的配置，你可能需要从源代码编译安装或者修改默认的配置文件。

2024-09-06




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
 
@Service
public class CachingService {
 
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
 
    @Cacheable(value = "userCache", key = "#id")
    public String getUserById(String id) {
        // 假设这是从数据库中获取用户的实际方法
        return "User_" + id;
    }
 
    // 使用RedisTemplate直接操作缓存
    public void setUserInCache(String id, String user) {
        redisTemplate.opsForValue().set("user_" + id, user);
    }
 
    public void evictUserCache(String id) {
        redisTemplate.delete("user_" + id);
    }
}

这个示例中，我们定义了一个CachingService类，它使用了@Cacheable注解来标记getUserById方法，使其能够利用名为userCache的缓存。同时，我们提供了setUserInCache方法来直接往Redis中设置用户数据，以及evictUserCache方法来从缓存中移除用户数据。这样，开发者可以根据需要选择使用注解驱动的缓存还是直接操作缓存。

2024-09-06

为了在Linux环境下安装Python 3.12.4并运行Redis和MongoDB，你需要执行以下步骤：

安装Python 3.12.4:




# 安装依赖
sudo apt-update
sudo apt install -y build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libsqlite3-dev libreadline-dev libffi-dev wget
 
# 下载Python源码
wget https://www.python.org/ftp/python/3.12.4/Python-3.12.4.tgz
 
# 解压源码
tar -xf Python-3.12.4.tgz
 
# 编译安装
cd Python-3.12.4
./configure --enable-optimizations
make -j `nproc`
sudo make altinstall
 
# 验证安装
python3.12 -V

安装Redis:




# 使用包管理器安装Redis
sudo apt update
sudo apt install redis-server
 
# 启动Redis服务
sudo systemctl start redis-server
 
# 验证Redis是否运行
redis-cli ping

安装MongoDB:




# 导入MongoDB公钥
wget -qO - https://www.mongodb.org/static/pgp/server-5.0.asc | sudo apt-key add -
 
# 创建MongoDB列表文件
echo "deb [ arch=amd64,arm64 ] http://repo.mongodb.org/apt/ubuntu $(lsb_release -cs)/mongodb-org/5.0 main" | sudo tee /etc/apt/sources.list.d/mongodb-org-5.0.list
 
# 更新本地包数据库
sudo apt update
 
# 安装MongoDB包
sudo apt install -y mongodb-org
 
# 启动MongoDB服务
sudo systemctl start mongod
 
# 验证MongoDB是否运行
sudo systemctl status mongod

请注意，在实际环境中，你可能需要处理依赖关系和系统特定的配置细节。上述命令假定你有适当的权限，并且你的Linux发行版是使用apt作为包管理器的Debian或Ubuntu系列。对于其他发行版，如Fedora、CentOS等，你可能需要使用相应的包管理命令，如yum或dnf。

redis数据同步时的过程

2024-09-06

Redis数据同步通常涉及以下几个方面：

主从同步（Replication）：Redis支持主从架构，数据可以从主服务器复制到一个或多个从服务器。
哨兵模式（Sentinel）：哨兵是一个监控主服务器和其从服务器状态的特殊Redis服务器。
自动分区（Cluster）：Redis Cluster通过分区来提供一种自动的数据分布式解决方案。

主从同步过程：

从服务器连接到主服务器，并发送SYNC命令。
主服务器接收到SYNC命令后，开始执行BGSAVE命令生成RDB文件。
主服务器BGSAVE执行完毕后，将RDB文件发送给从服务器。
从服务器接收并载入RDB文件。
主服务器在生成RDB期间的写命令会保存在缓冲区，发送完RDB后发送缓冲区的数据。
从服务器接收并执行这些写命令以对数据进行更新。

示例配置：




# 在从服务器的redis.conf中添加
slaveof <master-ip> <master-port>

哨兵模式工作过程：

哨兵监控主服务器和其从服务器。
当主服务器不能正常服务时，哨兵会根据投票和主观下线状态来选举一个从服务器晋升为新的主服务器。
新的主服务器会被所有其他从服务器更新配置文件，以连接到新主服务器。

示例配置：




# 在哨兵的redis.conf中添加
sentinel monitor mymaster <master-ip> <master-port> <quorum>

Cluster自动分区过程：

节点间通过Gossip协议交换信息。
数据根据一定的算法分布在不同的节点上。
当数据所在的节点不可达时，集群会重新分配这些数据到其他可用节点上。

示例配置：




# 在redis.conf中添加
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout <milliseconds>

以上是Redis数据同步的基本过程和配置示例。实际应用中可能还需要考虑更多配置选项，如集群节点间网络分片、手动分区等。

使用Nginx OpenResty与Redis实现高效IP黑白名单管理

2024-09-06




local redis_host = "127.0.0.1"
local redis_port = 6379
local redis_password = "your_redis_password"
 
-- 初始化Redis连接
local function init_redis(redis_host, redis_port, redis_password)
    local redis = require "resty.redis"
    local red = redis:new()
    red:set_timeout(1000) -- 1 秒超时
 
    local ok, err = red:connect(redis_host, redis_port)
    if not ok then
        return nil, err
    end
 
    if redis_password and redis_password ~= "" then
        ok, err = red:auth(redis_password)
        if not ok then
            return nil, err
        end
    end
 
    return red
end
 
-- 检查IP是否在黑名单中
local function is_ip_blacklisted(red, ip)
    local blacklist_key = "ip_blacklist"
    local is_blacklisted, err = red:sismember(blacklist_key, ip)
    if not is_blacklisted then
        ngx.log(ngx.ERR, "查询Redis出错: ", err)
        return false
    end
    return is_blacklisted == 1
end
 
-- 处理请求
local function handle_request()
    local red, err = init_redis(redis_host, redis_port, redis_password)
    if not red then
        ngx.log(ngx.ERR, "连接Redis失败: ", err)
        return ngx.exit(ngx.HTTP_FORBIDDEN)
    end
 
    local ip = ngx.var.remote_addr
    if is_ip_blacklisted(red, ip) then
        ngx.log(ngx.ERR, "IP ", ip, " 在黑名单中")
        return ngx.exit(ngx.HTTP_FORBIDDEN)
    end
 
    -- 继续其他请求处理逻辑
end
 
handle_request()

这段代码展示了如何使用OpenResty的resty.redis模块来连接Redis，并检查一个IP地址是否在黑名单中。如果IP在黑名单中，请求将被拒绝。这是一个高效的IP黑名单管理方法，适合在API网关或Web服务中使用。