最佳实践 - Huawei...WebUtil项目：WebServer依赖的自研工具包，在WebServer项目pom文件中引入，主要为演示私有依赖库使用场景。基础镜像：以此镜像为基础，在基础镜像中添加WebServer构建包制作Docker镜

编译构建

佳实践

文档版本 17

发布日期 2020-05-30

华为技术有限公司

版权所有 © 华为技术有限公司 2020。保留一切权利。

非经本公司书面许可，任何单位和个人不得擅自摘抄、复制本文档内容的部分或全部，并不得以任何形式传播。商标声明

和其他华为商标均为华为技术有限公司的商标。本文档提及的其他所有商标或注册商标，由各自的所有人拥有。注意

您购买的产品、服务或特性等应受华为公司商业合同和条款的约束，本文档中描述的全部或部分产品、服务或特性可能不在您的购买或使用范围之内。除非合同另有约定，华为公司对本文档内容不做任何明示或默示的声明或保证。

由于产品版本升级或其他原因，本文档内容会不定期进行更新。除非另有约定，本文档仅作为使用指导，本文档中的所有陈述、信息和建议不构成任何明示或暗示的担保。

文档版本 17 (2020-05-30) 版权所有 © 华为技术有限公司 i

目录

1 ARM 交叉编译............................................................................................................................ 1

2 使用 Maven 构建包制作 Docker 镜像...................................................................................12

3 使用 Ant 构建包制作 Docker 镜像.........................................................................................25

4 使用 Node.js 构建包制作 Docker 镜像..................................................................................31

5 基于 Python 项目制作 Docker 镜像...................................................................................... 38

6 基于 PHP 项目制作 Docker 镜像............................................................................................42

7 基于 Go 项目制作 Docker 镜像.............................................................................................. 52

8 使用自定义 Dockerfile 制作 Docker 镜像............................................................................ 60

9 跨租户推送镜像到 SWR.......................................................................................................... 67

10 使用 Cmake 编译 C 语言程序............................................................................................... 71

11 使用 msbuild 编译 C#语言程序........................................................................................... 77

12 使用 Android 构建生成 APK 并签名....................................................................................83

13 使用快应用组件编译生成 RPK 并签名................................................................................. 89

14 使用 Ionic 构建生成 Android 应用...................................................................................... 92

15 使用 PyInstaller 构建 Python 可执行程序......................................................................... 99

16 使用 Gradle 构建 jar 包...................................................................................................... 102

17 基于 mono 完成 msbuild 和 dotnet 编译的应用............................................................ 11117.1 前提条件.............................................................................................................................................................................. 11117.2 基于 mono 完成 msbuild 项目构建............................................................................................................................ 11117.3 基于 mono 完成 dotnet 项目构建............................................................................................................................... 11817.4 Dotnet 编译结果制作 Docker 镜像.............................................................................................................................123

18 Maven 多模块构建..............................................................................................................126

编译构建佳实践目录

文档版本 17 (2020-05-30) 版权所有 © 华为技术有限公司 ii

1 ARM 交叉编译

前提条件

参照前提准备创建项目。

准备 Dockerfile

步骤1 进入代码托管服务，创建代码仓库，本例仓库名为“arm-cross-build”，单击代码仓库的“克隆/下载”，完成仓库的SSH地址复制。

步骤2 打开git bash客户端，完成代码下载。git clone [email protected]:jcby00001/arm-cross-build.git

步骤3 在本地“arm-cross-build”目录下新建Dockerfile文件，输入以下内容：FROM centos:7USER rootRUN curl http://xxx.xxx.xxx.xxx/arm9net/mini2440/linux/arm-linux-gcc-4.4.3-20100728.tar.gz -o /usr/local/arm \&& cd /usr/local \&& tar -zxvf arm \&& yum -y install gcc automake autoconf libtool make \

编译构建佳实践 1 ARM 交叉编译

文档版本 17 (2020-05-30) 版权所有 © 华为技术有限公司 1

https://support.huaweicloud.com/qs-codeci/codeci_qs_1000.html#section0

&& yum -y install glibc.i686 \&& yum -y install ncurses-devel.i686 \&& yum -y install binutils-devel.i686 \&& yum -y install gcc-c++.x86_64 \&& curl http://mirror.centos.org/centos/7/os/x86_64/Packages/zlib-1.2.7-18.el7.i686.rpm -o zlib-1.2.7-18.el7.i686.rpm \&& rpm -ivh zlib-1.2.7-18.el7.i686.rpm \&& yum clean allENV ARM_HOME=/usr/local/opt/FriendlyARM/toolschain/4.4.3ENV PATH=$ARM_HOME/bin:$PATHRUN echo "ARM_HOME=/usr/local/arm\nPATH=$ARM_HOME/bin:$PATH" >> /etc/profile

说明

● 1 部分基于官方的CentOS7为基础镜像制作arm交叉编译镜像。

● 2 部分安装ARM交叉编译所需的软件和依赖工具。

● 3 部分设定交叉编译环境变量。

● 第三行，需要替换成自己的GCC下载地址。

步骤4 上传Dockerfile到代码仓库。

完成代码上传到软件仓库，依次执行如下命令：

git add -Agit commit –m "add Dockerfile for arm cross compiler"git push origin master



步骤5 回到代码托管服务，检查该次提交是否生效。

----结束

制作交叉编译镜像

步骤1 进入SWR容器镜像服务。

步骤2 单击页面左侧“组织管理”，在页面中单击“创建组织”按钮。

步骤3 输入组织名称“test2018”，单击“确定”按钮，完成容器组织的创建。

步骤4 创建编译任务。

1. 进入“构建&发布 > 编译构建”页面，单击“新建任务”。

– 在“基本信息”页面，任务名称填写“arm-cross-build-docker”，归属项目默认为当前项目。



https://console.huaweicloud.com/swr/

– 在“选择代码源”页面，源码源选择“DevCloud”，源码仓库选择“arm-cross-build”，分支选择“master”。

– “选择构建模板”步骤中，单击“不使用模板，直接创建”。

2. 进入“构建步骤”页面，输入并搜索“swr”，选择步骤“制作镜像并推送到SWR仓库”，单击“添加”。

依次填写组织、镜像名字、镜像标签，单击“新建”。



步骤5 单击页面右上角“执行”，开始进行镜像制作。

构建完成后，可以看到构建成功的镜像坐标为“swr.cn-north-1.myhuaweicloud.com/crosscompiler/armcross:arm-linux-gcc-4.4.3”。

步骤6 设置镜像权限为“公开”。

1. 回到SWR页面，进入创建的组织“test2018”，显示镜像已经推送成功。

2. 单击右上角“编辑”按钮，当前镜像状态为“私有”。

选择“公开”，单击“确定”按钮完成设置。



----结束

交叉编译

步骤1 上传源代码（仅演示用，非正式项目）。

1. 在本地“arm-cross-build”目录下中创建hello.c文件，写入以下内容并保存。#include <stdio.h>int main(){ printf("hello,world!\n"); return 0;}

2. 推送至代码仓库。git add –f hello.cgit commit –m “add hello.c for arm cross compiler”git push origin master



3. 进入代码仓库页面，查看提交代码与自己编写的是否一致。

步骤2 创建交叉编译源码项目。

1. 进入“构建&发布 > 编译构建”页面，单击“新建任务”按钮。

2. “基本信息”步骤中，填写任务名称“arm-cross-build-hello”，单击“下一步”按钮。

“选择代码源”步骤中，源码源选中“DevCloud”，源码仓库选择“arm-cross-build”，分支选择“master”。

“选择构建模板”步骤中，单击“不使用模板，直接创建”。

3. 搜索“swr”，添加步骤“使用SWR公共镜像”。



4. 输入镜像地址“swr.cn-north-1.myhuaweicloud.com/crosscompiler/

armcross:arm-linux-gcc-4.4.3”。

在命令框中填写完成交叉编译“hello.c”的指令：arm-linux-gcc hello.c -ohello

5. 单击“使用SWR公共镜像”下方的。

输入并搜索“上传”，添加步骤“ 上传软件包到发布仓库”。

6. 填写构建包路径为“./hello”，指的是编译后生成的文件路径。

填写发布版本号和包名，单击“新建”按钮完成任务创建。



步骤3 单击页面右上角“执行”按钮，开始进行交叉编译。

待构建执行成功后，单击右上角“下载构建包”，下载构建结果。

----结束

异常处理● 执行交叉编译报错: only accept X-Auth-Token or Authorization

– 问题现象

构建报错信息如下：

– 原因分析

报错原因为自定义的docker镜像没有设置权限为公开



– 处理方法

将镜像设置为将镜像设置为“公开”，操作步骤参见制作交叉编译镜像-步骤6。

● 执行交叉编译报错：DEV.CB.0220021, The archived files were not found.

Maybe archive file path is incorrect: hello– 问题现象

构建报错信息如下：

– 原因分析

报错原因为指定的归档包路径配置错误。

– 处理方法

查看构建任务，确定归档文件输出路径准确，并配置对应的归档路径。

如下归档文件输出为当前目录下的hello。

归档包路径要与输出路径一致。

● 历史编译归档包如何下载？

– 当前版本的构建包可以在构建页面单击“下载构建包”下载。



– 历史版本的构建包，可以单击页面上方的“构建&发布 > 发布”，进入到发

布页面下载。

● 如何进行mips平台交叉编译docker镜像制作？

Dockerfile可以参照如下内容：FROM ubuntu:18.04USER rootRUN apt-get -y update \&& apt-get install -y emdebian-archive-keyring \&& apt-get install -y linux-libc-dev-mips-cross libc6-mips-cross libc6-dev-mips-cross binutils-mips-linux-gnu gcc-mips-linux-gnu g++-mips-linux-gnu \&& mips-linux-gnu-gcc -dumpmachine



2 使用 Maven 构建包制作 Docker 镜像

背景

为方便使用，DevCloud编译构建服务提供了大量构建步骤、模板等，并通过缓存、私有依赖库、开源镜像站等实现开箱即用编译构建体验；但由于构建场景多样化，初次使用编译构建服务时，仍有可能会因设计不当或理解偏差、使用方式不当，导致上手过程存在一定困难。因此，编译构建针对常见的复杂构建场景提供完整的佳实践方案，供初次使用DevCloud编译构建服务或需要尝试复杂构建场景的用户使用。

