安装JDK1.8

#解压：
tar -zxvf jdk-8u181-linux-x64.tar.gz
#重命名：
mv jdk1.8.0_181/ jdk1.8

#添加配置
vim /etc/profile
# 填写自己的jdk安装的位置
JAVA_HOME=/usr/local/software/jdk1.8
CLASSPATH=$JAVA_HOME/lib/
PATH=$PATH:$JAVA_HOME/bin
export PATH JAVA_HOME CLASSPATH

#环境变量立刻生效
source /etc/profile
#查看安装情况
java -version

安装Zookeeper (默认2181端口)

#解压
tar -zxvf apache-zookeeper-3.7.0-bin.tar.gz
#默认配置文件 zoo.cfg 
cp zoo_sample.cfg  zoo.cfg
#启动zk
./zkServer.sh start

安装Kafka (默认 9092端口)

#解压
tar -zxvf kafka_2.13-2.8.0.tgz

• config目录下 server.properties

#标识broker编号，集群中有多个broker，则每个broker的编号需要设置不同
broker.id=0# listeners 配置的ip和advertised.listeners相同时启动kafka会报错
# 内网ip
#虚拟机配置 listeners=PLAINTEXT://:9092  
listeners=PLAINTEXT://172.21.0.17:9092    
# 公网ip
advertised.listeners=PLAINTEXT://81.70.217.100:9092#修改zk地址,默认地址
zookeeper.connection=localhost:2181

• bin目录启动

  #启动
  ./kafka-server-start.sh  ../config/server.properties &#停止
  ./kafka-server-stop.sh
  

• 创建topic

./kafka-topics.sh --create --zookeeper 192.168.23.129 --replication-factor 1 --partitions 1 --topic xdclass-topic#创建⽣产者发送消息
./kafka-console-producer.sh --broker-list 192.168.23.129:9092 --topic xdclass-topic#运⾏⼀个消费者
./kafka-console-consumer.sh --bootstrap-server 192.168.23.129:9092 --topic xdclass-topic --from-beginning

• 查看topic

./kafka-topics.sh --list --zookeeper 192.168.23.129:2181

• kafka如果直接启动信息会打印在控制台,如果关闭窗口，kafka随之关闭
• 守护进程方式启动

./kafka-server-start.sh -daemon ../config/server.properties &

安装kafka集群

• 没那么多机器，采用伪集群方式搭建（端口号区分）

• • zookeeper部署3个节点
    • 2181
    • 2182
    • 2183
  • kafka部署3个节点
    • 9092
    • 9093
    • 9094

• 网络安全组记得开放端口

  zookeeper集群环境准备

• zookeeper节点端口

  • 2181
  • 2182
  • 2183

• cp -r 复制zk节点

• 修改配置zoo.cfg

#客户端端口
clientPort=2181#数据存储路径
dataDir=/tmp/zookeeper/2181#修改AdminServer的端口：
admin.serverPort=8888

• dataDir对应目录下分别创建myid文件，内容对应1、2、3

cd /tmp/zookeeper/2183
echo 1 > myid

• 配置集群

# server.服务器id=服务器IP地址:服务器直接通信端口:服务器之间选举投票端口server.1=127.0.0.1:2881:3881
server.2=127.0.0.1:2882:3882
server.3=127.0.0.1:2883:3883

• zk命令

#启动zk
./zkServer.sh  start#查看节点状态
./zkServer.sh status#停止节点
./zkServer.sh stop

Kafka高可用集群搭建-环境准备

• 伪集群搭建，3个节点同个机器端口区分
  • 9092
  • 9093
  • 9094
• 配置

#内网中使用，内网部署 kafka 集群只需要用到 listeners，内外网需要作区分时 才需要用到advertised.listeners
listeners=PLAINTEXT://172.18.123.229:9092advertised.listeners=PLAINTEXT://112.74.55.160:9092#每个节点编号1、2、3
broker.id=1#端口
port=9092#配置3个
log.dirs=/tmp/kafka-logs-1#zk地址
zookeeper.connect=localhost:2181,localhost:2182,localhost:2183

安装Redis

#安装gcc
yum install -y gcc-c++ autoconf automake#centos7 默认的 gcc 默认是4.8.5,版本小于 5.3 无法编译,需要先安装gcc新版才能编译
gcc -v#升级新版gcc，配置永久生效
yum -y install centos-release-scl
yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++ devtoolset-9-binutilsscl enable devtoolset-9 bash  
echo "source /opt/rh/devtoolset-9/enable" >>/etc/profile #编译redis
cd redis-6.2.1
make#安装到指定目录
mkdir -p /usr/local/redismake PREFIX=/usr/local/redis install

Docker安装redis

docker run -itd --name xdclass-redis1 -p 6379:6379 -v /mydata/redis/data:/data redis:6.2.4 --requirepass root-i 以交互模式运⾏容器，通常与
-t 同时使⽤;
-d 后台运⾏容器，并返回容器ID;

分布式缓存Redis6常见核心配置讲解

• 你现在必须要知道的配置
  • daemonize yes 配置后台运行，默认no
  • bind 绑定指定ip访问，0.0.0.0是不限制，配置多个ip例子 12.13.432.12 31.12.43.13 用空格隔开
  • port 端口号 默认6379
  • requirepass 密码配置
  • dbfilename 配置redis持久化文件名称
  • dir 配置redis持久化文件存储地址
  • save 配置redis持久化机制
• 创建目录
  • 日志 mkdir /usr/local/redis/log
  • 数据 mkdir /usr/local/redis/data
  • 配置文件 mkdir /usr/local/redis/conf
• 创建自定义配置文件 (使用自带的也行)

#任何ip可以访问
bind 0.0.0.0#守护进程
daemonize yes#密码
requirepass tmhc20170717#日志文件
logfile "/usr/local/redis/log/redis.log"#持久化文件名称
dbfilename xdclass.rdb#持久化文件存储路径
dir /usr/local/redis/data#持久化策略, 10秒内有个1个key改动，执行快照
save 10 1

启动redis指定配置文件

./redis-server ../conf/redis.conf

Redis6.X 主从复制 一主二从架构环境准备

• 配置

mkdir -p /data/redis/master/data 
mkdir -p /data/redis/slave1/data 
mkdir -p /data/redis/slave2/data#从节点开启只读模式(默认)
replica-read-only yes
#从节点访问主节点的密码，和requirepass一样
masterauth 123456
#哪个主节点进行复制
replicaof 8.129.113.233 6379

• 创建主配置文件redis.conf

