【Linux】canal1.1.7同步MySQL8.0.3和Redis

前言

自MySQL 8.0.3开始,身份验证插件默认使用caching_sha2_password。按照官网的文档执行,在启动时会报错。

本文写了下大致的步骤。

一、MySQL8配置

1. 修改my.cnf

可以 find / -name my.cnf 命令找到这个配置文件

对于自建 MySQL , 需要先开启 Binlog 写入功能,配置 binlog-format 为 ROW 模式,my.cnf 中配置如下

[mysqld]
log-bin=mysql-bin # 开启 binlog
binlog-format=ROW # 选择 ROW 模式
server_id=1 # 配置 MySQL replaction 需要定义,不要和 canal 的 slaveId 重复

2. 重启mysql

systemctl stop mysqld.service
systemctl start mysqld.service

3. 建用户、授权

授权 canal 链接 MySQL 账号具有作为 MySQL slave 的权限

-- 降低密码验证等级
set global validate_password.policy=LOW;
set global validate_password.length=5;
-- 自MySQL 8.0.3开始,身份验证插件默认使用caching_sha2_password
drop user canal;
CREATE USER canal IDENTIFIED WITH mysql_native_password BY 'canal';
GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'canal'@'%';
FLUSH PRIVILEGES;

二、Canal服务端配置

1. 下载

canal下载地址
在这里插入图片描述
上传服务器

# 建立文件夹
mkdir canal
# 解压
tar -xvf canal.deployer-1.1.7-SNAPSHOT.tar.gz -C ./canal/

2. 修改配置

# 进入conf/example目录
cd conf/example
# 修改配置文件
vi instance.properties

在这里插入图片描述

  • slaveId:从节点id,不与1.1节的server_id一样即可
  • address:连接的mysql的ip:port
  • dbUsername/dbPassword:用户名/密码

主要配置这几个即可

3. 启动服务与验证

# 进入bin目录
cd bin
# 启动脚本
sh startup.sh
# 查看启动日志
tail -200f ../logs/example/example.log

在这里插入图片描述
无报错信息即可。

三、Canal客户端编写

Spring Boot集成canal.client获取变更信息,插入Redis

1. yml配置文件添加canal服务端配置信息和Redis信息

canal:
  host: Canal服务端所在服务器IP
  port: 11111
  username: canal
  password: canal
  destination: example
spring:
  redis:
    port: 6379
    host: 
    password: 123456
    database: 1
    lettuce:
       pool:
         min-idle: 0
         max-idle: 8
         max-active: 20

2. 配置pom文件

下面是所需的依赖

<dependency>
    <groupId>com.alibaba.otter</groupId>
    <artifactId>canal.client</artifactId>
    <version>1.1.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
 <dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>fastjson</artifactId>
     <version>1.2.83</version>
 </dependency>

3. 代码

  1. CanalClientProperties 为Canal连接属性
import lombok.Data;
@Data
public class CanalClientProperties {
    private String host;
    private int port;
    private String username;
    private String password;
    private String destination;
}

  1. CanalConfig 为配置类
import java.net.InetSocketAddress;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.client.CanalConnectors;

@Configuration
public class CanalConfig {
    @Bean
    @ConfigurationProperties(prefix = "canal")
    CanalClientProperties canalClientProperties(){
        return new CanalClientProperties();
    }

    @Bean(destroyMethod = "disconnect")
    CanalConnector canalConnector(CanalClientProperties canalClientProperties) {
        // 创建链接
        return CanalConnectors.newSingleConnector(
                new InetSocketAddress(canalClientProperties.getHost(), canalClientProperties.getPort()),
                canalClientProperties.getDestination(), canalClientProperties.getUsername(), canalClientProperties.getPassword());
    }
}

  1. CanalClient为同步监听

TABLE_NAME 限制了读取的表


import java.util.List;

import javax.annotation.Resource;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.protocol.CanalEntry;
import com.alibaba.otter.canal.protocol.Message;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Component
public class CanalClient implements ApplicationRunner {

    @Resource
    private RedisTemplate<String, String> redisTemplate;

    private static final String TABLE_NAME = "storage";
    private static final String PRIMARY_KEY = "c_id";
    private static final String SEPARATOR = ":";

    @Resource
    private CanalConnector canalConnector;

    @Override
    public void run(ApplicationArguments args) {
        this.initCanal();
    }

