一、kafka架构

kafka 是一个分布式的基于发布和订阅模式的消息队列（message queue），主要用于大数据实时处理领域。

1.1 消息队列

同步通信

异步通信

使用消息队列的好处如下：

• 解耦：允许独立的扩展或修改两边的处理过程
• 可恢复性：系统的一部分组件失效时，不会影响到整个系统
• 缓冲：控制和优化数据经过系统的速度
• 灵活性和峰值处理能力：在特殊情况下，通信中的请求量会急剧增大（如双十一等活动），但这种情况并不常见，如果投入资源来待命是很浪费的，使用消息队列就可以顶住突发的访问压力，而保护集群不会因为请求量过多而崩溃
• 异步通信：有时候用户不想也不需要立即处理消息，这种时候就允许用户把消息放在队列中，等待处理

消息队列分为点对点模式和发布/订阅模式

点对点模式

消息生产者生产消息发送到 queue 中，消费者再从 queue 拉取消息并消费，消息被消费之后就不再存在于 queue 中，queue 可以有多个消费者，但对于消息而言只能有一个消费者。

发布/订阅模式

消息生产者将消息发送到 topic 中，可以同时有多个消费者订阅该消息，发布到 topic 的消息可以被所有消费者订阅。

1.2 kafka基础架构

kafka 有四个核心的 API：

• The Producer API：允许一个应用程序发布一串流式的数据到一个或者多个 topic
• The Consumer API：允许一个应用程序订阅一个或多个 topic ，并且对发布给他们的流式数据进行处理
• The Streams API：允许一个应用程序作为一个流处理器，消费一个或者多个 topic 产生的输入流，然后生产一个输出流到一个或多个 topic 中去，在输入输出流中进行有效的转换
• The Connector API：允许构建并运行可重用的生产者或者消费者，将 topics 连接到已存在的应用程序或者数据系统

• producer：消息生产者
• consumer：消息消费者
• topic：数据主题，是数据订阅/发布的地方，可以被多个消费者订阅
• partition：分区，每个 topic 包含一个或多个分区，分区是一个有序的队列，分区中的消息都会被分配一个 offset，kafka 保证按每一个分区中的顺序将消息发送给消费者，但不保证按每一个 topic 中的顺序将消息发送给消费者；且 partition 是消费者和生产者操作的最小单元
• offset（偏移量）：kafka 的存储文件都是按照 offset.kafka 来命名，方便查找数据
• leader 副本：消息的订阅/发布都由 leader 来完成
• follower 副本：进行消息数据的备份，当 leader 挂了之后，就成为新的 leader 来代替旧的 leader
• broker：一个 kafka 就是一个 broker，一个集群由多个 broker 组成
• consumer group：消费者组，组中有多个消费者，组中的消费者都只能够接收一个分区的消息
• zookeeper：保存 kafka 集群状态的信息，2.8.0版本开始支持 kraft 模式，可不依赖 zk 运行 kafka 集群
• replicas：副本数

1.3 kafka 存储机制

kafka 内部会自己创建一个 _consumer_offsets 并包含 50 个分区，这些主题用来保存消费者消费某个 topic 的偏移量。

每个 partitions 都被切割成相同大小的 segment，segment 由四个部分构成，具体如下：

• log：数据文件
• index：索引文件，用来保存消息的索引，能够使查找数据更加高效
• timeindex：具体时间日志
• leader-epoch-checkpoint：保存了每一任 leader 开始写入消息时的 offset，会定时更新

1.4 生产者分区策略

kafka 允许为每条消息定义消息 key，可以根据 key 来为消息选择分区。

分区策略即决定生产者将消息发送到哪个分区的算法，主要有以下几种：

• 轮询策略（没给定分区号和 key 值）：可以提供优秀的负载均衡能力，保证消息被平均的分配到各个分区上，但不能保证消息的有序性。
• 随即策略：瞎分，基本不用。
• hash 策略（没给定分区号，但给了 key 值）：将 key 的 hash 值与 topic 的 partition 数进行取余得到
  partition值
• 自定义分区

1.5 生产者ISR

ISR 即同步副本，leader 维护了一个动态的 ISR，为 leader 保持同步的 follower 集合，当 ISR 中的 follower 完成数据的同步之后，leader 就会给 follower 发送 acks，如果 follower 长时间没有向 leader 同步数据，则该 follower 将被踢出 ISR。leader 发生故障之后就会在 ISR 中选取出新的 leader。

1.6 生产者ACKS

kafka 发送确认参数 acks 的几种模式：

• acks = 0：意味着生产者能够通过网络把消息发送出去，broker 接收到数据还没写入就发送，容易丢数据
• acks = 1：等待 leader 写入数据（不等待 follower 同步），就可以发送数据，可能会丢数据
• acks = all/-1：等待 leader 和 follower（ISR 中的）写入数据，就可以发送数据，数据不容易丢，但效率底

1.7 kafka数据一致性原理

• HW：所有副本中的最小 LEO
• LEO：每个副本的最后一个（最大的） offset

假设分区的副本为3，副本0为 leader，副本1、2为 follower，并且都在 ISR 列表中。虽然 leader 已经写入了 message3，但消费者只能读到 message1，因为所有的 ISR 都同步了 message1，只有在 HW 之上的消息才支持被消费，而 HW 取决于 LEO，原理类似于木桶原理。

这么做的原因是如果 leader 崩溃了，一个 follower 成为新的 leader 后，由于该新的 leader 没有做好数据的同步，如果允许消费者读取 HW 之下的数据的话，那么就会出现数据不一致的问题。

1.7 Exactly-once

当生产者发送消息到 topic 时，很可能会出现宕机的情况，或者出现了网络故障，导致生产者消息发送失败，而生产者要如何处理这样的错误，就产生了如下几种不同的语义：

• At least once：至少一次，如果生产者收到了 broker 发送过来的 acks，且 acks 设置为了 all/-1，这就代表消息已经被写入 topic 且同步好了。如果生产者在时间内没受到 acks 或收到的 acks 有误，那么就会重新发送消息。如果 broker 恰好在消息已经写入 topic 时，发送 acks 前出了故障，那么就会导致生产者发送同样的消息两次，消费者消费两次。
• At more once：最多一次，如果生产者在接收 acks 超时或返回有问题的时候不重新发送消息，那么消息很可能没写入 topic 中，因此消费者也不会消费该条消息，不会出现数据重复的现象，但很容易缺数据。
• Exactly once：精确一次，即使生产者重新发送消息，也只会被消费者消费一次，实际上就是在 kafka 集群中做一次去重的操作。kafka 集群会给生产者分配一个 PID，生产者每次发送消息到 broker 时都会附带 PID、分区以及序列号，broker 就会对数据做一个保存，如果生产者再发送同样消息，那么 broker 就会对数据进行去重，但如果生产者宕机重启了，就会被分配一个新的 PID，所以去重无法做到精准的数据写入。要开启 exactly-once，需要在 broker 中配置 enable.idempotence = true ，这时候 acks 默认被设置为 -1。

1.8 消费者分区分配策略

消费者是采用 pull 的方式在 kafka 集群中获取消息的。

push 模式很难适应消费速率不同的消费者，因为消息的发送速率是由 broker 决定的；而 pull 方式当 kafka 集群没有数据的时候，消费者可能会陷入循环之中，一直取到空数据。

一个消费者组里由多个消费者，一个 topic 里由多个分区，那么数据在消费的时候就会涉及到分配的问题，即确定那些分区由消费者组里的哪些消费者来消费。

kakfa 有三种分配策略，如下：

• RangeAssignor（默认）：RangeAssignor 是针对 topic 而言的，首先会对 topic 中的分区按照序号进行排列，并对消费者根据字典序排列，然后用分区个数除以消费者线程的总数来决定分区的分配，但如果除不尽，那么前面的消费者就会多分配一些分区。
• RoundRobin：将消费组内所有消费者以及消费者所订阅的所有 topic 的 partition 按照字典序排序，然后通过轮询的方式逐个分配给组内的消费者。如果同时消费多个 topic，那么消费者会将这些 topic 视为一个。但如果同一个消费组内的消费者所订阅的信息是不相同的，那么在执行分区分配的时候就不是完全的轮询分配，有可能会导致分区分配的不均匀。
• StickyAssignor：StickyAssignor 要实现的是分区的分配要尽可能的均匀，分配给消费者者的主题分区数最多相差一个，假设一个消费者组有三个消费者，都订阅了四个 topic，且每个 topic 中有二个分区，那么这时候分配的结果与 RoundRobin 会很相似，即消费者A三个分区、消费者B三个分区、消费者C两个分区，假设消费者C退出了消费者组，这时候 StickyAssignor 会保留之前消费者A和B分配到的分区，然后再将消费者C之前分配到的分区再分配给消费者A和B，即体现了粘性，不需要消费者将之前处理过的数据送到新的消费者再处理一次。

