Drone配合Gogs实现持续集成

最新推荐文章于 2023-10-09 09:07:26 发布

XP-Code

最新推荐文章于 2023-10-09 09:07:26 发布

阅读量1k

点赞数

分类专栏： K8s 文章标签： Drone Gogs

本文链接：https://blog.csdn.net/Wisimer/article/details/116203786

版权

K8s 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Gogs 是一个轻量级Git仓库。Drone是一款基于容器技术的持续集成工具，使用简单的YAML配置文件即可完成复杂的自动化构建、测试、部署任务。

1. 可以直接使用docker-compose安装启动

新建文件docker-compose.yml :

version: "3.8"

services:
  gogs:
    image: gogs/gogs
    container_name: my-gogs
    restart: always
    networks:
      dronenet:
        aliases:
          - gogs
    volumes:
      - /data1/mygogs:/data
    ports:
      - "10022:22"
      - "3000:3000"
  drone:
    image: drone/drone:1
    container_name: my-drone
    restart: always
    ports:
      - 10080:80
      - 10443:443
    networks:
      dronenet:
        aliases:
          - drone
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /data1/drone/:/var/lib/drone
    environment:
      - TZ=Asia/Shanghai
      - DRONE_DEBUG=true
      - DRONE_LOGS_TRACE=true
      - DRONE_LOGS_DEBUG=true
      - DRONE_LOGS_PRETTY=true
      - DRONE_GIT_ALWAYS_AUTH=false
      - DRONE_RPC_SECRET=${YOUR_SECRET}
      - DRONE_SERVER_HOST=${YOUR_IP}:10080
      - DRONE_SERVER_PROTO=http
      - DRONE_GOGS_SERVER=http://${YOUR_IP}:3000
      - DRONE_USER_CREATE=username:${GOGS_ROOT},admin:true
  drone-sshrunner:
    image: drone/drone-runner-ssh
    container_name: my-drone-sshrunner
    restart: always
    ports:
      - 10081:3000
    depends_on:
      - drone
    networks:
      dronenet:
        aliases:
          - drone-sshrunner
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - TZ=Asia/Shanghai
      - DRONE_DEBUG=true
      - DRONE_RPC_SECRET=${YOUR_SECRET}
      - DRONE_RPC_HOST=${YOUR_IP}:10080
      - DRONE_RPC_PROTO=http
      - DRONE_RUNNER_CAPACITY=2
      - DRONE_RUNNER_NAME=drone-sshrunner
  drone-runner:
    image: drone/drone-runner-docker:1
    container_name: my-drone-runner
    restart: always
    ports:
      - 10082:3000
    depends_on:
      - drone
    networks:
      dronenet:
        aliases:
          - drone-runner
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - TZ=Asia/Shanghai
      - DRONE_DEBUG=true
      - DRONE_RPC_SECRET=${YOUR_SECRET}
      - DRONE_RPC_HOST=${YOUR_IP}:10080
      - DRONE_RPC_PROTO=http
      - DRONE_RUNNER_CAPACITY=2
      - DRONE_RUNNER_NAME=drone-runner
networks:
  dronenet:
    external: true # 使用外部网络, 需先创建网络

注意修改这几个参数：

YOUR_IP：自己的IP
YOUR_SECRET：自定义密码
GOGS_ROOT：GOGS_ROOT的root用户名

2. 初始化Gogs

（1）启动之后访问：http://YOUR_IP:3000/install，执行初始化配置。
init
（2）注意这几个配置要配置正确：
config
（3）安装完成进入主页面（明显感觉比gitlab快很多）：
home

3. 访问Drone

控制台页面：http://YOUR_IP:10080

账户密码就是Gogs中创建的用户名和密码。

drone
这个时候就可以看到Gogs中创建的仓库了。

点进去，点击ACTIVATE REPOSITORY这个按钮配置一下：
config
主要这个Trusted一定要勾选：
config
点击SAVE保存成功后会在Gogs中自动配置一个Web钩子，当我们推送代码到Gogs中去时，会触发这个钩子，然后执行在Drone中的流水线任务，看一下Gogs那边仓库里的Webhooks：
hoos

点进去，默认配置不用改，执行一下Test Delivery，绿勾表示成功：
test

4. 使用Drone进行自动打包发布

当我们向Git仓库Push代码时，会自动触发Web钩子，然后Drone就会从Git仓库Clone代码，再通过项目根目录下的.drone.yml配置，执行相应的流水线，接下来我们来看看这个脚本是如何写的。

直接看一个最简单的打印文字的.drone.yml的例子：

kind: pipeline
type: docker
name: default

steps:
- name: greeting
  image: alpine
  commands:
  - echo hello
  - echo world

提交到仓库之后，会通过webhook触发Drone执行任务：
clone
greeting

5. 实战

针对SpringBoot应用来说，我们要做的就是编写.drone.yml，然后执行任务：

打包jar
生成Docker镜像
启动对应容器
拷贝jar到容器
运行jar

Step1. 为SpringBoot应用创建Docker镜像

（1）首先就是自己将项目打包成一个jar包。

（2）然后在项目根目录创建Dcokerfile文件：

# 该镜像需要依赖的基础镜像
FROM java:8
# 将当前目录下的jar包复制到docker容器的/目录下
ADD ./PPBill-0.0.1-SNAPSHOT.jar /PPBill-0.0.1-SNAPSHOT.jar
# 运行过程中创建一个mall-tiny-docker-file.jar文件
RUN bash -c 'touch /PPBill.jar'
# 声明服务运行在8080端口
EXPOSE 8080
# 指定docker容器启动时运行jar包
ENTRYPOINT ["java", "-jar","/PPBill-0.0.1-SNAPSHOT.jar"]
# 指定维护者的名字
MAINTAINER wangxianpeng

