版权所有 © 华为技术有限公司 2021。 保留一切权利。
非经本公司书面许可，任何单位和个人不得擅自摘抄、复制本文档内容的部分或全部，并不得以任何形式传 播。
商标声明
和其他华为商标均为华为技术有限公司的商标。
本文档提及的其他所有商标或注册商标，由各自的所有人拥有。
注意
您购买的产品、服务或特性等应受华为公司商业合同和条款的约束，本文档中描述的全部或部分产品、服务或 特性可能不在您的购买或使用范围之内。除非合同另有约定，华为公司对本文档内容不做任何明示或默示的声 明或保证。
由于产品版本升级或其他原因，本文档内容会不定期进行更新。除非另有约定，本文档仅作为使用指导，本文 档中的所有陈述、信息和建议不构成任何明示或暗示的担保。
1 ARM 交叉编译... 1
2 使用 Maven 构建包制作 Docker 镜像...12
3 使用 Ant 构建包制作 Docker 镜像...24
4 使用 Node.js 构建包制作 Docker 镜像...30
5 基于 Python 项目制作 Docker 镜像... 37
6 基于 PHP 项目制作 Docker 镜像...41
7 基于 Go 项目制作 Docker 镜像... 51
8 使用自定义 Dockerfile 制作 Docker 镜像... 59
9 跨租户推送镜像到 SWR... 66
10 使用 Cmake 编译 C 语言程序...70
11 使用 msbuild 编译 C#语言程序... 76
12 使用 Android 构建生成 APK 并签名...82
13 使用快应用组件编译生成 RPK 并签名... 88
14 使用 Ionic 构建生成 Android 应用... 91
15 使用 PyInstaller 构建 Python 可执行程序... 98
16 使用 Gradle 构建 jar 包... 101
17 基于 mono 完成 msbuild 和 dotnet 编译的应用... 110
17.1 前提条件... 110
17.2 基于 mono 完成 msbuild 项目构建... 110
17.3 基于 mono 完成 dotnet 项目构建...117
17.4 Dotnet 编译结果制作 Docker 镜像...122
18 Maven 多模块构建...125
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:7 USER root
RUN 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 \
&& yum -y install glibc.i686 \
&& yum -y install ncurses-devel.i686 \
● 第1部分：基于官方的CentOS7为基础镜像制作arm交叉编译镜像。
● 第2部分：安装ARM交叉编译所需的软件和依赖工具。
● 第3部分：设定交叉编译环境变量。
● 第3行：需要替换成自己的GCC下载地址。
● 第11行：安装ARM交叉编译所需的软件和依赖工具的下载地址。
步骤4 上传Dockerfile到代码仓库。
完成代码上传到软件仓库，依次执行如下命令：
git add -A
git commit –m "add Dockerfile for arm cross compiler"
git push origin master
步骤5 回到代码托管服务，检查该次提交是否生效。
----结束
制作交叉编译镜像
步骤1 进入SWR容器镜像服务。
步骤2 单击页面左侧“组织管理”，在页面中单击“创建组织”按钮。
步骤3 输入组织名称“test2018”，单击“确定”按钮，完成容器组织的创建。
步骤4 创建编译任务。
1. 进入“构建&发布 > 编译构建”页面，单击“新建任务”。
– 在“基本信息”页面，任务名称填写“arm-cross-build-docker”，归属项目 默认为当前项目。
– 在“选择代码源”页面，源码源选择“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.c
git 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 -o hello
5. 单击“使用SWR公共镜像”下方的 。
输入并搜索“上传”，添加步骤“ 上传软件包到发布仓库”。
6. 填写构建包路径为“./hello”，指的是编译后生成的文件路径。
填写发布版本号和包名，单击“新建”按钮完成任务创建。
步骤3 单击页面右上角“执行”按钮，开始进行交叉编译。
待构建执行成功后，单击右上角“下载构建包”，下载构建结果。
----结束
异常处理
● 执行交叉编译报错: only accept X-Auth-Token or Authorization – 问题现象
构建报错信息如下：
– 原因分析
报错原因为自定义的docker镜像没有设置权限为公开
– 原因分析
报错原因为指定的归档包路径配置错误。
– 处理方法
查看构建任务，确定归档文件输出路径准确，并配置对应的归档路径。
如下归档文件输出为当前目录下的hello。
归档包路径要与输出路径一致。
● 历史编译归档包如何下载？
– 当前版本的构建包可以在构建页面单击“下载构建包”下载。
– 历史版本的构建包，可以单击页面上方的“构建&发布 > 发布”，进入到发 布页面下载。
● 如何进行mips平台交叉编译docker镜像制作？
Dockerfile可以参照如下内容：
FROM ubuntu:18.04 USER root
RUN 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编译构建服务提供了大量构建步骤、模板等，并通过缓存、私 有依赖库、开源镜像站等实现开箱即用编译构建体验；但由于构建场景多样化，初次 使用编译构建服务时，仍有可能会因设计不当或理解偏差、使用方式不当，导致上手 过程存在一定困难。因此，编译构建针对常见的复杂构建场景提供完整的最佳实践方 案，供初次使用编译构建服务或需要尝试复杂构建场景的用户使用。
目标
本文旨在演示如何使用编译构建服务完成Maven构建，使用构建包制作Docker镜像并 推送到SWR仓库，同时对构建过程涉及的开源镜像站、私有依赖库、缓存的使用等作 简要说明。
SWR，即容器镜像服务。SWR镜像仓库用于存储用户上传的Docker镜像，可以在构 建、部署时或其他场景使用。
项目说明
本文演示项目涉及两个Maven工程、一个基础Docker镜像及一个Dockerfile。
● WebServer项目：此次构建主项目，期望使用DevCloud构建此项目，并使用得到 的构建包制作Docker镜像，制作镜像所用Dockerfile存放于此项目根目录。
● WebUtil项目：WebServer依赖的自研工具包，在WebServer项目pom文件中引 入，主要为演示私有依赖库使用场景。
● 基础镜像：以此镜像为基础，在基础镜像中添加WebServer构建包制作Docker镜 像。
● Dockerfile：用来制作镜像。
项目构建过程如下：
本文详细描述了从准备代码仓库到构建并制作镜像、推送镜像到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组织名，参考创建组织。
----结束
上传/发布私有依赖
本节说明如何将所需私有依赖上传/发布到私有私有依赖库，使用DevCloud构建前请务 必仔细阅读以下注意事项，以避免因依赖使用不当导致后续的构建异常。
须知
私有依赖库与软件发布库属于两个概念，要注意区分：
● 软件发布库主要用于归档用以部署或其他用途的软件包。
● 私有依赖库主要用于存储供其他项目使用的工具包等，如WebUtil.jar。
● 使用时要务必注意区分，避免出现如“将依赖上传到软件发布库但是构建时无法下 载”此类场景。
此例中假设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私有包”。
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. 保存任务，执行成功后可于私有依赖库查看上传的依赖。
步骤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
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/
● Jboss： https://repository.jboss.org/nexus/content/repositories/releases/
● Jcenter： 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
须知
要在DevCloud构建使用此类仓库，该仓库必须满足以下条件：
● 仓库地址在公网（大陆）可直接访问。
● 依赖下载无需身份认证信息。
步骤6 在步骤“Maven构建”之后添加步骤“制作镜像并推送到SWR仓库”。
步骤7 配置步骤“制作镜像并推送到SWR仓库”，录入所需镜像信息。
● 仓库地址取默认值即可。
● 组织已于章节创建组织中说明。
● 镜像名称自定义，注意需要符合SWR对镜像名格式要求，此处为webserver。
● 镜像标签自定义，注意需要符合SWR对镜像名格式要求，此处为v1.1。
● 工作目录取默认当前目录即可。
● Dockerfile路径：准备好的Dockerfile已存放于WebServer项目根目录。当前构建 目录即为项目根目录，默认值“./Dockerfile”无需更改。
步骤8 保存任务并执行，最终任务详情页如下：
----结束
查看构建结果
步骤1 进入SWR镜像仓库首页，选择对应region，
步骤2 单击“我的镜像”，选择“制作镜像并推送到SWR仓库”步骤中填写的组织，即可查 看上传的镜像。
–
新建编译构建任务时，默认选择使用缓存加速构建，用户可于步骤“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/{Group ID}/{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”创建一个代码仓库。
创建出来的代码仓库的目录。
2. 编写Dockerfile
– 准备基础镜像，可使用DockerHub或SWR仓库中公开镜像，本例中使用 CentOS作为基础镜像。
– 获取构建包路径。
Ant的构建包路径在build.xml中定义，在打包的方法中，属性“destfile”定 义了生成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');
// Constants constPORT=8080;
constHOST='0.0.0.0';
// App
const app =express();
app.get('/',(req, res)=>{
res.send('Hello world\n');
});app.listen(PORT,HOST);
console.log(`Running on http://${HOST}:${PORT}`);
步骤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 Hub FROM node:12
# Create app directory WORKDIR /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 source COPY . .
EXPOSE 8080
CMD ["node","server.js"]
步骤5 新建.dockerignore。内容如下
node_modules npm-debug.log
步骤6 上传代码至代码托管服务。
进入代码托管服务，创建代码仓库nodesource，并根据指导文档完成代码上传，代码 上传完后，可进入代码仓库查看内容。
步骤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.4 RUN mkdir -p /usr/src/app
步骤3 新建编译构建任务，源码仓库本例选择DjangoDemo，模板选择“不使用模板，直接 创建”。
步骤4 添加步骤“制作镜像并推送到SWR仓库”。
步骤5 单击镜像仓库右边的链接容器镜像服务，跳转至“容器镜像服务”页面。
选择“组织管理”，创建组织“test_2018”。
步骤6 回到构建任务，配置构建步骤。选择上面步骤中创建的组织，并输入镜像名字、镜像 标签。
步骤7 保存任务并执行，任务成功构建如下：
编辑镜像为“公开”。
单击“下载指令”里的 ，可复制镜像地址进行后续使用。
----结束
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运行环境中能正常运行。
本次用于演示的项目目录结构如下：
步骤3 本地验证
本地运行效果如下：
说明
本地PHP运行环境，可以使用appserv（https://www.appserv.org/en/）等PHP集成运行环 境，需要提前安装。
步骤4 准备Dockerfile
将项目复制到镜像中，解压到“php workspace”目录，并在容器启动时将项目运行 起来 ，Dockerfile内容为：
FROM php:7.3.9-apache COPY 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 创建代码仓库
进入代码托管服务，创建代码仓库，并完成代码上传。关于如何将代码上传到云端代 码仓库，请参考代码托管帮助文档。
步骤6 创建编译构建任务
编译构建任务分为如下两部分：
● 编译PHP项目，并将项目打包上传到发布库，后续如果要在其他环境上运行的 话，可以直接下载该项目部署并运行。
● 制作包含php-apache运行环境和项目app的Docker镜像，在swarm，k8s等容器 化环境下可以直接部署并提供服务。
步骤如下：
1. 进入编译构建服务，新建任务，输入任务名称如：myphpmail-build，单击“下 一步”。
2. 源码源选择“DevCloud，”源码仓库选择上面创建的代码仓库“php-mail”，分 支选择“master”，单击“下一步”。
3. 选择推荐模板“PHP”，单击“确定”。
4. 配置步骤“PHP构建”
5. 配置步骤“上传软件包到发布库”，按照如下内容填充表单：
6. 添加步骤“制作镜像并推送到swr仓库”。
7. 参考下图编辑表单，单击“新建”按钮，完成构建任务创建 此处组织需要根据实际情况编辑表单，如myphp等。
步骤7 执行构建任务，将镜像上传到SWR。
● 单击“执行”按钮，等待构建完成。
● 构建成功，通过构建日志可以看到新的镜像坐标为“swr.cn-
north-1.myhuaweicloud.com/xxxxxx/myphpmail:v1.0.0.1”，且已经上传到SWR 仓库。
步骤9 设置镜像为公共镜像
● 登录容器镜像服务，选择“我的镜像” ，单击刚刚制作完的myphpmail镜像。
● 选中镜像版本v1.0.0.1，单击右上角“编辑”，在弹出的框中选择“公开”，单击
“确定”。
步骤10 验证镜像
找一个已安装Docker运行环境的主机。
关于如何在各个操作系统平台安装docker，请参考docker官方文档，可以看到各平台 的安装文档入口。
● 在SWR页面中按照如下操作复制镜像下载命令。
● 在Docker执行机上粘贴命令然后回车，开始下载镜像。
● 执行如下命令启动镜像：
----结束
7 基于 Go 项目制作 Docker 镜像
本文旨在演示如何使用DevCloud编译构建服务完成Go构建，使用构建包制作Docker 镜像并推送到SWR仓库。
前提条件
● 熟悉Go编程语言，了解Go的安装和Linux系统基本操作。
● 了解Docker的基本概念，环境安装和基本操作。
● 注册DevCloud帐号，了解DevCloud的基本操作。
准备代码
步骤1 在本地准备好Go项目：gomail，确保项目在Go运行环境中能正常运行。
本次用于演示的项目目录结构如下：gomail.go为go代码，static为静态网站内容，
Dockerfile为镜像打包描述文件。
步骤2 将项目复制到镜像golang:1.12中，完成项目编译，放开容器的8090端口，在容器启动 时执行gomail将项目运行起来，内容如下：
步骤3 进入代码托管服务，选择“普通新建”，创建代码仓库，并完成代码上传。关于如何 将代码上传到云端代码仓库，请参考代码托管。
----结束
创建编译构建任务
编译构建任务分为如下两部分：
● 编译Go项目，并将项目打包上传到发布库，若后续要在其他环境上运行，可以直 接下载该项目部署并运行。
● 制作包含Go运行环境和项目gomail的docker镜像，在如swarm，k8s等容器化环 境下可以直接部署并提供服务。
操作步骤如下：
步骤1 进入编译构建服务，单击“新建任务”按钮，输入任务名称“gomail-build”，单击
“下一步”。
步骤2 源码源选择“DevCloud”，源码仓库选择上面创建的代码仓库“gomail”，分支选择
“master”，单击“下一步”。
步骤3 选择推荐模板“Go”，单击“确定”
步骤4 由于Dockerfile中已经有了项目编译脚本，我们可以先完成Docker镜像制作，再完成构 建包上传发布库过程。
单击Go语言构建上方的 图标，添加步骤“制作镜像并推送到SWR仓库”。
参考下图编辑表单，其中，“组织”可根据实际自行输入，创建组织请参考创建组 织。
步骤5 配置步骤“Go语言构建”：参考下图修改命令文本框中命令（打包后清理掉源码和 Dockerfile）。
步骤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
----结束
8 使用自定义 Dockerfile 制作 Docker 镜像
背景
由于用户构建场景多样化，默认提供的构建模板镜像不完全适用于当前项目，或缺少 项目必需的依赖包、工具，导致用户每次构建时重复执行自定义的安装命令，影响编 译构建速度。为此，软件开发云编译构建针对复杂构建场景提供自定义构建环境，供 默认构建模板无法满足构建需求的用户使用。
本文以Go项目为例，假设DevCloud编译构建服务没有提供满足Go的编译环境，且项 目需要Tomcat工具。演示如何制作自定义Docker构建镜像并推送到SWR仓库，及如何 使用自定义镜像编译构建。
前提准备
步骤1 如果是初次使用软件开发云，请确认已完成准备操作，然后开始本示例。
步骤2 了解Docker的基本概念、环境安装和基本操作。关于Docker基本概念和基本操作命 令，请参考Docker官方文档。
步骤3 创建容器组织。
1. 进入SWR容器镜像服务，单击页面左侧“组织管理”，在页面中单击“创建组 织”。
2. 输入组织名称，单击“确定”，完成容器组织的创建。
----结束
制作自定义构建镜像
步骤1 制作自定义Dockerfile文件。
1. 进入构建服务，单击右上角“更多管理 > 自定义构建环境”。
2. 选择合适的基础镜像，下载Dockerfile模板
3. 编辑下载的Dockerfile文件，加入项目需要的依赖和工具。
步骤2 新建空白仓库“special-image-build”，将项目代码提交至此仓库，并上传Dockerfile 至项目根目录。
步骤3 制作镜像并推送到SWR仓库。
1. 新建构建任务“制作自定义构建环境”，源码选择在上个步骤创建的代码仓库，
模板选择“制作镜像并推送到SWR仓库”。
2. 输入必需的参数，单击“新建”按钮，完成构建任务创建。
参数说明如下：
参数 说明
组织 准备阶段创建的SWR组织，本例中为voting-sample。
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”创建代码仓库。
说明
这个仓库主要是一个maven工程，可以通过maven构建打包成一个war包，在Dockerfile中将这 个war包打包到docker镜像中。
镜像仓库环境准备
步骤1 登录镜像仓库服务，新建一个组织。
步骤2 参考指导文档获取上传镜像的用户名和密码。
须知
如果你想要上传的镜像仓库不是本租户的，你可以通过其他租户登录，参照上面链 接，获取AK/SK。
----结束
配置构建任务
步骤1 进入“编译构建”页面，新建任务。
源码仓库选择上面创建的代码仓库，构建模板选择“Maven”。
步骤2 单击“参数设置”页签，参考下图添加构建参数。
步骤3 参考下图操作添加步骤“执行Docker命令”，并删除步骤“上传软件包到软件发布 库”删除。
● push命令参数：${swrurl}$/${group}$/${imagename}:${imageversion}
须知
请勿漏掉build命令最后的“ .”。
----结束
执行构建任务
单击“执行”按钮，根据自己的需要改变构建参数的值，比如“imageversion”，每 次构建都可以用一个不同的版本号。
查看构建结果
任务执行成功后，进入镜像仓库，在“我的镜像”页面的镜像列表中即可查看生成的 docker容器。
须知
请选择和您构建任务一致的区域。
10 使用 Cmake 编译 C 语言程序
目标
本文旨在演示如何使用DevCloud编译构建服务Cmake构建C语言项目，并上传软件包 到软件发布仓库。
前提条件
● 掌握C++编程语言开发，了解gcc，make，Cmake等c语言编译工具的部署和日常 基本操作。
● 注册DevCloud帐号，了解DevCloud的基本操作。
说明
● 本文演示基于开源项目：google/leveldb，地址为: https://github.com/google/
leveldb。
● Cmake教程，可参考https://github.com/Campanula/CMake-tutorial。
● Cmake下载可在https://cmake.org/download/下载最新版本，也可以在https://
cmake.org/files/下载各种历史版本和对应源码。
操作步骤
步骤1 准备代码
1. 进入代码托管服务，单击“普通新建”旁的下拉按钮，选择“导入外部仓库”。
2. 输入源仓库路径，其他选项默认，单击“下一步”。
3. 输入代码仓库名称和描述，单击“确定”，等待仓库完成同步。
4. 代码同步完成，单击仓库名称，进入代码仓库页面。对比和github上的代码仓库 结构和内容，查看代码是否完整同步过来。
步骤2 创建CMake任务
1. 进入编译构建服务，单击“新建任务”，新建任务。
2. 填写基本信息，单击“下一步”。
3. 源码源选择“DevCloud”，源码仓库选择步骤1中创建的代码仓库“ leveldb”，
分支选则“master”，单击“下一步”。
4. 选择推荐模板“Cmake”，单击“确定”。
5. 配置步骤“CMake构建”：
– 构建工具版本选择cmake3.10.1-gcc7.3.0。
– 在命令框第四行后面添加如下两行命令，用来将编译后的结果打包成tgz包，
方便归档。
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 准备代码
1. 进入到代码托管页面，选择“导入外部仓库”。
2. 输入源仓库路径，其他选项默认，单击“下一步”。
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项目代码提交到代码仓库。
----结束
编译并生成 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”。
----结束
编译并生成 rpk 文件
步骤1 新建编译构建任务，模板选择系统模板“Quickapp”，单击“确定”开始配置。
步骤2
步骤3 配置步骤“Android快应用构建”。
根据代码实际使用的npm版本选择“工具版本”，本例中选择“10.15.3”。
须知
由于是debug签名公开的，安全性无法保证，因此一定不要使用debug签名签发正式上 线的应用。
步骤4 配置步骤“上传软件包到软件发布库”。
输入要上传到软件发布仓的构建包路径，版本号和包名。其中构建包路径默认是通配 符“./dist/*.rpk”格式，可根据自己的实际情况输入准确的路径，也可以选择默认通配 符格式，详细请参见上传软件包到软件发布库。
步骤5 单击“新建”按钮完成编译构建任务配置，执行任务即可。
----结束
14 使用 Ionic 构建生成 Android 应用
目标
本文演示如何基于开源项目hybirddemo使用DevCloud编译构建服务完成Ionic Android APP构建，并上传软件包到软件发布仓库。
前提条件
● 掌握混合编译基本概念，了解Android、NPM、Ionic、Angular、Gradle等语言和 工具的安装和基本操作
● 注册DevCloud帐号，熟悉DevCloud的基本操作。
说明
Ionic技术入门可参考： https://www.runoob.com/ionic/ionic-tutorial.html。
准备代码
步骤1 进入代码托管服务，单击“普通新建”旁的下拉按钮，选择“导入外部仓库”。
步骤2 输入源仓库路径，其他选项默认，单击“下一步”。
步骤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 -g
npm install -g ionic [email protected]
npm config set registry https://repo.huaweicloud.com/repository/npm/
npm cache clean -f
#添加android编译平台
ionic cordova platform add 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.txt
requests
步骤2 进入代码托管服务，创建代码仓库“PyInstallerDemo”，并将上一步创建的代码文件 推送至PyInstallerDemo。关于如何将代码上传到云端代码仓库，请参考代码托管帮助 文档。
步骤3 进入构建服务，创建任务。
源码仓库选择上一步中创建的“PyInstallerDemo”，构建模板选择系统模板
“PyInstaller”。
步骤4 配置步骤“PyInstaller”：参考下图编辑命令行。
步骤6 单击“创建”，完成任务创建。
步骤7 单击“执行”启动编译构建任务，待看到下图所示页面时，表示任务构建成功。
● 从日志可以看到编译成功后dist下生成了可执行程序main，执行后下面打印了豆 瓣的主页。
● 点击“下载构建包”按钮，可以把本次构建包下载到本地。
----结束
