软件安装文档

虚拟机安装

虚拟机账号root密码123456

安装完成后，我们把IP设置为192.168.211.130，此时需要修改网卡配置：

#编辑文件
vi /etc/sysconfig/network-scripts/ifcfg-ens33

#修改配置如下：
TYPE=Ethernet
PROXY_METHOD=none
BROWSER_ONLY=no
BOOTPROTO=static
DEFROUTE=yes
IPV4_FAILURE_FATAL=no
IPV6INIT=yes
IPV6_AUTOCONF=yes
IPV6_DEFROUTE=yes
IPV6_FAILURE_FATAL=no
IPV6_ADDR_GEN_MODE=stable-privacy
NAME=ens33
UUID=17a66726-0303-4d70-bf76-545ff501191b
DEVICE=ens33
ONBOOT=yes
IPADDR=192.168.211.130
GATEWAY=192.168.211.2
DNS1=114.114.114.114

#重启服务或者重启网卡
reboot

开发环境一般建议关闭防火墙：

#关闭防火墙
systemctl stop firewalld.service

#禁止防火墙开机启动
systemctl disable firewalld.service

系统死锁问题

kernel:NMI watchdog: BUG: soft lockup - CPU#4 stuck for 35s! [kworker/4:2:530]

出现如上问题，其实是一种死锁问题，大概是这个意思：这个bug没有让系统彻底死机，但是若干个进程(或者kernel thread)被锁死在了某个状态(一般在内核区域)，很多情况下这个是由于内核锁的使用的问题。

这个会导致系统卡顿甚至连不上，这个问题解决也简单，执行如下命令即可解决：

echo 30 > /proc/sys/kernel/watchdog_thresh
echo "kernel.watchdog_thresh=30" >> /etc/sysctl.conf
sysctl -w kernel.watchdog_thresh=30
sysctl -q vm.swappiness
sysctl -p

JDK11安装

下载地址：https://www.oracle.com/java/technologies/downloads/#java11

安装包：jdk-11.0.15.1_linux-x64_bin.tar.gz上传至虚拟机/usr/local/server目录下，并解压，改名为jdk即可。

修改配置文件/etc/profile添加环境变量配置：

#修改
vi /etc/profile

#添加配置
JAVA_HOME=/usr/local/server/jdk
CLASSPATH=.:$JAVA_HOME/lib
PATH=$JAVA_HOME/bin:$PATH
export JAVA_HOME CLASSPATH PATH

#保存退出并让文件立即生效
source /etc/profile

#查看JDK版本
[root@localhost server]# java --version
java 11.0.15.1 2022-04-22 LTS
Java(TM) SE Runtime Environment 18.9 (build 11.0.15.1+2-LTS-10)
Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.15.1+2-LTS-10, mixed mode)

Docker安装

Docker安装:

#更新至最新的库
yum update

#安装Docker
yum install docker

#启动Docker
systemctl start docker

#开机启动Docker
systemctl enable docker

Docker默认镜像源下载太慢，可以调整为国内镜像源，

#编辑配置文件
vi /etc/docker/daemon.json

#添加镜像地址信息
{
    "registry-mirrors": [
        "http://hub-mirror.c.163.com",
        "https://docker.mirrors.ustc.edu.cn",
        "https://registry.docker-cn.com"
    ]
}

#重启Docker
systemctl restart docker

为了验证是否切换成功，可以使用docker info查看，会显示如下信息：

Registry Mirrors:
 http://hub-mirror.c.163.com
 https://docker.mirrors.ustc.edu.cn
 https://registry.docker-cn.com

Docker-Compose安装

安装Docker-Compose，这里下载的是最新版本v2.5.0，安装流程如下：

#下载安装文件，其中uname -s是获取系统内核，uname -m获取系统版本，所以最后其实是下载docker-compose-Linux-x86_64
sudo curl -L https://github.com/docker/compose/releases/download/v2.5.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

#添加可执行权限
sudo chmod +x /usr/local/bin/docker-compose

#检查版本，是否安装成功
docker-compose --version

MySQL安装

这里提供MySQL8安装、MySQL7安装，同时讲解基于Docker安装和Docker-Compose安装。

MySQL8安装

安装命令：

docker run -d -i \
--name mysql \
-v /usr/local/server/mysql/datadir:/var/lib/mysql \
-v /usr/local/server/mysql/conf.d:/etc/mysql/conf.d \
-v /etc/localtime:/etc/localtime \
--privileged=true \
-p 3306:3306 \
-e MYSQL_ROOT_PASSWORD=123456 \
--restart=always \
mysql:8.0

修改密码:

#进入容器
docker exec -it mysql /bin/bash
#登录mysql
mysql -u root -p
#修改登录权限
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';

select NOW()时间如果小了8小时，执行如下操作同步时区即可：

docker cp /usr/share/zoneinfo/Asia/Shanghai mysql:/usr/share/zoneinfo/Asia

docker exec -it mysql bash

cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

docker restart mysql

Docker-Compose安装MySQL8

创建mysql-compose.yml文件，配置如下：

version: '3.0'
services:
  mysql:
    image: mysql:8.0
    restart: always
    container_name: mysql
    privileged: true
    environment:
      # 当您的配置需要文字美元符号时，您可以使用$$（双美元符号）。
      MYSQL_ROOT_PASSWORD: 123456
    command:
      --default-authentication-plugin=mysql_native_password
      --character-set-server=utf8mb4
      --collation-server=utf8mb4_general_ci
      --explicit_defaults_for_timestamp=true
      --lower_case_table_names=1
    ports:
      - 3306:3306
    volumes:
      - /usr/local/server/mysql:/var/lib/mysql

