Docker篇之秒杀项目环境部署

Posted 2021-12-24 Maynor的大数据奋斗之路

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Docker篇之秒杀项目环境部署相关的知识，希望对你有一定的参考价值。

1. 秒杀项目环境(基于Centos7.6测试全部成功)

1.Docker和JDK安装

Docker安装

# 设置仓库
yum install -y yum-utils device-mapper-persistent-data lvm2
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

#安装
yum install -y docker-ce docker-ce-cli containerd.io

#启动
systemctl start docker

#设置开机启动
systemctl enable docker

#安装好后，可以查看docker的版本
docker -v

#修改Docker配置文件，使用国内的Docker镜像：
vi /etc/docker/daemon.json

# 添加以下内容
"registry-mirrors":["https://ncwlarc2.mirror.aliyuncs.com"]

#使之生效
systemctl daemon-reload

#重启
systemctl restart docker

安装Docker Compose

#国内资源(建议)
curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.4/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

# 将可执行权限应用于二进制文件：
chmod +x /usr/local/bin/docker-compose

# 创建软链：
ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

# 测试是否安装成功：
docker-compose --version

JDK安装

# jdk镜像仓库：https://repo.huaweicloud.com/java/jdk/8u171-b11/

# 下载、解压jdk
wget https://repo.huaweicloud.com/java/jdk/8u171-b11/jdk-8u171-linux-x64.tar.gz
tar -zxf jdk-8u171-linux-x64.tar.gz
mv jdk1.8.0_171 /usr/local/jdk8

# 配置环境
vi /etc/profile

# 添加内容：
export JAVA_HOME=/usr/local/jdk8
export PATH=$JAVA_HOME/bin:$PATH

# 配置生效命令
source /etc/profile
#查看j版本命令
java -version

unzip命令安装

yum install -y unzip

2. 创建Nacos

# 启动容器
docker run -id --name nacos \\
--restart=always -p 8848:8848 \\
-e MODE=standalone nacos/nacos-server:1.4.1

3. 创建mysql

后期要使用Canal，需要把MySQL的配置文件提取出来，所以要进行相关的配置文件的编写

#创建MySQL配置文件
mkdir -p /mnt/mysql/conf
#创建配置文件mysql.cnf
vim /mnt/mysql/conf/mysql.cnf

#内容如下：
[mysqld]
# 设置关闭二进制日志
skip-log-bin

启动MySQL容器

# 创建MySQL网络环境，指定子网网段
docker network create --subnet=172.36.0.0/16 seckill_network

# 启动MySQL 指定容器IP，固定IP地址
docker run -id --name seckill_mysql \\
--net seckill_network --ip 172.36.0.3 \\
-v /mnt/mysql/data:/var/lib/mysql \\
-v /mnt/mysql/conf:/etc/mysql/conf.d \\
--restart=always -p 3306:3306 \\
-e MYSQL_ROOT_PASSWORD=eVcWs1dsEgiv4ijEZ1b6 mysql:8.0.18

4. 创建Canal数据同步

配置MySQL

需要让canal伪装成salve并正确获取mysql中的binary log，首先要开启 Binlog 写入功能，配置 binlog-format 为 ROW 模式

修改MySQL配置文件，如下操作：

# 执行修改命令
vi /mnt/mysql/conf/mysql.cnf

# 配置文件 mysql.cnf 内容如下
[mysqld]
# 设置关闭二进制日志
#skip-log-bin

# 开启二进制日志
log-bin=mysql-bin

#开启binlog 选择ROW模式
binlog-format=ROW

#server_id不要和canal的slaveId重复
server_id=1

配置文件修改完成后重启MySQL

docker restart seckill_mysql

在MySQL中执行以下sql，查询数据库状态

show variables like 'log_bin';
show variables like 'binlog_format';
show master status;

创建连接MySQL的账号canal并授予作为 MySQL slave 的权限，执行以下sql：

