Docker常用中间件安装

高高要努力

于 2024-08-28 14:29:12 发布

阅读量517

点赞数 10

分类专栏： Docker 文章标签： docker 中间件容器

本文链接：https://blog.csdn.net/LG_971124/article/details/141639434

版权

Docker 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一.Nacos安装

1.单机版

单机版不需要Mysql,而是使用Nacos自带的数据库保存配置内容

docker run --name nacos -e MODE=standalone -e JVM_XMS=256m -e JVM_XMX=512m --restart=always --privileged=true -p 9848:9848  -p 9849:9849 -p 8848:8848 -d  nacos/nacos-server:v2.2.0

2.Docker-Compose安装

这种方式需要外部数据库来存储数据库，我们根据官网的步骤来安装，我这里使用的是v.2.0.4,参考：https://github.com/nacos-group/nacos-docker/tree/v2.0.4

首先需要安装一个docker-compose , 下载地址:https://github.com/docker/compose/releases/ ,下载 docker-compose-linux-x86_64 版本即可。
然后上传到linux服务器，然后执行移动命令

mv  docker-compose-linux-x86_64  /usr/local/bin/docker-compose

然后添加执行权限后，测试查看版本

sudo chmod +x /usr/local/bin/docker-compose

docker-compose --version

安装 git ，并下载nacos源码

yum -y install git
git clone https://github.com/nacos-group/nacos-docker.git
cd nacos-docker

如果需要安装基于mysql5.7的nacos，执行下面命令

docker run -id --name=mysql -p 3306:3306 --restart=always  -e MYSQL_ROOT_PASSWORD=123456 --memory=400m mysql:5.7

等待一会儿Nacos就安装好了，默认访问地址：http://ip:8848/nacos/index.html ，默认账号是 nacos、nacos。Mysql的默认账号也是：nacos、nacos
通过Navicat远程连接Mysql，我们可以把事先准备好的SQL脚本导入进去，把默认的表覆盖掉，这样我们就有配置文件了，效果如下：

二.安装RocketMQ

安装RocketMQ我们需要安装nameserver注册中心 ,brocker ,console控制台三个部分

1.安装nameserv

下载rocketmq镜像，这里下载的是 rocketmqinc/rocketmq 的镜像

docker pull rocketmqinc/rocketmq

//注册中心日志和数据目录
mkdir -p /docker/rocketmq/data/namesrv/logs /docker/rocketmq/data/namesrv/store

//broker日志和数据目录、配置文件目录
mkdir -p /docker/rocketmq/data/broker/logs /docker/rocketmq/data/broker/store /docker/rocketmq/conf

docker run -d --restart=always --name rmqnamesrv -p 9876:9876 -v /docker/rocketmq/data/namesrv/logs:/root/logs -v /docker/rocketmq/data/namesrv/store:/root/store -e "MAX_POSSIBLE_HEAP=100000000" rocketmqinc/rocketmq sh mqnamesrv

启动一个容器

-p 9876:9876 : 映射的端口是9876

2.安装Brocker

创建一个配置配置文件,内容如下

vim /docker/rocketmq/conf/broker.conf

terName = DefaultCluster
#broker名称，master和slave使用相同的名称，表明他们的主从关系
brokerName = broker-a
#0表示Master，大于0表示不同的slave
brokerId = 0
#表示几点做消息删除动作，默认是凌晨4点
deleteWhen = 04
#在磁盘上保留消息的时长，单位是小时
fileReservedTime = 48
#有三个值：SYNC_MASTER，ASYNC_MASTER，SLAVE；同步和异步表示Master和Slave之间同步数据的机制；
brokerRole = ASYNC_MASTER
#刷盘策略，取值为：ASYNC_FLUSH，SYNC_FLUSH表示同步刷盘和异步刷盘；SYNC_FLUSH消息写入磁盘后才返回成功状态，ASYNC_FLUSH不需要；
flushDiskType = ASYNC_FLUSH
#设置broker节点所在服务器的ip地址
brokerIP1 = 124.70.38.118

注意这里需要修改IP

启动一个brocker的容器，命令如下

docker run -d  --restart=always --name rmqbroker --link rmqnamesrv:namesrv -p 10911:10911 -p 10909:10909 -v  /docker/rocketmq/data/broker/logs:/root/logs -v  /docker/rocketmq/data/broker/store:/root/store -v /docker/rocketmq/conf/broker.conf:/opt/rocketmq-latest/conf/broker.conf -e "NAMESRV_ADDR=namesrv:9876" -e "MAX_POSSIBLE_HEAP=200000000" rocketmqinc/rocketmq sh mqbroker -c /opt/rocketmq-latest/conf/broker.conf

