zoukankan      html  css  js  c++  java

  • Drone 中的概念：webhooks、workspace、cloning、pipelines、services、plugins、deployments

    Drone 官方中文文档
    参考资料

    项目流程为：

    • git push 提交代码到版本控制系统（GitHub、GitLab、Gogs 等）
    • 版本控制系统通过 webhook 触发 Drone 的 pipeline
    • Drone 执行 pipeline，build 构建项目
    • 构建 Docker 镜像（需要 Dockerfile 文件）
    • 将镜像 push 到 registry（Harbor 等）

    在 Drone 的 .drone.yml 配置文件中，有以下几个常用的模块，每个模块定义了不同的功能。

    webhooks

    Drone 通过 OAuth 认证（GitHub、GitLab）或账号密码（Gogs）登录版本控制系统后，获得完整的控制权。在 Drone 的 web 页面激活仓库后，Drone 会自动将 webhooks 添加到对应的版本控制系统中。

    Webhooks 由版本控制系统发送，用于触发 pipeline。版本控制系统会在下面 3 种情况下，自动发送 webhook 请求到 Drone：

    • 代码被 push 到仓库
    • 新建一个合并请求（pull request）
    • 新建一个标签

    跳过提交

    可以通过添加 [CI SKIP] （大小写不敏感）到提交信息（commit message）中来让 Drone 跳过某个提交。

    git commit -m "updated README [CI SKIP]"

    包含/跳过分支 branches

    Drone 可以通过 branches 忽略某个分支上的提交。branches 支持单个变量、数组、通配符，还支持子选项 exclude（不包含分支）。

    • 跳过不是 master 分支的提交：
    pipeline:
  build:
    image: golang
    commands:
      - go build
      - go test

branches: master
    • 匹配多个目标分支的例子：
    pipeline:
  build:
    image: golang
    commands:
      - go build
      - go test

branches: [ master, develop ]
    • 批量匹配的例子：
    pipeline:
  build:
    image: golang
    commands:
      - go build
      - go test

