在 Amazon Web Services (AWS) 上安装极狐GitLab POC

本页面提供了使用官方 Linux 安装包在 AWS 上部署极狐GitLab 的常见配置指南。您应根据自身需求对其进行定制。

开始使用生产级极狐GitLab#

严格按照本指南操作，会得到一个概念验证实例，大致相当于 40 RPS 或 2,000 用户参考架构 的 非高可用 版本中 两个可用区实现 的 缩水 版。2K 参考架构并非高可用，因为它主要旨在提供一定扩展能力，同时保持较低的成本和复杂度。60 RPS 或 3,000 用户参考架构 是达到极狐GitLab 高可用的最小规模。它拥有额外的服务角色来实现高可用，最显著的是使用 Gitaly 集群 (Praefect) 为 Git 仓库存储实现高可用，并指定了三重冗余。

极狐GitLab 维护并测试两种主要类型的参考架构。Linux 安装包架构 在实例计算上实现，而 云原生混合架构 则最大化利用 Kubernetes 集群。云原生混合参考架构规范是参考架构规模页面的附录部分，这些页面首先描述 Linux 安装包架构。例如，60 RPS 或 3,000 用户云原生参考架构位于 60 RPS 或 3,000 用户参考架构页面中标题为 使用 Helm Chart 的云原生混合参考架构（替代方案） 的子章节中。

开始使用生产级 Linux 安装包安装#

基础设施即代码工具 GitLab 环境工具 (GET) 是在 AWS 上使用 Linux 安装包进行构建的最佳起点，尤其是在您目标是实现高可用设置时。虽然它不能自动化所有工作，但它确实能为您完成复杂设置，例如 Gitaly 集群 (Praefect)。GET 是开源的，任何人都可以在此基础上构建并向其贡献改进。

开始使用生产级云原生混合极狐GitLab#

GitLab 环境工具包 (GET) 是一组有主见的 Terraform 和 Ansible 脚本。这些脚本有助于在选定的云提供商上部署 Linux 安装包或云原生混合环境，并被极狐GitLab 开发者用于（例如）极狐GitLab Dedicated。

您可以使用 GitLab 环境工具包在 AWS 上部署云原生混合环境。但是，这不是必需的，并且可能不支持所有有效的排列组合。话虽如此，这些脚本是按原样提供的，您可以相应地调整它们。

介绍#

在大多数情况下，我们在设置中使用 Linux 安装包，但我们也利用原生 AWS 服务。我们使用 Amazon RDS 和 ElastiCache，而不是使用 Linux 安装包捆绑的 PostgreSQL 和 Redis。

在本指南中，我们将进行多节点设置，首先配置我们的虚拟私有云和子网，然后集成诸如 RDS（作为数据库服务器）和 ElastiCache（作为 Redis 集群）等服务，最后在一个具有自定义扩缩策略的自动扩缩组中管理它们。

要求#

除了基本熟悉 AWS 和 Amazon EC2 之外，您还需要：

• 一个 AWS 账户
• 创建或上传 SSH 密钥 以通过 SSH 连接到实例
• 极狐GitLab 实例的域名
• 用于保护您域名的 SSL/TLS 证书。如果您还没有，可以通过 AWS Certificate Manager(ACM) 申请免费的公共 SSL/TLS 证书，以用于我们创建的 Elastic Load Balancer。

架构#

以下图表概述了推荐的架构。

AWS 费用#

极狐GitLab 使用以下 AWS 服务，并附有定价信息链接：

• EC2：极狐GitLab 部署在共享硬件上，适用 按需定价。 如果您想在专用或预留实例上运行极狐GitLab，请参阅 EC2 定价页面 了解其费用。
• S3：极狐GitLab 使用 S3（定价页面）来 存储备份、产物和 LFS 对象。
• NLB：一个网络负载均衡器（定价页面）， 用于将请求路由到极狐GitLab 实例。
• RDS：一个使用 PostgreSQL 的 Amazon 关系数据库服务 （定价页面）。
• ElastiCache：一个内存缓存环境（定价页面）， 用于提供 Redis 配置。

创建 IAM EC2 实例角色和配置文件#

由于我们使用 Amazon S3 对象存储，我们的 EC2 实例必须具有对 S3 存储桶的读取、写入和列出权限。为避免在极狐GitLab 配置中嵌入 AWS 密钥，我们使用 IAM 角色 来授予极狐GitLab 实例此访问权限。我们必须创建一个 IAM 策略以附加到 IAM 角色：

创建 IAM 策略#

1. 转到 IAM 控制面板，在左侧菜单中选择 策略。

2. 选择 创建策略，选择 JSON 选项卡，然后添加策略。我们希望 遵循安全最佳实践并授予 最小权限，仅赋予角色执行所需操作所需的权限。

   1. 假设您如图所示使用 gl- 前缀命名 S3 存储桶，添加以下策略：

   json
   1{   "Version": "2012-10-17",
   2    "Statement": [
   3        {
   4            "Effect": "Allow",
   5            "Action": [
   6                "s3:PutObject",
   7                "s3:GetObject",
   8                "s3:DeleteObject",
   9                "s3:PutObjectAcl"
   10            ],
   11            "Resource": "arn:aws:s3:::gl-*/*"
   12        },
   13        {
   14            "Effect": "Allow",
   15            "Action": [
   16                "s3:ListBucket",
   17                "s3:AbortMultipartUpload",
   18                "s3:ListMultipartUploadParts",
   19                "s3:ListBucketMultipartUploads"
   20            ],
   21            "Resource": "arn:aws:s3:::gl-*"
   22        }
   23    ]
   24}

3. 选择 下一步 查看策略。为您的策略命名（我们使用 gl-s3-policy），然后选择 创建策略。

创建 IAM 角色#

1. 仍在 IAM 控制面板上，在左侧菜单中选择 角色，然后 选择 创建角色。
2. 对于 受信任实体类型，选择 AWS 服务。对于 使用案例，在下拉列表和单选按钮中都选择 EC2，然后选择 下一步。
3. 在策略筛选器中，搜索我们之前创建的 gl-s3-policy，选择它，然后选择 下一步。
4. 为角色命名（我们使用 GitLabS3Access）。如果需要，添加一些标签。选择 创建角色。