参数说明：

default-authentication-plugin:
	mysql8 版本默认的认证方式是 caching_sha2_password ，客户端不支持，之前是采用 mysql_native_password，可以在启动容器时添加参数

character-set-server:
	编码设置，mb4就是most bytes 4的意思，专门用来兼容四字节的unicode。utf8mb4是utf8的超集，除了将编码改为utf8mb4外不需要做其他转换。

collation-server：
	服务器的字符集设置。

explicit_defaults_for_timestamp：
	默认情况下，timestamp类型字段所在数据行被更新时，该字段会自动更新为当前时间，而参数explicit_defaults_for_timestamp控制这一种行为。
	explicit_defaults_for_timestamp=false，数据行更新时，timestamp类型字段更新为当前时间。
	explicit_defaults_for_timestamp=true，数据行更新时，timestamp类型字段不更新为当前时间。

lower_case_table_names:
	lower_case_table_names=0 表名存储为给定的大小和比较是区分大小写的
	lower_case_table_names = 1 表名存储在磁盘是小写的，但是比较的时候是不区分大小写
	lower_case_table_names=2 表名存储为给定的大小写但是比较的时候是小写的

安装命令：docker-compose -f mysql-compose.yml up -d

MySQL5.7安装

如果要安装MySQL5.7，可按照如下安装流程执行：

docker run -it --name mysql -d \
-p 3306:3306 --restart=always \
-e MYSQL_ROOT_PASSWORD=123456 \
mysql:5.7

MySQL修改权限：

GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY '123456';

Nacos安装

这里讲解Docker安装Nacos单节点，同时讲解基于Docker-Compose安装Nacos集群。

Docker安装Nacos单机

安装Nacos，默认采用的是Derby数据库存储，如果想用MySQL存储，需要先获取SQL脚本，并创建数据库，我们可以下载安装包获取SQL脚本,将conf/nacos_config.sql导入数据库即可。

下载地址：https://github.com/alibaba/nacos/releases

安装脚本：

docker run -d \
-e MODE=standalone \
-e SPRING_DATASOURCE_PLATFORM=mysql \
-e MYSQL_SERVICE_HOST=192.168.33.31 \
-e MYSQL_SERVICE_PORT=3306 \
-e MYSQL_SERVICE_USER=root \
-e MYSQL_SERVICE_PASSWORD=123456 \
-e MYSQL_SERVICE_DB_NAME=nacos_config \
-p 8848:8848 \
--restart=always \
--name nacos nacos/nacos-server:v2.1.0

参数说明：

SPRING_DATASOURCE_PLATFORM=mysql   使用MySQL存储数据
MYSQL_SERVICE_HOST=192.168.33.31   存储数据的MySQL的IP
MYSQL_SERVICE_PORT=3306            MySQL的端口号
MYSQL_SERVICE_USER=root            MySQL的账号
MYSQL_SERVICE_PASSWORD=123456      MySQL的密码
MYSQL_SERVICE_DB_NAME=nacos_config 存储数据的数据库名字

Docker-Compose安装Nacos集群

这里实现集群的节点如下：

节点1         192.168.33.31          8818
节点2         192.168.33.31          8828
节点3         192.168.33.31          8838

创建nacos-cluster.yml，配置如下：

version: "3"
services:
  nacos1:
    image: nacos/nacos-server:v2.1.0
    container_name: nacos1
    environment:
      PREFER_HOST_MODE: ip
      MODE: cluster
      NACOS_SERVER_IP: 192.168.33.31
      NACOS_SERVERS: "192.168.33.31:8818 192.168.33.31:8828 192.168.33.31:8838"
      SPRING_DATASOURCE_PLATFORM: mysql
      MYSQL_SERVICE_HOST: 192.168.33.31
      MYSQL_SERVICE_PORT: 3306
      MYSQL_SERVICE_DB_NAME: nacos_config
      MYSQL_SERVICE_USER: root
      MYSQL_SERVICE_PASSWORD: 123456
      JVM_XMS: 256m
      JVM_XMX: 512m
      JVM_XMN: 256m
      SERVER_PORT: 8818
    ports:
      - "8818:8818"
    restart: always
    build:
      context: .
      network: host
 
  nacos2:
    image: nacos/nacos-server:v2.1.0
    container_name: nacos2
    environment:
      PREFER_HOST_MODE: ip
      MODE: cluster
      NACOS_SERVER_IP: 192.168.33.31
      NACOS_SERVERS: "192.168.33.31:8818 192.168.33.31:8828 192.168.33.31:8838"
      SPRING_DATASOURCE_PLATFORM: mysql
      MYSQL_SERVICE_HOST: 192.168.33.31
      MYSQL_SERVICE_PORT: 3306
      MYSQL_SERVICE_DB_NAME: nacos_config
      MYSQL_SERVICE_USER: root
      MYSQL_SERVICE_PASSWORD: 123456
      JVM_XMS: 256m
      JVM_XMX: 512m
      JVM_XMN: 256m
      SERVER_PORT: 8828
    ports:
      - "8828:8828"
    restart: always
    build:
      context: .
      network: host
 
 
  nacos3:
    image: nacos/nacos-server:v2.1.0
    container_name: nacos3
    environment:
      PREFER_HOST_MODE: ip
      MODE: cluster
      NACOS_SERVER_IP: 192.168.33.31
      NACOS_SERVERS: "192.168.33.31:8818 192.168.33.31:8828 192.168.33.31:8838"
      SPRING_DATASOURCE_PLATFORM: mysql
      MYSQL_SERVICE_HOST: 192.168.33.31
      MYSQL_SERVICE_PORT: 3306
      MYSQL_SERVICE_DB_NAME: nacos_config
      MYSQL_SERVICE_USER: root
      MYSQL_SERVICE_PASSWORD: 123456
      JVM_XMS: 256m
      JVM_XMX: 512m
      JVM_XMN: 256m
      SERVER_PORT: 8838
    ports:
      - "8838:8838"
    restart: always
    build:
      context: .
      network: host

