安装好docker后，在docker上安装MysqL , redis，nacos

1. MysqL

下载镜像

docker pull MysqL:5.7

创建实例并启动

docker run -p 3306:3306 --name MysqL 
-v/mydata/MysqL/log:/var/log/MysqL 
-v/mydata/MysqL/data:/var/lib/MysqL 
-v/mydata/MysqL/conf:/etc/MysqL 
-e MysqL_ROOT_PASSWORD=root 
-d MysqL:5.7

参数说明
-p 3306:3306  将容器的3306端口映射到主机的3306端口
-v/mydata/MysqL/log:/var/log/MysqL   将日志文件挂载到主机
-v/mydata/MysqL/data:/var/lib/MysqL  将数据文件挂载到主机
-v/mydata/MysqL/conf:/etc/MysqL      将配置文件挂载到主机
-e MysqL_ROOT_PASSWORD=root          初始化root用户密码

查看运行中的容器

docker ps 

配置MysqL

vi /mydata/MysqL/conf/my.cnf

[client]
default-character-set=utf8

[MysqL]
default-character-set=utf8

[MysqLId]
init_connect='SET collation_connection=utf8_unicode_ci'
init_connect='SET NAMES utf8'
character-set-server=utf8
collation-server=utf8_unicode_ci
skip-character-set-client-handshake
skie-name-resolve

docker restart MysqL

2. redis

docker pull redis


mkdir -p /mydata/redis/conf

touch /mydata/redis/conf/redis.conf


docker run -p 6379:6379 --name redis 
-v /mydata/redis/data:/data 
-v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf 
-d redis redis-server /etc/redis/redis.conf

//redis持久化配置
vi redis.conf //编辑配置文件
appendonly yes  

3. nacos

docker pull nacos/nacos-server

mkdir -p /root/nacos/init.d /root/nacos/logs

touch /root/nacos/init.d/custom.properties

management.endpoints.web.exposure.include=*

docker run -d -p 8848:8848 
-e MODE=standalone -e PREFER_HOST_MODE=hostname 
-v /root/nacos/init.d/custom.properties:/home/nacos/init.d/custom.properties 
-v /root/nacos/logs:/home/nacos/logs --name nacos nacos/nacos-server

设置开机启动

docker update redis --restart=always

docker update MysqL --restart=always

docker update nacos --restart=always

Canal1.1.4使用RocketMQ同步MySQL到Redis（二）

一、Canal使用RocketMQ同步MySQL

Canal结合RocketMQ同步MySQL

二、 同步数据到Redis

2.1 安装Redis

略

2.2 Redis配置

略

2.3 SpringBoot配置

2.3.1 引入依赖

<dependency>
    <groupId>com.alibaba.otter</groupId>
    <artifactId>canal.client</artifactId>
    <version>1.1.4</version>
</dependency>

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot-starter</artifactId>
    <version>2.0.2</version>
</dependency>

<!-- 根据个人需要依赖 -->
<dependency>
    <groupId>javax.persistence</groupId>
    <artifactId>persistence-api</artifactId>
</dependency>

2.3.2 通用代码

SQLType.java

import lombok.AccessLevel;
import lombok.NoArgsConstructor;

/**
 * Canal监听SQL类型
 *
 * @author Yu
 * @date 2019/09/08 00:18
 **/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class SQLType {

    /**插入*/
    public static final String INSERT = "INSERT";
    /**更新*/
    public static final String UPDATE = "UPDATE";
    /**删除*/
    public static final String DELETE = "DELETE";

}

User.java

import lombok.Data;
import javax.persistence.Id;
import java.io.Serializable;

/**
 * UserPo对象
 *
 * @author Yu
 * @date 2019/09/08 14:13
 **/

@Data
public class User implements Serializable {

    private static final long serialVersionUID = -6845801275112259322L;

    @Id
    private Integer uid;

    private String username;

    private String password;

    private String sex;

}

CanalSynService.java

import com.alibaba.otter.canal.protocol.FlatMessage;
import java.util.Collection;

/**
 * Canal同步服务
 *
 * @author Yu
 * @date 2019/09/08 00:00
 **/

public interface CanalSynService<T> {

    /**
     * 处理数据
     *
     * @param flatMessage CanalMQ数据
     */
    void process(FlatMessage flatMessage);

    /**
     * DDL语句处理
     *
     * @param flatMessage CanalMQ数据
     */
    void ddl(FlatMessage flatMessage);

    /**
     * 插入
     *
     * @param list 新增数据
     */
    void insert(Collection<T> list);