我们稍后 创建启动模板 时会使用此角色。

配置网络#

我们首先为极狐GitLab 云基础设施创建 VPC，然后 我们可以创建子网，以便在至少两个 可用区 (AZs) 中拥有公共和私有实例。公共子网需要维护路由表并关联 互联网网关。

创建虚拟私有云 (VPC)#

现在我们创建一个 VPC，一个由您控制的虚拟网络环境：

1. 登录 Amazon Web Services。

2. 从左侧菜单中选择 您的 VPC，然后选择 创建 VPC。 在“名称标签”处输入 gitlab-vpc，在“IPv4 CIDR 块”处输入 10.0.0.0/16。如果您不需要专用硬件，可以将 “租赁”保留为默认。准备就绪后选择 创建 VPC。

   

3. 选择该 VPC，选择 操作，选择 编辑 VPC 设置，然后勾选 启用 DNS 解析。完成后选择 保存。

子网#

现在，让我们在不同的可用区中创建一些子网。确保 每个子网都与我们刚刚创建的 VPC 关联，并且 CIDR 块不重叠。这也 允许我们启用多 AZ 以实现冗余。

我们还创建私有和公共子网以匹配负载均衡器和 RDS 实例：

1. 从左侧菜单中选择 子网。

2. 选择 创建子网。根据 IP 为其赋予描述性名称标签， 例如 gitlab-public-10.0.0.0，选择我们之前创建的 VPC，选择一个可用区（我们使用 us-west-2a）， 并在 IPv4 CIDR 块中给予一个 24 子网 10.0.0.0/24：

   

3. 按照相同步骤创建所有子网：

   名称标签	类型	可用区	CIDR 块
   gitlab-public-10.0.0.0	public	us-west-2a	10.0.0.0/24
   gitlab-private-10.0.1.0	private	us-west-2a	10.0.1.0/24
   gitlab-public-10.0.2.0	public	us-west-2b	10.0.2.0/24
   gitlab-private-10.0.3.0	private	us-west-2b	10.0.3.0/24

4. 创建所有子网后，为两个公共子网启用 自动分配 IPv4：

   1. 依次选择每个公共子网，选择 操作，然后选择 编辑子网设置。勾选 启用自动分配公有 IPv4 地址 选项并保存。

互联网网关#

现在，仍在同一控制面板上，转到互联网网关并 创建一个新网关：

1. 从左侧菜单中选择 互联网网关。

2. 选择 创建互联网网关，将其命名为 gitlab-gateway，然后 选择 创建。

3. 从表格中选择它，然后在 操作 下拉列表中选择 “附加到 VPC”。

   

4. 从列表中选择 gitlab-vpc，然后点击 附加。

创建 NAT 网关#

部署在私有子网中的实例必须连接到互联网以进行更新，但不应可从公共互联网访问。为实现这一点，我们使用 NAT 网关，部署在每个公共子网中：

1. 转到 VPC 控制面板，在左侧菜单栏中选择 NAT 网关。
2. 选择 创建 NAT 网关 并完成以下操作：
   1. 可用性模式：选择 区域。
   2. 子网：从下拉列表中选择 gitlab-public-10.0.0.0。
   3. 弹性 IP 分配 ID：输入现有弹性 IP，或选择 分配弹性 IP 地址 为您的 NAT 网关分配一个新的 IP。
   4. 根据需要添加标签。
   5. 选择 创建 NAT 网关。

创建第二个 NAT 网关，但这次将其放置在第二个公共子网 gitlab-public-10.0.2.0 中。

路由表#

公共路由表#

我们必须为公共子网创建一个路由表，使其能通过我们在上一步创建的互联网网关访问互联网。

在 VPC 控制面板上：

1. 从左侧菜单中选择 路由表。
2. 选择 创建路由表。
3. 在“名称标签”处输入 gitlab-public，并在“VPC”下选择 gitlab-vpc。
4. 选择 创建。

现在，我们必须将互联网网关添加为新目标，并 使其接收来自任何目的地的流量。

1. 从左侧菜单中选择 路由表，选择 gitlab-public 路由以显示底部选项。
2. 选择 路由 选项卡，选择 编辑路由 > 添加路由，并将 0.0.0.0/0 设为目标。在目标列中，选择 互联网网关，然后选择我们之前创建的 gitlab-gateway。 完成后选择 保存更改。

接下来，我们必须将 公共 子网关联到路由表：

1. 选择 子网关联 选项卡，然后选择 编辑子网关联。
2. 仅勾选公共子网，然后选择 保存关联。

私有路由表#

我们还必须创建两个私有路由表，以便每个私有子网中的实例可以通过同一可用区中对应公共子网中的 NAT 网关访问互联网。

1. 按照之前的步骤创建两个私有路由表。将它们命名为 gitlab-private-a 和 gitlab-private-b。
2. 接下来，为每个私有路由表添加新路由，其中目标为 0.0.0.0/0，目标是我们之前创建的其中一个 NAT 网关。
   1. 将在 gitlab-public-10.0.0.0 中创建的 NAT 网关添加为 gitlab-private-a 路由表中新路由的目标。
   2. 类似地，将在 gitlab-public-10.0.2.0 中的 NAT 网关添加为 gitlab-private-b 中新路由的目标。
3. 最后，将每个私有子网与私有路由表关联。
   1. 将 gitlab-private-10.0.1.0 与 gitlab-private-a 关联。
   2. 将 gitlab-private-10.0.3.0 与 gitlab-private-b 关联。

负载均衡器#

我们创建一个负载均衡器，以均匀分配入站流量到我们的极狐GitLab 应用服务器。根据我们稍后创建的 扩缩策略，实例会根据需要添加到负载均衡器或从中移除。此外，负载均衡器会对我们的实例执行健康检查。

AWS 为此架构提供了两种方法：

