五、在 macOS 实例上设置开发工具
要在 Amazon EC2 Mac 实例上开始开发，就像任何其他 Mac 构建服务器一样，必须安装 Xcode 等 iOS 构建工具。还有其他开源和第三方自动化工具，如 Jenkins，Fastlane 等。，它与 Xcode 集成以增加自动化并改进 iOS 开发流程。
在本章中，我们将探讨如何在亚马逊 EC2 macOS 实例上安装 Xcode、Jenkins、Fastlane 和 GitLab Runner。但是，在安装软件之前，必须有足够的存储空间，因此我们将从如何增加 macOS 实例的卷大小开始。
增加 macOS 实例宗卷大小
要安装像 Xcode 这样的 iOS 应用构建工具，必须有足够的磁盘空间。macOS 实例卷大小可以在启动时或 Mac 实例运行后修改。如果在启动时没有修改卷大小，Amazon EC2 Mac 实例提供的默认磁盘大小可能不够。
macOS 实例使用 Amazon 弹性块存储(EBS)卷。增加正在运行的 macOS 实例的存储容量包括增加所连接的 EBS 卷的容量、重新启动实例，以及使增加的磁盘空间可供使用。
在 EC2 控制台上选择 macOS 实例，可以看到实例卷大小，如图 5-1 所示。要增加卷大小，点击 EBS 卷 ID，如图 5-1 所示；这将引导您进入 EBS 控制台。
图 5-1
macOS 实例详细信息中显示的卷大小
进入卷修改页面，如图 5-2 所示。
图 5-2
选择修改卷选项
修改实例 EBS 卷大小。图 5-3 中所示的示例将卷增加到 200 GB。
图 5-3
将音量调整到所需的大小
调整正在运行的 macOS 实例的附加 EBS 卷的大小后，在重新启动之前，该卷在实例中不可见。您可以从 EC2 控制台重启 macOS 实例，如图 5-4 和 5-5 所示。
图 5-5
确认实例重新启动
图 5-4
调整宗卷大小后重新启动 macOS 实例
在调整 EBS 卷大小时，macOS 重新启动后，新的磁盘大小应该在 macOS 实例上可见，如清单 5-1 所示。
ec2-user@ip-172-31-47-239 ~ % diskutil list external physical
/dev/disk1 (external, physical):
#: TYPE NAME SIZE IDENTIFIER
0: GUID_partition_scheme *214.7 GB disk1
1: EFI EFI 209.7 MB disk1s1
2: Apple_APFS Container disk2 64.2 GB disk1s2
Listing 5-1Listing disk size
如清单 5-1 所示，新的磁盘大小是可见的，但是 APFS 容器的大小仍然较小，因此增加的磁盘空间还没有被使用。增加的磁盘大小可以变得可用，如清单 5-2 所示。
ec2-user@ip-172-31-47-239 ~ % PDISK=$(diskutil list physical external | head -n1 | cut -d" " -f1)
ec2-user@ip-172-31-47-239 ~ % APFSCONT=$(diskutil list physical external | grep "Apple_APFS" | tr -s " " | cut -d" " -f8)
ec2-user@ip-172-31-47-239 ~ % yes | sudo diskutil repairDisk $PDISK
Repairing the partition map might erase disk1s1, proceed? (y/N) Started partition map repair on disk1
Checking prerequisites
Listing 5-2Repairing disk and making increased size usable
修复之后，最后一步是调整苹果 APFS 容器的大小，如清单 5-3 所示。
ec2-user@ip-172-31-47-239 ~ % sudo diskutil apfs resizeContainer $APFSCONT 0
Started APFS operation
Aligning grow delta to 150,323,855,360 bytes and targeting a new physical store size of 214,538,608,640 bytes
Determined the maximum size for the targeted physical store of this APFS Container to be 214,537,580,544 bytes
Listing 5-3Resizing APFS container size
设置 Xcode
Xcode 可以从 App Store 手动安装在 macOS 实例上，正如第一章所讨论的。安装 Xcode 后，要开始使用 Xcode，您必须接受 Xcode 和 iOS SDK 许可协议，如图 5-6 所示。
图 5-6
Xcode 和 iOS SDK 许可协议
如果提示输入密码以授予 Xcode 权限，请输入您的用户密码。如果使用默认的 ec2 用户，这是为用户创建的用户密码，如第四章所述。
一旦 Xcode 准备好使用，它应该会进入它的欢迎页面，如图 5-7 所示。
图 5-7
Xcode 欢迎页面
Xcode 命令行工具
从 App Store 安装 Xcode 时，它的命令行工具也会被安装，无需任何进一步操作。可以从命令终端验证安装，如清单 5-4 所示。
ec2-user@ip-172-31-47-239 ~ % xcode-select --install
xcode-select: error: command line tools are already installed, use "Software Update" to install updates
ec2-user@ip-172-31-47-239 ~ % xcodebuild
Command line invocation:
/Applications/Xcode.app/Contents/Developer/usr/bin/xcodebuild
User defaults from command line:
IDEPackageSupportUseBuiltinSCM = YES
xcodebuild: error: The directory /Users/ec2-user does not contain an Xcode project
.
ec2-user@ip-172-31-47-239 ~ % xcodebuild -version
Xcode 12.5.1
Build version 12E507
Listing 5-4Verifying Xcode command line tools installation
陷害 Jenkins
Jenkins 是一个开源的自动化和应用构建工具。它与各种其他工具相集成，这使得它适用于各种类型的构建和自动化。Jenkins 支持分布式构建；通过使用并行运行作业的代理，可以为每个生成项目使用不同的生成环境。
这些代理由控制器控制，控制器是配置和调度所有构建作业的主要 Jenkins 节点。代理可以是与控制器相同类型的环境，在控制器中调度作业以平衡工作负载，也可以是与主控制器不同的环境，在主控制器中，基于正在构建的应用所需的构建环境在代理上调度作业。
让我们在接下来的两节中探索如何在 Amazon EC2 实例上的 Linux 环境中配置 Jenkins 控制器，以及如何使用 macOS 构建代理来构建 iOS 应用。
供应 Jenkins 控制器
控制器将在 Amazon EC2 Linux 实例上提供，因此，首先，必须从 EC2 控制台创建一个 EC2 实例，如图 5-8 所示。
图 5-8
从 EC2 控制台启动 Amazon EC2 实例
选择适用 AWS 地区的最新 Amazon Linux Amazon Machine Image(AMI)，如图 5-9 所示。
图 5-9
选择最新的亚马逊 Linux AMI
选择实例类型，并根据需要配置实例和存储容量。对于安全组，需要 SSH (TCP 端口 22)访问来启用对 Jenkins 服务器的访问。Jenkins 还在 TCP 端口 8080 上提供流量，因此这必须在安全组中得到允许。安全组配置示例如图 5-10 所示。这些规则可以通过工作站的源 IP 地址进一步限制。
图 5-10
配置安全组规则
在实例启动之后，下一步是通过 SSH 登录实例，安装 Jenkins 软件。
因为提供了 Amazon Linux EC2 实例，所以将使用 yum package manager 来安装 Jenkins。类似地，其他操作系统中的包管理器可以用来在那些操作系统上安装 Jenkins。
首先，执行实例上所有包的快速软件更新，如清单 5-5 所示。
[ec2-user ~]$ sudo yum update
Listing 5-5Updating software packages
更新软件包后，可以将 Jenkins repo 添加到 yum 中，如清单 5-6 所示。
[ec2-user ~]$ sudo wget -O /etc/yum.repos.d/jenkins.repo \
https://pkg.jenkins.io/redhat-stable/jenkins.repo
Listing 5-6Adding Jenkins to yum repo
接下来是导入 RPM 的密钥文件来验证包。这显示在清单 5-7 中。
[ec2-user ~]$ sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io.key
[ec2-user ~]$ sudo yum upgrade
Listing 5-7Import rpm key file to verify package
然后可以安装 Jenkins，如清单 5-8 所示。
[ec2-user ~]$ sudo yum install jenkins java-1.8.0-openjdk-devel -y
[ec2-user ~]$ sudo systemctl daemon-reload
Listing 5-8Installing Jenkins
安装后，Jenkins 可以作为服务启动，如清单 5-9 所示。
[ec2-user ~]$ sudo systemctl start jenkins
Listing 5-9Starting Jenkins as a service
如清单 5-10 所示，可以检查 Jenkins 状态。
[ec2-user ~]$ sudo systemctl status jenkins
Listing 5-10Checking Jenkins status
最初设置 Jenkins 时，需要一个初始管理员密码。如清单 5-11 所示，可以检索该密码。
[ec2-user ~]$ sudo cat /var/lib/jenkins/secrets/initialAdminPassword
Listing 5-11Retriving initial Admin Password
要通过管理界面首次访问您的 Jenkins 服务器，请从您的网络浏览器连接到http://<your_server_public_DNS>:8080。初始设置页面如图 5-11 所示。输入取回的初始密码，如清单 5-11 所示。
图 5-11
Jenkins 初始设置页面
为了支持不同类型的应用和工具，Jenkins 使用插件来扩展其功能。在 Jenkins 初始设置期间，您可以选择安装特定的插件，或者安装建议的插件，如图 5-12 所示。
图 5-12
安装 Jenkins 插件
还必须创建一个初始的管理员用户来验证 Jenkins。初始管理员用户的设置如图 5-13 所示。
图 5-13
创建初始管理员用户
在安装了所有插件并设置了初始管理员用户之后，Jenkins 就可以开始创建作业和注册构建代理了。全新的 Jenkins 安装欢迎页面如图 5-14 所示。
图 5-14
Jenkins 欢迎页面
EC2 Mac 实例作为 Jenkins 构建代理
创建 Jenkins 控制器后，您可以为分布式生成设置生成代理。要构建 iOS 应用，必须存在 macOS 构建代理。让我们探索如何通过 SSH 将 EC2 Mac 实例作为构建代理添加到 Jenkins 控制器中。
要添加 Jenkins 构建代理，必须安装 Java。清单 5-12 展示了如何在 EC2 Mac 上安装带有 Homebrew 的 Java 开发工具包。
ec2-user@ip-172-31-47-239 ~ % su ec2-user -c '/usr/local/bin/brew install openjdk@8'
Password:
Updating Homebrew...
==> Auto-updated Homebrew!
Updated 1 tap (homebrew/core).
==> Updated Formulae
Updated 20 formulae.
==> Downloading https://ghcr.io/v2/homebrew/core/libpng/manifests/1.6.37
######################################################################## 100.0%
.
.
.
.
.
==> Installing dependencies for openjdk@8: libpng and freetype
==> Installing openjdk@8 dependency: libpng
Listing 5-12Installing OpenJDK on EC2 Mac
在用 Homebrew 安装 OpenJDK 之后，为它创建一个符号链接并验证安装，如清单 5-13 所示。
sh-3.2# ln -sfn /usr/local/opt/openjdk@8/libexec/openjdk.jdk /Library/Java/JavaVirtualMachines/openjdk-8.jdk
sh-3.2# java -version
openjdk version "1.8.0_282"
OpenJDK Runtime Environment (build 1.8.0_282-bre_2021_01_20_16_06-b00)
OpenJDK 64-Bit Server VM (build 25.282-b00, mixed mode)
Listing 5-13Create symlink for OpenJDK and verify Installation
安装 Java 之后，下一个需求是创建一个 Jenkins 用户并为该用户设置 SSH 访问。Jenkins 控制器将使用该用户通过 SSH 连接到 macOS 构建代理，以提交构建作业。您可以创建一个新的 Jenkins 用户，如清单 5-14 所示。
sh-3.2# sysadminctl -addUser jenkins
2021-07-10 19:50:42.793 sysadminctl[6437:155160] --------------
2021-07-10 19:50:42.793 sysadminctl[6437:155160] No clear text password or interactive option was specified (adduser, change/reset password will not allow user to use FDE) !
2021-07-10 19:50:42.793 sysadminctl[6437:155160] --------------
2021-07-10 19:50:42.970 sysadminctl[6437:155160] Creating user record...
2021-07-10 19:50:43.043 sysadminctl[6437:155160] Assigning UID: 503 GID: 20
2021-07-10 19:50:43.076 sysadminctl[6437:155160] Creating home directory at /Users/jenkins
Listing 5-14Creating Jenkins user
创建用户后，您可以设置一个新的密钥，或者在 macOS 实例上重用现有的默认 ec2-user 密钥。清单 5-15 展示了如何对新的 Jenkins 用户重用默认的 ec2 用户 SSH 凭证。
sh-3.2# mkdir /Users/jenkins/.ssh/
sh-3.2# cp -a /Users/ec2-user/.ssh/. /Users/jenkins/.ssh/
sh-3.2# cp /Users/ec2-user/.ssh/* /Users/jenkins/.ssh/.
sh-3.2# chown -R jenkins /Users/jenkins/.ssh
sh-3.2# chmod 700 /Users/jenkins/.ssh
sh-3.2# chmod 600 /Users/jenkins/.ssh/authorized_keys
Listing 5-15Setting up SSH keys for Jenkins user
接下来，让我们确保 Jenkins 控制器可以通过 SSH 从安全组访问 EC2 Mac 实例。
如图 5-15 所示，为 Jenkins 控制器实例的/32 私有 IP 地址配置 TCP 端口 22 访问。使用私有 IP 地址是因为 Jenkins 控制器和 EC2 Mac 实例位于同一个虚拟私有云(VPC)中。如果它们在不同的 VPC 中，并且 Jenkins 控制器将通过互联网与 Mac 实例连接，您将添加 Jenkins 控制器的公共 IP 地址。
图 5-15
EC2 Mac 实例的安全组配置
安装了 Java、创建了 Jenkins 用户、设置了 SSH 访问并配置了安全组之后，就可以添加 EC2 macOS 实例作为构建节点了。
在 Jenkins 用户界面上，选择“管理 Jenkins”选项，然后选择“管理节点和云”，如图 5-16 所示。
图 5-16
管理 Jenkins 选项
启动添加新节点的流程，并为节点提供名称，如图 5-17 所示。
图 5-17
添加新的 Jenkins 节点
将配置节点的连接信息，包括节点的 IP 地址、启动方法、标签、节点的凭证等。该标签是在生成作业中配置的，控制器使用它来标识要在其上调度特定作业的生成代理。图 5-18 显示了使用 SSH 启动方法和 iOS 标签的节点配置示例。
SSH 凭证必须单独配置。凭据可以预先创建，也可以在添加节点时创建。图 5-18 显示了如何在配置构建节点时添加新凭证。
图 5-18
为 Jenkins 节点配置新凭据
要添加 SSH 凭证，您需要提供 Jenkins 用户名和 SSH 私有密钥。要获取私钥内容，请打开为 Jenkins 用户 SSH 访问配置的私钥文件。
- 在本例中，与清单 5-15 中配置的相同的 SSH 私有密钥用于 ec2-user 和 Jenkins 用户，因此从您的工作站检索该私有密钥的内容。
图 5-19 显示了配置 SSH 凭证的示例。
图 5-19
在 Jenkins 中配置 SSH 凭证
可以为节点配置路径变量等环境变量，如图 5-20 所示。
图 5-20
为节点配置环境变量
保存新节点的配置。在图 5-18 中，主机密钥验证被配置为手动信任，因此在保存新节点配置后，Jenkins 控制器尝试通过 SSH 连接到构建代理，并且在 Jenkins 节点的左侧选项中显示提示，请求信任 Jenkins 控制器；选择此项以允许继续连接。
您可以在 Jenkins 上查看控制台输出，以查看状态并了解它的运行情况。列表 5-16 显示了一个成功添加代理的控制台输出示例。
[07/11/21 17:31:16] [SSH] Checking java version of java
[07/11/21 17:31:16] [SSH] java -version returned 1.8.0_282.
[07/11/21 17:31:16] [SSH] Starting sftp client.
[07/11/21 17:31:16] [SSH] Copying latest remoting.jar...
[07/11/21 17:31:16] [SSH] Copied 1,502,119 bytes.
Expanded the channel window size to 4MB
[07/11/21 17:31:16] [SSH] Starting agent process: cd "/Users/Jenkins" && java -jar remoting.jar -workDir /Users/Jenkins -jar-cache /Users/Jenkins/remoting/jarCache
Jul 11, 2021 5:31:17 PM org.jenkinsci.remoting.engine.WorkDirManager initializeWorkDir
INFO: Using /Users/Jenkins/remoting as a remoting work directory
Jul 11, 2021 5:31:17 PM org.jenkinsci.remoting.engine.WorkDirManager setupLogging
INFO: Both error and output logs will be printed to /Users/Jenkins/remoting
<===[JENKINS REMOTING CAPACITY]===>channel started
Remoting version: 4.7
This is a Unix agent
Evacuated stdout
Agent successfully connected and online
Listing 5-16Output snippet of adding Jenkins agent
添加一个构建节点后，它会出现在节点列表中，如图 5-21 所示。
图 5-21
Jenkins 建立节点
建立 Fastlane
Fastlane 是一个开源自动化工具，用于自动化移动应用开发。它自动化了构建 iOS 应用的所有方面，从开发到发布到应用商店。其主要特点是
-
在 App Store 中使用的自动化屏幕截图
-
自动化测试版部署
-
应用商店部署
-
代码签名
Fastlane 可以与 Jenkins 集成，为 iOS 应用开发创建完整的端到端持续集成持续交付(CICD)流程。
Fastlane 可以使用自制软件简单地安装在 macOS 工作站上，如清单 5-17 所示。
ec2-user@ip-172-31-47-239 ~ % brew install fastlane
Updating Homebrew...
==> Auto-updated Homebrew!
Updated 2 taps (homebrew/core and homebrew/cask).
==> Updated Formulae
Updated 52 formulae.
==> Updated Casks
Updated 13 casks.
.
.
.
.
.
==> Installing fastlane
==> Pouring fastlane--2.187.0.big_sur.bottle.1.tar.gz
Listing 5-17Fastlane installation output snippet
安装后，您可以验证安装并开始使用 Fastlane。清单 5-18 中显示了启动 Fastlane 的示例和输出示例。
**清单 5-18。**从 Fastlane 出发
设置 GitLab
GitLab 是一个 DevOps 平台，它提供了许多特性来提高软件开发过程中的灵活性。其中的一些特性包括用于管理源代码的 git repository manager、持续集成以及用于自动构建和部署应用的部署管道等。
对于其持续集成和部署特性，它使用 GitLab runner。GitLab Runner 是一个与 GitLab CICD 协同工作的应用，用于在管道中运行作业。GitLab Runner 应用可以安装在单独的基础设施和操作系统上，这取决于 Runner 将要执行的工作。
GitLab Runner 也可以安装在 macOS 上运行 iOS 相关的作业，那么我们就来探讨一下如何设置 GitLab，在 macOS EC2 实例上安装一个 GitLab Runner。
创建 GitLab 项目
要开始使用 GitLab，您必须注册一个 GitLab 帐户。可以在 https://gitlab.com/ 上免费报名。然后，创建一个如图 5-22 所示的项目。
图 5-22
创建 GitLab 项目
接下来，您可以选择如何创建项目，如图 5-23 所示，您可以创建一个空白项目或使用一个模板，该模板会用文件预先填充您的项目。
图 5-23
选择项目初始配置
配置项目名称、URL 和可见性级别(私有或公共)。图 5-24 显示了一个示例项目配置。
图 5-24
配置和创建 GitLab 项目
设置 macOS GitLab Runner
当您创建 GitLab 项目时，会为项目创建一个存储库，您可以访问许多 DevOps 特性，其中包括 CICD。要设置可以构建 iOS 应用的 GitLab CICD 管道，必须设置一个 macOS GitLab 运行程序。
项目的 GitLab Runner 配置可以在项目设置中进入，如图 5-25 所示。
图 5-25
GitLab 项目 CICD 设置
要在 macOS 实例上注册 GitLab runner，需要 GitLab 位置的 URL 和唯一的注册令牌。在项目 CICD 设置中展开滑道即可找回两者，如图 5-26 所示。
图 5-26
GitLab Runner 注册令牌和 URL
GitLab Runner 以二进制形式提供。您可以下载二进制文件并在 macOS 实例上提供适当的权限，如清单 5-19 所示。
ec2-user@ip-172-31-47-239 ~ % sudo curl --output /usr/local/bin/gitlab-runner "https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-darwin-amd64"
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 53.0M 100 53.0M 0 0 92.6M 0 --:--:-- --:--:-- --:--:-- 92.4M
ec2-user@ip-172-31-47-239 ~ % sudo chmod +x /usr/local/bin/gitlab-runner
Listing 5-19Download GitLab Runner binary for macOS
现在您可以注册跑步者，如清单 5-20 所示。注册是一个交互式操作，您需要提供注册令牌、GitLab URL、跑步者描述等。
ec2-user@ip-172-31-47-239 ~ % gitlab-runner register
Runtime platform arch=amd64 os=darwin pid=4212 revision=c1edb478 version=14.0.1
WARNING: Running in user-mode.
WARNING: Use sudo for system-mode:
WARNING: $ sudo gitlab-runner...
Enter the GitLab instance URL (for example, https://gitlab.com/):
https://gitlab.com/
Enter the registration token:
nxxxxxxxxxxxxxxi
Enter a description for the runner:
[ip-172-31-47-239.ec2.internal]: mac os runner
Enter tags for the runner (comma-separated):
Registering runner... succeeded runner=nYR2beCG
Enter an executor: custom, docker, parallels, docker-ssh, shell, ssh, virtualbox, docker+machine, docker-ssh+machine, kubernetes:
shell
Runner registered successfully. Feel free to start it, but if it's running already the config should be automatically reloaded!
Listing 5-20GitLab Runner registration
成功的转轮注册不会安装转轮，您必须单独安装转轮。清单 5-21 展示了如何安装和启动 GitLab Runner。
ec2-user@ip-172-31-47-239 ~ % gitlab-runner install
Runtime platform arch=amd64 os=darwin pid=4237 revision=c1edb478 version=14.0.1
ec2-user@ip-172-31-47-239 ~ % gitlab-runner start
Runtime platform arch=amd64 os=darwin pid=4240 revision=c1edb478 version=14.0.1
Listing 5-21Installing and starting GitLab Runner
一旦安装了 GitLab Runner，您就可以开始从 GitLab CICD 管道向这个 Runner 调度作业。要验证 runner 是否已注册到您的 GitLab 项目并准备好接收作业，请确保您可以在 GitLab 项目的 runner 列表中看到注册的 macOS runner。图 5-27 显示了在 GitLab 上注册为 runner 的 macOS 实例。
图 5-27
在 GitLab 上查看注册的 macOS runner
- 关于设置 GitLab CICD 管道的更多信息，见
https://docs.gitlab.com/ee/ci/pipelines/index.html。
摘要
设置 iOS 应用开发环境需要安装不同的软件，如 iOS 专用的 Xcode 和其他第三方及开源工具。我们已经介绍了在 macOS Amazon EC2 实例上安装和设置所有这些工具，以便为开发做好准备。
六、使用 AWS CodeCommit 的源代码管理
正如第三章所讨论的，AWS CodeCommit 是一个托管的私有 Git 库。当交互和使用 CodeCommit 时，您使用标准的 Git 工具，所有标准的 Git 概念和特性都适用。
在本章中，我们将深入探讨如何使用 AWS CodeCommit 进行源代码管理，首先是如何连接到 CodeCommit 存储库以添加源代码，以及诸如拉请求、分支等功能是如何实现的。，工作。
在开始使用 AWS CodeCommit 之前，让我们回顾一下基本的 Git 基础知识。
Git 基础
Git 是一个开源的版本控制系统。它跟踪您对启用它的目录中的文件所做的更改，这允许您在任何时间点恢复到文件的任何版本。它还使协作变得容易，因为它允许将不同人对文件所做的更改合并到一个文件中。
Git 安装
所有主要平台的 Git 客户端都可以从 Git 网站下载，如图 6-1 所示。
图 6-1
Git 客户端下载
- 下载网站可在
https://git-scm.com/downloads访问。
对于不同的操作系统，可以使用软件包管理器从命令行下载它。清单 6-1 分别展示了如何为 macOS 和 Debian/Ubuntu 系统安装 Git。
macOS
$ brew install git
Debian/Ubuntu
$ apt-get install git
Listing 6-1Git installation with package managers
初始化 Git 存储库
一旦安装了 Git，要在目录中启用 Git，必须对它进行初始化。在一个目录中初始化 Git 意味着您希望它启动版本控制并开始跟踪该目录中的所有更改。Git 可以在目录中初始化，如清单 6-2 所示。
$ git init
Initialized empty Git repository in /home/cloudshell-user/git-diretory/.git/
$ git status
On branch master
No commits yet
nothing to commit (create/copy files and use "git add" to track)
Listing 6-2Initializing Git repository and checking Git status
记录对 Git 存储库的更改
如清单 6-2 所示，在 Git 初始化的目录中没有 Git 要跟踪的文件，因为它是一个空目录。新文件被添加到目录中，如清单 6-3 所示。
$ touch file1 file2 file3
$ git status
On branch master
No commits yet
Untracked files
:
(use "git add <file>..." to include in what will be committed)
file1
file2
file3
nothing added to commit but untracked files present (use "git add" to track)
Listing 6-3Adding new files and checking Git status
文件被添加到目录中，但不是为了 Git 开始跟踪而添加的。为了让 Git 开始跟踪这些新文件，首先应该如清单 6-4 所示进行修改。
$ git add .
$ git status
On branch master
No commits yet
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file: file1
new file: file2
new file: file3
Listing 6-4Staging changes and checking Git status
在变更被暂存之后，Git 开始跟踪这些文件的最后一步是提交变更。如果这是你第一次使用 Git，你必须如清单 6-5 所示配置你的名字和邮箱。向 Git 提交文件时，必须提供注释来描述正在提交的更改；这提供了-m标志，如清单 6-5 所示。
$ git config --global user.name "Enter Your Name"
$ git config --global user.email "Enter Your Email"
$ git commit -m "Add files"
[master (root-commit) 6ebb411] Add files
3 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 file1
create mode 100644 file2
create mode 100644 file3
$ git status
On branch master
nothing to commit, working tree clean
Listing 6-5Committing changes and checking Git status
克隆和使用远程 Git 存储库
有时，您已经有一个现有的项目存储在一个远程 Git 存储库中，如 GitHub、GitLab、AWS CodeCommit 等。，你想在本地工作。为此，您可以通过克隆来本地下载存储库。在本地克隆了存储库之后，您可以对文件进行更改，并通过前面描述的 Git 生命周期来开始跟踪您的更改。
清单 6-6 显示了一个克隆存储库的例子。在这里，我克隆了公共 AWS CLI GitHub 存储库。要克隆您拥有的私有存储库，系统会提示您进行身份验证。
$ git clone https://github.com/aws/aws-cli.git
Cloning into 'aws-cli'...
remote: Enumerating objects: 84578, done.
remote: Counting objects: 100% (790/790), done.
remote: Compressing objects: 100% (246/246), done.
remote: Total 84578 (delta 556), reused 763 (delta 543), pack-reused 83788
Receiving objects: 100% (84578/84578), 53.34 MiB | 20.19 MiB/s, done.
Resolving deltas: 100% (57974/57974), done.
Listing 6-6Cloning remote Git repository
在本地克隆远程存储库后，本地存储库会自动配置为指向远程存储库，以便将来进行同步操作。例如，如果远程存储库中有更新，本地存储库可以提取这些更改以与本地存储库合并，或者如果本地存储库中有更改，则需要推送这些更改以更新远程存储库。
清单 6-7 展示了如何查看为本地存储库配置的远程存储库，如何通过拉和推操作来保持本地和远程存储库同步，以及如何为本地存储库配置不同名称的其他远程存储库。Git 为远程存储库使用的默认简称是 origin，并且配置了一个新的远程存储库 origin2，如清单 6-7 所示。
$ cd aws-cli/
$ git remote -v
origin https://github.com/aws/aws-cli.git (fetch)
origin https://github.com/aws/aws-cli.git (push)
$ git pull origin
Already up to date.
$ git push origin master
$ git remote add origin2 https://github.com/aws/aws-cli.git
$ git remote -v
origin2 https://github.com/aws/aws-cli.git (fetch)
origin2 https://github.com/aws/aws-cli.git (push)
origin https://github.com/aws/aws-cli.git (fetch)
origin https://github.com/aws/aws-cli.git (push)
Listing 6-7Listing remote repositories and configuring a new remote repository
Git 分支
在 Git 中，分支是指向提交的指针。它用于分离正在进行的文件工作，并维护 Git 存储库的独立并发版本。如果一个文件存在于多个分支上，则在一个分支上对此文件所做的更改不会影响另一个分支中的同一文件。分支通常用于开发新特性，存储来自特定提交的项目的特定版本，等等。
在新的 Git 存储库中，当您创建第一个提交时，会为您创建一个默认分支。可以创建附加分支来跟踪项目的不同版本。
拉取请求
拉请求允许您和存储库中的其他用户从一个分支到另一个分支查看、添加注释和合并代码更改。Pull requests 是多个存储库用户协作的一种方式，在应用的新版本发布之前，通过检查代码更改和修复 bug 来实现。
一个典型的例子是，当您有一个主 Git 分支，其中包含您的应用的生产部署版本，而新功能是在单独的功能分支中开发的。当功能分支中的功能准备好进行生产部署时，拉请求允许团队成员在将功能分支合并到主分支之前检查新功能的代码更改或添加。
创建 AWS 代码提交存储库
在第三章中，介绍了 AWS CodeCommit，我介绍了如何在 AWS 管理控制台上创建 CodeCommit 存储库。在本章中，我们将更深入地了解创建 CodeCommit 存储库的各种方法，如 AWS 命令行界面(CLI)、CloudFormation、Terraform 和 AWS SDK。
使用 AWS 命令行界面(CLI)创建
必须首先安装和配置 AWS CLI。要开始使用 AWS CLI，必须使用有权执行预期操作的凭据进行配置。清单 6-8 展示了如何配置 AWS CLI 和一个示例输出。
- 可以参考
https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html的 AWS 文档进行安装。
$ aws configure
AWS Access Key ID [None]:
AWS Secret Access Key [None]:
Default region name [None]:
Default output format [None]:
Listing 6-8Configuring AWS CLI
配置 AWS CLI 环境后，可以创建一个带有示例输出的 CodeCommit 存储库，如清单 6-9 所示。
$ aws codecommit create-repository --repository-name devops-ios-repository --repository-description "Example Description"
{
"repositoryMetadata": {
"accountId": "123456789101",
"repositoryId": "abcdedgh-6234-457b-b2c3-184babcdefgh",
"repositoryName": "devops-ios-repository",
"repositoryDescription": "Example Description",
"lastModifiedDate": "2021-08-14T21:20:03.893000+00:00",
"creationDate": "2021-08-14T21:20:03.893000+00:00",
"cloneUrlHttp": "https://git-codecommit.us-east-1.amazonaws.com/v1/repos/devops-ios-repository",
"cloneUrlSsh": "ssh://git-codecommit.us-east-1.amazonaws.com/v1/repos/devops-ios-repository",
"Arn": "arn:aws:codecommit:us-east-1:123456789101:devops-ios-repository"
}
}
Listing 6-9Creating a CodeCommit repository with AWS CLI
使用 AWS CloudFormation 创建
要使用 CloudFormation 创建 CodeCommit 存储库，可以如清单 6-10 所示定义 CloudFormation 模板。
AWSTemplateFormatVersion: "2010-09-09"
Parameters:
RepositoryName:
Type: String
Default: devops-ios-repository
Description: Name of the CodeCommit Repository
Resources:
MyRepo:
Type: AWS::CodeCommit::Repository
Properties:
RepositoryName: !Ref RepositoryName
RepositoryDescription: Example Description
Listing 6-10CloudFormation template to create CodeCommit repository
如清单所示，CloudFormation 模板是 YAML 格式的，只包含一个 CodeCommit 资源。可以用这些 YAML 内容创建云形成堆栈，如图 6-2 所示。
图 6-2
使用 CloudFormation 创建 CodeCommit 知识库
存储库名称是参数化的，如清单 6-10 所示；默认名称在模板中定义，但可以修改。该参数可以在堆栈详情页面进行修改，如图 6-3 所示。
图 6-3
配置代码提交存储库的名称
图 6-4 显示了处于 CREATE_COMPLETE 状态的 CloudFormation 堆栈，这表示 CodeCommit 存储库已经创建。resources 选项卡显示了由 CloudFormation 堆栈创建的资源列表。
图 6-4
CodeCommit 云信息堆栈已创建
在 CodeCommit 控制台中可以看到创建的 CodeCommit 存储库，如图 6-5 所示。
图 6-5
代码提交存储库已创建
使用 Terraform 创建
必须首先参考 Terraform 官方文档安装和配置 Terraform。用于 CodeCommit 存储库创建的 Terraform 代码可以如清单 6-11 所示进行定义。
provider "aws" {
region = "us-east-1"
}
resource "aws_codecommit_repository" "test" {
repository_name = "devops-ios-repository"
description = "Example Description"
}
Listing 6-11Terraform code to create CodeCommit repository
代码应该保存在一个带有。tf 文件扩展名，并保存在专用的 Terraform 目录中，以用于预期的操作。在专用目录中，可以初始化 Terraform，如清单 6-12 所示。这里显示的操作下载了 Terraform 脚本中定义的资源所需的所有插件。
$ terraform init
Initializing the backend...
Initializing provider plugins...
- Finding latest version of hashicorp/aws...
- Installing hashicorp/aws v3.54.0...
- Installed hashicorp/aws v3.54.0 (signed by HashiCorp)
Terraform has created a lock file .terraform.lock.hcl to record the provider selections it made above. Include this file in your version control repository so that Terraform can guarantee to make the same selections by default when you run "terraform init" in the
future.
Terraform has been successfully initialized!
...........................
...........................
Listing 6-12Initializing Terraform directory
您可以选择性地运行清单 6-13 中所示的terraform plan来查看 Terraform 将在您的 AWS 帐户中执行的操作，即创建、删除或修改资源。
$ terraform plan
Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
+ create
Terraform will perform the following actions:
# aws_codecommit_repository.test will be created
+ resource "aws_codecommit_repository" "test" {
+ arn = (known after apply)
+ clone_url_http = (known after apply)
+ clone_url_ssh = (known after apply)
+ description = "Example Description"
+ id = (known after apply)
+ repository_id = (known after apply)
+ repository_name = "devops-ios-repository"
+ tags_all = (known after apply)
}
Plan: 1 to add, 0 to change, 0 to destroy.
Listing 6-13Terraform plan to see the actions Terraform will perform
初始化 Terraform 目录后，一旦您对清单 6-13 中所示的 Terraform 将采取的行动感到满意，就可以通过应用清单 6-14 中所示的 Terraform 脚本来创建资源。
$ terraform apply
Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
+ create
Terraform will perform the following actions:
# aws_codecommit_repository.test will be created
+ resource "aws_codecommit_repository" "test" {
+ arn = (known after apply)
+ clone_url_http = (known after apply)
+ clone_url_ssh = (known after apply)
+ description = "Example Description"
+ id = (known after apply)
+ repository_id = (known after apply)
+ repository_name = "devops-ios-repository"
+ tags_all = (known after apply)
}
Plan: 1 to add, 0 to change, 0 to destroy.
Do you want to perform these actions?
Terraform will perform the actions described above.
Only 'yes' will be accepted to approve.
Enter a value: yes
aws_codecommit_repository.test: Creating...
aws_codecommit_repository.test: Creation complete after 0s [id=devops-ios-repository]
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
Listing 6-14Applying Terraform script to create CodeCommit repository
使用 Python Boto3 SDK 创建
AWS 拥有针对不同编程语言的 SDK，使您能够使用自己喜欢的开发语言来管理和访问 AWS 服务。这里我将重点介绍名为 boto3 的 AWS Python SDK。要了解 boto3 SDK 的更多信息，请访问这里的官方文档: https://boto3.amazonaws.com/v1/documentation/api/latest/index.html 。
在安装 boto3 之前，您的工作站上需要 Python。假设安装了 Python，清单 6-15 展示了如何使用pip在工作站上安装 boto3。
- 参考
https://pip.pypa.io/en/stable/installation/安装 pip。
$ pip install boto3
Listing 6-15Installing boto3
清单 6-16 中显示了一个使用 boto3 创建 CodeCommit 存储库的示例 Python 脚本。
import boto3
client = boto3.client('codecommit')
response = client.create_repository(
repositoryName='devops-ios-repository',
repositoryDescription='Example Description'
)
print(response
Listing 6-16Python script to create CodeCommit repository
在 boto3 可以创建资源之前，工作站必须配置有 AWS 凭证。可以用 AWS CLI 配置凭证，如清单 6-8 所示。
一旦工作站配置了 AWS 凭证，就可以执行 Python 脚本，如清单 6-17 所示。
- 有关下载 Python 的信息，请参考
www.python.org/downloads。
$ python codecommit.py
{
u'repositoryMetadata': {
u'repositoryName': u'devops-ios-repository',
u'cloneUrlSsh': u'ssh://git-codecommit.us-east-1.amazonaws.com/v1/repos/devops-ios-repository',
u'lastModifiedDate': datetime.datetime(2021, 8, 14, 21, 53, 50, 718000, tzinfo=tzlocal()),
u'repositoryDescription': u'Example Description',
u'cloneUrlHttp': u'https://git-codecommit.us-east-1.amazonaws.com/v1/repos/devops-ios-repository',
u'creationDate': datetime.datetime(2021, 8, 14, 21, 53, 50, 718000, tzinfo=tzlocal()),
u'repositoryId': u'3cd590f1-b898-43d7-b82c-eac6aef602a1',
u'Arn': u'arn:aws:codecommit:us-east-1:123456789101:devops-ios-repository',
u'accountId': u'123456789101'
},
'ResponseMetadata': {
'RetryAttempts': 0,
'HTTPStatusCode': 200,
'RequestId': 'ff463517-219e-4d51-869f-fba5b1345c76',
'HTTPHeaders': {
'x-amzn-requestid': 'abcdefgh-219e-4d51-869f-fba5abcdefgh',
'date': 'Sat, 14 Aug 2021 21:53:50 GMT',
'content-length': '519',
'content-type': 'application/x-amz-json-1.1'
}
}
}
Listing 6-17Running Python script to create CodeCommit repository
在 AWS 代码提交中添加源代码
正如我们所知，CodeCommit 是一个私有的 Git 存储库，但由于它是一个 AWS 服务，AWS 的核心基础仍然适用，例如在连接到存储库时使用身份访问管理(IAM)进行授权和认证。
让我们探索连接到 CodeCommit 存储库和存储源代码的不同选项。
连接到代码提交存储库
有各种选项可用于连接到 CodeCommit 存储库。适合您的选项将取决于您使用 AWS 服务的身份验证方式。例如，它是否是 IAM 用户、IAM 角色、联合访问等。？
对于连接到 CodeCommit 存储库的每种方法，使用的 URL 是不同的；对于特定的存储库，可以检索每个连接方法的 URL，如图 6-6 所示。
图 6-6
CodeCommit 连接 URL
安全超文本传输协议
HTTPS 方法用于 IAM 用户，它涉及为该 IAM 用户生成 Git 用户名和密码。生成的用户名和密码在执行 Git 操作时用作 Git 凭证。
要为 IAM 用户生成 Git 用户名和密码，请转到 IAM 用户的安全凭证设置，如图 6-7 所示。
图 6-7
IAM 用户的安全凭据设置
在 IAM 用户的安全凭证页面中，可以看到为 AWS CodeCommit 生成 HTTPS Git 凭证的选项，如图 6-8 所示。
图 6-8
正在生成 HTTPS Git 凭据
生成凭证后，您可以下载. csv 文件形式的凭证或复制用户名和密码，如图 6-9 所示。
图 6-9
正在下载生成的 HTTPS 凭据
通过克隆一个新创建的存储库，生成的凭证可以用来连接到一个带有 HTTPS URL 的 CodeCommit 存储库，如清单 6-18 所示。
$ git clone https://git-codecommit.us-east-1.amazonaws.com/v1/repos/devops-ios-repository
Cloning into 'devops-ios-repository'...
Username for 'https://git-codecommit.us-east-1.amazonaws.com': abdullahi-at-168181944806
Password for 'https://abdullahi-at-168181944806@git-codecommit.us-east-1.amazonaws.com':
warning: You appear to have cloned an empty repository.
$ cd devops-ios-repository/
$ git status
On branch master
No commits yet
nothing to commit (create/copy files and use "git add" to track)
Listing 6-18Connect to CodeCommit repository with HTTPS
嘘
与 HTTPS 方法类似，连接到 AWS CodeCommit 存储库的 SSH 方法也用于 IAM 用户；这种连接方法需要一对私钥和公钥。公钥与 IAM 用户相关联，而私钥在 Git 工作站中本地配置。使用 SSH 连接方法的第一步是使用ssh-keygen生成一个 SSH 密钥对，如清单 6-19 所示。
$ ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/home/cloudshell-user/.ssh/id_rsa): /home/cloudshell-user/.ssh/codecommit_key
Created directory '/home/cloudshell-user/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/cloudshell-user/.ssh/codecommit_key.
Your public key has been saved in /home/cloudshell-user/.ssh/codecommit_key.pub.
The key fingerprint is:
SHA256:AJ1EUBde/TT0K/D6SqaryVdSEalDPVN8K/Lp55yWPrU cloudshell-user@ip-10-1-34-183.ec2.internal
The key's randomart image is:
+---[RSA 2048]----+
| o*+.o.oo=o. |
| .oo o *..oo |
| . o ..+o..o|
| . o oo....|
| S o ooo. |
| . ..o. .|
| o+. +|
| . ..+ ...E.|
| +oo....==.|
+----[SHA256]-----+
Listing 6-19Generating SSH key pair
清单 6-19 中生成的密钥对被命名为 codecommit_key，因此生成的公钥将被命名为 codecommit_key.pub，而私钥是 codecommit_key，两者都存储在目录 /home/cloudshell-user/中。宋承宪。
接下来，为预期的 IAM 用户将公钥上传到 AWS。要上传 IAM 用户的 SSH 公钥，请访问安全凭证设置，如图 6-7 所示。在安全凭证中，开始上传的选项如图 6-10 所示。
图 6-10
开始 SSH 公钥上传
将提供 SSH 公钥的内容，如图 6-11 所示。在本例中，这是 codecommit_key.pub 的内容。您可以检索清单 6-20 中所示的内容。
图 6-11
添加 SSH 公钥内容
$ cat ~/.ssh/codecommit_key.pub
Listing 6-20Retriving SSH public key content
公钥上传成功后，生成 SSH 密钥 ID，如图 6-12 所示。检索 SSH 密钥 ID，因为它将用于本地 Git 配置。
图 6-12
上传的公钥的 SSH 密钥 ID
本地 Git 配置存储在。ssh 文件夹，如清单 6-21 所示。配置文件中的主机字段是跨所有区域的 CodeCommit URL 模式，用户字段是应该用于连接的 SSH 用户，(这是从 AWS IAM 检索的 SSH 密钥 ID，如图 6-12 所示)，而标识文件字段指向存储 SSH 私钥的位置。
$ vim ~/.ssh/config
Host git-codecommit.*.amazonaws.com
User APKASOKDM2HTO6CTLRZS
IdentityFile ~/.ssh/codecommit_key
Listing 6-21Local SSH configuration
读写权限也应该添加到配置文件权限中，如清单 6-22 所示。
$ chmod 600 .ssh/config
Listing 6-22Setting config file permission
现在配置了 SSH，您可以通过克隆一个新创建的存储库，用它的 SSH URL 连接到 CodeCommit 存储库，如清单 6-23 所示。
$ git clone ssh://git-codecommit.us-east-1.amazonaws.com/v1/repos/devops-ios-repository
Cloning into 'devops-ios-repository'...
The authenticity of host 'git-codecommit.us-east-1.amazonaws.com (52.94.229.29)' can't be established.
RSA key fingerprint is SHA256:eLMY1j0DKA4uvDZcl/KgtIayZANwX6t8+8isPtotBoY.
RSA key fingerprint is MD5:a6:9c:7d:bc:35:f5:d4:5f:8b:ba:6f:c8:bc:d4:83:84.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added 'git-codecommit.us-east-1.amazonaws.com,52.94.229.29' (RSA) to the list of known hosts.
warning: You appear to have cloned an empty repository.
$ cd devops-ios-repository/
$ git status
On branch master
No commits yet
nothing to commit (create/copy files and use "git add" to track)
Listing 6-23Connecting to CodeCommit repository with SSH
Git 远程代码提交(GRC)
当您使用具有 IAM 角色的临时凭据来连接 AWS 时，会使用此选项。临时凭证的常见用例是身份联合、跨帐户访问和 AWS 服务(如 EC2)的角色。
GRC 是一个必须安装在工作站上的工具(git-remote-codecommit)，在这种方法中，GRC 获取执行 git 操作的用户的当前 AWS 凭据，并使用它们对 codecommit 进行身份验证；因此，不需要 IAM 永久用户。
GRC 需要安装 Python，可以用 pip 安装，如清单 6-24 所示。
$ pip install git-remote-codecommit
Listing 6-24Installing Git remote CodeCommit
为了演示 git-remote-codecommit 如何工作，我将假设一个 IAM 角色，并使用为 IAM 角色生成的临时凭证来连接到存储库。
- 有关创建和配置 IAM 角色的更多信息，请在此处查看 AWS 官方文档:
https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html。
将要承担的 IAM 角色的配置如图 6-13 所示。
图 6-13
具有 AWS 代码提交权限的 IAM 角色
为了获得临时凭证，我将使用 AWS CLI 承担 IAM 角色，如清单 6-25 所示。其中如图 6-13 所示的角色 ARN 被传递给--role-arn标志，并且在--role-session-name标志中为会话名称提供一个描述性名称。
$ aws sts assume-role --role-arn "arn:aws:iam::123456789101:role/CodeCommitRole" --role-session-name AWSCLI-Session
Listing 6-25Assuming IAM role
此 AWS CLI 操作返回临时凭据作为输出，并返回凭据的过期信息。检索 AccessKeyId 、 SecretAccessKey 、 SessionToken ，配置将要执行 Git 操作的工作站，如清单 6-26 所示。
$ export AWS_ACCESS_KEY_ID=<RoleAccessKeyID>
$ export AWS_SECRET_ACCESS_KEY=<RoleSecretAccessKey>
$ export AWS_SESSION_TOKEN=<RoleSessionToken>
Listing 6-26Configure workstation with temporary credentials
您的工作站现在应该正在使用临时凭证。您可以验证临时凭证是否配置正确并且是活动的，如清单 6-27 所示。
$ aws sts get-caller-identity
{
"UserId": "AROASOKDM2HTNVOJHAAV7:AWSCLI-Session",
"Account": "123456789101",
"Arn": "arn:aws:sts::123456789101:assumed-role/CodeCommitRole/AWSCLI-Session"
}
Listing 6-27Verifying temporary credentials
在验证临时凭证是活动的之后，我可以通过克隆一个新创建的存储库，使用 GRC URL 连接到存储库，如清单 6-28 所示。
$ git clone codecommit::us-east-1://devops-ios-repository
Cloning into 'devops-ios-repository'...
warning: You appear to have cloned an empty repository.
$ cd devops-ios-repository/
$ git status
On branch master
No commits yet
nothing to commit (create/copy files and use "git add" to track)
Listing 6-28Connecting to CodeCommit repository with Git remote CodeCommit
将代码推送到代码提交存储库
现在，我们已经探索了通过在本地克隆一个空的 CodeCommit 存储库来连接到 CodeCommit 存储库的不同方法，让我们向本地存储库添加一些源代码，并将更改推送到 CodeCommit。
- 这里使用的源代码是样例 app 代码，可以从
https://github.com/abdulola/devops-on-aws-ios-development-app下载。
在将源代码添加到本地目录但还没有提交到 Git 之后，可以检查存储库的状态，如清单 6-29 所示，在这里您会看到新文件被列为未跟踪。
$ git status
On branch master
No commits yet
Untracked files:
(use "git add <file>..." to include in what will be committed)
SampleApp.xcodeproj/
SampleApp/
SampleAppTests/
SampleAppUITests/
nothing added to commit but untracked files present (use "git add" to track)
Listing 6-29Checking the status of new files added to local repository
然后，新添加的文件被暂存并提交给 Git，如清单 6-30 所示。
$ git add .
$ git commit -m "Add Sample Application Code"
[master (root-commit) 4c25bde] Add Sample Application Code
34 files changed, 981 insertions(+)
create mode 100644 SampleApp.xcodeproj/project.pbxproj
create mode 100644 SampleApp.xcodeproj/project.xcworkspace/contents.xcworkspacedata
create mode 100644 SampleApp.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
create mode 100644 SampleApp.xcodeproj/project.xcworkspace/xcuserdata/olaoyea.xcuserdatad/UserInterfaceState.xcuserstate
create mode 100644 SampleApp.xcodeproj/xcuserdata/olaoyea.xcuserdatad/xcschemes/xcschememanagement.plist
create mode 100644 SampleApp/Assets.xcassets/AccentColor.colorset/Contents.json
create mode 100644 SampleApp/Assets.xcassets/AppIcon.appiconset/1024.png
create mode 100644
...................................................
...................................................
...................................................
Listing 6-30Committing source code to Git
然后，通过简单地运行 Git push 将更改推送到 CodeCommit，如清单 6-31 所示。
- CodeCommit SSH URL 用于此操作。
$ git push
Warning: Permanently added the RSA host key for IP address '52.94.233.146' to the list of known hosts.
Enumerating objects: 45, done.
Counting objects: 100% (45/45), done.
Delta compression using up to 2 threads
Compressing objects: 100% (40/40), done.
Writing objects: 100% (45/45), 75.21 KiB | 6.84 MiB/s, done.
Total 45 (delta 1), reused 0 (delta 0)
To ssh://git-codecommit.us-east-1.amazonaws.com/v1/repos/devops-ios-repository
* [new branch] master -> master
Listing 6-31Pushing changes to CodeCommit
将 Git 存储库迁移到 AWS 代码提交
现有的远程 Git 存储库也可以迁移到 CodeCommit。要迁移到 CodeCommit，将在本地克隆存储库，然后将其推送到目标 CodeCommit 存储库。
例如，我想将一个名为devo PS-on-AWS-IOs-development的私有 GitHub 存储库迁移到一个名为target-CodeCommit-repository的 CodeCommit 存储库。首先，我将源 GitHub 存储库克隆到一个临时的本地目录，我将其命名为 migrate-to-codecommit ，如清单 6-32 所示。传递的--mirror标志用于克隆用于迁移的远程存储库的裸副本。
$ git clone --mirror https://github.com/abdulola/devops-on-aws-ios-development.git migrate-to-codecommit
Cloning into bare repository 'migrate-to-codecommit'...
Username for 'https://github.com': abdulola
Password for 'https://abdulola@github.com':
remote: Enumerating objects: 97, done.
remote: Counting objects: 100% (97/97), done.
remote: Compressing objects: 100% (79/79), done.
remote: Total 97 (delta 11), reused 86 (delta 7), pack-reused 0
Unpacking objects: 100% (97/97), done.
Listing 6-32Cloning source GitHub repository to local directory
接下来，我将进入本地目录，然后将内容推送到目标 CodeCommit 存储库，如清单 6-33 所示。--all标志确保存储库的所有分支都被推送到目标 CodeCommit 存储库。
$ cd migrate-to-codecommit/
$ git push --all ssh://git-codecommit.us-east-1.amazonaws.com/v1/repos/target-codeommit-repository
Enumerating objects: 97, done.
Counting objects: 100% (97/97), done.
Delta compression using up to 2 threads
Compressing objects: 100% (86/86), done.
Writing objects: 100% (97/97), 291.28 KiB | 10.40 MiB/s, done.
Total 97 (delta 11), reused 0 (delta 0)
To ssh://git-codecommit.us-east-1.amazonaws.com/v1/repos/target-codeommit-repository
* [new branch] main -> main
Listing 6-33Pushing contents to the destination CodeCommit repository
此时，GitHub 库已经迁移到 AWS CodeCommit，临时本地目录 migrate-to-codecommit 可以删除了。新迁移的仓库如图 6-14 所示。
图 6-14
CodeCommit 中迁移的存储库
要开始与 CodeCommit 存储库交互，您必须将存储库克隆到本地。清单 6-34 显示了临时迁移目录的删除和本地迁移存储库的克隆。
- CodeCommit SSH URL 用于此操作。
$ rm -rf migrate-to-codecommit/
$ git clone ssh://git-codecommit.us-east-1.amazonaws.com/v1/repos/target-codeommit-repository
Cloning into 'target-codeommit-repository'...
Warning: Permanently added the RSA host key for IP address '52.94.226.180' to the list of known hosts.
remote: Counting objects: 97, done.
Receiving objects: 100% (97/97), 291.28 KiB | 15.33 MiB/s, done.
Resolving deltas: 100% (11/11), done
.
Listing 6-34Cloning migrated repository to local
AWS 代码提交中分支
在 CodeCommit 中创建分支有不同的方法，当您第一次提交到 CodeCommit 存储库时，会创建一个名为 **main 的默认分支。**接下来，我将向您展示如何使用 AWS 控制台、Git 和 AWS CLI 创建额外的分支。
在 AWS 控制台上创建分支
从 CodeCommit 存储库控制台中，选择分支菜单，如图 6-15 所示。
图 6-15
从代码提交存储库控制台访问分支菜单
- 上一节中迁移到 CodeCommit 的存储库用于本练习。
在下一页开始创建分支，如图 6-16 所示。如前所述，存储库的默认主分支已经存在。
图 6-16
开始分支创建
创建分支时，必须选择要从中创建新分支的分支。如图 6-17 所示，一个名为 dev 的分支正在从唯一存在的分支 main 中创建。
图 6-17
创建新的开发分支
创建的新开发分支可以在图 6-18 中看到。两个分支的最后一个提交消息是相同的，这是因为 dev 分支是新创建的，没有添加额外的提交。
图 6-18
创建了新的开发分支
用 Git 创建分支
CodeCommit 中的新分支也可以从 Git 命令行使用 Git 创建。当从 Git 命令行创建分支时，最初只在本地创建，必须将分支推送到 CodeCommit，以便在 CodeCommit 上创建。
清单 6-35 显示了在本地创建一个新的分支，以及在 CodeCommit 上创建这个分支的推送操作。
- 上一节中迁移到 CodeCommit 的存储库用于本练习。本地存储库已经从清单 6-34 中的 Git 克隆操作链接到 CodeCommit 存储库。
$ cd target-codeommit-repository/
$ git checkout -b test
Switched to a new branch 'test'
$ git push origin test
Total 0 (delta 0), reused 0 (delta 0)
To ssh://git-codecommit.us-east-1.amazonaws.com/v1/repos/target-codeommit-repository
* [new branch] test -> test
Listing 6-35Create CodeCommit branch using Git
在 CodeCommit 控制台上可以看到新创建的分支测试，如图 6-19 所示。
图 6-19
从 Git 创建的新测试分支
使用 AWS CLI 创建分支
要使用 AWS CLI 创建分支，除了将存储库名称和分支名称作为参数传递之外，还必须指定要从中创建分支的 Git commit ID。要检索 Git 提交 ID，您可以访问您的 CodeCommit 存储库的所有提交，如图 6-20 所示。
图 6-20
访问代码提交资料档案库的所有提交
您可以复制提交 ID 来创建新的分支，如图 6-21 所示。
图 6-21
复制提交 ID
知道了用于分支创建的提交 ID 后，就可以使用 AWS CLI 创建新的分支，如清单 6-36 所示。
$ aws codecommit create-branch --repository-name target-codeommit-repository --branch-name preprod --commit-id 7da70dd7ef5eb237012ac0699367922d9cb3524e
Listing 6-36Creating branch using AWS CLI
如图 6-22 所示，可以在代码提交控制台上看到新创建的预编程分支。
图 6-22
使用 AWS CLI 创建新的预编程分支
更新本地存储库
随着所有新分支的创建，一些分支存在于 CodeCommit 中，但不在本地，您可以获取远程存储库的更新并查看所有分支，如清单 6-37 所示。
$ git remote update origin
Fetching origin
From ssh://git-codecommit.us-east-1.amazonaws.com/v1/repos/target-codeommit-repository
* [new branch] preprod -> origin/preprod
$ git branch --all
dev
* test
remotes/origin/HEAD -> origin/dev
remotes/origin/dev
remotes/origin/main
remotes/origin/preprod
remotes/origin/test
Listing 6-37Fetch update from remote repository
配置默认分支
当您第一次提交到 CodeCommit 存储库时，会为您创建一个名为 main 的默认基础分支。如果需要，可以将这个默认分支更改为存储库中的其他分支。要更改默认分支，请转到如图 6-23 所示的存储库设置。
图 6-23
存储库设置
在默认分支菜单中，可以从库分支列表中选择新的默认分支，如图 6-24 所示。
图 6-24
选择默认分支
AWS 代码提交中的拉请求
AWS 代码提交存储库支持在合并分支之前创建拉请求。还有一些额外的特定于 CodeCommit 的 pull request 特性，比如批准规则和 Amazon CodeGuru Reviewer 集成。接下来让我们探索所有这些概念。
创建拉取请求
当两个分支合并时，例如，一个功能分支与一个主分支合并，可以在 AWS 控制台或 CLI 上创建一个拉请求。
在您可以创建一个拉请求来合并两个分支之前，这两个分支之间必须有一个增量。一个增量被引入到本地存储库中的一个测试分支，并被推送到远程代码提交存储库中，如清单 6-38 所示。
$ echo "Add New Text" >> README.md
$ git status
On branch test
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: README.md
no changes added to commit (use "git add" and/or "git commit -a")
$ git add README.md
$ git commit -m "Add new text to Readme"
[test 7ea6176] Add new text to Readme
1 file changed, 1 insertion(+)
$ git push --set-upstream origin test
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 2 threads
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 311 bytes | 311.00 KiB/s, done.
Total 3 (delta 1), reused 0 (delta 0)
To ssh://git-codecommit.us-east-1.amazonaws.com/v1/repos/target-codeommit-repository
7da70dd..7ea6176 test -> test
Branch 'test' set up to track remote branch 'test' from 'origin'.
Listing 6-38Adding changes to repository test branch and pushing to CodeCommit
既然代码更改已经被推送到 CodeCommit 存储库的测试分支，就可以创建一个 pull 请求了。
AWS 控制台
要创建一个拉请求，您可以访问存储库的拉请求页面，如图 6-25 所示。
图 6-25
访问拉取请求控制台
在存储库的 Pull requests 页面上，您可以开始创建 Pull requests，如图 6-26 所示。
图 6-26
开始创建拉取请求
如图 6-27 所示选择源和目的分支。对于这个例子，包含代码变更的源分支是测试，目标分支是主。
图 6-27
选择源和目标分支
为拉取请求提供标题和可选描述，如图 6-28 所示。通常，该描述将包含代码更改的细节，以便为将要审查它的团队成员提供上下文。
图 6-28
为拉取请求提供标题和描述
在最终创建拉请求之前，您可以检查由源分支引入的变更，如图 6-29 所示。
图 6-29
查看由“拉”请求引入的更改
最后，一旦成功创建了拉请求，新的拉请求将如图 6-30 所示。
图 6-30
已创建拉取请求
AWS CLI
为了在 AWS CLI 上创建一个拉请求，我们使用清单 6-39 中的命令。拉请求标题被传递给--title选项，描述被传递给--description选项，您生成的惟一幂等令牌应该被传递给--client-request-token选项，存储库和分支信息被传递给--targets选项。
$ aws codecommit create-pull-request --title "Merge Test to Main Branch" --description "Example description" --client-request-token Example --targets repositoryName=target-codeommit-repository,sourceReference=Test,destinationReference=main
Listing 6-39Creating pull request with the AWS CLI
合并拉取请求
一旦“拉”请求被其他人审阅并准备好合并，这个操作也可以在 AWS 控制台或 CLI 上执行。
AWS 控制台
只要两个分支是可合并的，即没有合并冲突或批准规则会阻止合并，合并选项总是被激活，如图 6-31 所示。
图 6-31
开始提取请求合并
要合并，必须选择一个合并策略；CodeCommit 支持三种不同的合并策略，如图 6-32 所示。合并的默认 Git 行为是尽可能快进。如果由于合并方案而无法应用特定的合并类型，此选项将灰显且无法选择。成功合并后，您可以选择删除源分支，选择此选项后，本例中使用的测试分支将从存储库中删除。
图 6-32
选择合并类型和合并提取请求
一旦拉请求被成功合并，你会得到一个确认，如图 6-33 所示。
图 6-33
已合并拉取请求
要查看所应用的合并更改，您可以切换到存储库中的目标分支，并检查由 pull 请求所做的文件更改。如图 6-34 所示，拉取请求更新的仓库的 README.md 已经被更改。
图 6-34
来自拉取请求的更新文件
现在远程主分支已经更新，为了保持本地主分支也是最新的，必须执行一个git pull操作，如清单 6-40 所示。
$ git pull
From ssh://git-codecommit.us-east-1.amazonaws.com/v1/repos/target-codeommit-repository
7da70dd..7ea6176 main -> origin/main
Your configuration specifies to merge with the ref 'refs/heads/test'
from the remote, but no such ref was fetched.
$ git checkout main
Branch 'main' set up to track remote branch 'main' from 'origin'.
Switched to a new branch 'main'
Listing 6-40Updating local main branch with changes from remote
AWS CLI
要在 AWS CLI 上合并拉请求，要执行的命令取决于要应用的合并策略。清单 6-41 展示了如何使用快进合并策略进行合并。拉请求 ID 被传递给--pull-request-id选项，来自源分支的最新完整提交 ID 被传递给--source-commit-id选项，最后，存储库名称被传递给--repository-name选项。
- 要查看如何将 CLI 与其他合并策略一起使用，请参见
https://docs.aws.amazon.com/cli/latest/reference/codecommit/。
$ aws codecommit merge-pull-request-by-fast-forward --pull-request-id 1 --source-commit-id EXAMPLE1112222333 --repository-name target-codeommit-repository
Listing 6-41Merging using fast forward strategy
创建审批规则模板
批准规则模板允许您自动将批准规则应用于在存储库中创建的提取请求。在每个 AWS 区域中，您可以将批准规则模板应用于在所有 CodeCommit 存储库中创建的部分或全部拉请求。
使用批准规则模板，您可以在为给定分支(例如，您的主分支)创建提取请求时自动应用批准规则，并在合并提取请求之前要求某些团队成员的批准。
让我们看看如何在 AWS 控制台和 CLI 上创建批准模板。
AWS 控制台
您可以在 AWS 控制台上访问审批规则模板页面，如图 6-35 所示。
图 6-35
访问审批规则模板页面
您可以开始创建审批规则模板，如图 6-36 所示。
图 6-36
开始创建审批规则模板
我正在创建的审批规则模板定义如图 6-37 所示。批准的最小数量定义为 1，还提供了有效批准人的列表。这里我提供一个 I am 用户的 ARN；还指定了要应用规则的目标分支。最后，指定要应用该模板的存储库列表。
图 6-37
审批规则模板定义
AWS CLI
要在 AWS CLI 上创建批准规则模板，必须首先在 JSON 中定义该模板，如清单 6-42 所示。定义的示例模板应用于存储库的主分支，需要两次批准，批准者列表中提供了 IAM 用户 ARN。
{
"Version": "2018-11-08",
"DestinationReferences": [
"refs/heads/main"
],
"Statements": [
{
"Type": "Approvers",
"NumberOfApprovalsNeeded": 2,
"ApprovalPoolMembers": [
"arn:aws:iam::123456789101:user/abdullahi"
]
}
]
}
Listing 6-42Approval rule template definition
该模板可以提供给 AWS CLI 命令，如清单 6-43 所示。审批模板名称在--approval-rule-template-name选项中提供，描述在--approval-rule-template-description选项中提供，模板 JSON 定义在--approval-rule-template-content选项中提供。
$ aws codecommit create-approval-rule-template --approval-rule-template-name Engineering-Manager-Approval --approval-rule-template-description "Requires Engineering Manager Approval" --approval-rule-template-content "{\"Version\":\"2018-11-08\",\"DestinationReferences\":[\"refs\/heads\/main\"],\"Statements\":[{\"Type\":\"Approvers\",\"NumberOfApprovalsNeeded\":2,\"ApprovalPoolMembers\":[\"arn:aws:iam::123456789101:user\/abdullahi\"]}]}"
{
"approvalRuleTemplate": {
"approvalRuleTemplateId": "d812838a-4010-4c68-80ce-e03b8ba456c7",
"approvalRuleTemplateName": "Engineering-Manager-Approval",
"approvalRuleTemplateDescription": "Requires Engineering Manager Approval",
"approvalRuleTemplateContent": "{\"Version\":\"2018-11-08\",\"DestinationReferences\":[\"refs/heads/main\"],\"Statements\":[{\"Type\":\"Approvers\",\"NumberOfApprovalsNeeded\":2,\"ApprovalPoolMembers\":[\"arn:aws:iam::123456789101:user/abdullahi\"]}]}",
"ruleContentSha256": "609e9411c4a0a04d8f49438ac4faa377393355ba831646637f5895a4283aa732",
"lastModifiedDate": "2021-08-18T00:23:22.780000+00:00",
"creationDate": "2021-08-18T00:23:22.780000+00:00",
"lastModifiedUser": "arn:aws:iam::123456789101:user/abdullahi"
}
}
Listing 6-43Creating an approval rule template from the AWS CLI
带有审批规则模板的拉取请求
如果您创建了拉取请求，并且已将批准规则模板应用于存储库，并且批准规则模板中定义的分支与拉取请求的目标分支相匹配，则无需任何进一步的操作，即可为拉取请求创建批准规则。审批规则的条件在审批规则模板中定义。
图 6-38 显示了一个 pull 请求，它被创建来将 dev 分支合并到我们的示例 CodeCommit 存储库的主分支。审批规则被应用于该拉取请求，因为如图 6-37 所示创建的审批规则模板应用于该存储库和主分支。因为我使用在批准规则模板的批准者列表中指定的 I am 用户登录 AWS 控制台，所以我看到可用的批准选项。
图 6-38
应用审批规则的提取请求
一旦拉动请求被批准，批准规则要求就被满足，合并按钮出现，如图 6-39 所示。
图 6-39
审批后合并拉取请求
Amazon CodeGuru Reviewer 集成
Amazon CodeGuru reviewer 是一个 AWS 服务，它使用机器学习来检测代码中的缺陷，CodeGuru reviewer 可以与 CodeCommmit 存储库相关联。当在与 CodeGuru 评审者相关联的存储库中创建一个拉请求时，它会自动开始评审该拉请求，并将发现和建议作为注释添加到拉请求中。
目前 CodeGuru reviewer 只支持审查 Java 和 Python 代码。
协会代码专家评审员
要将 CodeGuru reviewer 与 CodeCommit 存储库相关联，请访问存储库设置中的 Amazon CodeGuru Reviewer 选项卡，如图 6-40 所示。
图 6-40
CodeCommit 存储库设置中的 CodeGuru Reviewer 选项卡
将 CodeGuru Reviewer 关联到您的 CodeCommit 存储库，如图 6-41 所示。
图 6-41
协会代码专家评审员
关联不会立即完成，而关联状态是关联。如图 6-42 所示，关联需要 10 分钟。
图 6-42
CodeGuru 审阅者关联正在进行中
关联完成后，状态变为关联。解除存储库关联的选项也会出现，如图 6-43 所示。
图 6-43
CodeGuru 审查者关联
- 参考
https://docs.aws.amazon.com/codeguru/latest/reviewer-ug/create-codecommit-association.html#create-codecommit-association-cli了解如何通过 AWS CLI 将 Amazon CodeGuru Reviewer 关联到存储库。
查看拉取请求
让我们通过用 Python 代码创建一个 pull 请求来看看 CodeGuru Reviewer 是如何工作的。为了触发 CodeGuru reviewer 的评论，我将使用一个有缺陷的 Python 代码。要使用的 Python 代码如清单 6-44 所示；这是一个简单的代码，列出了 S3 桶中的所有对象。
import boto3
s3_client = boto3.client('s3')
s3_client.list_objects(Bucket="BucketName")
Listing 6-44Example Python code to trigger CodeGuru reviewer
我将这个代码片段添加到我的存储库的 dev 分支中的一个. py 文件中，并创建一个 pull 请求来合并到主分支中。CodeGuru reviewer 自动开始审查 pull 请求，如图 6-44 所示。
图 6-44
CodeGuru 审核者审核拉取请求
完成审查后，如果在拉请求中发现任何缺陷，它会留下一个注释。如图 6-45 所示，我在代码中使用了一个过时的 API，CodeGuru reviewer 建议使用修改后的 API。
图 6-45
查看 CodeGuru 评论
摘要
iOS 应用开发流程的自动化和编排始于源代码控制管理。在这一章中，我们介绍了 Git 版本控制系统的基础知识，然后深入探讨了 AWS CodeCommit 的 Git 特性，以及如何使用它作为一个私有的远程 Git 存储库，并附有演练示例。然后，我们介绍了它与 Amazon CodeGuru Reviewer 的集成，通过机器学习自动审查 Python 和 Java 代码。
七、将 AWS CodeCommit 与 Jenkins 集成
当应用源代码存储在 AWS CodeCommit 中以进行源代码控制时，它可以与其他构建和测试系统集成以进行持续集成，以便当在源存储库中进行新的提交时，触发自动构建和/或测试。
在本章中，我们将看到 AWS CodeCommit 如何使用 Jenkins 插件与 Jenkins 集成。通过这种集成，可以使用 AWS CodeCommit for source control 在 Jenkins 上设置 iOS 应用构建作业，其中当代码提交到 AWS CodeCommit 时，在 Jenkins 上触发构建。
Jenkins 代码提交插件
插件用于增强 Jenkins 的功能，以适应特定的用例，它允许各种工具和云提供商与 Jenkins 集成。为了集成 AWS CodeCommit 和 Jenkins，使用了一个 AWS CodeCommit 插件。
当通过亚马逊简单通知服务(SNS)进行提交时，Jenkins AWS CodeCommit 插件通过向亚马逊简单队列服务(SQS)队列发送消息来工作。Jenkins 作业定期轮询队列中的任何新消息，如果发现新消息，则触发作业的新构建。
要在 Jenkins 控制器上安装该插件，图 7-1 显示了如何从 Jenkins 环境主页访问管理 Jenkins 页面。
图 7-1
访问管理 Jenkins 控制台
在设置控制台上，有各种配置 Jenkins 环境的选项，如图 7-2；您可以访问“管理插件”页面来管理插件。
图 7-2
管理 Jenkins 插件
所有安装在 Jenkins 环境中的插件都可以在这个页面上管理，从不同的可用选项卡可以看到。 Updates 选项卡显示任何已安装的插件，该更新了， Available 选项卡显示可以安装在 Jenkins 环境中的所有可用插件， Installed 选项卡显示安装在该 Jenkins 环境中的所有 Jenkins 插件， Advanced 选项卡提供执行操作的选项，如通过手动上传档案来安装插件。使用高级选项的一个用例是当您想要安装一个通过 web UI 不可用的插件的旧版本时。
要开始安装 AWS CodeCommit 插件，切换到 Available 选项卡并搜索 CodeCommit，如图 7-3 所示。
图 7-3
正在搜索 AWS 代码提交插件
选择 AWS CodeCommit 触发器并安装，如图 7-4 所示。你可以指示 Jenkins 立即安装而不重启，或者下载并等待下次重启来安装插件。
图 7-4
正在安装 AWS 代码提交插件
现在已经安装了插件，要开始在项目中使用插件，必须对它进行配置。但是，要配置该插件，作为先决条件，需要设置一些 AWS 资源。
在下一节中，我们将看到如何设置这些先决资源。
设置集成组件
要配置在上一节中安装的 AWS CodeCommit Jenkins 插件，我们需要创建一个 Amazon SQS 队列和 Amazon SNS 主题，并配置 CodeCommit 存储库，以便在创建新的提交时将消息发布到 SQS 队列。
通过 AWS 控制台设置组件
在本节中，我们将通过 AWS 控制台手动设置这些组件。
正在创建 SQS 队列
要访问亚马逊简单队列服务(SQS)控制台，在 AWS 控制台上搜索 SQS ，如图 7-5 所示。
图 7-5
在 AWS 管理控制台上搜索 SQS
开始创建 SQS 队列，如图 7-6 所示。
图 7-6
开始创建 SQS 队列
图 7-7 显示了如何配置 SQS 队列的示例。对于这个用例，标准队列类型就足够了。
图 7-7
配置和创建 SQS 队列
创建 SNS 主题和订阅 SQS 队列
要访问亚马逊简单通知服务(SNS)控制台，在 AWS 控制台上搜索 SNS ，如图 7-8 所示。
图 7-8
在 AWS 管理控制台上搜索 SNS
开始创建一个 SNS 主题，如图 7-9 所示。
图 7-9
开始创建 SNS 主题
SNS 主题的配置示例如图 7-10 所示。标准的 SNS 主题类型适合这个用例。
图 7-10
配置和创建 sns 主题
既然已经创建了一个 SQS 队列和一个 SNS 主题，那么通过为 SNS 主题订阅 SQS 队列，这两个队列将被集成在一起。SNS 主题向其订阅的所有实体发布消息；当 SQS 队列接收到来自 SNS 主题的消息时，它会存储该消息，直到消费者使用队列中的消息。在这种情况下，消费者是运行在 Jenkins 中的 AWS CodeCommit 插件。
访问创建的 SNS 主题并创建订阅，如图 7-11 所示。
图 7-11
开始创建订阅
由于订阅是为 SQS 队列创建的，因此应该相应地选择亚马逊 SQS 协议和相应的 SQS 队列，如图 7-12 所示。
图 7-12
配置和创建亚马逊 SQS 订阅
成功创建 SQS 订阅的示例如图 7-13 所示。
图 7-13
成功创建 SQS 订阅
设置 SQS 队列权限
要允许 SNS 主题向 SQS 队列发布消息，应该将 SQS 队列的访问策略配置为允许访问 SNS 主题。要配置 SQS 队列访问策略，从 SQS 队列进入访问策略页签，如图 7-14 所示。
图 7-14
配置 SQS 队列访问策略
默认情况下，帐户中的 IAM 身份可以访问创建的 SQS 队列，但是要允许访问 SNS 等 AWS 服务，需要修改访问策略。
清单 7-1 显示了一个示例策略，该策略可以应用于访问策略，以允许 SNS 主题向 SQS 队列发布消息。
- 要使用此示例策略，请更改帐户 id 和资源名称以与您的相匹配。
{
"Version": "2008-10-17",
"Id": "__default_policy_ID",
"Statement": [
{
"Sid": "__owner_statement",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789101:root"
},
"Action": "SQS:*",
"Resource": "arn:aws:sqs:us-east-1:123456789101:codecommit-trigger-queue"
}
,
{
"Effect":"Allow",
"Principal": {
"Service": "sns.amazonaws.com"
},
"Action":"sqs:SendMessage",
"Resource":"arn:aws:sqs:us-east-1:123456789101:codecommit-trigger-queue",
"Condition":{
"ArnEquals":{
"aws:SourceArn":"arn:aws:sns:us-east-1:123456789101:codecommit-trigger-topic"
}
}
}]
}
Listing 7-1SQS queue access policy
测试 SQS 和社交网络整合
随着 SQS 队列访问策略的配置，亚马逊 SQS 和亚马逊 SNS 的集成就完成了。可以通过在 SNS 主题中手动发布消息并验证消息是否在 SQS 队列中收到来测试集成。
在 SNS 话题上发布消息，如图 7-15 所示。
图 7-15
社交网络发布消息
提供测试消息主题和消息体，如图 7-16 所示。该消息将被分发给订阅 SNS 主题的所有实体。
图 7-16
提供测试消息主题和正文
切换到 SQS 队列控制台，验证消息是否已收到。在 SQS 队列上，您可以开始接收如图 7-17 所示的消息。
图 7-17
正在 SQS 队列上接收消息
可以轮询和查看消息，如图 7-18 所示。将显示队列中的所有消息。要轮询消息，点击轮询消息选项，如图 7-18 所示。
图 7-18
轮询和查看 SQS 队列中的消息
队列中的消息验证从 SNS 发布的消息是否被传递到 SQS。
要查看消息内容，点击消息 ID，如图 7-18 所示。消息内容将类似于清单 7-2 。
{
"Type": "Notification",
"MessageId": "f1ddce6c-0f19-5961-8413-97ad8d705b83",
"TopicArn": "arn:aws:sns:us-east-1:123456789101:codecommit-trigger-topic",
"Subject": "Test Message",
"Message": "Test Message",
"Timestamp": "2021-09-19T18:23:37.676Z",
"SignatureVersion": "1",
"Signature": "PPp9ZRsxc8/TY**************",
"SigningCertURL": "https://sns.us-east-1.amazonaws.com/SimpleNotificationService-7ff5318490ec183fbaddaa2a969abfda.pem",
"UnsubscribeURL": "https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:123456789101:codecommit-trigger-topic:7272ea84-728e-4fdb-9e15-6a02e9c5b2f1"
}
Listing 7-2SQS message received from SNS topic
配置代码提交存储库触发器
如前几节所示，已经创建了一个 SQS 队列和一个 SNS 主题。要设置的最后一个组件是在 AWS CodeCommit 上配置触发器。CodeCommit trigger 允许您在存储库事件发生时触发操作。
您可以配置特定存储库事件或所有存储库事件来触发操作。对于操作，您可以调用 AWS lambda 函数或向 Amazon SNS 主题发送通知。我们将了解存储库事件如何向 Amazon SNS 主题发送通知。
首先，从您希望使用的 CodeCommit 库，转到设置页面，如图 7-19 所示。
图 7-19
代码提交存储库设置
从触发器页签创建一个触发器，如图 7-20 所示。
图 7-20
开始代码提交触发器创建
如图 7-21 所示配置并创建触发器。对于 SNS 主题，选择出于相同目的集成到 SQS 队列中的 SNS 主题。
图 7-21
配置和创建代码提交触发器
通过 Terraform 设置组件
让我们通过 Terraform for infra structure as Code(IaC)来设置所需的 AWS 资源。
清单 7-3 显示了设置所有所需资源的示例 Terraform 代码片段。
- 完整的代码可以从
https://github.com/abdulola/devops-on-aws-ios-development/blob/main/Chapter_7/Listing%207-3.tf中检索。
variable "aws-account-id" {
default = "xxxxxxxxxxxx"
}
.
.
.
provider "aws" {
region = "${var.aws-region}"
alias = "default"
}
data "aws_iam_policy_document" "sns-sqs-policy" {
policy_id = "arn:aws:sqs:us-east-1:${var.aws-account-id}:testing/SQSDefaultPolicy"
statement {
sid = "SubscribeToSNS"
effect = "Allow"
principals {
type = "AWS"
identifiers = [ "*" ]
}
actions = [ "SQS:SendMessage" ]
resources = [ "${aws_sqs_queue.main.arn}" ]
condition {
test = "ArnLike"
variable = "aws:SourceArn"
values = [ "arn:aws:sns:${var.aws-region}:${var.aws-account-id}:${var.sns-topic-prefix}*${var.sns-topic-suffix}" ]
}
}
}
.
.
.
resource "aws_sqs_queue" "main" {
name = "codecommit-notifications-queue"
delay_seconds = 90
max_message_size = 2048
message_retention_seconds = 86400
receive_wait_time_seconds = 10
}
resource "aws_sqs_queue_policy" "sns" {
queue_url = "${aws_sqs_queue.main.id}"
policy = "${data.aws_iam_policy_document.sns-sqs-policy.json}"
}
.
.
.
output "sns-name" {
value = "${aws_sns_topic.main.name}"
}
output "sns-arn" {
value = "${aws_sns_topic.main.arn}"
}
Listing 7-3Setting up components with Terraform
要创建资源，请将此 Terraform 代码保存到包含。tf 扩展并初始化，如清单 7-4 所示。
- 将清单 7-3 中的变量 repository_name 替换为您的代码提交库名称。
$ terraform init
Initializing the backend...
Initializing provider plugins...
- Finding latest version of hashicorp/aws...
- Installing hashicorp/aws v3.59.0...
- Installed hashicorp/aws v3.59.0 (signed by HashiCorp)
Terraform has created a lock file .terraform.lock.hcl to record the provider selections it made above. Include this file in your version control repository so that Terraform can guarantee to make the same selections by default when you run "terraform init" in the future.
Terraform has been successfully initialized!
You may now begin working with Terraform. Try running "terraform plan" to see any changes that are required for your infrastructure. All Terraform commands should now work.
If you ever set or change modules or backend configuration for Terraform, rerun this command to reinitialize your working directory. If you forget, other commands will detect it and remind you to do so if necessary.
Listing 7-4Initializing Terraform
成功初始化后，所有依赖项都已下载，现在您可以运行terraform apply来部署资源。该命令的输出将类似于清单 7-5 中所示的示例片段。
$ terraform apply
provider.aws.region
The region where AWS operations will take place. Examples
are us-east-1, us-west-2, etc.
Enter a value: us-east-1
.
.
.
Do you want to perform these actions?
Terraform will perform the actions described above.
Only 'yes' will be accepted to approve.
Enter a value: yes
.
.
.
Apply complete! Resources: 6 added, 0 changed, 0 destroyed.
Outputs:
sns-arn = "arn:aws:sns:us-east-1:123456789101:codecommit-target-codeommit-repository-topic"
sns-name = "codecommit-target-codeommit-repository-topic"
Listing 7-5Creating resources with Terraform
配置插件
已经设置的插件先决条件资源是 SQS 队列、SNS 主题、为 SNS 主题订阅 SQS 队列，以及设置 CodeCommit 触发器以在存储库事件时向插件 SNS 主题发送通知。现在，插件可以配置为利用已经创建的资源来完成集成。
要配置插件，进入 Jenkins 系统配置，如图 7-22 所示。
图 7-22
配置 Jenkins 系统
在系统配置页面上，可以看到 CodeCommit 插件配置。图 7-23 显示了如何开始用已经创建的 SQS 队列配置插件。
图 7-23
将 SQS 配置添加到代码提交插件
应提供 AWS 区域和 SQS 队列名称，如图 7-24 所示。该插件使用提供的 AWS 凭证测试对 SQS 队列的访问。
图 7-24
配置 SQS 队列名和 AWS 区域
如果可用，可以使用 Jenkins 上配置的现有 AWS 凭证，但是要添加新的 AWS 凭证，图 7-25 中显示了一个示例。
图 7-25
向 Jenkins 添加 AWS 凭据
- 为插件配置的 AWS 凭据必须具有 SQS 访问权限和代码提交只读访问权限。
Jenkins CodeCommit 插件现在应该已经配置好并处于活动状态。接下来，我们将创建一个示例 Jenkins 作业来验证插件是如何工作的。
使用 AWS 代码提交源创建 Jenkins 作业
在本节中，我们将看到一个示例 Jenkins 作业如何使用 AWS CodeCommit 源代码，以及如何使用已配置的 Jenkins CodeCommit 插件进行自动构建。图 7-26 显示了如何开始创建 Jenkins 作业。
图 7-26
开始创建 Jenkins 作业
我们将创建一个 Jenkins**自由式项目。**如图 7-27 所示，需要提供项目名称。
图 7-27
创建 Jenkins 自由式项目
对于项目配置，需要将本章前面配置的 CodeCommit 库添加到源代码管理(SCM)中，如图 7-28 所示。
图 7-28
使用 AWS 代码提交配置 SCM
如果可用，可以使用 Jenkins 上配置的现有 CodeCommit Git 凭证，但要添加新的 Git 凭证，图 7-29 中显示了一个示例。这里提供的 Git 凭据是 CodeCommit IAM 用户的 HTTPS 凭据。
图 7-29
配置代码提交 HTTPS 凭据
为自动构建配置构建触发器，如图 7-30 所示。显示了将由插件监控的 SQS 队列。
图 7-30
设置构建触发器
对于构建，输入一些基本的示例命令，如图 7-31 所示，项目就创建好了。当一个构建被触发时，存储库的内容被克隆到 Jenkins 工作空间，图 7-31 中提供的命令列出工作空间并确认存储库内容是否被下载。
图 7-31
输入构建命令
图 7-32 中可以看到一个自由式项目的例子。
图 7-32
Jenkins 自由式项目
测试 AWS 代码提交插件
为了测试该插件，将在 CodeCommit 存储库中创建一个新的提交，这将触发 Jenkins 上的自动构建。
清单 7-6 显示了在 CodeCommit 存储库中创建一个新的提交，该存储库被配置为示例 Jenkins 作业的源。
$ touch testfile
$ git add . && git commit -m "Test listing directory"
[master fb68e27] Test listing directory
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 testfile
$ git push
Enumerating objects: 4, done.
Counting objects: 100% (4/4), done.
Delta compression using up to 6 threads
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 285 bytes | 285.00 KiB/s, done.
Total 3 (delta 1), reused 0 (delta 0), pack-reused 0
To codecommit::us-east-1://devops-ios-repository
bc42da1..fb68e27 master -> master
Listing 7-6Adding commit to AWS CodeCommit Repository
在 Jenkins 项目上，您可以验证该项目是从新提交自动启动的，如图 7-33 所示。
图 7-33
Jenkins 作业自动构建
图 7-34 显示了包含所有构建命令输出的构建日志。
图 7-34
Jenkins 工作构建输出
摘要
Jenkins 是 DevOps 中使用非常广泛的工具，因为它具有丰富的功能，能够与许多其他工具集成以满足不同的用例，这也是它对 iOS 开发非常有用的原因。当 iOS 应用的源代码存储在 AWS CodeCommit 上时，将 CodeCommit 与 Jenkins 集成以实现端到端自动化变得至关重要。
到目前为止，我们已经深入研究了将 Jenkins 和 CodeCommit 集成到自动化 Jenkins 构建和基本构建中的过程。接下来，我们将从这里开始，向 Jenkins 添加更多特定于 iOS 的构建和测试。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