参数列表说明：

PREFER_HOST_MODE: Nacos会以什么方式来寻找自己的集群节点，一共有两种方式:
	1)如果指定为 ip，那么 NACOS_SERVERS 也必须指定的是一组 ip（所有Nacos的集群节点）
	2)如果指定为 hostname，那么 NACOS_SERVERS 也必须指定的是一组 hostname（所有Nacos的集群节点），所以还需要配置docker-compose中service的 hostname 用来显示指定主机名

NACOS_SERVERS: 服务集群的节点列表，以IP1:Port1,IP2:Port2的方式编写

NACOS_SERVER_IP: 192.168.33.31   节点的IP，如果不指定，在多网卡环境下，会出现多IP问题

SERVER_PORT: 8838  每个节点的容器中Nacos的IP，如果是非8848端口，一定要指定，否则集群会多出一个无效的8848节点

安装命令：docker-compose -f nacos-cluster.yml up -d

访问任意一个节点，集群节点列表如下：

OpenResty安装

安装OpenResty需要先安装相关依赖库：

yum install libtermcap-devel ncurses-devel libevent-devel readline-devel pcre-devel gcc openssl openssl-devel per perl wget

安装OpenResty

#下载OpenResty
wget https://openresty.org/download/openresty-1.11.2.5.tar.gz

#解压OpenResty
tar -xf openresty-1.11.2.5.tar.gz

#配置 OpenResty
./configure --prefix=/usr/local/openresty --with-luajit --without-http_redis2_module --with-http_stub_status_module --with-http_v2_module --with-http_gzip_static_module --with-http_sub_module

#编译安装
make && make install

#在profile中添加环境配置
vi /etc/profile

Nginx服务自启

创建/etc/systemd/system/nginx.service，添加如下配置：

[Unit]
 Description=nginx service
 After=network.target

 [Service]
 Type=forking
 ExecStart=/usr/local/openresty/nginx/sbin/nginx
 ExecReload=/usr/local/openresty/nginx/sbin/nginx -s reload
 ExecStop=/usr/local/openresty/nginx/sbin/nginx -s quit

 PrivateTmp=true

 [Install]
 WantedBy=multi-user.target

保存退出后，然后执行服务配置加载，并设置开机启动，同时可以验证一下命令是否生效，操作如下：

#重新加载服务配置
systemctl daemon-reload

#Nginx开机启动
systemctl enable nginx

#nginx启动:
systemctl start nginx

#nginx停止:
systemctl stop nginx

#重启 验证是否开机自启
reboot

Redis安装

这里将实现Docker安装单机版的Redis以及Docker-Compose安装Redis集群。

Docker安装单机Redis

安装Redis，这里固定版本为6.2.4，操作如下：

docker run -itd --name redis -p 6379:6379 \
--privileged=true \
-v /usr/local/docker/redis/data:/data \
-v /usr/local/docker/redis/conf/redis.conf:/usr/local/etc/redis/redis.conf \
--restart=always \
redis:6.2.4 --requirepass 123456

Docker-Compose安装Redis集群

这里准备6个节点，节点信息如下：

节点	IP	Port	类型
redis1	192.168.33.31	7001	Master
redis2	192.168.33.31	7002	Master
redis3	192.168.33.31	7003	Master
redis4	192.168.33.31	7004	Slave
redis5	192.168.33.31	7005	Slave
redis6	192.168.33.31	7006	Slave

创建6个目录存储每个节点的配置：

#创建文件目录，分别存储每个节点的配置和数据
mkdir -p /usr/local/server/redis-cluster/redis1/conf
mkdir -p /usr/local/server/redis-cluster/redis1/data
mkdir -p /usr/local/server/redis-cluster/redis2/conf
mkdir -p /usr/local/server/redis-cluster/redis2/data
mkdir -p /usr/local/server/redis-cluster/redis3/conf
mkdir -p /usr/local/server/redis-cluster/redis3/data
mkdir -p /usr/local/server/redis-cluster/redis4/conf
mkdir -p /usr/local/server/redis-cluster/redis4/data
mkdir -p /usr/local/server/redis-cluster/redis5/conf
mkdir -p /usr/local/server/redis-cluster/redis5/data
mkdir -p /usr/local/server/redis-cluster/redis6/conf
mkdir -p /usr/local/server/redis-cluster/redis6/data

为每个节点创建配置：/usr/local/server/redis-cluster/redis1/conf/redis.conf

port 7001
bind 0.0.0.0
databases 1
#开启集群
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 15000

这里要把redis1~redis6的conf目录下都创建该配置，端口修改成7001/7002/7003/7004/7005/7006即可。