• 仅网络负载均衡器 (NLB)：适用于较小部署的更简单设置。NLB 直接处理所有流量（端口 22 上的 SSH、端口 80 上的 HTTP 和端口 443 上的 HTTPS）到 Rails 节点，并在 NLB 处终止 SSL/TLS。
• 混合 NLB->ALB 方法：一个更具可扩展性的设置，分离关注点。NLB 处理 TCP 流量（端口 22 上的 SSH），而应用程序负载均衡器 (ALB) 处理 HTTP/HTTPS 流量并终止 SSL/TLS。此方法支持 AWS WAF 集成和更好的流量管理。

选择最适合您部署的方法：

• 仅 NLB：

  Rendering chart...

• 混合 NLB/ALB：

  Rendering chart...

| 设置 | 值 | |---------|-------| | 负载均衡器名称 | `gitlab-alb` | | 方案 | 面向互联网 | | IP 地址类型 | IPv4 | | VPC | `gitlab-vpc` | | 映射 | 选择两个公有子网 `gitlab-public-10.0.0.0` 和 `gitlab-public-10.0.2.0`| | 安全组 | `gitlab-alb-sec-group` |

1. 在 监听器和路由 部分，配置：

   协议	端口	操作	目标组
   HTTPS	443	转发至	gitlab-alb-http-target

   对于 HTTPS 监听器，选择你的 ACM 证书并选择适当的安全策略（请参阅 应用程序负载均衡器的预定义 SSL 安全策略）。

2. 选择 创建负载均衡器。

创建网络负载均衡器：

1. 在 EC2 控制台中，在左侧导航栏找到 负载均衡器，然后选择 创建负载均衡器。

2. 选择 网络负载均衡器，然后选择 创建。

3. 使用以下设置配置负载均衡器：

   设置	值
   负载均衡器名称	gitlab-nlb
   方案	面向互联网
   IP 地址类型	IPv4
   VPC	gitlab-vpc
   映射	选择两个公有子网 gitlab-public-10.0.0.0 和 gitlab-public-10.0.2.0
   安全组	gitlab-nlb-sec-group

4. 在 监听器和路由 部分，配置：

   协议	端口	目标组
   TCP	22	gitlab-nlb-ssh-target
   TCP	443	gitlab-nlb-alb-target

5. 选择 创建负载均衡器。

将 ALB 注册为 NLB 的目标：

1. 在 EC2 控制台中，从左侧菜单栏选择 目标组。
2. 选择 gitlab-nlb-alb-target 目标组。
3. 在 目标 选项卡中，选择 注册目标。
4. 选择 gitlab-alb 应用程序负载均衡器，然后选择 注册挂起的目标。
5. 选择 保存。

{{< /tab >}}

{{< /tabs >}}

在 NLB 负载均衡器启动并运行后，你可以重新访问安全组，以细化仅通过 NLB 的访问以及你可能有的任何其他要求。

某些属性只能在负载均衡器创建后配置。以下是你可能会根据自己的需要配置的一些功能：

• 客户端 IP 保留 默认在目标组上启用。这样，连接到负载均衡器的客户端的 IP 就能在极狐GitLab 应用程序中保留。你可以根据自己的需求启用或禁用此功能。
• 代理协议 默认在目标组上禁用。这允许负载均衡器在代理协议标头中发送附加信息。如果要启用此功能，请确保配置了其他环境组件，如内部负载均衡器、NGINX 等。对于此 POC，我们只需要在稍后的 GitLab 节点 中启用它。

为负载均衡器配置 DNS#

在 Route 53 控制台中，选择左侧导航栏中的 托管区域：

1. 选择现有托管区域，或者如果你还没有适用于你的域名的托管区域，选择 创建托管区域，输入你的域名，然后选择 创建。
2. 选择 创建记录 并提供以下值：
   1. 名称：使用域名（默认值）或输入子域名。
   2. 类型：选择 A - IPv4 地址。
   3. 别名：默认为 禁用。启用此选项。
   4. 路由流量至：选择 别名指向网络负载均衡器。
   5. 区域：选择网络负载均衡器所在的区域。
   6. 选择网络负载均衡器：选择我们之前创建的网络负载均衡器。
   7. 路由策略：我们使用 简单，但你可以根据用例选择不同的策略。
   8. 评估目标运行状况：我们将其设置为 否，但你可以选择让负载均衡器根据目标运行状况来路由流量。
   9. 选择 创建。
3. 如果你是通过 Route 53 注册的域名，那么你的设置就完成了。如果你用的是其他域名注册商，则必须使用你的域名注册商更新 DNS 记录。你需要：
   1. 选择 托管区域，然后选择你之前添加的域名。
   2. 你会看到一个 NS 记录列表。从你的域名注册商的管理面板中，将这些记录作为 NS 记录添加到域名的 DNS 记录中。这些步骤可能因域名注册商而异。如果你遇到困难，可以搜索 “你的注册商名称” 添加 DNS 记录，你应该能找到特定于你的域名注册商的帮助文章。

具体操作步骤因所使用的注册商而异，这超出了本指南的范围。

使用 RDS 的 PostgreSQL#

对于我们的数据库服务器，我们使用 Amazon RDS for PostgreSQL，它提供多个可用区以实现冗余（不支持 Aurora）。首先，我们创建一个安全组和一个子网组，然后创建实际的 RDS 实例。

RDS 安全组#

我们需要为数据库设置一个安全组，允许从我们稍后部署到 gitlab-nlb-sec-group 中的实例传入流量：

1. 从 EC2 控制台中，选择左侧菜单栏中的 安全组。
2. 选择 创建安全组。
3. 为其命名（我们使用 gitlab-rds-sec-group）、添加描述，并从 VPC 下拉列表中选择 gitlab-vpc。
4. 在 入站规则 部分，选择 添加规则 并设置以下内容：
   1. 类型：搜索并选择 PostgreSQL 规则。
   2. 源类型：设置为“自定义”。
   3. 源：根据你的负载均衡器方法选择适当的安全组：
      • 仅 NLB：gitlab-nlb-sec-group
      • 混合 NLB->ALB：gitlab-rails-sec-group
5. 完成后，选择 创建安全组。

RDS 子网组#