branches: [ master, feature/* ]
    • 包含分支的例子：
    pipeline:
  build:
    image: golang
    commands:
      - go build
      - go test

branches:
  include: [ master, feature/* ]
    • 忽略分支的例子：
    pipeline:
  build:
    image: golang
    commands:
      - go build
      - go test

branches:
  exclude: [ develop, feature/* ]

    workspace

    workspace 定义了所有工作流步骤共享的容器空间和目录。各个阶段通过各个阶段共享 volume 和工作路径，避免了复制。默认的工作区的目录和仓库 URL 相匹配：

    /drone/src/github.com/octocat/hello-world

    可以使用 YAML 文件的 workspace 来自定义工作区：

    workspace:
   base: /go
   path: src/github.com/octocat/hello-world

pipeline:
  build:
    image: golang:latest
    commands:
      - go get
      - go test

    base 属性

    base 属性定义了所有工作流步骤共享的基础容器空间。基础容器空间保证了代码、依赖和编译的二进制文件能够在各步骤间持久化和共享。

    workspace:
  base: /go
  path: src/github.com/octocat/hello-world

pipeline:
  deps:
    image: golang:latest
    commands:
      - go get
      - go test
  build:
    image: node:latest
    commands:
      - go build

    上面的步骤将和下面的 docker 命令类似：

    docker volume create my-named-volume

docker run --volume=my-named-volume:/go golang:latest
docker run --volume=my-named-volume:/go node:latest

    path 属性

    path 属性定义了构建的工作目录。这是代码被克隆到的目录，也将是每一个构建步骤的默认工作目录。这个路径必须是基于 base 路径的相对路径。

    workspace:
  base: /go
  path: src/github.com/octocat/hello-world
    git clone https://github.com/octocat/hello-world /go/src/github.com/octocat/hello-world

    cloning

    可以在工作流中手动配置克隆步骤。如果没有定义具体的克隆步骤，Drone 会自动配置。

    clone:
   git:
     image: plugins/git

pipeline:
  build:
    image: golang
    commands:
      - go build
      - go test

    depth 修改克隆深度：

    clone:
  git:
    image: plugins/git
    depth: 50

    通过 image 指定克隆插件时，可以使用 plugins/ 下的预定义插件，也可以使用自定义插件：

    clone:
  git:
    image: octocat/custom-git-plugin

    pipelines

    pipelines 定义了工作流（或叫流水线），包含代码构建，代码测试和代码部署等一系列步骤。工作流根据各个步骤的定义位置按顺序执行。如果一个步骤返回了非 0 的退出代码，工作流将立即停止并返回一个错误状态。

    定义了两个工作流 frontend 和 backend：

    pipeline:
  backend:
    image: golang
    commands:
      - go build
      - go test
  frontend:
    image: node
    commands:
      - npm install
      - npm run test
      - npm run build

    构建步骤

    构建步骤是工作流在 Docker 容器中执行的命令。这些命令将工作区（workspace）作为工作路径。

    pipeline:
  backend:
    image: golang
    commands:
+     - go build
+     - go test

    上面的 commands 将会被转换成简单的 Shell 脚本，大致如下：

    #!/bin/sh
set -e

go build
go test

    上面的脚本在之后会被作为 Docker 的入口被执行，类似这样：

    docker run --entrypoint=build.sh golang

    请注意，只有构建步骤可以定义命令，不能使用插件（plugins）或者服务（services）来定义命令。

    并行执行 group

    Drone 支持在同一个示例上并行执行多个步骤。使用 group 属性来配置并行步骤，这将让工作流执行者（pipeline runner）并行执行指定的命令。

    并行执行配置示例：

    pipeline:
  backend:
+   group: build
    image: golang
    commands:
      - go build
      - go test
  frontend:
+   group: build
    image: node
    commands:
      - npm install
      - npm run test
      - npm run build
  publish:
    image: plugins/docker
    repo: octocat/hello-world

    在上面到例子中，frontend 和 backend 将并行执行。在这两组任务完成之前，publish 步骤将不会执行。

    条件执行 when

    Drone 可以有条件地执行步骤。下面的例子限制了使用 Slack 插件的 Git 分支：

    pipeline:
  slack:
    image: plugins/slack
    channel: dev
+   when:
+     branch: master

    故障执行 when + status

    Drone 使用容器退出代码来决定一个构建到成功或者失败。非 0 退出代码（Non-zero exit codes）使构建失败，同时立即退出当前工作流。

    有的时候需要在构建失败时，执行特定的工作流步骤。可以使用状态条件限制（status constraint）来修改构建失败时的默认行为和执行步骤。

    pipeline:
  slack:
    image: plugins/slack
    channel: dev
+   when:
+     status: [ success, failure ]

    services

    services 模块定义服务容器。下面的配置文件组建了数据库服务容器和缓存服务容器：

    pipeline:
  build:
    image: golang:latest
    commands:
      - go build
      - go test

services:
  my-db:
    image: mysql

  my-cache:
    image: redis

    服务容器可以使用 YAML 配置文件中定义的名称来访问。在上面的例子中， mysql 服务被指定为 my-db，可以使用 my-db:3306 来访问。

    配置

    服务容器可以通过环境变量来自定义用户名，密码以及端口。具体支持的环境变量需要参考每个服务的官方镜像文档。

    services:
  database:
    image: mysql
    environment:
      - MYSQL_DATABASE=test
      - MYSQL_ALLOW_EMPTY_PASSWORD=yes

    初始化

    服务容器需要一定时间来初始化，然后才能被访问。如果刚开始时无法连接到一个服务，可以先等几秒钟或者添加一个退让（backoff）的机制。

    pipeline:
  test:
    image: golang
    commands:
+     - sleep 15
     - go get
      - go test

services:
  database:
    image: mysql

    plugins

    插件是执行预定义任务的容器，它们在工作流中被配置为步骤（steps）。插件可以用来部署代码，发布构建结果，发送通知以及部署其他更多的功能。

    git 是 Drone 默认的插件，不需要配置。

    Docker 和 Slack 插件工作流示例：

    pipeline:
  build:
    image: golang
    commands:
      - go build
      - go test

  publish:
    image: plugins/docker
    repo: foo/bar
    tags: latest

  notify:
    image: plugins/slack
    channel: dev

    插件隔离

    插件在 Docker 容器中执行，它们与工作流中的其他步骤相互隔离。注意，插件挂载和共享当前工作区，因此它将可以访问对应源代码。

    插件市场

    插件被打包和发布为 Docker 容器，它们在概念上和软件库类似（比如 npm），可以被在社区中发布和共享。可以在 http://plugins.drone.io 找到一系列可用的插件。

    deployments

    可以触发 Drone 来部署项目。部署项目在工作流中的事件类型（event type）是 deployment。可以使用事件类型（event type）或者目标环境变量（target environment）来限制执行的步数。

    pipeline:
  build:
    image: golang
    commands:
      - go build
      - go test

  publish:
    image: plugins/docker
    registry: registry.heroku.com
    repo: registry.heroku.com/my-staging-app/web
    when:
+     event: deployment
+     environment: staging

  publish_to_prod:
    image: plugins/docker
    registry: registry.heroku.com
    repo: registry.heroku.com/my-production-app/web
    when:
+     event: deployment
+     environment: production

    上面的例子展示了如何设置工作流来只在特定的目标环境中部署项目，比如 production 生产环境。

    触发部署

    可以使用命令行从已有的构建结果中触发部署。这个行为与使用构建结果（promoting builds）的概念类似。

    drone deploy <repo> <build> <environment>

    在准生产环境（staging environment）中使用某一序号的构建结果。

    drone deploy octocat/hello-world 24 staging

    在生产环境（production environment）中使用某一序号的构建结果。

    drone deploy octocat/hello-world 24 production

    matrix builds 矩阵构建

    Drone 支持整合矩阵构建。Drone 为配置文件矩阵中的每个组合各执行一个独立的构建任务。矩阵构建允许您使用多个配置来构建和测试一个提交（commit）。

    矩阵定义示例：

    matrix:
  GO_VERSION:
    - 1.4
    - 1.3
  REDIS_VERSION:
    - 2.6
    - 2.8
    - 3.0

    只包含特定组合的矩阵示例：

    matrix:
  include:
    - GO_VERSION: 1.4
      REDIS_VERSION: 2.8
    - GO_VERSION: 1.5
      REDIS_VERSION: 2.8
    - GO_VERSION: 1.6
      REDIS_VERSION: 3.0

    变量插值

    矩阵变量可以使用 ${VARIABLE} 的语法来进行插值。

    pipeline:
  build:
    image: golang:${GO_VERSION}
    commands:
      - go get
      - go build
      - go test

services:
  database:
    image: ${DATABASE}

matrix:
  GO_VERSION:
    - 1.4
    - 1.3
  DATABASE:
    - mysql:5.5
    - mysql:6.5
    - mariadb:10.1

    插入矩阵变量后的 Yaml 文件示例：

    pipeline:
  build:
-   image: golang:${GO_VERSION}
+   image: golang:1.4
    commands:
      - go get
      - go build
      - go test
+   environment:
+     - GO_VERSION=1.4
+     - DATABASE=mysql:5.5

services:
  database:
-   image: ${DATABASE}
+   image: mysql:5.5

    示例

    基于 Docker 镜像标签（Docker image tag）的矩阵构建

    pipeline:
  build:
    image: golang:${TAG}
    commands:
      - go build
      - go test

matrix:
  TAG:
    - 1.7
    - 1.8
    - latest

    基于 Docker 镜像的矩阵构建

    pipeline:
  build:
    image: ${IMAGE}
    commands:
      - go build
      - go test

matrix:
  IMAGE:
    - golang:1.7
    - golang:1.8
    - golang:latest

    示例

    workspace:
  base: /go
  path: src/gogs.xxx.com/baa-cicd
pipeline:
  build:
    image: golang:latest
    commands:
      - go build -o baa-cicd
  publish:
    image: plugins/docker
    registry: registry.xxx.com
    repo: registry.xxx.com/test/baa-cicd
    tags: latest
    secrets: [ docker_username, docker_password ]
    insecure: true
  notify:
    image: plugins/slack
    webhook: https://hooks.slack.com/services/xxx/xxx/xxx
    channel: dev
    template: >
      {{#success build.status}}
        build {{build.number}} succeeded. Good job.
      {{else}}
        build {{build.number}} failed. Fix me please.
      {{/success}}

    上面示例中，pipeline 中的 build 部分执行项目的构建，publish 部分讲项目的 Docker 镜像发布到 registry，notify 部分发送 slack 消息。
  • 相关阅读:
    iOS获取系统时间
    iOS面试-assign与retain
    iOS-检测网络可连接性
    iOS-ASI异步下载图片
    iOS-NSString值为Unicode格式（字符串编码转换成中文编码）
    iOS-模态视图动画
    iOS-UIScrollView滚动视图（转）
    iOS-NSFileManager
    iOS-self.用法
    iOS-iphone网络编程总结
  • 原文地址：https://www.cnblogs.com/kika/p/10851597.html
Copyright © 2011-2022 走看看