    /**
     * 更新
     *
     * @param list 更新数据
     */
    void update(Collection<T> list);

    /**
     * 删除
     *
     * @param list 删除数据
     */
    void delete(Collection<T> list);

}

AbstractCanalMQ2RedisService.java

import com.alibaba.otter.canal.protocol.FlatMessage;
import com.google.common.collect.Sets;
import com.taco.springcloud.canal.constant.SQLType;
import com.taco.springcloud.core.component.ApplicationContextHolder;
import com.taco.springcloud.core.exception.BizException;
import com.taco.springcloud.core.exception.constants.BaseApiCodeEnum;
import com.taco.springcloud.core.utils.JsonUtil;
import com.taco.springcloud.redis.utils.RedisUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.util.ReflectionUtils;
import javax.annotation.Resource;
import javax.persistence.Id;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.*;


/**
 * 抽象CanalMQ通用处理服务
 *
 * @author Yu
 * @date 2019/09/08 00:05
 **/

@Slf4j
public abstract class AbstractCanalMQ2RedisService<T> implements CanalSynService<T> {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Resource
    private RedisUtils redisUtils;

    private Class<T> cache;

    /**
     * 获取Model名称
     *
     * @return Model名称
     */
    protected abstract String getModelName();

    @Override
    public void process(FlatMessage flatMessage) {

        if(flatMessage.getIsDdl()) {
            ddl(flatMessage);
            return;
        }

        Set<T> data = getData(flatMessage);

        if(SQLType.INSERT.equals(flatMessage.getType())) {
            insert(data);
        }

        if(SQLType.UPDATE.equals(flatMessage.getType())) {
            update(data);
        }

        if(SQLType.DELETE.equals(flatMessage.getType())) {
            delete(data);
        }

    }

    @Override
    public void ddl(FlatMessage flatMessage) {
        //TODO : DDL需要同步，删库清空，更新字段处理

    }

    @Override
    public void insert(Collection<T> list) {
        insertOrUpdate(list);
    }

    @Override
    public void update(Collection<T> list) {
        insertOrUpdate(list);
    }

    private void insertOrUpdate(Collection<T> list) {
        redisTemplate.executePipelined( (RedisConnection redisConnection) -> {
            for (T data : list) {
                String key = getWrapRedisKey(data);
                RedisSerializer keySerializer = redisTemplate.getKeySerializer();
                RedisSerializer valueSerializer = redisTemplate.getValueSerializer();
                redisConnection.set(keySerializer.serialize(key), valueSerializer.serialize(data));
            }
            return null;
        });
    }

    @Override
    public void delete(Collection<T> list) {

        Set<String> keys = Sets.newHashSetWithExpectedSize(list.size());

        for (T data : list) {
            keys.add(getWrapRedisKey(data));
        }

        //Set<String> keys = list.stream().map(this::getWrapRedisKey).collect(Collectors.toSet());
        redisUtils.delAll(keys);
    }

    /**
     * 封装redis的key
     *
     * @param t 原对象
     * @return  key
     */
    protected String getWrapRedisKey(T t) {
        return new StringBuilder()
                        .append(ApplicationContextHolder.getApplicationName())
                        .append(":")
                        .append(getModelName())
                        .append(":")
                        .append(getIdValue(t))
                        .toString();

    }

    /**
     * 获取类泛型
     *
     * @return 泛型Class
     */
    protected Class<T> getTypeArguement() {
        if(cache == null) {
            cache = (Class<T>) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
        }
        return cache;
    }

    /**
     * 获取Object标有@Id注解的字段值
     *
     * @param t 对象
     * @return  id值
     */
    protected Object getIdValue(T t) {
        Field fieldOfId = getIdField();
        ReflectionUtils.makeAccessible(fieldOfId);
        return ReflectionUtils.getField(fieldOfId, t);
    }

    /**
     * 获取Class标有@Id注解的字段名称
     *
     * @return id字段名称
     */
    protected Field getIdField() {

        Class<T> clz = getTypeArguement();
        Field[] fields = clz.getDeclaredFields();
        for (Field field : fields) {
            Id annotation = field.getAnnotation(Id.class);

            if (annotation != null) {
                return field;
            }
        }

        log.error("PO类未设置@Id注解");
        throw new BizException(BaseApiCodeEnum.FAIL);
    }