1. 转到 RDS 控制台，从左侧菜单中选择 子网组。
2. 选择 创建数据库子网组。
3. 在 子网组详细信息 下，输入名称（我们使用 gitlab-rds-group）、描述，并从 VPC 下拉列表中选择 gitlab-vpc。
4. 从 可用区 下拉列表中，选择包含你所配置子网的可用区。在我们的例子中，我们添加 us-west-2a 和 us-west-2b。
5. 从 子网 下拉列表中，选择我们在 子网部分 中定义的两个私有子网（10.0.1.0/24 和 10.0.3.0/24）。
6. 准备就绪后，选择 创建。

创建数据库#

现在，是时候创建数据库了：

1. 转到 RDS 控制台，从左侧菜单中选择 数据库，然后选择 创建数据库。

2. 为数据库创建方法选择 标准创建。

3. 选择 PostgreSQL 作为数据库引擎，并选择我们的 数据库要求 中针对你的极狐GitLab 版本定义的最低 PostgreSQL 版本。

4. 由于这是生产服务器，我们从 模板 部分选择 生产。

5. 在 可用性和持久性 下，选择 多可用区数据库实例，以在不同的 可用区 中预配备用 RDS 实例。

6. 在 设置 下，使用：

   • 数据库实例标识符：gitlab-db-ha
   • 主用户名：gitlab
   • 主密码：一个非常安全的密码。

   注意这些信息，因为稍后需要用到。

7. 对于数据库实例大小，选择 标准类别，然后从下拉列表中选择满足你需求的实例大小。我们使用 db.m5.large 实例。

8. 在 存储 下，配置以下内容：

   1. 从存储类型下拉列表中选择 预配置 IOPS (SSD)。预配置 IOPS (SSD) 存储最适合此用途（尽管你可以选择通用型 (SSD) 以降低成本）。在 Amazon RDS 存储 上了解更多信息。
   2. 分配存储并设置预配置 IOPS。我们使用最小值 100 和 1000。
   3. 启用存储自动扩展（可选）并设置最大存储阈值。

9. 在 连接 下，配置以下内容：

   1. 从 虚拟私有云 (VPC) 下拉列表中选择我们之前创建的 VPC (gitlab-vpc)。
   2. 从 数据库子网组 中选择我们之前创建的子网组 (gitlab-rds-group)。
   3. 将公共访问设置为 否。
   4. 在 VPC 安全组 下，选择 选择现有，然后从下拉列表中选择我们之前创建的 gitlab-rds-sec-group。
   5. 在 其他配置 下，将数据库端口保留为默认的 5432。

10. 对于 数据库身份验证，选择 密码身份验证。

11. 展开 附加配置 部分并完成以下操作：

    1. 初始数据库名称。我们使用 gitlabhq_production。
    2. 配置你偏好的备份设置。
    3. 我们在此进行的唯一其他更改是在 维护 下禁用自动次要版本升级。
    4. 保持所有其他设置不变，或根据你的需求进行调整。
    5. 如果满意，选择 创建数据库。

现在数据库已创建，让我们继续使用 ElastiCache 设置 Redis。

使用 ElastiCache 的 Redis#

ElastiCache 是一种内存托管缓存解决方案。Redis 维护自己的持久性，并用于存储极狐GitLab 应用程序的会话数据、临时缓存信息以及后台作业队列。

创建 Redis 安全组#

1. 转到 EC2 控制台。
2. 从左侧菜单中选择 安全组。
3. 选择 创建安全组 并填写详细信息。为其命名（我们使用 gitlab-redis-sec-group），添加描述，并选择我们之前创建的 VPC (gitlab-vpc)。
4. 在 入站规则 部分，选择 添加规则，添加一个 自定义 TCP 规则，设置端口 6379，并根据你的负载均衡器方法设置“自定义”源：
   • 仅 NLB：gitlab-nlb-sec-group
   • 混合 NLB->ALB：gitlab-rails-sec-group
5. 完成后，选择 创建安全组。

Redis 子网组#

1. 从你的 AWS 控制台转到 ElastiCache 控制台。

2. 转到左侧菜单中的 子网组，并创建一个新的子网组（我们将其命名为 gitlab-redis-group）。 选择我们之前创建的 VPC (gitlab-vpc)，并确保所选的子网表格仅包含 私有子网。

3. 准备就绪后，选择 创建。

   

创建 Redis 集群#

1. 返回到 ElastiCache 控制台。

2. 在左侧菜单中选择 Redis 缓存，然后选择 创建 Redis 缓存 以创建一个新的 Redis 集群。

3. 在 部署选项 下，选择 设计你自己的缓存。

4. 在 创建方法 下，选择 集群缓存。

5. 在 集群模式 下，选择 禁用，因为 不支持 该集群模式。即使未启用集群模式，你仍然可以在多个可用区中部署 Redis。

6. 在 集群信息 下，为集群命名 (gitlab-redis) 并添加描述。

7. 在 位置 下，选择 AWS 云 并启用 多可用区 选项。

8. 在集群设置部分：

   1. 对于引擎版本，选择我们的 Redis 要求 中针对你的极狐GitLab 版本定义的 Redis 版本。
   2. 将端口保留为 6379，因为这是我们之前在 Redis 安全组中使用的端口。
   3. 选择节点类型（至少 cache.t3.medium，但可根据你的需求调整）和副本数量。

9. 在连接设置部分：

   1. 网络类型：IPv4
   2. 子网组：选择 选择现有子网组，然后选择我们之前创建的 gitlab-redis-group。

10. 在可用区放置部分：

    1. 手动选择首选可用区，并在“副本 2”下 选择一个与其他两个不同的区域。

       

11. 选择 下一步。

12. 在安全设置中，编辑安全组并选择我们之前创建的 gitlab-redis-sec-group。选择 下一步。

13. 将其余设置保留为默认值，或根据自己的喜好进行编辑。

14. 完成后，选择 创建。

设置堡垒主机#

由于我们的极狐GitLab 实例位于私有子网中，我们需要一种通过 SSH 连接到这些实例以进行操作（包括进行配置更改和执行升级）的方法。一种方法是使用 堡垒主机，有时也称为跳板机。