目标

本文旨在演示如何使用DevCloud编译构建服务完成Maven构建，使用构建包制作Docker镜像并推送到SWR仓库，同时对构建过程涉及的开源镜像站、私有依赖库、缓存的使用等作简要说明。

SWR，即容器镜像服务。SWR镜像仓库用于存储用户上传的Docker镜像，可以在构建、部署时或其他场景使用。

项目说明

本文演示项目涉及两个Maven工程、一个基础Docker镜像及一个Dockerfile。

● WebServer项目：此次构建主项目，期望使用DevCloud构建此项目，并使用得到的构建包制作Docker镜像，制作镜像所用Dockerfile存放于此项目根目录。

● WebUtil项目：WebServer依赖的自研工具包，在WebServer项目pom文件中引入，主要为演示私有依赖库使用场景。

● 基础镜像：以此镜像为基础，在基础镜像中添加WebServer构建包制作Docker镜像。

● Dockerfile：用来制作镜像。

项目构建过程如下：

编译构建佳实践 2 使用 Maven 构建包制作 Docker 镜像


https://support.huaweicloud.com/productdesc-swr/swr_03_0001.html

本文详细描述了从准备代码仓库到构建并制作镜像、推送镜像到SWR仓库的完整过程。大致分为以下步骤，可根据熟悉程度选择阅读：

● 构建准备

● 上传/发布私有依赖

● 打包并制作、推送镜像

● 查看构建结果

构建准备

如果是初次使用DevCloud，请确认已完成准备操作，然后开始本示例。

步骤1 准备WebUtil项目代码仓库

进入代码托管服务，新建空白仓库WebUtil，并将WebUtil项目代码提交到此仓库。

步骤2 准备WebServer项目代码

1. 新建空白仓库WebServer，并将WebServer项目代码提交到此仓库。

2. 编写Dockerfile。

– 准备基础镜像，可使用DockerHub或SWR仓库中公开镜像，本例中使用CentOS作为基础镜像。

– 获取构建包路径。

Maven构建包名格式为artifactId-version.packaging，构建包默认生成于“./target”目录下。

查看WebServer项目pom.xml中坐标定义。若坐标如下图所示，则终构建包路径为：./target/server-1.0.jar。




3. 使用获取的构建包路径编写Dockerfile。FROM centos MAINTAINER <[email protected]> USER root RUN mkdir /demo COPY ./target/server-1.0.jar /demo/app.jar

4. 上传Dockerfile到WebServer项目根目录。

步骤3 准备SWR镜像仓库

前往容器镜像服务，请参考容器镜像服务用户指南准备SWR仓库。

步骤4 创建组织

在DevCloud编译构建服务添加步骤“制作镜像并推送到SWR仓库”步骤时，需要指定SWR组织名，参考创建组织。

----结束




https://support.huaweicloud.com/usermanual-swr/swr_01_0009.html


上传/发布私有依赖

本节说明如何将所需私有依赖上传/发布到私有私有依赖库，使用DevCloud构建前请务必仔细阅读以下注意事项，以避免因依赖使用不当导致后续的构建异常。

须知

私有依赖库与软件发布库属于两个概念，要注意区分：

1. 软件发布库主要用于归档用以部署或其他用途的软件包。

2. 私有依赖库主要用于存储供其他项目使用的工具包等，如WebUtil.jar。

3. 使用时要务必注意区分，避免出现如“将依赖上传到软件发布库但是构建时无法下载”此类场景。

此例中假设WebServer使用了三种私有依赖：

● WebUtil：项目组自研公共组件，此时使用构建任务发布私有依赖。

● CommonUtil：合作伙伴提供，有jar包，有pom文件（CommonUtil项目pom文件，不可使用WebServer项目的），此时可使用POM模式手工上传。

● MessageSDK：三方消息推送平台提供，只有Jar包，无POM文件，此时需要考虑可否通过其他途径获取POM文件，或者能否直接使用GAV模式上传。

步骤1 初始化私有依赖库

新用户首次使用软件开发云服务时，需要前往私有依赖库首页初始化私有依赖库，详情可参考文档创建私有依赖库。

步骤2 发布自研工具包WebUtil

对于自行研发的工具包（需要以一定频率编译发布依赖包），推荐使用DevCloud编译构建服务提供的“发布Maven私有包”功能构建并发布私有包到私有依赖库。强烈建议尽可能使用此方式发布依赖，此方式具备以下优势：

● 工具包版本迭代时，可以一键发布，避免版本迭代带来的重复的手工上传依赖动作。

● 可结合构建任务、流水线的定时构建、合并代码触发等功能实现自动化持续集成。

● 使用构建任务发布的内容由maven自动生成，可有效避免人为造成的文件缺失、损坏，保证上传依赖的完整性、有效性。

任务配置步骤如下：

1. 新建构建任务，任务名称为“发布WebUtil到私有依赖库”。

源码源选择“DevCloud”，源码仓库选择“WebUtil”。

构建模板选择“发布maven私有包”。



https://support.huaweicloud.com/usermanual-releaseman/cloudrelease_01_1001.html

模板“发布maven私有包”预置了步骤“配置maven私有仓库”、“Maven构建”，以及默认的mvn deploy命令。多数场景下，直接使用即可完成构建并将生成的依赖包发布到DevCloud私有依赖仓库。

2. 配置步骤“配置maven私有仓库”：此步骤无需任何参数，在步骤中添加即可直

接使用。

说明

步骤“配置maven私有仓库”作用是为“发布maven私有包（mvn deploy）”命令指定私有仓库地址，如构建过程只需要从私有依赖库下载依赖，无需添加此步骤。

3. 配置步骤“Maven构建”。

检查构建命令：模板“发布maven私有包”已给出默认参数配置，此处只需确认参数正确即可。

– 默认命令要从根目录读取pom文件，本例中WebUtil项目pom文件在根目录，无需调整。

– WebUtil项目要求使用jdk1.8编译、运行，确认工具版本选择maven-3.5.3-jdk1.8无误。

– 本次构建目标为发布私有包，默认命令为mvn deploy，无需调整。

说明

mvn deploy命令作用为将项目打包，并发布到指定的依赖仓库；可供其他项目直接引用。

必要时（无需发布到私有仓库或私有仓库故障）也可选择使用mvn install，将项目打包并install到构建缓存，同样可以供其他项目直接引用（构建时需要使用缓存，缓存内容不保证数据持久性，如丢失需重新构建）

默认命令参数说明可参考Maven构建默命令含义。

检查缓存配置：

– DevCloud编译构建服务提供了构建缓存加速功能，可通过缓存配置选择是否使用缓存。

– 由于网络抖动、并发构建或其他极端情况，可能出现缓存内容异常导致构建异常，此时需要参考缓存清理步骤清理缓存。

4. 保存任务，执行成功后可于私有依赖库查看上传的依赖。



https://devcloud.huaweicloud.com/releaseman/repository/maven

步骤3 使用POM模式手工上传依赖包CommonUtil

部分情况下，项目中使用的依赖是以SystemPath方式引入，或者拿到三方提供的jar包手工上传到企业自建的私有依赖库中（如本例中CommonUtil包），该类依赖无法从公开仓库下载，且不适合使用DevCloud构建任务发布；此时需要在私有依赖库手工上传，上传时优先使用POM模式，步骤如下：

1. 进入私有依赖库首页，根据要上传的依赖包类型选择仓库类型。

2. 获取POM文件。

– 方式一：从原始仓库下载pom

部分依赖可能来自于DevCloud无法访问的三方仓库，用户自己可以从仓库下载，此类场景下Maven仓库一般会同时提供jar包和pom文件，用户直接从原仓库下载POM文件即可。

– 方式二：从jar包中获取pom文件

因为各种原因，部分依赖可能只能找到jar包，原始仓库、源码、pom文件等都无法找到，此时可以参考以下步骤尝试获取POM文件（以WebUtil包为例）：

i. 解压util-1.0.0.jar，如无法解压先更改后缀为支持的压缩包格式。

ii. 进入解压所得目录，打开“META-INF/maven/{groupid}/{artifactid}/目录”，此处为“META-INF/maven/com.huawei.demo.web/util”，打开该pom文件，确认无误则可直接使用。



iii. 如果确认无法找到POM文件，则需要考虑是否可以使用GAV模式上传。

3. 单击“上传”按钮，选择“POM模式”，选择POM文件和jar文件上传即可。

以WebUtil为例，手工上传需要注意：

此处是WebServer项目依赖WebUtil项目，上传WebUtil项目时，必须使用WebUtil项目的pom文件，如果误操作上传了WebServer项目的POM文件与WebUtil项目jar包，会导致上传依赖坐标与预期不一致，导致依赖下载失败。

步骤4 使用GAV模式上传三方依赖MessageSDK

优先考虑了使用POM模式手工上传依赖后，若始终无法找到POM文件，则需要考虑使用GAV模式上传；但此方式存在一定隐患，使用前需要注意评估。

须知

可以使用GAV模式的场景及风险说明：

1. 使用GAV模式上传时，私有仓库会根据输入的坐标信息自动生成POM文件，文件内容只包含依赖自身坐标定义。

2. 以WebUtil为例，如果WebUtil项目本身依赖了工具包lib.jar，使用GAV模式上传WebUtil后，会导致终WebServer构建无法下载lib.jar，导致构建包与预期不符。

3. 反之，若WebUtil项目本身无任何依赖（pom文件的节点为空），则可以使用此模式上传。

如您已认真阅读以上风险说明，确保上传依赖无上述隐患或接受该风险，可按如下步骤操作：

1. 进入私有依赖库首页，根据要上传的依赖包类型选择仓库类型。

2. 单击上传，选择“GAV模式”，根据提示编辑坐标信息，选择jar文件，上传即可。

----结束



打包并制作、推送镜像

步骤1 新建构建任务“使用WebServer制作Docker镜像”。

源码源选择“DevCloud”，源码仓库选择“WebServer”。

构建模板选择“Maven”。

模板“Maven”预置了步骤“Maven构建”、“上传软件包到软件发布库”，以及配套的默认构建命令。多数场景下，直接使用即可完成构建并将生成的软件包上传到软件发布库，本例需要删除“上传软件包到软件发布库”步骤。