1.9 offset存储

kafka 在0.9版本之前，offset 是存储在 zk 中，在之后的版本则是存储在 kafka 内置的一个 topic 中，即 _consumer_offsets，一个 offset 提交的信息包括以下：

offset 的提交会根据消费者组的 key（GTP） 进行分区，对于一个给定的消费者，它所有的消息都会发送到唯一的 broker，这样消费者就不需要对多个 broker 拉取数据，但如果消费者组消费很多数量的分区，会对 broker 造成性能瓶颈。

1.10 kafka写机制

• 顺序写入磁盘
• 零拷贝

1.11 kafka-controller

kafka 集群中会有一个 broker 被选举为 controller，用来负责管理 broker 的上下线，所有 topic 的分区、副本分配和 leader 选举等。

1.12 kafka事务

事务可以保证在 Exactly-Once 的基础上，生产和消费可以跨分区跨会话，即生产者在同一个事务内提交到多个分区的消息，要么同时提交成功，要么同时失败，这样就保证了生产者在运行时出现异常或宕机之后仍然成立。

生产者事务

为了实现跨分区跨会话的事务，需要引入全局唯一的 Transaction ID（由客户端给定），并将生产者的 PID 与之绑定，这样以来生产者即使宕机重启也可以与原来的 PID 进行绑定。

为了管理 Transaction ID，kafka 中引入了一个新的组件 Transaction Coordinator，生产者就是与 Transaction Coordinator 交互来获得 Transaction ID 对应的任务状态。Transaction Coordinator 还负责将事务写入 topic，这样即使服务重启，也可以得到恢复。

消费者事务

事务主要是为生产者作保证，无法保证消费者的精准消费，是因为消费者可以根据 offset 来访问消息。

二、kafka基础

2.1 kafka安装

通过二进制包部署

1. 下载 kafka

1
2

curl -O https://mirrors.tuna.tsinghua.edu.cn/apache/kafka/2.8.0/kafka_2.13-2.8.0.tgz
tar -xf kafka_2.13-2.8.0.tgz

2. 修改 server.properties

1
2
3
4

# broker的id必须为唯一的整数，设置为-1时随机生成
broker.id=-1
# 修改为实际zookeeper节点地址+2181端口
zookeeper.connect=...

3. 开启 zookeeper 和 kafka

1
2
3

# daemon参数:不输出启动日志信息
./bin/zookeeper-server-start.sh -daemon ../config/zookeeper.properties
./bin/kafka-server-start.sh -daemon ./config/server.properties

通过 docker-compose 部署

1. docker-compose.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

version: "3.8"
services:
  zookeeper:
    container_name: zookeeper
    image: docker.io/bitnami/zookeeper:3.7
    ports:
      - "12181:2181"
    volumes:
      - "./data/zookeeper_data:/zookeeper_data"
    environment:
      - ALLOW_ANONYMOUS_LOGIN=yes
  kafka1:
    container_name: kafka1
    image: docker.io/bitnami/kafka:2.8.0
    ports:
      - "19092:9092"
    volumes:
      - "./data/kafka1_data:/data"
    environment:
      - KAFKA_CFG_ZOOKEEPER_CONNECT=zookeeper:2181
      - ALLOW_PLAINTEXT_LISTENER=yes
    depends_on:
      - zookeeper
  kafka2:
    container_name: kafka2
    image: docker.io/bitnami/kafka:2.8.0
    ports:
      - "19093:9092"
    volumes:
      - "./data/kafka2_data:/data"
    environment:
      - KAFKA_CFG_ZOOKEEPER_CONNECT=zookeeper:2181
      - ALLOW_PLAINTEXT_LISTENER=yes
    depends_on:
      - zookeeper
  kafka3:
    container_name: kafka3
    image: docker.io/bitnami/kafka:2.8.0
    ports:
      - "19094:9092"
    volumes:
      - "./data/kafka3_data:/data"
    environment:
      - KAFKA_CFG_ZOOKEEPER_CONNECT=zookeeper:2181
      - ALLOW_PLAINTEXT_LISTENER=yes
    depends_on:
      - zookeeper

2. 进入 zookeeper 内部查看 brokers 是否存在

1
2
3

zkCli.sh
ls /brokers/ids
...

kraft 模式部署

1. kraft/server.properties

1
2
3
4

# 根据节点数改
node.id=1
# 控制节点
controller.quorum.voters=1@master:9093,2@slave1:9093,3@slave2:9093

2. 生成集群ID

1

./bin/kafka-storage.sh random-uuid

3. 生成 /tmp/kraft-combined-logs 目录

1

./bin/kafka-storage.sh format -t <uuid> -c ./config/kraft/server.properties

4. 各节点启动 kafka

1

./bin/kafka-server-start.sh -daemon ./config/kraft/server.properties

kraft 模式 docker-compose 部署

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

version: "3.8"
services:
  kafka1:
    container_name: kafka1
    image: docker.io/bitnami/kafka:2.8.0
    command:
      - /bin/bash
      - -c
      - |
          kafka-storage.sh format -t <uuid> -c /opt/bitnami/kafka/config/kraft/server.properties
          kafka-server-start.sh /opt/bitnami/kafka/config/kraft/server.properties
    ports:
      - "19092:9092"
    volumes:
      - "./conf/kafka1:/opt/bitnami/kafka/config/kraft"
    environment:
      - ALLOW_PLAINTEXT_LISTENER=yes
  kafka2:
    container_name: kafka2
    image: docker.io/bitnami/kafka:2.8.0
    command:
      - /bin/bash
      - -c
      - |
          kafka-storage.sh format -t <uuid> -c /opt/bitnami/kafka/config/kraft/server.properties
          kafka-server-start.sh /opt/bitnami/kafka/config/kraft/server.properties
    ports:
      - "19093:9092"
    volumes:
      - "./conf/kafka2:/opt/bitnami/kafka/config/kraft"
    environment:
      - ALLOW_PLAINTEXT_LISTENER=yes
  kafka3:
    container_name: kafka3
    image: docker.io/bitnami/kafka:2.8.0
    command:
      - /bin/bash
      - -c
      - |
          kafka-storage.sh format -t <uuid> -c /opt/bitnami/kafka/config/kraft/server.properties
          kafka-server-start.sh /opt/bitnami/kafka/config/kraft/server.properties
    ports:
      - "19094:9092"
    volumes:
      - "./conf/kafka3:/opt/bitnami/kafka/config/kraft"
    environment:
      - ALLOW_PLAINTEXT_LISTENER=yes

2.2 kafka基本使用

1. 列出某个 zookeeper 中的 topic

1

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

2. 创建 topic

1
2
3

# --replication-factor:副本数，总副本数为(分区数 * 副本数参数)，下面的例子总副本数为4
# --partitions:分区数
./kafka-topics.sh --create --zookeeper zookeeper_ip:2181 --replication-factor 2 --partitions 2 --topic test

3. 删除 topic

1
2

# delete.topic.enable为true时才会真正删除
./kafka-topics.sh --delete --zookeeper zookeeper_ip:2181 --topic test

4. 查看 topic

1

./kafka-topics.sh --describe --zookeeper zookeeper_ip:2181 --topic test

5. 启动 producer

1
2

# --broker-list:针对生产者使用，指定集群中的一个或者多个kafka服务器
./kafka-console-producer.sh --broker-list kafka_id:9092 --topic test

6. 启动 consumer

1
2
3

# --bootstrap-server:针对消费者使用，指定集群中的一个或者多个kafka服务器
# --from-beginning:查看所有消息数据
./kafka-console-consumer.sh --bootstrap-server kafka_id:9092 --topic test --from-beginning

2.3 单播消息

如果多个消费者在同一个消费者组，只有一个消费者可以收到同一个订阅的 topic 的消息。

如果 topic 进行了分区，那么一个 partition 只能被消费者组内的一个消费者消费，但消费者可以消费多个不同的 partition，而这些 partition 也可以被不同消费者组的消费者消费。

1
2

# --consumer-property group.id:指定该消费者从属于哪个消费者组
./kafka-console-consumer.sh --bootstrap-server kafka_id:9092 --consumer-property group.id=testgroup --topic test 

2.4 多播消息

如果多个不同消费者组中的消费者消费同一个订阅的 topic 的消息，那么这些消费者都可以消费同样的消息。

2.5 查看消费者组信息

1. 查看指定节点有哪些消费者组

1

./kafka-consumer-groups.sh --bootstrap-server kafka_id:9092 --list

2. 查看消费者组详细信息

1
2
3
4