创建堡垒主机 A#

1. 转到 EC2 控制台并选择 启动实例。
2. 在 名称和标签 部分，将 名称 设置为 Bastion Host A。
3. 选择最新的 Ubuntu Server LTS (HVM) AMI。检查极狐GitLab 文档以了解 最新支持的操作系统版本。
4. 选择一个实例类型。我们使用 t2.micro，因为我们只将堡垒主机用于 SSH 连接到其他实例。
5. 在 密钥对 部分，选择 创建新密钥对。
   1. 为密钥对命名（我们使用 bastion-host-a），并保存 bastion-host-a.pem 文件以备后用。
6. 编辑网络设置部分：
   1. 在 VPC 下，从下拉列表中选择 gitlab-vpc。
   2. 在 子网 下，选择我们之前创建的公有子网 (gitlab-public-10.0.0.0)。
   3. 检查 自动分配公有 IP 下是否选择了 禁用。稍后会在 下一部分 中将一个 弹性 IP 地址 分配给该主机。
   4. 在 防火墙 下，选择 创建安全组，输入 安全组名称（我们使用 bastion-sec-group），并添加描述。
   5. 我们允许从任何地方 (0.0.0.0/0) 进行 SSH 访问。如果你想要更严格的安全性，请指定单个 IP 地址或 CIDR 表示法的 IP 地址范围。
7. 对于存储，我们将所有内容保留为默认值，仅添加 8 GB 的根卷。我们不在该实例上存储任何内容。
8. 查看所有设置，如果满意，选择 启动实例。

为堡垒主机 A 分配弹性 IP#

1. 转到 EC2 控制台，选择 网络与安全。
2. 选择 弹性 IP，并将 网络边界组 设置为 us-west-2。
3. 选择 分配。
4. 选择已创建的弹性 IP 地址。
5. 选择 操作，然后选择 关联弹性 IP 地址。
6. 在 资源类型 下，选择 实例，并在 实例 下拉列表中选择 Bastion Host A 主机。
7. 选择 关联。

确认你可以通过 SSH 连接到实例#

1. 在 EC2 控制台中，选择左侧菜单中的 实例。
2. 从实例列表中选择 堡垒主机 A。
3. 选择 连接 并按照连接说明进行操作。
4. 如果能够成功连接，让我们继续设置第二个堡垒主机以实现冗余。

创建堡垒主机 B#

1. 使用与之前相同的步骤创建 EC2 实例，但进行以下更改：
   1. 对于 子网，选择我们之前创建的第二个公有子网 (gitlab-public-10.0.2.0)。
   2. 在 添加标签 部分，我们设置 键: Name 和 值: Bastion Host B 以便我们能识别这两个实例。
   3. 对于安全组，选择我们之前创建的现有 bastion-sec-group。

使用 SSH 代理转发#

运行 Linux 的 EC2 实例使用私钥文件进行 SSH 身份验证。你使用 SSH 客户端和存储在客户端的私钥文件连接到堡垒主机。由于堡垒主机上没有私钥文件，你无法连接到私有子网中的实例。

将私钥文件存储在堡垒主机上是个坏主意。为了解决这个问题，请在客户端上使用 SSH 代理转发。

例如，命令行 ssh 客户端使用其 -A 开关进行代理转发，如下所示：

shell
ssh -A user@<堡垒主机的公有 IP 地址>

有关如何为其他客户端使用 SSH 代理转发的分步指南，请参阅 安全连接到在私有 Amazon VPC 中运行的 Linux 实例。

安装极狐GitLab 并创建自定义 AMI#

我们需要一个预配置的自定义极狐GitLab AMI，以便稍后在我们的启动配置中使用。作为起点，我们使用官方极狐GitLab AMI 创建一个极狐GitLab 实例。然后，我们添加针对 PostgreSQL、Redis 和 Gitaly 的自定义配置。如果你愿意，也可以不使用官方极狐GitLab AMI，而是启动一个你选择的 EC2 实例并 手动安装极狐GitLab。

安装极狐GitLab#

从 EC2 控制台：

1. 使用以下标题为 在 AWS 上查找官方极狐GitLab 创建的 AMI ID 的部分查找正确的 AMI，然后选择 启动。
2. 在 名称和标签 部分，将 名称 设置为 GitLab。
3. 在 实例类型 下拉列表中，根据工作负载选择实例类型。请查阅 硬件要求 以选择适合你需求的类型（至少 c5.2xlarge，这足以容纳 100 个用户）。
4. 在 密钥对 部分，选择 创建新密钥对。
   1. 为密钥对命名（我们使用 gitlab），并保存 gitlab.pem 文件以备后用。
5. 在 网络设置 部分：

   1. VPC：选择 gitlab-vpc，我们之前创建的 VPC。

   2. 子网：从之前创建的子网列表中选择 gitlab-private-10.0.1.0。

   3. 自动分配公有 IP：选择 禁用。

   4. 防火墙：选择 选择现有安全组，然后根据你的负载均衡器方法选择适当的安全组：

      • 仅 NLB：gitlab-nlb-sec-group 和 bastion-sec-group
      • 混合 NLB->ALB：gitlab-rails-sec-group 和 bastion-sec-group

      bastion-sec-group 允许来自堡垒主机的 SSH 访问，以便使用 SSH 代理转发 进行管理和配置任务。

6. 对于存储，根卷默认为 8 GiB，这足够了，因为我们不会在那里存储任何数据。
7. 查看所有设置，如果满意，选择 启动实例。

添加自定义配置#

通过 堡垒主机 A 使用 SSH 代理转发 连接到你的极狐GitLab 实例。连接后，添加以下自定义配置：

禁 Let's Encrypt#

由于我们在负载均衡器处添加 SSL 证书，因此不需要极狐GitLab 内置的 Let's Encrypt 支持。当使用 https 域时，Let's Encrypt 默认 启用，因此我们必须显式禁用它：

1. 打开 /etc/gitlab/gitlab.rb 并禁用它：

   ruby
   letsencrypt['enable'] = false