创建redis-cluster.yml:

version: "3"
services:
  redis1:
    container_name: redis1
    image: redis:6.2.4
    network_mode: host
    privileged: true
    volumes:
      - /usr/local/server/redis-cluster/redis1/conf/redis.conf:/etc/redis/redis.conf
      - /usr/local/server/redis-cluster/redis1/data:/data
    command: [ "redis-server", /etc/redis/redis.conf ]
    restart: always
  redis2:
    container_name: redis2
    image: redis:6.2.4
    network_mode: host
    privileged: true
    volumes:
      - /usr/local/server/redis-cluster/redis2/conf/redis.conf:/etc/redis/redis.conf
      - /usr/local/server/redis-cluster/redis2/data:/data
    command: [ "redis-server", /etc/redis/redis.conf ]
    restart: always
  redis3:
    container_name: redis3
    image: redis:6.2.4
    network_mode: host
    privileged: true
    volumes:
      - /usr/local/server/redis-cluster/redis3/conf/redis.conf:/etc/redis/redis.conf
      - /usr/local/server/redis-cluster/redis3/data:/data
    command: [ "redis-server", /etc/redis/redis.conf ]
    restart: always
  redis4:
    container_name: redis4
    image: redis:6.2.4
    network_mode: host
    privileged: true
    volumes:
      - /usr/local/server/redis-cluster/redis4/conf/redis.conf:/etc/redis/redis.conf
      - /usr/local/server/redis-cluster/redis4/data:/data
    command: [ "redis-server", /etc/redis/redis.conf ]
    restart: always
  redis5:
    container_name: redis5
    image: redis:6.2.4
    network_mode: host
    privileged: true
    volumes:
      - /usr/local/server/redis-cluster/redis5/conf/redis.conf:/etc/redis/redis.conf
      - /usr/local/server/redis-cluster/redis5/data:/data
    command: [ "redis-server", /etc/redis/redis.conf ]
    restart: always
  redis6:
    container_name: redis6
    image: redis:6.2.4
    network_mode: host
    privileged: true
    volumes:
      - /usr/local/server/redis-cluster/redis6/conf/redis.conf:/etc/redis/redis.conf
      - /usr/local/server/redis-cluster/redis6/data:/data
    command: [ "redis-server", /etc/redis/redis.conf ]
    restart: always

安装命令：docker-compose -f redis-cluster.yml up -d，效果如下：

创建集群：

# 进入容器内部
docker exec -it redis1 /bin/bash

#执行Redis集群创建命令，注意要修改所有的192.168.33.31为自己设备的实际IP，如果使用云服务器，则使用公网IP
redis-cli --cluster create 192.168.33.31:7001 \
192.168.33.31:7002 192.168.33.31:7003 \
192.168.33.31:7004 192.168.33.31:7005 \
192.168.33.31:7006 --cluster-replicas 1

#集群节点信息
redis-cli -p 7001 cluster nodes

效果如下：

Docker-Compose安装Kafka集群

Kafka集群需要使用Zookeeper实现分布式管理，我们先拉去Zookeeper镜像，再实现安装：

docker pull zookeeper:3.7.0

创建脚本文件kafka.yml

version: '3.8'
services:
  zookeeper:
    image: zookeeper:3.7.0
    restart: always
    hostname: 192.168。211.130
    container_name: zookeeper
    privileged: true
    ports:
      - 2181:2181
    volumes:
      - /usr/local/server/zookeeper/data/:/data
    build:
      context: .
      network: host

  kafka1:
    container_name: kafka1
    restart: always
    image: wurstmeister/kafka:2.12-2.5.0
    privileged: true
    ports:
      - 9092:9092
      - 19092:19092
    environment:
      KAFKA_BROKER_ID: 1
      HOST_IP: 192.168.211.130
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9092
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://192.168.211.130:9092    ## 宿主机IP
      KAFKA_ZOOKEEPER_CONNECT: 192.168.211.130:2181
      #docker部署必须设置外部可访问ip和端口，否则注册进zk的地址将不可达造成外部无法连接
      KAFKA_ADVERTISED_HOST_NAME: 192.168.211.130
      KAFKA_ADVERTISED_PORT: 9092
      KAFKA_PORT: 9092
      KAFKA_delete_topic_enable: 'true'
      KAFKA_JMX_OPTS: "-Dcom.sun.management.jmxremote=true -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false -Djava.rmi.server.hostname=192.168.211.130 -Dcom.sun.management.jmxremote.rmi.port=19092"
      JMX_PORT: 19092
      volumes:
        /etc/localtime:/etc/localtime
      depends_on:
        zookeeper
  kafka2:
    container_name: kafka2
    restart: always
    image: wurstmeister/kafka:2.12-2.5.0
    privileged: true
    ports:
      - 9093:9093
      - 19093:19093
    environment:
      KAFKA_BROKER_ID: 2
      HOST_IP: 192.168.211.130
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9093
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://192.168.211.130:9093    ## 宿主机IP
      KAFKA_ZOOKEEPER_CONNECT: 192.168.211.130:2181
      #docker部署必须设置外部可访问ip和端口，否则注册进zk的地址将不可达造成外部无法连接
      KAFKA_ADVERTISED_HOST_NAME: 192.168.211.130
      KAFKA_ADVERTISED_PORT: 9093
      KAFKA_PORT: 9093
      KAFKA_delete_topic_enable: 'true'
      KAFKA_JMX_OPTS: "-Dcom.sun.management.jmxremote=true -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false -Djava.rmi.server.hostname=192.168.211.130 -Dcom.sun.management.jmxremote.rmi.port=19093"
      JMX_PORT: 19093
      volumes:
        /etc/localtime:/etc/localtime
      depends_on:
        zookeeper
  kafka3:
    container_name: kafka3
    restart: always
    image: wurstmeister/kafka:2.12-2.5.0
    privileged: true
    ports:
      - 9094:9094
      - 19094:19094
    environment:
      KAFKA_BROKER_ID: 3
      HOST_IP: 192.168.211.130
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9094
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://192.168.211.130:9094    ## 宿主机IP
      KAFKA_ZOOKEEPER_CONNECT: 192.168.211.130:2181
      #docker部署必须设置外部可访问ip和端口，否则注册进zk的地址将不可达造成外部无法连接
      KAFKA_ADVERTISED_HOST_NAME: 192.168.211.130
      KAFKA_ADVERTISED_PORT: 9094
      KAFKA_PORT: 9094
      KAFKA_delete_topic_enable: 'true'
      KAFKA_JMX_OPTS: "-Dcom.sun.management.jmxremote=true -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false -Djava.rmi.server.hostname=192.168.211.130 -Dcom.sun.management.jmxremote.rmi.port=19094"
      JMX_PORT: 19094
      volumes:
        /etc/localtime:/etc/localtime
      depends_on:
        zookeeper

  eagle:
    image: gui66497/kafka_eagle
    container_name: eagle_monitor
    restart: always
    depends_on:
      - kafka1
      - kafka2
      - kafka3
    ports:
      - "8048:8048"
    environment:
      ZKSERVER: "192.168.211.130:2181"