步骤2 删除步骤“上传软件包到软件发布库”。

如需要归档软件包到发布库，可选择保留，构建包路径与准备WebServer项目代码中描述的一致，一般已自动生成。

步骤3 配置步骤“Maven构建”，确认构建命令、缓存配置无误。

检查构建命令：模板“Maven”已给出默认参数配置，此处只需确认参数正确即可。

● 默认命令要从根目录读取pom文件，本例中WebServer项目pom文件在根目录，无需调整。

● WebServer项目要求使用jdk1.8编译、运行，确认工具版本选择maven-3.5.3-jdk1.8无误。

● 本次构建目标为打包，默认命令为mvn package，无需调整；默认参数说明可参考Maven构建默认命令含义。

检查缓存配置：

● DevCloud编译构建服务提供了构建缓存加速功能，用户可通过缓存配置选择是否使用缓存。

● 由于网络抖动、并发构建或其他极端情况，可能出现缓存内容异常导致构建异常，此时需要参考缓存清理步骤清理缓存。

步骤4 在步骤“Maven构建”之前添加步骤“配置Maven华为开源镜像站”。

DevCloud编译构建任务会自动配置私有依赖库和开源镜像站，开源镜像站已代理或同步的镜像源有：

● Maven2： https://repo1.maven.org/maven2/

● Google： https://maven.google.com/

● Jboss： https://repository.jboss.org/nexus/content/repositories/releases/

● Jcenter： https://jcenter.bintray.com/



https://repo1.maven.org/maven2/

https://maven.google.com/

https://repository.jboss.org/nexus/content/repositories/releases/

https://jcenter.bintray.com/

● Grails-core： https://repo.grails.org/grails/core/

● Grails-plugins： https://repo.grails.org/grails/plugins/

● Spring-release： https://repo.spring.io/libs-release/

● Spring-plugins：https://repo.spring.io/plugins-release/

换言之，如果您使用的依赖皆可在以上仓库和私有依赖库找到，在使用DevCloud编译构建服务时可自动下载，无需任何额外配置，请直接跳转到步骤8

步骤5 配置步骤“配置Maven华为开源镜像站”。

本例中假设WebServer引用了来自三方仓库“https://test.repo.com/”的依赖lib.jar，配置如下：

须知

要在DevCloud构建使用此类仓库，该仓库必须满足以下条件：

1. 仓库地址在公网（大陆）可直接访问。

2. 依赖下载无需身份认证信息。

步骤6 在步骤“Maven构建”之后添加步骤“制作镜像并推送到SWR仓库”。



https://repo.grails.org/grails/core/

https://repo.grails.org/grails/plugins/

https://repo.spring.io/libs-release/

https://repo.spring.io/plugins-release/

步骤7 配置步骤“制作镜像并推送到SWR仓库”，录入所需镜像信息。

● 仓库地址取默认值即可。

● 组织已于章节创建组织中说明。

● 镜像名称自定义，注意需要符合SWR对镜像名格式要求，此处为webserver。● 镜像标签自定义，注意需要符合SWR对镜像名格式要求，此处为v1.1。

● 工作目录取默认当前目录即可。

● Dockerfile路径：准备好的Dockerfile已存放于WebServer项目根目录。当前构建目录即为项目根目录，默认值“./Dockerfile”无需更改。

步骤8 保存任务并执行，终任务详情页如下：

----结束

查看构建结果

步骤1 进入SWR镜像仓库首页，选择对应region，




步骤2 单击“我的镜像”，选择“制作镜像并推送到SWR仓库”步骤中填写的组织，即可查看上传的镜像。

----结束

疑问解答● 什么是构建缓存，缓存异常时怎么清理？

DevCloud编译构建服务提供了构建缓存功能，构建时可将依赖缓存于用户私有存储空间，下次构建时直接使用，无需重复下载，可极大提高构建效率。

– 构建缓存配置

新建编译构建任务时，默认选择使用缓存加速构建，用户可于步骤“Maven构建” -->“高级设置”中选择是否使用缓存。

– 清理缓存

由于网络抖动、并发构建或其他极端情况，可能出现缓存内容异常导致构建异常，下面介绍异常缓存的清理过程。



须知

执行缓存清理操作前，请务必仔细阅读以下“缓存清理风险以及注意事项”：

1. 由于缓存目录为同租户共享，频繁清理缓存会概率性导致同租户用户构建异常（常表现为xxx文件不存在），故此操作只可在缓存异常时清理一次，正常后需要务必再次编辑任务，删除清理命令。

2. 清理缓存时尽可能使用精确的文件路径，如清理demo 1.0.0版本，请使用rm -rf /path/com/huawei/demo/1.0.0,尽量避免删除目录层级过高，导致下次构建缓慢或因网络问题导致依赖异常。

3. 出于安全考虑，缓存清理命令只可在“Maven构建”步骤执行，在其他步骤执行此命令会导致“目录不存在”问题或清理无效。

如您已认真阅读以上风险说明，确保理解且接受该风险，可按如下步骤清理缓存。

i. 准备清理命令

○ 缓存清理命令格式为：rm -rf /repository/local/maven/{GroupID}/{Artifact ID}/{Version}。

○ 其中需要的参数分别对应依赖坐标中的GroupID、ArtifactID、version。

○ 若依赖如下：<dependency> <groupId>com.huawei.devcloud</groupId> <artifactId>demo</artifactId> <version>1.0.9-SNAPSHOT</version></dependency>

那么清理该依赖所需命令为：rm -rf /repository/local/maven/com/huawei/devcloud/demo/1.0.9-SNAPSHOT。

ii. 编辑构建任务，编辑构建步骤 -> Maven构建。

iii. 找到mvn xxxx命令位置，在此命令之前新增一行，填入步骤一准备好的清理命令，保存任务。

iv. 重新执行构建任务，成功后再次编辑，移除清理缓存命令。

● Maven构建默认命令含义是什么？

构建服务内置的默认构建命令为# 打包:跳过单元测试;每次构建检查更新mvn package -Dmaven.test.skip=true -U -e -X

其中，各命令/参数含义为：

– mvn package：使用maven执行打包动作，此命令会在项目target目录下生成软件包，可根据需要自行调整。

– -Dmaven.test.skip=true：跳过单元测试，建议保留。

– -U：每次构建强行更新SNAPSHOT类型依赖，避免默认策略导致无法下载SNAPSHOT类型依赖新版本问题，建议保留。

– -e：打印Maven错误详细信息，如有需要可以选择移除，需要详细日志定位构建异常时打开即可。



– -X：打印Maven构建过程的DEBUG级别日志，如有需要可以选择移除，需要详细日志定位构建异常时打开即可。



3 使用 Ant 构建包制作 Docker 镜像

背景信息

本文旨在演示如何使用DevCloud编译构建服务完成Ant构建，再将构建包制作Docker镜像并推送到SWR仓库。

SWR，即容器镜像服务。SWR镜像仓库用于存储用户上传的Docker镜像，可以在构建、部署时或其他场景使用。

前提准备● 了解Ant的基本使用方法

● 了解Docker的基本概念、环境安装和基本操作。

关于如何在各个操作系统平台安装docker，请参考Docker官方文档。

创建仓库

步骤1 新建antDemo代码仓库

1. 进入代码托管服务，使用模板“Java Ant Demo”创建一个代码仓库。

编译构建佳实践 3 使用 Ant 构建包制作 Docker 镜像


https://support.huaweicloud.com/productdesc-swr/swr_03_0001.html

https://docs.docker.com/

创建出来的代码仓库的目录。

2. 编写Dockerfile

– 准备基础镜像，可使用DockerHub或SWR仓库中公开镜像，本例中使用CentOS作为基础镜像。

– 获取构建包路径。

Ant的构建包路径在build.xml中定义，在打包的方法中，属性“destfile”定义了生成jar包的位置。



根据下面的变量定义，得出构建包的路径为：“./build/jar/javaAntDemo.jar”。

3. 使用获取的构建包路径编写Dockerfile。FROM centos MAINTAINER <[email protected]> USER root RUN mkdir /demo COPY ./build/jar/javaAntDemo.jar /demo/antDemo.jar

4. 上传Dockerfile到项目的根目录下。

步骤2 准备SWR镜像仓库

前往容器镜像服务，请参考容器镜像服务用户指南准备SWR仓库。





步骤3 创建组织

在DevCloud编译构建服务添加步骤“制作镜像并推送到SWR仓库”时，需要指定SWR组织名，参考创建组织。

----结束

打包并制作、推送镜像

步骤1 新建构建任务“使用antDemo制作Docker镜像”。

源码源选择“DevCloud”，源码仓库选择“antDemo”，构建模板选择“Ant”。

Ant模板预置了步骤“Ant构建”、“上传软件包到软件发布库”，以及配套的默认构建命令。多数场景下，直接使用即可完成构建并将生成的软件包上传到软件发布库。

步骤2 删除步骤“上传软件包到软件发布库”。

如需要归档软件包到发布库，可选择保留，构建包路径会自动生成。

步骤3 配置步骤“Ant构建”，确认构建命令无误。

检查构建命令：模板中已给出默认参数配置，此处只需确认参数正确即可。

● 默认命令要从根目录读取build.xml文件，本例中build.xml在根目录，无需调整。

● 本项目要求使用jdk1.8编译、运行，确认工具版本选择ant1.10.3-jdk1.8无误。

步骤4 添加步骤“制作镜像并推送到SWR仓库”，录入所需镜像信息：

● 仓库地址取默认值即可。

● 指定SWR组织名。

● 镜像名称自定义，注意需要符合SWR对镜像名格式要求，此处为antdemo。

● 镜像标签自定义，注意需要符合SWR对镜像标签格式要求，此处为v1.1。

● 工作目录取默认当前目录即可。

● Dockerfile路径：准备好的Dockerfile已存放于项目根目录。当前构建目录即为项目根目录，默认值“./Dockerfile”无需更改。




步骤5 保存任务并执行，任务成功构建如下：

----结束

查看构建结果

步骤1 进入SWR镜像仓库首页，选择对应region。




步骤2 单击“我的镜像”，选择“制作镜像并推送到SWR仓库”步骤中填写的组织，即可查看上传的镜像。