# 创建账号
CREATE USER canal IDENTIFIED BY 'canal'; 
# 授予权限
GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'canal'@'%';
# 修改数据库加密算法
ALTER USER 'canal'@'%' IDENTIFIED WITH mysql_native_password BY 'canal'; 
# 刷新并应用
FLUSH PRIVILEGES;

创建并配置Cancal

创建canal-server容器

docker run -d --name canal-server \\
--net seckill_network --ip 172.36.0.8 \\
--restart=always -p 11111:11111 \\
canal/canal-server:v1.1.4

配置Canal

# 进入Canal容器
docker exec -it canal-server /bin/bash

# 修改配置文件
vi /home/admin/canal-server/conf/example/instance.properties

# instance.properties需要修改以下三个部分
# 修改Canal的slaveId，不能和MySQL的server_id重复
canal.instance.mysql.slaveId=101
# 修改需要进行同步操作的MySQL的连接地址
canal.instance.master.address=172.36.0.3:3306
# 修改需要进行监听的数据库表
canal.instance.filter.regex=seckill_goods.tb_sku

# 修改完成后重启Canal服务
docker restart canal-server

监听数据库表的配置 canal.instance.filter.regex 如下：

mysql 数据解析关注的表，Perl正则表达式.
多个正则之间以逗号(,)分隔，转义符需要双斜杠(\\\\) 
常见例子：
1.  所有表：.*   or  .*\\\\..*
2.  canal schema下所有表： canal\\\\..*
3.  canal下的以canal打头的表：canal\\\\.canal.*
4.  canal schema下的一张表：canal.test1
5.  多个规则组合使用：canal\\\\..*,mysql.test1,mysql.test2 (逗号分隔)
注意：此过滤条件只针对row模式的数据有效(ps. mixed/statement因为不解析sql，所以无法准确提取tableName进行过滤)

5. 创建Elasticsearch和kibana

准备IK分词器

# 创建存放IK分词器的目录
mkdir -p /mnt/elasticsearch/plugins/ik

# 上传IK分词器

# 解压IK到指定路径
tar -xf ik-7.4.0.tar -C /mnt/elasticsearch/plugins/ik

启动docker服务

# 创建单机版elasticsearch容器
docker run -id --name elasticsearch \\
--net seckill_network --ip 172.36.0.13 \\
-v /mnt/elasticsearch/plugins:/usr/share/elasticsearch/plugins \\
--restart=always -p 9200:9200 -p 9300:9300 \\
-e "discovery.type=single-node" elasticsearch:7.4.0

# 创建kibana
docker run -id --name kibana --net seckill_network \\
-e ELASTICSEARCH_HOSTS=http://172.36.0.13:9200 \\
--restart=always -p 5601:5601 kibana:7.4.0

连接kibana，测试中文分词

GET /_analyze

  "analyzer": "ik_smart",
  "text": "乒乓球明年总冠军"

初始化索引库

GET goodsindex
PUT goodsindex

	"mappings": 
		"properties": 
			"name": 
				"type": "text",
				"analyzer": "ik_smart"
			,
			"price":  
				"type": "long"
			,
			"seckillPrice":  
				"type": "long"
			,
			"image":  
				"type": "text"
			,
			"updateTime": 
				"type": "date"
			,
			"category1Id":  
				"type": "text"
			,
			"category2Id":  
				"type": "text"
			,
			"category3Id":  
				"type": "text"
			,
			"category1Name": 	
				"type": "keyword"
			,
			"category2Name": 	
				"type": "keyword"
			,
			"category3Name": 	
				"type": "keyword"
			,
			"brandName": 	
				"type": "keyword"
			,
			"bgtime": 	
				"type": "keyword"
			,
			"brandId": 	
				"type": "text"
			,
			"seckillBegin": 
				"type": "date"
			,
			"seckillEnd": 
				"type": "date"
			,
			"status": 
				"type": "integer"
			,
	
			"spec": 		
				"type": "text"
			,
			
			"points": 	
				"type": "integer"

6. 创建Redis集群

准备环境：