    /**
     * 转换Canal的FlatMessage中data成泛型对象
     *
     * @param flatMessage   Canal发送MQ信息
     * @return              泛型对象集合
     */
    protected Set<T> getData(FlatMessage flatMessage) {
        List<Map<String, String>> sourceData = flatMessage.getData();
        Set<T> targetData = Sets.newHashSetWithExpectedSize(sourceData.size());
        for (Map<String, String> map : sourceData) {
            T t = JsonUtil.mapConvertPojo(map, getTypeArguement());
            targetData.add(t);
        }
        return targetData;
    }

}

TestUsersConsumer.java

import com.alibaba.otter.canal.protocol.FlatMessage;
import com.taco.springcloud.canal.model.User;
import com.taco.springcloud.canal.service.AbstractCanalMQ2RedisService;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Service;


/**
 * Canal订阅消息
 *
 * @author Yu
 * @date 2019/09/04 23:10
 **/

@Slf4j
@Service
@RocketMQMessageListener(topic = "test_users", consumerGroup = "users")
public class TestUsersConsumer extends AbstractCanalMQ2RedisService<User> implements RocketMQListener<FlatMessage> {

    @Getter
    private String modelName = "user";

    @Override
    public void onMessage(FlatMessage s) {
        process(s);
    }
}

2.3.2 注意事项

代码应该放在Common模块下，需要canal同步服务依赖该模块，继承AbstractCanalMQ2RedisService即可，根据需要可以重写里面的方法，DDL处理暂时还没完成，只是整个Demo，有时间再完善吧。

centos 安装docker mysql redis 及配置

centos环境

一.安装docker

1.设置yum源

yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

2.安装需要的软件

yum install -y yum-utils device-mapper-persistent-data lvm2

3.查看docker版本号及安装

yum list docker-ce --showduplicates | sort -r


yum install docker-ce-18.03.1.ce

4.启动docker 并加入开机自启

systemctl start docker

systemctl enable docker

二.docker下安装mysql8

1.查询mysql镜像

docker search mysql

2.安装mysql，默认安装最新版本，需要指定版本号 docker pull mysql：版本号

docker pull mysql

3.创建挂载目录

mkdir -p /data/docker/mysql/data /data/docker/mysql/logs /data/docker/mysql/conf

4.创建配置文件

cd /data/docker/mysql/conf
vim my.conf

5.配置文件

[mysqld]
pid-file        = /var/run/mysqld/mysqld.pid
socket          = /var/run/mysqld/mysqld.sock
datadir         = /var/lib/mysql
secure-file-priv= NULL
# Disabling symbolic-links is recommended to prevent assorted security risks
symbolic-links=0

# Custom config should go here
# 不区分大小写配置
lower_case_table_names=1
# 解决远程连接慢
skip-name-resolve

6.启动容器

docker run \
-d -p 3306:3306 \
--name mysql8 \
-v /data/docker/mysql/conf:/etc/mysql/conf.d \
-v /data/docker/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root \
--privileged=true \
--restart=always \
mysql

7.登录mysql 并创建用户远程访问及授权

docker exec -it mysql8 bash

mysql -u root -p

CREATE USER ''name''@''%'' IDENTIFIED WITH mysql_native_password BY ''xxxx'';

GRANT ALL PRIVILEGES ON *.* TO ''新用户名''@''%'';

flush privileges;

8.退出容器

ctrl+p+q

三.安装redis

redis 直接安装到服务器了，没有放在docker中

1.下载redis

cd /usr/local

wget http://download.redis.io/releases/redis-6.0.7.tar.gz

2.安装gcc 

yum -y install centos-release-scl
yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++ devtoolset-9-binutils
scl enable devtoolset-9 bash

3.编译

tar -zxvf redis-6.0.7.tar.gz 

cd redis-6.0.7

make

make install

4.配置

vim redis.conf

bind 0.0.0.0
daemonize yes
tcp-keepalive 20

5.设置启动

cd /etc

mkdir redis

cp /usr/local/redis-6.0.7/redis.conf /etc/redis/6379.conf

cp /usr/local/redis-6.0.7/utils/redis_init_script /etc/init.d/redis

cd /etc/init.d

chkconfig redis on

service redis start

今天关于Docker 学习之 mysql 与 redis和二的分享就到这里，希望大家有所收获，若想了解更多关于.NET 6 + EF Core + MySQL + Docker + Identity +MVC 学习笔记 （二）、02.docker安装mysql,redis,nacos、Canal1.1.4使用RocketMQ同步MySQL到Redis（二）、centos 安装docker mysql redis 及配置等相关知识，可以在本站进行查询。