2. 保存文件并重新配置以使更改生效：

   shell
   sudo gitlab-ctl reconfigure

为 PostgreSQL 安装所需的扩展#

从你的极狐GitLab 实例连接到 RDS 实例，以验证访问权限并安装 所需的 PostgreSQL 扩展。

要查找主机或端点，请前往 Amazon RDS > 数据库，然后选择你之前创建的数据库。在 连接与安全 选项卡下查找端点。

对于 -h，仅使用 RDS 端点主机名 - 省略尾部的冒号和端口号：

shell
sudo /opt/gitlab/embedded/bin/psql -U gitlab -h <rds-endpoint> -d gitlabhq_production

然后使用 CREATE EXTENSION 安装每个 所需的扩展：

sql
CREATE EXTENSION IF NOT EXISTS btree_gist;
CREATE EXTENSION IF NOT EXISTS ...;

使用 \dx 验证已安装的扩展。

配置极狐GitLab 以连接到 PostgreSQL 和 Redis#

1. 编辑 /etc/gitlab/gitlab.rb，找到 external_url 'http://<domain>' 选项 并将其更改为你正在使用的 https 域。

2. 查找极狐GitLab 数据库设置，并根据需要取消注释。在 我们当前的情况下，我们指定数据库适配器、编码、主机、名称、 用户名和密码：

   ruby
   1# 禁用内置的 Postgres
   2 postgresql['enable'] = false
   3
   4# 填写连接详细信息
   5gitlab_rails['db_adapter'] = "postgresql"
   6gitlab_rails['db_encoding'] = "unicode"
   7gitlab_rails['db_database'] = "gitlabhq_production"
   8gitlab_rails['db_username'] = "gitlab"
   9gitlab_rails['db_password'] = "mypassword"
   10gitlab_rails['db_host'] = "<rds-endpoint>"

3. 接下来，我们必须通过添加主机和 取消注释端口来配置 Redis 部分：

   ruby
   1# 禁用内置的 Redis
   2redis['enable'] = false
   3
   4# 填写连接详细信息
   5gitlab_rails['redis_host'] = "<redis-endpoint>"
   6gitlab_rails['redis_port'] = 6379
   7
   8# 根据你的 Redis 设置进行调整
   9gitlab_rails['redis_ssl'] = true

4. 最后，重新配置极狐GitLab 以使更改生效：

   shell
   sudo gitlab-ctl reconfigure

5. 你还可以运行检查和查看服务状态，以确保 所有内容已正确设置：

   shell
   sudo gitlab-rake gitlab:check
   sudo gitlab-ctl status

设置 Gitaly#

Gitaly 是一项通过高级 RPC 访问 Git 仓库的服务。 它应在我们之前配置的 私有子网 之一中单独的 EC2 实例上启用和配置。

让我们创建一个 EC2 实例并安装 Gitaly： 1.从 EC2 仪表板，选择 启动实例。

1. 在 名称和标签 部分，将 名称 设置为 Gitaly。
2. 选择一个 AMI。在本示例中，我们选择最新的 Ubuntu Server LTS（HVM），SSD 卷类型。查阅 极狐GitLab 文档中的 最新支持的操作系统版本。
3. 选择实例类型。我们选择 m5.xlarge。
4. 在 密钥对 部分，选择 创建新密钥对。
   1. 输入密钥对名称（我们使用 gitaly），并保存 gitaly.pem 文件以备后用。
5. 在网络设置部分：
   1. 在 VPC 下，从下拉列表中选择 gitlab-vpc。
   2. 在 子网 下，选择我们之前创建的私有子网（gitlab-private-10.0.1.0）。
   3. 确保在 自动分配公有 IP 下选择了 禁用。
   4. 在 防火墙 下，选择 创建安全组，输入 安全组名称（我们使用 gitlab-gitaly-sec-group），并添加描述。
      1. 创建一条 自定义 TCP 规则，并在 端口范围 中添加端口 8075。对于 源，根据你的负载均衡器方式选择适当的安全组：
         • 仅 NLB：gitlab-nlb-sec-group
         • 混合 NLB->ALB：gitlab-rails-sec-group
      2. 同时为来自 bastion-sec-group 的 SSH 添加入站规则，以便我们可以使用来自堡垒主机的 SSH 代理转发 进行连接。
6. 将根卷大小增加到 20 GiB，并将 卷类型 更改为 Provisioned IOPS SSD (io1)。（卷大小是一个任意值。为仓库存储需求创建足够大的卷。）
   1. 对于 IOPS，设置为 1000（20 GiB x 50 IOPS）。你可以为每 GiB 提供高达 50 IOPS。如果选择更大的卷，请相应地增加 IOPS。像 git 这样以串行方式写入许多小文件的工作负载需要高性能存储，因此选择 Provisioned IOPS SSD (io1)。
7. 查看所有设置，如果满意，选择 启动实例。

现在我们的 EC2 实例已准备就绪，请遵循 在独立服务器上安装 极狐GitLab 并设置 Gitaly 的文档。在之前创建的 极狐GitLab 实例 上执行该文档中的客户端设置步骤。

弹性文件系统 (EFS)#

如果你决定使用 EFS，请确保 PosixUser 属性要么省略，要么正确指定了安装 Gitaly 的系统上 git 用户的 UID 和 GID。可以使用以下命令获取 UID 和 GID：

shell
# UID
id -u git

# GID
id -g git

此外，你不应配置多个 访问点，尤其是它们指定了不同的凭证。除了 Gitaly 之外的应用程序可能会以阻止 Gitaly 正常运行的方式操纵 Gitaly 存储目录上的权限。有关此问题的示例，请参阅 omnibus-gitlab issue 8893。

添加对代理 SSL 的支持#

由于我们在 负载均衡器 处终止 SSL，请按照 支持代理 SSL 中的步骤在 /etc/gitlab/gitlab.rb 中配置。

记住在保存对 gitlab.rb 文件的更改后运行 sudo gitlab-ctl reconfigure。

快速查找授权 SSH 密钥#