bind 0.0.0.0
port 6379
daemonize yesrequirepass "123456"logfile "/usr/local/redis/log/redis1.log"
dbfilename "xdclass1.rdb"
dir "/usr/local/redis/data"
appendonly yes
appendfilename "appendonly1.aof"
masterauth "123456"

• 创建两个从配置文件redis.conf

bind 0.0.0.0
port 6380
daemonize yes
requirepass "123456"
logfile "/usr/local/redis/log/redis2.log"
dbfilename "xdclass2.rdb"
dir "/usr/local/redis/data"
appendonly yes
appendfilename "appendonly2.aof"
replicaof 8.129.113.233 6379
masterauth "123456"

• 创建从配置文件redis.conf

bind 0.0.0.0
port 6381
daemonize yes
requirepass "123456"
logfile "/usr/local/redis/log/redis3.log"
dbfilename "xdclass3.rdb"
dir "/usr/local/redis/data"
appendonly yes
appendfilename "appendonly3.aof"
replicaof 8.129.113.233 6379
masterauth "123456"

• 防火墙记得关闭，或者开放对应的端口

  • 阿里云服务器记得开发网络安全组

• 启动

#启动主
./redis-server /data/redis/master/data/redis.conf#启动从
./redis-server /data/redis/slave1/data/redis.conf#启动从
./redis-server /data/redis/slave2/data/redis.conf

• info replication 查看状态
• 主从复制和读写验证
• 防火墙和网络安全组记得开放端口
  • 6379 主节点
  • 6380 从节点
  • 6381 从节点

Redis6.X节点高可用监控之Sentinel哨兵搭建环境准备

• 核心流程
  • 每秒ping，超过时间不响应 则认为主观下线
  • 满足多个，则认为是客观下线
  • 投票选择主节点
  • 如果没有足够的节点同意master下线，则状态会被移除
• 环境准备
  • 配置3个哨兵，每个哨兵的配置都是一样的
  • 启动顺序 先启动主再启动从，最后启动3个哨兵
  • 哨兵端口是 【26379】记得开放

#不限制ip
bind 0.0.0.0# 让sentinel服务后台运行
daemonize yes# 配置监听的主服务器，mymaster代表服务器的名称，自定义，172.18.172.109 代表监控的主服务器，6379代表端口，
#2代表只有两个或两个以上的哨兵认为主服务器不可用的时候，才会进行failover操作。
sentinel monitor mymaster 172.18.172.109 6379 2# sentinel auth-pass定义服务的密码，mymaster是服务名称，123456是Redis服务器密码
sentinel auth-pass mymaster 123456#超过5秒master还没有连接上，则认为master已经停止
sentinel down-after-milliseconds mymaster 5000#如果该时间内没完成failover操作，则认为本次failover失败
sentinel failover-timeout mymaster 30000

• 在目录下创建3个文件sentinel-1.conf、sentinel-2.conf、sentinel-3.conf

  port 26379
  bind 0.0.0.0
  daemonize yes
  pidfile "/var/run/redis-sentinel-1.pid"
  logfile "/var/log/redis/sentinel_26379.log"
  dir "/tmp"
  sentinel monitor mymaster 8.129.113.233 6379 2
  sentinel down-after-milliseconds mymaster 5000
  sentinel auth-pass mymaster 123456
  sentinel failover-timeout mymaster 30000
  

  port 26380
  bind 0.0.0.0
  daemonize yes
  pidfile "/var/run/redis-sentinel-2.pid"
  logfile "/var/log/redis/sentinel_26380.log"
  dir "/tmp"
  sentinel monitor mymaster 8.129.113.233 6379 2
  sentinel down-after-milliseconds mymaster 5000
  sentinel auth-pass mymaster 123456
  sentinel failover-timeout mymaster 30000
  

  port 26381
  bind 0.0.0.0
  daemonize yes
  pidfile "/var/run/redis-sentinel-3.pid"
  logfile "/var/log/redis/sentinel_26381.log"
  dir "/tmp"
  sentinel monitor mymaster 8.129.113.233 6379 2
  sentinel down-after-milliseconds mymaster 5000
  sentinel auth-pass mymaster 123456
  sentinel failover-timeout mymaster 30000
  

  • 记得创建 /var/log/redis 文件夹

• 启动哨兵集群

./redis-server /usr/local/redis/conf/sentinel-1.conf --sentinel./redis-server /usr/local/redis/conf/sentinel-2.conf --sentinel./redis-server /usr/local/redis/conf/sentinel-3.conf --sentinel

Redis6.X高可用之Cluster集群和分片

• 说明
  • 旧版本的需要使用ruby语言进行构建，新版5之后直接用redis-cli即可
  • 6个节点，三主双从，主从节点会自动分配，不是人工指定
  • 主节点故障后，从节点会替换主节点
• 注意点：
  • 把之前的rdb、aof文件删除
• 节点(网络安全组开放端口)
  • 6381、6382
  • 6383、6384
  • 6385、6386

• 配置

bind 0.0.0.0
port 6381
daemonize yes
requirepass "123456"
logfile "/usr/local/redis/log/redis1.log"
dbfilename "xdclass1.rdb"
dir "/usr/local/redis/data"
appendonly yes
appendfilename "appendonly1.aof"
masterauth "123456"#是否开启集群
cluster-enabled yes# 生成的node文件，记录集群节点信息，默认为nodes.conf，防止冲突，改为nodes-6381.conf
cluster-config-file nodes-6381.conf#节点连接超时时间
cluster-node-timeout 20000#集群节点的ip，当前节点的ip
cluster-announce-ip 172.18.172.109#集群节点映射端口
cluster-announce-port 6381#集群节点总线端口,节点之间互相通信，常规端口+1万
cluster-announce-bus-port 16381

bind 0.0.0.0
port 6386
daemonize yes
requirepass "123456"
logfile "/usr/local/redis/log/redis6.log"
dbfilename "xdclass6.rdb"
dir "/usr/local/redis/data"
appendonly yes
appendfilename "appendonly6.aof"
masterauth "123456"cluster-enabled yes
cluster-config-file nodes-6386.conf
cluster-node-timeout 20000
cluster-announce-ip 172.18.172.109
cluster-announce-port 6386
cluster-announce-bus-port 16386

• 启动6个节点

./redis-server ../conf/cluster/redis1.conf
./redis-server ../conf/cluster/redis2.conf
./redis-server ../conf/cluster/redis3.conf
./redis-server ../conf/cluster/redis4.conf
./redis-server ../conf/cluster/redis5.conf
./redis-server ../conf/cluster/redis6.conf

• 加入集群(其中一个节点执行即可)
  • –cluster 构建集群全部节点信息
  • –cluster-replicas 1 主从节点的比例，1表示1主1从的方式