#创建文件目录
mkdir -p /mnt/redis/r1/data
mkdir -p /mnt/redis/r2/data
mkdir -p /mnt/redis/r3/data
mkdir -p /mnt/redis/r4/data
mkdir -p /mnt/redis/r5/data
mkdir -p /mnt/redis/r6/data

准备Redis配置文件，需要准备6份，第一份：

执行命令 vi /mnt/redis/r1/redis.conf 内容为：

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

配置文件注意路径不同，端口号为7001~7006

编写 vim /mnt/redis/docker-compose.yml ，内容为：

version: "3.6"
services:
  redis1:
    container_name: redis1
    image: redis:5.0.9
    network_mode: host
    volumes:
      - /mnt/redis/r1/redis.conf:/config/redis.conf
      - /mnt/redis/r1/data:/data
    command: [ "redis-server", /config/redis.conf ]
    restart: always
  redis2:
    container_name: redis2
    image: redis:5.0.9
    network_mode: host
    volumes:
      - /mnt/redis/r2/redis.conf:/config/redis.conf
      - /mnt/redis/r2/data:/data
    command: [ "redis-server", /config/redis.conf ]
    restart: always
  redis3:
    container_name: redis3
    image: redis:5.0.9
    network_mode: host
    volumes:
      - /mnt/redis/r3/redis.conf:/config/redis.conf
      - /mnt/redis/r3/data:/data
    command: [ "redis-server", /config/redis.conf ]
    restart: always
  redis4:
    container_name: redis4
    image: redis:5.0.9
    network_mode: host
    volumes:
      - /mnt/redis/r4/redis.conf:/config/redis.conf
      - /mnt/redis/r4/data:/data
    command: [ "redis-server", /config/redis.conf ]
    restart: always
  redis5:
    container_name: redis5
    image: redis:5.0.9
    network_mode: host
    volumes:
      - /mnt/redis/r5/redis.conf:/config/redis.conf
      - /mnt/redis/r5/data:/data
    command: [ "redis-server", /config/redis.conf ]
    restart: always
  redis6:
    container_name: redis6
    image: redis:5.0.9
    network_mode: host
    volumes:
      - /mnt/redis/r6/redis.conf:/config/redis.conf
      - /mnt/redis/r6/data:/data
    command: [ "redis-server", /config/redis.conf ]
    restart: always

执行服务编排：

#进入指定路径
cd /mnt/redis

#服务编排启动Redis集群
docker-compose up -d

启动集群：

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

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

redis-cli --cluster create 39.103.206.202:7001 39.103.206.202:7002 39.103.206.202:7003 39.103.206.202:7004 39.103.206.202:7005 39.103.206.202:7006 --cluster-replicas 1


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

# 连接集群
redis-cli -h 127.0.0.1 -p 7001 -c

如果卡在 Waiting for the cluster to join 这一步，检查端口号是否开放。redis集群除了需要使用7001~7006，还需要开通集群总线端口，端口号为redis端口号+10000 在这里就是端口号为17001~17006的都需要开放

注意：

集群启动成功后，需要在宿主机中检查集群节点的配置文件（Ctrl+d可以退出容器）

#查看配置文件命令：
cat vi /mnt/redis/r1/data/nodes.conf

# 如果出现内网IP(例如172.x.x.x)，则需要修改宿主机的集群配置文件
# 检查6个配置文件，把所有的内网IP都改为当前公网IP
# 在宿主机分别执行以下命令，分别进行修改：
vi /mnt/redis/r1/data/nodes.conf
vi /mnt/redis/r2/data/nodes.conf
vi /mnt/redis/r3/data/nodes.conf
vi /mnt/redis/r4/data/nodes.conf
vi /mnt/redis/r5/data/nodes.conf
vi /mnt/redis/r6/data/nodes.conf

#服务编排启动Redis集群
docker-compose up -d

#服务编排停止Redis集群并删除容器
docker-compose down

7. 创建Zookeeper