./kafka-consumer-groups.sh --bootstrap-server kafka_id:9092 --describe --group testgroup
# CURRENT-OFFSET:上次消费消息偏移量
# LOG-END-OFFSET:当前topic最后消息偏移量
# LAG:未消费信息的数量

2.6 kafka集群操作

1. 消息发送

1

./kafka-console-producer.sh --broker-list kafka_01:9092 kafka_02:9092 kafka_03:9092 --topic test

2. 消息消费

1

./kafka-console-consumer.sh --bootstrap-server kafka_01:9092 kafka_02:9092 kafka_03:9092 --from-beginning --topic test

3. 消费者组消费信息

1

./kafka-consumer-groups.sh --bootstrap-server kafka_01:9092 kafka_02:9092 kafka_03:9092 --from-beginning --consumer-property group.id=testgroup --topic test

三、kafka优化

3.1 如何防止消息丢失

• 发送方：设置 ack 的值为 1 或 -1/all
• 消费方：设置 offset 为手动提交

3.2 如何防止消息的重复消费

如果 broker 收到了消息并发送了 ack 给生产者，因为网络原因生产者在一定时间内没有收到 ack 就会进行消息的重新发送，这样 broker 就会有两条一样的消息，就可能会造成消费者重复消费。

在消费者端进行非幂等性（多次访问的结果是一样的）消费问题，就可以解决。

• 方法一：在数据库中创建一个联合主键（id，uuid），这样只有联合主键匹配成功才能写入数据
• 方法二：使用分布式锁，例如 Redission.lock（uuid）

3.3 如何做到顺序消费

顺序消费的使用场景并不多，因为会牺牲较多的性能。

• 发送方：ack 不能设置为 0（否则可能会丢失消息），关闭重试并使用同步发送（重试可能会导致消息重复，异步发送会导致消息发送顺序不一致），消息发送成功后才会发送下一条，以保证消息的顺序发送
• 消费方：消息都是发送到一个 partition 中，只能有一个消费者来消费该 partition 的消息

3.4 消息积压

当消费者的消费速度远远跟不上生产者的消息生产速度，那么 kafka 中就会有大量的消息没有被消费，消费者寻址的性能也会越来越差，最后导致服务雪崩。

• 方法一：使用多线程
• 方法二：创建多个消费者组和多个消费者，一起消费
• 方法三：创建一个消费者，该消费者新建一个 topic，并划分多个分区，多个分区再划分给多个消费者，这时候该消费者将消息拉取下来但不进行消费，而是放在新的 topic 上让多个消费者进行消费。

3.5 延时队列

如果在订单创建成功后 30 分钟内没有付款，则自动取消订单，在这就可以通过延时队列来实现。

方法：

• kafka 创建相应 topic
• 消费者轮询消费该 topic 的消息
• 消费者判断该 topic 的创建时间与当前时间是否超过 30 分钟（前提是订单未支付）
  • 如果是：在数据库中修改订单状态为取消
  • 如果不是：记录当前消息的 offset，并不再继续消费

四、kafka-eagle监控平台

1. 下载 kafka-eagle

1

curl -O https://github.com/smartloli/kafka-eagle-bin/archive/v2.0.8.tar.gz

2. 修改 system-config.properties

1
2
3
4
5
6
7
8

# zk地址
efak.zk.cluster.alias=cluster1
cluster1.zk.list=localhost:12181
# mysql地址
efak.driver=com.mysql.cj.jdbc.Driver
efak.url=jdbc:mysql://127.0.0.1:3306/ke?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
efak.username=root
efak.password=toortoor

3. 修改环境变量

1
2
3
4
5
6
7

vim /etc/profile
export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.302.b08-0.el7_9.x86_64
export CLASSPATH=.:$JAVA_HOME/jre/lib/rt.jar.:$JAVA_HOME/lib/dt.jar.:$JAVA_HOME/lib/tools.jar
export PATH=$PATH:$JAVA_HOME/bin
export KE_HOME=/root/kafka/kafka-eagle/efak-web-2.0.8
export PATH=$PATH:$KE_HOME/bin
source /etc/profile

4. 访问

Nexus 是一个用于专门搭建 Maven 仓库的软件，除了作为 Maven 仓库，它还能够作为 Docker 镜像仓库、Yum 仓库等等。

Nexus 部署

deploy.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: nexus
  name: nexus
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nexus
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: nexus
    spec:
      initContainers:
        - name: volume-mount-hack
          image: busybox:latest
          command:
            - sh
            - '-c'
            - 'chown -R 200:200 /nexus-data'
          volumeMounts:
            - name: nexus-data
              mountPath: /nexus-data
      containers:
      - image: sonatype/nexus3:3.37.3
        name: nexus
        ports:
          - containerPort: 8081
        env:
          - name: INSTALL4J_ADD_VM_PARAMS
            value: "-Xms2703m -Xmx2703m -XX:MaxDirectMemorySize=2703m -Djava.util.prefs.userRoot=${NEXUS_DATA}/javaprefs"
        resources:
          limits:
            cpu: 2000m
            memory: 2048Mi      
          requests:
            cpu: 2000m
            memory: 2048Mi
        volumeMounts:
            - name: nexus-data
              mountPath: /nexus-data
      volumes:
      - name: nexus-data
        # 自行修改挂载类型，不修改则需创建对应PV和PVC👇
        persistentVolumeClaim:
          claimName: nexus-data
  
---
apiVersion: v1
kind: Service
metadata:
  name: nexus
  labels:
    app: nexus
spec:
  type: NodePort
  ports:
    - name: nexus
      port: 8081
      targetPort: 8081
      protocol: TCP
  selector:
    app: nexus

部署后，在容器内部获取 admin 密码

1

echo $(cat /nexus-data/admin.password)

默认仓库说明

• maven-central：中央仓库，默认从 https://repo1.maven.org/maven2/ 拉取 jar 包
• maven-releases：私库发行 jar，建议将设置改为 Allow redeploy
• maven-snapshots：私库快照 jar，即库中的 jar 均为调试版本
• maven-public：仓库分组，把上面三个仓库组合在一起对外提供服务，在本地 maven 的 settings.xml 文件或项目的 pom.xml 文件设置为该仓库地址，即可调用

仓库类型说明

• group：仓库组，起到了聚合的作用，在该组中的仓库都可以通过该组的 URL 进行访问
• hosted：私有仓库，顾名思义，用来存储自己的 jar 包
• snapshot：快照仓库
• release：本地项目的正式版本仓库
• proxy：代理，Nexus 的 maven-central 就是这种类型，代理地址为 https://repo1.maven.org/maven2/ ，默认会去该地址下拉取 jar 包
• central：中央仓库

新增代理仓库

创建仓库选择 maven2(proxy) 类型

添加到 maven-public

Maven 配置使用私服

要在本地 Maven 在私服拉取 jar 的方式有两种：

• settings.xml：全局配置模式
• pom.xml：项目独享模式

如果两种方式都配置了，那么以 pom.xml 文件配置为准。

当我们通过 Maven 使用 Nexus 的 maven-public 的时候，会按照以下方式顺序访问：

1. 本地仓库

2. 私服 maven-releases

3. 私服 maven-snapshots

4. 远程阿里 maven 仓库

5. 远程中央仓库

通过 settings.xml 文件配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<!-- servers块中添加用户认证信息 -->
<server>
   <id>nexus</id>
   <username>admin</username>
   <password>changeme</password>
</server>
<!-- mirrors块中添加maven-public信息 -->
<mirror>
   <!-- 唯一标识符 -->
   <id>nexus</id> 
   <!-- 名称 -->
   <name>cqm maven</name>
   <!-- maven-public地址 -->
   <url>http://192.168.159.11:35826/repository/maven-public/</url>
   <!-- *指的是访问任何仓库都使用我们的私服，可设置为central等等 -->
   <mirrorOf>*</mirrorOf>
</mirror>

也可以设置为阿里的

1
2
3
4
5
6

<mirror>
   <id>alimaven</id>
   <name>aliyun maven</name>
   <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
   <mirrorOf>central</mirrorOf>
</mirror>

通过 pom.xml 文件配置

1
2
3
4
5
6
7
8
9
10
11
12
13

<repositories>
    <repository>
        <id>mnexus</id>
        <name>cqm nexus</name>
        <url>http://192.168.159.11:35826/repository/maven-public/</url>
        <releases>
            <enabled>true</enabled>
        </releases>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>

同样也可以设置为阿里的

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<repositories>
   <repository>
      <id>alimaven</id>
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
      <releases>
         <enabled>true</enabled>
      </releases>
      <snapshots>
         <enabled>true</enabled>
         <updatePolicy>always</updatePolicy>
         <checksumPolicy>fail</checksumPolicy>
      </snapshots>
   </repository>
</repositories>

使用 Maven 批量向 Nexus 上传