    public void initCanal() {
        int batchSize = 1000;
        log.info("启动 canal 数据同步...");
        canalConnector.connect();
        canalConnector.subscribe("storage.storage");
        canalConnector.rollback();
        while (true) {
            // 获取指定数量的数据
            Message message = canalConnector.getWithoutAck(batchSize);
            long batchId = message.getId();
            int size = message.getEntries().size();
            if (batchId == -1 || size == 0) {
                try {
                    // 时间间隔1000毫秒
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                syncEntry(message.getEntries());
            }
            canalConnector.ack(batchId); // 提交确认
        }
    }

    private void syncEntry(List<CanalEntry.Entry> entrys) {
        for (CanalEntry.Entry entry : entrys) {
            if (entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONBEGIN
                    || entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONEND) {
                continue;
            }

            CanalEntry.RowChange rowChange;
            try {
                rowChange = CanalEntry.RowChange.parseFrom(entry.getStoreValue());
            } catch (Exception e) {
                throw new RuntimeException("ERROR data:" + entry.toString(), e);
            }

            CanalEntry.EventType eventType = rowChange.getEventType();
            log.info("================> binlog[{}:{}] , name[{},{}] , eventType : {}",
                    entry.getHeader().getLogfileName(), entry.getHeader().getLogfileOffset(),
                    entry.getHeader().getSchemaName(), entry.getHeader().getTableName(),
                    eventType);

            String tableName = entry.getHeader().getTableName();
            if (!TABLE_NAME.equalsIgnoreCase(tableName)) continue;
            for (CanalEntry.RowData rowData : rowChange.getRowDatasList()) {
                if (eventType == CanalEntry.EventType.INSERT) {
                    printColumn(rowData.getAfterColumnsList());
                    redisInsert(tableName, rowData.getAfterColumnsList());
                } else if (eventType == CanalEntry.EventType.UPDATE) {
                    printColumn(rowData.getAfterColumnsList());
                    redisUpdate(tableName, rowData.getAfterColumnsList());
                } else if (eventType == CanalEntry.EventType.DELETE) {
                    printColumn(rowData.getBeforeColumnsList());
                    redisDelete(tableName, rowData.getBeforeColumnsList());
                }
            }
        }
    }

    private void redisInsert(String tableName, List<CanalEntry.Column> columns) {
        JSONObject json = new JSONObject();
        for (CanalEntry.Column column : columns) {
            json.put(column.getName(), column.getValue());
        }
        for (CanalEntry.Column column : columns) {
            if (PRIMARY_KEY.equalsIgnoreCase(column.getName())) {
                String key = tableName + SEPARATOR + column.getValue();
                redisTemplate.opsForValue().set(key, json.toJSONString());
                log.info("redis数据同步新增,key:" + key);
                break;
            }
        }
    }

    private void redisUpdate(String tableName, List<CanalEntry.Column> columns) {
        JSONObject json = new JSONObject();
        for (CanalEntry.Column column : columns) {
            json.put(column.getName(), column.getValue());
        }
        for (CanalEntry.Column column : columns) {
            if (PRIMARY_KEY.equalsIgnoreCase(column.getName())) {
                String key = tableName + SEPARATOR + column.getValue();
                redisTemplate.opsForValue().set(key, json.toJSONString());
                log.info("redis数据同步更新,key:" + key);
                break;
            }
        }
    }

    private void redisDelete(String tableName, List<CanalEntry.Column> columns) {
        for (CanalEntry.Column column : columns) {
            if (PRIMARY_KEY.equalsIgnoreCase(column.getName())) {
                String key = tableName + SEPARATOR + column.getValue();
                redisTemplate.delete(key);
                log.info("redis数据同步删除,key:" + key);
                break;
            }
        }
    }

    private void printColumn(List<CanalEntry.Column> columns) {
        for (CanalEntry.Column column : columns) {
            log.info(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
        }
    }

}


4. MySQL建表storage.storage

建模式与建表

create database storage;
CREATE TABLE storage.storage (
  `c_id` bigint NOT NULL AUTO_INCREMENT,
  `c_commodity_name` varchar(32) NOT NULL,
  `n_count` bigint NOT NULL,
  PRIMARY KEY (`c_id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

5. 启动客户端与验证

启动spring boot项目,修改表数据。查看日志

在这里插入图片描述

参考

  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
### 回答1: 要将MySQL数据同步Redis,您可以使用一个名为“Canal”的工具。Canal是阿里巴巴开源的一款数据变更捕获和同步工具,可以监控MySQL数据库中的数据变化,并将其同步Redis或其他数据存储中。 以下是将MySQL数据同步Redis的一般步骤: 1. 安装和配置Canal,可以参考Canal官方文档。 2. 配置Canal实例,包括MySQLRedis的连接信息、数据过滤规则等。 3. 启动Canal实例,开始监控MySQL数据库的数据变化。 4. 编写处理Canal数据的程序,将数据从Canal获取并同步Redis。 5. 运行处理程序,开始将MySQL数据同步Redis。 需要注意的是,在将MySQL数据同步Redis时,需要考虑数据格式的转换、数据冲突处理等问题,以确保数据的正确性和一致性。 ### 回答2: 在现代的web应用中,通常会使用关系型数据库MySQL来存储数据,而使用Redis来作为缓存数据库,加快应用的响应速度。同时,为了保证数据一致性,需要将MySQL中的数据同步Redis中。这里就介绍下如何使用Canal来实现MySQLRedis的数据同步。 Canal是阿里巴巴开源的一款基于Java开发的数据库同步工具,可以实时监控MySQL数据库的变化,并将变化同步到指定的目的地,如Redis等。以下是步骤: 1、下载Canal 可以从Canal的github仓库中找到最新的release版本,下载解压后,即可使用。同时,需要准备一个MySQL服务器和一个Redis服务器。 2、配置Canal 在Canal的安装目录中,可以找到一个conf文件夹,其中存放着各种配置文件。在这里,我们需要修改instance.properties文件,其中涉及到的参数包括: - canal.instance.master.address:MySQL服务器的地址。 - canal.instance.master.journal.name:MySQL服务器的binlog名称。 - canal.instance.master.position:上次同步MySQL的位置。 - canal.instance.rdb.url:Redis服务器的地址。 - canal.instance.rdb.password:Redis服务器的密码。 3、启动Canal 在安装目录中的bin文件夹中,可以找到canal.sh/canal.bat等启动脚本文件,启动Canal服务。 4、创建同步任务 在Canal的管理界面中,可以创建同步任务,并指定目标同步位置、过滤规则等参数。 5、同步MySQL数据到Redis 启动Canal服务后,即可实时监控MySQL的变化,并将数据同步Redis中。可以在Redis中通过命令行或者客户端工具查看已同步的数据。 以上是使用Canal同步MySQL数据到Redis的基本步骤,需要注意的是,Canal的数据同步可以控制灵活,支持多种过滤规则,可以根据具体需求进行设置。同时,受限于Redis的并发处理能力,当数据量较大时,需要注意Redis设置参数的调整,以充分利用其性能优势。 ### 回答3: Canal是一款用于MySQL数据库日志增量订阅&消费的工具,可以将MySQL数据库的变更事件以Kafka消息队列的形式发布出来,并提供了多种客户端的消费途径。Redis则是一款高性能的非关系型数据库,通常被用作缓存和存储数据结构。 将MySQL数据同步Redis,是一项非常实用的任务。通过使用Canal,我们可以订阅MySQL数据库的变化,并将数据以Kafka消息的形式呈现出来。接着,可以通过编写定制化的程序,按需消费Kafka消息,并将消息中的数据存储到Redis中。 以下是同步MySQL数据到Redis的基本步骤: 1. 启动Canal和Kafka。首先,需要安装Canal和Kafka,并启动两者。启动Canal后,需要创建一个Canal实例来订阅MySQL数据库的变更事件。在这里,我们可以指定订阅特定的数据库、表和事件类型,以便更好地控制数据流。 2. 编写消费者程序。在Canal和Kafka都已启动的情况下,我们需要编写一个Kafka消费者程序,用于消费Canal发送的消息。在消费者程序中,我们可以通过解析Kafka消息体来获取变化的数据,然后将其转换为Redis中的数据格式,并存储到Redis中。 3. 数据格式转换。根据不同的业务需求,我们需要将MySQL中的数据转换成Redis支持的数据格式。例如,在存储关系型数据时,我们可以使用Hash来存储key-value键值对;在存储非关系型数据时,我们可以使用Sorted Set等数据结构。 4. 容错与性能优化。在实际应用场景中,我们还需要考虑各种异常情况的处理。例如,当Redis出现宕机或网络中断等故障时,需要自动进行重试或者将数据存储到其他存储介质中。此外,还需要对程序进行性能优化,以便提高系统的吞吐量和性能表现。 总的来说,通过Canal同步MySQL数据到Redis具有很大的实用价值,可以极大地提高系统的实时性和响应性。但是,该过程涉及比较复杂的流程和技术,需要综合考虑多种因素,才能实现高效可靠的数据同步
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值