docker run -d --name zk \\
--net seckill_network --ip 172.36.0.16 \\
--restart=always \\
-v /etc/localtime:/etc/localtime \\
-p 3181:2181 zookeeper:3.4.14

8. 创建Kafka

创建Kafka之前，必须先确保Zookeeper已经存在，请先确认 7.创建Zookeeper 是否完成。

使用Docker启动Kafka：

docker run -d --name kafka \\
--restart=always -p 9092:9092 \\
-e KAFKA_BROKER_ID=0 \\
-e KAFKA_ZOOKEEPER_CONNECT=192.168.200.188:3181/kafka \\
-e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.200.188:9092 \\
-e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 \\
-v /etc/localtime:/etc/localtime \\
wurstmeister/kafka:2.12-2.4.1

注意：需要修改192.168.200.188为宿主机的实际ip地址(如果有公网IP，填写公网IP地址)

测试Kafka

创建队列：

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

# 进入目录
cd /opt/kafka_2.12-2.4.1/bin

# 创建队列
./kafka-topics.sh --create --bootstrap-server localhost:9092 --partitions 1 --replication-factor 1 --topic itemaccess

使用kafka-topics.sh创建队列:
–create:执行创建一个新的队列操作

--bootstrap-server：需要链接的kafka配置，必填

--partitions 1：设置一个topic设置几个分区(就是把数据切割成几块，分别存储)

--replication-factor 1:设置分区的副本数量（就是设置多少个备份，有了备份，一个挂了没事，可以使用备份）

--topic itemaccess：队列的名字叫itemaccess

消息发布

在kafka容器中执行消息发送（接着上面的步骤执行）：

# 发送消息
./kafka-console-producer.sh --broker-list localhost:9092 --topic itemaccess

# 发送内容为
"actime":"2021-4-10 9:50:10","uri":"http://www-seckill.itheima.net/items/333.html","IP":"119.123.33.231","Token":"Bearer itcast"

消息订阅

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

# 进入目录
cd /opt/kafka_2.12-2.4.1/bin

# 订阅消息
./kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic itemaccess --from-beginning

其他命令

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

# 进入目录
cd /opt/kafka_2.12-2.4.1/bin

# 查看topic列表
./kafka-topics.sh --bootstrap-server localhost:9092 --list

# 查看指定的topic信息
./kafka-topics.sh --bootstrap-server localhost:9092 --list

# 删除topics
./kafka-topics.sh --bootstrap-server localhost:9092 --delete --topic itemaccess2

9. 创建OpenRestry

如果因为本地计算机的内存不够，不能使用本地虚拟机而使用云服务器，最好还是把OpenRestry放在本地。

也就是说，除了OpenRestry以外的服务都可以安装到云服务器上，OpenRestry需要安装到本地虚拟机中。后面在进行秒杀抢单的时候，需要进行nginx转发，OpenRestry在本地更方便配置。

9.1 安装OpenRestry

安装OpenRestry：

# 安装环境
yum -y install pcre-devel openssl-devel gcc curl

# 上传openresty-1.11.2.5.tar.gz

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

# 进入到解压目录
cd openresty-1.11.2.5

# 安装
./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

配置环境变量：

# 修改环境文件
vi /etc/profile

# 修改为以下内容
export JAVA_HOME=/usr/local/jdk8
export OPENRESTY_HOME=/usr/local/openresty/nginx
export PATH=$JAVA_HOME/bin:$OPENRESTY_HOME/sbin:$PATH

# 使环境文件生效
source /etc/profile

9.2 安装Lua的Kafka插件

# 上传lua-resty-kafka-master.zip

# 解压
unzip lua-resty-kafka-master.zip

# 移动到指定目录
mv lua-resty-kafka-master /usr/local/openresty/

# 修改nginx.conf
vi /usr/local/openresty/nginx/conf/nginx.conf

# 添加内容  在配置文件中指定lua-resty-kafka的库文件位置
# 配置到http里面，和server平级
lua_package_path "/usr/local/openresty/lua-resty-kafka-master/lib/?.lua;;";

配置效果如下：