允许访问 极狐GitLab 的用户的公钥 SSH 密钥存储在 /var/opt/gitlab/.ssh/authorized_keys 中。通常我们会使用共享存储，以便当用户通过 SSH 执行 Git 操作时所有实例都能访问此文件。由于在我们的设置中没有共享存储，我们更新配置以通过 极狐GitLab 数据库中的索引查找来授权 SSH 用户。

按照 设置快速 SSH 密钥查找 中的说明，从使用 authorized_keys 文件切换到数据库。

如果没有配置快速查找，通过 SSH 执行的 Git 操作将导致以下错误：

shell
Permission denied (publickey).
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

配置主机密钥#

通常我们会手动将主应用服务器上 /etc/ssh/ 的内容（主密钥和公钥）复制到所有辅助服务器上的 /etc/ssh。这可以防止在负载均衡器后面访问集群中的服务器时出现虚假的中间人攻击警报。

我们通过在自定义 AMI 中创建静态主机密钥来自动化此过程。由于这些主机密钥在每次 EC2 实例启动时也会轮换，将它们“硬编码”到自定义 AMI 中作为一种变通方法。

在你的 极狐GitLab 实例上运行以下命令：

shell
sudo mkdir /etc/ssh_static
sudo cp -R /etc/ssh/* /etc/ssh_static

在 /etc/ssh/sshd_config 中更新以下内容：

shell
# HostKeys for protocol version 2
HostKey /etc/ssh_static/ssh_host_rsa_key
HostKey /etc/ssh_static/ssh_host_dsa_key
HostKey /etc/ssh_static/ssh_host_ecdsa_key
HostKey /etc/ssh_static/ssh_host_ed25519_key

Amazon S3 对象存储#

由于我们没有使用 NFS 进行共享存储，我们使用 Amazon S3 存储桶来存储备份、产物、LFS 对象、上传、合并请求差异、容器镜像仓库镜像等。我们的文档包含针对每种数据类型的 如何配置对象存储的说明，以及有关将对象存储与 极狐GitLab 结合使用的其他信息。

记住在保存对 gitlab.rb 文件的更改后运行 sudo gitlab-ctl reconfigure。

---

至此，我们对 极狐GitLab 实例的配置更改已经完成。接下来，我们将基于此实例创建一个自定义 AMI，用于我们的启动配置和自动扩缩组。

IP 允许列表#

我们必须将之前创建的 gitlab-vpc 的 VPC IP 地址范围 (CIDR) 添加到 健康检查端点 的 IP 允许列表 中。

1. 编辑 /etc/gitlab/gitlab.rb：

   ruby
   gitlab_rails['monitoring_whitelist'] = ['127.0.0.0/8', '10.0.0.0/16']

2. 重新配置 极狐GitLab：

   shell
   sudo gitlab-ctl reconfigure

代理协议#

如果在之前创建的 负载均衡器 中启用了代理协议，我们还必须在 gitlab.rb 文件中 启用。

1. 编辑 /etc/gitlab/gitlab.rb：

   ruby
   nginx['proxy_protocol'] = true
   nginx['real_ip_trusted_addresses'] = [ "127.0.0.0/8", "IP_OF_THE_PROXY/32"]

2. 重新配置 极狐GitLab：

   shell
   sudo gitlab-ctl reconfigure

首次登录#

使用你在设置 负载均衡器的 DNS 时使用的域名，你现在应该能够在浏览器中访问 极狐GitLab。

根据你安装 极狐GitLab 的方式，以及你是否通过其他任何方式更改了密码，默认密码为以下之一：

• 如果你使用了官方 极狐GitLab AMI，则为你的实例 ID。
• 随机生成的密码，存储在 /etc/gitlab/initial_root_password 中，24 小时内有效。

要更改默认密码，使用默认密码以 root 用户身份登录，然后 在用户资料中更改它。

当我们的 自动扩缩组 启动新实例时，我们可以使用用户名 root 和新创建的密码登录。

创建自定义 AMI#

在 EC2 仪表板上：

1. 选择我们 之前创建 的 GitLab 实例。
2. 选择 操作，向下滚动到 镜像和模板，然后选择 创建镜像。
3. 为镜像命名并添加描述（我们为两者使用 GitLab-Source）。
4. 其他所有设置保留默认值，然后选择 创建镜像。

现在我们有了自定义 AMI，我们将在下一步中使用它来创建启动配置。

在自动扩缩组内部署极狐GitLab#

创建启动模板#

从 EC2 仪表板：

1. 从左侧菜单中选择 启动模板，然后选择 创建启动模板。

2. 输入启动模板的名称（我们使用 gitlab-launch-template）。

3. 选择 启动模板内容，然后选择 我的 AMI 选项卡/

4. 选择 我拥有的，然后选择我们之前创建的 GitLab-Source 自定义 AMI。

5. 选择最适合你需求的实例类型（至少 c5.2xlarge）。

6. 在 密钥对 部分，选择 创建新密钥对。

   1. 输入密钥对名称（我们使用 gitlab-launch-template），并保存 gitlab-launch-template.pem 文件以备后用。

7. 根卷大小默认为 8 GiB，由于我们不在那里存储任何数据，这应该足够了。选择 配置安全组。

8. 选中 选择现有安全组，然后根据你的负载均衡器方式选择适当的安全组：

   • 仅 NLB：gitlab-nlb-sec-group 和 bastion-sec-group
   • 混合 NLB->ALB：gitlab-rails-sec-group 和 bastion-sec-group

   bastion-sec-group 允许从堡垒主机进行 SSH 访问，以便使用 SSH 代理转发 执行管理和配置任务。

9. 在 高级详细信息 部分：

   1. IAM 实例配置文件：选择我们 之前创建 的 GitLabS3Access 角色。

10. 查看所有设置，如果满意，选择 创建启动模板。

创建自动扩缩组#

从 EC2 仪表板：

1. 从左侧菜单中选择 自动扩缩组，然后选择 创建自动扩缩组。

2. 输入 组名称（我们使用 gitlab-auto-scaling-group）。

3. 在 启动模板 下，选择我们之前创建的启动模板。选择 下一步。

4. 在网络设置部分：

   1. 在 VPC 下，从下拉列表中选择 gitlab-vpc。
   2. 在 可用区和子网 下，选择我们 之前创建的私有子网（gitlab-private-10.0.1.0 和 gitlab-private-10.0.3.0）。
   3. 选择 下一步。

5. 在负载均衡设置部分：

   1. 选择 附加到现有负载均衡器。
   2. 在 现有负载均衡器目标组 下拉列表中，根据你的负载均衡器方式选择适当的目标组：
      • 仅 NLB：选择 gitlab-nlb-ssh-target 和 gitlab-nlb-http-target
      • 混合 NLB->ALB：选择 gitlab-nlb-ssh-target 和 gitlab-alb-http-target 自动扩缩组会自动将所有启动的实例注册到这些目标组。
   3. 对于 健康检查类型，选中 打开 Elastic Load Balancing 健康检查 选项。我们将 健康检查宽限期 保留为默认的 300 秒。
   4. 选择 下一步。

6. 对于 组大小，将 所需容量 设置为 2。

7. 在扩展设置部分：

   1. 选择 无扩展策略。策略将在稍后配置。
   2. 最小所需容量：设置为 2。
   3. 最大所需容量：设置为 4。
   4. 选择 下一步。

8. 最后，根据需要配置通知和标签，查看更改，然后创建自动扩缩组。

9. 创建自动扩缩组后，我们需要在 Cloudwatch 中创建扩展和缩减策略并分配它们。

   1. 为我们之前创建的 EC2 实例 按自动扩缩组 的 CPUUtilization 指标创建警报。
   2. 使用以下条件创建 扩展策略：
      1. 当 CPUUtilization 大于或等于 60% 时，添加 1 个容量单位。
      2. 将 扩展策略名称 设置为 Scale Up Policy。

   

   1. 使用以下条件创建 缩减策略：
      1. 当 CPUUtilization 小于或等于 45% 时，移除 1 个容量单位。
      2. 将 缩减策略名称 设置为 Scale Down Policy。

   

   1. 将新的动态扩展策略分配给我们之前创建的自动扩缩组。

随着自动扩缩组的创建，你会在 EC2 仪表板中看到新实例正在启动。你还会看到新实例已添加到负载均衡器。实例通过健康检查后，它们就准备好开始接收来自负载均衡器的流量。

由于我们的实例是由自动扩缩组创建的，请返回你的实例，然后终止 我们之前手动创建的实例。我们只需要这个实例来创建我们的自定义 AMI。

使用 Prometheus 进行健康检查和监控#

除了可以在各种服务上启用的 Amazon CloudWatch 之外，极狐GitLab 还提供了自己的基于 Prometheus 的集成监控解决方案。有关如何设置它的更多信息，请参阅 极狐GitLab Prometheus。

极狐GitLab 还有各种 健康检查端点，你可以 ping 并获取报告。

GitLab Runner#

如果你想利用 极狐GitLab CI/CD，你必须设置至少一个 runner。

阅读更多关于 在 AWS 上配置自动扩缩的 GitLab Runner 的信息。

备份和恢复#

极狐GitLab 提供 一个备份工具，用于备份和恢复其 Git 数据、数据库、附件、LFS 对象等。

一些重要须知：

• 备份/恢复工具不会存储某些配置文件，如 secrets；你必须 自行配置。
• 默认情况下，备份文件存储在本地，但你可以 使用 S3 备份 极狐GitLab。
• 你可以 从备份中排除特定目录。

备份极狐GitLab#

要备份 极狐GitLab：

1. SSH 进入你的实例。

2. 执行备份：

   shell
   sudo gitlab-backup create

从备份恢复极狐GitLab#

要恢复 极狐GitLab，首先查看 恢复文档，尤其是恢复前提条件。然后，按照 Linux 软件包安装部分 中的步骤操作。

更新极狐GitLab#

极狐GitLab 每月在 发布日期 发布一个新版本。每当新版本发布时，你可以更新你的 极狐GitLab 实例：

1. SSH 进入你的实例

2. 执行备份：

   shell
   sudo gitlab-backup create

3. 更新仓库并安装 极狐GitLab：

   shell
   sudo apt update
   sudo apt install gitlab-ee

几分钟后，新版本应该启动并运行。

在 AWS 上查找官方 极狐GitLab 创建的 AMI ID#

阅读更多关于如何使用 极狐GitLab 版本作为 AMI 的信息。

总结#

在本指南中，我们主要介绍了扩展和一些冗余选项，你的实际结果可能有所不同。

请记住，所有解决方案都需要在成本/复杂性和正常运行时间之间进行权衡。你想要的正常运行时间越多，解决方案就越复杂。解决方案越复杂，设置和维护它所需的工作就越多。

阅读以下其他资源，并随时 创建一个议题 以请求其他资料：

• 扩展 极狐GitLab：极狐GitLab 支持多种不同类型的集群。
• Geo 复制：Geo 是面向广泛分布开发团队的解决方案。
• Linux 软件包 - 你必须要知道的关于管理你的 极狐GitLab 实例的一切。
• 添加许可证：使用许可证激活所有 极狐GitLab Enterprise Edition 功能。
• 定价：不同级别的定价。

故障排除#

实例健康检查失败#

如果你的实例未能通过负载均衡器的健康检查，请验证它们是否从我们之前配置的健康检查端点返回状态 200。任何其他状态，包括像状态 302 的重定向，都会导致健康检查失败。

你可能需要为 root 用户设置密码，以防止在健康检查通过之前登录端点上的自动重定向。

提示：您请求的更改被拒绝 (422)#

如果在尝试通过 Web 界面设置密码时看到此页面，请确保 gitlab.rb 中的 external_url 与你发起请求的域匹配，并在对其进行任何更改后运行 sudo gitlab-ctl reconfigure。

某些作业日志未上传到对象存储#

当 极狐GitLab 部署扩展到多个节点时，某些作业日志可能无法正确上传到 对象存储。CI 需要 增量日志记录 才能使用对象存储。

如果尚未启用，请启用 增量日志记录。