3.安装控制台

首选需要下载可视化界面console的镜像

docker search rocketmq-console-ng

然后启动一个容器

docker run -d --restart=always --name rmqadmin -e "JAVA_OPTS=-Drocketmq.namesrv.addr=124.70.38.118:9876 -Dcom.rocketmq.sendMessageWithVIPChannel=false" -p 8082:8080 styletang/rocketmq-console-ng

-p 8082:8080 ：控制台端口是：8082

启动测试：http://服务器IP/8082

三.安装Redis

1.下载Redis镜像

这里下载最新版本的Redis镜像，采用命令：docker pull redis 来下载

docker pull redis

2.启动一个redis

docker run -id --name redis -p 6379:6379 --restart=always  --memory=400m redis:latest --requirepass 123456

-p 6379:6379 ：连接端口是6379

--requirepass 123456 ： redis的密码是123456

四.安装Sentinel

1.下载镜像

第一步：下载sentinel-dashboard的镜像，采用命令：docker search sentinel

docker pull bladex/sentinel-dashboard:1.8.0

2.启动容器

第二步：启动sentinel容器，端口指定为：

docker run --name sentinel  -d -p 8858:8858 -p 8719:8719 -d bladex/sentinel-dashboard:1.8.0 -e username=sentinel -e password=sentinel -e server=8.137.78.153:8858

测试访问：http://8.137.78.153:8858,账号为：sentinel /sentinel

spring:
    cloud:
        sentinel:
            transport:
                dashboard: ip:8858
                client-ip: ip
                port: 8719

五.安装MiniIO

1.下载镜像

docker pull minio/minio

2.启动容器

 docker run --name minio -p 9090:9000 -p 9999:9999 -d --restart=always -e "MINIO_ROOT_USER=minioadmin" -e "MINIO_ROOT_PASSWORD=minioadmin123?" -v /home/minio/data:/data -v /home/minio/config:/root/.minio minio/minio server /data --console-address '0.0.0.0:9999'

3.配置权限

六.安装ElasticSearch

1.下载镜像

docker pull elasticsearch:7.9.3

2.启动容器

docker run -id --name=elasticsearch -p 9210:9200 -p 9310:9300 -e "discovery.type=single-node" -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" elasticsearch:7.9.3

discovery.type ：指定为单节点

ES_JAVA_OPTS ：配置jvm，堆的大小

3.启动Kinbana

docker run -id --name=kinana -p 5602:5602 --memory=200m --link elasticsearch:elasticsearch kibana:7.9.3

通过 link指定连接的elasticsearch的名字

七.MongDB安装

1.下载镜像

 docker pull mongo:4.4

2.启动容器

docker run -itd --name mongo  -p 27017:27017 mongo:4.4 --auth

3.创建管理员

docker exec -it mongo mongo admin
db.createUser({ user:'root',pwd:'123456',roles:[ { role:'userAdminAnyDatabase', db: 'admin'},'readWriteAnyDatabase']});

【user:‘root’ 】：设置用户名为root

【pwd:‘123456’】：设置密码为123456

【role:‘userAdminAnyDatabase’】：只在admin数据库中可用，赋予用户所有数据库的userAdmin权限

【db: ‘admin’】：可操作的数据库

【‘readWriteAnyDatabase’】：赋予用户读写权限

4.测试

db.auth('root', '123456');
db.user.insert({"name":"zhangsan","age":18});
db.user.find();

5.Nacacit链接

文件，新建mongodb链接，验证选password

八.XXL-JOB安装

参考文档：分布式任务调度平台XXL-JOB
代码地址：xxl-job: 一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。 - Gitee.com ， sql在 doc/db目录中

1.安装数据库

docker run -id --name=mysql -p 3307:3306 -e MYSQL_ROOT_PASSWORD=123456 --memory=400m mysql:5.7

找到xxl-job 代码，在 doc/db目录中找到sql,执行sql脚本为数据库添加xxl-job相关表

2.安装xxl-job

docker run -e PARAMS="--spring.datasource.url=jdbc:mysql://8.137.114.221:3306/xxl_job?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai --spring.datasource.username=root --spring.datasource.password=123456 --xxl.job.accessToken=default_token" -p 8089:8080 -v /tmp:/data/applogs --name xxl-job -d xuxueli/xxl-job-admin:2.3.1

注意：mysql的ip和端口，用户名，密码和上面要对应，启动xxl-job控制台 http://127.0.0.1:8089/xxl-job-admin/ ,默认密码： admin / 123456
后续操作请参考文档：分布式定时调度-xxl-job_xxl-job定时任务-CSDN博客