执行安装;

#执行命令
docker-compose -f kafka.yml up -d

#效果如下
[root@localhost kafka]# docker-compose -f kafka.yml up -d
[+] Running 5/5
 ⠿ Container kafka2         Started    1.1s
 ⠿ Container kafka3         Started    1.2s
 ⠿ Container zookeeper      Started    1.0s
 ⠿ Container kafka1         Started    1.1s
 ⠿ Container eagle_monitor  Started    3.0s
[root@localhost kafka]#

访问控制台http://192.168.211.130:8048/ke/，输入账号密码admin / 123456登录，效果如下：

ElasticSearch安装

采用Docker方式安装ElasticSearch：

docker run -i --name elasticsearch -d \
--restart=always -p 9200:9200 -p 9300:9300 \
--privileged=true \
-v /usr/local/server/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
-e "discovery.type=single-node" \
elasticsearch:7.12.1

IK分词器安装，下载地址：https://github.com/medcl/elasticsearch-analysis-ik/releases?page=4 下载后，将压缩包拷贝到 /usr/local/server/elasticsearch/plugins目录下，在资料\软件\elasticsearch-analysis-ik-7.12.1.zip已经下载好了该文件，可以直接上传到服务器上，操作如下：

#解压需要用到unzip，如果没有安装它，可以先安装
yum install unzip

#解压文件
unzip elasticsearch-analysis-ik-7.12.1.zip -d ./ik

#重新启动elasticsearch，IK分词器就生效
docker restart elasticsearch

elasticsearch-hq是一个非常方便的Elasticsearch可视化管理工具，我们可以安装一个：

docker run -id -p 5000:5000 --restart=always elastichq/elasticsearch-hq

安装完成后，访问http://192.168.211.130:5000/即可。

Kibana也是一款非常不错的Elasticsearch管理工具，我们也可以安装它：

docker run -d \
--name kibana \
--restart=always \
-e ELASTICSEARCH_HOSTS=http://192.168.211.131:9200 \
-p 5601:5601  \
kibana:7.12.1

安装完成后，界面都是英文，我们可以把它换成中文：

#进入容器 
docker exec -it kibana /bin/bash

#编辑config/kibana.yml，修改中文，添加下面配置即可
i18n.locale: "zh-CN"

#重启容器
docker restart kibana

Skywalking安装

安装OAP

docker run \
--name skywalking-oap \
--restart always \
-p 11800:11800 \
-p 12800:12800 -d \
--privileged=true \
-e TZ=Asia/Shanghai \
-e SW_STORAGE=elasticsearch7 \
-e SW_STORAGE_ES_CLUSTER_NODES=192.168.211.131:9200 \
-v /etc/localtime:/etc/localtime:ro \
apache/skywalking-oap-server:8.6.0-es7

安装Skywalking UI

docker run \
--name skywalking-ui \
--restart always \
-p 8080:8080 -d \
--privileged=true \
--link skywalking-oap:skywalking-oap \
-e TZ=Asia/Shanghai \
-e SW_OAP_ADDRESS=192.168.211.131:12800 \
-v /etc/localtime:/etc/localtime:ro \
apache/skywalking-ui:8.6.0

访问SkywalkingUI http://192.168.211.131:8080

1)ES分片数量上限

如果此时访问http://192.168.211.136:8080/ 出现500错误，错误如下，此时其实是Elasticsearch出了问题：

"com.netflix.zuul.exception.ZuulException","message":"GENERAL"

我们可以查看skywalking的日志docker logs --since 30m skywalking，会报如下错误：

Failed: 1: this action would add [2] total shards, but this cluster currently has [1000]/[1000] maximum shards open;]