----结束



4 使用 Node.js 构建包制作 Docker 镜像

目标

本文旨在帮助用户了解如何使用软件开发云编译构建服务打包Node.js项目及制作构建包的Docker镜像。

前提准备

● 了解Node.js环境的安装和基本操作。

● 了解Docker的基本概念、环境安装和基本操作，关于如何在各个操作系统平台安装docker，请参考Docker官方文档。

操作步骤

步骤1 创建一个用于存放代码的目录nodesource，进入该目录并创建名称为package.json的文件，内容如下:{"name": "docker_web_app","version": "1.0.0","description": "Node.js on Docker","author": "First Last <[email protected]>","main": "server.js","scripts": {"start": "node server.js"},"dependencies": {"express": "^4.16.1"}}

步骤2 创建名为server.js的文件，内容如下：'use strict';const express =require('express');// ConstantsconstPORT=8080;constHOST='0.0.0.0';// Appconst app =express();app.get('/',(req, res)=>{ res.send('Hello world\n');});app.listen(PORT,HOST);console.log(`Running on http://${HOST}:${PORT}`);

编译构建佳实践 4 使用 Node.js 构建包制作 Docker 镜像


https://www.runoob.com/nodejs/nodejs-install-setup.html

https://www.runoob.com/nodejs/nodejs-tutorial.html


步骤3 本地验证。

代码准备好之后，可以在本地先编译，然后将项目运行起来，看结果是否正常。

首先，打开一个命令行，cd到nodesource所在目录，输入npm install完成依赖安装，再输入node server.js运行项目。

然后打开浏览器，在浏览器中输入本机IP:8080，如果出现下图结果，则表示服务运行正常。

步骤4 新建Dockerfile文件。内容如下：#use the latest LTS (long term support) version 12 of node available from the Docker HubFROM node:12# Create app directoryWORKDIR /usr/src/app# Install app dependencies# A wildcard is used to ensure both package.json AND package-lock.json are copied# where available (npm@6+)COPY package*.json ./RUN npm install# If you are building your code for production# RUN npm ci --only=production# Bundle app sourceCOPY . .EXPOSE 8080CMD ["node","server.js"]

步骤5 新建.dockerignore。内容如下node_modulesnpm-debug.log

步骤6 上传代码至代码托管服务。

进入代码托管服务，创建代码仓库nodesource，并根据指导文档完成代码上传，代码上传完后，可进入代码仓库查看内容。



https://support.huaweicloud.com/qs-codehub/codehub_qs_1000.html

步骤7 创建编译构建任务。

1. 进入编译构建服务，单击“新建任务”按钮，进入“新建编译构建任务”页面。

2. 在“基本信息”步骤，在任务名称处输入“nodesource-build”，单击“下一步”。

在“选择代码源”步骤，源码源选择“DevCloud”，源码仓库选择刚才上传的“nodesource”，分支为“master”，单击“下一步”。

在“选择构建模板”步骤，选择推荐模板“Npm”，单击“确定”。

3. 配置构建步骤。

配置“NPM构建”，在右下方的命令行编辑器里，注释掉npm run build，输入zip -r ./nodeserver.zip ./，用来将代码打包成nodeserver.zip。



配置“上传软件包到软件发布库”，按照下图内容填充表单。

单击“上传软件包到软件发布库”下方的，输入并搜索“swr”，添加步骤“制作镜像并推送到swr仓库”。

按照下图所示编辑表单内容，然后单击“新建”，完成构建任务创建。



步骤8 单击页面右上角“执行”，执行编译构建任务。

任务执行成功后，新的镜像地址为“swr.cn-north-1.myhuaweicloud.com/study/nodestudy:v1.1.0”。

步骤9 查看发布库软件包

进入发布服务，按照目录结构“nodeserver/v0.0.1”找到上传的nodeserver.zip包。

步骤10 设置镜像为公共镜像。



进入容器镜像服务SWR，选择左侧“我的镜像” ，单击刚才制作完的nodestudy镜像。

按照下图标记的顺序，先选中镜像版本v1.1.0，然后单击右上角的“编辑”，在弹出的框中选择“公开”，然后单击“确定”。

步骤11 验证镜像。

找一个安装了Docker的主机，在命令行中输入docker pull swr.cn-north-1.myhuaweicloud.com/study/nodestudy:v1.1.0。




执行命令docker run -p 28080:8080 -d swr.cn-north-1.myhuaweicloud.com/study/nodestudy:v1.1.0启动镜像。

其中，-p 28080:8080，是把镜像中的8080端口映射到本机的28080端口。

在浏览器中输入“http://ip:port”，出现如下界面，说明镜像制作成功。

----结束



5 基于 Python 项目制作 Docker 镜像

目标

本文旨在演示如何使用DevCloud编译构建服务将Python的web框架Django项目制作为Docker镜像并推送到SWR仓库。

前提准备● 安装Git客户端。

● 了解Python和Django。

● 了解Docker的基本概念、环境安装和基本操作。关于如何在各个操作系统平台安装docker，请参考Docker官方文档。

操作步骤

步骤1 创建代码仓库“DjangoDemo”，将本地推送代码至DjangoDemo，本例的代码都放在src目录下。

步骤2 在根目录下创建Dockerfile，并写入以下内容。FROM python:3.4RUN mkdir -p /usr/src/app

编译构建佳实践 5 基于 Python 项目制作 Docker 镜像


https://support.huaweicloud.com/usermanual-codehub/codehub_hlp_0006.html

https://www.djangoproject.com/


WORKDIR /usr/src/appCOPY ./src /usr/src/appRUN pip install --no-cache-dir -r requirements.txtEXPOSE 8000CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

步骤3 新建编译构建任务，源码仓库本例选择DjangoDemo，模板选择“不使用模板，直接创建”。

步骤4 添加步骤“制作镜像并推送到SWR仓库”。

步骤5 单击镜像仓库右边的链接容器镜像服务，跳转至“容器镜像服务”页面。

选择“组织管理”，创建组织“test_2018”。



https://www.huaweicloud.com/product/swr.html

步骤6 回到构建任务，配置构建步骤。选择上面步骤中创建的组织，并输入镜像名字、镜像标签。

步骤7 保存任务并执行，任务成功构建如下：



步骤8 再次登录容器镜像服务，可以看到构建任务推送的镜像。

编辑镜像为“公开”。

单击“下载指令”里的，可复制镜像地址进行后续使用。

----结束



6 基于 PHP 项目制作 Docker 镜像

目标

本文旨在演示如何使用DevCloud编译构建服务完成PHP构建，使用构建包制作Docker镜像并推送到SWR仓库。

前提条件● 了解PHP、composer环境的安装和基本操作。

● 了解Docker的基本概念、环境安装和基本操作。

● 熟悉Linux操作系统基本操作。

● 注册DevCloud账号，了解DevCloud的基本操作。

操作步骤

步骤1 本地环境搭建

● PHP详细使用教程，请参考：https://www.runoob.com/php/php-tutorial.html。

● 使用PHP，需要安装php开发和运行环境，详细的安装文档请参考：https://www.runoob.com/php/php-install.html，也可以参考官方文档：https://www.php.net/manual/en/install.php。

步骤2 准备代码

首先在本地准备好PHP项目：myphpmail，确保项目在PHP运行环境中能正常运行。

本次用于演示的项目目录结构如下：

编译构建佳实践 6 基于 PHP 项目制作 Docker 镜像


https://www.runoob.com/php/php-tutorial.html

https://www.runoob.com/php/php-tutorial.html

https://www.runoob.com/php/php-install.html

https://www.runoob.com/php/php-install.html

https://www.php.net/manual/en/install.php

https://www.php.net/manual/en/install.php

步骤3 本地验证

本地运行效果如下：



说明

本地PHP运行环境，可以使用appserv（https://www.appserv.org/en/）等PHP集成运行环境，需要提前安装。

步骤4 准备Dockerfile

将项目复制到镜像中，解压到“php workspace”目录，并在容器启动时将项目运行起来，Dockerfile内容为：

FROM php:7.3.9-apacheCOPY php_mail.tgz .RUN cd /var/www/html/ \&& tar -zxf php_mail.tgz \&& rm -rf php_mail.tgz

说明

php_mail.tgz为云上项目打包文件，后面会专门制作该软件包php:7.3.9-apache 镜像包含了PHP和Apache运行环境，可以直接运行PHP项目。

步骤5 创建代码仓库

进入代码托管服务，创建代码仓库，并完成代码上传。关于如何将代码上传到云端代码仓库，请参考代码托管帮助文档。



https://www.appserv.org/en/


步骤6 创建编译构建任务

编译构建任务分为如下两部分：

● 编译PHP项目，并将项目打包上传到发布库，后续如果要在其他环境上运行的话，可以直接下载该项目部署并运行。

● 制作包含php-apache运行环境和项目app的Docker镜像，在swarm，k8s等容器化环境下可以直接部署并提供服务。

步骤如下：

1. 进入编译构建服务，新建任务，输入任务名称如：myphpmail-build，单击“下一步”。



2. 源码源选择“DevCloud，”源码仓库选择上面创建的代码仓库“php-mail”，分

支选择“master”，单击“下一步”。

3. 选择推荐模板“PHP”，单击“确定”。

4. 配置步骤“PHP构建”



在命令编辑器修改命令如下：

– 1到4行为设置composer依赖仓，并完成php依赖包安装，无需修改，

– 将第5行修改为： tar -zcvf php_mail.tgz *，用来将代码打包成“php_mail.tgz”。

5. 配置步骤“上传软件包到发布库”，按照如下内容填充表单：

6. 添加步骤“制作镜像并推送到swr仓库”。

7. 参考下图编辑表单，单击“新建”按钮，完成构建任务创建

此处组织需要根据实际情况编辑表单，如myphp等。



步骤7 执行构建任务，将镜像上传到SWR。

● 单击“执行”按钮，等待构建完成。

● 构建成功，通过构建日志可以看到新的镜像坐标为“swr.cn-north-1.myhuaweicloud.com/xxxxxx/myphpmail:v1.0.0.1”，且已经上传到SWR仓库。



步骤8 查看软件包

进入软件发布库，可看到刚刚上传的php_mail.tgz，单击链接即可直接下载该安装包。