然后本地测试一下打包镜像操作：

docker build -t wisimer/ppbill:0.0.1 .

打包完成后直接运行的时候连接不上mysql会报错，是因为项目中的application.yml文件中mysql地址是localhost，所以需要修改application.yml，将localhost改为db，docker容器之间可以通过指定好的服务名称db进行访问，至于db这个名称可以在运行容器的时候指定。

启动Mysql：

docker run -p 3306:3306 --name mysql \
-v /mydata/mysql/log:/var/log/mysql \
-v /mydata/mysql/data:/var/lib/mysql \
-v /mydata/mysql/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=${YOUR_SECRET}   \
-d mysql:5.7

初始化数据库：

# 进入运行mysql的docker容器：
docker exec -it mysql /bin/bash
# 进入mysql命令交互器
mysql -uroot -p${YOUR_SECRET} --default-character-set=utf8
# 修改root权限
mysql> grant all privileges on *.* to 'root'@'%'
# 创建数据库
mysql> create database billcheck character set utf8

再重新启动一个容器，正常不报错了：

docker run -p 8080:8080 --name ppbill --link mysql:db -d wisimer/ppbill:0.0.2

注意这里的--link mysql:db，mysql是刚刚启动的MySQL容器的名称，db就是上面项目中application.yml中配置的mysql地址。

Step2. 自动打包运行应用

上面打包和运行的步骤是手动分开执行的，现在要把它们放在一个脚本里，执行这个脚本会完成所有操作。

创建一个run-bill.sh文件：

#!/usr/bin/env bash
# 定义应用组名
group_name='wisimer'
# 定义应用名称
app_name='ppbill'
# 定义应用版本
app_version='0.0.1'
# 定义应用环境
profile_active='qa'
echo '----copy jar----'
docker stop ${app_name}
echo '----stop container----'
docker rm ${app_name}
echo '----rm container----'
docker rmi ${group_name}/${app_name}:${app_version}
echo '----rm image----'
# 打包编译docker镜像
docker build -t ${group_name}/${app_name}:${app_version} .
echo '----build image----'
# mac下/etc/localtime不能映射
docker run -p 8080:8080 --name ${app_name} \
--link mysql:db \
-e 'spring.profiles.active'=${profile_active} \
-e TZ="Asia/Shanghai" \
-v /etc/localtime:/etc/localtime \
-v /tmp/app/${app_name}/logs:/var/logs \
-d ${group_name}/${app_name}:${app_version}
echo '----start container----'

所以直接运行这个脚本就会执行打包和运行操作：

sh run-bill.sh

Step3. 编写.drone.xml脚本

kind: pipeline # 定义对象类型，还有secret和signature两种类型
type: docker # 定义流水线类型，还有kubernetes、exec、ssh等类型
name: ppbill-drone # 定义流水线名称

steps: # 定义流水线执行步骤，这些步骤将顺序执行
  - name: package # 流水线名称
    image: maven:3-jdk-8 # 定义创建容器的Docker镜像
    volumes: # 将容器内目录挂载到宿主机，仓库需要开启Trusted设置
      - name: maven-cache
        path: /root/.m2 # 将maven下载依赖的目录挂载出来，防止重复下载
      - name: maven-build
        path: /mydata/maven/build # 将应用打包好的Jar和执行脚本挂载出来
    commands: # 定义在Docker容器中执行的shell命令
      - mvn clean package # 应用打包命令
      - cp target/PPBill-0.0.1-SNAPSHOT.jar /mydata/maven/build/PPBill-0.0.1-SNAPSHOT.jar #从容器内部拷贝到宿主机
      - cp Dockerfile /mydata/maven/build/Dockerfile
      - cp run-bill.sh /mydata/maven/build/run-bill.sh

  - name: build-start
    image: appleboy/drone-ssh # SSH工具镜像
    settings:
      host: 42.193.145.252 # 远程连接地址，这里其实是从drone的容器内部发送文件到宿主机
      username: lighthouse # 远程连接账号
      password:
        from_secret: ssh_password # 从Secret中读取SSH密码
      port: 22 # 远程连接端口
      command_timeout: 5m # 远程执行命令超时时间
      script:
        - cd /mydata/maven/build # 进入宿主机构建目录
        # - chmod +x run-bill.sh # 更改为可执行脚本
        - sh run-bill.sh # 运行脚本打包应用镜像并运行

volumes: # 定义流水线挂载目录，用于共享数据
  - name: maven-build
    host:
      path: /mydata/maven/build # 从宿主机中挂载的目录
  - name: maven-cache
    host:
      path: /mydata/maven/cache

# drone执行触发器
trigger:
  branch:
    - release

然后，每次向release分支提交代码都会触发Drone的操作：
drone

参考

THE END.

XP-Code

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
Drone配合Gogs实现持续集成

Gogs 是一个轻量级Git仓库。Drone是一款基于容器技术的持续集成工具，使用简单的YAML配置文件即可完成复杂的自动化构建、测试、部署任务。1. 可以直接使用docker-compose安装启动新建文件docker-compose.yml :version: "3.8"services: gogs: image: gogs/gogs container_name: my-gogs restart: always networks: dronen
复制链接

扫一扫