首先需要将 .m2/repository 下的相应 jar 包和 pom 文件 cp 出来，再进行 deploy。

1
2

# -DrepositoryId 参数调用了 settings.xml 中 servers 块的账号密码进行认证
find . -name "*.jar" | awk '{ gsub("\.jar$","",$0); print "mvn deploy:deploy-file -Dfile="$0".jar -DpomFile="$0".pom -Dpackaging=jar -DrepositoryId=nexus -Durl=\"http://nexus-path\""}'	

Jenkins是一个开源的持续集成的服务器，Jenkins开源帮助我们自动构建各类项目。Jenkins强大的插件式，使得Jenkins可以集成很多软件，可能帮助我们持续集成我们的工程项目。

一、什么是CI、CD

Devops也就是开发运维一体化，而随着Devops的兴起，出现了持续集成、持续交付以及持续部署的新方法，传统的软件开发和交付方法正在迅速变得过时。从历史上看，在敏捷时代，大多数公司会每月、每季度、每两年甚至每年发布部署或发布软件。然而，在DevOps时代，每周、每天、甚至每天多次。当SaaS正在占领世界时，我们可以轻松地动态更新应用程序，而无需强迫客户下载新组件。很多时候，他们甚至都不会意识到正在发生变化。开发团队通过软件交付流水线（Pipeline）实现自动化，以缩短交付周期，大多数团队都有自动化流程来检查代码并部署到新环境。

持续集成的重点是将各个开发人员的工作集合到一个代码仓库中。通常，每天都要进行几次，主要目的是尽早发现集成错误，使团队更加紧密结合，更好地协作。

持续交付的目的是最小化部署或释放过程中固有的摩擦。它的实现通常能够将构建部署的每个步骤自动化，以便任何时刻能够安全地完成代码发布（理想情况下）。

持续部署是一种更高程度的自动化，无论何时对代码进行重大更改，都会自动进行构建/部署。

而Jenkins就是来实现以上持续集成工作的服务器。

二、持续集成环境搭建

Jenkins流程图：

2.1 Gitlab代码托管服务器安装

Gitlab 是一个用于仓库管理系统的开源项目，使用Git作为代码管理工具，并在此基础上搭建起来的Web服务。

1. 开启postfix服务（支持gitlab发信功能）

1
2

systemctl start postfix
systemctl enable postfix

2. 配置gitlab的yum源

1
2
3
4
5
6
7
8
9

vim /etc/yum.repos.d/gitlab-cd.repo
[gitlab-ce]
name=Gitlab CE Repository
baseurl=https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/yum/el$releasever/
gpgcheck=0
enabled=1

yum clean all
yum makecache

3. 安装gitlab

1

yum -y install gitlab-ce

4. 修改gitlab配置文件

1
2
3
4
5
6
7
8
9

vim /etc/gitlab/gitlab.rb
#用户访问所使用的URL，域名或者IP地址
external_url 'http://192.168.88.133'
#时区
gitlab_rails['time_zone'] = 'Asia/Shanghai'
#启用SMTP邮箱功能
gitlab_rails['smtp_enable'] = 'ture'
#使用SSH协议拉取代码所使用的连接端口
gitlab_rails['gitlab_shell_ssh_port'] = '22'

5. 刷新配置

1

gitlab-ctl reconfigure

6. 启动服务

1
2
3

gitlab-ctl restart
gitlab-ctl status
......

7. docker-compose.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

version: '3.8'
services:
  gitlab:
    container_name: gitlab
    image: gitlab/gitlab-ce:latest
    restart: always
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        external_url 'http://192.168.88.30'
        gitlab_rails['time_zone'] = 'Asia/Shanghai'
        gitlab_rails['gitlab_shell_ssh_port'] = '22'
    ports:
      - '80:80'
      - '23:22'
    volumes:
      - '/root/cicd/gitlab/config:/etc/gitlab'
      - '/root/cicd/gitlab/logs:/var/log/gitlab'
      - '/root/cicd/gitlab/data:/var/opt/gitlab'

8. 进入容器查看默认用户名和修改密码

1
2
3
4
5
6
7
8
9

gitlab-rails console
# 查找root用户
u=User.where(id:1).first
# 修改密码
u.password='toortoor'
# 确认修改密码
u.password_confirmation='toortoor'
# 保存修改
u.save

2.2 Gitlab创建组、用户、项目

Gitlab创建组：

1. 添加组

2. 设置组名和权限

Gitlab创建用户：

1. 添加用户

2. 配置选项

3. 将用户添加到项目组

Gitlab创建项目：

1. 在指定组中添加项目

2. 设置项目名称

2.5 项目上传到Gitlab

2.4 Jenkins安装

1. 安装JDK

1

yum -y install java-1.8.0-openjdk*

2. 放行端口

1
2

firewall-cmd --zone=public --add-port=8888/tcp --permanent
firewall-cmd --reload

3. 添加Jenkins官方源并安装

1
2
3

wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo
rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io.key
yum -y install jenkins

4. 修改配置文件

1
2
3

vim /etc/sysconfig/jenkins
JENKINS_USER="root"
JENKINS_PORT="8888"

5. 查看初始密码

1
2

cat /var/lib/jenkins/secrets/initialAdminPassword
......

6. docker-compose.yaml

1
2
3
4
5
6
7
8
9
10
11

version: '3.8'
services:
  jenkins:
    container_name: jenkins
    image: jenkins:2.60.3
    restart: always
    ports:
      - '8080:8080'
      - '50000:50000'
    volumes:
      - '/root/cicd/jenkins/home:/var/jenkins_home'

2.5 Jenkins中文插件安装

1. 由于Jenkins官方下载插件很慢，我们修改为国内Jenkins插件地址，jenkins -> Manage jenkins -> Manage Plugins

1. 更换配置文件中的地址

1
2
3
4
5

cp /var/lib/jenkins/updates/default.json /var/lib/jenkins/updates/default.json.backup

sed -i 's/https:\/\/updates.jenkins.io\/download/https:\/\/mirrors.tuna.tsinghua.edu.cn\/jenkins/g' /var/lib/jenkins/updates/default.json && sed -i 's/http:\/\/www.google.com/https:\/\/www.baidu.com/g' /var/lib/jenkins/updates/default.json

systemctl restart jenkins

3. 安装中文插件

2.6 Jenkins用户权限管理

1. 由于Jenkins功能较为简介，都要靠安装插件来丰富体验，所以用户管理需要安装role-based插件

2. 在Configure Global Security开启刚刚安装的插件

3. 在Manage and Assign Roles中创建角色baserole并分配具体权限

4. 用户没加入角色前是没有访问权限的，将用户加入到角色baserole即可，但只有部分权限

2.7 Jenkins安装凭证管理插件

1. 安装Credential Binding插件，安装完就可以看到多了凭据的功能

2.8 Jenkins普通用户密码认证

1. 为了Jenkins能够拉取gitlab的代码，需要安装git插件

1

yum -y install git

2. 创建普通用户凭证，注意这里的用户是gitlab创建好的用户

3. 创建项目添加普通用户凭证

4. build now构建

1. Jenkins主机上查看是否构建成功

2.9 Jenkins使用ssh免密认证

1. 在Jenkins主机上生产公钥私钥

1

ssh-keygen -t rsa

2. 在gitlab上添加公钥

3. 在Jenkins上添加ssh凭证

4. 创建项目添加ssh凭证

5. build now构建项目后

2.10 Jenkins安装Maven

1. 下载maven

1
2
3
4