步骤9 设置镜像为公共镜像

● 登录容器镜像服务，选择“我的镜像” ，单击刚刚制作完的myphpmail镜像。

● 选中镜像版本v1.0.0.1，单击右上角“编辑”，在弹出的框中选择“公开”，单击

“确定”。




步骤10 验证镜像

找一个已安装Docker运行环境的主机。

关于如何在各个操作系统平台安装docker，请参考docker官方文档，可以看到各平台的安装文档入口。

● 在SWR页面中按照如下操作复制镜像下载命令。

● 在Docker执行机上粘贴命令然后回车，开始下载镜像。

● 执行如下命令启动镜像：




docker run -p 89:80 -d swr.cn-north-1.myhuaweicloud.com/xxxxxx/myphpmail:v1.0.0.1

说明

命令行中-p 89:80为把镜像中的80端口映射到本机的89端口。89端口可以自己定义，只要不和本机已经启动的端口冲突即可。

● 在浏览器中输入http://ip:89，若出现如下界面，说明镜像制作成功。

----结束



7 基于 Go 项目制作 Docker 镜像

本文旨在演示如何使用DevCloud编译构建服务完成Go构建，使用构建包制作Docker镜像并推送到SWR仓库。

前提条件● 熟悉Go编程语言，了解Go的安装和Linux系统基本操作。

● 了解Docker的基本概念，环境安装和基本操作。


准备代码

步骤1 在本地准备好Go项目：gomail，确保项目在Go运行环境中能正常运行。

本次用于演示的项目目录结构如下：gomail.go为go代码，static为静态网站内容，Dockerfile为镜像打包描述文件。

步骤2 将项目复制到镜像golang:1.12中，完成项目编译，放开容器的8090端口，在容器启动时执行gomail将项目运行起来，内容如下：

编译构建佳实践 7 基于 Go 项目制作 Docker 镜像


步骤3 进入代码托管服务，选择“普通新建”，创建代码仓库，并完成代码上传。关于如何将代码上传到云端代码仓库，请参考代码托管。

----结束

创建编译构建任务

编译构建任务分为如下两部分：

● 编译Go项目，并将项目打包上传到发布库，若后续要在其他环境上运行，可以直接下载该项目部署并运行。

● 制作包含Go运行环境和项目gomail的docker镜像，在如swarm，k8s等容器化环境下可以直接部署并提供服务。

操作步骤如下：

步骤1 进入编译构建服务，单击“新建任务”按钮，输入任务名称“gomail-build”，单击“下一步”。




步骤2 源码源选择“DevCloud”，源码仓库选择上面创建的代码仓库“gomail”，分支选择“master”，单击“下一步”。

步骤3 选择推荐模板“Go”，单击“确定”

步骤4 由于Dockerfile中已经有了项目编译脚本，我们可以先完成Docker镜像制作，再完成构建包上传发布库过程。

单击Go语言构建上方的图标，添加步骤“制作镜像并推送到SWR仓库”。



参考下图编辑表单，其中，“组织”可根据实际自行输入，创建组织请参考创建组织。

步骤5 配置步骤“Go语言构建”：参考下图修改命令文本框中命令（打包后清理掉源码和Dockerfile）。



https://support.huaweicloud.com/api-swr/swr_02_0026.html

https://support.huaweicloud.com/api-swr/swr_02_0026.html

步骤6 配置步骤“上传软件包到发布库”，参考下图填充表单，单击“确定”，完成任务新建。

----结束

执行构建任务将镜像上传到 SWR

步骤1 单击“执行”按钮，执行构建任务，出现如下画面表示任务执行成功。

步骤2 单击节点“制作镜像并传到SWR仓库”，可以在日志中找到新的镜像地址为“swr.cn-north-1.myhuaweicloud.com/study/gomail:v1.0.1”。



----结束

查看发布库软件包

进入软件发布库，依次单击文件夹“gomail > v1.0.1”，就能看到刚刚上传的gomail.tgz。

设置镜像为公共镜像

步骤1 进入容器镜像服务，选择对应region，单击左侧的“我的镜像” ，单击刚刚制作完成的镜像gomail。




步骤2 选中镜像版本v1.0.1，单击右上角的“编辑”按钮，在弹出的框中选择“公开”，单击“确定”按钮。

----结束

验证镜像

步骤1 找一个已安装Docker运行环境的主机。

步骤2 在SWR页面中按照如下操作复制镜像下载命令。

步骤3 在Docker执行机上粘贴命令然后回车，开始下载镜像。

步骤4 执行如下命令启动镜像docker run -p 8090:8090 -d swr.cn-north-1.myhuaweicloud.com/study/gomail:v1.0.1



说明

命令行中-p 8090:8090为把镜像中的8090端口映射到本机的8090端口，端口可以自己定义，只要和本机已经启动的端口不冲突即可。

步骤5 在浏览器中输入http://ip:8090，若出现如下界面，说明镜像制作成功。

----结束



8 使用自定义 Dockerfile 制作 Docker 镜像

背景

由于用户构建场景多样化，默认提供的构建模板镜像不完全适用于当前项目，或缺少项目必需的依赖包、工具，导致用户每次构建时重复执行自定义的安装命令，影响编译构建速度。为此，软件开发云编译构建针对复杂构建场景提供自定义构建环境，供默认构建模板无法满足构建需求的用户使用。

本文以Go项目为例，假设DevCloud编译构建服务没有提供满足Go的编译环境，且项目需要Tomcat工具。演示如何制作自定义Docker构建镜像并推送到SWR仓库，及如何使用自定义镜像编译构建。

前提准备

步骤1 如果是初次使用软件开发云，请确认已完成准备操作，然后开始本示例。

步骤2 了解Docker的基本概念、环境安装和基本操作。关于Docker基本概念和基本操作命令，请参考Docker官方文档。

步骤3 创建容器组织。

1. 进入SWR容器镜像服务，单击页面左侧“组织管理”，在页面中单击“创建组织”。

2. 输入组织名称，单击“确定”，完成容器组织的创建。

----结束

制作自定义构建镜像

步骤1 制作自定义Dockerfile文件。

1. 进入构建服务，单击右上角“更多管理 > 自定义构建环境”。

2. 选择合适的基础镜像，下载Dockerfile模板

编译构建佳实践 8 使用自定义 Dockerfile 制作 Docker 镜像




3. 编辑下载的Dockerfile文件，加入项目需要的依赖和工具。

步骤2 新建空白仓库“special-image-build”，将项目代码提交至此仓库，并上传Dockerfile至项目根目录。

步骤3 制作镜像并推送到SWR仓库。

1. 新建构建任务“制作自定义构建环境”，源码选择在上个步骤创建的代码仓库，模板选择“制作镜像并推送到SWR仓库”。



2. 输入必需的参数，单击“新建”按钮，完成构建任务创建。

参数说明如下：

参数说明

组织准备阶段创建的SWR组织，本例中为voting-sample。



参数说明

镜像名字自定义命名，符合命名规范即可，本例中为special_image_build_sample。

镜像标签自定义命名，符合命名规范即可，本例中为v1.1。

Dockerfile路径

项目中Dockerfile文件存放的路径，如果Dockerfile放置于项目根目录，默认即可。

3. 单击“执行”按钮执行构建任务。执行成功后，可查看到制作的镜像地址为：

“swr.cn-south-1.myhuaweicloud.com/voting-sample/special_image_build_sample:v1.1”。

步骤4 设置镜像为公共镜像

1. 进入容器镜像服务，选择对应区域。

2. 单击“我的镜像”，选择在上面步骤中输入的组织，即可查看上传的镜像。




3. 单击镜像名称，进入“镜像详情”页面。

按照下图标记的顺序，先选中镜像版本，然后单击右上角的“编辑”按钮，在弹出的框中选择“公开”按钮，单击“确定”按钮，设置镜像为公开镜像。

4. 在“镜像详情”页面中，可通过“下载指令”查看到镜像地址。

本例中镜像地址为：“swr.cn-south-1.myhuaweicloud.com/voting-sample/special_image_build_sample:v1.1”。

----结束

使用自定义构建镜像编译构建

步骤1 编辑构建任务“制作自定义构建环境”，删除步骤“制作镜像并推送到SWR仓库”，添加步骤“使用SWR公共镜像”。



步骤2 输入镜像地址和构建命令。

本例中的镜像地址为“swr.cn-south-1.myhuaweicloud.com/voting-sample/special_image_build_sample:v1.1”。

步骤3 保存并执行构建任务。

执行成功后，可看到项目使用了SWR仓库中自定义的镜像编译构建，并且该自定义镜像中安装了项目必需的Tomcat工具。

----结束



至此，该自定义镜像就可以作为该项目的构建环境，以后仅需使用步骤“使用SWR公共镜像”编译构建项目即可。



9 跨租户推送镜像到 SWR

背景

本文主要介绍如何在云端构建一个docker容器，实现微服务的构建过程。

主要操作步骤如下：

● 代码准备

● 镜像仓库环境准备

● 配置构建任务

● 执行构建任务

● 查看构建结果

代码准备

进入“代码托管”页面，使用模板“DevCloud Demo”创建代码仓库。

编译构建佳实践 9 跨租户推送镜像到 SWR


说明

这个仓库主要是一个maven工程，可以通过maven构建打包成一个war包，在Dockerfile中将这个war包打包到docker镜像中。

镜像仓库环境准备

步骤1 登录镜像仓库服务，新建一个组织。

步骤2 参考指导文档获取上传镜像的用户名和密码。

须知

如果你想要上传的镜像仓库不是本租户的，你可以通过其他租户登录，参照上面链接，获取AK/SK。

----结束

配置构建任务

步骤1 进入“编译构建”页面，新建任务。

源码仓库选择上面创建的代码仓库，构建模板选择“Maven”。

步骤2 单击“参数设置”页签，参考下图添加构建参数。

步骤3 参考下图操作添加步骤“执行Docker命令”，并删除步骤“上传软件包到软件发布库”删除。



https://console.huaweicloud.com/swr/?locale=zh-cn#/app/organization/list


步骤4 配置“执行Docker命令”构建步骤，单击“新建”完成任务创建。

命令参数如下：