http 
    ......
    
    #gzip  on;

    #添加内容  在配置文件中指定lua-resty-kafka的库文件位置
    lua_package_path "/usr/local/openresty/lua-resty-kafka-master/lib/?.lua;;";


    server 
        listen       80;
        server_name  localhost;   
        
    ......

9.2 安装Lua的Jwt插件

# 安装环境
yum install -y yum-utils

# 设置yum的资源地址
yum-config-manager --add-repo https://openresty.org/package/centos/openresty.repo

# 安装resty和opm工具
yum install -y openresty-resty
yum install -y openresty-opm

# 安装jwt组件
opm get SkyLothar/lua-resty-jwt

9.3 安装Lua的Redis插件

# 安装环境
yum install -y lua-devel

# 上传资料中的lua-resty-redis-cluster-master.zip到服务器的 /root目录下

# 解压
cd /root
unzip lua-resty-redis-cluster-master.zip

# 拷贝redis_slot.c：
cp /root/lua-resty-redis-cluster-master/lib/redis_slot.c /usr/local/openresty/lualib/

# 拷贝rediscluster.lua：
cp /root/lua-resty-redis-cluster-master/lib/resty/rediscluster.lua /usr/local/openresty/lualib/resty/

# 编译
cd /usr/local/openresty/lualib
gcc redis_slot.c -fPIC -shared -o libredis_slot.so

lua-resty-redis-cluster中有部分redis指令并未开放，我们可以手动修改，开放相关指令,我们这里开放过期指令，因为后面会用到该指令。

开放设置过期时间的指令，步骤如下：

# 修改配置文件
vi /usr/local/openresty/lualib/resty/rediscluster.lua

# 进入指定的行数
:90
# 插入空行
o
# 在空行中添加指令，设置过期时间的指令如下：(注意""和,都不能少)
"expire",
# 按 Esc 进入一般模式，保存退出
:wq

10. 创建Druid

下载Druid安装包 https://mirrors.aliyun.com/apache/druid/，注意下载bin版本，不是src源码

# 上传资料中的apache-druid-0.20.2-bin.tar.gz，
# 也可以使用命令 wget https://mirrors.aliyun.com/apache/druid/0.20.2/apache-druid-0.20.2-bin.tar.gz获取安装包

# 解压
tar -zxf apache-druid-0.20.2-bin.tar.gz

# 移动到指定位置
mv apache-druid-0.20.2 /usr/local/druid

# 修改时区
cd /usr/local/druid/conf/druid/single-server
sed -i "s/Duser.timezone=UTC/Duser.timezone=UTC+8/g" `grep Duser.timezone=UTC -rl ./`

# 进入启动脚本的目录
cd /usr/local/druid/bin

# 选择合适的方式启动(根据实际情况选择不同的启动命令)
# Nano-Quickstart，要求硬件环境：1 CPU, 4GB RAM
./start-nano-quickstart

# 微型快速，要求硬件环境： 4 CPU, 16GB RAM
./start-micro-quickstart

# 小型，要求硬件环境：8 CPU，64GB RAM
./start-single-server-small

# 中型，要求硬件环境：16 CPU，128GB RAM
./start-single-server-medium

# 大型，要求硬件环境：32 CPU，256GB RAM
./start-single-server-large

# 大型X，要求硬件环境：64 CPU，512GB RAM
./start-single-server-xlarge

使用文档参考：http://www.apache-druid.cn/GettingStarted/chapter-1.html

11. 创建seata

docker run -d --name seata-server \\
-p 8191:8191 -e SEATA_PORT=8191 \\
--restart=always \\
seataio/seata-server:1.4.1

12. 创建sentinel

docker run -d --name sentinel \\
--restart=always -p 8858:8858 \\
bladex/sentinel-dashboard:1.7.2

2. Kafka集群

以上的环境已经可以满足开发要求。但是如果需要支撑更大的并发，还需要实现排队下单的集群化部署。

排队下单主要用到Kafka集群，这里提供Kafka集群的搭建。