./redis-cli -a 123456 --cluster create 172.18.172.109:6381 172.18.172.109:6382 172.18.172.109:6383 172.18.172.109:6384 172.18.172.109:6385 172.18.172.109:6386 --cluster-replicas 1

• 检查状态信息(其中一个节点执行即可)

./redis-cli -a 123456 --cluster check 172.18.172.109:6381

• 集群状态

./redis-cli -c -a 123456 -p 6379#集群信息
cluster info#节点信息
cluster nodes

开启swap分区

查看swap信息，可以利用“free -m”显示

以上显示swap的总数为0，证明没有开启swap分区

创建方式如下：

1、创建一个swap文件

cd /var
mkdir swap
dd if=/dev/zero of=swapfile bs=1024 count=2000000

count代表创建2G大小

2、把文件转换为swap文件

#在var目录执行
mkswap swapfile

3、激活swap文件

（1）可以直接使用命令挂载一个swap分区，但是重启要重新挂载

#挂载
swapon /var/swapfile#如果不需要了，可以卸载
swapoff /var/swapfile

（2）如果需要开机自动挂载，可以把它添加到/etc/fstab文件中

#编辑/etc/fstab末行添加
/var/swapfile    swap    swap defaults    0    0

再执行swapon /var/swapfile

4、这样就完成增加swap分区，可以用free -m来查看结果

安装Nginx

# 解压tar -zxvf nginx-1.9.9.tar.gz cd nginx-1.9.9/#安装
./configure --with-http_ssl_module --with-http_gzip_static_module
make
make install  
cd /usr/local/nginx/sbin/
# 启动程序    
./nginx   
# 关闭程序
./nginx -s stop
# 查看运行状态
#ps aux | grep nginx    

make可能出错

cd objs/
修改Makefile  
删除 -Werror

nginx前端项目代理地址配置
在/usr/local/nginx/conf目录下配置nginx.conf文件只要修改root即可，（root为项目打包后文件的存放路径。）
修改配置代码如下：