注意：如果是开发环境，采用云服务器docker部署的xxl-job，他们本地定时调度服务是需要做内网穿透的，否则调度中心无法访问我们的微服务。如果要本地演示，可以直接下载xxl官网提供的代码来演示。

九.zipkin链路追踪

1.下载并安装zipkin容器

docker run --name zipkin-server -d --restart=always -p 9411:9411 openzipkin/zipkin:2.21.7

2.客户端连接

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zipkin</artifactId>
    <version>2.2.8.RELEASE</version>
</dependency>

yaml配置

spring:
  zipkin:
    base-url: http://ip:9411 #Zipkin服务端地址 ,可以使用ip地址也可以使用服务发现方式。
    discovery-client-enabled: false #如果使用服务发现的方式查找zipkin则打开为true
    sender:
      type: web #使用http方式发送信息给zipkinServer , 还可以使用MQ的方式
  sleuth:
    sampler:
      probability: 1.0

十.ELK安装

1.安装ELK容器

修改虚拟内存 : 安装ELK虚拟内存max_map_count需要大于262144才可以，如果出现下面错误提示就是虚拟内存太小
[1]: max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144] ，通过下面命令修改

vi /etc/sysctl.conf

#添加如下代码
vm.max_map_count=262144

#刷新一下，否则不生效
sysctl -p

vim /etc/security/limits.conf , 添加以下内容，注意要添加在End of file之前，否则报错

* soft nofile 65536
* hard nofile 131072
* soft nproc 2048
* hard nproc 4096

elk是业界认可的微服务日志收集方案，它可以把日志统一收集到ElasticSearch组件中，方便日志查看，排错等，下面是安装ELK容器的命令 https://hub.docker.com/r/sebp/elk

# 下载elk镜像
[root@localhost ~]# docker pull sebp/elk:6.8.22
# 启动ELK容器 ，指定最小内存和最大内存，并映射相关端口
[root@localhost ~]# docker run --name elk --restart always -d -p 5601:5601 -p 9200:9200 -p 9300:9300 -p 5044:5044 -e ES_MIN_MEM=128m -e ES_MAX_MEM=512m sebp/elk:6.8.22

我们还需要对容器中的logstash进行配置，对数据输入和输出做配置

# 进入到ELK容器中
[root@localhost ~]# docker exec -it elk /bin/bash
#修改logstash配置
root@79823af789f6:/#  vim /etc/logstash/conf.d/02-beats-input.conf

编辑文件 /etc/logstash/conf.d/02-beats-input.conf 删掉已有内容，把下面的内容粘贴进去

input{
    tcp{
        port => 5044
        codec=> json_lines
    }
}
output{
    elasticsearch{
        hosts => ["localhost:9200"]
    }
}

大概含义是：

input代表数据输入配置， logstatsh的开放端口是 5044

output代表数据输出配置，输出到elasticsearch, hosts是es的地址localhost:9200

然后退出容器： exit ，重启ELK容器

docker restart elk

2.项目集成ELK

接下来就是微服务把日志收集到ELK服务器了，实现原理就是通过logstash来收集logback日志框架打印的日志，然后发送到云服务器ELK中。首先我们需要导入 logstash 整合 logback 的依赖

<dependency>
  <groupId>net.logstash.logback</groupId>
  <artifactId>logstash-logback-encoder</artifactId>
  <version>5.2</version>
</dependency>