Kafka自身就支持集群，我们需要保证集群协调服务 Zookeeper集群化，然后再部署多个Kafka节点即可。

在使用Kafka集群的时候，创建topic的时候需要设置多个分片以及副本即可

2.1 创建Zookeeper集群

Zookeeper集群需要选举投票，所以至少由三个节点组成。当然可以有更多节点，我们这里用三个节点演示

使用服务编排进行Zookeeper集群创建，Zookeeper集群的三个节点端口号为 3183、3184、3185

首先创建目录，执行命令

mkdir -p /mnt/zookeeper

创建服务编排配置文件：

vim /mnt/zookeeper/docker-compose.yml

文件内容为：

version: '3.6'

services:
  zoo1:
    image: zookeeper:3.4.14
    restart: always
    hostname: zoo1
    container_name: zoo1
    ports:
    - 3183:2181
    volumes:
    - "/mnt/zookeeper/zoo1/data:/data"
    - "/mnt/zookeeper/zoo1/datalog:/datalog"
    - "/etc/localtime:/etc/localtime"
    environment:
      ZOO_MY_ID: 1
      ZOO_SERVERS: server.1=0.0.0.0:2888:3888 server.2=zoo2:2888:3888 server.3=zoo3:2888:3888
    networks:
      seckill_network:
        ipv4_address: 172.36.0.83

  zoo2:
    image: zookeeper:3.4.14
    restart: always
    hostname: zoo2
    container_name: zoo2
    ports:
    - 3184:2181
    volumes:
    - "/mnt/zookeeper/zoo2/data:/data"
    - "/mnt/zookeeper/zoo2/datalog:/datalog"
    - "/etc/localtime:/etc/localtime"
    environment:
      ZOO_MY_ID: 2
      ZOO_SERVERS: server.1=zoo1:2888:3888 server.2=0.0.0.0:2888:3888 server.3=zoo3:2888:3888
    networks:
      seckill_network:
        ipv4_address: 172.36.0.84

  zoo3:
    image: zookeeper:3.4.14
    restart: always
    hostname: zoo3
    container_name: zoo3
    ports:
    - 3185:2181
    volumes:
    - "/mnt/zookeeper/zoo3/data:/data"
    - "/mnt/zookeeper/zoo3/datalog:/datalog"
    - "/etc/localtime:/etc/localtime"
    environment:
      ZOO_MY_ID: 3
      ZOO_SERVERS: server.1=zoo1:2888:3888 server.2=zoo2:2888:3888 server.3=0.0.0.0:2888:3888
    networks:
      seckill_network:
        ipv4_address: 172.36.0.85

networks:
  seckill_network:
    external:
      name: seckill_network

启动命令

# 进入目录
cd /mnt/zookeeper/

# 服务编排启动Zookeeper集群
docker-compose up -d

# 进入容器内部
docker exec -it zoo3 /bin/bash
# 查看节点信息
zkServer.sh status

# 服务编排停止Zookeeper集群并删除容器
docker-compose down

8.2 创建Kafka集群版

首先创建目录，执行命令

mkdir -p /mnt/kafka

创建服务编排配置文件：

vim /mnt/kafka/docker-compose.yml

文件内容为：(192.168.200.188需要改为实际的IP)

version: '3.6'