server {listen       9104;server_name  localhost;#charset koi8-r;#access_log  logs/host.access.log  main;location / {root   /home/kaifa01/purchase/web/dist;index  index.html index.htm;}add_header Access-Control-Allow-Origin "*";default_type 'text/html';charset utf-8;#error_page  404              /404.html;}

配置多个

   location / {root   /asset/dist;index  index.html index.htm;}location /audit {alias   /audit/dist;index  index.html index.htm;}location /meta {alias   /meta/dist;index  index.html index.htm;}

安装Docker

关闭防火墙：systemctl stop firewalld.service vi /etc/selinux/config

#添加yum源
yum update
yum install epel-release -y
yum clean all
yum list
#安装并运行Docker
yum install docker-io -y
systemctl start docker
#检查安装结果
docker info
#启动使用Docker
systemctl start docker #运⾏Docker守护进程
systemctl stop docker #停⽌Docker守护进程
systemctl restart docker #重启Docker守护进程

查看本地镜像：docker images
搜索镜像：docker search centos
搜索镜像并过滤是官方的： docker search --filter "is-official=true" centos
搜索镜像并过滤大于多少颗星星的：docker search --filter stars=10 centos
下载centos7镜像：docker pull centos:7
修改本地镜像名字（小写）：docker tag centos:7 mycentos:1
本地镜像的删除：docker rmi centos:7

配置阿里云镜像加速

vi /etc/docker/daemon.json

{"registry-mirrors": ["https://qkmzgrtd.mirror.aliyuncs.com"]
}

重启：systemctl daemon-reload && systemctl restart docker

#运行一个容器
docker run --name nginx-xd -p 8080:80 -d nginx
docker run - 运⾏⼀个容器-d 后台运⾏-p 端⼝映射--name "xxx" 容器名称

6 Docker核心基础之容器的构建等基本操作
简介：Docker容器的创建，查看，停止，重启等
构建容器：docker run -itd --name=mycentos centos:7
-i：表示以交互模式运行容器（让容器的标准输入保持打开）
-d：表示后台运行容器，并返回容器ID
-t：为容器重新分配一个伪输入终端
--name：为容器指定名称
查看本地所有的容器：docker ps -a
查看本地正在运行的容器：docker ps
停止容器：docker stop CONTAINER_ID / CONTAINER_NAME
一次性停止所有容器：docker stop $(docker ps -a -q)
启动容器：docker start CONTAINER_ID / CONTAINER_NAME
重启容器：docker restart CONTAINER_ID / CONTAINER_NAME
删除容器：docker rm CONTAINER_ID / CONTAINER_NAME
强制删除容器：docker rmi -f CONTAINER_ID / CONTAINER_NAME
查看容器详细信息：docker inspect CONTAINER_ID / CONTAINER_NAME
进入容器：docker exec -it 0ad5d7b2c3a4 /bin/bash

编写dockerfile文件（springboot_dockerfile）：启动springboot项目

FROM java:8
MAINTAINER xuhongwei
ADD demo-0.0.1-SNAPSHOT.jar app.jar
CMD java -jar app.jar

#启动dockerfile文件
docker build -f ./springboot_dockerfile -t app . 
#启动镜像
docker run -id app
#端口映射
docker run -id -p 9000:7000 app

安装Docker Compose 服务编排

#安装
curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
#设置文件可执行权限
chmod +x /usr/local/bin/docker-cpmpose
#查看版本信息
docker-compose -version
#卸载
rm /usr/local/bin/docker-compose

使用docker compose编排nginx+springboot项目

1.创建docker-compose目录

mkdir ~/docker-compose
cd ~/docker-compose

2.编写docker-compose.yml文件

version: '3'
services:nginx:image: nginxports:- 80:80links:- appvolumes:- ./nginx/conf.d:/etc/nginx/conf.dapp:image: appexpose:- "8080"

3.创建./nginx/conf.d目录

mkdir -p ./nginx/conf.d

4.在./nginx/conf.d目录下编写***.conf文件

server{listen 80;access_log off;location / {proxy_pass http://app:8080}
}

5.在 ~/docker-compose目录下使用docker-compose启动容器

docker-compose up 
#后台启动
docker-compose up -d 

6.测试访问

Docker私有仓库

# 1、拉取私有仓库镜像
docker pull registry
# 2、启动私有仓库容器
docker run -id --name=registry -p 5000:5000 registry
# 3、打开浏览器 输入http://私有仓库服务器ip:5000/v2/_catalog,看到{"repositories":[]}标识私有仓库搭建成功
# 4、修改daemon.json
vim /etc/docker/daemon.json
# 在上述文件中添加一个key，保存退出。此步用于让docker 信任私有仓库地址；注意将私有仓库服务器ip修改为自己私有仓库服务器真是ip
{"insecure-registries":["私有仓库服务器ip:5000"]}
# 5、重启docker服务
systemctl restart docker
docker start registry

将镜像上传至私有仓库

# 1、标记镜像为私有仓库的镜像
docker tag centos:7 私有仓库服务器ip:5000/centos:7
# 2、上传标记的镜像
docker push 私有仓库服务器ip:5000/centos7

拉取镜像

docker pull 私有仓库服务器ip:5000/centos:7

项目整合Docker

• 添加依赖

 <properties><docker.image.prefix>xdclass-cloud</docker.image.prefix></properties><build><finalName>alibaba-cloud-gateway</finalName><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><executions><execution><goals><goal>repackage</goal></goals></execution></executions><configuration><fork>true</fork><addResources>true</addResources></configuration></plugin><plugin><groupId>com.spotify</groupId><artifactId>dockerfile-maven-plugin</artifactId><version>1.4.10</version><configuration><repository>${docker.image.prefix}/${project.artifactId}</repository><buildArgs><JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE></buildArgs></configuration></plugin></plugins></build>

微服务Docker镜像打包整合JDK11

• 创建Dockerfile,默认是根⽬录，（可以修改为 src/main/docker/Dockerfile,如果修则需要制定路径）
• 什么是Dockerfile
  • 由⼀系列命令和参数构成的脚本，这些命令应⽤于基础 镜像, 最终创建⼀个新的镜像

FROM adoptopenjdk/openjdk11:ubi
VOLUME /tmp
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]/*FROM <image>:<tag> 需要⼀个基础镜像，可以是公共的或者是私有的，后续构建会基于此镜像，如果同⼀个Dockerfile中建⽴多个镜像时，可以使⽤多个FROM指令
VOLUME 配置⼀个具有持久化功能的⽬录，主机/var/lib/docker ⽬录下创建了⼀个临时⽂件，并链接到容器的/tmp。改步骤是可选的，如果涉及到⽂件系统的应⽤就很有必要了/tmp⽬录⽤来持久化到 Docker 数据⽂件夹，因为Spring Boot 使⽤的内嵌 Tomcat 容器默认使⽤/tmp作为⼯作⽬录
ARG 设置编译镜像时加⼊的参数， JAR_FILE 是设置容器的环境变量(maven⾥⾯配置的)
COPY : 只⽀持将本地⽂件复制到容器 ,还有个ADD更强⼤但复杂点
ENTRYPOINT 容器启动时执⾏的命令
EXPOSE 8080 暴露镜像端⼝*/

• 构建镜像( 去到⼦模块pom⽂件下)

mvn install -Dmaven.test.skip=true dockerfile:build

推送镜像到阿里云仓库（网关服务）

#登录
docker login --username=哼哼与瑾禾 registry.cn-hangzhou.aliyuncs.com
#密码
xuhw19950118
#将镜像推送到Registry
#docker tag 4db9c092245f registry.cn-hangzhou.aliyuncs.com/xuhongwei/cloud_gateway:v1.0
docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/xuhongwei/cloud_gateway:[镜像版本号]#docker push registry.cn-hangzhou.aliyuncs.com/xuhongwei/cloud_gateway:v1.0
docker push registry.cn-hangzhou.aliyuncs.com/xuhongwei/cloud_gateway:[镜像版本号]#从Registry中拉取镜像
#docker pull registry.cn-hangzhou.aliyuncs.com/xuhongwei/cloud_gateway:v1.0
docker pull registry.cn-hangzhou.aliyuncs.com/xuhongwei/cloud_gateway:[镜像版本号]

安装SVN

#安装
yum install subversion

配置

我们这里在/home下建立一个名为svn的仓库（repository），以后所有代码都放在这个下面，创建成功后在svn下面多了几个文件夹。

[root@localhost /]# cd /home
[root@localhost home]# mkdir svn
[root@localhost home]# svnadmin create /home/svn
[root@localhost home]# ls svn
conf  db  format  hooks  locks  README.txt

我们这里特别关注一下conf文件夹，这个是存放配置文件的

[root@localhost home]# cd svn/conf
[root@localhost conf]# ls
authz  passwd  svnserve.conf

其中：

• authz 是权限控制文件
• passwd 是帐号密码文件
• svnserve.conf 是SVN服务配置文件

接下来我们依次修改这3个文件。

2.2. 配置passwd

[root@localhost conf]# vi passwd 
[users]
test1=123456
test2=123456

上面的例子中我们创建了2个用户，一个test1，一个test2

2.3. 配置authz

[root@localhost conf]# vi authz 
[/]
liuxianan=rw
test1=r
test2=r
*=

上面配置的含义是，liuxianan对/home/svn/下所有文件具有可读可写权限，test只有只读权限，除此之外，其它用户均无任何权限，最后一行*=很重要不能少。

2.3.1. 拓展：使用用户分组

这个我一般不用，但是记录下来。

还是这个文件：

[root@localhost conf]# vi authz
[groups]
group1 = liuxianan
group2 = test1,test2
[/]
@group1 = rw
@group2 = r
* =

上面配置中创建了2个分组，分组1的用户可读可写，分组2的用户只读。

格式说明：

版本库目录格式：
[<版本库>:/项目/目录]
@<用户组名> = <权限>
<用户名> = <权限>

2.4. 配置svnserve.conf

[root@localhost conf]# vi svnserve.conf 
打开下面的5个注释
anon-access = read #匿名用户可读
auth-access = write #授权用户可写
password-db = passwd #使用哪个文件作为账号文件
authz-db = authz #使用哪个文件作为权限文件
realm = /home/svn # 认证空间名，版本库所在目录

2点注意：

• 最后一行的realm记得改成你的svn目录
• 打开注释时切记前面不要留有空格，否则可能有问题（网上说的，我没有亲测）

启动与停止

[root@localhost conf]# svnserve -d -r /home/svn（启动）
[root@localhost conf]#killall svnserve（停止）

上述启动命令中，-d表示守护进程， -r 表示在后台执行。停止还可以采用杀死进程的方式：

[root@localhost conf]# ps -ef|grep svnserve
root      4908     1  0 21:32 ?        00:00:00 svnserve -d -r /home/svn
root      4949  4822  0 22:05 pts/0    00:00:00 grep svnserve
[root@localhost conf]# kill -9 4908

最后来个总的截图：

客户端连接

这里使用TortoiseSVN，输入地址svn://你的IP 即可，不出意外输入用户名和密码就能连接成功了。

默认端口3690，如果你修改了端口，那么要记得加上端口号。

安装ElasticSearch

首先要安装jdk

启动⼀定要使⽤⾮root账户！！！这是es强制规定的。 Elasticsearch为了安全考虑，不让使 ⽤root启动，解决⽅法是新建⼀个⽤户，⽤此⽤户进⾏相关的操作。如果你⽤root启动，会 报错。

#添加用户
adduser es
#设定密码
passwd es

如果是使⽤root账号安装es的，⾸先给安装包授权，⽐如chown -R 777 ‘安装包路 径’，然后再使⽤⾮root账号启动，具体的权限配置，可以根据⾃⼰想要的来配置。

#授权
chown -R es:es /usr/local/software/elasticsearch-7.2.0#修改配置文件  默认-Xms1g    -Xmx1g 修改如下
vi jvm.options    

#编辑elasticsearch.yml修改数据和日志目录
vi elasticsearch.yml#内容
node.name: node-1 #配置当前es节点名称（默认是被注释的，并且默认有一个节点名）
cluster.name: my-application #默认是被注释的，并且默认有一个集群名path.data: /home/es/data # 数据目录位置
path.logs: /home/es/logs # 日志目录位置network.host: 0.0.0.0   #绑定的ip：默认只允许本机访问，修改为0.0.0.0后则可以远程访问
cluster.initial_master_nodes: "node-1" #默认是被注释的 设置master节点列表 用逗号分隔
#cluster.initial_master_nodes: ["node-1", "node-2"] #默认是被注释的 设置master节点列表 用逗号分隔   ###############两个节点怎么用的，目前不清楚，备注一下

#修改/etc/security/limits.conf文件 增加配置
vi /etc/security/limits.conf #在文件最后，增加如下配置：
* soft nofile 65536
* hard nofile 65536vi /etc/sysctl.conf
#在文件最后添加内容
vm.max_map_count=655360#保存后 执行命令
sysctl -p

linux，打开软件的安装路径，将所有文件权限迭代给es用户 进⼊到bin⽬录

#切换es用户
su es
#执⾏
sh elasticsearch
#守护进程的⽅式可以使⽤
nohup elasticsearch/bin/elasticsearch &

windows，打开软件的安装路径，进⼊到bin⽬录，双击elasticsearch.bat。

验证 打开浏览器输⼊localhost:9200

搭建集群

1、搭建步骤 拷⻉elasticsearch-7.2.0安装包3份，分别命名elasticsearch-7.2.0-a, elasticsearch-7.2.0-b, elasticsearch-7.2.0-c。

2、分别修改elasticsearch.yml⽂件。

3、分别启动a ,b ,c 三个节点。 打开浏览器输⼊：http://localhost:9200/_cat/health?v ,如果返回的node.total是3，代表集 群搭建成功

4、配置elasticsearch.yml⽂件

#集群名称
cluster.name: my-application
#节点名称
node.name: node-1
#是不是有资格主节点
node.master: true
#是否存储数据
node.data: true
#最⼤集群节点数
node.max_local_storage_nodes: 3
#⽹关地址
network.host: 0.0.0.0
#端⼝
http.port: 9200
#内部节点之间沟通端⼝  单机情况下配置
transport.tcp.port: 9300
#es7.x 之后新增的配置，写⼊候选主节点的设备地址，在开启服务后可以被选为主节点
discovery.seed_hosts: ["localhost:9300","localhost:9400","localhost:9500"]
#es7.x 之后新增的配置，初始化⼀个新的集群时需要此配置来选举master
cluster.initial_master_nodes: ["node-1", "node-2","node-3"]
#数据和存储路径
path.data: /Users/louis.chen/Documents/study/search/storage/a/data
path.logs: /Users/louis.chen/Documents/study/search/storage/a/logs

kibana

kibana⼯具的安装和使⽤

简介：可视化⼯具kibana的安装和使⽤ 下载 https://www.elastic.co/cn/downloads/kibana 选择对应版本 启动 进⼊到⽂件夹的bin⽬录，

#执⾏
sh kibana 
#访问
localhost:5601

集群情况下kibana设置

打开配置 kibana.yml，

添加elasticsearch.hosts: [“http://localhost:9200”,“http://localhost: 9201”,“http://localhost:9202”]

启动kibana，可以看到集群信息

安装Nacos（注册中心+配置中心）

解压安装包

进⼊bin⽬录

#启动 
sh startup.sh -m standalone
#关闭
sh shutdown.sh#访问 ip:8848/nacos
#默认账号密码 nacos/nacos

Docker部署Nacos

#拉取镜像
docker pull nacos/nacos-server
#查看镜像
docker images
#启动Nacos
docker run --env MODE=standalone --name xdclass-nacos -d -p 8848:8848 bdf60dc2ada3 (镜像id)
#查看日志
docker logs -f id

项目集成Nacos（注册中心）

• 添加依赖

<!--添加nacos客户端-->
<dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

server:port: 9000
spring:application:name: xdclass-video-servicecloud:nacos:discovery:server-addr: 127.0.0.1:8848

• 启动类添加配置

@EnableDiscoveryClient

Nacos配置中心

• 添加依赖

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

• 讲解Nacos作为配置中⼼实战
  • 不能使⽤原先的application.yml, 需要使⽤ bootstrap.yml作为配置⽂件
  • 配置读取优先级 bootstrap.yml > application.yml

spring:application:name: xdclass-order-servicecloud:nacos:config:server-addr: 127.0.0.1:8848 #Nacos配置中⼼地址file-extension: yaml #⽂件拓展格式profiles:active: dev

• 讲解Nacos动态刷新配置
  • 我们修改了配置，程序不能⾃动更新
  • 动态刷新就可以解决这个问题
• 在类上添加注解

@RefreshScope
public class OrderController {@Value("${video.title}")private String videoTitle;
}

#启动微服务验证
http://127.0.0.1:8848/nacos/v1/cs/configs?dataId=xdclass-order-service-dev.yaml&group=DEFAULT_GROUP
#如果出现 config dta not exist 建议重启nacos
#重新构建下项⽬
mvn clean package -U
#然后重启IDEA

• dataId组成，在 Nacos Spring Cloud 中，dataId 的完整 格式如下

  ${prefix}-${spring.profiles.active}.${file-extension}
  prefix 默认为 spring.application.name 的值
  spring.profiles.active 即为当前环境对应的 profile当 spring.profiles.active 为空时，对应的连接符 - 也将不存在，dataId 的拼接格式变成 ${prefix}.${file-extension}
  file-exetension 为配置内容的数据格式，可以通过配置项spring.cloud.nacos.config.file-extension 来配置。⽬前只⽀持 properties 和 yaml 类型。
  

Nacos注册中心配置mysql持久化

• nacos数据库脚本

  • 导入数据库脚本
  • 新增一个用户 nacos/nacos

  INSERT INTO `users` (`username`, `password`, `enabled`)
  VALUES('nacos', '$2a$10$EuWPZHzz32dJN7jexM34MOeYirDdFAZm2kuWj7VEOJhhZkDrxfvUu', 1);
  

• mysql最好使用5.7版本（业界用的比较多，稳定）

• 启动命令

docker run -d \
-e MODE=standalone \
-e SPRING_DATASOURCE_PLATFORM=mysql \
-e MYSQL_SERVICE_HOST=192.168.23.129 \
-e MYSQL_SERVICE_PORT=3306 \
-e MYSQL_SERVICE_USER=root \
-e MYSQL_SERVICE_PASSWORD=root \
-e MYSQL_SERVICE_DB_NAME=xdclass_nacos \
-p 8848:8848 \
--restart=always \
--name nacos \
nacos/nacos-server 

• 访问（大家改成自己的ip）
  • http://192.168.23.129:8848/nacos

Sentinel(流量控制)

#启动 Sentinel 控制台需要 JDK 版本为 1.8 及以上版本
-Dserver.port=8081 ⽤于指定 Sentinel 控制台端⼝为 8081
#默认⽤户名和密码都是 sentinel

#启动jar包
nohup java -Dserver.port=8081 -Dcsp.sentinel.dashboard.server=192.168.23.129:8081 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.8.0.jar &#访问
http://ip:8081

Docker部署Sentinel

#拉取镜像
docker pull bladex/sentinel-dashboard:latest
#查看镜像
docker images
#启动Nacos
docker run --name sentinel -d -p 8858:8858 aa398704ebd3 镜像id
#查看日志
docker logs -f id

AlibabaCloud微服务整合Sentinel限流

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

spring:cloud:sentinel:transport:dashboard: 127.0.0.1:8081port: 9999
#dashboard: 8081 控制台端⼝
#port: 9999 本地启的端⼝，随机选个不能被占⽤的，与dashboard进⾏数据交互，会在应⽤对应的机器上启动⼀个Http Server，该 Server 会与 Sentinel 控制台做交互, 若被占⽤,则开始+1⼀次扫描

• 微服务注册上去后，由于Sentinel是懒加载模式，所以需 要访问微服务后才会在控制台出现

安装MySQL

#解压
tar -xvf mysql-5.7.26-linux-glibc2.12-x86_64.tar #移动并重命名
mv mysql-5.7.26-linux-glibc2.12-x86_64 /usr/local/mysql#创建MySQL用户组和用户并修改权限
groupadd mysql
useradd -r -g mysql mysql#创建数据目录并赋予权限
mkdir -p  /data/mysql              #创建目录
chown mysql:mysql -R /data/mysql   #赋予权限#配置my.cnf
vim /etc/my.cnf#内容如下
[mysqld]
bind-address=0.0.0.0
port=3306
user=mysql
basedir=/usr/local/mysql
datadir=/data/mysql
socket=/tmp/mysql.sock
log-error=/data/mysql/mysql.err
pid-file=/data/mysql/mysql.pid
#character config
character_set_server=utf8mb4
symbolic-links=0
explicit_defaults_for_timestamp=true#初始化数据库
#进入mysql的bin目录
cd /usr/local/mysql/bin/#初始化
./mysqld --defaults-file=/etc/my.cnf --basedir=/usr/local/mysql/ --datadir=/data/mysql/ --user=mysql --initialize#查看密码
cat /data/mysql/mysql.err

#启动MySQL，并更改root密码
#先将mysql.server放置到/etc/init.d/mysql中
cp /usr/local/mysql/support-files/mysql.server /etc/init.d/mysql# 启动与停止解压包安装
service mysql start
service mysql stop
#重启
service mysql restart#查看
ps -ef | grep mysql#在bin目录下登录MySQL
./mysql -u root -p   #首次输入上面默认密码#修改密码
SET PASSWORD = PASSWORD('root');
ALTER USER 'root'@'localhost' PASSWORD EXPIRE NEVER;
FLUSH PRIVILEGES;   #外部访问MySQL
use mysql                                            #访问mysql库
update user set host = '%' where user = 'root';      #使root能再任何host访问
FLUSH PRIVILEGES;                                    #刷新

#命令安装的MySQL 启动 /bin目录
systemctl restart mysqld.service
systemctl start mysqld.service
systemctl stop mysqld.service

Docker安装MySQL

docker run -p 3306:3306 --name xdclass_mysql \
-v /usr/local/docker/mysql/conf:/etc/mysql \
-v /usr/local/docker/mysql/logs:/var/log/mysql \
-v /usr/local/docker/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:5.7# \ 换行
# -v 目录映射  左边是宿主机目录 右边是容器目录

安装MySQL审计工具Audit Plugin

#解压
unzip  audit-plugin-mysql-5.7-1.1.4-725-linux-x86_64.zip 

查看MySQL的插件目录

> show variables like 'plugin_dir';
+---------------+------------------------------+
| Variable_name | Value                        |
+---------------+------------------------------+
| plugin_dir    | /usr/local/mysql/lib/plugin/ |
+---------------+------------------------------+

复制库文件到MySQL库目录下：

# cp audit-plugin-mysql-5.7-1.1.4-725/lib/libaudit_plugin.so /usr/local/mysql/lib/plugin/
# chmod a+x libaudit_plugin.so

进入mysql命令窗口，安装插件：

> install plugin audit soname 'libaudit_plugin.so';
Query OK, 0 rows affected (0.06 sec) 

查看mysql当前已经加载了哪些插件：

> show plugins;
+----------------------------+----------+--------------------+--------------------+---------+
| Name                       | Status   | Type               | Library            | License |
+----------------------------+----------+--------------------+--------------------+---------+
| binlog                     | ACTIVE   | STORAGE ENGINE     | NULL               | GPL     |
| mysql_native_password      | ACTIVE   | AUTHENTICATION     | NULL               | GPL     |
| sha256_password            | ACTIVE   | AUTHENTICATION     | NULL               | GPL     |
| MyISAM                     | ACTIVE   | STORAGE ENGINE     | NULL               | GPL     |
| PERFORMANCE_SCHEMA         | ACTIVE   | STORAGE ENGINE     | NULL               | GPL     |
| InnoDB                     | ACTIVE   | STORAGE ENGINE     | NULL               | GPL     |
| INNODB_TRX                 | ACTIVE   | INFORMATION SCHEMA | NULL               | GPL     |
| INNODB_LOCKS               | ACTIVE   | INFORMATION SCHEMA | NULL               | GPL     |…………
| MRG_MYISAM                 | ACTIVE   | STORAGE ENGINE     | NULL               | GPL     |
| MEMORY                     | ACTIVE   | STORAGE ENGINE     | NULL               | GPL     |
| CSV                        | ACTIVE   | STORAGE ENGINE     | NULL               | GPL     |
| BLACKHOLE                  | ACTIVE   | STORAGE ENGINE     | NULL               | GPL     |
| partition                  | ACTIVE   | STORAGE ENGINE     | NULL               | GPL     |
| FEDERATED                  | DISABLED | STORAGE ENGINE     | NULL               | GPL     |
| ARCHIVE                    | ACTIVE   | STORAGE ENGINE     | NULL               | GPL     |
| ngram                      | ACTIVE   | FTPARSER           | NULL               | GPL     |
| rpl_semi_sync_master       | ACTIVE   | REPLICATION        | semisync_master.so | GPL     |
| rpl_semi_sync_slave        | ACTIVE   | REPLICATION        | semisync_slave.so  | GPL     |
| AUDIT                      | ACTIVE   | AUDIT              | libaudit_plugin.so | GPL     |
+----------------------------+----------+--------------------+--------------------+---------+

查看版本：

> show global status like '%audit%';
+------------------------+-----------+
| Variable_name          | Value     |
+------------------------+-----------+
| Audit_protocol_version | 1.0       |
| Audit_version          | 1.1.4-725 |
+------------------------+-----------+

开启Audit功能：

> SET GLOBAL audit_json_file=ON;
Query OK, 0 rows affected (0.00 sec)

执行任何语句（默认会记录任何语句，有语法错误的不会记录），然后去mysql数据目录查看mysql-audit.json文件（默认为该文件）。

插入一些数据，查看一下mysql-audit.json文件信息（json格式）该文件保存在 /data/mysql目录下，如下：

{"msg-type": "activity","date": "1510038432019","thread-id": "43","query-id": "1891","user": "root","priv_user": "root","ip": "","host": "localhost","connect_attrs": {"_os": "linux-glibc2.5","_client_name": "libmysql","_pid": "4009","_client_version": "5.7.9","_platform": "x86_64","program_name": "mysql"},"pid": "4009","os_user": "root","appname": "mysql","rows": "1","cmd": "insert","objects": [{"db": "part","name": "e","obj_type": "TABLE"}],"query": "insert into e values (9898,'smart','james')"
}

可以查看插件有哪些可配置的参数：

mysql>  SHOW GLOBAL VARIABLES LIKE '%audi%'; 

其中我们需要关注的参数有：

1. audit_json_file
是否开启audit功能。2. audit_json_log_file
记录文件的路径和名称信息（默认放在mysql数据目录下）。3. audit_record_cmds
audit记录的命令，默认为记录所有命令。可以设置为任意dml、dcl、ddl的组合。如：audit_record_cmds=select,insert,delete,update。还可以在线设置set global audit_record_cmds=NULL。(表示记录所有命令)4. audit_record_objs
audit记录操作的对象，默认为记录所有对象，可以用SET GLOBAL audit_record_objs=NULL设置为默认。也可以指定为下面的格式：audit_record_objs=,test.*,mysql.*,information_schema.*。5. audit_whitelist_users
用户白名单。

详细的参数说明，可以直接访问官方说明：

https://github.com/mcafee/mysql-audit/wiki/Configuration

#最后为了保证重启数据库，配置不丢失，修改my.cnf 配置文件，将下面的配置添加到[mysqld]中，所以在配置文件中my.cnf加入参数：
vim /etc/my.cnf
#保证mysql重启后自动启动插件
audit_json_file=on  
#防止删除了插件，重启后又会加载
plugin-load=AUDIT=libaudit_plugin.so  
#要记录哪些命令语句,因为默认记录所有操作；
audit_record_cmds='insert,delete,update,create,drop,alter,grant,truncate'#保存重启即可看到效果。

插件卸载

直接执行 UNINSTALL PLUGIN AUDIT 卸载会报错：

> uninstall plugin AUDIT;
ERROR 1148 (42000): Uninstall AUDIT plugin disabled> set audit_uninstall_plugin=on;
ERROR 1238 (HY000): Variable 'audit_uninstall_plugin' is a read only variable

需要在 my.cnf 中 [mysqld] 下添加 audit_uninstall_plugin=1，重启mysql。重启完毕后执行两次 UNINSTALL PLUGIN AUDIT; 即可卸载。

> UNINSTALL PLUGIN AUDIT;
ERROR 1620 (HY000): Uninstall AUDIT plugin must be called again to complete
> UNINSTALL PLUGIN AUDIT;
Query OK, 0 rows affected, 1 warning (0.01 sec)

卸载完成后需要从 my.cnf 中删除 audit_uninstall_plugin=1 ，否则下次mysql启动会报错：[ERROR] /data/mysql/bin/mysqld: unknown variable ‘audit_uninstall_plugin=1’

链路追踪组件Zipkin+Sleuth

• 原理

1、sleuth收集跟踪信息通过http请求发送给zipkin server
2、zipkin server进⾏跟踪信息的存储以及提供Rest API即可
3、Zipkin UI调⽤其API接⼝进⾏数据展示默认存储是内存，可也⽤mysql或者elasticsearch等存储

• 持久化配置：mysql或者elasticsearch

#启动jar包
nohup java -jar zipkin-server-2.12.9-exec.jar --STORAGE_TYPE=mysql --MYSQL_HOST=192.168.1.6 --MYSQL_TCP_PORT=3306 --MYSQL_DB=zipkin_log --MYSQL_USER=root --MYSQL_PASS=root &#访问
http://ip:9411

[order-service,96f95a0dd81fe3ab,852ef4cfcdecabf3,false]第⼀个值，spring.application.name的值第⼆个值，96f95a0dd81fe3ab ，sleuth⽣成的⼀个ID，叫Trace ID，⽤来标识⼀条请求链路，⼀条请求链路中包含⼀个Trace ID，多个Span ID第三个值，852ef4cfcdecabf3、spanid 基本的⼯作单元，获取元数据，如发送⼀个http第四个值：false，是否要将该信息输出到zipkin服务中来收集和展示。

• 各个微服务添加依赖

<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>

spring:application:name: api-gatewayzipkin:base-url: http://127.0.0.1:9411/ #zipkin地址discovery-client-enabled: false #不⽤开启服务发现sleuth:sampler:probability: 1.0 #采样百分⽐

默认为0.1，即10%，这⾥配置1，是记录全部的sleuth信息，是为了收集到更多的数据（仅供测试⽤）。在分布式系统中，过于频繁的采样会影响系统性能，所以这⾥配置需要采⽤⼀个合适的值。

Docker部署ZipKin

#拉取镜像
docker pull openzipkin/zipkin:latest
#查看镜像
docker images
#启动Nacos
docker run --name xdclass-zipkin -d -p 9411:9411 镜像id
#查看日志
docker logs -f id

Flink WebUI可视化界⾯

• nc命令介绍

  • Linux nc命令⽤于设置⽹络路由的

  • nc -lk 8888

  • 开启 监听模式，⽤于指定nc将处于监听模式, 等待客户端来链 接指定的端⼝

• linux 安装(二选一)
  • yum install -y netcat
  • yum install -y nc
• 访问 IP:8081
• 查看端口的进程 lsof -i:8081

Flink安装

#解压
tar -zxvf flink-1.13.1-bin-scala_2.12.tgz
#修改配置文件 conf目录 flink-conf.yaml
#web ui 端⼝
rest.port=8081
#调整，我的机器是2、4、8g都有的，⼤家最好买4g或者8g
jobmanager.memory.process.size: 1000m
taskmanager.memory.process.size: 1000m
#启动 进入bin目录 
./start-cluster.sh
#停⽌ 
./stop-cluster.sh
#查看进程 jps
TaskManagerRunner
StandaloneSessionClusterEntrypoint
#访问
http://ip:8081

测试

#创建文件
cd /usr/local/software/flink/examples
mkdir source
cd source
vim xdclass_source.txt
#写入内容
java xdclass
springboot springcloud
html flink
springboot redis
java flink
kafka flink
java springboot#bin目录运行
./flink run /usr/local/software/flink/examples/batch/WordCount.jar --input \
/usr/local/software/flink/examples/source/xdclass_source.txt --output \
/usr/local/software/flink/examples/source/xdclass_result.txt

Docker安装Flink

Docker安装clickhouse

#创建文件夹和文件 -v参数不会报错
mkdir -p /mydata/docker/clickhouse/conf#部署服务端 最新版本
docker run -d --name xdclass_clickhouse4 --ulimit nofile=262144:262144 \
-p 8123:8123 -p 9000:9000 -p 9009:9009 --privileged=true \
-v /mydata/docker/clickhouse/log:/var/log/clickhouse-server \
-v /mydata/docker/clickhouse/data:/var/lib/clickhouse yandex/clickhouse-server#部署服务端 指定版本
docker run -d --name xdclass_clickhouse4 --ulimit nofile=262144:262144 \
-p 8123:8123 -p 9000:9000 -p 9009:9009 --privileged=true \
-v /mydata/docker/clickhouse/log:/var/log/clickhouse-server \
-v /mydata/docker/clickhouse/data:/var/lib/clickhouse yandex/clickhouse-server:20.8.19.4#默认http端⼝是8123，tcp端⼝是9000, 同步端⼝9009#进入容器
docker exec -it 容器id /bin/bash
#连接
clickhouse-client --host 容器ip，默认是当前节点
#查看数据库
show databases;

Docker安装RabbitMQ

#拉取镜像
docker pull rabbitmq:3.8.12-management-alpinedocker run -d --hostname rabbit_host1 --name xd_rabbit -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=password -p 15672:15672 -p 5672:5672 rabbitmq:3.8.12-management-alpine#介绍
-d 以守护进程方式在后台运行
-p 15672:15672 management 界面管理访问端口
-p 5672:5672 amqp 访问端口
--name：指定容器名
--hostname：设定容器的主机名，它会被写到容器内的 /etc/hostname 和 /etc/hosts，作为容器主机IP的别名，并且将显示在容器的bash中-e 参数RABBITMQ_DEFAULT_USER 用户名RABBITMQ_DEFAULT_PASS 密码

4369 erlang 发现口5672 client 端通信口15672 管理界面 ui 端口25672 server 间内部通信口#访问
ip:15672

cd /usr/local/software/flink/examples
mkdir source
cd source
vim xdclass_source.txt
#写入内容
java xdclass
springboot springcloud
html flink
springboot redis
java flink
kafka flink
java springboot

#bin目录运行
./flink run /usr/local/software/flink/examples/batch/WordCount.jar --input
/usr/local/software/flink/examples/source/xdclass_source.txt --output
/usr/local/software/flink/examples/source/xdclass_result.txt

## Docker安装Flink# Docker安装clickhouse```shell
#创建文件夹和文件 -v参数不会报错
mkdir -p /mydata/docker/clickhouse/conf#部署服务端 最新版本
docker run -d --name xdclass_clickhouse4 --ulimit nofile=262144:262144 \
-p 8123:8123 -p 9000:9000 -p 9009:9009 --privileged=true \
-v /mydata/docker/clickhouse/log:/var/log/clickhouse-server \
-v /mydata/docker/clickhouse/data:/var/lib/clickhouse yandex/clickhouse-server#部署服务端 指定版本
docker run -d --name xdclass_clickhouse4 --ulimit nofile=262144:262144 \
-p 8123:8123 -p 9000:9000 -p 9009:9009 --privileged=true \
-v /mydata/docker/clickhouse/log:/var/log/clickhouse-server \
-v /mydata/docker/clickhouse/data:/var/lib/clickhouse yandex/clickhouse-server:20.8.19.4#默认http端⼝是8123，tcp端⼝是9000, 同步端⼝9009#进入容器
docker exec -it 容器id /bin/bash
#连接
clickhouse-client --host 容器ip，默认是当前节点
#查看数据库
show databases;

Docker安装RabbitMQ

#拉取镜像
docker pull rabbitmq:3.8.12-management-alpinedocker run -d --hostname rabbit_host1 --name xd_rabbit -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=password -p 15672:15672 -p 5672:5672 rabbitmq:3.8.12-management-alpine#介绍
-d 以守护进程方式在后台运行
-p 15672:15672 management 界面管理访问端口
-p 5672:5672 amqp 访问端口
--name：指定容器名
--hostname：设定容器的主机名，它会被写到容器内的 /etc/hostname 和 /etc/hosts，作为容器主机IP的别名，并且将显示在容器的bash中-e 参数RABBITMQ_DEFAULT_USER 用户名RABBITMQ_DEFAULT_PASS 密码

4369 erlang 发现口5672 client 端通信口15672 管理界面 ui 端口25672 server 间内部通信口#访问
ip:15672