然后为微服务添加日志配置文件 logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
  <include resource="org/springframework/boot/logging/logback/base.xml"/>

  <!--输出到控制台-->
  <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
      <pattern>%d{HH:mm:ss.SSS} %contextName [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
  </appender>

  <appender name="stash" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
    <!--  logstash服务器地址-->
    <destination>192.168.119.129:5044</destination>
    <encoder class="net.logstash.logback.encoder.LogstashEncoder" />
  </appender>


  <root  level="info" additivity="false">
    <appender-ref ref="console"/>
    <appender-ref ref="stash"/>
  </root>

</configuration>

到这里配置完毕，启动程序进行访问，程序就会把日志自动发送到服务器:5044 服务器中。然后我们可以直接通过kibana可视化工具进行分析。这里我们点击：discover 创建 index pattern。

按照timestamp 过滤，在下面窗口选择@timestamp

然后再次点击Discover 就可以看到日志数据

十一.jenkins安装

1.认识jenkins

Jenkins是一个开源的、可扩展的持续集成、交付、部署（软件/代码的编译、打包、部署）的基于web界面的平台。

起源于Hudson（Hudson是商用的），主要用于持续、自动的构建/测试软件项目、监控外部任务的运行（这个比较抽象，暂且写上，不做解释）。

允许持续集成和持续交付项目，无论用的是什么平台，可以处理任何类型的构建或持续集成。

它可以在代码上传仓库（如github,gitee，gitlab）后，在jenkins（一个网站界面）中通过获取代码仓库中最新代码，进行自动化部署，而省去手动打包、上传服务器、部署这一系列步骤，非常方便。

2.安装jenkins

准备jenkins映射的目录

#创建jenkins文件映射目录
mkdir /var/jenkins_home

#给目录设置权限
chmod 777 /var/jenkins_home

执行下面命令启动jenkins容器

docker run --privileged -d --name jenkins -p 7777:8080 -p 8888:8888 -p 50000:50000 \
-v /var/jenkins_home:/var/jenkins_home  \
-v /var/run/docker.sock:/var/run/docker.sock  \
-v $(which docker):/bin/docker jenkins/jenkins:latest-jdk17

-d : 后台运行

-p 8088:8080 : 将容器的8080端口映射到宿主的8088端口

-v /var/jenkins_home:/var/jenkins_home : 将容器中/var/jenkins_home的目录挂载到宿主的/mnt/jenkins_home

-v $(which docker):/bin/docker : 将宿主的docker目录映射到容器内，以便在容器中能使用docker对应的命令完成自动化部署

上面的操作已经将docker相互映射，但在jenkins容器中直接执行docker的命令时，可能会报权限不足。这个问题是容器中的docker是通过docker.sock的方式与宿主的docker通信的，其对应的可执行用户为root。此时我们可以将 /var/run/docker.sock 的权限放开来解决此问题

chmod 777 /var/run/docker.sock

然后在linux机器的 /usr/local/src/jdk 目录安装好JDK，以及在 /usr/local/src/maven 目录安装好maven 请注意版本

3.jenkins初始化

更改jenkins插件下载地址，因为默认是去国外网站下载插件比较慢，而且容易下载失败，我们修改插件下载地址为国内地址

cd /var/jenkins_home

vi hudson.model.UpdateCenter.xml

修改地址为下面的地址

https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json

然后重启jenkins : docker restart jenkins

浏览器访问：http://服务IP:9999/ ，进入jenkins初始化页面。

可以通过：docker logs jenkins 来查看密码，输入密码后，选择：安装推荐的插件

耐心等待安装完成进入下面界面，你可以创建一个新的管理员，或者使用admin账户继续
后面就一直下一步就可以了，安装完成后界面如下

4.安装插件

根据推荐安装好插件后，还需安装一个maven 插件，登录jenkins,找到插件管理
然后在可用插件一栏中，搜索：Maven Integration 插件进行安装

5.全局工具配置

接下来我们对maven做配置，找到 manager jenkins - tools

进去后，找到最下边的maven ，选择自动安装，如下

注意：如果采用jenkins自动安装方式可能会安装不上，我们可以自己解压一个maven到 -v 的目录中，然后设置好权限，比如：我上传了一个maven到linux中，然后他会自动同步到容器中去

然后设置权限

chmod -R 777 /var/jenkins_home/tools/hudson.tasks.Maven_MavenInstallation/apache-maven-3.9.4

然后在全局工具设置出不要使用自动安装，而是指向上传的maven home.

然后保存退出即可

然后来到 : manage jenkins -> 系统配置(sytem) -> 全局属性 -> 添加环境变量如下

Linux的maven环境变量

6.构建项目

回到最外层 - 点击新建 item

选择构建一个自由软件 - 指定构建的项目名，拉后确定

进去之后，找到 源码管理 - 指定你的代码仓库地址，以及添加账号

填好之后往下滚动，找到构建环境 - 选择调用顶层Maven目标。

然后指定maven版本和目标： clean install -Dmaven.test.skip=true 该命令是对项目进行打包

点击保存退出，然后点击立即构建 - 查看构建日志

日志如下 - jenkins从尝试安装maven,然后从git下载代码后，进行： clean install -Dmaven.test.skip=true 命令执行

7.启动项目容器

启动项目的原理是通过Dockerfile构建项目镜像，并自动启动容器，因为我们项目和jenkins在同一台服务器，所以我们用shell脚本运行项目，原理既是通过dockerfile 打包镜像，然后docker运行即可。

我们是把linux的 /var/jenkins_home/workspace 目录映射到 jekins的工作目录的,进入到目录

cd /var/jenkins_home/workspace

在项目根目录新建一个名为Dockerfile的文件，注意没有后缀名，其内容如下:（大致就是使用jdk，把jar包添加到docker然后运行prd配置文件）- 我这里以网关为例

FROM meddream/jdk17:latest
VOLUME /tmp
ADD ./target/app.jar /app.jar
ENV TZ=Asia/Shanghai
EXPOSE 10010
ENTRYPOINT ["java", "-jar", "/app.jar","--spring.profiles.active=dev"]

这个我们可以在代码中编辑好如下-然后推送到Git上，jenkins会自动帮我们下载

然后给pom.xml加上打包插件

<build>
<finalName>app</finalName>
<plugins>
    <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
    <!--docker的maven插件，官网： https://github.com/spotify/docker‐maven‐plugin-->
</plugins>
</build>

接下来我们，修改jenkins任务配置 -
shell脚本如下：

注意：这个 install 目录和构建jenins项目时取的名字保持一样

cd /var/jenkins_home/workspace//blog-server
docker stop blog || true
docker rm blog || true
docker rmi blog || true
docker build -t blog .
docker run -id -p 9527:9527 --name blog blog:latest

解释：

当执行jenins项目构建，jenkins会执行install把我们的代码打包为jar

然后执行上面脚本，脚本通过docker file 来构建镜像并启动容器

然后执行构建，效果如下

然后回到docker，执行：docker ps 查看容器

为了方便理解，下面整理了一个流程图

程序员吧IDEA的代码推送到GIT远程仓库

Jenkins通过Git客户端从Git仓库中拉取最新的代码

Jenkins执行maven命令打包项目：clean install

Jenkins执行脚本，cd到代码目录，执行docker build，根据Dockerfile 构建镜像

执行脚本 docker run 启动容器

十二.SeataServer安装

1.下载镜像

第一步，启动一个docker容器


docker pull seataio/seata-server:1.6.1

docker run -id --name seata-server --restart=always  -p 8091:8091 -p 7091:7091 seataio/seata-server:1.6.1

2.准备配置文件

将seata server中的配置文件(/seata-server/resources)复制到服务器本地,我们要基于已有的配置文件做修改，执行命令

mkdir -p /usr/seata/config
docker cp seata-server:/seata-server/resources /usr/seata/config

这样的话会把seata的配置文件赋值到 /User/seata/config 目录中，我们进去找到application.yaml配置文件进行修改，如下

server:
  port: 7091

spring:
  application:
    name: seata-server

logging:
  config: classpath:logback-spring.xml
  file:
    path: ${user.home}/logs/seata
  extend:
    logstash-appender:
      destination: 127.0.0.1:4560
    kafka-appender:
      bootstrap-servers: 127.0.0.1:9092
      topic: logback_to_logstash

console:
  user:
    username: seata
    password: seata

seata:
  config:
    # support: nacos 、 consul 、 apollo 、 zk  、 etcd3
    type: nacos
    nacos:
      server-addr: 123.60.160.247:8848
      namespace: de930835-fcc8-4ccd-8fcd-59c1f1dea0ed
      group: DEFAULT_GROUP
      username: nacos
      password: nacos
      context-path:
      data-id: seataServer.properties
  registry:
    # support: nacos 、 eureka 、 redis 、 zk  、 consul 、 etcd3 、 sofa
    type: nacos
    preferred-networks: 30.240.*
    nacos:
      application: seata-server
      server-addr: 123.60.160.247:8848
      group: DEFAULT_GROUP #这里指定为默认分组
      namespace: de930835-fcc8-4ccd-8fcd-59c1f1dea0ed
      cluster: default
      username: nacos
      password: nacos
      context-path:
  store:
    # support: file 、 db 、 redis
    mode: file #基于文件存储，就不用管数据库了
    file:
      dir: sessionStore
      max-branch-session-size: 16384
      max-global-session-size: 512
      file-write-buffer-cache-size: 16384
      session-reload-read-size: 100
      flush-disk-mode: async
    db:
      datasource: druid
      db-type: mysql
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://127.0.0.1:3306/drive-seata?rewriteBatchedStatements=true
      user: root
      password: 123456
      min-conn: 10
      max-conn: 100
      global-table: global_table
      branch-table: branch_table
      lock-table: lock_table
      distributed-lock-table: distributed_lock
      query-limit: 1000
      max-wait: 5000
  metrics:
    enabled: false
    registry-type: compact
    exporter-list: prometheus
    exporter-prometheus-port: 9898
  transport:
    rpc-tc-request-timeout: 15000
    enable-tc-server-batch-send-response: false
    shutdown:
      wait: 3
    thread-factory:
      boss-thread-prefix: NettyBoss
      worker-thread-prefix: NettyServerNIOWorker
      boss-thread-size: 1
#  server:
#    service-port: 8091 #If not configured, the default is '${server.port} + 1000'
  security:
    secretKey: SeataSecretKey0c382ef121d778043159209298fd40bf3850a017
    tokenValidityInMilliseconds: 1800000
    ignore:
      urls: /,/**/*.css,/**/*.js,/**/*.html,/**/*.map,/**/*.svg,/**/*.png,/**/*.ico,/console-fe/public/**,/api/v1/auth/login

注意： data-id: seataServer.properties 是nacos中配置文件的名字

3.配置seata的nacos配置文件

seata的nacos配置config.txt地址：https://github.com/seata/seata/blob/2.x/script/config-center/config.txt
在nacos配置中心创建一个配置文件 seataServer.properties ，内容如下：

#For details about configuration items, see https://seata.io/zh-cn/docs/user/configurations.html
#Transport configuration, for client and server
transport.type=TCP
transport.server=NIO
transport.heartbeat=true
transport.enableTmClientBatchSendRequest=false
transport.enableRmClientBatchSendRequest=true
transport.enableTcServerBatchSendResponse=false
transport.rpcRmRequestTimeout=30000
transport.rpcTmRequestTimeout=30000
transport.rpcTcRequestTimeout=30000
transport.threadFactory.bossThreadPrefix=NettyBoss
transport.threadFactory.workerThreadPrefix=NettyServerNIOWorker
transport.threadFactory.serverExecutorThreadPrefix=NettyServerBizHandler
transport.threadFactory.shareBossWorker=false
transport.threadFactory.clientSelectorThreadPrefix=NettyClientSelector
transport.threadFactory.clientSelectorThreadSize=1
transport.threadFactory.clientWorkerThreadPrefix=NettyClientWorkerThread
transport.threadFactory.bossThreadSize=1
transport.threadFactory.workerThreadSize=default
transport.shutdown.wait=3
transport.serialization=seata
transport.compressor=none
#事务组名字
#Transaction routing rules configuration, only for the client #重要这里要和微服务的事务组名一样
service.vgroupMapping.it-drive-service-driver-tx-group=default
service.vgroupMapping.it-drive-service-uaa-tx-group=default
service.vgroupMapping.it-drive-service-customer-tx-group=default

#If you use a registry, you can ignore it
service.default.grouplist=123.60.160.247:8091 #127.0.0.1:8091   重要，这里要改成服务器IP

service.enableDegrade=false
service.disableGlobalTransaction=false

#Transaction rule configuration, only for the client
client.rm.asyncCommitBufferLimit=10000
client.rm.lock.retryInterval=10
client.rm.lock.retryTimes=30
client.rm.lock.retryPolicyBranchRollbackOnConflict=true
client.rm.reportRetryCount=5
client.rm.tableMetaCheckEnable=false
client.rm.tableMetaCheckerInterval=60000
client.rm.sqlParserType=druid
client.rm.reportSuccessEnable=false
client.rm.sagaBranchRegisterEnable=false
client.rm.sagaJsonParser=fastjson
client.rm.tccActionInterceptorOrder=-2147482648
client.rm.sqlParserType=druid
client.tm.commitRetryCount=5
client.tm.rollbackRetryCount=5
client.tm.defaultGlobalTransactionTimeout=60000
client.tm.degradeCheck=false
client.tm.degradeCheckAllowTimes=10
client.tm.degradeCheckPeriod=2000
client.tm.interceptorOrder=-2147482648
client.undo.dataValidation=true
client.undo.logSerialization=jackson
client.undo.onlyCareUpdateColumns=true
server.undo.logSaveDays=7
server.undo.logDeletePeriod=86400000
client.undo.logTable=undo_log
client.undo.compress.enable=true
client.undo.compress.type=zip
client.undo.compress.threshold=64k
#For TCC transaction mode
tcc.fence.logTableName=tcc_fence_log
tcc.fence.cleanPeriod=1h

#Log rule configuration, for client and server
log.exceptionRate=100

#Transaction storage configuration, only for the server. The file, DB, and redis configuration values are optional.
store.mode=file #这里基于文件存储就可以不用创建数据库了
store.lock.mode=file
store.session.mode=file
#Used for password encryption
store.publicKey=

#If `store.mode,store.lock.mode,store.session.mode` are not equal to `file`, you can remove the configuration block.
store.file.dir=file_store/data
store.file.maxBranchSessionSize=16384
store.file.maxGlobalSessionSize=512
store.file.fileWriteBufferCacheSize=16384
store.file.flushDiskMode=async
store.file.sessionReloadReadSize=100

#These configurations are required if the `store mode` is `db`. If `store.mode,store.lock.mode,store.session.mode` are not equal to `db`, you can remove the configuration block.
store.db.datasource=druid
store.db.dbType=mysql
store.db.driverClassName=com.mysql.cj.jdbc.Driver
store.db.url=jdbc:mysql://localhost:3306/drive-seata?useUnicode=true&rewriteBatchedStatements=true
store.db.user=root
store.db.password=123456
store.db.minConn=5
store.db.maxConn=30
store.db.globalTable=global_table
store.db.branchTable=branch_table
store.db.distributedLockTable=distributed_lock
store.db.queryLimit=100
store.db.lockTable=lock_table
store.db.maxWait=5000

#These configurations are required if the `store mode` is `redis`. If `store.mode,store.lock.mode,store.session.mode` are not equal to `redis`, you can remove the configuration block.
store.redis.mode=single
store.redis.single.host=127.0.0.1
store.redis.single.port=6379
store.redis.sentinel.masterName=
store.redis.sentinel.sentinelHosts=
store.redis.maxConn=10
store.redis.minConn=1
store.redis.maxTotal=100
store.redis.database=0
store.redis.password=
store.redis.queryLimit=100

#Transaction rule configuration, only for the server
server.recovery.committingRetryPeriod=1000
server.recovery.asynCommittingRetryPeriod=1000
server.recovery.rollbackingRetryPeriod=1000
server.recovery.timeoutRetryPeriod=1000
server.maxCommitRetryTimeout=-1
server.maxRollbackRetryTimeout=-1
server.rollbackRetryTimeoutUnlockEnable=false
server.distributedLockExpireTime=10000
server.session.branchAsyncQueueSize=5000
server.session.enableBranchAsyncRemove=true

#Metrics configuration, only for the server
metrics.enabled=false
metrics.registryType=compact
metrics.exporterList=prometheus
metrics.exporterPrometheusPort=9898

比较重要的三个地方，必须要注意

service.vgroupMapping.it-drive-service-driver-tx-group=default ： default_tx_group是组名要和项目中的一样

service.default.grouplist=123.60.160.247:8091 : 这个是微服务注册到seata的地址

store.mode=file ：数据存储到数据库 , 并之地数据库的连接配置,默认是file

4.准备数据库

根据步骤三设置的seata数据库地址，执行以下SQL，添加seata所需要的表。如果上面store.mode=file模式就不用指定数据库配置了，db模式需要，执行下面sql创建，在seata的源码script/server/db目录也能找到

-- -------------------------------- The script used when storeMode is 'db' --------------------------------
-- the table to store GlobalSession data
CREATE TABLE IF NOT EXISTS `global_table`
(
  `xid`                       VARCHAR(128) NOT NULL,
  `transaction_id`            BIGINT,
  `status`                    TINYINT      NOT NULL,
  `application_id`            VARCHAR(32),
  `transaction_service_group` VARCHAR(32),
  `transaction_name`          VARCHAR(128),
  `timeout`                   INT,
  `begin_time`                BIGINT,
  `application_data`          VARCHAR(2000),
  `gmt_create`                DATETIME,
  `gmt_modified`              DATETIME,
  PRIMARY KEY (`xid`),
  KEY `idx_status_gmt_modified` (`status` , `gmt_modified`),
  KEY `idx_transaction_id` (`transaction_id`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4;

-- the table to store BranchSession data
CREATE TABLE IF NOT EXISTS `branch_table`
(
  `branch_id`         BIGINT       NOT NULL,
  `xid`               VARCHAR(128) NOT NULL,
  `transaction_id`    BIGINT,
  `resource_group_id` VARCHAR(32),
  `resource_id`       VARCHAR(256),
  `branch_type`       VARCHAR(8),
  `status`            TINYINT,
  `client_id`         VARCHAR(64),
  `application_data`  VARCHAR(2000),
  `gmt_create`        DATETIME(6),
  `gmt_modified`      DATETIME(6),
  PRIMARY KEY (`branch_id`),
  KEY `idx_xid` (`xid`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4;

-- the table to store lock data
CREATE TABLE IF NOT EXISTS `lock_table`
(
  `row_key`        VARCHAR(128) NOT NULL,
  `xid`            VARCHAR(128),
  `transaction_id` BIGINT,
  `branch_id`      BIGINT       NOT NULL,
  `resource_id`    VARCHAR(256),
  `table_name`     VARCHAR(32),
  `pk`             VARCHAR(36),
  `status`         TINYINT      NOT NULL DEFAULT '0' COMMENT '0:locked ,1:rollbacking',
  `gmt_create`     DATETIME,
  `gmt_modified`   DATETIME,
  PRIMARY KEY (`row_key`),
  KEY `idx_status` (`status`),
  KEY `idx_branch_id` (`branch_id`),
  KEY `idx_xid` (`xid`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4;

CREATE TABLE IF NOT EXISTS `distributed_lock`
(
  `lock_key`       CHAR(20) NOT NULL,
  `lock_value`     VARCHAR(20) NOT NULL,
  `expire`         BIGINT,
  primary key (`lock_key`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4;

INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('AsyncCommitting', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('RetryCommitting', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('RetryRollbacking', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('TxTimeoutCheck', ' ', 0);

5.为每个微服务undolog

client端各个服务执行以下SQL语句，添加undo_log表 - 必须要

-- for AT mode you must to init this sql for you business database. the seata server not need it.
CREATE TABLE IF NOT EXISTS `undo_log`
(
    `branch_id`     BIGINT       NOT NULL COMMENT 'branch transaction id',
    `xid`           VARCHAR(128) NOT NULL COMMENT 'global transaction id',
    `context`       VARCHAR(128) NOT NULL COMMENT 'undo_log context,such as serialization',
    `rollback_info` LONGBLOB     NOT NULL COMMENT 'rollback info',
    `log_status`    INT(11)      NOT NULL COMMENT '0:normal status,1:defense status',
    `log_created`   DATETIME(6)  NOT NULL COMMENT 'create datetime',
    `log_modified`  DATETIME(6)  NOT NULL COMMENT 'modify datetime',
    UNIQUE KEY `ux_undo_log` (`xid`, `branch_id`)
) ENGINE = InnoDB
  AUTO_INCREMENT = 1
  DEFAULT CHARSET = utf8mb4 COMMENT ='AT transaction mode undo table';

6.挂载配置文件

挂载配置文件并启动 seata server,将目前正在运行的seata server服务停止并删除后，将配置文件挂载后启动。

docker kill seata-server
docker rm seata-server

docker run -id --name seata-server \
        -p 8091:8091 \
        -p 7091:7091 \
        -e SEATA_IP=123.60.160.247 \
        -v /usr/seata/config/resources:/seata-server/resources  \
        seataio/seata-server:1.6.1;

-e SEATA_IP=123.60.160.247 : 手动指定seata的ip为服务器IP,否则会以默认的IP连接seata会连接不上

-v /usr/seata/config/resources:/seata-server/resources ：把上面修改的配置映射到容器中

另外注意开放 7091 ， 8091的防火墙

7.项目整合Seata

第一步：springcloud整合seata的基础依赖

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
</dependency>

项目的yaml中对seata做配置

这里的tx-service-group: ${spring.application.name}-tx-group要和seataServer.properties中的保持一致

seata:
  enabled: true
  application-id: ${spring.application.name}
  tx-service-group: ${spring.application.name}-tx-group 
  #对应seataServer.properties中的service.vgroupMapping.it-drive-service-driver-tx-group=default
  config:
    type: nacos
    nacos:
      server-addr: ${NACOS_HOST:123.60.160.247}:${NACOS_PORT:8848}
      username: nacos
      password: nacos #账号再nacos管理界面配置
      namespace: de930835-fcc8-4ccd-8fcd-59c1f1dea0ed #取pom.xml中的命名空间
      data-id: seataServer.properties
      group: DEFAULT_GROUP #重要，和seataServer.properties保持一样
  registry:
    type: nacos
    nacos:
      application: seata-server
      server-addr: ${NACOS_HOST:123.60.160.247}:${NACOS_PORT:8848}
      username: nacos
      password: nacos #账号再nacos管理界面配置
      namespace: de930835-fcc8-4ccd-8fcd-59c1f1dea0ed #取pom.xml中的命名空间
      group: DEFAULT_GROUP
  enable-auto-data-source-proxy: true #开启seata的datasource自动代理

在启动类贴注解开启seata ，因为yaml做了配置，下面注解可以不要

@EnableAutoDataSourceProxy(dataSourceProxyMode="AT",useJdkProxy=false)

开启全局事务,在入口方法贴注解

注意：只在业务入口的微服务的方法上贴即可

@GlobalTransactional(name = "driver-wechat-register",rollbackFor = Exception.class)

另外其他的事务参与服务也照着配置就行

高高要努力

关注

10
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
Docker常用中间件安装

记录docker学习
复制链接

扫一扫

专栏目录