services:
  kafka1:
    image: wurstmeister/kafka:2.12-2.4.1
    restart: always
    hostname: kafka1
    container_name: kafka1
    privileged: true
    ports:
    - 9093:9093
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ADVERTISED_HOST_NAME: kafka1
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9093
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://192.168.200.188:9093
      KAFKA_ADVERTISED_PORT: 9093
      KAFKA_ZOOKEEPER_CONNECT: 192.168.200.188:3183,192.168.200.188:3184,192.168.200.188:3185/kafka
    networks:
      seckill_network:
        ipv4_address: 172.36.0.93


  kafka2:
    image: wurstmeister/kafka:2.12-2.4.1
    restart: always
    hostname: kafka2
    container_name: kafka2
    privileged: true
    ports:
    - 9094:9094
    environment:
      KAFKA_BROKER_ID: 2
      KAFKA_ADVERTISED_HOST_NAME: kafka2
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9094
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://192.168.200.188:9094
      KAFKA_ADVERTISED_PORT: 9094
      KAFKA_ZOOKEEPER_CONNECT: 192.168.200.188:3183,192.168.200.188:3184,192.168.200.188:3185/kafka
    networks:
      seckill_network:
        ipv4_address: 172.36.0.94


  kafka3:
    image: wurstmeister/kafka:2.12-2.4.1
    restart: always
    hostname: kafka3
    container_name: kafka3
    privileged: true
    ports:
    - 9095:9095
    environment:
      KAFKA_BROKER_ID: 3
      KAFKA_ADVERTISED_HOST_NAME: kafka3
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9095
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://192.168.200.188:9095
      KAFKA_ADVERTISED_PORT: 9095
      KAFKA_ZOOKEEPER_CONNECT: 192.168.200.188:3183,192.168.200.188:3184,192.168.200.188:3185/kafka
    networks:
      seckill_network:
        ipv4_address: 172.36.0.95


networks:
  seckill_network:
    external:
      name: seckill_network

启动命令：

# 进入目录
cd /mnt/kafka/

# 服务编排启动Kafka集群
docker-compose up -d

# 服务编排停止Kafka集群并删除容器
docker-compose down

8.3 测试Kafka

创建队列：

# 进入容器  Kafka1为容器的名字，可以选择任意节点进入
docker exec -it kafka1 /bin/bash

# 进入目录
cd /opt/kafka_2.12-2.4.1/bin

# 创建队列 9093需要改为当前节点监听的端口号
./kafka-topics.sh --create --bootstrap-server localhost:9093 --partitions 3 --replication-factor 2 --topic itemaccess

使用kafka-topics.sh创建队列:
–create:执行创建一个新的队列操作

--bootstrap-server：需要链接的kafka配置，必填

--partitions 1：设置一个topic设置几个分区(就是把数据切割成几块，分别存储)

--replication-factor 1:设置分区的副本数量（就是设置多少个备份，有了备份，一个挂了没事，可以使用备份）

--topic itemaccess：队列的名字叫itemaccess

消息发布

在kafka容器中执行消息发送（接着上面的步骤执行）：

# 发送消息
./kafka-console-producer.sh --broker-list localhost:9093 --topic itemaccess

# 发送内容为
"actime":"2021-4-10 9:50:10","uri":"http://www-seckill.itheima.net/items/333.html","IP":"119.123.33.231","Token":"Bearer itcast"

消息订阅

# 进入容器  Kafka3为容器的名字，测试集群选择任意节点进入
docker exec -it kafka3 /bin/bash

# 进入目录
cd /opt/kafka_2.12-2.4.1/bin

# 订阅消息  9095需要改为当前节点监听的端口号
./kafka-console-consumer.sh --bootstrap-server localhost:9095 --topic itemaccess --from-beginning

其他命令

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

# 进入目录
cd /opt/kafka_2.12-2.4.1/bin

# 查看topic列表   注意修改9093为当前节点端口号
./kafka-topics.sh --bootstrap-server localhost:9093 --list

# 查看指定的topic信息   注意修改9093为当前节点端口号
./kafka-topics.sh --bootstrap-server localhost:9093 --list

# 删除topics   注意修改9093为当前节点端口号
./kafka-topics.sh --bootstrap-server localhost:9093 --delete --topic itemaccess2

以上是关于Docker篇之秒杀项目环境部署的主要内容，如果未能解决你的问题，请参考以下文章

java初探之秒杀的安全

JAVA秒会技术之秒杀面试官JavaEE常见面试题

JAVA秒会技术之秒杀面试官秒杀Java面试官——集合篇

JAVA秒会技术之秒杀面试官JavaEE常见面试题

SSM之秒杀系统

Redis之秒杀下单优化以及认识redis消息队列