wget https://mirrors.bfsu.edu.cn/apache/maven/maven-3/3.6.3/binaries/apache-maven-3.6.3-bin.tar.gz
mkdir maven
tar -xf apache-maven-3.6.3-bin.tar.gz
cp apache-maven-3.6.3-bin.tar.gz/* maven/

2. 配置环境变量

1
2
3
4
5
6

vim /etc/profile
export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk
export MAVEN_HOME=/root/maven
export PATH=$PATH:$JAVA_HOME/bin:/$MAVEN_HOME/bin
source /etc/profile
mvn -v

3. 全局工具配置里新增jdk和maven

4. 在系统配置里添加三个变量

5. 修改maven配置文件

1
2
3
4
5
6
7
8
9

mkdir /root/repo
vim /root/maven/conf/settings.xml
<localRepository>/root/repo</localRepository>
<mirror>
  <id>aliyunmaven</id>
  <mirrorOf>*</mirrorOf>
  <name>阿里云公共仓库</name>
  <url>https://maven.aliyun.com/repository/public</url>
</mirror>

6. 测试maven构建项目

2.11 Tomcat安装和配置

1. 安装jdk和tomcat

1
2
3
4
5
6

yum -y install java-1.8.0-openjdk*
wget https://downloads.apache.org/tomcat/tomcat-9/v9.0.43/bin/apache-tomcat-9.0.43.tar.gz
tar -xf apache-tomcat-9.0.43.tar.gz
mkdir /root/tomcat
mv apache-tomcat-9.0.43.tar.gz/* /root/tomcat
./root/tomcat/bin/startup.sh

2. 添加tomcat管理用户

1
2
3
4
5
6
7
8
9

vim /root/tomcat/conf/tomcat-users.xml
  <role rolename="tomcat"/>
  <role rolename="role1"/>
  <role rolename="manager-gui"/>
  <role rolename="manager-script"/>
  <role rolename="admin-gui"/>
  <role rolename="admin-script"/>
  <role rolename="manager-status"/>
  <user username="tomcat" password="toortoor" roles="manager-gui,manager-script,tomcat,admin-gui,admin-script"/>

1
2
3
4
5

vim /root/tomcat/webapps/manager/META-INF/context.xml
<!--
  <Valve className="org.apache.catalina.valves.RemoteAddrValve"
         allow="127\.\d+\.\d+\.\d+|::1|0:0:0:0:0:0:0:1" />
-->

3. 测试

三、Jenkins构建项目

Jenkins构建的项目类型主要为以下三种：

1. 自由风格软件项目（freestyle project）
2. Maven项目（maven project）
3. 流水线项目（pipeline project）

3.1 自由风格软件项目构建

1. 要将项目部署到tomcat服务器上，需要安装deploy to container插件

2. Jenkins -> 新建items

3. 使用ssh免密登录来拉取代码

4. 使用maven编译打包

5. 部署

6. 再次构建后可以回到tomcat查看是否部署成功

3.2 Maven项目构建

1. 安装Maven Integration插件

2. 创建maven项目

3. 构建设置，其余设置都相同

4. 构建后查看是否部署成功

3.3 Pipeline project简介

pipeline就是一套运行在Jenkins上的工作流框架，将独立运行的单个或多个节点的任务连接起来，实现复杂流程的编排和可视化的工作。

优点有：

• 自动地为所有分支创建流水线构建过程并拉取请求。
• 在流水线上代码复查/迭代 (以及剩余的源代码)。
• 对流水线进行审计跟踪。
• 该流水线的真正的源代码，可以被项目的多个成员查看和编辑。

3.4 Pipeline流水线项目构建

1. 安装pipeline插件
2. 新建流水线项目

声明式流水线

3.5 Jenkinsfile脚本文件

pipeline脚本内容放在Jenkins服务器不好管理，所以就在项目添加一个Jenkinsfile文件并推送到gitlab上，实现直接拉取执行。

1. 在项目下添加一个Jenkinsfile，将pipeline内容复制进去并推送到gitlab上

2. 在pipeline项目中修改为在gitlab拉取Jenkinsfile文件

四、Jenkins构建细节

4.1 Jenkins常用的构建触发器

Jenkins内置4种构建触发器：

• 触发远程构建
• 其它工程构建后触发
• 定时构建
• 轮询SCM

4.2 触发远程构建

1. 在项目中设置触发器

2. 在浏览器输入JENKINS_URL/job/pipeline-project/build?token=TOKEN_NAME即可触发

4.3 其它工程构建后触发

是指某一工程构建后才会触发构建，这里测试freestyle工程构建后触发pipeline构建

1. 在pipeline配置构建后触发

2. freestyle工程构建后就会触发pipeline构建

4.4 定时构建

五个*分别代表分时日月周，H/2则代表每分时日月周

4.5 轮询SCM

和定时构建一样是设置时间来进行构建，不过轮询只有在代码仓库发生变化后才会触发，相当于定时检查

注意：轮询会定时扫描仓库的代码，增大系统的开销，不建议使用

4.6 Gitlab Hook自动触发构建

SCM轮询是Jenkins服务器主动检测gitlab中的代码有没有发生变化，而gitlab的webhook可以实现代码变更后向Jenkins服务器主动发送构建请求，实现自动构建。

1. 在Jenkins安装gitlab和gitlab hook插件

2. 在gitlab配置中允许发出请求

3. 在项目中添加第一步中的地址

4. 配置Jenkins允许接受gitlab发送过来的请求

4.7 Jenkins参数化构建

前边实操演示的都是默认从master下拉取代码，如果要实现在其他分支拉取代码，就需要设置参数化构建。

1. 在Jenkins的项目中添加参数，这里选择字符串参数

2. 修改Jenkinsfile文件中拉取代码部分的master为变量，并推送到gitlab

3. 在项目中添加一个v1分支

4. 在Jenkins中拉取v1代码构建

4.8 配置邮件服务器发送构建结果

1. 安装Email Extension插件

2. 在Jenkins中配置

3. 在项目中创建一个email.html文件，添加以下内容并推送到gitlab中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>${PROJECT_NAME}-第${BUILD_NUMBER}次构建日志</title>
</head>
 
<body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4">
    <table width="95%" cellpadding="0" cellspacing="0"
        style="font-size: 11pt; font-family: Tahoma, Arial, Helvetica, sans-serif">
        <tr>
            <td>(本邮件是程序自动下发的，请勿回复！)<br/></td>
        </tr>
        <tr>
            <td><h2>
                    <font color="#0000FF">构建结果 - ${BUILD_STATUS}</font>
                </h2></td>
        </tr>
        <tr>
            <td><br />
            <b><font color="#0B610B">构建信息</font></b>
            <hr size="2" width="100%" align="center" /></td>
        </tr>
        <tr>
            <td>
                <ul>
                    <li>项目名称 ： ${PROJECT_NAME}</li>
                    <li>构建编号 ： 第${BUILD_NUMBER}次构建</li>
                    <li>触发原因： ${CAUSE}</li>
                    <li>构建日志： <a href="${BUILD_URL}console">${BUILD_URL}console</a></li>
                    <li>构建  Url ： <a href="${BUILD_URL}">${BUILD_URL}</a></li>
                    <li>工作目录 ： <a href="${PROJECT_URL}ws">${PROJECT_URL}ws</a></li>
                    <li>项目  Url ： <a href="${PROJECT_URL}">${PROJECT_URL}</a></li>
                </ul>
            </td>
        </tr>
        <tr>
            <td><b><font color="#0B610B">Changes Since Last Successful Build:</font></b>
            <hr size="2" width="100%" align="center" /></td>
        </tr>
        <tr>
            <td>
                <ul>
                    <li>历史变更记录 : <a href="${PROJECT_URL}changes">${PROJECT_URL}changes</a></li>
                </ul> ${CHANGES_SINCE_LAST_SUCCESS,reverse=true, format="Changes for Build #%n:<br />%c<br />",showPaths=true,changesFormat="<pre>[%a]<br />%m</pre>",pathFormat="    %p"}
            </td>
        </tr>
        <tr>
            <td> <hr size="2" width="100%" align="center" /></td>
        </tr>
        <tr>
            <td></td>
        </tr>
        <tr>
            <td><b><font color="#0B610B">构建情况总览:</font></b>${TEST_COUNTS,var="fail"}<br/>
            <hr size="2" width="100%" align="center" /></td>
        </tr>
        <tr>
            <td><textarea cols="80" rows="30" readonly="readonly"
                    style="font-family: Courier New">${BUILD_LOG,maxLines=23}</textarea>
            </td>
        </tr>
    </table>
</body>
</html>

4. 在Jenkinsfile中添加发送email功能，post即指构建后操作

1
2
3
4
5
6
7
8
9

post {
	always {
		emailext(
			subject: '构建通知：${PROJECT_NAME} - Build # ${BUILD_NUMBER} - ${BUILD_STATUS}!',
			body: '${FILE,path="email.html"}',
			to: 'chenqiming13@qq.com'
		)
	}
}

5. 构建测试是否收到邮件

五、Jenkins+SonarQube代码审查

sonarqube是一个用于管理代码质量的开放平台，可以快速定位代码中潜在的错误。

环境要求：

1. JDK11
2. PostgreSQL

5.1 安装PostgreSQL

1. 新版本的sonarqube不再支持MySQL，所以在Jenkins服务器上安装PostgreSQL并创建一个sonar数据库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#安装postgresql
yum -y install https://download.postgresql.org/pub/repos/yum/9.6/redhat/rhel-7-x86_64/pgdg-redhat-repo-latest.noarch.rpm
yum -y install postgresql96-server postgresql96-contrib

#初始化postgresql
postgresql-9.6-setup initdb
systemctl enable postgresql-9.6.service
systemctl start postgresql-9.6.service

#初始化之后会自动创建postgres用户，切换用户
su - postgres

#psql进入命令行模式配，\q退出
psql
alter user postgres with password 'toortoor';
create database sonar;
create user sonar;
alter user sonar with password 'toortoor';
alter role sonar createdb;
alter role sonar superuser;
alter role sonar createrole;
alter database sonar owner to sonar;
\q

2. 开启远程访问和远程连接

1
2
3
4
5

vim /var/lib/pgsql/9.6/data/postgresql.conf
listen_addresses = '*'
vim /var/lib/pgsql/9.6/data/pg_hba.conf
host    all             all             127.0.0.1/32            trust
host    all             all             192.168.88.1/32         trust

3. 重启服务

5.2 安装SonarQube

1. 安装sonarqube

1
2
3
4
5
6

wget https://binaries.sonarsource.com/Distribution/sonarqube/sonarqube-8.7.1.42226.zip
unzip sonarqube-8.7.1.42226.zip
mv sonarqube-8.7.1.42226 sonarqube
useradd sonar
chown -R sonar:sonar sonarqube/*
mv sonarqube /opt/sonarqube

2. 修改sonar配置文件

1
2
3
4
5
6

vim sonarqube/conf/sonar.properties
sonar.jdbc.username=sonar
sonar.jdbc.password=toortoor
sonar.jdbc.url=jdbc:postgresql://localhost/sonarqube?currentSchema=my_schema
sonar.jdbc.url=jdbc:postgresql://localhost/sonar?currentSchema=public
sonar.web.port=9000

3. 启动sonarqube

1
2
3

#只能用sonar用户启动
su sonar
./opt/sonarqube/bin/linux-x86-64/sonar.sh start

4. 遇到的问题

1
2
3
4
5
6

#sonar用户线程数不够，*代表所有用户
cat /etc/security/limits.conf
* soft nofile 65536
* hard nofile 65536
* soft noproc 65535
* hard noproc 65535

5. deploy.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sonarqube
  labels:
    app: sonarqube
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sonarqube
  template:
    metadata:
      name: sonarqube
      labels:
        app: sonarqube
    spec:
      initContainers:
      - name: init-sysctl
        image: busybox
        imagePullPolicy: IfNotPresent
        command: ["sysctl", "-w", "vm.max_map_count=262144"]
        securityContext:
          privileged: true
      containers:
      - name: sonarqube
        image: sonarqube:lts-community
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 9000
        env:
        # 此处用到了集群现有的pg
        # 数据库用户sonarqube
        # 数据库名sonarqube
        - name: SONARQUBE_JDBC_USERNAME
          value: "sonarqube"
        - name: SONARQUBE_JDBC_PASSWORD
          value: "dangerous"
        - name: SONARQUBE_JDBC_URL
          value: "jdbc:postgresql://dcs-installer-gitlab-postgresql.dcs-system:5432/sonarqube"
        livenessProbe:
          httpGet:
            path: /sessions/new
            port: 9000
          initialDelaySeconds: 60
          periodSeconds: 30
        readinessProbe:
          httpGet:
            path: /sessions/new
            port: 9000
          initialDelaySeconds: 60
          periodSeconds: 30
          failureThreshold: 6
        resources:
          limits:
            cpu: 2000m
            memory: 2048Mi
          requests:
            cpu: 1000m
            memory: 1024Mi
 
---
apiVersion: v1
kind: Service
metadata:
  name: sonarqube
spec:
  type: NodePort
  selector:
    app: sonarqube
  ports:
  - port: 9000
    targetPort: 9000
    protocol: TCP

5.3 Jenkins整合SonarQube

1. 安装sonarqube scanner插件
2. 在Jenkins安装sonarqube scanner

3. 在sonarqube中生成密钥

4. 在系统配置中配置sonarqube server，利用刚刚生成的密钥

5.4 实现代码审查

非流水线项目添加代码审查

1. 在项目中添加构建步骤

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#Must be unique in a given SonarQube instance
# SonarQube创建项目时的key
sonar.projectKey=freestyle_project

#This is the name and version displayed in the SonarQube UI.
# 项目名称
sonar.projectName=freestyle_project
# 项目版本
sonar.projectVersion=1.0

#Path is relative to the sonar-project.properties file.
#This property is optional if sonar.modules is set.
sonar.sources=.
# 忽略扫描的目录
sonar.exclusions=**/test/**,**/target/**

sonar.java.source=11
sonar.java.target=11

#Encoding of the source code.Default is default system encoding.
sonar.sourceEncoding=UTF-8

2. 构建项目
3. 回到sonarqube就可以看到提交的代码审查了

流水线项目添加代码审查

1. 在项目中创建sonar-project.properties

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#Must be unique in a given SonarQube instance
sonar.projectKey=pipeline_project

#This is the name and version displayed in the SonarQube UI.
sonar.projectName=pipeline_project
sonar.projectVersion=1.0

#Path is relative to the sonar-project.properties file.
#This property is optional if sonar.modules is set.
sonar.sources=.
sonar.exclusions=**/test/**,**/target/**

sonar.java.source=11
sonar.java.target=11

#Encoding of the source code.Default is default system encoding.
sonar.sourceEncoding=UTF-8

2. 修改Jenkinsfile文件

1
2
3
4
5
6
7
8
9
10
11
12

stage('code checking'){
	steps {
		script {
			//引入scanner工具
			scannerHome = tool 'sonar-scanner'
		}
		//引入sonarqube服务器环境
		withSonarQubeEnv('sonarqube') {
			sh "${scannerHome}/bin/sonar-scanner"
		}
	}
}

3. 将Jenkinsfile和sonar-project.properties推送到gitlab
4. 构建项目后在sonarqube就可以看到代码审查了

六、Jenkins+Docker+SpringCloud微服务持续集成

大致流程：

1. 开发人员push代码到gitlab。
2. Jenkins服务器进行编译打包并构建镜像推送到harbor镜像仓库（服务器的JAVA环境要与项目对应）。
3. Jenkins服务器触发远程命令使生产服务器（tomcat）从私有仓库拉取镜像。
4. 生产服务器（tomcat）生成容器，项目上线。
5. 用户访问。

6.1 Harbor部署

1. 下载

1

curl -O https://github.com/goharbor/harbor/releases/download/v2.3.4/harbor-offline-installer-v2.3.4.tgz

2. 修改 harbor.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

cp harbor.yml.tmpl harbor.yml
egrep -v '^#|^$|*#' harbor.yml
hostname: 192.168.88.30
http:
  port: 81
harbor_admin_password: toortoor
database:
  password: toortoor
  max_idle_conns: 100
  max_open_conns: 900
data_volume: /root/cicd/harbor/data
trivy:
  ignore_unfixed: false
  skip_update: false
  insecure: false
jobservice:
  max_job_workers: 10
notification:
  webhook_job_max_retry: 10
chart:
  absolute_url: disabled
log:
  level: info
  local:
    rotate_count: 50
    rotate_size: 200M
    location: /root/cicd/harbor/var
_version: 2.3.0
proxy:
  http_proxy:
  https_proxy:
  no_proxy:
  components:
    - core
    - jobservice
    - trivy

3. docker-compose.yaml 文件中指定 harbor 访问端口为 80，避免与 gitlab 冲突， 修改为 81

4. 通过脚本部署

1
2

./prepare
./install.sh

5. 创建私有仓库

6. 修改 daemon.json，让 docker 信任此仓库

1
2
3
4

{
  "registry-mirrors": ["https://5v5rh037.mirror.aliyuncs.com"],
  "insecure-registries": ["192.168.88.30:81"]
}

7. 登录远程镜像仓库

1

docker login -u admin -p toortoor 192.168.88.30:81

6.2 提交代码到Gitlab

6.3 Jenkins创建流水线工程

1. 创建工程

2. 在项目根目录下创建 Jenkinsfile，通过语法生成器进行编写

3. Jenkinsfile 拉取代码部分

4. 在流水线工程中创建参数，如果有多个服务就可以根据参数选择进行构建

5. Jenkinsfile 添加编译打包微服务工程部分，以及通过 Dockerfile 构建镜像部分

• 在 pom.xml 中添加 Dockerfile 依赖

1
2
3
4
5
6
7
8
9
10

<plugin>
             <groupId>com.spotify</groupId>
             <artifactId>dockerfile-maven-plugin</artifactId>
             <version>1.4.10</version>
             <configuration>
                 <repository>${project.artifactId}</repository>
                 <buildArgs>
                     <JAR_NAME>target/${project.build.finalname}.jar</JAR_NAME>
                 </buildArgs>
         </plugin>

• 在项目根目录添加 Dockerfile

1
2
3
4
5
6

FROM openjdk:11
ARG JAR_NAME
WORKDIR /usr/src/myapp
EXPOSE 8080
COPY ./${JAR_NAME} /usr/src/myapp/
ENTRYPOINT ["java", "-jar", "/usr/src/myapp/${JAR_NAME}"]

6. Jenkinsfile 添加上传镜像至 Harbor 部分

• 在 Jenkins 中添加 Harbor 账户凭证，以便于上传代码，这里用到的是 Harbor 的用户名和密码

• 保留好凭证ID

• 在语法生成器中生成新语法用于登录 Harbor 仓库

7. Jenkins 安装 Publish Over SSH 插件，能够对远程主机发送 shell 命令，安装完后先给远程主机发送公钥

1

ssh-copy-id root@192.168.88.30

• 发送完后在系统配置进行配置

• 接着生成流水线语法，去远程执行脚本文件 test.sh

test.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

#!/bin/bash

harbor_url=$1
project_name=$2
image_name=$3
service_port=$4

# 删除none容器
echo "docker rmi none..."
docker images | grep none | awk '{ print "docker rmi "$3 }' | sh &>/dev/null

# 检查是否有已运行容器
num=`docker ps | grep $project_name | wc -l`
if [ $num -gt 0 ]
then
    docker stop $project_name && docker rm $project_name &>/dev/null
    if [ `echo $?` -eq 0 ]
    then
        echo "docker stop $project_name && docker rm $project_name [OK]"
    else
        echo "ERROR: docker stop $project_name && docker rm $project_name"
    fi
fi

# 检查是否有重命名镜像
temp=`docker images | grep $image_name | awk '{ print $1":"$2 }' | wc -l`
if [ $temp -eq 1 ]
then
    docker rmi $image_name &>/dev/null
    if [ `echo $?` -eq 0 ]
    then
        echo "docker rmi $image_name [OK]"
    else
        echo "ERROR: docker rmi $image_name"
    fi
fi

# 登录镜像仓库
echo "docker login repository..."
docker login -u admin -p toortoor $harbor_url &>/dev/null
if [ `echo $?` -ne 0 ]
then
    echo "ERROR: failed to login repository"
else
    echo "docker login repository [OK]"
fi

# 拉取镜像
echo "docker pull image..."
docker pull $image_name &>/dev/null
if [ `echo $?` -ne 0 ]
then
    echo "ERROR: failed to pull image"
else
    echo "docker pull image [OK]"
fi

# 运行容器
echo "docker run container..."
docker run -d --name $project_name -p $service_port:8080 $image_name &>/dev/null
if [ `echo $?` -ne 0 ]
then
    echo "ERROR: failed to run container"
else
    echo "docker run container [OK]"
fi

8. 最终的 Jenkinsfile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

// git凭证id
def git_auth = "bad37d0d-7260-43a2-a350-9abf6e99753a"
// git凭证url
def git_url = "http://192.168.88.30/test_group/test_project.git"
// Harbor地址
def harbor_url = "192.168.88.30:81"
// 镜像仓库名称
def harbor_repository = "test"
// Harbor用户凭证ID
def harbor_auth = "c147d241-a254-48d6-be1c-0d5f0964ce9a"
// 镜像版本号
def image_version = "1.0"
// 拉取的微服务名称
def project_name = "test"
// 微服务所需端口号
def service_port = "8081"


node {
    // 拉取代码
    stage('Pull Code') {
        git branch: "${branch}", credentialsId: "${git_auth}", url: "${git_url}"
    }

    // 编译，打包微服务工程，构建镜像
    stage('Mvn clean package and Docker build') {
        sh "mvn clean package dockerfile:build"
    }

    // 上传镜像至Harbor
    stage('Push image to Harbor') {
        // 镜像命名，打标签
        def image_name = "${project_name}:${image_version}"
        sh "docker tag ${project_name}:latest ${harbor_url}/${harbor_repository}/${image_name} && docker rmi ${project_name}:latest"
        // 登录Harbor仓库
        withCredentials([usernamePassword(credentialsId: "${harbor_auth}", passwordVariable: 'harbor_password', usernameVariable: 'harbor_user')]) {
            sh "docker login -u ${harbor_user} -p ${harbor_password} ${harbor_url}"
        }
        // 镜像上传
        sh "docker push ${harbor_url}/${harbor_repository}/${project_name}:${image_version}"
    }

    // 远程连接服务器拉取镜像运行
    stage('Pull image and Running container') {
        // 获取镜像命名
        def image_name = "${project_name}:${image_version}"
        sshPublisher(publishers: [sshPublisherDesc(configName: '192.168.88.30', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: './root/test.sh $harbor_url $project_name $harbor_url/$harbor_repository/image_name $service_port', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '', remoteDirectorySDF: false, removePrefix: '', sourceFiles: '')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
    }
}

6.4 微服务架构CICD优化

从以上配置中可以看到，每次构建都只能选择一个服务，且部署的服务器也只有一台，是不符合生产环境的，主要需求有以下三个：

• 多个微服务同时构建流水线工程
• 批量处理镜像
• 将微服务部署服务器集群

1. 安装 Extended Choice Parameter 插件，实现多个微服务同时构建

2. 在创建流水线时设置选项

3. 将公钥下发，并在系统设置的 Publish over SSH 中添加多台主机
4. 在流水线工程中添加多一个多选项配置，用于选择要部署的服务器

5. 修改流水线语法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

// git凭证id
def git_auth = "bad37d0d-7260-43a2-a350-9abf6e99753a"
// git凭证url
def git_url = "http://192.168.88.30/test_group/test_project.git"
// Harbor地址
def harbor_url = "192.168.88.30:81"
// 镜像仓库名称
def harbor_repository = "test"
// Harbor用户凭证ID
def harbor_auth = "c147d241-a254-48d6-be1c-0d5f0964ce9a"
// 镜像版本号
def image_version = "1.0"

node {
    // 获取服务名
    def selectedProjectNames = "${project_name}".split(",")
    // 获取集群地址
    def selectedServices = "${publish_server}".split(",")

    // 拉取代码
    stage('Pull Code') {
        git branch: "${branch}", credentialsId: "${git_auth}", url: "${git_url}"
    }

    // 编译，打包微服务工程，构建镜像
    stage('Mvn clean package and Docker build') {
        sh "mvn clean package dockerfile:build"
    }

    // 上传镜像至Harbor
    stage('Push image to Harbor') {
        for(int i=0; i<selectedProjectNames.length; i++) {
            // 获取每个选项
            def project_info = selectedProjectNames[i]
            // 获取选项中的微服务名称
            def current_project_name = "${project_info}".split("@")[0]
            // 镜像命名，打标签
            def image_name = "${current_project_name}:${image_version}"
            sh "docker tag ${current_project_name}:latest ${harbor_url}/${harbor_repository}/${image_name} && docker rmi ${current_project_name}:latest"
            // 登录Harbor仓库
            withCredentials([usernamePassword(credentialsId: "${harbor_auth}", passwordVariable: 'harbor_password', usernameVariable: 'harbor_user')]) {
                sh "docker login -u ${harbor_user} -p ${harbor_password} ${harbor_url}"
            }
            // 镜像上传
            sh "docker push ${harbor_url}/${harbor_repository}/${current_project_name}:${image_version}"
        }
    }

    // 远程连接服务器拉取镜像运行
    stage('Pull image and Running container') {
        for(int i=0; i<selectedProjectNames.length; i++) {
            // 获取每个选项
            def project_info = selectedProjectNames[i]
            // 获取选项中的微服务名称
            def current_project_name = "${project_info}".split("@")[0]
            // 获取选项中的微服务所需端口
            def current_project_port = "${project_info}".split("@")[1]
            // 需要拉取的镜像
            def image_name = "${current_project_name}:${image_version}"
            // 遍历所有服务器，分别部署
            for(int j=0; j<selectedServices.length; j++) {
                // 获取当前服务器
                def current_server = selectedServices[j]
                // 加上参数配置，根据配置文件的不同选择不同的服务器部署
                if(current_server == "192.168.88.31") {
                    activeProfile = activeProfile+"serviceName-server1"
                }else if(current_server == "192.168.88.32") {
                    activeProfile = activeProfile+"serviceName-server2"
                }
                // 远程执行脚本
                sshPublisher(publishers: [sshPublisherDesc(configName: "${current_server}", transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: './root/test.sh $harbor_url $current_project_name $harbor_url/$harbor_repository/$image_name $current_project_port $activeProfile', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '', remoteDirectorySDF: false, removePrefix: '', sourceFiles: '')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
            }
        }
    }
}

6. 修改 test.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

#!/bin/bash

harbor_url=$1
project_name=$2
image_name=$3
service_port=$4
profile=$6

# 删除none容器
echo "docker rmi none..."
docker images | grep none | awk '{ print "docker rmi "$3 }' | sh &>/dev/null

# 检查是否有已运行容器
num=`docker ps | grep $project_name | wc -l`
if [ $num -gt 0 ]
then
    docker stop $project_name && docker rm $project_name &>/dev/null
    if [ `echo $?` -eq 0 ]
    then
        echo "docker stop $project_name && docker rm $project_name [OK]"
    else
        echo "ERROR: docker stop $project_name && docker rm $project_name"
    fi
fi

# 检查是否有重命名镜像
temp=`docker images | grep $image_name | awk '{ print $1":"$2 }' | wc -l`
if [ $temp -eq 1 ]
then
    docker rmi $image_name &>/dev/null
    if [ `echo $?` -eq 0 ]
    then
        echo "docker rmi $image_name [OK]"
    else
        echo "ERROR: docker rmi $image_name"
    fi
fi

# 登录镜像仓库
echo "docker login repository..."
docker login -u admin -p toortoor $harbor_url &>/dev/null
if [ `echo $?` -ne 0 ]
then
    echo "ERROR: failed to login repository"
else
    echo "docker login repository [OK]"
fi

# 拉取镜像
echo "docker pull image..."
docker pull $image_name &>/dev/null
if [ `echo $?` -ne 0 ]
then
    echo "ERROR: failed to pull image"
else
    echo "docker pull image [OK]"
fi

# 运行容器
echo "docker run container..."
docker run -d --name $project_name -p $service_port:8080 $image_name $profile &>/dev/null
if [ `echo $?` -ne 0 ]
then
    echo "ERROR: failed to run container"
else
    echo "docker run container [OK]"
fi

七、基于K8S的CICD

基于 Kubernetes 平台来实现 CICD 功能。

7.1 Jenkins对接K8S

• 首先通过 bitnami helm 部署 Jenkins（Master），需开放 jnlp 50000 端口

1
2
3
4
5
6
7

# 添加repo源
helm repo add bitnami https://charts.bitnami.com/bitnami
# 下载chart到本地
helm pull bitnami/jenkins
# 根据需求修改values.yaml
# 部署
helm install jenkins jeknins/

• RBAC 授权，SA 名为 jenkins，后续会用到

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

apiVersion: v1
kind: ServiceAccount
metadata:
  name: jenkins
  namespace: nextcloud

---

kind: Role
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: jenkins
  namespace: nextcloud
rules:
  - apiGroups: [""]
    resources: ["pods"]
    verbs: ["create","delete","get","list","patch","update","watch"]
  - apiGroups: [""]
    resources: ["pods/exec"]
    verbs: ["create","delete","get","list","patch","update","watch"]
  - apiGroups: [""]
    resources: ["pods/log"]
    verbs: ["get","list","watch"]
  - apiGroups: [""]
    resources: ["secrets"]
    verbs: ["get"]
  - apiGroups: ["extensions", "apps"]
    resources: ["deployments"]
    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
  - apiGroups: [""]
    resources: ["services"]
    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]

---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: RoleBinding
metadata:
  name: jenkins
  namespace: nextcloud
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: jenkins
subjects:
  - kind: ServiceAccount
    name: jenkins
    namespace: nextcloud

• 获取刚刚创建的 ca.crt 信息

1

kubectl get secret jenkins-token-xxx -oyaml | awk '/ca.crt/{ print $2 }' | base64 -d

• 在 Jenkins 创建凭据

• 添加云，这里用到刚刚创建的凭据

设置 Pod Template，即 Jenkins Slave，将包含 jnlp 一个容器，来实现编译打包等功能。

这里需挂载宿主机的 docker.sock、docker 和 kubectl 的二进制文件。

然后使用到刚刚创建的 SA。

测试链接。

7.2 构建前准备

需要在项目的根目录下准备好 Dockerfile、Jenkinsfile、deploy.yaml。

• Jenkinsfile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// gitlab及harbur凭据认证等信息
def git_auth = "764f29f3-8955-4551-a23a-659aa4c8deaa"
def git_url = "http://192.168.159.12:30098/root/nextcloud.git"
def harbor_url = "192.168.159.101"
def harbor_repository = "nextcloud"
def harbor_auth = "7ebc36f8-73a3-417f-864f-24856490b1a2"
def project_name = "nextcloud"

// jenkins-slave为pod template中的name
node('jenkins-slave') {
    
    // jnlp为pod template中的容器名称
    container('jnlp') {

        // pipeline步骤
        stage('Git Clone') {
            git branch: "${branch}", credentialsId: "${git_auth}", url: "${git_url}"
        }

        stage('Docker Build') {
            sh "docker build -t ${harbor_url}/${harbor_repository}/${project_name}:${branch}-${version} ."
        }

        stage('Docker Push') {
            withCredentials([usernamePassword(credentialsId: "${harbor_auth}", passwordVariable: 'harbor_password', usernameVariable: 'harbor_user')]) {
            sh "docker login -u ${harbor_user} -p ${harbor_password} ${harbor_url}"
            }
            sh "docker push ${harbor_url}/${harbor_repository}/${project_name}:${branch}-${version}"
            sh "docker rmi ${harbor_url}/${harbor_repository}/${project_name}:${branch}-${version}"
            }
        }

    	// 在deploy.yaml中将镜像tag设为了build-tag,方便通过sed修改
        stage('Sed YAML') {
            sh "sed -i 's#build-tag#${branch}-${version}#g' deploy.yaml"
        }

        stage('Deploy to K8s') {
            sh "kubectl apply -f deploy.yaml"
        }

}

7.3 创建流水线项目

这里添加了两个字符参数，用于构建前选择分支和 tag 的标签定义。

构建测试，会发现集群中创建了一个 jenkins-slave-xxx 的 pod，pod 中包含 jnlp 一个容器，通过观察日志可发现与 Jenkins Master 进行了连接。

Jenkins 中查看流水线进度。

流水线结束后，通过 kubectl 可看到项目已部署，且使用的镜像是刚刚构建好的。

一、简介

REmote DIctionary Server（Redis）是一个由 Salvatore Sanfilippo 写的 key-value 存储系统，是跨平台的非关系型数据库。

Redis 就是一款 NoSQL，而 NoSQL 就是指非关系型数据库，主要分为四种：

1. 键值型：Redis
2. 文档型：ElasticSearch、Mongdb
3. 面向列：Hbase
4. 图形化：Neo4j

二、Redis基础

2.1 Redis安装

1. 通过 docker-compose 安装 redis

1
2
3
4
5
6
7
8
9
10

version: '3.8'
services:
  redis:
    image: daocloud.io/library/redis:5.0.9
    restart: always
    container_name: redis
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 6379:6379

2. 进入容器内部测试 redis

1
2
3
4
5
6

# 连接redis
redis-cli
# set新建键值对
set key value
# get获取键值
get key

2.2 Redis常用命令

redis 的数据存储结构有以下几种：

• key-string（字符串）：一个 key 对应一个值
• key-hash（哈希）：一个 key 对应一个 map
• key-list（列表）：一个 key 对应一个列表
• key-set（集合）：一个 key 对应一个集合
• key-zset（有序集合）：一个 key 对应一个有序的集合

2.2.1 string常用命令

1. 设置值

1

set key value

2. 取值

1

get key

3. 批量操作

1
2

mset key1 value1 key2 value2 ...
mget key1 key2 ... 

4. 自增

1

incr key

5. 自减

1

decr key

6. 自增自减指定数量

1
2

incrby key number
decrby key number

7. 设置值的同时指定生存时间

1

setex key seconds value

8. 设置值，如果当前 key 不存在如同 set，如果存在则说明都不做

1

setex key value

9. 在 key 对应的 value 后追加内容

1

append key value

10. 查看 value 字符串长度

1

strlen key

2.2.2 hash常用命令

1. 存储数据

1

hset key field value

2. 获取数据

1

hget key field

3. 批量操作

1
2

hmset key1 field1 value1 field2 value2 ...
hmget key1 firle1 field2 ...

4. 指定自增

1

hincrby key field number

5. 设置值，如果当前 key 不存在如同 set，如果存在则说明都不做

1

hsetnx key field value

6. 检查 field 是否存在

1

hexists key field

7. 删除某个 field

1

hdel key field1 field2 ...

8. 获取当前 hash 结构中的全部 field 和 value

1

hgetall key

9. 获取当前 hash 结构中的全部 field

1

hkeys key

10. 获取当前 hash 结构中的全部 value

1

hvals key

11. 获取当前 hash 中 field 的数量

1

hlen key

2.2.3 list常用命令

1. 存储数据

1
2
3
4
5
6
7
8
9
10
11

# 从左侧插入数据
lpush key value1 value2 ...
# 从右侧插入数据
rpush key value1 value2 ...

# 如果key不存在，什么都不做，如果key存在但不是list结构，也什么都不做
lpushx key value1 value2 ...
rpushx key value1 value2 ...

# 通过索引位置添加value
lset key index value

2. 获取数据

1
2
3
4
5
6
7
8
9
10
11
12
13