● login命令参数：-u cn-north-4@${swrusername} -p ${swrpassword} ${swrurl}

● build命令参数：-f Dockerfile -t ${swrurl}$/${group}$/${imagename}:${imageversion} .

● push命令参数：${swrurl}$/${group}$/${imagename}:${imageversion}

须知

请勿漏掉build命令后的“ .”。

----结束

执行构建任务

单击“执行”按钮，根据自己的需要改变构建参数的值，比如“imageversion”，每次构建都可以用一个不同的版本号。



查看构建结果

任务执行成功后，进入镜像仓库，在“我的镜像”页面的镜像列表中即可查看生成的docker容器。

须知

请选择和您构建任务一致的区域。



10 使用 Cmake 编译 C 语言程序

目标

本文旨在演示如何使用DevCloud编译构建服务Cmake构建C语言项目，并上传软件包到软件发布仓库。

前提条件● 掌握C++编程语言开发，了解gcc，make，Cmake等c语言编译工具的部署和日常

基本操作。


说明

● 本文演示基于开源项目：google/leveldb，地址为: https://github.com/google/leveldb。

● Cmake教程，可参考https://github.com/Campanula/CMake-tutorial。

● Cmake下载可在https://cmake.org/download/下载新版本，也可以在https://cmake.org/files/下载各种历史版本和对应源码。

操作步骤


1. 进入代码托管服务，单击“普通新建”旁的下拉按钮，选择“导入外部仓库”。

2. 输入源仓库路径，其他选项默认，单击“下一步”。

编译构建佳实践 10 使用 Cmake 编译 C 语言程序


https://github.com/google/leveldb

https://github.com/google/leveldb

https://github.com/Campanula/CMake-tutorial

https://cmake.org/download/

https://cmake.org/files/

https://cmake.org/files/

3. 输入代码仓库名称和描述，单击“确定”，等待仓库完成同步。

4. 代码同步完成，单击仓库名称，进入代码仓库页面。对比和github上的代码仓库

结构和内容，查看代码是否完整同步过来。



步骤2 创建CMake任务

1. 进入编译构建服务，单击“新建任务”，新建任务。

2. 填写基本信息，单击“下一步”。

3. 源码源选择“DevCloud”，源码仓库选择步骤1中创建的代码仓库“ leveldb”，

分支选则“master”，单击“下一步”。



4. 选择推荐模板“Cmake”，单击“确定”。

5. 配置步骤“CMake构建”：

– 构建工具版本选择cmake3.10.1-gcc7.3.0。

– 在命令框第四行后面添加如下两行命令，用来将编译后的结果打包成tgz包，方便归档。



cd ..tar –zcvf leveldb.tgz build

6. 配置步骤“上传软件包到发布库”，参考下图编辑表单：软件包路径为

“leveldb.tgz”，发布版本号为“1.0.1”，包名为“leveldb”。

单击“新建”按钮，完成构建任务创建。

步骤3 执行构建任务

单击“执行”按钮，执行构建任务。构建成功后，可以单击页面右上方的 “下载构建包”，将打包好的软件包下载下来。



步骤4 查看发布仓库中的软件包

进入发布页面，依次单击文件夹“laveldb > 1.0.1”，可看到刚刚上传的软件包leveldb.tgz。

单击软件包，进入软件包下载页面，单击链接即可下载。

----结束



11 使用 msbuild 编译 C#语言程序

目标

本文旨在演示如何使用DevCloud编译构建服务msbuild构建C#项目，并上传软件包到软件发布仓库

前提条件

1. 掌握C#编程语言开发，了解VS、dotnetframework、.netcore、msbuild等C#语言编译工具的安装和基本操作

2. 注册DevCloud账号，了解DevCloud的基本操作。

说明

● 本文演示基于开源项目： yubaolee/OpenAuth.Core,地址为: https://github.com/yubaolee/OpenAuth.Core。

● C#简单教程，可参考https://www.runoob.com/csharp/csharp-tutorial.html。

● Windows的“dotnet-framework-sdk”镜像，可以去https://hub.docker.com/_/microsoft-dotnet-framework-sdk/下载，也可以去https://hub.docker.com/publishers/microsoftowner寻找自己需要的各类镜像。

操作步骤


1. 进入到代码托管页面，选择“导入外部仓库”。

2. 输入源仓库路径，其他选项默认，单击“下一步”。

编译构建佳实践 11 使用 msbuild 编译 C#语言程序


https://github.com/yubaolee/OpenAuth.Core

https://github.com/yubaolee/OpenAuth.Core

https://www.runoob.com/csharp/csharp-tutorial.html

https://hub.docker.com/_/microsoft-dotnet-framework-sdk/

https://hub.docker.com/_/microsoft-dotnet-framework-sdk/

https://hub.docker.com/publishers/microsoftowner

https://hub.docker.com/publishers/microsoftowner

3. 输入代码仓库名称和描述，单击“确定”按钮，等待仓库完成同步。

4. 代码同步完成，单击仓库名称，进入代码仓库页面。对比和github上的代码仓库

结构和内容，查看代码是否完整同步过来。



步骤2 创建MSbuild编译构建任务

1. 进入编译构建服务，单击“新建任务”按钮，新建任务。

2. 输入任务名称，单击“下一步”。



3. 源码源选择“DevCloud”，源码仓库选择步骤1中创建的代码仓库

“OpenAuth”，分支选则“master”，单击“下一步”。

4. 选择推荐模板“msbuild”，单击“确定”。



5. 配置步骤“Msbuild构建”：构建工具版本选择msbuild16-

dotnetframework4.8。

6. 配置步骤“上传软件包到发布库”，参考下图编辑表单：软件包路径为

“archive.zip”，发布版本号为“1.0.1”，包名为“openauth”。

单击“新建”按钮，完成构建任务创建。

步骤3 执行构建任务




步骤4 查看发布仓库中的软件包

进入发布页面，依次单击文件夹“openauth > 1.0.1”，可看到刚刚上传的软件包openauth.zip。


----结束



12 使用 Android 构建生成 APK 并签名

目标

本文旨在演示如何在编译构建服务上，将一个Android App项目构建成APK可执行文件，以及如何对APK文件进行签名，得到一个可发布的APK文件。

项目说明

本文演示项目涉及一个Android App工程，一个keystore密钥库。

● TestApp项目：此次构建主项目，将使用DevCloud构建此项目，并得到可在Android系统上执行的APK文件。

● debug.keystore密钥库：证书和私钥的存储区（如何生成密钥库？），开发者需要使用其中存储的密钥对APK文件进行数字签名后，才能将APK文件发布到应用市场，Google Play等应用市场。

操作准备

如果是初次使用软件开发云，请确认已完成使用编译构建的前提准备，然后开始本示例。

步骤1 新建空白仓库“TestApp”。

步骤2 将TestApp项目代码提交到代码仓库。

编译构建佳实践 12 使用 Android 构建生成 APK 并签名


https://developer.android.com/studio/publish/app-signing.html?hl=zh-CN#generate-key


----结束

编译并生成 APK 文件

步骤1 新建构建任务，任务名称为“构建APK文件”。

步骤2 源码源选择“DevCloud”，源码仓库选择操作准备中创建的代码仓库，分支选择“maste”r。



步骤3 选择推荐模板“Android APK”。

模板“Android APK”预置了步骤“Android构建”和“上传软件包到发布库”，多数场景下直接使用即可完成构建并将生成的APK文件发布到DevCloud发布库。

步骤4 配置步骤“Android构建”

● 一般情况下，若Android App项目使用Gradle Wrapper管理，使用默认配置即可构建出APK文件，使用Gradle Wrapper根据配置自动下载对应版本的Gradle构建项目。

● 如果需要使用指定版本的Gradle进行构建，可选择Gradle下拉列表，选择需要的Gradle版本。

● 如果在项目中需要使用NDK编译项目中的C和C++代码，则需要单击NDK下拉列表，选择希望使用的NDK版本。



步骤5 保存任务并执行，任务执行成功后可在软件发布库查看上传的APK文件。

----结束

对 APK 文件进行签名

在发布到应用市场前，需要对APK文件进行数字签名。

步骤1 进入构建任务详情中，在步骤“Android构建”后，添加步骤“Android APK签名”。

步骤2 配置步骤“Android APK签名”

单击“上传”，将密钥库文件上传到DevCloud，在文本框中输入密钥相关信息（签名密钥需要哪些信息？）





须知

为了降低安全风险，DevCloud不推荐开发者在代码仓库中保存密钥库。

步骤3 保存任务并执行。任务执行成功后可于软件发布库查看上传的APK文件。

单击链接下载APK文件后，可直接将该APK上传到应用市场。

----结束



疑问解答● 为什么构建过程中，Gradle会使用华为开源镜像站下载第三方依赖？

DevCloud编译构建服务默认使用可信，高速，稳定的华为开源镜像站作为依赖源。

若想取消该配置，使用自定义依赖源，可将命令行中的-- init-script ./.codeci/.gradle/init_template.gradle部分去掉。



13 使用快应用组件编译生成 RPK 并签名

目标

本文旨在演示如何使用软件开发云编译构建服务，将一个快应用项目构建生成rpk文件，以及如何对rpk文件进行签名，得到一个可发布的rpk文件。

项目说明

本文演示项目涉及一个带有签名文件的快应用工程项目，快应用的签名文件是放在项目根目录的sign文件夹下，分为release和debug两种，本文示例使用debug来演示。

操作准备

步骤1 创建代码仓库，将项目代码上传至仓库中。

步骤2 创建签名文件。

通过openssl命令等工具生成签名文件“private.pem”、“certificate.pem”，例如：

openssl req -newkey rsa:2048 -nodes -keyout private.pem -x509 -days 3650 -out certificate.pem

在工程的sign目录下创建debug目录，并上传私钥文件“private.pem”和证书文件“certificate.pem”。

编译构建佳实践 13 使用快应用组件编译生成 RPK 并签名


----结束

编译并生成 rpk 文件

步骤1 新建编译构建任务，模板选择系统模板“Quickapp”，单击“确定”开始配置。

步骤2

步骤3 配置步骤“Android快应用构建”。

根据代码实际使用的npm版本选择“工具版本”，本例中选择“10.15.3”。



https://support.huaweicloud.com/usermanual-codeci/devcloud_hlp_00036.html