这种错误一般是生产环境中Elasticsearch分片数量达到了峰值，es集群的默认最大分片数是1000，我们需要调整Elasticsearch的默认分片数量，修改方式有多种，最常用的是直接修改elasticsearch.yml配置文件：

#进入elasticsearch容器
docker exec -it elasticsearch /bin/bash

#编辑
vi /usr/share/elasticsearch/config/elasticsearch.yml

#添加如下配置
cluster.max_shards_per_node: 10000000

保存配置后，记得删除data/nodes数据包，再重启elasticsearch，此时就可以正常访问了。

2)磁盘清理

如果此时能打开skywalking-ui界面，但是没有数据，则需要清理磁盘空间，可能是磁盘空间满了，如果是docker容器，可以使用docker system prune命令实现清理，docker system prune命令可以用于清理磁盘，删除关闭的容器、无用的数据卷和网络，以及dangling镜像（即无tag的镜像）。docker system prune -a命令清理得更加彻底，可以将没有容器使用Docker镜像都删掉。

探针下载https://archive.apache.org/dist/skywalking/

MinIO安装

MinIO基于Apache License v2.0开源协议的对象存储服务，可以做为云存储的解决方案用来保存海量的图片，视频，文档。由于采用Golang实现，服务端可以工作在Windows,Linux, OS X和FreeBSD上。配置简单，基本是复制可执行程序，单行命令可以运行起来。

关于MinIOn使用参考文档 http://docs.minio.org.cn/docs/

我们可以使用docker进行环境部署和启动

docker run -i -d \
  -p 9000:9000 \
  -p 9001:9001 \
  --restart=always \
  --name minio1 \
  --network=host \
  --privileged=true \
  -v /etc/localtime:/etc/localtime \
  -v ~/minio/data:/data \
  -e "MINIO_ROOT_USER=minio" \
  -e "MINIO_ROOT_PASSWORD=minio123" \
  quay.io/minio/minio server /data --console-address ":9001"

访问：http://192.168.211.130:9000/login 输入账号 minio / minio123即可登录。

创建Buckets：

Buckets权限管理

上传图片测试：

如果所有文件都存储到shop下，不容易区分，我们可以根据不同文件，创建不同目录，例如shop/items/存储所有商品静态页，多级路径创建：

选择Upload上传文件：

文件访问：http://192.168.211.130:9000/shop/items/002.jpg

效果如下：

如果是java程序抛出异常，主要是时间不同步问题：

The difference between the request time and the server's time is too large.

解决方案如下：

#安装ntp ntpdate
yum -y install ntp ntpdate

#与时间服务器同步时间
ntpdate cn.pool.ntp.org

#将系统时间写入硬件时间
hwclock --systohc

FastDFS安装

安装FastDFS需要安装Tracker和Storage：

#Tracker安装
docker run -d --name tracker --restart=always \
--net=host morunchang/fastdfs \
sh tracker.sh

#Storage安装
docker run -d --name storage \
--restart=always --net=host -e \
TRACKER_IP=192.168.211.130:22122 \
-e GROUP_NAME=group1 morunchang/fastdfs \
sh storage.sh

Canal安装

canal 1.1.4版本，迎来最重要的WebUI能力，引入canal-admin工程，支持面向WebUI的canal动态管理能力，支持配置、任务、日志等在线白屏运维能力。

不过当前已经更新到了最新版本1.1.6,但1.1.6属于测试版，1.1.5属于稳定版，所以我们安装1.1.5。

docker run -p 11111:11111 --name=canal \
--restart=always -d \
canal/canal-server:v1.1.5

Git安装

安装命令：

# 1. 卸载旧版本
yum remove git

# 2. 安装 yum 源的 Git 版本
yum install -y git

# 3. 查看版本
git version 
# 输出 git version 1.8.3.1

Seata1.4.2安装

1）单机

docker run --name seata1 -d \
-p 8091:8091 -e SEATA_PORT=8091 \
--privileged=true -e SEATA_IP=192.168.211.131  \
-v /usr/local/server/seata1/conf:/root/seata-config \
-v /usr/local/server/seata1/logs:/root/logs/seata \
seataio/seata-server:1.4.2

修改注册中心

#1）进入容器
docker exec -it seata1 sh


#2）进入resources
cd resources/


#3）修改配置中心和注册中心
registry {
  # file ...nacos ...eureka...redis...zk...consul...etcd3...sofa
  type = "nacos"

  nacos {
    application = "seata-tc-server"
    serverAddr = "192.168.211.131:8848"
    group = "SEATA_GROUP"
    namespace = ""
    cluster = "default"
    username = "nacos"
    password = "nacos"
  }
}

config {
  # file...nacos ...apollo...zk...consul...etcd3
  type = "nacos"

  nacos {
    serverAddr = "192.168.211.131:8848"
    namespace = ""
    group = "SEATA_GROUP"
    username = "nacos"
    password = "nacos"
    dataId = "seataServer.properties"
  }
}


#4）退出，修改
exit


#5）修改Nacos，添加seataServer.properties，内容如下：
# 数据存储方式，db代表数据库
store.mode=db
store.db.datasource=druid
store.db.dbType=mysql
store.db.driverClassName=com.mysql.jdbc.Driver
store.db.url=jdbc:mysql://192.168.211.131:3306/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.queryLimit=100
store.db.lockTable=lock_table
store.db.maxWait=5000
# 事务、日志等配置
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.undo.logSaveDays=7
server.undo.logDeletePeriod=86400000

# 客户端与服务端传输方式
transport.serialization=seata
transport.compressor=none
# 关闭metrics功能，提高性能
metrics.enabled=false
metrics.registryType=compact
metrics.exporterList=prometheus
metrics.exporterPrometheusPort=9898


#6）创建seata数据库，并将如下脚本导入到数据库中
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- 分支事务表
-- ----------------------------
DROP TABLE IF EXISTS `branch_table`;
CREATE TABLE `branch_table`  (
  `branch_id` bigint(20) NOT NULL,
  `xid` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `transaction_id` bigint(20) NULL DEFAULT NULL,
  `resource_group_id` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `resource_id` varchar(256) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `branch_type` varchar(8) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `status` tinyint(4) NULL DEFAULT NULL,
  `client_id` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `application_data` varchar(2000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `gmt_create` datetime(6) NULL DEFAULT NULL,
  `gmt_modified` datetime(6) NULL DEFAULT NULL,
  PRIMARY KEY (`branch_id`) USING BTREE,
  INDEX `idx_xid`(`xid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- 全局事务表
-- ----------------------------
DROP TABLE IF EXISTS `global_table`;
CREATE TABLE `global_table`  (
  `xid` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `transaction_id` bigint(20) NULL DEFAULT NULL,
  `status` tinyint(4) NOT NULL,
  `application_id` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `transaction_service_group` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `transaction_name` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `timeout` int(11) NULL DEFAULT NULL,
  `begin_time` bigint(20) NULL DEFAULT NULL,
  `application_data` varchar(2000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `gmt_create` datetime NULL DEFAULT NULL,
  `gmt_modified` datetime NULL DEFAULT NULL,
  PRIMARY KEY (`xid`) USING BTREE,
  INDEX `idx_gmt_modified_status`(`gmt_modified`, `status`) USING BTREE,
  INDEX `idx_transaction_id`(`transaction_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

SET FOREIGN_KEY_CHECKS = 1;


#7）重启容器
docker restart seata1

此时查看Nacos中的服务注册数据，能看到seata服务注册数据：

服务名	分组名称	集群数目	实例数	健康实例数
seata-tc-server	SEATA_GROUP	1	1	1

MongoDB安装

1）单机安装-不支持事务

安装脚本

docker run -di --name \
mongo-service --restart=always \
-p 27017:27017 -v ~/data/mongodata:/data mongo

2）MongoDB多副本集-支持事务

安装3台节点：

docker run --name mongo1 -p 27024:27024 -d mongo mongod --replSet "rs0" --port 27024

docker run --name mongo2 -p 27025:27025 -d mongo mongod --replSet "rs0" --port 27025

docker run --name mongo3 -p 27026:27026 -d mongo mongod --replSet "rs0" --port 27026

初始化关联：

#进入容器
docker exec -it mongo1 mongo --port 27024

#初始化
rs.initiate({"_id":"rs0","members":[{"_id":0,"host":"192.168.211.131:27024"},{"_id":1,"host":"192.168.211.131:27025"},{"_id":2,"host":"192.168.211.131:27026"}]})

项目中链接配置如下：

spring:
  data:
    mongodb:
      uri: mongodb://192.168.211.131:27024,192.168.211.131:27025,192.168.211.131:27026/test?replicaSet=rs0&readPreference=secondaryPreferred&connectTimeoutMS=300000

注意：如果有密码，则按如下方式配置：

uri: mongodb://userName:password@IP1:Port1,IP2:Port2,IP3:Port3/base?replicaSet=rs1&readPreference=secondaryPreferred&connectTimeoutMS=300000

MongoDB分布式事务：

1）创建事务管理器MongoTransactionManager

@Bean
MongoTransactionManager transactionManager(MongoDatabaseFactory factory){
    return new MongoTransactionManager(factory);
}

2)案例演示

这里支持多文档事务;

@Transactional
public void add(User user){
    mongoTemplate.save(user);

    Card card = new Card();
    card.setId("2");
    card.setNumber("55555");
    card.setUserId("No001");
    mongoTemplate.save(card);

    log.info("执行成功！");
    //int q=10/0;
}

3）MongoDB关联查询

@GetMapping(value = "/link/{id}")
public List<Card> load(@PathVariable(value = "id")String id){
    //关联查询
    Aggregation aggregation = Aggregation.newAggregation(
            // 匹配条件
            Aggregation.match(Criteria.where("_id").is(id)),
            // from：class作为主collection，from字段表示需要链接的collection，不明白为啥命名个from
            // localField：主collection里的外键字段
            // foreignField：连接collection里对应外键的字段
            // as：最终连接的部分输出的字段名称
            Aggregation.lookup("user", "userId", "_id", "user"));

    AggregationResults<Card> result = mongoTemplate.aggregate(aggregation, "card", Card.class);
    return result.getMappedResults();
}

等同于：select * from card inner join user on card.userId=user._id where card._id=?

RabbitMQ安装

安装命令如下：

docker run -d --hostname host130 \
--name rabbitMq \
-e RABBITMQ_DEFAULT_USER=admin \
-e RABBITMQ_DEFAULT_PASS=123456 \
-p 15672:15672 \
-p 5672:5672 \
--restart=always \
rabbitmq:3.8.2-management

参数说明：

-d 以守护进程方式在后台运行
-p 15672:15672 management 界面管理访问端口
-p 5672:5672 amqp 访问端口
--name：指定容器名
--hostname：设定容器的主机名，它会被写到容器内的 /etc/hostname 和 /etc/hosts，作为容器主机IP的别名，并且将显示在容器的bash中，所以记得将host130添加到/etc/hosts下面，如下：
#127.0.0.1 host130

-e 参数
  RABBITMQ_DEFAULT_USER 用户名
  RABBITMQ_DEFAULT_PASS 密码

输入http://192.168.211.130:15672/ 访问，账号admin，密码123456，或者guest/guest

RocketMQ安装

安装RocketMQ需要安装mqnamesrv和broker，安装流程如下：

#创建存储日志目录
mkdir -p  /usr/local/server/rocketmq/data/namesrv/logs   /usr/local/server/rocketmq/data/namesrv/store

#安装mqnamesrv
docker run -d \
--restart=always \
--name rmqnamesrv \
-p 9876:9876 \
-v /usr/local/server/rocketmq/data/namesrv/logs:/root/logs \
-v /usr/local/server/rocketmq/data/namesrv/store:/root/store \
-e "MAX_POSSIBLE_HEAP=100000000" \
rocketmqinc/rocketmq \
sh mqnamesrv


#创建目录存储broker日志信息和配置文件
mkdir -p  /usr/local/server/rocketmq/data/broker/logs   /usr/local/server/rocketmq/data/broker/store /usr/local/server/rocketmq/conf

#创建配置文件
vi /usr/local/server/rocketmq/conf/broker.conf

#配置文件完整内容如下
# 所属集群名称，如果节点较多可以配置多个
brokerClusterName = 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 = 192.168.211.130
# 磁盘使用达到95%之后,生产者再写入消息会报错 CODE: 14 DESC: service not available now, maybe disk full
diskMaxUsedSpaceRatio=95

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

#创建控制台console
docker run -d \
--restart=always \
--name rmqadmin \
-e "JAVA_OPTS=-Drocketmq.namesrv.addr=192.168.211.130:9876 \
-Dcom.rocketmq.sendMessageWithVIPChannel=false" \
-p 9999:8080 \
pangliang/rocketmq-console-ng

Dockerfile-SpringBoot

以IgeMonitor例，使用Dockerfile构建,Dockerfile文件如下：

FROM openjdk:11-jre
LABEL maintainer="研究院研发组 shenkunlin@itcast.cn"
RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo "Asia/Shanghai" > /etc/timezone
ADD ./ige-monitor-igem-1.0.jar /app.jar
ENV dbuname="root"
ENV dbpwd="root"
ENV dbname="ige_config"
ENV dburl="localhost:3306"
ENV iport="8085"
WORKDIR /
ENTRYPOINT ["sh","-c","java -jar -Ddbuname=$dbuname -Ddbpwd=$dbpwd -Ddbname=$dbname -Ddburl=$dburl -Diport=$iport -Xms512m -Xmx512m -XX:PermSize=512M -XX:MaxPermSize=512m /app.jar"]

构建镜像：

 docker build -t igemonitor:2.0 .

安装容器：

docker run -it -d --name=igemonitor \
-p 8085:8085 -p 28888:28888 \
--restart=always \
-e dbuname=root \
-e dbpwd=123456 \
-e dburl=192.168.211.131:3306 \
dockershenkunlin/igemonitor:v2.0

镜像上传Dockerhub

Dockerhub地址：https://hub.docker.com/，如果想将自己制作的镜像发布上去，首先可以注册一个DockerHub账号：dockershenkunlin，密码：***********

1）创建仓库

2）镜像推送

#查看本地容器
[root@localhost igemonitor]# docker ps
CONTAINER ID        IMAGE                  NAMES
4eecde9ee7f6        igemonitor:1.0        igemonitor

#并提交容器制作成本地镜像
docker commit igemonitor dockershenkunlin/igemonitor:v1.0

#登录dockerhub
[root@localhost igemonitor]# docker login
Login with your Docker ID to push and pull images from Docker Hub. If you don't have a Docker ID, head over to https://hub.docker.com to create one.
Username: dockershenkunlin
Password:
Login Succeeded

#将本地镜像推送至Dockerhub
docker push dockershenkunlin/igemonitor:1.0

我们可以看到镜像已经推送至Dockerhub了，如下图：

3）镜像下载安装测试

记得先清除本地Docker镜像，再执行如下操作安装镜像：

docker run -it -d --name=igemonitor \
-p 8085:8085 -p 28888:28888 \
--restart=always \
-e dbuname=root \
-e dbpwd=123456 \
-e dburl=192.168.211.130:3306 \
dockershenkunlin/igemonitor:v1.0

效果如下：

安装完成后，访问http://192.168.211.130:8085/效果如下：

jar包安装到本地仓库

mvn install:install-file -Dfile=E:\ige-rpc-client-igem-1.0.jar -DgroupId=com.itheima -DartifactId=ige-rpc-client -Dversion=igem-1.0 -Dpackaging=jar

效果如下：

开发常见问题

Idea运行程序无法启动

运行程序出现如下错误：

出现这个的原因一般是因为项目需要打印的环境变量太长，超过了限制，需要你缩短命令行来解决问题。解决这个问题，只需要修改工作空间中的配置即可。

#在项目的.idea/workspace.xml文件中，找到
<component name="PropertiesComponent">

#后面在添加下面一行配置即可,这种方式一次设置就行。
<property name="dynamic.classpath" value="true" />