修改构建命令：

发布程序包前需要增加release签名，然后在工程的根目录下运行。命令为npm runrelease，生成的应用路径为“/dist/.release.rpk”。

本例中用的是debug签名，因此使用命令npm run release --debug。

须知

由于是debug签名公开的，安全性无法保证，因此一定不要使用debug签名签发正式上线的应用。

步骤4 配置步骤“上传软件包到软件发布库”。

输入要上传到软件发布仓的构建包路径，版本号和包名。其中构建包路径默认是通配符“./dist/*.rpk”格式，可根据自己的实际情况输入准确的路径，也可以选择默认通配符格式，详细请参见上传软件包到软件发布库。

步骤5 单击“新建”按钮完成编译构建任务配置，执行任务即可。

----结束



https://support.huaweicloud.com/usermanual-codeci/codeci_ug_0038.html

14 使用 Ionic 构建生成 Android 应用

目标

本文演示如何基于开源项目hybirddemo使用DevCloud编译构建服务完成IonicAndroid APP构建，并上传软件包到软件发布仓库。

前提条件● 掌握混合编译基本概念，了解Android、NPM、Ionic、Angular、Gradle等语言和

工具的安装和基本操作

● 注册DevCloud账号，熟悉DevCloud的基本操作。

说明

Ionic技术入门可参考： https://www.runoob.com/ionic/ionic-tutorial.html。

准备代码

步骤1 进入代码托管服务，单击“普通新建”旁的下拉按钮，选择“导入外部仓库”。

步骤2 输入源仓库路径，其他选项默认，单击“下一步”。

编译构建佳实践 14 使用 Ionic 构建生成 Android 应用


https://github.com/wenchui/hybirddemo

https://www.runoob.com/ionic/ionic-tutorial.html

步骤3 输入代码仓库名称和描述，单击“确定”按钮，等待仓库完成同步。



步骤4 代码同步完成，单击仓库名称，进入代码仓库页面。对比和github上的代码仓库结构和内容，查看代码是否完整同步过来。



----结束

创建编译构建任务

步骤1 进入编译构建服务，单击“新建任务”，新建任务。

步骤2 输入任务名称，单击“下一步”。

步骤3 源码源选择“DevCloud”，源码仓库选择准备代码中创建的代码仓库“hybird-android”，分支选则“master”，单击“下一步”。



步骤4 选择系统模板“Ionic Android App”，单击“确定”。

步骤5 配置步骤“Ionic Android App构建”

● 根据需要的构建工具Gradle、JDK和NDK版本

● 默认的命令无需修改也可以完成编译，这里我们稍微修改一下编译脚本，将Cordova修改为8.0版本，然后添加Android平台，命令行内容如下：npm uninstall cordova -gnpm install -g ionic [email protected] config set registry https://repo.huaweicloud.com/repository/npm/npm cache clean -f#添加android编译平台ionic cordova platform add android



#混合编译ionic cordova build android

步骤6 配置步骤“上传软件包到发布库”，参考下图内容编辑表单：

软件包路径为“platforms/android/app/build/outputs/apk/debug/app-debug.apk”，版本为“v1.0.1”，包名为“hybird-android”。

单击“新建”，完成构建任务创建。

----结束

执行构建任务




查看发布仓库中的软件包

进入发布页面，依次单击文件夹“hybird-android > v1.0.1”，可看到刚刚上传的软件包hybird-android.apk。




15 使用 PyInstaller 构建 Python 可执行程

序

目标

本文旨在演示如何使用DevCloud编译构建服务将Python脚本编译为可执行程序，并将构建结果上传至软件发布库。

前提准备

了解Python和PyInstaller。

● 安装Git客户端

● 创建项目

操作步骤

步骤1 准备以下三个代码文件：

● douban.py# -*-coding:utf-8-*-import requests

def request_douban(): r = requests.get("https://www.douban.com/") if r.status_code == 200: return r.text else: return ""

● main.py# -*- coding:utf-8 -*-import douban

res = douban.request_douban()print(res)

● requirement.txtrequests

步骤2 进入代码托管服务，创建代码仓库“PyInstallerDemo”，并将上一步创建的代码文件推送至PyInstallerDemo。关于如何将代码上传到云端代码仓库，请参考代码托管帮助文档。

编译构建佳实践 15 使用 PyInstaller 构建 Python 可执行程序


https://www.pyinstaller.org/

https://support.huaweicloud.com/usermanual-codehub/codehub_hlp_0006.html

https://support.huaweicloud.com/usermanual-projectman/devcloud_hlp_00032.html



步骤3 进入构建服务，创建任务。

源码仓库选择上一步中创建的“PyInstallerDemo”，构建模板选择系统模板“PyInstaller”。

步骤4 配置步骤“PyInstaller”：参考下图编辑命令行。



步骤5 配置步骤“上传软件包到软件发布库”：参考下图编辑构建包路径。

步骤6 单击“创建”，完成任务创建。

步骤7 单击“执行”启动编译构建任务，待看到下图所示页面时，表示任务构建成功。

● 从日志可以看到编译成功后dist下生成了可执行程序main，执行后下面打印了豆瓣的主页。

● 点击“下载构建包”按钮，可以把本次构建包下载到本地。

----结束



16 使用 Gradle 构建 jar 包

目标

本文旨在演示如何使用Gradle将Java程序构建成可发布的jar文件。

项目说明

本文采用一个基于Springboot的Java工程“gs-rest-service”项目作为演示项目，使用DevCloud构建此项目，得到可运行RESTful服务的jar包。

本文详细描述了从准备代码仓库到构建出jar包的完整过程，大致分为以下步骤，可根据熟悉程度选择阅读：

1. 准备代码仓库

2. 将代码与资源文件编译构建成jar包3. 将jar包发布到私有依赖库

准备代码仓库

如果是初次使用软件开发云，请确认已完成使用编译构建的前提准备，然后开始本示例。

步骤1 进入“代码托管”服务，单击“普通新建”旁的下拉按钮，选择“导入外部仓库”，创建空白仓库“gs-rest-service”。

步骤2 输入源仓库路径，其他选项默认，单击“下一步”。

编译构建佳实践 16 使用 Gradle 构建 jar 包



步骤3 输入代码仓库名称“gs-rest-service”，单击“确定”，等待仓库完成同步。



步骤4 单击代码仓库名称进入仓库，对比和github上的代码仓库结构和内容，查看代码是否完整同步过来。



步骤5 单击页面左侧仓库名称旁的，选择“新建文件”。

步骤6 新建文件“GreetingController”，文件内容如下：package hello;import java.util.concurrent.atomic.AtomicLong;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic classGreetingController {private static final String template = "Hello, %s!";private final AtomicLong counter = newAtomicLong();



@RequestMapping("/greeting")public Greeting greeting(@RequestParam(value="name", defaultValue="World") String name) {returnnewGreeting(counter.incrementAndGet(),String.format(template, name));}}

----结束

将代码与资源文件编译构建成 jar 包

步骤1 进入“编译构建”服务，单击“新建任务”，输入任务名称“springboot工程”，单击“下一步”。

步骤2 源码源选择“DevCloud”，代码仓库选择“gs-rest-service” ，分支选择“master”，单击“下一步”。

步骤3 构建模板选择系统推荐模板“Gradle”。

模板“Gradle”预置了步骤“Gradle构建”和“上传软件包到发布库”。多数场景下，直接使用即可完成构建并将生成的jar包发布到DevCloud软件发布库。



步骤4 配置步骤“Gradle构建”

● 一般情况下，若项目使用Gradle Wrapper管理使用的Gradle工具，则不需要修改任何配置即可使用该步骤编译构建出jar包。

● 该步骤默认使用Gradle Wrapper自动根据配置下载对应版本的Gradle构建项目，若希望直接使用指定版本的Gradle进行构建，可选择Gradle下拉条，选择需要的Gradle版本。



步骤5 单击“新建”，完成构建任务的创建。

步骤6 进入“构建详情”页面，单击“执行”。当出现以下页面时，任务执行成功。

步骤7 进入“发布”服务，可以找到构建生成的jar包。



----结束

将 jar 包发布到私有依赖库

若企业内部需要用上述构建任务生成的jar包作为依赖，则需要将此jar包上传到私有依赖库中。

通过在构建任务中添加私有依赖库配置，可以实现此操作。

操作步骤如下：

步骤1 进入“设置 > 通用设置 > 服务扩展点管理”页面。

步骤2 单击“新建服务扩展点”，在下拉列表中选择“nexus endpoint”。

步骤3 按照页面提示输入服务扩展点名称、仓库地址、用户名、密码，单击“确定”。

步骤4 返回编译构建服务，进入“编译编辑 > 构建步骤”页面。找到“依赖库配置”，单击“私有依赖仓库”一栏中的“添加”。



步骤5 选择步骤3中添加的仓库链接，单击“保存”。

----结束



17 基于 mono 完成 msbuild 和 dotnet 编

译的应用

本文旨在演示如何使用软开云基于mono完成msbuid和dotnet编译构建，使用构建包制作Docker镜像并推送到SWR仓库。

17.1 前提条件● 掌握编程语言开发，了解VS、.NET Framework、.NET Core、msbuild等c#语言

编译工具的安装和日常基本操作。

● 注册DevCloud账号，且免费额度没有用尽，注册后登录DevCloud。

● 本文演示基于开源项目，用户可自行访问如下链接，获取对应的git路径：

– yubaolee/OpenAuth.Core（Msbuild）

– OrchardCMS/OrchardCore（dotnetcore）

● 参考教程。

● 当前mono提供了msbuild16和dotnet环境，其中dotnet-core-sdk版本如下，请选择合适的版本。

– mono6-dotnetcoresdk2.1（dotnet-sdk-2.1.607）



– mono6-dotnetcoresdk3.1（dotnet-sdk-3.1.100-preview3-01464）

17.2 基于 mono 完成 msbuild 项目构建

代码准备

1. 登录DevCloud，创建项目，并进入到“代码托管”页面，单击“普通新建”旁边的下拉列表，选择“导入外部仓库”。

编译构建佳实践 17 基于 mono 完成 msbuild 和 dotnet 编译的应用


https://support.huaweicloud.com/devcloud_faq/devcloud_faq_0057.html#section0

https://github.com/OrchardCMS/OrchardCore

https://github.com/OrchardCMS/OrchardCore

https://www.runoob.com/csharp/csharp-tutorial.html

2. 在“导入外部仓库 > 填写外部仓库信息”页面，“源仓库路径”中填写

OpenAuth的git路径，然后单击“下一步”。

3. 在“导入外部仓库 > 创建仓库”页面，填写代码仓库名称和描述，单击“确

定”，等待仓库完成同步。



4. 仓库创建完成后，单击仓库名称进入代码仓库详情页面，对比github上的代码仓

库结构和内容，看代码是否完整同步过来。



创建 Mono-MSbuild 编译构建任务

1. 在项目下，单击“构建&发布 > 编译构建”，进入“编译构建”页面，然后单击“新建任务”。

2. 进入“新建编译构建任务 > 基本信息”页面，填写任务名称，选择构建环境主机

类型，然后单击“下一步”。



说明

当前mono支持“x86服务器”和“鲲鹏（ARM）服务器”构建，其中，“鲲鹏（ARM）服务器”当前只有华北-北京四区域支持。

3. 进入“新建编译构建任务 > 选择代码源”页面，源码仓库选择上一环节中创建的

OpenAuth代码仓库，分支选择master，然后单击“下一步”。

4. 进入“新建编译构建任务 > 选择构建模板”页面，在搜索框输入“mono”，从

筛选出来的结果中选择“mono-linux”模板，然后单击“确定”。



5. 进入“构建步骤”页面。

构建工具版本需要根据项目编译环境选择对应的.NET Core SDK版本，OpenAuth是基于.NET Core 2.X版本开发的，此处可以选“mono6-msbuild16-dotnetcoresdk2.2”或“mono6-msbuild16-dotnetcoresdk2.1”。

说明

编译命令中第6到10行是为msbuild准备的，可以根据项目具体情况进行调整。

6. 选择并配置“上传软件包到发布库”，将软件包archive.zip上传到发布库。填写基

本信息，然后单击“新建”，完成构建任务的创建。



任务构建

构建任务创建完成后，单击任务名称，进入“编译详情”页面，单击页面右上方的“执行”，开始构建，构建成功后，可以单击页面右上方的“下载构建包”，将打包好的软件包下载下来。


构建任务执行成功后，在项目下单击“构建&发布 > 发布”，进入“发布 > 软件发布库”页面。

依次单击openauth、1.0.1文件夹，再单击软件包名称，进入软件包下载页面，单击链接即可下载构建好的openauth.zip。



17.3 基于 mono 完成 dotnet 项目构建

代码准备

参考基于mono完成Msbuild项目构建-代码准备创建代码仓库，仓库创建完成后，单击仓库名称进入代码仓库详情页面。



创建 mono-dotnet 编译构建任务

1. 在项目下，单击“构建&发布 > 编译构建”，进入“编译构建”页面，然后单击“新建任务”。

2. 进入“新建编译构建任务 > 基本信息”页面，填写任务名称，选择构建环境主机

类型，然后单击“下一步”。



说明

mono支持“x86服务器”和“鲲鹏（ARM）服务器”构建，其中，“鲲鹏（ARM）服务器”目前只有华北-北京四区域支持。

3. 进入“新建编译构建任务 > 选择代码源”页面，源码仓库选择上一环节中创建的

OrchardCore代码仓库，分支选择dev，然后单击“下一步”。

4. 进入“新建编译构建任务 > 选择构建模板”页面，在搜索框输入“mono”，从

筛选出来的结果中选择“mono-linux”模板，然后单击“确定”。



5. 进入“构建步骤”页面。

构建工具版本需要根据项目编译环境选择对应的.NET Core SDK版本，OrchardCore是基于.NET Core 3.X版本开发的，此处可以选“mono6-msbuild16-dotnetcoresdk3.0”或“mono6-msbuild16-dotnetcoresdk3.1”。

说明

编译命令中第1到5行是为msbuild准备的，可以根据项目具体情况进行调整；第6到10行需要注释掉。

6. 选择并配置“上传软件包到发布库”，将软件包archive.zip上传到发布库。填写基

本信息，单击“新建”，完成构建任务的创建。



任务构建

构建任务创建完成后，单击任务名称，进入“编译详情”页面，单击页面右上方的“执行”，开始构建，构建成功后，可以单击页面右上方的下载构建包，将打包好的软件包下载下来。


构建任务执行成功后，在项目下单击“构建&发布 > 发布”，进入“发布 > 软件发布库”页面。

依次单击OrchardCore，1.0.1文件夹，再单击软件包名称，进入软件包下载页面，单击链接即可下载构建好的OrchardCore.zip。



17.4 Dotnet 编译结果制作 Docker 镜像步骤1 编写Dockerfile文件，内容如下：

FROM mcr.microsoft.com/dotnet/core/aspnet:3.0WORKDIR /appEXPOSE 80ENV ASPNETCORE_URLS http://+:80# envENV TZ=Asia/ShanghaiENV ASPNETCORE_ENVIRONMENT=$ASPNETCORE_ENVIRONMENT COPY src/OrchardCore.Mvc.Web/app .ENTRYPOINT ["dotnet", "OrchardCore.Mvc.Web.dll"]

步骤2 在代码库中将Dockerfile修改为上述内容，如图：



步骤3 在构建任务中添加“制作镜像并推送到SWR仓库”步骤。



说明

组织名称、镜像名字和镜像标签可根据实际情况填写。

步骤4 构建成功后，可到SWR上查看该镜像，并下载该镜像运行起来查看结果

----结束



18 Maven 多模块构建

背景

为方便使用，DevCloud编译构建服务提供了默认的Maven构建命令，可以解决大部分项目构建场景。但在部分大型Maven项目中，存在多个子模块，使用默认命令会构建所有模块，耗时较长，影响开发效率。本文目标即为演示在多模块构建场景下，如何优化构建速度，提高开发效率。

项目说明

本文使用的演示项目为GitHub拉取的开源项目，其中包含1个父pom与7个子模块，项目结构如下：

目录结构

编译构建佳实践 18 Maven 多模块构建


模块依赖关系

说明

为演示方便本例中假设hope-framework与hope-core为工具模块（构建产物仅作为jar包供其他模块使用），其余皆为业务模块（构建产物需要部署到服务器节点）。



优化策略

默认构建命令是直接在根目录执行，会将所有模块依次构建，终构建时长为所有模块构建总时长；基于此背景，优化策略主要可考虑如下两点：

● 每次只构建指定模块：使用 -pl -amd等参数指定构建的模块。

● 将多个模块并行构建：使用 -T 参数同时构建相互独立的多个模块。

两种策略互不影响，可根据实际情况选择同时使用；在构建命令后增加-T 4C命令即可实现并行构建，下文不再赘述，仅对策略一做详细说明。

步骤1 分析各模块依赖关系

由于多个子模块之间可能存在相互依赖关系，若只构建某个模块，可能会出现找不到依赖导致构建失败或部分变更无法同步问题，如本项目中hope-core依赖hope-framework模块，只构建指定模块可能会导致如下问题：

1. 直接构建hope-core，构建报错，提示找不到hope-framework依赖。

2. 为解决1的问题，需要再给hope-framework建立单独的构建任务，将framework发布到私有依赖库，导致大量构建任务的建立。

3. 开发A修改并发布了hope-framework，hope-core由开发B独立维护，没有同步更新，终使用了老版本产物，导致变更不同步。

因此，在调整构建任务之前，需要梳理各个模块之间的依赖关系，根据各个模块的类型针对性优化。由项目说明到模块依赖关系不难得出以下结论：

● 7个子模块全部依赖父POM hope-boot。

● 子模块hope-admin依赖hope-core、hope-core依赖hope-framework，即：hope-admin、hope-core、hope-framework，这三个模块需要依次构建。

● 子模块hope-sso-server、hope-generator、hope-quartz、hope-flyway相互独立，互不影响，可以独立构建。

步骤2 根据依赖关系确定各模块构建命令

● hope-boot（父pom）：一般改动较少，直接手工上传到私有依赖仓库即可。

● hope-framework：mvn deploy -pl hope-framework -amd ，其中，-pl 表示此次构建hope-framework模块， -amd 表示要同时构建依赖hope-framework的所有模块，deploy表示将framework发布到私有依赖库。

● hope-core：mvn deploy -pl hope-core -amd

● hope-admin：mvn package -pl hope-admin，此处admin为业务模块，无需发布到私有依赖库，使用package打包后上传到软件发布库即可。

● hope-sso-server：mvn package -pl hope-sso-server

● hope-generator：mvn package -pl hope-generator

● hope-quartz：mvn package -pl hope-quartz

● hope-flyway：mvn package -pl hope-flyway

步骤3 使用构建任务参数化功能精简构建命令

DevCloud编译构建服务提供了参数化功能，可以把构建任务中的命令、代码仓库分支等参数化，此处借助此功能，将构建的模块名等参数化，以达到精简构建命令/任务数的目的。

在步骤2中，得到了构建命令列表如下：



## 有依赖关系的三个模块mvn deploy -pl hope-framework -amdmvn deploy -pl hope-core -amdmvn package -pl hope-admin## 相互独立的四个模块mvn package -pl hope-sso-servermvn package -pl hope-generatormvn package -pl hope-quartzmvn package -pl hope-flyway

使用构建任务参数化功能，将模块名参数化，可得到如下命令：

mvn deploy -pl ${moduleName} -amdmvn package -pl ${moduleName}

即终只需建立两个构建任务分别如下：

发布工具模块到私有依赖库：



构建业务模块：



构建任务建立完成后，任意模块有变动，执行对应构建任务即可。

----结束



Documents

最佳实践 - Huawei...WebUtil项目：WebServer依赖的自研工具包，在WebServer项目pom文件中引 入，主要为演示私有依赖库使用场景。 基础镜像：以此镜像为基础，在基础镜像中添加WebServer构建包制作Docker镜

最佳实践 - Huawei...WebUtil项目：WebServer依赖的自研工具包，在WebServer项目pom文件中引入，主要为演示私有依赖库使用场景。基础镜像：以此镜像为基础，在基础镜像中添加WebServer构建包制作Docker镜