**帮助改进此页面**
要帮助改进本用户指南，请选择位于每个页面右侧窗格中的**在 GitHub 上编辑此页面**链接。
# 使用节点来管理计算资源
Kubernetes 节点是运行容器化应用程序的机器。每个节点包含下列组件：
+ **[容器运行时](https://kubernetes.io/docs/setup/production-environment/container-runtimes/)** – 负责运行容器的软件。
+ ** [kubelet](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/) ** – 确保容器运行状况良好且在关联的容器组（pod）中运行。
+ ** [kube-proxy](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-proxy/) ** – 维护允许与容器组（pod）通信的网络规则。
有关更多信息，请参阅 Kubernetes 文档中的[节点](https://kubernetes.io/docs/concepts/architecture/nodes/)。
Amazon EKS 集群可以按照任意 [EKS 自动模式托管节点](automode.md)、[自主管理型节点](worker.md)、[Amazon EKS 托管节点组](managed-node-groups.md)、[AWS Fargate](fargate.md) 以及 [Amazon EKS 混合节点功能](hybrid-nodes-overview.md)组合调度容器组（pod）。要了解集群中部署的节点的更多信息，请参阅 [在 AWS 管理控制台中查看 Kubernetes 资源](view-kubernetes-resources.md)。
**注意**
除混合节点外，节点必须位于与您创建集群时所选子网相同的 VPC 中。不过，节点不需要在相同子网中。
## 比较计算选项
下表提供了在决定哪些选项最符合您的要求时需要评估的几个标准。另一个选项是自主管理型节点，此选项支持所列的所有标准，但需要更多的手动维护。有关更多信息，请参阅 [使用自行管理型节点来自行维护节点](worker.md)。
**注意**
Bottlerocket 与此表中的一般信息有一些具体的区别。有关更多信息，请参阅 GitHub 上的 Bottlerocket [文档](https://github.com/bottlerocket-os/bottlerocket/blob/develop/README.md)。
| 标准 | EKS 托管节点组 | EKS 自动模式 | Amazon EKS 混合节点功能 |
| --- | --- | --- | --- |
| 可以部署到 [AWS Outposts](https://docs.aws.amazon.com/outposts/latest/userguide/what-is-outposts.html) | 否 | 否 | 否 |
| 可以部署到 [AWS 本地区域](local-zones.md) | 是 | 否 | 否 |
| 可以运行需要 Windows 的容器 | 是 | 否 | 否 |
| 可以运行需要 Linux 的容器 | 支持 | 是 | 是 |
| 可以运行需要 Inferentia 芯片的工作负载 | [是](inferentia-support.md) – 仅限 Amazon Linux 节点 | 是 | 否 |
| 可以运行需要 GPU 的工作负载 | [是](eks-optimized-ami.md#gpu-ami) – 仅限 Amazon Linux 节点 | 支持 | 是 |
| 可以运行需要 ARM 处理器的工作负载 | [是](eks-optimized-ami.md#arm-ami) | 是 | 是 |
| 可以运行 AWS [ Bottlerocket](https://aws.amazon.com/bottlerocket/) | 支持 | 是 | 否 |
| 容器组之间共享 CPU、内存、存储和网络资源。 | 支持 | 是 | 是 |
| 必须部署和管理 Amazon EC2 实例 | 是 | 否 – 了解 [EC2 托管式实例](automode-learn-instances.md) | 是 – 本地物理计算机或虚拟机由您使用自己选择的工具进行管理。 |
| 必须保护、维护和修补 Amazon EC2 实例的操作系统 | 是 | 否 | 是 – 在物理计算机或虚拟机上运行的操作系统由您使用自己选择的工具进行管理。 |
| 可以在部署节点时提供引导参数，例如额外的 [kubelet](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/) 实际参数。 | 是 – 使用 `eksctl` 或将[启动模板](launch-templates.md)与自定义 AMI 结合使用。 | 否 – [使用 `NodeClass` 配置节点](create-node-class.md) | 是 – 可以使用 nodeadm 自定义引导参数。请参阅 [混合节点 `nodeadm` 参考](hybrid-nodes-nodeadm.md)。 |
| 可以从与分配给节点的 IP 地址不同的 CIDR 块为容器组（pod）分配 IP 地址。 | 是 – 结合使用启动模板和自定义 AMI。有关更多信息，请参阅 [使用启动模板自定义托管式节点](launch-templates.md)。 | 否 | 是 – 请参阅[为混合节点配置 CNI](hybrid-nodes-cni.md)。 |
| 可以通过 SSH 访问节点 | 是 | 否 – [了解如何进行节点故障排除](auto-troubleshoot.md) | 是 |
| 可以将您自己的自定义 AMI 部署到节点 | 是 – 使用[启动模板](launch-templates.md) | 否 | 是 |
| 可以将自己的自定义 CNI 部署到节点 | 是 – 结合使用[启动模板](launch-templates.md)和自定义 AMI | 否 | 是 |
| 必须自己更新节点 AMI | [是](update-managed-node-group.md) – 如果部署 Amazon EKS 优化版 AMI，更新可用时，Amazon EKS 控制台会通知您。可以在控制台中单击一键执行更新。如果部署自定义 AMI，更新可用时，Amazon EKS 控制台不会通知您。必须自己执行更新。 | 否 | 是 – 在物理计算机或虚拟机上运行的操作系统由您使用自己选择的工具进行管理。请参阅 [为混合节点准备操作系统](hybrid-nodes-os.md)。 |
| 必须自己更新节点 Kubernetes 版本 | [是](update-managed-node-group.md) – 如果部署 Amazon EKS 优化版 AMI，更新可用时，Amazon EKS 控制台会通知您。可以在控制台中单击一键执行更新。如果部署自定义 AMI，更新可用时，Amazon EKS 控制台不会通知您。必须自己执行更新。 | 否 | 是 – 您可以使用自己选择的工具或使用 `nodeadm` 来管理混合节点升级。请参阅 [升级集群的混合节点](hybrid-nodes-upgrade.md)。 |
| 可以为容器组（pod）使用 Amazon EBS 存储 | [是](ebs-csi.md) | 是，作为一项集成功能。了解如何[创建存储类](create-storage-class.md)。 | 否 |
| 可以为容器组（pod）使用 Amazon EFS 存储 | [是](efs-csi.md) | 是 | 否 |
| 可以为容器组（pod）使用适用于 Lustre 的 Amazon FSx 存储 | [是](fsx-csi.md) | 是 | 否 |
| 可以对服务使用 Network Load Balancer | [是](network-load-balancing.md) | 是 | 是 – 必须使用目标类型 `ip`。 |
| Pod 可以在公有子网中运行 | 支持 | 是 | 否 – 容器组在本地环境中运行。 |
| 可以将不同的 VPC 安全组分配给各个容器组（pod） | [是](security-groups-for-pods.md) – 仅限 Linux 节点 | 否 | 否 |
| 可以运行 Kubernetes DaemonSets | 支持 | 是 | 是 |
| 支持容器组（pod）清单中的 `HostPort` 和 `HostNetwork` | 支持 | 是 | 是 |
| AWS 区域可用性 | [所有 Amazon EKS 支持的区域](https://docs.aws.amazon.com/general/latest/gr/eks.html) | [所有 Amazon EKS 支持的区域](https://docs.aws.amazon.com/general/latest/gr/eks.html) | [所有支持 Amazon EKS 的区域](https://docs.aws.amazon.com/general/latest/gr/eks.html)，AWS GovCloud（美国）区域和中国区域除外。 |
| 可以在 Amazon EC2 专属主机上运行容器 | 是 | 否 | 否 |
| 定价 | 运行多个容器组（pod）的 Amazon EC2 实例的成本。有关更多信息，请参阅 [Amazon EC2定价](https://aws.amazon.com/ec2/pricing/)。 | 在集群中启用 EKS 自动模式后，除标准的 EC2 实例费用外，您还需要为使用自动模式的计算能力启动的实例单独付费。具体金额因启动的实例类型和集群所在 AWS 区域而异。有关更多信息，请参阅 [Amazon EKS 定价](https://aws.amazon.com/eks/pricing/)。 | 每小时的混合节点 vCPU 成本。有关更多信息，请参阅 [Amazon EKS 定价](https://aws.amazon.com/eks/pricing/)。 |
# 使用托管式节点组简化节点生命周期
Amazon EKS 托管节点组为 Amazon EKS Kubernetes 集群自动对节点（Amazon EC2 实例）进行预置和生命周期管理。
使用 Amazon EKS 托管节点组，您无需单独预置或注册 Amazon EC2 实例以提供计算容量来运行 Kubernetes 应用程序。您可以通过单个操作为集群创建、自动更新或终止节点。节点的更新和终止操作会自动耗尽节点，以确保您的应用程序保持为可用的状态。
所有托管节点均作为由 Amazon EKS 为您管理的 Amazon EC2 Auto Scaling 组的一部分进行预置。所有资源（包括实例和自动扩缩组在内）都在您的 AWS 账户中运行。每个节点组跨您定义的多个可用区运行。
托管式节点组还可以选择利用节点自动修复功能，从而持续监控节点的运行状况。此功能还会自动处理检测到的问题，并在可能的情况下替换节点。这有助于在尽可能减少手动干预的情况下提高集群的整体可用性。有关更多信息，请参阅 [检测节点运行状况问题并启用自动节点修复](node-health.md)。
您可以使用 Amazon EKS 控制台、`eksctl`、AWS CLI、AWS API 或基础设施即代码工具（包括 AWS CloudFormation），将托管式节点组添加到新的或现有集群中。作为托管节点组一部分启动的节点会自动进行标记，以便 Kubernetes [Cluster Autoscaler](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/cloudprovider/aws/README.md) 能自动发现这些节点。您可以使用节点组将 Kubernetes 标签应用到节点并随时更新它们。
使用 Amazon EKS 托管节点组没有额外的费用，您只需为预置的 AWS 资源付费。这些资源包括 Amazon EC2 实例、Amazon EBS 卷、Amazon EKS 集群小时数和任何其他 AWS 基础设施。无最低费用，无预先承诺。
要开始使用新 Amazon EKS 集群和托管节点组，请参阅 [开始使用 Amazon EKS – AWS 管理控制台和 AWS CLI](getting-started-console.md)。
要将托管节点组添加到现有集群，请参阅 [为集群创建托管式节点组](create-managed-node-group.md)。
## 托管节点组概念
+ Amazon EKS 托管节点组为您创建和管理 Amazon EC2 实例。
+ 所有托管节点均作为由 Amazon EKS 为您管理的 Amazon EC2 Auto Scaling 组的一部分进行预置。此外，包括 Amazon EC2 实例和自动扩缩组在内的所有资源都在您的 AWS 账户中运行。
+ 托管节点组的弹性伸缩组涵盖您在创建组时指定的所有子网。
+ Amazon EKS 标记托管节点组资源，以便将其配置为使用 Kubernetes [Cluster Autoscaler](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/cloudprovider/aws/README.md)。
**重要**
如果要使用 Kubernetes [Cluster Autoscaler](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/cloudprovider/aws/README.md) 在由 Amazon EBS 卷支持的多个可用区中运行有状态应用程序，则应该配置多个节点组，且每个节点组的范围都限定为一个可用区。此外，您还应该启用 `--balance-similar-node-groups` 功能。
+ 在部署托管节点时，可以使用自定义启动模板以获得更大灵活性和自定义性。例如，您可以指定额外的 `kubelet` 参数并使用自定义 AMI。有关更多信息，请参阅 [使用启动模板自定义托管式节点](launch-templates.md)。如果首次创建托管节点组时没有使用自定义启动模板，则会有自动生成的启动模板。不要手动修改此自动生成的模板，否则会发生错误。
+ Amazon EKS 在托管节点组上遵循 CVE 和安全补丁的责任共担模式。当托管节点运行 Amazon EKS 优化版 AMI 时，Amazon EKS 负责在报告 Bug 或问题时构建 AMI 的修补版本。我们可以发布修复程序。但是，您负责将这些修补的 AMI 版本部署到托管节点组。当托管节点运行自定义 AMI 时，您要负责在报告 Bug 或问题时构建 AMI 的修补版本，然后部署 AMI。有关更多信息，请参阅 [更新集群的托管式节点组](update-managed-node-group.md)。
+ Amazon EKS 托管节点组既可以在公有子网也可以在私有子网中启动。如果您在不早于 2020 年 4 月 22 日启动了公有子网中的托管节点组，则子网必须将 `MapPublicIpOnLaunch` 设置为 true，这些实例才能成功加入集群。如果公有子网是使用 `eksctl` 或 [Amazon EKS 发布的 AWS CloudFormation 模板](creating-a-vpc.md)并在 2020 年 3 月 26 日或之后创建的，则此设置已设置为 true。如果在 2020 年 3 月 26 日之前创建了公有子网，则必须手动更改设置。有关更多信息，请参阅[修改子网的公有 IPv4 寻址属性](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-ip-addressing.html#subnet-public-ip)。
+ 在私有子网中部署托管节点组时，必须确保它可以访问 Amazon ECR 来拉取容器映像。您可以通过将 NAT 网关连接到子网的路由表或添加以下 [AWS PrivateLink VPC 端点](https://docs.aws.amazon.com/AmazonECR/latest/userguide/vpc-endpoints.html#ecr-setting-up-vpc-create)来实现此目的：
+ Amazon ECR API 端点接口 – `com.amazonaws.region-code.ecr.api`
+ Amazon ECR Docker 注册表 API 端点接口 – `com.amazonaws.region-code.ecr.dkr`
+ Amazon S3 网关端点 – `com.amazonaws.region-code.s3`
有关其他常用服务和端点的信息，请参阅 [部署具有有限互联网访问权限的私有集群](private-clusters.md)。
+ 托管节点组无法部署在 [AWS Outposts](eks-outposts.md) 上或 [AWS Wavelength](https://docs.aws.amazon.com/wavelength/) 中。托管节点组现已可在 [AWS Local Zones](https://aws.amazon.com/about-aws/global-infrastructure/localzones/) 中创建。有关更多信息，请参阅 [使用 AWS Local Zones 启动低延迟 EKS 集群](local-zones.md)。
+ 您可以在单个集群中创建多个托管节点组。例如，您可以为某些工作负载使用标准的 Amazon EKS 优化版 Amazon Linux AMI 创建一个节点组，为需要 GPU 支持的工作负载使用 GPU 变体创建另一个节点组。
+ 如果您的托管节点组遇到 [Amazon EC2 实例状况检查](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-system-instance-status-check.html)失败，则 Amazon EKS 会返回错误代码来帮助您诊断问题。有关更多信息，请参阅 [托管节点组错误代码](troubleshooting.md#troubleshoot-managed-node-groups)。
+ Amazon EKS 将 Kubernetes 标签添加到托管节点组实例。Amazon EKS 提供的这些标签带有前缀 `eks.amazonaws.com`。
+ 在终止或更新期间，Amazon EKS 使用 Kubernetes API 自动耗尽节点。
+ 使用 `AZRebalance` 终止节点或减少所需节点数量时，未遵守容器组（pod）中断预算。这些操作试图驱逐节点上的容器组（pod）。但如果超过 15 分钟，则无论节点上的所有容器组（pod）是否都被终止，该节点都会终止。要将时间延长至节点终止，请向自动扩缩组添加生命周期挂钩。有关更多信息，请参阅《Amazon EC2 Auto Scaling 用户指南》**中的[添加生命周期挂钩](https://docs.aws.amazon.com/autoscaling/ec2/userguide/adding-lifecycle-hooks.html)。
+ 为了在收到 Spot 中断通知或容量再平衡通知后正确运行耗尽进程，必须将 `CapacityRebalance` 设置为 `true`。
+ 更新托管节点组遵循您为容器组（pod）设置的容器组（pod）中断预算。有关更多信息，请参阅 [了解节点更新的各个阶段](managed-node-update-behavior.md)。
+ 使用 Amazon EKS 托管节点组不会产生额外的费用。您仅需为预置的AWS资源付费。
+ 如果要为节点加密 Amazon EBS 卷，可以使用启动模板部署节点。要在不使用启动模板的情况下部署包含加密 Amazon EBS 卷的托管节点，必须对账户中创建的所有新 Amazon EBS 卷进行加密。有关更多信息，请参阅 *Amazon EC2 用户指南*中的[默认加密](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-by-default)。
## 托管节点组容量类型
创建托管节点组时，您可以选择按需容量或 Spot 容量类型。Amazon EKS 使用 Amazon EC2 Auto Scaling 组部署托管节点组，该组只包含按需实例或只包含 Amazon EC2 竞价型实例。您可以将容错应用程序的容器组（pod）调度到 Spot 托管节点组，将容错应用程序调度到单个 Kubernetes 集群中的按需节点组。预设情况下，托管节点组部署按需 Amazon EC2 实例。
### 按需
使用按需实例，您按秒为计算容量支付费用，无需长期订阅。
预设情况下，如果您没有指定**容量类型**，则会使用按需实例预置托管节点组。托管节点组会代表您配置 Amazon EC2 Auto Scaling 组，并应用以下设置：
+ 预置按需容量的分配策略设置为 `prioritized`。托管节点组使用实例类型在 API 中的传入顺序，确定在满足按需容量时首先使用哪种实例类型。例如，您可以按以下顺序指定三种实例类型：`c5.large`、`c4.large` 和 `c3.large`。在启动您的按需实例时，托管节点组满足按需容量的顺序是从 `c5.large` 开始，然后是 `c4.large`，再然后是 `c3.large`。有关更多信息，请参阅 *Amazon EC2 Auto Scaling 用户指南*中的 [Amazon EC2 Auto Scaling 组](https://docs.aws.amazon.com/autoscaling/ec2/userguide/asg-purchase-options.html#asg-allocation-strategies)。
+ Amazon EKS 会向您指定了容量类型的托管节点组中的所有节点添加以下 Kubernetes 标注：`eks.amazonaws.com/capacityType: ON_DEMAND`。您可以使用此标注在按需节点上调度有状态或不容错的应用程序。
### Spot
Amazon EC2 Spot 实例是备用的 Amazon EC2 容量，价格相当于在按需实例价格上打了巨大折扣。当 EC2 需要收回容量时，Amazon EC2 Spot 实例可能中断并发出一个两分钟的中断通知。有关更多信息，请参阅 *Amazon EC2 用户指南*中的[竞价型实例](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances.html)。您可以使用 Amazon EC2 Spot 实例配置托管节点组，以优化 Amazon EKS 集群中运行的计算节点的成本。
要在托管节点组中使用 Spot 实例，请将容量类型设置为 `spot`，创建托管节点组。托管节点组使用以下 Spot 最佳实践代表您配置 Amazon EC2 Auto Scaling 组：
+ 为确保在最佳 Spot 容量池中预置 Spot 节点，将分配策略设置为以下策略之一：
+ `price-capacity-optimized`（PCO）– 在 Kubernetes `1.28` 版本或更高版本的集群中创建新节点组时，将分配策略设置为 `price-capacity-optimized`。但是，对于在 Amazon EKS 托管节点组开始支持 PCO 之前使用 `capacity-optimized` 创建的节点组，分配策略不会更改。
+ `capacity-optimized`（CO）– 在 Kubernetes `1.27` 版本或更低版本的集群中创建新节点组时，将分配策略设置为 `capacity-optimized`。
要增加可用于分配容量的 Spot 容量池的数量，请将托管节点组配置为使用多个实例类型。
+ 启用了 Amazon EC2 Spot 容量再平衡，以便 Amazon EKS 能够顺畅地耗尽和重新平衡您的 Spot 节点，从而在 Spot 节点中断风险增加时最大限度地减少应用程序中断。有关更多信息，请参阅 *Amazon EC2 Auto Scaling 用户指南*中的 [Amazon EC2 Auto Scaling 容量再平衡](https://docs.aws.amazon.com/autoscaling/ec2/userguide/capacity-rebalance.html)。
+ Spot 节点收到再平衡建议时，Amazon EKS 会自动尝试启动新的替换 Spot 节点。
+ 如果 Spot 两分钟中断通知在替换 Spot 节点进入 `Ready` 状态之前到达时间，Amazon EKS 将开始耗尽收到再平衡建议的 Spot 节点。Amazon EKS 会尽最大努力耗尽节点。因此，无法保证 Amazon EKS 会等待替换节点加入集群后再耗尽现有节点。
+ 当替换 Spot 节点引导启动并在 Kubernetes 中处于 `Ready` 状态后，Amazon EKS 将封锁并耗尽收到再平衡建议的 Spot 节点。封锁 Spot 节点可确保服务控制器不会向此 Spot 节点发送任何新请求。它还将其从其运行状况良好的活动 Spot 节点列表中删除。耗尽 Spot 节点可确保正在运行的容器组（pod）被自然地逐出。
+ Amazon EKS 会向您指定了容量类型的托管节点组中的所有节点添加以下 Kubernetes 标注：`eks.amazonaws.com/capacityType: SPOT`。您可以使用此标注在 Spot 节点上安排容错应用程序。
**重要**
EC2 会在终止您的竞价型实例前两分钟发出[竞价型实例中断通知](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-instance-termination-notices.html)。但是，竞价型实例节点上的容器组（pod）可能无法获得完整的 2 分钟正常关闭时段。当 EC2 发出通知时，Amazon EKS 开始驱逐容器组（pod）之前会有延迟。驱逐按顺序进行，以保护 Kubernetes API 服务器，因此在同时进行多次竞价型实例回收期间，某些容器组（pod）可能会收到延迟驱逐的通知。容器组（pod）可能会在未接收到终止信号的情况下被强制终止，尤其是在高密度的容器组（pod）节点上、并发回收期间或使用较长的终止宽限期时。对于竞价型实例工作负载，建议将应用程序设计为可承受中断，使用 30 秒或更短的终止宽限期，避免长时间运行的 PreStop 钩子，并监控容器组（pod）驱逐指标以了解集群中的实际宽限期。对于需要保证正常终止的工作负载，建议改用按需容量。
在决定是部署具有按需容量还是 Spot 容量的节点组时，应考虑以下条件：
+ Spot 实例适合无状态、容错且灵活的应用程序。其中包括批处理和机器学习培训工作负载、大数据 ETL（例如 Apache Spark）、队列处理应用程序和无状态 API 端点。由于 Spot 是备用 Amazon EC2 容量，这些容量可能会随时间变化，因此我们建议您对可容忍中断的工作负载使用 Spot 容量。更具体地说，Spot 容量适合可以容忍所需容量不可用的时段的工作负载。
+ 我们建议您为不容错的应用程序使用 On-Demand。这包括集群管理工具，例如监控和操作工具，需要 `StatefulSets` 的部署，以及有状态的应用程序，如数据库。
+ 为了在使用 Spot 实例时最大限度地提高应用程序的可用性，我们建议您将 Spot 托管节点组配置为使用多个实例类型。我们建议在使用多个实例类型时应用以下规则：
+ 在托管节点组中，如果使用 [Cluster Autoscaler](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/cloudprovider/aws/README.md)，我们建议使用具有相同数量 vCPU 和内存资源的灵活实例类型集。这是为了确保集群中的节点按预期进行扩缩。例如，如果需要 4 个 vCPU 和 8 GiB 内存，请使用 `c3.xlarge`、`c4.xlarge`、`c5.xlarge`、`c5d.xlarge`、`c5a.xlarge`、`c5n.xlarge` 或其他类似实例类型。
+ 为了提高应用程序可用性，我们建议部署多个 Spot 托管节点组。为此，每个组应使用一组具有相同 vCPU 和内存资源的灵活实例类型。例如，如果您需要 4 个 vCPU 和 8 GiB 内存，我们建议您使用 `c3.xlarge`、`c4.xlarge`、`c5.xlarge`、`c5d.xlarge`、`c5a.xlarge`、`c5n.xlarge` 或其他类似的实例类型创建一个托管节点组，并使用 `m3.xlarge`、`m4.xlarge`、`m5.xlarge`、`m5d.xlarge`、`m5a.xlarge`、`m5n.xlarge` 或其他类似的实例类型创建第二个托管节点组。
+ 用使用自定义启动模板的 Spot 容量类型部署节点组时，请使用 API 传递多个实例类型。不要通过启动模板传递单个实例类型。有关使用启动模板部署节点组的更多信息，请参阅 [使用启动模板自定义托管式节点](launch-templates.md)。
# 为集群创建托管式节点组
本主题介绍了如何启动向 Amazon EKS 集群注册的节点的 Amazon EKS 托管节点组。在这些节点加入集群后，您可以向其部署 Kubernetes 应用程序。
如果这是您首次启动 Amazon EKS 托管节点组，建议您改为遵循[开始使用 Amazon EKS](getting-started.md)中的指南之一。这些指南提供了有关创建包含节点的 Amazon EKS 集群的演练。
**重要**
Amazon EKS 节点是标准的 Amazon EC2 实例。将根据正常的 Amazon EC2 价格向您计费。有关更多信息，请参阅 [Amazon EC2 定价](https://aws.amazon.com/ec2/pricing/)。
您无法在启用了 AWS Outposts 或 AWS Wavelength 的 AWS 区域创建托管节点。您可以创建自行管理的节点。有关更多信息，请参阅 [创建自行管理的 Amazon Linux 节点](launch-workers.md)、[创建自主管理型 Microsoft Windows 节点](launch-windows-workers.md) 和 [创建自主管理型 Bottlerocket 节点](launch-node-bottlerocket.md)。您还可以在 Outpost 上创建自行管理的 Amazon Linux 节点组。有关更多信息，请参阅 [在 AWS Outpost 上创建 Amazon Linux 节点](eks-outposts-self-managed-nodes.md)。
如果您没有为包含在 Amazon EKS 优化版 Linux 或 Bottlerocket 中的 `bootstrap.sh` 文件[指定 AMI ID](launch-templates.md#launch-template-custom-ami)，则托管节点组会对 `maxPods` 的值强制实施最大数量。对于 vCPU 少于 30 个的实例，最大数量为 `110`。对于 vCPU 大于 30 个的实例，最大数量将跳至 `250`。此强制执行措施会覆盖其他 `maxPods` 配置，包括 `maxPodsExpression`。有关如何确定 `maxPods` 以及如何对其进行自定义的更多信息，请参阅 [如何确定 maxPods](choosing-instance-type.md#max-pods-precedence)。
+ 现有 Amazon EKS 集群。要部署一个角色，请参阅[创建一个 Amazon EKS 集群。](create-cluster.md)。
+ 供节点使用的现有 IAM 角色。要创建该文件，请参阅 [Amazon EKS 节点 IAM 角色](create-node-role.md)。如果此角色没有 VPC CNI 的任一策略，则需要为 VPC CNI Pod 使用随后的单独角色。
+ （可选，但推荐）适用于 Kubernetes 附加组件的 Amazon VPC CNI 插件已配置自己的 IAM 角色，并附加了必要的 IAM 策略。有关更多信息，请参阅 [配置 Amazon VPC CNI 插件以使用 IRSA](cni-iam-role.md)。
+ 熟悉[选择最优的 Amazon EC2 节点实例类型](choosing-instance-type.md)中列出的注意事项。根据您选择的实例类型，您的集群和 VPC 可能还有其他先决条件。
+ 要添加 Windows 托管节点组，必须先启用对集群的 Windows 支持。有关更多信息，请参阅 [在 EKS 集群上部署 Windows 节点](windows-support.md)。
您可以使用以下任一途径创建托管节点组：
+ [`eksctl`](#eksctl_create_managed_nodegroup)
+ [AWS 管理控制台](#console_create_managed_nodegroup)
## `eksctl`
**使用 eksctl 创建托管节点组**
此过程需要 `eksctl` 版本 `0.215.0` 或更高版本。可以使用以下命令来查看您的版本：
```
eksctl version
```
有关安装或升级 `eksctl` 的说明，请参阅 `eksctl` 文档中的 [Installation](https://eksctl.io/installation)。
1. （可选）如果 **AmazonEKS\$1CNI\$1Policy** 托管的 IAM 策略附加到 [Amazon EKS 节点 IAM 角色](create-node-role.md)，我们建议将其分配给您与 Kubernetes `aws-node` 服务账户关联的 IAM 角色。有关更多信息，请参阅 [配置 Amazon VPC CNI 插件以使用 IRSA](cni-iam-role.md)。
1. 使用或不使用自定义启动模板创建托管节点组。手动指定启动模板可允许对节点组进行更好的自定义。例如，它可以允许部署自定义 AMI 或向 Amazon EKS 优化的 AMI 中的 `boostrap.sh` 脚本提供参数。要查看所有可用选项和原定设置的完整列表，请输入以下命令。
```
eksctl create nodegroup --help
```
在以下命令中，将 *my-cluster* 替换为您的集群名称，并将 *my-mng* 替换为您的节点组名称。节点组名称的长度不能超过 63 个字符。它必须以字母或数字开头，但也可以包括其余字符的连字符和下划线。
**重要**
如果首次创建托管节点组时没有使用自定义启动模板，则以后不要对节点组使用模板。如果没有指定自定义启动模板，系统会自动生成启动模板，我们不建议您手动修改该模板。手动修改此自动生成的启动模板可能会导致错误。
**不使用启动模板**
`eksctl` 在您的账户中创建默认的 Amazon EC2 启动模板，并使用它根据您指定的选项创建的启动模板来部署节点组。在为 `--node-type` 指定值之前，请参阅 [选择最优的 Amazon EC2 节点实例类型](choosing-instance-type.md)。
将 *ami-family* 替换为允许的关键字。有关更多信息，请参阅 `eksctl` 文档中的 [Setting the node AMI Family](https://eksctl.io/usage/custom-ami-support/#setting-the-node-ami-family)（设置节点 AMI 系列）。将 *my-key* 替换为您的 Amazon EC2 密钥对或公有密钥的名称。此密钥用于在节点启动后通过 SSH 进入节点。
**注意**
对于 Windows，此命令不会启用 SSH。反之，它会将 Amazon EC2 密钥对与实例关联，并允许您 RDP 到实例中。
如果还没有 Amazon EC2 密钥对，可以在 AWS 管理控制台 中创建一个。有关 Linux 信息，请参阅《Amazon EC2 用户指南》**中的 [Amazon EC2 密钥对和 Linux 实例](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)。有关 Windows 信息，请参阅《Amazon EC2 用户指南》**中的 [Amazon EC2 密钥对和 Windows 实例](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ec2-key-pairs.html)。
如果满足以下条件，我们建议阻止容器组（pod）访问 IMDS：
+ 您计划将 IAM 角色分配给所有 Kubernetes 服务账户，以便容器组（pod）仅具有其所需的最低权限。
+ 集群中没有任何容器组（pod）需要出于其他原因（例如检索当前 AWS 区域）访问 Amazon EC2 实例元数据服务（IMDS）。
有关更多信息，请参阅[限制对分配给工作节点的实例配置文件的访问](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node)。
如果要阻止容器组（pod）访问 IMDS，请将 `--disable-pod-imds` 选项添加到以下命令。
```
eksctl create nodegroup \
--cluster my-cluster \
--region region-code \
--name my-mng \
--node-ami-family ami-family \
--node-type m5.large \
--nodes 3 \
--nodes-min 2 \
--nodes-max 4 \
--ssh-access \
--ssh-public-key my-key
```
实例可以选择为容器组（pod）分配更多 IP 地址，为其他 CIDR 块（而不是实例的 CIDR 块）中的容器组（pod）分配 IP 地址，并将其部署到没有互联网访问的集群。有关更多信息，请参阅 [为带前缀的 Amazon EKS 节点分配更多 IP 地址](cni-increase-ip-addresses.md)、[使用自定义网络在备用子网中部署容器组（pod）](cni-custom-network.md) 和 [部署具有有限互联网访问权限的私有集群](private-clusters.md)，以获取要添加到上一个命令中的其他选项。
托管节点组将根据实例类型计算并应用单个值，以作为可以在节点组的每个节点上运行的最大容器组（pod）数量。如果创建具有不同实例类型的节点组，则在所有实例类型中计算得出的最小值将应用为可以在节点组中每种实例类型上运行的最大容器组（pod）数量。托管节点组会使用 中引用的脚本计算值。
**使用启动模板**
启动模板必须已存在，并且必须满足[启动模板配置基础知识](launch-templates.md#launch-template-basics)中指定的要求。如果满足以下条件，我们建议阻止容器组（pod）访问 IMDS：
+ 您计划将 IAM 角色分配给所有 Kubernetes 服务账户，以便容器组（pod）仅具有其所需的最低权限。
+ 集群中没有任何容器组（pod）需要出于其他原因（例如检索当前 AWS 区域）访问 Amazon EC2 实例元数据服务（IMDS）。
有关更多信息，请参阅[限制对分配给工作节点的实例配置文件的访问](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node)。
如果要阻止容器组（pod）访问 IMDS，请在启动模板中指定必要的设置。
1. 将以下内容复制到您的设备。替换示例值，然后运行修改后的命令以创建 `eks-nodegroup.yaml` 文件。在不使用启动模板的情况下进行部署时指定的多个设置将移动到启动模板中。如果未指定 `version`，则使用模板的默认版本。
```
cat >eks-nodegroup.yaml <
**使用 AWS 管理控制台创建托管节点组**
1. 等待集群状态显示为 `ACTIVE`。无法为状态尚未处于 `ACTIVE` 的集群创建托管节点组。
1. 打开 [Amazon EKS 控制台](https://console.aws.amazon.com/eks/home#/clusters)。
1. 选择要在其中创建托管节点组的集群的名称。
1. 选择 **Compute**（计算）选项卡。
1. 请选择 **Add node group**（添加节点组）。
1. 在 **Configure node group (配置节点组)** 页面上，填写相应参数，然后选择 **Next (下一步)**。
+ **名称** – 为托管节点组输入唯一名称。节点组名称的长度不能超过 63 个字符。它必须以字母或数字开头，但也可以包括其余字符的连字符和下划线。
+ **节点 IAM 角色** – 选择要与节点组一起使用的节点实例角色。有关更多信息，请参阅 [Amazon EKS 节点 IAM 角色](create-node-role.md)。
**重要**
您不能使用创建任何集群时使用的相同角色。
我们建议使用任何自行管理节点组当前未使用的角色。否则，计划与新的自行管理节点组配合使用。有关更多信息，请参阅 [从集群中删除托管式节点组](delete-managed-node-group.md)。
+ **使用启动模板** -（可选）选择是否要使用现有启动模板。选择 **Launch Template Name**（启动模板名称）。然后，选择 **Launch template version**（启动模板版本）。如果您未选择版本，Amazon EKS 将使用模板的默认版本。启动模板允许您对节点组进行更多自定义，例如允许您部署自定义 AMI、将更多的 IP 地址分配给容器组（pod）、将 IP 地址分配给其他 CIDR 块（而不是实例的 CIDR 块）中的容器组（pod），并将节点部署到没有出站互联网访问的集群。有关更多信息，请参阅 [为带前缀的 Amazon EKS 节点分配更多 IP 地址](cni-increase-ip-addresses.md)、[使用自定义网络在备用子网中部署容器组（pod）](cni-custom-network.md) 和 [部署具有有限互联网访问权限的私有集群](private-clusters.md)。
启动模板必须满足中的[使用启动模板自定义托管式节点](launch-templates.md)中的要求。如果您不使用自己的启动模板，Amazon EKS API 会在您的账户中创建默认 Amazon EC2 启动模板，并使用默认启动模板部署节点组。
如果实施[服务账户的 IAM 角色](iam-roles-for-service-accounts.md)，请将必要的权限直接分配给需要访问 AWS 服务的所有容器组（pod）。如果集群中没有容器组（pod）出于其他原因（例如检索当前 AWS 区域）而需要访问 IMDS，您还可以在启动模板中为不使用主机网络的容器组（pod）禁用 IMDS 的访问权限。有关更多信息，请参阅[限制对分配给工作节点的实例配置文件的访问](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node)。
+ **Kubernetes 标签** –（可选）您可以选择对托管节点组中的节点应用 Kubernetes 标签。
+ **Kubernetes 污点** –（可选）您可以选择对托管节点组中的节点应用 Kubernetes 污点。**Effect**（效果）菜单中的可用选项包括 ` NoSchedule `、` NoExecute ` 和 ` PreferNoSchedule `。有关更多信息，请参阅 [方案：防止在特定节点上调度容器组（pod）](node-taints-managed-node-groups.md)。
+ **标签** –（可选）您可以选择对 Amazon EKS 托管节点组进行标记。这些标签不会传播到节点组中的其它资源，例如自动扩缩组或实例。有关更多信息，请参阅 [使用标签整理 Amazon EKS 资源](eks-using-tags.md)。
1. 在 **Set compute and scaling configuration（设置计算和扩展配置）**页面上，填写相应参数，然后选择 **Next（下一步）**。
+ **AMI 类型** – 选择一个 AMI 类型。如果要部署 Arm 实例，请务必在部署前查看 [Amazon EKS 优化版 Arm Amazon Linux AMI](eks-optimized-ami.md#arm-ami) 中的注意事项。
如果您在上一页指定了启动模板，并在启动模板中指定了 AMI，则无法选择值。此时将显示模板中的值。模板中指定的 AMI 必须满足[指定 AMI](launch-templates.md#launch-template-custom-ami) 中的要求。
+ **容量类型** – 选择容量类型。有关选择容量类型的更多信息，请参阅 [托管节点组容量类型](managed-node-groups.md#managed-node-group-capacity-types)。不能在同一节点组中混合使用不同的容量类型。如果要同时使用这两种容量类型，请创建单独的节点组，每个节点组都有自己的容量和实例类型。有关预置和扩展由 GPU 加速的 Worker 节点的信息，请参阅[为托管节点组预留 GPU](https://docs.aws.amazon.com/eks/latest/userguide/capacity-blocks-mng.html)。
+ **实例类型** – 默认指定一个或多个实例类型。要删除默认实例类型，请选择实例类型右侧的 `X`。选择要在托管节点组中使用的实例类型。有关更多信息，请参阅 [选择最优的 Amazon EC2 节点实例类型](choosing-instance-type.md)。
控制台显示一组常用的实例类型。如果需要使用未显示的实例类型创建托管节点组，请使用 `eksctl`、AWS CLI、AWS CloudFormation 或 SDK 创建节点组。如果在上一页指定了启动模板，则无法选择值，因为必须在启动模板中指定实例类型。将显示启动模板中的值。如果为**容量类型**选择了 **Spot 实例**，我们建议您指定多个实例类型以增强可用性。
+ **磁盘大小** – 输入要用于节点根卷的磁盘大小（单位为 GiB）。
如果在上一页指定了启动模板，则无法选择值，因为必须在启动模板中指定该值。
+ **所需大小** – 指定托管节点组在启动时应当维持的当前节点数量。
**注意**
Amazon EKS 不会自动扩展或缩减节点组。但是，您可以配置 Kubernetes Cluster Autoscaler 来为您执行此操作。有关更多信息，请参阅 [AWS 上的 Cluster Autoscaler](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/cloudprovider/aws/README.md)。
+ **最小大小** – 指定托管节点组可以横向缩减到的最小节点数量。
+ **最大大小** – 指定托管节点组可以横向扩展到的最大节点数量。
+ **节点组更新配置** –（可选）您可以选择要并行更新的节点的数量或百分比。这些节点在更新期间将不可用。对于**最大不可用**，选择下列选项之一，然后指定一个**值**：
+ **Number**（数字）– 选择并指定节点组中可以并行更新的节点数。
+ **Percentage**（百分比）– 选择并指定节点组中可并行更新的节点的百分比。如果您的节点组中有大量节点，这将非常有用。
+ **节点自动修复配置** –（可选）如果您激活了**启用节点自动修复**复选框，Amazon EKS 将在检测到问题时自动替换节点。有关更多信息，请参阅 [检测节点运行状况问题并启用自动节点修复](node-health.md)。
1. 在 **Specify networking（指定联网）**页面上，相应填写参数，然后选择 **Next（下一步）**。
+ **子网** – 选择要在其中启动托管节点的子网。
**重要**
如果要使用 Kubernetes [Cluster Autoscaler](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/cloudprovider/aws/README.md) 在由 Amazon EBS 卷支持的多个可用区中运行有状态应用程序，则应该配置多个节点组，且每个节点组的范围都限定为一个可用区。此外，您还应该启用 `--balance-similar-node-groups` 功能。
**重要**
如果您选择公有子网，并且您的集群仅启用公有 API 服务器端点，则子网必须将 `MapPublicIPOnLaunch` 设置为 `true`，实例才能成功加入集群。如果子网是使用 `eksctl` 或 [Amazon EKS 发布的 AWS CloudFormation 模板](creating-a-vpc.md)在 2020 年 3 月 26 日或之后创建的，则此设置已设置为 `true`。如果子网是在 2020 年 3 月 26 日之前使用 `eksctl` 或 AWS CloudFormation 模板创建的，则需要手动更改设置。有关更多信息，请参阅[修改子网的公有 IPv4 寻址属性](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-ip-addressing.html#subnet-public-ip)。
如果使用启动模板并指定多个网络接口，即使 `MapPublicIpOnLaunch` 设置 `true`，Amazon EC2 也不会自动分配公有 `IPv4` 地址。在这种情况下，要让节点加入集群，您必须启用集群的私有 API 服务器端点，或者在具有出站 Internet 访问的私有子网中启动节点（Internet 访问通过如 NAT 网关等其它方法提供）。有关更多信息，请参阅 *Amazon EC2 用户指南*中的 [Amazon EC2 实例 IP 寻址](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html)。
+ **Configure SSH access to nodes**（配置对节点的 SSH 访问）（可选）。启用 SSH 后，如果出现问题，您可以连接到实例并收集诊断信息。我们强烈建议您在创建节点组时启用远程访问。创建节点组后，将无法启用远程访问。
如果您选择使用启动模板，则不会显示此选项。要启用对节点的远程访问，请在启动模板中指定密钥对，并确保为您在启动模板中指定的安全组中的节点打开正确的端口。有关更多信息，请参阅 [使用自定义安全组](launch-templates.md#launch-template-security-groups)。
**注意**
对于 Windows，此命令不会启用 SSH。反之，它会将 Amazon EC2 密钥对与实例关联，并允许您 RDP 到实例中。
+ 对于 **SSH 密钥对**（可选），请选择要使用的 Amazon EC2 SSH 密钥。有关 Linux 信息，请参阅《Amazon EC2 用户指南》**中的 [Amazon EC2 密钥对和 Linux 实例](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)。有关 Windows 信息，请参阅《Amazon EC2 用户指南》**中的 [Amazon EC2 密钥对和 Windows 实例](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ec2-key-pairs.html)。如果您选择使用启动模板，则无法选择密钥对。使用 Bottlerocket AMI 为节点组提供 Amazon EC2 SSH 密钥后，还启用管理容器。有关更多信息，请参阅 GitHub 上的 [Admin 容器](https://github.com/bottlerocket-os/bottlerocket#admin-container)。
+ 对于 **Allow SSH remote access from**（允许来自以下的远程访问），如果要限制对特定实例的访问，请选择与这些实例关联的安全组。如果没有选择特定的安全组，则允许从 Internet 上的任何位置进行 SSH 访问（`0.0.0.0/0`）。
1. 在 **Review and create (审核并创建)** 页面上，审核托管节点组配置并选择 **Create (创建)**。
如果节点无法加入集群，则请参阅故障排除一章中的 [节点未能加入集群](troubleshooting.md#worker-node-fail)。
1. 查看节点的状态并等待它们达到 `Ready` 状态。
```
kubectl get nodes --watch
```
1. （仅限 GPU 节点）如果选择 GPU 实例类型和 Amazon EKS 优化版加速型 AMI，则必须将[适用于 Kubernetes 的 NVIDIA 设备插件](https://github.com/NVIDIA/k8s-device-plugin)用作集群上的 DaemonSet。将 *vX.X.X* 替换为您需要的 [NVIDIA/k8s-device-plugin](https://github.com/NVIDIA/k8s-device-plugin/releases) 版本，然后运行以下命令。
```
kubectl apply -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/vX.X.X/deployments/static/nvidia-device-plugin.yml
```
## 安装 Kubernetes 附加组件
现在，您已有使用节点运行的 Amazon EKS 集群，那么就可以准备开始安装 Kubernetes 附加组件并将应用程序部署到集群。以下文档主题可帮助您扩展集群的此功能。
+ 创建集群的 [IAM 主体](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html#iam-term-principal)是唯一可以使用 `kubectl` 或 AWS 管理控制台 调用 Kubernetes API 服务器的主体。如果您希望其他 IAM 主体拥有访问您的集群的权限，您需要添加它们。有关更多信息，请参阅[向 IAM 用户和角色授予对 Kubernetes API 的访问权限](grant-k8s-access.md)和[所需的权限](view-kubernetes-resources.md#view-kubernetes-resources-permissions)。
+ 如果满足以下条件，我们建议阻止容器组（pod）访问 IMDS：
+ 您计划将 IAM 角色分配给所有 Kubernetes 服务账户，以便容器组（pod）仅具有其所需的最低权限。
+ 集群中没有任何容器组（pod）需要出于其他原因（例如检索当前 AWS 区域）访问 Amazon EC2 实例元数据服务（IMDS）。
有关更多信息，请参阅[限制对分配给 Worker 节点的实例配置文件的访问](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node)。
+ 配置 Kubernetes [Cluster Autoscaler](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/cloudprovider/aws/README.md) 以自动调整节点组中的节点数。
+ 将[示例应用程序](sample-deployment.md)部署到您的集群。
+ 使用管理集群的重要工具来[组织和监控集群资源](eks-managing.md)。
# 更新集群的托管式节点组
启动托管节点组更新后，Amazon EKS 会自动更新您的节点，完成[了解节点更新的各个阶段](managed-node-update-behavior.md)中列出的步骤。如果您使用的是 Amazon EKS 优化版 AMI，Amazon EKS 会自动将最新的安全补丁和操作系统更新应用到您的节点，作为最新 AMI 版本的一部分。
在几种情况下，需要更新 Amazon EKS 托管节点组的版本或配置：
+ 您已更新 Amazon EKS 集群的 Kubernetes 版本，并且您希望更新节点以使用相同 Kubernetes 版本。
+ 新 AMI 发行版本可用于您的托管节点组。有关 AMI 版本的更多信息，请参阅以下章节：
+ [检索 Amazon Linux AMI 版本信息](eks-linux-ami-versions.md)
+ [使用优化版 Bottlerocket AMI 创建节点](eks-optimized-ami-bottlerocket.md)
+ [检索 Windows AMI 版本信息](eks-ami-versions-windows.md)
+ 您希望调整托管节点组中的最少、最多或所需实例数。
+ 您希望对托管节点组中的实例添加或删除 Kubernetes 标签。
+ 您希望对托管节点组添加或删除 AWS 标签。
+ 您需要部署包含配置更改（如更新的自定义 AMI）的最新版本启动模板。
+ 您已部署了版本 `1.9.0` 或更高版本的 Amazon VPC CNI 附加组件，启用了前缀委派附加组件，并希望节点组中的新 AWS Nitro 实例支持数量显著增加的容器组（pod）。有关更多信息，请参阅 [为带前缀的 Amazon EKS 节点分配更多 IP 地址](cni-increase-ip-addresses.md)。
+ 您已为 Windows 节点启用了 IP 前缀委派，并希望节点组中的新 AWS Nitro System 实例支持数量显著增加的容器组（pod）。有关更多信息，请参阅 [为带前缀的 Amazon EKS 节点分配更多 IP 地址](cni-increase-ip-addresses.md)。
如果有相比您托管节点组的 Kubernetes 版本更新的 AMI 发行版，则可以将您节点组的版本更新为使用较新的 AMI 版本。同理，如果集群运行的 Kubernetes 版本比节点组更新，则可以将节点组更新为使用与集群 Kubernetes 版本匹配的最新 AMI 发行版。
如果托管节点组中的节点因扩展操作或更新而终止，则会先耗尽该节点中的容器组（pod）。有关更多信息，请参阅 [了解节点更新的各个阶段](managed-node-update-behavior.md)。
## 更新节点组版本
您可以使用以下任一方式更新节点组版本：
+ [`eksctl`](#eksctl_update_managed_nodegroup)
+ [AWS 管理控制台](#console_update_managed_nodegroup)
您更新到的版本不能高于控制面板的版本。
## `eksctl`
**使用 `eksctl` 更新托管节点组**
使用以下命令，将托管节点组更新到节点上当前部署的相同 Kubernetes 版本的最新 AMI 版本。将所有 *example value* 替换为您自己的值。
```
eksctl upgrade nodegroup \
--name=node-group-name \
--cluster=my-cluster \
--region=region-code
```
**注意**
如果要将使用启动模板部署的节点组升级到新的启动模板版本，请将 `--launch-template-version version-number ` 添加到上述命令。启动模板必须满足[使用启动模板自定义托管节点](launch-templates.md)中所述的要求。如果启动模板包含自定义 AMI，则 AMI 必须满足[指定 AMI](launch-templates.md#launch-template-custom-ami) 中的要求。将节点组升级到启动模板的更新版本后，将回收所有节点，以匹配指定的启动模板版本的新配置。
您不能将未使用启动模板部署的节点组直接升级到新的启动模板版本。相反，您必须使用启动模板部署新的节点组，以将节点组更新为新的启动模板版本。
您可以将节点组升级到与控制面板的 Kubernetes 版本相同的版本。例如，如果您的集群运行 Kubernetes `1.35`，则您可以使用以下命令，将当前运行 Kubernetes `1.34` 的节点升级到版本 `1.35`。
```
eksctl upgrade nodegroup \
--name=node-group-name \
--cluster=my-cluster \
--region=region-code \
--kubernetes-version=1.35
```
## AWS 管理控制台
**要使用 AWS 管理控制台创建托管节点组**
1. 打开 [Amazon EKS 控制台](https://console.aws.amazon.com/eks/home#/clusters)。
1. 选择包含要更新的节点组的集群。
1. 如果至少有一个节点组具有可用更新，则页面顶部将出现一个提示框，通知存在可用的更新。如果选择**计算**选项卡，则在具有可用更新的节点组的**节点组**表中，**AMI 发行版本**列会显示**立即更新**。要更新节点组，请选择 **Update now**（立即更新）。
对于使用自定义 AMI 部署的节点组，不会显示通知。如果您的节点是使用自定义 AMI 部署的，请完成以下步骤以部署更新的自定义 AMI。
1. 创建 AMI 的新版本。
1. 使用新 AMI ID 创建新的启动模板版本。
1. 将节点升级到新版本的启动模板。
1. 在 **Update node group version**（更新节点组版本）对话框中，激活或停用以下选项：
+ **Update node group version**（更新节点组版本）：如果您部署了自定义 AMI，或者您的 Amazon EKS 优化版 AMI 当前位于集群的最新版本上，则此选项不可用。
+ **Change launch template version**（更改启动模板版本）：如果部署节点组时没有使用自定义启动模板，则此选项不可用。您只能更新已使用自定义启动模板部署的节点组的启动模板版本。选择要将节点组更新到的 **Launch template version**（启动模板版本）。如果您的节点组配置了自定义 AMI，则您选择的版本还必须指定 AMI。升级到更新版本的启动模板后，所有节点都会被回收，以匹配指定的启动模板版本的新配置。
1. 对于 **Update strategy**（更新策略），选择下列选项之一：
+ **滚动更新** – 此选项会考虑集群的容器组（pod）中断预算。如果容器组（pod）中断预算问题导致 Amazon EKS 无法正常耗尽在此节点组上运行的容器组（pod），则更新将失败。
+ **强制更新** – 此选项不考虑容器组（pod）中断预算。通过强制节点重新启动，无论是否存在容器组（pod）中断预算问题，都会发生更新。
1. 选择**更新**。
## 编辑节点组配置
您可以修改托管节点组的某些配置。
1. 打开 [Amazon EKS 控制台](https://console.aws.amazon.com/eks/home#/clusters)。
1. 选择包含要编辑的节点组的集群。
1. 选择**计算**选项卡。
1. 选择要编辑的节点组，然后选择 **Edit**（编辑）。
1. （可选）在**编辑节点组**页面上，执行以下操作：
1. 编辑 **Node group scaling configuration**（节点组扩展配置）。
+ **所需大小** – 指定托管节点组应当维持的当前节点数量。
+ **最小大小** – 指定托管节点组可以横向缩减到的最小节点数量。
+ **最大大小** – 指定托管节点组可以横向扩展到的最大节点数量。有关节点组中支持的最大节点数，请参阅 [查看和管理 Amazon EKS 和 Fargate 服务配额](service-quotas.md)。
1. （可选）向节点组中的节点添加或删除 **Kubernetes 标签**。此处显示的标签仅为已应用于 Amazon EKS 的标签。节点上可能存在此处未显示的其它标签。
1. （可选）向节点组中的节点添加或删除 **Kubernetes 污点**。添加的污点可以具有 ` NoSchedule `、` NoExecute ` 或 ` PreferNoSchedule ` 效果。有关更多信息，请参阅 [方案：防止在特定节点上调度容器组（pod）](node-taints-managed-node-groups.md)。
1. （可选）向节点组资源添加或删除 **Tags**（标签）。这些标签仅应用于 Amazon EKS 节点组。这些标签不会传播到其它资源，例如节点组中的子网或 Amazon EC2 实例。
1. （可选）编辑**节点组更新配置**。选择**数字**或**百分比**。
+ **Number**（数字）– 选择并指定节点组中可以并行更新的节点数。这些节点在更新过程中将不可用。
+ **Percentage**（百分比）– 选择并指定节点组中可并行更新的节点的百分比。这些节点在更新过程中将不可用。如果您的节点组中有大量节点，这将非常有用。
1. 编辑完成后，选择**保存更改**。
**重要**
更新节点组配置时，修改 [https://docs.aws.amazon.com/eks/latest/APIReference/API_NodegroupScalingConfig.html](https://docs.aws.amazon.com/eks/latest/APIReference/API_NodegroupScalingConfig.html) 不会考虑容器组（pod）中断预算（PDB）。与[更新节点组](managed-node-update-behavior.md)进程（在升级阶段耗尽节点并考虑 PDB）不同，更新扩展配置会导致通过自动扩缩组（ASG）缩减调用立即终止节点。这种情况在不考虑 PDB 的情况下发生，无论缩减到什么目标大小。这意味着，当您减少 Amazon EKS 托管节点组的 `desiredSize` 时，只要节点终止，容器组（pod）就会立即被驱逐，而不考虑任何 PDB。
# 了解节点更新的各个阶段
Amazon EKS 托管 Worker 节点升级策略有四个不同的阶段，将在以下各节中介绍。
## 设置阶段
设置阶段有以下步骤：
1. 为与节点组关联的自动扩缩组创建新的 Amazon EC2 启动模板版本。新的启动模板版本使用目标 AMI 或自定义启动模板版本进行更新。
1. 对自动扩缩组进行更新，以便使用最新的启动模板版本。
1. 使用节点组的 `updateConfig` 属性确定要并行升级的节点最大数量。最大不可用的配额为 100 个节点。原定设置值为一个节点。有关更多信息，请参阅《Amazon EKS API 参考》**中的 [updateConfig](https://docs.aws.amazon.com/eks/latest/APIReference/API_UpdateNodegroupConfig.html#API_UpdateNodegroupConfig_RequestSyntax) 属性。
## 扩展阶段
升级托管节点组中的节点时，已升级的节点将在与正在升级的节点在相同可用区中启动。为了保证这一点，我们使用 Amazon EC2 的可用区重新平衡。有关更多信息，请参阅 *Amazon EC2 Auto Scaling 用户指南*的[可用区重新平衡](https://docs.aws.amazon.com/autoscaling/ec2/userguide/auto-scaling-benefits.html#AutoScalingBehavior.InstanceUsage)。为了满足此要求，将为托管节点组中的每个可用区启动最多两个实例。
扩展阶段有以下步骤：
1. 它增加自动扩缩组的最大大小和所需大小，增加幅度为以下两者中的较大者：
+ 部署自动扩缩组可用区数量的最多两倍。
+ 升级不可用的最大值。
例如，如果节点组有五个可用区，`maxUnavailable` 为 1，则升级过程可以启动最多 10 个节点。但是如果 `maxUnavailable` 为 20（或者任何高于 10 的值），则该过程将启动 20 个新节点。
1. 扩展 Auto Scaling 组后，将检查节点组中是否存在使用最新配置的节点。只有在满足以下标准时，此步骤才会成功：
+ 在节点所在的每个可用区中启动至少一个新节点。
+ 每个新节点都应该处于 `Ready` 状态。
+ 新节点应该有应用 Amazon EKS 的标签。
以下是常规节点组中的 Worker 节点上应用 Amazon EKS 的标签：
+ `eks.amazonaws.com/nodegroup-image=$amiName`
+ `eks.amazonaws.com/nodegroup=$nodeGroupName`
以下是自定义启动模板或 AMI 节点组中的 Worker 节点上应用 Amazon EKS 的标签：
+ `eks.amazonaws.com/nodegroup-image=$amiName`
+ `eks.amazonaws.com/nodegroup=$nodeGroupName`
+ `eks.amazonaws.com/sourceLaunchTemplateId=$launchTemplateId`
+ `eks.amazonaws.com/sourceLaunchTemplateVersion=$launchTemplateVersion`
1. 将节点标记为不可调度，避免调度新的容器组（pod）。它还使用 `node.kubernetes.io/exclude-from-external-load-balancers=true` 标记节点，以便在终止节点之前从负载均衡器中移除旧节点。
下面是导致这一阶段 `NodeCreationFailure` 出现错误的已知原因：
**可用区中容量不足**
可用区可能没有请求的实例类型的容量。建议在创建托管节点组时配置多种实例类型。
**账户的 EC2 实例限制**
可能需要使用服务配额增加账户可以同时运行的 Amazon EC2 实例数量。有关更多信息，请参阅*适用于 Linux 实例的 Amazon Elastic Compute Cloud 用户指南*中的 [EC2 Service Quotas](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-resource-limits.html)。
**自定义用户数据**
自定义用户数据有时会中断引导过程。这种情况可能导致节点不启动 `kubelet`，或者节点上没有获得预期的 Amazon EKS 标签。有关更多信息，请参阅 [指定 AMI](launch-templates.md#launch-template-custom-ami)。
**使节点不正常或未就绪的任何更改**
节点磁盘压力、内存压力和类似情况可能导致节点无法进入 `Ready` 状态。
**每个节点的引导时间最多不超过 15 分钟**
如果任何节点引导和加入集群的时间超过 15 分钟，则会导致升级超时。这是从需要新节点开始到新节点加入集群为止测量的引导新节点的总运行时间。升级托管节点组时，时间计数器会在自动扩缩组的大小增加后启动。
## 升级阶段
升级阶段有两种行为方式，具体取决于*更新策略*。更新策略分为**默认**策略和**最小**策略这两种。
建议在大多数情况下使用默认策略。该策略会在终止旧节点之前创建新节点，这样就能在升级阶段保持可用容量。在资源或成本受限的情况下，例如使用 GPU 等硬件加速器，最小策略非常有用。该策略会在创建新节点之前终止旧节点，这样总容量永远不会超过配置的数量。
*默认*更新策略包含如下步骤：
1. 增加自动扩缩组中的节点数量（所需数量），导致该节点组创建更多节点。
1. 它随机选择一个需要更新的节点，最多为该节点组配置的最大不可用性。
1. 耗尽节点的容器组（pod）。如果容器组（pod）在 15 分钟内没有离开节点并且没有强制标志，则升级阶段将失败并显示 `PodEvictionFailure` 错误。对于这种情况，您可以使用 `update-nodegroup-version` 请求应用强制标志来删除容器组（pod）。
1. 在每个容器组（pod）被驱逐后封锁节点并等待 60 秒钟。这样做是为了防止服务控制器向此节点发送任何新请求，并将此节点从活动节点列表中删除。
1. 它向封锁节点的自动扩缩组发送终止请求。
1. 它重复以前的升级步骤，直到节点组中没有使用早期版本启动模板部署的节点。
*最小*更新策略包括如下步骤：
1. 首先会封锁节点组中的所有节点，确保服务控制器不会向这些节点发送任何新请求。
1. 它随机选择一个需要更新的节点，最多为该节点组配置的最大不可用性。
1. 耗尽选定节点的容器组（pod）。如果容器组（pod）在 15 分钟内没有离开节点并且没有强制标志，则升级阶段将失败并显示 `PodEvictionFailure` 错误。对于这种情况，您可以使用 `update-nodegroup-version` 请求应用强制标志来删除容器组（pod）。
1. 将所有容器组弹出并等待 60 秒后，它会向选定节点的自动扩缩组发出一条终止请求。该自动扩缩组会创建新节点（数量与选定的节点数相同）来替换缺失的容量。
1. 它重复以前的升级步骤，直到节点组中没有使用早期版本启动模板部署的节点。
### 升级期间的 `PodEvictionFailure` 错误
下面是导致这一阶段 `PodEvictionFailure` 出现错误的已知原因：
**积极的 PDB**
积极的 PDB 在容器组（pod）上定义，或者有多个 PDB 指向同一个容器组（pod）。
**容忍所有污点的部署**
一旦每个容器组（pod）被逐出，预计该节点将为空，因为该节点在前面的步骤中[受到污染](https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/)。但是，如果部署容忍每个污点，则该节点更有可能是非空的，导致容器组（pod）驱逐失败。
## 缩减阶段
缩减阶段将自动扩缩组的最大大小和所需大小减小一，返回更新开始之前的值。
如果升级工作流确定 Cluster Autoscaler 在工作流缩减阶段扩展节点组，则会立即退出，而不会使节点组恢复原始大小。
# 使用启动模板自定义托管式节点
为实现最高级别的自定义，您可以根据此页面上的步骤使用自己的启动模板部署托管节点。使用启动模板可以实现以下功能：在部署节点期间提供引导参数（例如，额外的 [kubelet](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/) 参数），从与分配给节点的 IP 地址不同的 CIDR 数据块为容器组（pod）分配 IP 地址，将自己的自定义 AMI 部署到节点，或者将自己的自定义 CNI 部署到节点。
如果您在首次创建托管节点组时提供自己的启动模板，则以后也将具有更大的灵活性。只要使用自己的启动模板部署托管节点组，您就可以使用同一启动模板的不同版本对其进行迭代更新。将节点组更新为启动模板的其他版本时，将回收组中的所有节点，以匹配指定启动模板版本的新配置。
托管式节点组始终部署用于 Amazon EC2 Auto Scaling 组的启动模板。当您不提供启动模板时，Amazon EKS API 会在您的账户中自动创建一个具有默认值的模板。但是，我们建议不要修改自动生成的启动模板。而且，无法直接更新不使用自定义启动模板的现有节点组。相反，您必须使用自定义启动模板创建新的节点组才能执行此操作。
## 启动模板配置基础知识
您可以使用 AWS 管理控制台、AWS CLI 或 AWS SDK 创建 Amazon EC2 Auto Scaling 启动模板。有关更多信息，请参阅《Amazon EC2 Auto Scaling 用户指南》**中的[为自动扩缩组创建启动模板](https://docs.aws.amazon.com/autoscaling/ec2/userguide/create-launch-template.html)。启动模板中的某些设置类似于用于托管节点配置的设置。使用启动模板部署或更新节点组时，必须在节点组配置或启动模板中指定某些设置。不要在两个位置都指定一个设置。如果某个设置出现在错误的位置，则创建或更新节点组之类的操作将失败。
下表列出启动模板中禁止的设置，它还列出托管节点组配置中所需的类似设置（如果有）。列出的设置是显示在控制台中的设置。它们在 AWS CLI 和 SDK 中可能具有相似但不同的名称。
| 启动模板 - 已禁止 | Amazon EKS 节点组配置 |
| --- | --- |
| **Network interfaces（网络接口）**（**Add network interface（添加网络接口）**）下的**Subnet（子网）** | **Specify networking**（指定联网）页面上 **Node group network configuration**（节点组网络配置）下的 **Subnets**（子网） |
| **Advanced details（高级详细信息）**下的 **IAM instance profile（IAM 实例配置文件）** | **Configure Node group**（配置节点组）页面上 **Node group configuration**（节点组配置）下的 **Node IAM role**（节点 IAM 角色） |
| **Advanced details（高级详细信息）**下的 **Shutdown behavior（关机行为）**和 **Stop - Hibernate behavior（停止 - 休眠行为）**。在启动模板中，对于两个设置都保留默认的**不包含在启动模板设置中**。 | 无等效项 Amazon EKS 必须控制实例生命周期，而不是自动扩缩组。 |
下表列出托管节点组配置中禁止的设置，还列出启动模板中所需的类似设置（如果有）。列出的设置是显示在控制台中的设置。它们在 AWS CLI 和 SDK 中可能有类似的名称。
| Amazon EKS 节点组配置 – 已禁止 | 启动模板 |
| --- | --- |
| （仅当在启动模板中指定了自定义 AMI 时）**设置计算和扩缩配置**页面上**节点组计算配置**下的 **AMI 类型** – 控制台显示**已在启动模板中指定**和指定的 AMI ID。 如果未在启动模板中指定**应用程序和操作系统映像（Amazon 机器映像）**，则可以在节点组配置中选择 AMI。 | **Launch template contents**（启动模板内容）下的 **Application and OS Images (Amazon Machine Image)**（应用程序和操作系统映像（Amazon 机器映像））– 如果您有以下任一要求，则必须指定 ID： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/eks/latest/userguide/launch-templates.html) |
| **Set compute and scaling configuration**（设置计算和扩展配置）页面上 **Node group compute configuration**（节点组计算配置）下的 **Disk size**（磁盘大小）– 控制台显示 **Specified in launch template**（已在启动模板中指定）。 | **Storage (Volumes)（存储（卷））**（**Add new volume（添加新卷）**）下的 **Size（大小）**。您必须在启动模板中指定此项。 |
| **Specify Networking**（指定网络）页面上 **Node group configuration**（节点组配置）下的 **SSH key pair**（SSH 密钥对）– 控制台显示在启动模板中指定的密钥或显示 **Not specified in launch template**（未在启动模板中指定）。 | **Key pair (login)（密钥对（登录））**下的 **Key pair name（密钥对名称**。 |
| 在使用启动模板时，您无法指定允许远程访问的源安全组。 | 实例的 **Network settings（网络设置）**下的 **Security groups（安全组）**，或者 **Network interfaces（网络接口）**（**Add network interface（添加网络接口）**）下的 **Security groups（安全组）**，但不能同时兼具。有关更多信息，请参阅 [使用自定义安全组](#launch-template-security-groups)。 |
**注意**
如果使用启动模板部署节点组，请在启动模板的 **Launch template contents**（启动模板内容）下指定 0 或 1 个 **Instance type**（实例类型）。您也可以为控制台 **Set compute and scaling configuration**（设置计算和扩缩配置）页面的 **Instance types**（实例类型）指定 0-20 个实例类型。或者，您可以使用其他使用 Amazon EKS API 的工具来执行此操作。如果您在启动模板中指定实例类型，并使用该启动模板部署节点组，则无法在控制台中或通过使用 Amazon EKS API 的其它工具指定任何实例类型。如果没有在启动模板、控制台中或通过使用 Amazon EKS API 的其它工具指定实例类型，则使用 `t3.medium` 实例类型。如果您的节点组使用 Spot 容量类型，我们建议您使用控制台指定多个实例类型。有关更多信息，请参阅 [托管节点组容量类型](managed-node-groups.md#managed-node-group-capacity-types)。
如果部署到节点组的任何容器使用实例元数据服务版本 2，请确保在启动模板中将**Metadata response hop limit**（元数据响应跃点限制）设置为 `2`。有关更多信息，请参阅《Amazon EC2 用户指南**》中的[实例元数据和用户数据](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html)。
启动模板不支持 `InstanceRequirements` 功能，借助该功能可以灵活选择实例类型。
## 为 Amazon EC2 实例添加标签
您可以使用启动模板的 `TagSpecification` 参数来指定将哪些标签应用于节点组中的 Amazon EC2 实例。调用 `CreateNodegroup` 或 `UpdateNodegroupVersion` API 的 IAM 实体必须具有 `ec2:RunInstances` 和 `ec2:CreateTags` 的权限，并且必须将标签添加到启动模板中。
## 使用自定义安全组
您可以使用启动模板指定自定义 Amazon EC2 [安全组](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html)以应用到节点组中的实例。这可以在实例级安全组参数中，也可以作为网络接口配置参数的一部分。但是，您无法创建同时指定实例级安全组和网络接口安全组的启动模板。请考虑以下适用于为托管节点组使用自定义安全组的条件：
+ 使用 AWS 管理控制台时，Amazon EKS 仅允许使用具有单个网络接口规范的启动模板。
+ 预设情况下，Amazon EKS 将[集群安全组](sec-group-reqs.md)应用于节点组中的实例，以便于节点和控制层面之间的通信。如果您使用前面提到的任一选项在启动模板中指定自定义安全组，则 Amazon EKS 不会添加集群安全组。因此，您必须确保安全组的入站和出站规则启用了与集群端点的通信。如果您的安全组规则不正确，则 worker 节点无法加入集群。有关安全组规则的更多信息，请参阅 [查看集群的 Amazon EKS 安全组要求](sec-group-reqs.md)。
+ 如果需要对节点组中的实例进行 SSH 访问，请确保包含允许该访问的安全组。
## Amazon EC2 用户数据
启动模板包括自定义用户数据的部分。您可以在此部分为节点组指定配置设置，而无需手动创建单个自定义 AMI。有关 Bottlerocket 可用设置的更多信息，请参阅 GitHub 上的[使用用户数据](https://github.com/bottlerocket-os/bottlerocket#using-user-data)。
在启动实例时，您可以使用 `cloud-init` 在启动模板中提供 Amazon EC2 用户数据。有关更多信息，请参阅 [cloud-init 文档](https://cloudinit.readthedocs.io/en/latest/index.html)。您的用户数据可用于执行常见配置操作。其中包括以下操作：
+ [包含用户或组](https://cloudinit.readthedocs.io/en/latest/topics/examples.html#including-users-and-groups)
+ [安装程序包](https://cloudinit.readthedocs.io/en/latest/topics/examples.html#install-arbitrary-packages)
启动模板中用于托管节点组的 Amazon EC2 用户数据必须采用 [MIME 分段归档](https://cloudinit.readthedocs.io/en/latest/topics/format.html#mime-multi-part-archive)格式（用于 Amazon Linux AMI）和 TOML 格式（用于 Bottlerocket AMI）。这是因为您的用户数据与节点加入集群所需的 Amazon EKS 用户数据合并。不要在用户数据中指定任何启动或修改 `kubelet` 的命令。这是作为 Amazon EKS 合并的用户数据的一部分执行的。某些 `kubelet` 参数（例如节点上的设置标签）可以直接通过托管节点组 API 进行配置。
**注意**
如果需要高级 `kubelet` 自定义，包括手动启动或传入自定义配置参数，请参阅 [指定 AMI](#launch-template-custom-ami)。如果在启动模板中指定自定义 AMI ID，Amazon EKS 不会合并用户数据。
以下详细信息提供有关用户数据部分的更多信息。
**Amazon Linux 2 用户数据**
您可以将多个用户数据块合并到一个 MIME 分段文件中。例如，您可以将配置 Docker 守护进程的云 Boothook 与安装自定义软件包的用户数据 Shell 脚本合并。MIME 分段文件包含以下组成部分：
+ 内容类型和段边界声明 - `Content-Type: multipart/mixed; boundary="==MYBOUNDARY=="`
+ MIME 版本声明 - `MIME-Version: 1.0`
+ 一个或多个用户数据块，其包含以下组成部分：
+ 开口边界，表示用户数据块的开头 - `--==MYBOUNDARY==`
+ 数据块的内容类型声明：`Content-Type: text/cloud-config; charset="us-ascii"`。有关内容类型的更多信息，请参阅 [cloud-init](https://cloudinit.readthedocs.io/en/latest/topics/format.html) 文档。
+ 用户数据的内容（例如 Shell 命令或 `cloud-init` 指令的列表）。
+ 封闭边界，表示 MIME 分段文件的结尾：`--==MYBOUNDARY==--`
以下是 MIME 分段文件的示例，您可以用它来创建您自己的文件。
```
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="==MYBOUNDARY=="
--==MYBOUNDARY==
Content-Type: text/x-shellscript; charset="us-ascii"
#!/bin/bash
echo "Running custom user data script"
--==MYBOUNDARY==--
```
**Amazon Linux 2023 用户数据**
Amazon Linux 2023（AL2023）引入了使用 YAML 配置架构的新节点初始化流程 `nodeadm`。如果您使用的是自行管理的节点组或带有启动模板的 AMI，则在创建新节点组时，现在需要明确提供其它集群元数据。以下是最低必需参数的[示例](https://awslabs.github.io/amazon-eks-ami/nodeadm/)，其中 `apiServerEndpoint`、`certificateAuthority` 和服务 `cidr` 是必需的：
```
---
apiVersion: node.eks.aws/v1alpha1
kind: NodeConfig
spec:
cluster:
name: my-cluster
apiServerEndpoint: https://example.com
certificateAuthority: Y2VydGlmaWNhdGVBdXRob3JpdHk=
cidr: 10.100.0.0/16
```
通常，您将在用户数据中设置此配置，无论是按原样设置还是嵌入 MIME 多部分文档中：
```
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="BOUNDARY"
--BOUNDARY
Content-Type: application/node.eks.aws
---
apiVersion: node.eks.aws/v1alpha1
kind: NodeConfig spec: [...]
--BOUNDARY--
```
在 AL2 中，来自这些参数的元数据是从 Amazon EKS `DescribeCluster` API 调用中发现的。使用 AL2023，这种行为发生了变化，因为在大型节点纵向扩展期间，额外的 API 调用有节流风险。如果您使用的是没有启动模板的托管节点组或者 Karpenter，则此更改不会对您产生影响。有关 `certificateAuthority` 和服务 `cidr` 的更多信息，请参阅《Amazon EKS API 参考》**中的 [https://docs.aws.amazon.com/eks/latest/APIReference/API_DescribeCluster.html](https://docs.aws.amazon.com/eks/latest/APIReference/API_DescribeCluster.html)。
以下是一个完整的 AL2023 用户数据示例，该实例将用于自定义节点（例如安装程序包或预缓存容器映像）的 shell 脚本与所需的 `nodeadm` 配置进行组合。该示例展示了常见的自定义设置，包括：\$1 安装附加系统程序包 \$1 预缓存容器影响以缩短容器组（pod）启动时间 \$1 设置 HTTP 代理配置 \$1 配置用于节点标记的 `kubelet` 标志
```
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="BOUNDARY"
--BOUNDARY
Content-Type: text/x-shellscript; charset="us-ascii"
#!/bin/bash
set -o errexit
set -o pipefail
set -o nounset
# Install additional packages
yum install -y htop jq iptables-services
# Pre-cache commonly used container images
nohup docker pull public.ecr.aws/eks-distro/kubernetes/pause:3.2 &
# Configure HTTP proxy if needed
cat > /etc/profile.d/http-proxy.sh << 'EOF'
export HTTP_PROXY="http://proxy.example.com:3128"
export HTTPS_PROXY="http://proxy.example.com:3128"
export NO_PROXY="localhost,127.0.0.1,169.254.169.254,.internal"
EOF
--BOUNDARY
Content-Type: application/node.eks.aws
apiVersion: node.eks.aws/v1alpha1
kind: NodeConfig
spec:
cluster:
name: my-cluster
apiServerEndpoint: https://example.com
certificateAuthority: Y2VydGlmaWNhdGVBdXRob3JpdHk=
cidr: 10.100.0.0/16
kubelet:
config:
clusterDNS:
- 10.100.0.10
flags:
- --node-labels=app=my-app,environment=production
--BOUNDARY--
```
**Bottlerocket 用户数据**
Bottlerocket 采用 TOML 格式构建用户数据。您可以提供要与 Amazon EKS 提供的用户数据合并的用户数据。例如，您可以提供额外的 `kubelet` 设置。
```
[settings.kubernetes.system-reserved]
cpu = "10m"
memory = "100Mi"
ephemeral-storage= "1Gi"
```
有关支持设置的更多信息，请参阅 GitHub 上的 [Bottlerocket 文档](https://github.com/bottlerocket-os/bottlerocket)。您可以在用户数据中配置节点标签和[污点](node-taints-managed-node-groups.md)。但是，我们建议在节点组中对其进行配置。在您这样做时，Amazon EKS 应用这些配置。
合并用户数据时，不保留格式，但内容保持不变。您在用户数据中提供的配置将覆盖 Amazon EKS 配置的任何设置。所以，如果设置 `settings.kubernetes.max-pods` 或 `settings.kubernetes.cluster-dns-ip`，用户数据中的这些值将应用到节点。
Amazon EKS 不支持所有有效的 TOM。以下是已知不受支持的格式的列表：
+ 引用的键中的引号：`'quoted "value"' = "value"`
+ 值中的转义引号：`str = "I’m a string. \"You can quote me\""`
+ 混合浮点数和整数：`numbers = [ 0.1, 0.2, 0.5, 1, 2, 5 ]`
+ 数组中的混合类型：`contributors = ["[foo@example.com](mailto:foo@example.com)", { name = "Baz", email = "[baz@example.com](mailto:baz@example.com)" }]`
+ 带引用键的括号标题：`[foo."bar.baz"]`
**Windows 用户数据**
Windows 用户数据使用 PowerShell 命令。创建托管节点组时，您的自定义用户数据与 Amazon EKS 托管用户数据结合使用。您的 PowerShell 命令排在首位，然后是托管用户数据命令，所有这些命令都在一个 `` 标签内。
创建 Windows 节点组时，Amazon EKS 会更新 `aws-auth` `ConfigMap`，以便允许基于 Linux 的节点加入集群。该服务不会自动配置 Windows AMI 权限。如果使用的是 Windows 节点，则需要通过访问条目 API 或通过直接更新 `aws-auth` `ConfigMap` 来管理访问权限。有关更多信息，请参阅 [在 EKS 集群上部署 Windows 节点](windows-support.md)。
如果在启动模板中未指定 AMI ID，请勿在用户数据中使用 Windows Amazon EKS 引导脚本来配置 Amazon EKS。
用户数据示例如下所示。
```
Write-Host "Running custom user data script"
```
## 指定 AMI
如果您具有以下任一要求，请在启动模板的 `ImageId` 字段中指定一个 AMI ID。选择您对其他信息的要求。
### 提供用户数据，将参数传递给随 Amazon EKS 优化版 Linux/Bottlerocket AMI 一起提供的 `bootstrap.sh` 文件
Bootstrapping（引导启动）是一个术语，用于描述添加可以在实例启动时运行的命令。例如，引导允许使用额外的 [kubelet](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/) 参数。您可以使用 `eksctl` 将参数传递给 `bootstrap.sh` 脚本，无需指定启动模板。或者，您可以在启动模板的用户数据部分中指定信息来实现此目标。
**eksctl 无需指定启动模板**
创建一个名为 *my-nodegroup.yaml* 的文件，其中包含以下内容。将所有 *example value* 替换为您自己的值。`--apiserver-endpoint`、`--b64-cluster-ca` 和 `--dns-cluster-ip` 参数是可选的。但是，定义它们可使 `bootstrap.sh` 脚本避免进行 `describeCluster` 调用。在私有集群设置或频繁扩展节点的集群中，这是非常有用的。有关 `bootstrap.sh` 脚本的更多信息，请参阅 GitHub 上的 [bootstrap.sh](https://github.com/awslabs/amazon-eks-ami/blob/main/templates/al2/runtime/bootstrap.sh) 文件。
+ 唯一必需的参数是集群名称（*my-cluster*）。
+ 要检索 `ami-1234567890abcdef0 ` 的优化版 AMI ID，请参阅以下部分：
+ [检索建议的 Amazon Linux AMI ID](retrieve-ami-id.md)
+ [检索建议的 Bottlerocket AMI ID](retrieve-ami-id-bottlerocket.md)
+ [检索建议的 Microsoft Windows AMI ID](retrieve-windows-ami-id.md)
+ 要检索您的集群的 *certificate-authority*，请运行以下命令。
```
aws eks describe-cluster --query "cluster.certificateAuthority.data" --output text --name my-cluster --region region-code
```
+ 要检索您的集群的 *api-server-endpoint*，请运行以下命令。
```
aws eks describe-cluster --query "cluster.endpoint" --output text --name my-cluster --region region-code
```
+ `--dns-cluster-ip` 的值是您的服务 CIDR，末尾为 `.10`。要检索您的集群的 *service-cidr*，请运行以下命令。例如，如果返回值为 `ipv4 10.100.0.0/16`，则您的值为 *10.100.0.10*。
```
aws eks describe-cluster --query "cluster.kubernetesNetworkConfig.serviceIpv4Cidr" --output text --name my-cluster --region region-code
```
+ 此示例使用包含在 Amazon EKS 优化版 AMI 中的 `bootstrap.sh` 脚本提供一个 `kubelet` 参数来设置一个自定义 `max-pods` 值。节点组名称的长度不能超过 63 个字符。它必须以字母或数字开头，但也可以包括其余字符的连字符和下划线。有关选择 *my-max-pods-value* 的帮助，请参阅 。有关使用托管节点组时如何确定 `maxPods` 的更多信息，请参阅 [如何确定 maxPods](choosing-instance-type.md#max-pods-precedence)。
```
---
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: my-cluster
region: region-code
managedNodeGroups:
- name: my-nodegroup
ami: ami-1234567890abcdef0
instanceType: m5.large
privateNetworking: true
disableIMDSv1: true
labels: { x86-al2-specified-mng }
overrideBootstrapCommand: |
#!/bin/bash
/etc/eks/bootstrap.sh my-cluster \
--b64-cluster-ca certificate-authority \
--apiserver-endpoint api-server-endpoint \
--dns-cluster-ip service-cidr.10 \
--kubelet-extra-args '--max-pods=my-max-pods-value' \
--use-max-pods false
```
对于每一个可用的 `eksctl` `config` 文件选项，请参阅 `eksctl` 文档中的[配置文件架构](https://eksctl.io/usage/schema/)。`eksctl` 实用程序仍会为您创建启动模板，并使用您在 `config` 文件中提供的数据填充其用户数据。
使用以下命令创建节点组。
```
eksctl create nodegroup --config-file=my-nodegroup.yaml
```
**启动模板中的用户数据**
在启动模板的用户数据部分指定以下信息。将所有 *example value* 替换为您自己的值。`--apiserver-endpoint`、`--b64-cluster-ca` 和 `--dns-cluster-ip` 参数是可选的。但是，定义它们可使 `bootstrap.sh` 脚本避免进行 `describeCluster` 调用。在私有集群设置或频繁扩展节点的集群中，这是非常有用的。有关 `bootstrap.sh` 脚本的更多信息，请参阅 GitHub 上的 [bootstrap.sh](https://github.com/awslabs/amazon-eks-ami/blob/main/templates/al2/runtime/bootstrap.sh) 文件。
+ 唯一必需的参数是集群名称（*my-cluster*）。
+ 要检索您的集群的 *certificate-authority*，请运行以下命令。
```
aws eks describe-cluster --query "cluster.certificateAuthority.data" --output text --name my-cluster --region region-code
```
+ 要检索您的集群的 *api-server-endpoint*，请运行以下命令。
```
aws eks describe-cluster --query "cluster.endpoint" --output text --name my-cluster --region region-code
```
+ `--dns-cluster-ip` 的值是您的服务 CIDR，末尾为 `.10`。要检索您的集群的 *service-cidr*，请运行以下命令。例如，如果返回值为 `ipv4 10.100.0.0/16`，则您的值为 *10.100.0.10*。
```
aws eks describe-cluster --query "cluster.kubernetesNetworkConfig.serviceIpv4Cidr" --output text --name my-cluster --region region-code
```
+ 此示例使用包含在 Amazon EKS 优化版 AMI 中的 `bootstrap.sh` 脚本提供一个 `kubelet` 参数来设置一个自定义 `max-pods` 值。有关选择 *my-max-pods-value* 的帮助，请参阅 。有关使用托管节点组时如何确定 `maxPods` 的更多信息，请参阅 [如何确定 maxPods](choosing-instance-type.md#max-pods-precedence)。
```
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="==MYBOUNDARY=="
--==MYBOUNDARY==
Content-Type: text/x-shellscript; charset="us-ascii"
#!/bin/bash
set -ex
/etc/eks/bootstrap.sh my-cluster \
--b64-cluster-ca certificate-authority \
--apiserver-endpoint api-server-endpoint \
--dns-cluster-ip service-cidr.10 \
--kubelet-extra-args '--max-pods=my-max-pods-value' \
--use-max-pods false
--==MYBOUNDARY==--
```
### 提供用户数据，将参数传递给随 Amazon EKS 优化版 Windows AMI 一起提供的 `Start-EKSBootstrap.ps1` 文件
Bootstrapping（引导启动）是一个术语，用于描述添加可以在实例启动时运行的命令。您可以使用 `eksctl` 将参数传递给 `Start-EKSBootstrap.ps1` 脚本，无需指定启动模板。或者，您可以在启动模板的用户数据部分中指定信息来实现此目标。
如果您想指定自定义 Windows AMI ID，请记住以下注意事项：
+ 您必须使用启动模板并在用户数据部分提供所需的引导命令。要检索所需的 Windows ID，您可以使用[使用优化版 Windows AMI 创建节点](eks-optimized-windows-ami.md)中的表。
+ 有一些限制和条件。例如，您必须将 `eks:kube-proxy-windows` 添加到您的 AWS IAM 身份验证器配置映射中。有关更多信息，请参阅 [指定 AMI ID 时的限制和条件](#mng-ami-id-conditions)。
在启动模板的用户数据部分指定以下信息。将所有 *example value* 替换为您自己的值。`-APIServerEndpoint`、`-Base64ClusterCA` 和 `-DNSClusterIP` 参数是可选的。但是，定义它们可使 `Start-EKSBootstrap.ps1` 脚本避免进行 `describeCluster` 调用。
+ 唯一必需的参数是集群名称（*my-cluster*）。
+ 要检索您的集群的 *certificate-authority*，请运行以下命令。
```
aws eks describe-cluster --query "cluster.certificateAuthority.data" --output text --name my-cluster --region region-code
```
+ 要检索您的集群的 *api-server-endpoint*，请运行以下命令。
```
aws eks describe-cluster --query "cluster.endpoint" --output text --name my-cluster --region region-code
```
+ `--dns-cluster-ip` 的值是您的服务 CIDR，末尾为 `.10`。要检索您的集群的 *service-cidr*，请运行以下命令。例如，如果返回值为 `ipv4 10.100.0.0/16`，则您的值为 *10.100.0.10*。
```
aws eks describe-cluster --query "cluster.kubernetesNetworkConfig.serviceIpv4Cidr" --output text --name my-cluster --region region-code
```
+ 有关更多参数，请参阅 [引导脚本配置参数](eks-optimized-windows-ami.md#bootstrap-script-configuration-parameters)。
**注意**
如果您使用自定义服务 CIDR，则需要使用 `-ServiceCIDR` 参数进行指定。否则，集群中的容器组（pod）DNS 解析将失败。
```
[string]$EKSBootstrapScriptFile = "$env:ProgramFiles\Amazon\EKS\Start-EKSBootstrap.ps1"
& $EKSBootstrapScriptFile -EKSClusterName my-cluster `
-Base64ClusterCA certificate-authority `
-APIServerEndpoint api-server-endpoint `
-DNSClusterIP service-cidr.10
```
### 由于特定的安全性、合规性或内部策略要求，运行自定义 AMI
有关更多信息，请参阅《Amazon EC2 用户指南》**中的[亚马逊机器映像（AMI）](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html)。Amazon EKS AMI 构建规范包含用于构建基于 Amazon Linux 的自定义 Amazon EKS AMI 的资源和配置脚本。有关更多信息，请参阅 GitHub 上的 [Amazon EKS AMI 构建规范](https://github.com/awslabs/amazon-eks-ami/)。要构建与其他操作系统一起安装的自定义 AMI，请参阅 GitHub 上的 [Amazon EKS 示例自定义 AMI](https://github.com/aws-samples/amazon-eks-custom-amis)。
在与托管式节点组一起使用的启动模板中，AMI ID 不能使用动态参数引用。
**重要**
在指定 AMI 时，Amazon EKS 不会将您的 AMI 中嵌入的 Kubernetes 版本与您的集群控制面板版本进行比对验证。您有责任确保您的自定义 AMI 的 Kubernetes 版本符合 [Kubernetes 版本偏斜策略](https://kubernetes.io/releases/version-skew-policy)：
您节点上的 `kubelet` 版本不得高于您的集群版本
您节点上的 `kubelet` 版本必须与集群版本相同，或者比集群版本低 3 个或更少的次要版本（对于 Kubernetes 版本 `1.28` 或更高版本）；或者比集群版本低 2 个或更少的次要版本（对于 Kubernetes 版本 `1.27` 或更低版本）
创建存在版本偏差违规情况的托管节点组可能会导致：
节点未能加入集群
未定义的行为或 API 不兼容
集群不稳定或工作负载故障
指定 AMI 时，Amazon EKS 不会合并任何用户数据。实际上，您要负责提供节点加入集群所需的 `bootstrap` 命令。如果您的节点无法加入集群，那么 Amazon EKS `CreateNodegroup` 和 `UpdateNodegroupVersion` 操作也会失败。
## 指定 AMI ID 时的限制和条件
使用托管节点组指定 AMI ID 所涉及的限制和条件如下：
+ 您必须创建一个新的节点组，以便在在启动模板中指定 AMI ID 和不指定 AMI ID 之间进行切换。
+ 当有较新的 AMI 版本可用时，控制台中不会通知您。要将节点组更新为更新的 AMI 版本，需要使用更新的 AMI ID 创建新版本的启动模板。然后需要使用新的启动模板版本更新节点组。
+ 如果您指定 AMI ID，则无法在 API 中设置以下字段：
+ `amiType`
+ `releaseVersion`
+ `version`
+ 如果您指定 AMI ID，则会异步应用 API 中的任何 `taints` 设置。要在节点加入集群之前应用污点，必须使用 `--register-with-taints` 命令行标志将污点传递到用户数据中的 `kubelet`。有关更多信息，请参阅 Kubernetes 文档中的 [kubelet](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/)。
+ 为 Windows 托管节点组指定自定义 AMI ID 时，请将 `eks:kube-proxy-windows` 添加到您的 AWS IAM 身份验证器配置映射中。需要执行此操作 DNS 才能正常运行。
1. 打开 AWS IAM 身份验证器配置映射进行编辑。
```
kubectl edit -n kube-system cm aws-auth
```
1. 将此条目添加到每个与 Windows 节点关联的 `rolearn` 下的 `groups` 列表中。您的配置图应该看起来像 [aws-auth-cm-windows.yaml](https://s3.us-west-2.amazonaws.com/amazon-eks/cloudformation/2020-10-29/aws-auth-cm-windows.yaml)。
```
- eks:kube-proxy-windows
```
1. 保存文件并退出文本编辑器。
+ 对于使用自定义启动模板的任何 AMI，托管节点组的默认 `HttpPutResponseHopLimit` 均设置为 `2`。
# 从集群中删除托管式节点组
本主题介绍如何删除 Amazon EKS 托管节点组。删除托管式节点组时，Amazon EKS 会首先将自动扩缩组的最小、最大和所需大小设置为零。然后，这会导致节点组缩小。
在每个实例终止前，Amazon EKS 会发送一个信号对该节点执行排空操作。在节点排空流程中，Kubernetes 会对节点上的每个容器组（pod）执行以下操作：运行所有已配置的 `preStop` 生命周期挂钩，向容器发送 `SIGTERM` 信号，随后等待 `terminationGracePeriodSeconds` 完成正常关闭。如果 5 分钟后节点仍未完成排空，Amazon EKS 会允许自动扩缩组继续执行实例的强制终止操作。终止所有实例后，将删除自动扩缩组。
**重要**
如果您删除的托管节点组使用的节点 IAM 角色未由集群中任何其它托管节点组使用，则该角色将从 `aws-auth` `ConfigMap` 中移除。如果集群中的任何自行托管节点组使用相同的节点 IAM 角色，则自行管理的节点将变为 `NotReady` 状态。此外，集群操作也被中断。如果您的集群的平台版本至少为[使用 EKS 访问条目向 IAM 用户授予对 Kubernetes 的访问权限](access-entries.md) 的先决条件部分中列出的最低版本，要为仅用于自行管理的节点组的角色添加映射，请参阅[创建访问条目](creating-access-entries.md)。如果您的平台版本早于访问条目所需的最低版本，则可以将该条目重新添加到 `aws-auth` `ConfigMap`。要了解更多信息，请在您的终端中输入 `eksctl create iamidentitymapping --help`。
您可以使用以下工具删除托管节点组：
+ [`eksctl`](#eksctl-delete-managed-nodegroup)
+ [AWS 管理控制台](#console-delete-managed-nodegroup)
+ [AWS CLI](#awscli-delete-managed-nodegroup)
## `eksctl`
**用 `eksctl` 删除托管节点组**
输入以下命令。将每个 `` 替换为您自己的值。
```
eksctl delete nodegroup \
--cluster \
--name \
--region
```
有关更多选项，请参阅 `eksctl` 文档中的[删除和清空节点组](https://eksctl.io/usage/nodegroups/#deleting-and-draining-nodegroups)。
## AWS 管理控制台
**用 AWS 管理控制台删除托管节点组**
1. 打开 [Amazon EKS 控制台](https://console.aws.amazon.com/eks/home#/clusters)。
1. 在**集群**页面上，请选择包含要删除的节点组的集群。
1. 在所选集群页面上，请选择**计算**选项卡。
1. 在 **Node groups**（节点组）部分中，选择要删除的节点组。然后选择**删除**。
1. 在**删除节点组**确认对话框中，请输入节点组的名称。然后选择**删除**。
## AWS CLI
**用 AWS CLI 删除托管节点组**
1. 输入如下命令。将每个 `` 替换为您自己的值。
```
aws eks delete-nodegroup \
--cluster-name \
--nodegroup-name \
--region
```
1. 若 CLI 配置中已设置 `cli_pager=`，则使用键盘上的方向键滚动查看响应输出内容。完成后按 `q` 键。
有关更多选项，请参阅 *AWS CLI 命令参考*中的 ` [delete-nodegroup](https://docs.aws.amazon.com/cli/latest/reference/eks/delete-nodegroup.html) ` 命令。
# 使用自行管理型节点来自行维护节点
一个集群包含一个或多个在其上调度了容器组（pod）的 Amazon EC2 节点。Amazon EKS 节点在 AWS 账户中运行并通过集群 API 服务器端点连接到集群的控制层面。您需要根据 Amazon EC2 价格收取费用。有关更多信息，请参阅 [Amazon EC2 定价](https://aws.amazon.com/ec2/pricing/)。
一个集群可以包含多个节点组。每个节点组都包含在 [Amazon EC2 Auto Scaling 组](https://docs.aws.amazon.com/autoscaling/ec2/userguide/AutoScalingGroup.html)中部署的一个或多个节点。组内节点的实例类型可能会有所不同，例如[将基于属性的实例类型选择](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-attribute-based-instance-type-selection.html)与 [Karpenter](https://karpenter.sh/) 结合使用时。节点组中的所有实例都必须使用 [Amazon EKS 节点 IAM 角色](create-node-role.md)。
Amazon EKS 提供一个专用亚马逊机器映像（AMI），称为 Amazon EKS 优化版 AMI。AMI 配置为与 Amazon EKS 配合使用。其组件包括 `containerd`、`kubelet` 和 AWS IAM 身份验证器。此 AMI 还包含专用[引导脚本](https://github.com/awslabs/amazon-eks-ami/blob/main/templates/al2/runtime/bootstrap.sh)，从而允许它自动发现并连接到您的集群控制面板。
如果使用 CIDR 块限制对集群的公有端点的访问，建议您还启用私有端点访问。目的是为了让节点可以与集群通信。在未启用私有终端节点的情况下，您指定用于公有访问的 CIDR 块必须包含来自 VPC 的出口源。有关更多信息，请参阅 [集群 API 服务器端点](cluster-endpoint.md)。
要向您的 Amazon EKS 集群添加自行管理的节点，请参阅以下主题。如果手动启动自主管理型节点，则向每个节点添加以下标签，同时确保 `` 与集群匹配。有关更多信息，请参阅[为单个资源添加和删除标签](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#adding-or-deleting-tags)。如果按照下面指南中的步骤操作，则会将您所需的标签自动添加到节点。
| 键 | 值 |
| --- | --- |
| `kubernetes.io/cluster/` | `owned` |
**重要**
Amazon EC2 实例元数据服务（IMDS）中的标签与 EKS 节点不兼容。启用实例元数据标签后，将禁止在标签值中使用正斜杠（“/”）。不执行此限制可能会导致实例启动失败，尤其是在使用 Karpenter 或 Cluster Autoscaler 等节点管理工具时，因为这些服务能否正常运行取决于标签是否包含正斜杠。
有关节点的更多信息（从一般 Kubernetes 角度看），请参阅 Kubernetes 文档中的[节点](https://kubernetes.io/docs/concepts/architecture/nodes/)。
**Topics**
+ [创建自行管理的 Amazon Linux 节点](launch-workers.md)
+ [创建自主管理型 Bottlerocket 节点](launch-node-bottlerocket.md)
+ [创建自主管理型 Microsoft Windows 节点](launch-windows-workers.md)
+ [创建自主管理型 Ubuntu Linux 节点](launch-node-ubuntu.md)
+ [更新集群的自行管理型节点](update-workers.md)
# 创建自行管理的 Amazon Linux 节点
本主题介绍如何启动向 Amazon EKS 集群注册的 Linux 节点的自动扩缩组。在这些节点加入集群后，您可以向其部署 Kubernetes 应用程序。您可以使用 `eksctl` 或 AWS 管理控制台 启动自行管理的 Amazon Linux 节点。如果您需要在 AWS Outposts 上启动节点，请参阅 [在 AWS Outpost 上创建 Amazon Linux 节点](eks-outposts-self-managed-nodes.md)。
+ 现有 Amazon EKS 集群。要部署一个角色，请参阅[创建一个 Amazon EKS 集群。](create-cluster.md)。如果您在启用了 AWS Outposts、AWS Wavelength 或 AWS 本地区域的 AWS 区域中拥有子网，则这些子网不得在您创建集群时就已传入。
+ 供节点使用的现有 IAM 角色。要创建该文件，请参阅 [Amazon EKS 节点 IAM 角色](create-node-role.md)。如果此角色没有 VPC CNI 的任一策略，则需要为 VPC CNI Pod 使用随后的单独角色。
+ （可选，但推荐）适用于 Kubernetes 附加组件的 Amazon VPC CNI 插件已配置自己的 IAM 角色，并附加了必要的 IAM 策略。有关更多信息，请参阅 [配置 Amazon VPC CNI 插件以使用 IRSA](cni-iam-role.md)。
+ 熟悉[选择最优的 Amazon EC2 节点实例类型](choosing-instance-type.md)中列出的注意事项。根据您选择的实例类型，您的集群和 VPC 可能还有其他先决条件。
您可以使用以下任一选项来启动自行管理的 Linux 节点：
+ [`eksctl`](#eksctl_create_managed_amazon_linux)
+ [AWS 管理控制台](#console_create_managed_amazon_linux)
## `eksctl`
**使用 `eksctl` 启动自主管理型 Linux 节点**
1. 在您的设备或 AWS CloudShell 上安装 `0.215.0` 版或更高版本的 `eksctl` 命令行工具。要安装或更新 `eksctl`，请参阅 `eksctl` 文档中的 [Installation](https://eksctl.io/installation)。
1. （可选）如果 **AmazonEKS\$1CNI\$1Policy** 托管的 IAM 策略附加到 [Amazon EKS 节点 IAM 角色](create-node-role.md)，我们建议将其分配给您与 Kubernetes `aws-node` 服务账户关联的 IAM 角色。有关更多信息，请参阅 [配置 Amazon VPC CNI 插件以使用 IRSA](cni-iam-role.md)。
1. 以下命令在现有集群中创建节点组。将 *al-nodes* 替换为您的节点组名称。节点组名称的长度不能超过 63 个字符。它必须以字母或数字开头，但也可以包括其余字符的连字符和下划线。将 *my-cluster* 替换为您的集群的名称。名称只能包含字母数字字符（区分大小写）和连字符。该名称必须以字母数字字符开头，且不得超过 100 个字符。对于您在其中创建集群的 AWS 区域和 AWS 账户，该名称必须在其内具有唯一性。将其余的 *example value* 替换为您自己的值。预设情况下，将使用与控制层面相同的 Kubernetes 版本创建节点。
在为 `--node-type` 选择值之前，请查看[选择最优的 Amazon EC2 节点实例类型](choosing-instance-type.md)。
将 *my-key* 替换为您的 Amazon EC2 密钥对或公有密钥的名称。此密钥用于在节点启动后通过 SSH 进入节点。如果还没有 Amazon EC2 密钥对，可以在 AWS 管理控制台 中创建一个。有关更多信息，请参阅*《Amazon EC2 用户指南》*中的 [Amazon EC2 密钥对](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)。
使用以下命令创建您的节点组。
**重要**
如果要将节点组部署到 AWS Outposts、Wavelength 或本地区域子网，还有其它注意事项：
创建集群时，不得传入子网。
您必须使用配置文件创建节点组，指定子网和 ` [volumeType](https://eksctl.io/usage/schema/#nodeGroups-volumeType): gp2`。有关更多信息，请参阅 `eksctl` 文档中的[从配置文件创建节点组](https://eksctl.io/usage/nodegroups/#creating-a-nodegroup-from-a-config-file)和 [Config 文件架构](https://eksctl.io/usage/schema/)。
```
eksctl create nodegroup \
--cluster my-cluster \
--name al-nodes \
--node-type t3.medium \
--nodes 3 \
--nodes-min 1 \
--nodes-max 4 \
--ssh-access \
--managed=false \
--ssh-public-key my-key
```
部署符合以下条件的节点组：
+ 可以将明显高出默认配置数量的 IP 地址分配给容器组（pod），请参阅[为带前缀的 Amazon EKS 节点分配更多 IP 地址](cni-increase-ip-addresses.md)。
+ 可以将 `IPv4` 地址分配给来自与实例不同的 CIDR 块的容器组（pod），请参阅[使用自定义网络在备用子网中部署容器组（pod）](cni-custom-network.md)。
+ 可以将 `IPv6` 地址分配给容器组（pod）和服务，请参阅[了解如何将 IPv6 地址分配给集群、容器组（pod）和服务](cni-ipv6.md)。
+ 没有出站互联网访问权限，请参阅[部署具有有限互联网访问权限的私有集群](private-clusters.md)。
要查看所有可用选项和默认设置的完整列表，请输入以下命令。
```
eksctl create nodegroup --help
```
如果节点无法加入集群，则请参阅故障排除一章中的 [节点未能加入集群](troubleshooting.md#worker-node-fail)。
示例输出如下。创建节点时会输出几行。输出的最后几行类似于以下示例行。
```
[✔] created 1 nodegroup(s) in cluster "my-cluster"
```
1. （可选）部署[示例应用程序](sample-deployment.md)以测试集群和 Linux 节点。
1. 如果满足以下条件，我们建议阻止容器组（pod）访问 IMDS：
+ 您计划将 IAM 角色分配给所有 Kubernetes 服务账户，以便容器组（pod）仅具有其所需的最低权限。
+ 集群中没有任何容器组（pod）需要出于其他原因（例如检索当前 AWS 区域）访问 Amazon EC2 实例元数据服务（IMDS）。
有关更多信息，请参阅[限制对分配给 Worker 节点的实例配置文件的访问](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node)。
## AWS 管理控制台
**第 1 步：使用 AWS 管理控制台 启动自主管理型 Linux 节点**
1. 下载最新版本的 AWS CloudFormation 模板。
```
curl -O https://s3.us-west-2.amazonaws.com/amazon-eks/cloudformation/2025-11-26/amazon-eks-nodegroup.yaml
```
1. 等待集群状态显示为 `ACTIVE`。如果在集群处于活动状态之前启动节点，则节点将无法向集群注册，您必须重新启动节点。
1. 打开 [AWS CloudFormation 控制台](https://console.aws.amazon.com/cloudformation/)。
1. 选择 **Create stack（创建堆栈）**，然后选择 **With new resources (standard)（使用新资源（标准））**。
1. 对于 **Specify template（指定模板）**，选择 **Upload a template file（上传模板文件）**，然后选择**Choose file（选择文件） **。
1. 选择您下载的 `amazon-eks-nodegroup.yaml` 文件。
1. 选择**下一步**。
1. 在 **Specify stack details**（指定堆栈详细信息）页面上，相应填写以下参数，然后选择 **Next**（下一步）：
+ **堆栈名称**：为 AWS CloudFormation 堆栈选择堆栈名称。例如，您可以将其称为 *my-cluster-nodes*。名称只能包含字母数字字符（区分大小写）和连字符。该名称必须以字母数字字符开头，且不得超过 100 个字符。对于您在其中创建集群的 AWS 区域和 AWS 账户，该名称必须在其内具有唯一性。
+ **ClusterName**：输入您在创建 Amazon EKS 集群时使用的名称。此名称必须与集群名称完全匹配，否则您的节点无法加入该集群。
+ **ClusterControlPlaneSecurityGroup**：从您在创建 [VPC](creating-a-vpc.md) 时生成的 AWS CloudFormation 输出中，选择 **SecurityGroups** 值。
以下步骤显示了检索适用组的一种操作。
1. 打开 [Amazon EKS 控制台](https://console.aws.amazon.com/eks/home#/clusters)。
1. 选择集群的名称。
1. 选择 **Networking**（联网）选项卡。
1. 从 **ClusterControlPlaneSecurityGroup** 下拉列表中选择时使用 **Additional security groups**（其他安全组）值作为参考。
+ **ApiServerEndpoint**：输入 EKS 集群的 API 服务器端点。可以在 EKS 集群控制台的“详细信息”部分中找到此信息
+ **CertificateAuthorityData**：输入 base64 编码的证书颁发机构数据，这些数据也可以在 EKS 集群控制台的“详细信息”部分中找到。
+ **ServiceCidr**：输入用于为集群内的 Kubernetes 服务分配 IP 地址的 CIDR 范围。可以在 EKS 集群控制台的“网络”选项卡中找到此信息。
+ **AuthenticationMode**：查看 EKS 集群控制台中的访问选项卡，选择 EKS 集群中正在使用的身份验证模式。
+ **NodeGroupName**：输入节点组的名称。稍后您可以使用此名称来标识为您的节点创建的自动扩缩节点组。节点组名称的长度不能超过 63 个字符。它必须以字母或数字开头，但也可以包括其余字符的连字符和下划线。
+ **NodeAutoScalingGroupMinSize**：输入您的节点自动扩缩组可横向缩减到的最小节点数。
+ **NodeAutoScalingGroupDesiredCapacity**：输入创建堆栈时要扩展到的所需节点数目。
+ **NodeAutoScalingGroupMaxSize**：输入您的节点自动扩缩组可横向扩展到的最大节点数。
+ **NodeInstanceType**：选择节点的实例类型。有关更多信息，请参阅 [选择最优的 Amazon EC2 节点实例类型](choosing-instance-type.md)。
+ **NodeImageIdSSMParam**：使用用于某个变量 Kubernetes 版本最近的 Amazon EKS 优化版 Amazon Linux 2023 AMI 的 Amazon EC2 Systems Manager 参数进行预填充。要使用 Amazon EKS 支持的其他 Kubernetes 次要版本，可以将 *1.XX* 替换为不同的[支持版本](https://docs.aws.amazon.com/eks/latest/userguide/kubernetes-versions.html)。我们建议您指定与您的集群相同的 Kubernetes 版本。
您也可以将 *amazon-linux-2023* 替换为其它 AMI 类型。有关更多信息，请参阅 [检索建议的 Amazon Linux AMI ID](retrieve-ami-id.md)。
**注意**
Amazon EKS 节点 AMI 基于 Amazon Linux。您可以在 [Amazon Linux 安全中心](https://alas.aws.amazon.com/alas2023.html)跟踪 Amazon Linux 2023 的安全和隐私事件，或订阅关联的 [RSS 源](https://alas.aws.amazon.com/AL2023/alas.rss)。安全和隐私事件包括问题的概述、受影响的程序包以及如何更新实例以解决问题。
+ **NodeImageId**：（可选）如果使用自定义 AMI（而不是 Amazon EKS 优化型 AMI），则输入您 AWS 区域的节点 AMI ID。如果您在此处指定值，它会覆盖 **NodeImageIdSSMParam** 字段中的任意值。
+ **NodeVolumeSize**：指定您的节点的根卷大小（以 GiB 为单位）。
+ **NodeVolumeType**：指定您的节点的根卷类型。
+ **KeyName**：输入 Amazon EC2 SSH 密钥对的名称，您可使用该密钥对来在节点启动后使用 SSH 连接到这些节点。如果还没有 Amazon EC2 密钥对，可以在 AWS 管理控制台 中创建一个。有关更多信息，请参阅*《Amazon EC2 用户指南》*中的 [Amazon EC2 密钥对](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)。
+ **VpcId**：输入您创建的 [VPC](creating-a-vpc.md) 的 ID。
+ **Subnets**（子网）：选择您为 VPC 创建的子网。如果您使用[为您的 Amazon EKS 集群创建 Amazon VPC](creating-a-vpc.md) 中描述的步骤创建了 VPC，则在 VPC 中仅指定私有子网以供您的节点启动到其中。您可以通过从集群的 **Networking**（联网）选项卡中打开每个子网链接来查看哪些子网是私有的。
**重要**
如果其中的任何子网是公有子网，则其必须启用自动公有 IP 地址分配设置。如果没有为该公有子网启用该设置，则您部署到该公有子网的任何节点都不会分配到公有 IP 地址，也无法与集群或其它 AWS 服务进行通信。如果子网是在 2020 年 3 月 26 日之前使用任一 [Amazon EKS AWS CloudFormation VPC 模板](creating-a-vpc.md)部署的，或者是使用 `eksctl` 部署的，则会为这些公有子网禁用自动公有 IP 地址分配。有关如何为子网启用公有 IP 地址分配的信息，请参阅[修改子网的公有 IPv4 寻址属性](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-ip-addressing.html#subnet-public-ip)。如果节点部署到私有子网，则可以通过 NAT 网关与集群和其它 AWS 服务进行通信。
如果子网没有 Internet 访问权限，请确保您了解[部署具有有限互联网访问权限的私有集群](private-clusters.md)中的注意事项和额外步骤。
如果您选择 AWS Outposts、Wavelength 或本地区域子网，则这些子网不得在您创建集群时就已传入。
1. 在 **Configure stack options**（配置堆栈选项）页面上选择所需选项，然后选择 **Next**（下一步）。
1. 选择**我了解 AWS CloudFormation 可能会创建 IAM 资源。**左侧的复选框，然后选择**创建堆栈**。
1. 完成创建堆栈后，在控制台中选中它，然后选择 **Outputs（输出）**。如果您使用的是 `EKS API` 或 `EKS API and ConfigMap` 身份验证模式，则这是最后一步。
1. 如果您使用的是 `ConfigMap` 身份验证模式，请记录已创建的节点组的 **NodeInstanceRole**。
**第 2 步：使节点能够加入集群**
**注意**
只有在 EKS 集群内使用 Configmap 身份验证模式时，才需要执行以下两个步骤。此外，如果您在没有出站 Internet 访问的情况下在私有 VPC 内启动了节点，请确保使节点能够从 VPC 中加入您的集群。
1. 检查您是否已经应用拥有 `aws-auth` `ConfigMap`。
```
kubectl describe configmap -n kube-system aws-auth
```
1. 如果您看到的是 `aws-auth` `ConfigMap`，则请根据需要对其进行更新。
1. 打开 `ConfigMap` 文件进行编辑。
```
kubectl edit -n kube-system configmap/aws-auth
```
1. 根据需要添加新的 `mapRoles` 条目。将 `rolearn` 值设置为您在上一个步骤中记录的 **NodeInstanceRole** 值。
```
[...]
data:
mapRoles: |
- rolearn:
username: system:node:{{EC2PrivateDNSName}}
groups:
- system:bootstrappers
- system:nodes
[...]
```
1. 保存文件并退出文本编辑器。
1. 如果您收到错误提示 "`Error from server (NotFound): configmaps "aws-auth" not found`，则请使用库存 `ConfigMap`。
1. 下载配置映射。
```
curl -O https://s3.us-west-2.amazonaws.com/amazon-eks/cloudformation/2020-10-29/aws-auth-cm.yaml
```
1. 在 `aws-auth-cm.yaml` 文件中，将 `rolearn` 值设置为您在上一个步骤中记录的 **NodeInstanceRole** 值。您可以使用文本编辑器或者通过替换 *my-node-instance-role* 和运行以下命令来执行此操作：
```
sed -i.bak -e 's||my-node-instance-role|' aws-auth-cm.yaml
```
1. 应用配置。此命令可能需要几分钟才能完成。
```
kubectl apply -f aws-auth-cm.yaml
```
1. 查看节点的状态并等待它们达到 `Ready` 状态。
```
kubectl get nodes --watch
```
输入 `Ctrl`\$1`C` 以返回到 Shell 提示符。
**注意**
如果您收到任何授权或资源类型错误，请参阅故障排除主题中的 [未经授权或访问被拒绝 (`kubectl`)](troubleshooting.md#unauthorized)。
如果节点无法加入集群，则请参阅故障排除一章中的 [节点未能加入集群](troubleshooting.md#worker-node-fail)。
1. （仅限 GPU 节点）如果选择 GPU 实例类型和 Amazon EKS 优化版加速型 AMI，则必须在集群上应用[适用于 Kubernetes 的 NVIDIA 设备插件](https://github.com/NVIDIA/k8s-device-plugin)作为 DaemonSet。将 *vX.X.X* 替换为您需要的 [NVIDIA/k8s-device-plugin](https://github.com/NVIDIA/k8s-device-plugin/releases) 版本，然后运行以下命令。
```
kubectl apply -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/vX.X.X/deployments/static/nvidia-device-plugin.yml
```
**第 3 步：其它操作**
1. （可选）部署[示例应用程序](sample-deployment.md)以测试集群和 Linux 节点。
1. （可选）如果 **AmazonEKS\$1CNI\$1Policy** 托管 IAM 策略（如果您拥有 `IPv4` 集群）或 *AmazonEKS\$1CNI\$1IPv6\$1Policy*（如果您拥有 `IPv6` 集群时[自行创建](cni-iam-role.md#cni-iam-role-create-ipv6-policy)）附加到 [Amazon EKS 节点 IAM 角色](create-node-role.md)，我们建议将其分配给关联到 Kubernetes `aws-node` 服务账户的 IAM 角色。有关更多信息，请参阅 [配置 Amazon VPC CNI 插件以使用 IRSA](cni-iam-role.md)。
1. 如果满足以下条件，我们建议阻止容器组（pod）访问 IMDS：
+ 您计划将 IAM 角色分配给所有 Kubernetes 服务账户，以便容器组（pod）仅具有其所需的最低权限。
+ 集群中没有任何容器组（pod）需要出于其他原因（例如检索当前 AWS 区域）访问 Amazon EC2 实例元数据服务（IMDS）。
有关更多信息，请参阅[限制对分配给工作节点的实例配置文件的访问](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node)。
# 创建自主管理型 Bottlerocket 节点
**注意**
托管节点组可能会为您的使用案例带来一些优势。有关更多信息，请参阅 [使用托管式节点组简化节点生命周期](managed-node-groups.md)。
本主题介绍了如何启动向 Amazon EKS 集群注册的 [Bottlerocket](https://aws.amazon.com/bottlerocket/) 节点的自动扩缩组。Bottlerocket 是 AWS 的基于 Linux 的开源操作系统，用于在虚拟机或裸机主机上运行容器。在这些节点加入集群后，您可以向其部署 Kubernetes 应用程序。有关 Bottlerocket 的更多信息，请参阅 GitHub 上的[将 Bottlerocket AMI 与 Amazon EKS 一起使用](https://github.com/bottlerocket-os/bottlerocket/blob/develop/QUICKSTART-EKS.md)和 `eksctl` 文档中的[自定义 AMI 支持](https://eksctl.io/usage/custom-ami-support/)。
有关就地升级的信息，请参阅 GitHub 上的 [Bottlerocket Update Operator](https://github.com/bottlerocket-os/bottlerocket-update-operator)。
**重要**
Amazon EKS 节点是标准的 Amazon EC2 实例，您需要基于常规的 Amazon EC2 实例价格为其付费。有关更多信息，请参阅 [Amazon EC2 定价](https://aws.amazon.com/ec2/pricing/)。
您可以在 AWS Outpost 上的 Amazon EKS 扩展集群中启动 Bottlerocket 节点，但您无法在 AWS Outpost 上的本地集群中启动它们。有关更多信息，请参阅 [使用 AWS Outposts 在本地部署 Amazon EKS](eks-outposts.md)。
您可以部署到采用 `x86` 或 Arm 处理器的 Amazon EC2 实例。但是，您无法部署到具有 Inferentia 芯片的实例。
Bottlerocket 与 AWS CloudFormation 兼容。但是，没有可以复制用于为 Amazon EKS 部署 Bottlerocket 节点的官方 CloudFormation 模板。
Bottlerocket 映像不附带 SSH 服务器或 Shell。您可以使用带外访问方法来允许 SSH 启用管理员容器，并执行一些带有用户数据的引导启动配置步骤。有关更多信息，请参阅 GitHub 上的 [bottlerocket README.md](https://github.com/bottlerocket-os/bottlerocket)：
[Exploration (探索)](https://github.com/bottlerocket-os/bottlerocket#exploration)
[管理员容器](https://github.com/bottlerocket-os/bottlerocket#admin-container)
[Kubernetes 设置](https://github.com/bottlerocket-os/bottlerocket#kubernetes-settings)
此过程需要 `eksctl` 版本 `0.215.0` 或更高版本。可以使用以下命令来查看您的版本：
```
eksctl version
```
有关如何安装或升级 `eksctl` 的说明，请参阅 `eksctl` 文档中的[安装](https://eksctl.io/installation)。注意：此过程仅适用于使用 `eksctl` 创建的集群。
1. 将以下内容复制到您的设备。将 *my-cluster* 替换为您的集群的名称。名称只能包含字母数字字符（区分大小写）和连字符。该名称必须以字母数字字符开头，且不得超过 100 个字符。对于您在其中创建集群的 AWS 区域和 AWS 账户，该名称必须在其内具有唯一性。将 *ng-bottlerocket* 替换为您的节点组名称。节点组名称的长度不能超过 63 个字符。它必须以字母或数字开头，但也可以包括其余字符的连字符和下划线。要在 Arm 实例上部署，请将 *m5.large* 替换为 Arm 实例类型。将 *my-ec2-keypair-name* 替换为 Amazon EC2 SSH 密钥对的名称，您可使用该密钥对来在节点启动后使用 SSH 连接到这些节点。如果还没有 Amazon EC2 密钥对，可以在 AWS 管理控制台 中创建一个。有关更多信息，请参阅*《Amazon EC2 用户指南》*中的 [Amazon EC2 密钥对](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)。将所有剩余 example values 替换为您自己的值。完成替换后，运行修改后的命令以创建 `bottlerocket.yaml` 文件。
如果指定了 Arm Amazon EC2 实例类型，请在部署前查看 [Amazon EKS 优化版 Arm Amazon Linux AMI](eks-optimized-ami.md#arm-ami) 中的注意事项。有关使用自定义 AMI 进行部署的说明，请参阅 GitHub 上的[构建 Bottlerocket](https://github.com/bottlerocket-os/bottlerocket/blob/develop/BUILDING.md) 以及 `eksctl` 文档中的[自定义 AMI 支持](https://eksctl.io/usage/custom-ami-support/)。要部署托管节点组，请使用启动模板部署自定义 AMI。有关更多信息，请参阅 [使用启动模板自定义托管式节点](launch-templates.md)。
**重要**
要将节点组部署到 AWS Outposts、AWS Wavelength 或 AWS Local Zones 子网，就不要在创建集群时传递 AWS Outposts、AWS Wavelength 或 AWS Local Zones 子网。您必须在以下示例中指定子网。有关更多信息，请参阅 `eksctl` 文档中的[从配置文件创建节点组](https://eksctl.io/usage/nodegroups/#creating-a-nodegroup-from-a-config-file)和 [Config 文件架构](https://eksctl.io/usage/schema/)。将 *region-code* 替换为您的集群所在的 AWS 区域。
```
cat >bottlerocket.yaml <
本主题介绍了如何启动向 Amazon EKS 集群注册的 Windows 节点的自动扩缩组。在这些节点加入集群后，您可以向其部署 Kubernetes 应用程序。
**重要**
Amazon EKS 节点是标准的 Amazon EC2 实例，您需要基于常规的 Amazon EC2 实例价格为其付费。有关更多信息，请参阅 [Amazon EC2 定价](https://aws.amazon.com/ec2/pricing/)。
您可以在 AWS Outpost 上的 Amazon EKS 扩展集群中启动 Windows 节点，但您无法在 AWS Outpost 上的本地集群中启动它们。有关更多信息，请参阅 [使用 AWS Outposts 在本地部署 Amazon EKS](eks-outposts.md)。
为集群启用 Windows 支持。我们建议您在启动 Windows 节点组之前查看重要的注意事项。有关更多信息，请参阅 [启用 Windows 支持](windows-support.md#enable-windows-support)。
您可以通过以下任一方法启动自主管理型 Windows 节点：
+ [`eksctl`](#eksctl_create_windows_nodes)
+ [AWS 管理控制台](#console_create_windows_nodes)
## `eksctl`
**使用 `eksctl` 启动自主管理型 Windows 节点**
此过程要求您已安装 `eksctl`，且您的 `eksctl` 版本至少为 `0.215.0`。可以使用以下命令来查看您的版本。
```
eksctl version
```
有关安装或升级 `eksctl` 的说明，请参阅 `eksctl` 文档中的 [Installation](https://eksctl.io/installation)。
**注意**
此过程仅适用于使用 `eksctl` 创建的集群。
1. （可选）如果 **AmazonEKS\$1CNI\$1Policy** 托管 IAM 策略（如果您拥有 `IPv4` 集群）或 *AmazonEKS\$1CNI\$1IPv6\$1Policy*（如果您拥有 `IPv6` 集群时[自行创建](cni-iam-role.md#cni-iam-role-create-ipv6-policy)）附加到 [Amazon EKS 节点 IAM 角色](create-node-role.md)，我们建议将其分配给关联到 Kubernetes `aws-node` 服务账户的 IAM 角色。有关更多信息，请参阅 [配置 Amazon VPC CNI 插件以使用 IRSA](cni-iam-role.md)。
1. 此过程假设您已经有一个现有集群。如果还没有可添加 Windows 节点组的 Amazon EKS 集群和 Amazon Linux 节点组，则建议按照[开始使用 Amazon EKS – `eksctl`](getting-started-eksctl.md) 中的说明操作。该指南提供使用 Amazon Linux 节点创建 Amazon EKS 集群的完整演练。
使用以下命令创建您的节点组。将 *region-code* 替换为您的集群所在的 AWS 区域。将 *my-cluster* 替换为您的集群名称。名称只能包含字母数字字符（区分大小写）和连字符。该名称必须以字母数字字符开头，且不得超过 100 个字符。对于您在其中创建集群的 AWS 区域和 AWS 账户，该名称必须在其内具有唯一性。将 *ng-windows* 替换为您的节点组名称。节点组名称的长度不能超过 63 个字符。它必须以字母或数字开头，但也可以包括其余字符的连字符和下划线。您可以将 *2019* 替换为 `2022` 以使用 Windows Server 2022，或替换为 `2025` 以使用 Windows Server 2025。将 example values 的剩余部分替换为您自己的值。
**重要**
要将节点组部署到 AWS Outposts、AWS Wavelength 或 AWS 本地区域子网，在创建集群时不要传递 AWS Outposts、Wavelength 或本地区域子网。使用配置文件创建节点组，指定 AWS Outposts、Wavelength 或本地区域子网。有关更多信息，请参阅 `eksctl` 文档中的[从配置文件创建节点组](https://eksctl.io/usage/nodegroups/#creating-a-nodegroup-from-a-config-file)和 [Config 文件架构](https://eksctl.io/usage/schema/)。
```
eksctl create nodegroup \
--region region-code \
--cluster my-cluster \
--name ng-windows \
--node-type t2.large \
--nodes 3 \
--nodes-min 1 \
--nodes-max 4 \
--managed=false \
--node-ami-family WindowsServer2019FullContainer
```
**注意**
如果节点无法加入集群，请参阅《故障排除指南》中的 [节点未能加入集群](troubleshooting.md#worker-node-fail)。
要查看 `eksctl` 命令可用选项，请输入以下命令。
```
eksctl command -help
```
示例输出如下。创建节点时会输出几行。输出的最后几行类似于以下示例行。
```
[✔] created 1 nodegroup(s) in cluster "my-cluster"
```
1. （可选）部署[示例应用程序](sample-deployment.md)以测试您的集群和 Windows 节点。
1. 如果满足以下条件，我们建议阻止容器组（pod）访问 IMDS：
+ 您计划将 IAM 角色分配给所有 Kubernetes 服务账户，以便容器组（pod）仅具有其所需的最低权限。
+ 集群中没有任何容器组（pod）需要出于其他原因（例如检索当前 AWS 区域）访问 Amazon EC2 实例元数据服务（IMDS）。
有关更多信息，请参阅[限制对分配给 Worker 节点的实例配置文件的访问](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node)。
## AWS 管理控制台
**先决条件**
+ 现有 Amazon EKS 集群和 Linux 节点组。如果您没有这些资源，我们建议您按照我[开始使用 Amazon EKS](getting-started.md)中的指南之一创建它们。这些指南介绍如何使用 Linux 节点创建 Amazon EKS 集群。
+ 符合 Amazon EKS 集群要求的现有 VPC 和安全组。有关更多信息，请参阅[查看 Amazon EKS 对 VPC 和子网的联网要求](network-reqs.md)和[查看集群的 Amazon EKS 安全组要求](sec-group-reqs.md)。[开始使用 Amazon EKS](getting-started.md) 中的指南创建符合要求的 VPC。或者，您可以按照[为 Amazon EKS 集群创建一个 Amazon VPC](creating-a-vpc.md) 中的说明，手动创建一个。
+ 现有 Amazon EKS 集群，它使用符合 Amazon EKS 集群要求的 VPC 和安全组。有关更多信息，请参阅 [创建一个 Amazon EKS 集群。](create-cluster.md)。如果您在启用了 AWS Outposts、AWS Wavelength 或 AWS 本地区域的 AWS 区域中拥有子网，则这些子网不得在您创建集群时就已传入。
**第 1 步：使用 AWS 管理控制台 启动自行管理 Windows 节点**
1. 等待集群状态显示为 `ACTIVE`。如果在集群处于活动状态之前启动节点，则节点将无法向集群注册，您需要重新启动节点。
1. 打开 [AWS CloudFormation 控制台](https://console.aws.amazon.com/cloudformation/)
1. 选择**创建堆栈**。
1. 对于 **Specify template（指定模板）**，选择 **Amazon S3 URL**。
1. 复制以下 URL 并将其粘贴到 **Amazon S3 URL** 中。
```
https://s3.us-west-2.amazonaws.com/amazon-eks/cloudformation/2023-02-09/amazon-eks-windows-nodegroup.yaml
```
1. 选择 **Next**（下一步）两次。
1. 在 **Quick create stack**（快速创建堆栈）页面上，相应地填写以下参数：
+ **堆栈名称**：为 AWS CloudFormation 堆栈选择堆栈名称。例如，您可以将其命名为 `my-cluster-nodes`。
+ **ClusterName**：输入您在创建 Amazon EKS 集群时使用的名称。
**重要**
此名称必须与在[第 1 步：创建您的 Amazon EKS 集群](getting-started-console.md#eks-create-cluster)中使用的名称完全匹配。否则，您的节点无法加入集群。
+ **ClusterControlPlaneSecurityGroup**：从您在创建 [VPC](creating-a-vpc.md) 时生成的 AWS CloudFormation 输出中，选择安全组。以下步骤显示了检索适用组的一种方法。
1. 打开 [Amazon EKS 控制台](https://console.aws.amazon.com/eks/home#/clusters)。
1. 选择集群的名称。
1. 选择 **Networking**（联网）选项卡。
1. 从 **ClusterControlPlaneSecurityGroup** 下拉列表中选择时使用 **Additional security groups**（其他安全组）值作为参考。
+ **NodeGroupName**：输入节点组的名称。稍后您可以使用此名称来标识为您的节点创建的自动扩缩节点组。节点组名称的长度不能超过 63 个字符。它必须以字母或数字开头，但也可以包括其余字符的连字符和下划线。
+ **NodeAutoScalingGroupMinSize**：输入您的节点自动扩缩组可横向缩减到的最小节点数。
+ **NodeAutoScalingGroupDesiredCapacity**：输入创建堆栈时要扩展到的所需节点数目。
+ **NodeAutoScalingGroupMaxSize**：输入您的节点自动扩缩组可横向扩展到的最大节点数。
+ **NodeInstanceType**：选择节点的实例类型。有关更多信息，请参阅 [选择最优的 Amazon EC2 节点实例类型](choosing-instance-type.md)。
**注意**
GitHub 的 [vpc\$1ip\$1resource\$1limit.go](https://github.com/aws/amazon-vpc-cni-k8s/blob/master/pkg/vpc/vpc_ip_resource_limit.go) 列出[适用于 Kubernetes 的 Amazon VPC CNI 插件](https://github.com/aws/amazon-vpc-cni-k8s)最新版本支持的实例类型。您可能需要更新 CNI 版本以使用最新的受支持实例类型。有关更多信息，请参阅 [使用 Amazon VPC CNI 将 IP 分配给容器组（pod）](managing-vpc-cni.md)。
+ **NodeImageIdSSMParam**：预先填充了当前推荐的 Amazon EKS 优化版 Windows Core AMI ID 的 Amazon EC2 Systems Manager 参数。要使用完整版本的 Windows，请将 *Core* 替换为 `Full`。
+ **NodeImageId**：（可选）如果使用自定义 AMI（而不是 Amazon EKS 优化型 AMI），则输入您 AWS 区域的节点 AMI ID。如果您为此字段指定值，它会覆盖 **NodeImageIdSSMParam** 字段中的任意值。
+ **NodeVolumeSize**：指定您的节点的根卷大小（以 GiB 为单位）。
+ **KeyName**：输入 Amazon EC2 SSH 密钥对的名称，您可使用该密钥对来在节点启动后使用 SSH 连接到这些节点。如果还没有 Amazon EC2 密钥对，可以在 AWS 管理控制台 中创建一个。有关更多信息，请参阅*《Amazon EC2 用户指南》*中的 [Amazon EC2 密钥对](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ec2-key-pairs.html)。
**注意**
如果此处不提供密钥对，AWS CloudFormation 堆栈创建将失败。
+ **BootstrapArguments**：指定要传递给节点引导脚本的所有可选参数，如使用 `-KubeletExtraArgs` 的其他 `kubelet` 实际参数。
+ **DisableIMDSv1**：预设情况下，每个节点支持实例元数据服务版本 1 (IMDSv1) 和 IMDSv2。您可以禁用 IMDSv1。要防止节点组中的未来节点和容器组（pod）使用 MDSv1，请将 **DisableIMDSv1** 设置为 **true**。有关 IMDS 的更多信息，请参阅[配置实例元数据服务](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html)。
+ **VpcId**：选择创建的 [VPC](creating-a-vpc.md) 的 ID。
+ **NodeSecurityGroups**：选择在您创建 [VPC](creating-a-vpc.md) 时为您的 Linux 节点组创建的安全组。如果您的 Linux 节点附加了多个安全组，请指定所有安全组。例如，如果 Linux 节点组是使用创建的 `eksctl`。
+ **子网**：选择创建的子网。如果您使用[为 Amazon EKS 集群创建 Amazon VPC](creating-a-vpc.md) 中的步骤创建了 VPC，则在 VPC 中仅指定私有子网以供您的节点启动到其中。
**重要**
如果其中的任何子网是公有子网，则其必须启用自动公有 IP 地址分配设置。如果没有为该公有子网启用该设置，则您部署到该公有子网的任何节点都不会分配到公有 IP 地址，也无法与集群或其它 AWS 服务进行通信。如果子网是在 2020 年 3 月 26 日之前使用任一 [Amazon EKS AWS CloudFormation VPC 模板](creating-a-vpc.md)部署的，或者是使用 `eksctl` 部署的，则会为这些公有子网禁用自动公有 IP 地址分配。有关如何为子网启用公有 IP 地址分配的信息，请参阅[修改子网的公有 IPv4 寻址属性](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-ip-addressing.html#subnet-public-ip)。如果节点部署到私有子网，则可以通过 NAT 网关与集群和其它 AWS 服务进行通信。
如果子网没有 Internet 访问权限，请确保您了解[部署具有有限互联网访问权限的私有集群](private-clusters.md)中的注意事项和额外步骤。
如果您选择 AWS Outposts、Wavelength 或本地区域子网，则这些子网不得在您创建集群时就已传入。
1. 确认堆栈可创建 IAM 资源，然后选择 **Create stack（创建堆栈）**。
1. 完成创建堆栈后，在控制台中选中它，然后选择 **Outputs（输出）**。
1. 记录已创建的节点组的 **NodeInstanceRole**。您在配置 Amazon EKS Windows 节点时需要此值。
**第 2 步：使节点能够加入集群**
1. 检查您是否已经应用拥有 `aws-auth` `ConfigMap`。
```
kubectl describe configmap -n kube-system aws-auth
```
1. 如果您看到的是 `aws-auth` `ConfigMap`，则请根据需要对其进行更新。
1. 打开 `ConfigMap` 文件进行编辑。
```
kubectl edit -n kube-system configmap/aws-auth
```
1. 根据需要添加新的 `mapRoles` 条目。将 `rolearn` 值设置为您在前面的步骤中记录的 **NodeInstanceRole** 值。
```
[...]
data:
mapRoles: |
- rolearn:
username: system:node:{{EC2PrivateDNSName}}
groups:
- system:bootstrappers
- system:nodes
- rolearn:
username: system:node:{{EC2PrivateDNSName}}
groups:
- system:bootstrappers
- system:nodes
- eks:kube-proxy-windows
[...]
```
1. 保存文件并退出文本编辑器。
1. 如果您收到错误提示 "`Error from server (NotFound): configmaps "aws-auth" not found`，则请使用库存 `ConfigMap`。
1. 下载配置映射。
```
curl -O https://s3.us-west-2.amazonaws.com/amazon-eks/cloudformation/2020-10-29/aws-auth-cm-windows.yaml
```
1. 在 `aws-auth-cm-windows.yaml` 文件中，将 `rolearn` 值设置为您在前面的步骤中记录的 **NodeInstanceRole** 值。您可以使用文本编辑器或者通过替换 example values 和运行以下命令来执行此操作：
```
sed -i.bak -e 's||my-node-linux-instance-role|' \
-e 's||my-node-windows-instance-role|' aws-auth-cm-windows.yaml
```
**重要**
请勿修改此文件中的任何其它行。
不要对 Windows 和 Linux 节点使用相同的 IAM 角色。
1. 应用配置。此命令可能需要几分钟才能完成。
```
kubectl apply -f aws-auth-cm-windows.yaml
```
1. 查看节点的状态并等待它们达到 `Ready` 状态。
```
kubectl get nodes --watch
```
输入 `Ctrl`\$1`C` 以返回到 Shell 提示符。
**注意**
如果您收到任何授权或资源类型错误，请参阅故障排除主题中的 [未经授权或访问被拒绝 (`kubectl`)](troubleshooting.md#unauthorized)。
如果节点无法加入集群，则请参阅故障排除一章中的 [节点未能加入集群](troubleshooting.md#worker-node-fail)。
**第 3 步：其它操作**
1. （可选）部署[示例应用程序](sample-deployment.md)以测试您的集群和 Windows 节点。
1. （可选）如果 **AmazonEKS\$1CNI\$1Policy** 托管 IAM 策略（如果您拥有 `IPv4` 集群）或 *AmazonEKS\$1CNI\$1IPv6\$1Policy*（如果您拥有 `IPv6` 集群时[自行创建](cni-iam-role.md#cni-iam-role-create-ipv6-policy)）附加到 [Amazon EKS 节点 IAM 角色](create-node-role.md)，我们建议将其分配给关联到 Kubernetes `aws-node` 服务账户的 IAM 角色。有关更多信息，请参阅 [配置 Amazon VPC CNI 插件以使用 IRSA](cni-iam-role.md)。
1. 如果满足以下条件，我们建议阻止容器组（pod）访问 IMDS：
+ 您计划将 IAM 角色分配给所有 Kubernetes 服务账户，以便容器组（pod）仅具有其所需的最低权限。
+ 集群中没有任何容器组（pod）需要出于其他原因（例如检索当前 AWS 区域）访问 Amazon EC2 实例元数据服务（IMDS）。
有关更多信息，请参阅[限制对分配给工作节点的实例配置文件的访问](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node)。
# 创建自主管理型 Ubuntu Linux 节点
**注意**
托管节点组可能会为您的使用案例带来一些优势。有关更多信息，请参阅 [使用托管式节点组简化节点生命周期](managed-node-groups.md)。
本主题介绍了如何启动向 Amazon EKS 集群注册的[适用于 Amazon Elastic Kubernetes Service（EKS）的 Ubuntu](https://cloud-images.ubuntu.com/aws-eks/) 节点自动扩缩组，或[适用于 Amazon Elastic Kubernetes Service（EKS）的 Ubuntu Pro](https://ubuntu.com/blog/ubuntu-pro-for-eks-is-now-generally-available) 节点的自动扩缩组。适用于 EKS 的 Ubuntu 和 Ubuntu Pro 基于官方的 Ubuntu Minimal LTS，包括与 AWS 共同开发并专门为 EKS 构建的自定义 AWS 内核。Ubuntu Pro 通过支持 EKS 延期支持期、内核 livepatch、FIPS 合规性以及运行无限制 Pro 容器的功能，增加了额外的安全覆盖。
在这些节点加入集群后，您可以向其部署容器化应用程序。有关更多信息，请访问有关 [AWS 上的 Ubuntu](https://documentation.ubuntu.com/aws/en/latest/) 的文档和 `eksctl` 文档中的[自定义 AMI 支持](https://eksctl.io/usage/custom-ami-support/)。
**重要**
Amazon EKS 节点是标准的 Amazon EC2 实例，您需要基于常规的 Amazon EC2 实例价格为其付费。有关更多信息，请参阅 [Amazon EC2 定价](https://aws.amazon.com/ec2/pricing/)。
您可以在 AWS Outposts 上的 Amazon EKS 扩展集群中启动 Ubuntu 节点，但您无法在 AWS Outposts 上的本地集群中启动这些节点。有关更多信息，请参阅 [使用 AWS Outposts 在本地部署 Amazon EKS](eks-outposts.md)。
您可以部署到采用 `x86` 或 Arm 处理器的 Amazon EC2 实例。但是，具有 Inferentia 芯片的实例可能需要先安装 [Neuron SDK](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/)。
此过程需要 `eksctl` 版本 `0.215.0` 或更高版本。可以使用以下命令来查看您的版本：
```
eksctl version
```
有关如何安装或升级 `eksctl` 的说明，请参阅 `eksctl` 文档中的[安装](https://eksctl.io/installation)。注意：此过程仅适用于使用 `eksctl` 创建的集群。
1. 将以下内容复制到您的设备。将 `my-cluster` 替换为您的集群名称。名称只能包含字母数字字符（区分大小写）和连字符。该名称必须以字母字符开头，且不得超过 100 个字符。将 `ng-ubuntu` 替换为您的节点组名称。节点组名称的长度不能超过 63 个字符。它必须以字母或数字开头，但也可以包括其余字符的连字符和下划线。要在 Arm 实例上部署，请将 `m5.large` 替换为 Arm 实例类型。将 `my-ec2-keypair-name` 替换为 Amazon EC2 SSH 密钥对的名称，您可使用该密钥对来在节点启动后使用 SSH 连接到这些节点。如果还没有 Amazon EC2 密钥对，可以在 AWS 管理控制台 中创建一个。有关更多信息，请参阅《Amazon EC2 用户指南》中的 [Amazon EC2 密钥对](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)。将所有剩余 example values 替换为您自己的值。完成替换后，运行修改后的命令以创建 `ubuntu.yaml` 文件。
**重要**
要将节点组部署到 AWS Outposts、AWS Wavelength 或 AWS Local Zones 子网，就不要在创建集群时传递 AWS Outposts、AWS Wavelength 或 AWS Local Zones 子网。您必须在以下示例中指定子网。有关更多信息，请参阅 `eksctl` 文档中的[从配置文件创建节点组](https://eksctl.io/usage/nodegroups/#creating-a-nodegroup-from-a-config-file)和 [Config 文件架构](https://eksctl.io/usage/schema/)。将 *region-code* 替换为您的集群所在的 AWS 区域。
```
cat >ubuntu.yaml <
当发布新的 Amazon EKS 优化版 AMI 时，考虑将您自行管理节点组中的节点替换为这一新的 AMI。同样，如果为 Amazon EKS 集群更新 Kubernetes 版本，则还应更新节点将其用于同一 Kubernetes 版本。
**重要**
本主题介绍适用于自行管理的节点的节点更新。如果使用的是[托管式节点组](managed-node-groups.md)，请参阅[更新集群的托管式节点组](update-managed-node-group.md)。
有两种基本方法可以更新集群中自行管理的节点组以使用新 AMI：
**[将应用程序迁移到新的节点组](migrate-stack.md)**
创建一个新的节点组并将您的容器组（pod）迁移到该组。迁移到新节点组比简单地在现有 AWS CloudFormation 堆栈中更新 AMI ID 更好。这是因为迁移过程会将旧节点组[污染](https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/)为 `NoSchedule`，并在新堆栈准备好接受现有容器组（pod）工作负载之后耗尽节点。
**[更新 AWS CloudFormation 节点堆栈](update-stack.md)**
更新现有节点组的 AWS CloudFormation 堆栈以使用新 AMI。使用 `eksctl` 创建的节点组不支持此方法。
# 将应用程序迁移到新的节点组
本主题介绍如何创建新的节点组，将您的现有应用程序自然地迁移到新组，然后从您的集群中删除旧的节点组。您可以使用 `eksctl` 或 AWS 管理控制台 迁移到新的节点组。
+ [`eksctl`](#eksctl_migrate_apps)
+ [AWS 管理控制台 和 AWS CLI](#console_migrate_apps)
## `eksctl`
**使用 `eksctl` 将您的应用程序迁移到新的节点组**
有关使用 eksctl 进行迁移的更多信息，请参阅 `eksctl` 文档中的[非托管节点组](https://eksctl.io/usage/nodegroup-unmanaged/)。
此过程需要 `eksctl` 版本 `0.215.0` 或更高版本。可以使用以下命令来查看您的版本：
```
eksctl version
```
有关安装或升级 `eksctl` 的说明，请参阅 `eksctl` 文档中的 [Installation](https://eksctl.io/installation)。
**注意**
此过程仅适用于使用 `eksctl` 创建的集群和节点组。
1. 检索您现有节点组的名称，同时将 *my-cluster* 替换为您的集群名称。
```
eksctl get nodegroups --cluster=my-cluster
```
示例输出如下。
```
CLUSTER NODEGROUP CREATED MIN SIZE MAX SIZE DESIRED CAPACITY INSTANCE TYPE IMAGE ID
default standard-nodes 2019-05-01T22:26:58Z 1 4 3 t3.medium ami-05a71d034119ffc12
```
1. 用 `eksctl` 和下面的命令启动新节点组。将命令中的所有 *example value* 替换为您自己的值。版本号不能高于控制面板的 Kubernetes 版本，也不能比控制面板的 Kubernetes 版本低两个以上的次要版本。我们建议您使用与控制面板相同的版本。
如果满足以下条件，我们建议阻止容器组（pod）访问 IMDS：
+ 您计划将 IAM 角色分配给所有 Kubernetes 服务账户，以便容器组（pod）仅具有其所需的最低权限。
+ 集群中没有任何容器组（pod）需要出于其他原因（例如检索当前 AWS 区域）访问 Amazon EC2 实例元数据服务（IMDS）。
有关更多信息，请参阅[限制对分配给 Worker 节点的实例配置文件的访问](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node)。
要阻止容器组（pod）对 IMDS 的访问，请将 `--disable-pod-imds` 选项添加到以下命令。
**注意**
有关更多可用标志及其说明，请参阅 https://eksctl.io/。
```
eksctl create nodegroup \
--cluster my-cluster \
--version 1.35 \
--name standard-nodes-new \
--node-type t3.medium \
--nodes 3 \
--nodes-min 1 \
--nodes-max 4 \
--managed=false
```
1. 当上一个命令完成时，使用以下命令验证您的所有节点是否已达到 `Ready` 状态：
```
kubectl get nodes
```
1. 使用以下命令删除原始节点组。在命令中，将所有 *example value* 替换为集群和节点组名称：
```
eksctl delete nodegroup --cluster my-cluster --name standard-nodes-old
```
## AWS 管理控制台 和 AWS CLI
**使用 AWS 管理控制台和 AWS CLI 将您的应用程序迁移到新的节点组。**
1. 执行[创建自行管理的 Amazon Linux 节点](launch-workers.md)中概述的步骤，启动新的节点组。
1. 完成创建堆栈后，在控制台中选中它，然后选择 **Outputs（输出）**。
1. 记录已创建的节点组的 **NodeInstanceRole**。您需要它来将新的 Amazon EKS 节点添加到集群。
**注意**
如果您已将任何其他 IAM 策略附加到旧节点组 IAM 角色，则应将这些相同的策略附加到新节点组 IAM 角色以在新组上保持该功能。这适用于为 Kubernetes [Cluster Autoscaler](https://github.com/kubernetes/autoscaler/tree/master/cluster-autoscaler) 添加权限的情况。
1. 同时更新两个节点组的安全组，以便它们可以相互通信。有关更多信息，请参阅 [查看集群的 Amazon EKS 安全组要求](sec-group-reqs.md)。
1. 记下两个节点组的安全组 ID。这在 AWS CloudFormation 堆栈输出中显示为 **NodeSecurityGroup** 值。
您可以使用以下 AWS CLI 命令从堆栈名称中获取安全组 ID。在这些命令中，`oldNodes` 是您的较旧节点堆栈的 AWS CloudFormation 堆栈名称，`newNodes` 是要迁移到的堆栈的名称。将所有 *example value* 替换为您自己的值。
```
oldNodes="old_node_CFN_stack_name"
newNodes="new_node_CFN_stack_name"
oldSecGroup=$(aws cloudformation describe-stack-resources --stack-name $oldNodes \
--query 'StackResources[?ResourceType==`AWS::EC2::SecurityGroup`].PhysicalResourceId' \
--output text)
newSecGroup=$(aws cloudformation describe-stack-resources --stack-name $newNodes \
--query 'StackResources[?ResourceType==`AWS::EC2::SecurityGroup`].PhysicalResourceId' \
--output text)
```
1. 向每个节点安全组添加入口规则，以便它们接受彼此的流量。
以下 AWS CLI 命令向每个安全组添加入站规则，以允许来自另一个安全组的所有协议上的所有流量。通过此配置，在您将工作负载迁移到新组时，每个节点组中的容器组（pod）都可以相互通信。
```
aws ec2 authorize-security-group-ingress --group-id $oldSecGroup \
--source-group $newSecGroup --protocol -1
aws ec2 authorize-security-group-ingress --group-id $newSecGroup \
--source-group $oldSecGroup --protocol -1
```
1. 编辑 `aws-auth` configmap 以在 RBAC 中映射新的节点实例角色。
```
kubectl edit configmap -n kube-system aws-auth
```
为新的节点组添加新的 `mapRoles` 条目。
```
apiVersion: v1
data:
mapRoles: |
- rolearn: ARN of instance role (not instance profile)
username: system:node:{{EC2PrivateDNSName}}
groups:
- system:bootstrappers
- system:nodes>
- rolearn: arn:aws:iam::111122223333:role/nodes-1-16-NodeInstanceRole-U11V27W93CX5
username: system:node:{{EC2PrivateDNSName}}
groups:
- system:bootstrappers
- system:nodes
```
将 *ARN of instance role (not instance profile)* 代码段替换为在[上一步](#node-instance-role-step)中记录的 **NodeInstanceRole** 值。保存并关闭该文件以应用更新后的 configmap。
1. 查看节点的状态并等待新节点加入您的集群并达到 `Ready` 状态。
```
kubectl get nodes --watch
```
1. （可选）如果使用 [Kubernetes Cluster Autoscaler](https://github.com/kubernetes/autoscaler/tree/master/cluster-autoscaler)，请将部署缩减到 0 个副本以避免相互冲突的扩缩操作。
```
kubectl scale deployments/cluster-autoscaler --replicas=0 -n kube-system
```
1. 使用以下命令，对要使用 `NoSchedule` 删除的每个节点执行 Taint 操作。如此一来，就不会在要替换的节点上调用或重新调用新的容器组（pod）。有关更多信息，请参阅 Kubernetes 文档中的 [Taints and Tolerations](https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/)。
```
kubectl taint nodes node_name key=value:NoSchedule
```
如果要将节点升级到新的 Kubernetes 版本，则可使用以下代码段来标识并污染特定 Kubernetes 版本（此示例中为 `1.33` 版本）的所有节点。版本号不能高于控制面板的 Kubernetes 版本，也不能比控制面板的 Kubernetes 版本低两个以上的次要版本。我们建议您使用与控制面板相同的版本。
```
K8S_VERSION=1.33
nodes=$(kubectl get nodes -o jsonpath="{.items[?(@.status.nodeInfo.kubeletVersion==\"v$K8S_VERSION\")].metadata.name}")
for node in ${nodes[@]}
do
echo "Tainting $node"
kubectl taint nodes $node key=value:NoSchedule
done
```
1. 确定集群的 DNS 提供商。
```
kubectl get deployments -l k8s-app=kube-dns -n kube-system
```
示例输出如下。此集群使用 CoreDNS 解析 DNS，但您的集群可能会返回 `kube-dns`）：
```
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
coredns 1 1 1 1 31m
```
1. 如果您的当前部署所运行的副本少于 2 个，请将部署扩展到 2 个副本。如果您的上一个命令输出返回了该项，请将 *coredns* 替换为`kubedns`。
```
kubectl scale deployments/coredns --replicas=2 -n kube-system
```
1. 使用以下命令耗尽要从集群中删除的每个节点：
```
kubectl drain node_name --ignore-daemonsets --delete-local-data
```
如果您要将节点升级到新的 Kubernetes 版本，请使用以下代码段标识并耗尽特定 Kubernetes 版本（此示例中为 *1.33* 版本）的所有节点。
```
K8S_VERSION=1.33
nodes=$(kubectl get nodes -o jsonpath="{.items[?(@.status.nodeInfo.kubeletVersion==\"v$K8S_VERSION\")].metadata.name}")
for node in ${nodes[@]}
do
echo "Draining $node"
kubectl drain $node --ignore-daemonsets --delete-local-data
done
```
1. 在旧节点耗尽后，请撤销您之前授权的安全组入口规则。然后删除 AWS CloudFormation 堆栈以终止实例。
**注意**
如果您已将任何其它 IAM 策略附加到旧节点组 IAM 角色（例如，为 [Kubernetes Cluster Autoscaler](https://github.com/kubernetes/autoscaler/tree/master/cluster-autoscaler) 添加权限），请先将这些附加策略与该角色分离，然后才能删除 AWS CloudFormation 堆栈。
1. 撤销您之前为节点安全组创建的入站规则。在这些命令中，`oldNodes` 是您的较旧节点堆栈的 AWS CloudFormation 堆栈名称，`newNodes` 是要迁移到的堆栈的名称。
```
oldNodes="old_node_CFN_stack_name"
newNodes="new_node_CFN_stack_name"
oldSecGroup=$(aws cloudformation describe-stack-resources --stack-name $oldNodes \
--query 'StackResources[?ResourceType==`AWS::EC2::SecurityGroup`].PhysicalResourceId' \
--output text)
newSecGroup=$(aws cloudformation describe-stack-resources --stack-name $newNodes \
--query 'StackResources[?ResourceType==`AWS::EC2::SecurityGroup`].PhysicalResourceId' \
--output text)
aws ec2 revoke-security-group-ingress --group-id $oldSecGroup \
--source-group $newSecGroup --protocol -1
aws ec2 revoke-security-group-ingress --group-id $newSecGroup \
--source-group $oldSecGroup --protocol -1
```
1. 打开 [AWS CloudFormation 控制台](https://console.aws.amazon.com/cloudformation/)。
1. 选择您的旧节点堆栈。
1. 选择**删除**。
1. 在 **Delete stack**（删除堆栈）确认对话框中，请选择 **Delete stack**（删除堆栈）。
1. 编辑 `aws-auth` configmap 以从 RBAC 中删除旧节点实例角色。
```
kubectl edit configmap -n kube-system aws-auth
```
删除旧节点组的 `mapRoles` 条目。
```
apiVersion: v1
data:
mapRoles: |
- rolearn: arn:aws:iam::111122223333:role/nodes-1-16-NodeInstanceRole-W70725MZQFF8
username: system:node:{{EC2PrivateDNSName}}
groups:
- system:bootstrappers
- system:nodes
- rolearn: arn:aws:iam::111122223333:role/nodes-1-15-NodeInstanceRole-U11V27W93CX5
username: system:node:{{EC2PrivateDNSName}}
groups:
- system:bootstrappers
- system:nodes>
```
保存并关闭该文件以应用更新后的 configmap。
1. （可选）如果您使用的是 Kubernetes [Cluster Autoscaler](https://github.com/kubernetes/autoscaler/tree/master/cluster-autoscaler)，请将部署缩减为 1 个副本。
**注意**
您还必须适当地标记新的自动扩缩组（例如，`k8s.io/cluster-autoscaler/enabled,k8s.io/cluster-autoscaler/my-cluster`）并将您的 Cluster Autoscaler 部署命令更新为指向新标记的自动扩缩组。有关更多信息，请参阅 [AWS 上的 Cluster Autoscaler](https://github.com/kubernetes/autoscaler/tree/cluster-autoscaler-release-1.3/cluster-autoscaler/cloudprovider/aws)。
```
kubectl scale deployments/cluster-autoscaler --replicas=1 -n kube-system
```
1. （可选）确认您使用的是最新版本的 [Kubernetes 的 Amazon VPC CNI 插件](https://github.com/aws/amazon-vpc-cni-k8s)。您可能需要更新 CNI 版本以使用最新的受支持实例类型。有关更多信息，请参阅 [使用 Amazon VPC CNI 将 IP 分配给容器组（pod）](managing-vpc-cni.md)。
1. 如果您的集群使用适用于 DNS 解析的 `kube-dns`（请参阅[[migrate-determine-dns-step]](#migrate-determine-dns-step)），请将 `kube-dns` 部署横向缩减为 1 个副本。
```
kubectl scale deployments/kube-dns --replicas=1 -n kube-system
```
# 更新 AWS CloudFormation 节点堆栈
本主题介绍如何使用新 AMI 更新现有 AWS CloudFormation 自行管理的节点堆栈。在集群更新后，可以使用此过程将节点更新为新版本的 Kubernetes。或者，您可以更新到针对现有 Kubernetes 版本的最新 Amazon EKS 优化 AMI。
**重要**
本主题介绍适用于自行管理的节点的节点更新。有关[使用托管式节点组简化节点生命周期](managed-node-groups.md)的信息，请参阅[更新集群的托管式节点组](update-managed-node-group.md)。
最新的默认 Amazon EKS 节点 AWS CloudFormation 模板将配置为使用新 AMI 在集群中启动实例，然后再删除旧 AMI，一次删除一个。此配置可确保您在滚动更新期间始终具有集群中自动扩缩组所需的活动实例计数。
**注意**
使用 `eksctl` 创建的节点组不支持此方法。如果您使用 `eksctl` 创建了集群或节点组，请参阅 [将应用程序迁移到新的节点组](migrate-stack.md)。
1. 确定集群的 DNS 提供商。
```
kubectl get deployments -l k8s-app=kube-dns -n kube-system
```
示例输出如下。此集群使用 CoreDNS 解析 DNS，但您的集群可能会返回 `kube-dns`。您的输出可能看起来有所不同，具体取决于您使用的 `kubectl` 版本。
```
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
coredns 1 1 1 1 31m
```
1. 如果您的当前部署所运行的副本少于 2 个，请将部署扩展到 2 个副本。如果您的上一个命令输出返回了该项，请将 *coredns* 替换为`kube-dns`。
```
kubectl scale deployments/coredns --replicas=2 -n kube-system
```
1. （可选）如果使用 [Kubernetes Cluster Autoscaler](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/cloudprovider/aws/README.md)，请将部署缩减到 0 个副本以避免相互冲突的扩缩操作。
```
kubectl scale deployments/cluster-autoscaler --replicas=0 -n kube-system
```
1. 确定当前节点组的实例类型和所需的实例计数。以后更新该组的 AWS CloudFormation 模板时将输入这些值。
1. 通过以下网址打开 Amazon EC2 控制台：[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 请在左侧导航窗格中，选择 **Launch Configurations**（启动配置），然后记下现有节点启动配置的实例类型。
1. 请在左侧导航窗格中，选择**自动扩缩组**，并记下现有节点自动扩缩组的**所需**实例计数。
1. 打开 [AWS CloudFormation 控制台](https://console.aws.amazon.com/cloudformation/)。
1. 选择您的节点组堆栈，然后选择 **Update（更新）**。
1. 选择**替换当前模板**，然后选择 **Amazon S3 URL**。
1. 对于 **Amazon S3 URL**，请将以下 URL 粘贴到文本区域中以确保您使用的是最新版本的节点 AWS CloudFormation 模板。接下来，选择 **Next**（下一步）：
```
https://s3.us-west-2.amazonaws.com/amazon-eks/cloudformation/2022-12-23/amazon-eks-nodegroup.yaml
```
1. 在 **Specify stack details (指定堆栈详细信息)** 页面上，填写以下参数，然后选择 **Next (下一步)**：
+ **NodeAutoScalingGroupDesiredCapacity** - 输入在[上一步](#existing-worker-settings-step)记录的所需实例计数。或者输入更新堆栈时要扩展到的所需节点数目。
+ **NodeAutoScalingGroupMaxSize**：输入您的节点自动扩缩组可横向扩展到的最大节点数。此值必须比所需容量多至少一个节点。这样更新期间可以对节点进行滚动更新而不会减少节点数。
+ **NodeInstanceType** - 选择在[上一步](#existing-worker-settings-step)记录的实例类型。也可以为节点选择不同的实例类型。在选择其它实例类型之前，请查看[选择最优的 Amazon EC2 节点实例类型](choosing-instance-type.md)。每种 Amazon EC2 实例类型支持最大数量的弹性网络接口（网络接口），每个网络接口都支持最大数量的 IP 地址。由于为每个 Worker 节点和容器组（pod）分配了自己的 IP 地址，请务必选择一个实例类型，该实例类型可以支持您希望在每个 Amazon EC2 节点上运行的最大数量的容器组（pod）。有关实例类型支持的网络接口和 IP 地址数量的列表，请参阅[每种实例类型的每个网络接口的 IP 地址数](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html#AvailableIpPerENI)。例如，`m5.large` 实例类型最多支持 Worker 节点和容器组（pod）的 30 个 IP 地址。
**注意**
最新版本[适用于 Kubernetes 的 Amazon VPC CNI 插件](https://github.com/aws/amazon-vpc-cni-k8s)支持的实例类型在 GitHub 上的 [vpc\$1ip\$1resource\$1limit.go](https://github.com/aws/amazon-vpc-cni-k8s/blob/master/pkg/vpc/vpc_ip_resource_limit.go) 中显示。您可能需要更新适用于 Kubernetes 的 Amazon VPC CNI 插件版本，才能使用最新的受支持实例类型。有关更多信息，请参阅 [使用 Amazon VPC CNI 将 IP 分配给容器组（pod）](managing-vpc-cni.md)。
**重要**
一些实例类型并非在所有 AWS 区域中都可用。
+ **NodeImageIdSSMParam** – 要更新到的 AMI ID 的 Amazon EC2 Systems Manager 参数。以下值为 Kubernetes 版本 `1.35` 使用最新 Amazon EKS 优化版 AMI。
```
/aws/service/eks/optimized-ami/1.35/amazon-linux-2/recommended/image_id
```
您可以将 *1.35* 替换为相同的 [platform-version](https://docs.aws.amazon.com/eks/latest/userguide/platform-versions.html)。或者，它应该比控制面板运行的 Kubernetes 版本高最多一个版本。我们建议您将节点保持在与控制面板相同的版本。您也可以将 *amazon-linux-2* 替换为其它 AMI 类型。有关更多信息，请参阅 [检索建议的 Amazon Linux AMI ID](retrieve-ami-id.md)。
**注意**
使用 Amazon EC2 Systems Manager 参数让您可以在以后更新节点而无需查找和指定 AMI ID。如果您的 AWS CloudFormation 堆栈使用此值，则任何堆栈更新将为您指定的 Kubernetes 版本始终启动最新建议的 Amazon EKS 优化版 AMI。即使不更改模板中的任何值，情况也是如此。
+ **NodeImageId** – 要使用您的自定义 AMI，请输入要使用的 AMI 的 ID。
**重要**
此值覆盖为 **NodeImageIdSSMParam** 指定的任意值。如果您要使用 **NodeImageIdSSMParam** 值，请确保 **NodeImageId** 的值为空白。
+ **DisableIMDSv1** - 每个节点默认支持实例元数据服务版本 1 (IMDSv1) 和 IMDSv2。但可以禁用 IMDSv1。如果不希望节点组中调度的任何节点或任何容器组（pod）使用 IMDSv1，请选择 **true**。有关 IMDS 的更多信息，请参阅[配置实例元数据服务](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html)。如果已实施服务账户的 IAM 角色，请将所需权限直接分配给需要访问 AWS 服务的所有容器组（pod）。这样，集群中就没有任何容器组（pod）需要出于其他原因（例如检索当前 AWS 区域）访问 IMDS。然后，对于不使用主机网络的容器组（pod），您还可以禁用 IMDSv2 的访问权限。有关更多信息，请参阅[限制对分配给工作节点的实例配置文件的访问](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node)。
1. （可选）在 **Options (选项)** 页面上，为您的堆栈资源添加标签。选择**下一步**。
1. 在 **Review（审核）**页面上审核您的信息，确认堆栈可创建 IAM 资源，然后选择 **Update stack（更新堆栈）**。
**注意**
集群中每个节点的更新需要几分钟时间。等待所有节点更新完成，然后再执行后续步骤。
1. 如果您的集群的 DNS 提供商是 `kube-dns`，请将 `kube-dns` 部署横向缩减为 1 个副本。
```
kubectl scale deployments/kube-dns --replicas=1 -n kube-system
```
1. （可选）如果您使用的是 Kubernetes [Cluster Autoscaler](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/cloudprovider/aws/README.md)，请将部署缩减为所需数量的副本。
```
kubectl scale deployments/cluster-autoscaler --replicas=1 -n kube-system
```
1. （可选）确认您使用的是最新版本的 [Kubernetes 的 Amazon VPC CNI 插件](https://github.com/aws/amazon-vpc-cni-k8s)。您可能需要更新适用于 Kubernetes 的 Amazon VPC CNI 插件版本，才能使用最新的受支持实例类型。有关更多信息，请参阅 [使用 Amazon VPC CNI 将 IP 分配给容器组（pod）](managing-vpc-cni.md)。
# 使用 AWS Fargate 简化计算管理
本主题讨论使用 Amazon EKS 在 AWS Fargate 上运行 Kubernetes 容器组（pod）。Fargate 是一种为[容器](https://aws.amazon.com/what-are-containers)按需提供大小合适的计算容量的技术。使用 Fargate，您不必再自己预置、配置或扩展虚拟机组即可运行容器。您无需再选择服务器类型、确定扩展节点组的时间和优化集群打包。
您可以控制要在 Fargate 上启动的容器组（pod）及其如何利用 [Fargate 配置文件](fargate-profile.md)运行。Fargate 配置文件被定义为 Amazon EKS 集群的一部分。Amazon EKS 使用由 AWS 构建的控制器（使用 Kubernetes 提供的上游可扩展模型）将 Kubernetes 与 Fargate 集成。这些控制器作为 Amazon EKS 托管的 Kubernetes 控制面板的一部分运行，负责将本机 Kubernetes 容器组（pod）调度到 Fargate 上。除了若干转换和验证准入控制器外，Fargate 控制器还包括一个与默认 Kubernetes 调度器一起运行的新调度器。在启动满足 Fargate 上的运行条件的容器组（pod）时，集群中运行的 Fargate 控制器会识别、更新容器组（pod）并将其安排到 Fargate 上。
本主题介绍 Fargate 上运行的容器组（pod）的不同组件，还列出了将 Fargate 与 Amazon EKS 结合使用时的特别注意事项。
## AWS Fargate 注意事项
以下是使用 Amazon EKS 上的 Fargate 时要考虑的一些事项。
+ 在 Fargate 上运行的每个容器组都有自己的计算边界，不与其他容器组（pod）共享底层内核、CPU 资源、内存资源或弹性网络接口。
+ 网络负载均衡器和 Application Load Balancer (ALB) 只能与具有 IP 目标的 Fargate 一起使用。有关更多信息，请参阅[创建网络负载均衡器](network-load-balancing.md#network-load-balancer)和[使用应用程序负载均衡器路由应用程序和 HTTP 流量](alb-ingress.md)。
+ Fargate 暴露的服务仅在目标类型 IP 模式下运行，而不是在节点 IP 模式下运行。推荐通过服务名称进行连接来检查托管节点上运行的服务和 Fargate 上运行服务的连接性。
+ 在对容器组（pod）进行安排时，它们必须与 Fargate 配置文件匹配，才能在 Fargate 上运行。与 Fargate 配置文件不匹配的容器组可能会卡在 `Pending` 状态。如果存在匹配的 Fargate 配置文件，您可以删除已创建的待处理容器组（pod），将之重新调度到 Fargate 上。
+ Fargate 上不支持 Daemonset。如果应用程序需要进程守护程序，则应将该进程守护程序重新配置为在容器组（pod）中作为边车容器运行。
+ Fargate 上不支持特权容器。
+ 在 Fargate 上运行的容器组（pod）无法在容器组（pod）清单中指定 `HostPort` 或 `HostNetwork`。
+ 对于 Fargate 容器组（pod），默认 `nofile` 和 `nproc` 软限制为 1024，硬限制为 65535。
+ GPU 目前在 Fargate 上不可用。
+ 在 Fargate 上运行的容器组（pod）仅在私有子网上受支持（对 AWS 服务具有 NAT 网关访问权限，但没有到互联网网关的直接路由），因此您的集群的 VPC 必须具有可用的私有子网。对于没有出站 Internet 访问的集群，请参阅 [部署具有有限互联网访问权限的私有集群](private-clusters.md)。
+ 您可以按照[使用 Vertical Pod Autoscaler 调整容器组（pod）资源](vertical-pod-autoscaler.md)来设置 Fargate 容器组（pod）的正确初始 CPU 和内存大小，然后按照[使用 Horizontal Pod Autoscaler 扩展容器组（pod）部署](horizontal-pod-autoscaler.md)来扩展那些容器组（pod）。如果希望 Vertical Pod Autoscaler 自动将容器组（pod）重新部署到具有更大 CPU 和内存组合的 Fargate，请将 Vertical Pod Autoscaler 的模式设置为 `Auto` 或 `Recreate`，确保功能正常运行。有关更多信息，请参阅 GitHub 上的 [Vertical Pod Autoscaler](https://github.com/kubernetes/autoscaler/tree/master/vertical-pod-autoscaler#quick-start) 文档。
+ 必须为 VPC 启用 DNS 解析和 DNS 主机名。有关详细信息，请参阅[查看和更新您的 VPC 的 DNS 支持](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-updating)。
+ Amazon EKS Fargate 通过将虚拟机 (VM) 中的每个容器组隔离出来，从而为 Kubernetes 应用程序添加深度防御。此 VM 边界可防止在容器逃离情况下访问其他容器组使用的基于主机的资源，容器逃离是攻击容器化应用程序和获取容器外部资源访问权限的常见方法。
使用 Amazon EKS 不会更改您在[责任共担模式](security.md)下的责任。您应该仔细考虑集群安全和治理控制的配置。隔离应用程序的最安全方法始终是在单独的集群中运行该程序。
+ Fargate 配置文件支持从 VPC 辅助 CIDR 块指定子网。您可能想要指定辅助 CIDR 块。这是因为子网中可用 IP 地址的数量是有限的。因此，可在集群中创建的容器组（pod）数量受到限制。对容器组（pod）使用不同的子网，您可以增加可用 IP 地址的数量。有关更多信息，请参阅[向 VPC 中添加 IPv4 CIDR 块](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html#vpc-resize)。
+ 部署到 Fargate 节点的容器组（pod）无法使用 Amazon EC2 实例元数据服务（IMDS）。如果在 Fargate 部署了需要 IAM 凭证的容器组（pod），请使用[服务账户的 IAM 角色](iam-roles-for-service-accounts.md)将之分配到容器组（pod）。如果容器组（pod）需要通过 IMDS 访问其他可用信息，则必须将此信息硬编码到容器组（pod）规范中。这包括容器组（pod）部署到的 AWS 区域或可用区。
+ 您不能将 Fargate 容器组（pod）部署到 AWS Outposts、AWS Wavelength 或 AWS Local Zones。
+ Amazon EKS 必须定期修补 Fargate 容器组（pod）来确保它们的安全。我们以减少影响的方式尝试更新，但是有时候，如果没有成功驱逐容器组（pod），必须删除它们。您可以采取一些措施来尽量减少中断。有关更多信息，请参阅 [为 AWS Fargate 操作系统补丁事件设置操作](fargate-pod-patching.md)。
+ [适用于 Amazon EKS 的 Amazon VPC CNI 插件](https://github.com/aws/amazon-vpc-cni-plugins)安装在 Fargate 节点上。您不能将[适用于 Amazon EKS 集群的 Alternate CNI 插件](alternate-cni-plugins.md)用于 Fargate 节点。
+ Fargate 上运行的容器组（pod）会自动挂载 Amazon EFS 文件系统，无需手动执行驱动程序安装步骤。您不能将动态持久性卷预置与 Fargate 节点结合使用，但可以使用静态预置。
+ Amazon EKS 不支持 Fargate Spot。
+ 您无法将 Amazon EBS 卷挂载到 Fargate 容器组（pod）。
+ 您可以在 Fargate 节点上运行 Amazon EBS CSI 控制器，但 Amazon EBS CSI 节点 DaemonSet 只能在 Amazon EC2 实例上运行。
+ 在 [Kubernetes 作业](https://kubernetes.io/docs/concepts/workloads/controllers/job/)被标记为 `Completed` 或 `Failed` 后，作业创建的容器组（pod）通常会继续存在。此行为允许您查看日志和结果，但在使用 Fargate 的情况下，如果您过后不清理作业，则将会产生费用。
要在作业完成或失败后自动删除相关的容器组（pod），您可以使用生存时间（TTL）控制器指定时间段。以下示例显示了在作业清单中指定 `.spec.ttlSecondsAfterFinished`。
```
apiVersion: batch/v1
kind: Job
metadata:
name: busybox
spec:
template:
spec:
containers:
- name: busybox
image: busybox
command: ["/bin/sh", "-c", "sleep 10"]
restartPolicy: Never
ttlSecondsAfterFinished: 60 # <-- TTL controller
```
## Fargate 比较表
| 标准 | AWS Fargate |
| --- | --- |
| 可以部署到 [AWS Outposts](https://docs.aws.amazon.com/outposts/latest/userguide/what-is-outposts.html) | 否 |
| 可以部署到 [AWS 本地区域](local-zones.md) | 否 |
| 可以运行需要 Windows 的容器 | 否 |
| 可以运行需要 Linux 的容器 | 是 |
| 可以运行需要 Inferentia 芯片的工作负载 | 否 |
| 可以运行需要 GPU 的工作负载 | 否 |
| 可以运行需要 ARM 处理器的工作负载 | 否 |
| 可以运行 AWS [ Bottlerocket](https://aws.amazon.com/bottlerocket/) | 否 |
| 容器组（pod）之间共享内核运行时环境 | 否 – 每个容器组（pod）拥有专用的内核 |
| 容器组之间共享 CPU、内存、存储和网络资源。 | 否 – 每个容器组（pod）都有专用资源，并且可以独立调整大小，能够最大限度地提高资源利用率。 |
| 容器组（pod）可以使用多于容器组（pod）规范中所请求的硬件和内存 | 否 – 但是，可以使用更大的 vCPU 和内存配置重新部署容器组（pod）。 |
| 必须部署和管理 Amazon EC2 实例 | 否 |
| 必须保护、维护和修补 Amazon EC2 实例的操作系统 | 否 |
| 可以在部署节点时提供引导参数，例如额外的 [kubelet](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/) 实际参数。 | 否 |
| 可以从与分配给节点的 IP 地址不同的 CIDR 块为容器组（pod）分配 IP 地址。 | 否 |
| 可以通过 SSH 访问节点 | 否 – 没有主机操作系统要通过 SSH 访问的节点。 |
| 可以将您自己的自定义 AMI 部署到节点 | 否 |
| 可以将自己的自定义 CNI 部署到节点 | 否 |
| 必须自己更新节点 AMI | 否 |
| 必须自己更新节点 Kubernetes 版本 | 否 – 您不管理节点。 |
| 可以为容器组（pod）使用 Amazon EBS 存储 | 否 |
| 可以为容器组（pod）使用 Amazon EFS 存储 | [是](efs-csi.md) |
| 可以为容器组（pod）使用适用于 Lustre 的 Amazon FSx 存储 | 否 |
| 可以对服务使用 Network Load Balancer | 是，当使用[创建网络负载均衡器](network-load-balancing.md#network-load-balancer)时 |
| Pod 可以在公有子网中运行 | 否 |
| 可以将不同的 VPC 安全组分配给各个容器组（pod） | 是 |
| 可以运行 Kubernetes DaemonSets | 否 |
| 支持容器组（pod）清单中的 `HostPort` 和 `HostNetwork` | 否 |
| AWS 区域可用性 | [部分 Amazon EKS 支持的区域](https://docs.aws.amazon.com/general/latest/gr/eks.html) |
| 可以在 Amazon EC2 专属主机上运行容器 | 否 |
| 定价 | 单个 Fargate 内存和 CPU 配置的成本。每个容器组（pod）都有自己的成本。有关更多信息，请参阅 [AWS Fargate 定价](https://aws.amazon.com/fargate/pricing/)。 |
# 开始将 AWS Fargate 用于集群
本主题介绍如何通过 Amazon EKS 集群开始在 AWS Fargate 上运行容器组（pod）。
如果使用 CIDR 块限制对集群的公有端点的访问，建议您还启用私有端点访问。通过这种方式，Fargate 容器组（pod）可以与集群通信。在未启用私有端点的情况下，您指定用于公有访问的 CIDR 块必须包含来自 VPC 的出站源。有关更多信息，请参阅 [集群 API 服务器端点](cluster-endpoint.md)。
**先决条件**
现有集群。如果您还没有 Amazon EKS 集群，请参阅[开始使用 Amazon EKS](getting-started.md)。
## 第 1 步：确保现有节点可以与 Fargate 容器组（pod）进行通信
如果您使用的是没有节点的新集群，或是只有托管节点组的集群（请参阅[使用托管式节点组简化节点生命周期](managed-node-groups.md)），可以跳至[第 2 步：创建 Fargate 容器组（pod）执行角色](#fargate-sg-pod-execution-role)。
假设您正在使用已有关联节点的现有集群。确保这些节点上的容器组（pod）可以与 Fargate 上运行的容器组（pod）自由通信。在 Fargate 上运行的容器组（pod）会自动配置为使用与其关联的集群的集群安全组。确保集群中的任何现有节点都可以向集群安全组发送流量以及接收来自集群安全组的流量。托管节点组也会自动配置为使用集群安全组，所以您无需修改或检查它们是否具有此兼容性（请参阅[使用托管式节点组简化节点生命周期](managed-node-groups.md)）。
针对已使用 `eksctl` 或者 Amazon EKS 管理 AWS CloudFormation 模板创建的现有节点组，您可以手动将集群安全组添加到节点。您也可以修改节点组的自动扩缩组启动模板，以便将集群安全组附加到实例。有关更多信息，请参阅《Amazon VPC 用户指南》**中的[更改实例的安全组](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#SG_Changing_Group_Membership)。
您可以在 AWS 管理控制台 中集群的 **Networking**（联网）部分下，检查您集群的安全组。或者，您可以使用下面的 AWS CLI 命令进行这项操作。使用此命令时，请将 `` 替换为您的集群名称。
```
aws eks describe-cluster --name --query cluster.resourcesVpcConfig.clusterSecurityGroupId
```
## 第 2 步：创建 Fargate 容器组（pod）执行角色
当您的集群在 AWS Fargate 上创建容器组（pod）时，在 Fargate 基础设施上运行的组件必须代表您调用 AWS API。Amazon EKS 容器组（pod）执行角色提供执行此操作的 IAM 权限。要创建 AWS Fargate 容器组（pod）执行角色，请参阅 [Amazon EKS 容器组（pod）执行 IAM 角色](pod-execution-role.md)。
**注意**
如果您使用 `--fargate` 选项通过 `eksctl` 创建了集群，则集群已具有容器组（pod）执行角色，您可以使用模式 `eksctl-my-cluster-FargatePodExecutionRole-ABCDEFGHIJKL` 在 IAM 控制台中找到该角色。同理，如果您使用 `eksctl` 创建 Fargate 配置文件，则 `eksctl` 会创建您的容器组（pod）执行角色（如果尚未创建）。
## 第 3 步：为集群创建 Fargate 配置文件
您必须先定义一个 Fargate 配置文件，指定在启动时哪些容器组（pod）使用 Fargate，然后才能调度在集群中的 Fargate 上运行的容器组（pod）。有关更多信息，请参阅 [定义启动时将使用 AWS Fargate 的容器组（pod）](fargate-profile.md)。
**注意**
如果您使用 `--fargate` 选项通过 `eksctl` 创建了集群，则已经为您的集群创建了 Fargate 配置文件，而且其包含 `kube-system` 和 `default` 命名空间中所有容器组（pod）的选择器。使用以下程序为您想要用于 Fargate 的任何其他命名空间创建 Fargate 配置文件。
您可以使用以下任一工具创建 Fargate 配置文件：
+ [`eksctl`](#eksctl_fargate_profile_create)
+ [AWS 管理控制台](#console_fargate_profile_create)
### `eksctl`
此过程需要 `eksctl` 版本 `0.215.0` 或更高版本。可以使用以下命令来查看您的版本：
```
eksctl version
```
有关安装或升级 `eksctl` 的说明，请参阅 `eksctl` 文档中的 [Installation](https://eksctl.io/installation)。
**使用 `eksctl` 创建 Fargate 配置文件**
使用以下 `eksctl` 命令创建 Fargate 配置文件，并将所有 `` 替换为您自己的值。您需要指定命名空间。但是，`--labels` 选项不是必选。
```
eksctl create fargateprofile \
--cluster \
--name \
--namespace \
--labels
```
您可以将某些通配符用于 `` 和 `` 标签。有关更多信息，请参阅 [Fargate 配置文件通配符](fargate-profile.md#fargate-profile-wildcards)。
### AWS 管理控制台
**使用 AWS 管理控制台 创建 Fargate 配置文件**
1. 打开 [Amazon EKS 控制台](https://console.aws.amazon.com/eks/home#/clusters)。
1. 选择要为其创建 Fargate 配置文件的集群。
1. 请选择 **Compute**（计算）选项卡。
1. 在 **Fargate profiles（Fargate 配置文件）**下，选择 **Add Fargate profile（添加 Fargate 配置文件）**。
1. 在 **Configure Fargate profile**（配置 Fargate 配置文件）页面上，执行以下操作：
1. 对于 **Name**（名称），为 Fargate 配置文件输入名称。名称必须唯一。
1. 对于**容器组（pod）执行角色**，选择要用于您 Fargate 配置文件的容器组（pod）执行角色。将仅显示具有 `eks-fargate-pods.amazonaws.com` 服务委托人的 IAM 角色。如果您未看到列出的任何角色，则必须创建一个角色。有关更多信息，请参阅 [Amazon EKS 容器组（pod）执行 IAM 角色](pod-execution-role.md)。
1. 根据需要修改选定的**子网**。
**注意**
Fargate 上运行的容器组（pod）仅支持私有子网。
1. 对于 **Tags（标签）**，您可以自行选择是否为 Fargate 配置文件添加标签。这些标签不会传播到与配置文件关联的其他资源，如容器组（pod）。
1. 选择**下一步**。
1. 在**配置容器组（pod）选择**页面上，执行以下操作：
1. 对于**命名空间**，输入与容器组（pod）匹配的命名空间。
+ 您可以使用匹配的特定命名空间，例如 `kube-system` 或 `default`。
+ 您可以使用某些通配符（例如 `prod-*`）以匹配多个命名空间（例如，`prod-deployment` 和 `prod-test`)。有关更多信息，请参阅 [Fargate 配置文件通配符](fargate-profile.md#fargate-profile-wildcards)。
1. （可选）将 Kubernetes 标签添加到选择器中。特别是将它们添加到指定命名空间中的容器组（pod）需要匹配的那个。
+ 您可以将标签 `infrastructure: fargate` 添加到选择器中，以便只有指定命名空间中也具有 `infrastructure: fargate` Kubernetes 标签的容器组（pod）与选择器匹配。
+ 您可以使用某些通配符（例如 `key?: value?`）以匹配多个命名空间（例如，`keya: valuea` 和 `keyb: valueb`)。有关更多信息，请参阅 [Fargate 配置文件通配符](fargate-profile.md#fargate-profile-wildcards)。
1. 选择**下一步**。
1. 在 **Review and create（查看和创建）**页面上，查看 Fargate 配置文件的信息，然后选择 **Create（创建）**。
## 第 4 步：更新 CoreDNS
预设情况下，CoreDNS 配置为在 Amazon EKS 集群的 Amazon EC2 基础设施上运行。如果*仅*在集群中的 Fargate 上运行容器组（pod），请完成以下步骤。
**注意**
如果使用 `--fargate` 选项用 `eksctl` 创建集群，则可以跳至 [后续步骤](#fargate-gs-next-steps)。
1. 使用以下命令为 CoreDNS 创建 Fargate 配置文件。将 `` 替换为您的集群名称，将 `<111122223333>` 替换为您的账户 ID，将 `` 替换为您的容器组（pod）执行角色名称，并将 `<000000000000000a>`、`<000000000000000b>` 和 `<000000000000000c>` 替换为您的私有子网 ID。如果没有容器组（pod）执行角色，则必须先创建一个（请参阅[第 2 步：创建 Fargate 容器组（pod）执行角色](#fargate-sg-pod-execution-role)）。
**重要**
角色 ARN 不能包含 `/` 之外的[路径](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-friendly-names)。例如，如果您的角色名称为 `development/apps/AmazonEKSFargatePodExecutionRole`，则需要在为该角色指定 ARN 时将其更改为 `AmazonEKSFargatePodExecutionRole`。角色 ARN 的格式必须为 ` arn:aws:iam::<111122223333>:role/`。
```
aws eks create-fargate-profile \
--fargate-profile-name coredns \
--cluster-name \
--pod-execution-role-arn arn:aws:iam::<111122223333>:role/ \
--selectors namespace=kube-system,labels={k8s-app=kube-dns} \
--subnets subnet-<000000000000000a> subnet-<000000000000000b> subnet-<000000000000000c>
```
1. 触发 `coredns` 部署的推出。
```
kubectl rollout restart -n kube-system deployment coredns
```
## 后续步骤
+ 您可以开始使用以下工作流迁移现有应用程序来在 Fargate 上运行现有应用程序。
1. [创建 Fargate 配置文件](fargate-profile.md#create-fargate-profile)，该配置文件与您应用程序的 Kubernetes 命名空间和 Kubernetes 标签匹配。
1. 删除并重新创建所有现有的容器组（pod），以便可以在 Fargate 上调度容器组。修改 `` 和 `` 以更新您的特定容器组（pod）。
```
kubectl rollout restart -n deployment
```
+ 部署 [使用应用程序负载均衡器路由应用程序和 HTTP 流量](alb-ingress.md)，允许在 Fargate 上运行的容器组（pod）的入口对象。
+ 您可以使用 [使用 Vertical Pod Autoscaler 调整容器组（pod）资源](vertical-pod-autoscaler.md) 为 Fargate 容器组（pod）设置正确的初始 CPU 和内存大小，然后使用 [使用 Horizontal Pod Autoscaler 扩展容器组（pod）部署](horizontal-pod-autoscaler.md) 来扩展这些容器组（pod）。如果您希望 Vertical Pod Autoscaler 自动将容器组（pod）重新部署到具有更高 CPU 和内存组合的 Fargate，请将 Vertical Pod Autoscaler 的模式设置为 `Auto` 或 `Recreate`。这是为了确保正确的功能。有关更多信息，请参阅 GitHub 上的 [Vertical Pod Autoscaler](https://github.com/kubernetes/autoscaler/tree/master/vertical-pod-autoscaler#quick-start) 文档。
+ 您可以依照[这些说明](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Container-Insights-EKS-otel.html)设置 [AWS Distro for OpenTelemetry](https://aws.amazon.com/otel) (ADOT) 收集器，用于监控应用程序。
# 定义启动时将使用 AWS Fargate 的容器组（pod）
您必须先定义至少一个 Fargate 配置文件，指定在启动时哪些容器组（pod）使用 Fargate，然后才能调度集群中的 Fargate 上的容器组（pod）。
作为管理员，您可以使用 Fargate 配置文件声明哪些容器组（pod）在 Fargate 上运行。您可以通过配置文件的选择器执行此操作。您最多可以为每个配置文件添加五个选择器。每个选择器都必须包含一个命名空间。选择器还可以包含标签。标注字段由多个可选键值对组成。与选择器匹配的容器组（pod）被安排在 Fargate 上。容器组（pod）使用选择器中指定的命名空间和标签进行匹配。如果定义了没有标签的命名空间选择器，Amazon EKS 会尝试使用配置文件将在该命名空间中运行的所有容器组（pod）调度到 Fargate。如果待调度的容器组（pod）与 Fargate 配置文件中的任意一个选择器都匹配，则该容器组（pod）将被调度到 Fargate 上。
如果容器组（pod）匹配多个 Fargate 配置文件，您可以指定容器组（pod）使用的配置文件，方法为将以下 Kubernetes 标签添加到容器组（pod）规范：`eks.amazonaws.com/fargate-profile: my-fargate-profile`。但是，容器组（pod）仍必须匹配该配置文件中的选择器，才能被调度到 Fargate 上。Kubernetes 亲和性/反亲和性规则不适用，Amazon EKS Fargate 容器组（pod）并不需要这些规则。
创建 Fargate 配置文件时，必须指定容器组（pod）执行角色。此执行角色适用于使用配置文件在 Fargate 基础设施上运行的 Amazon EKS 组件。该角色将被添加到集群的 Kubernetes [基于角色的访问控制](https://kubernetes.io/docs/reference/access-authn-authz/rbac/)（RBAC）以进行授权。这样，Fargate 基础设施上运行的 `kubelet` 可以注册到您的 Amazon EKS 集群，并在您的集群中作为节点显示。容器组（pod）执行角色还提供对 Fargate 基础设施的 IAM 权限，以允许对 Amazon ECR 映像存储库进行读取访问。有关更多信息，请参阅 [Amazon EKS 容器组（pod）执行 IAM 角色](pod-execution-role.md)。
您无法更改 Fargate 配置文件。但是，您可以创建新的更新配置文件来替换现有配置文件，然后删除原始配置文件。
**注意**
删除配置文件后，使用 Fargate 配置文件运行的任何容器组（pod）都会停止并进入待处理状态。
如果集群中有任何 Fargate 配置文件处于 `DELETING` 状态，您必须等待删除该 Fargate 配置文件后，才能在该集群中创建其他配置文件。
**注意**
Fargate 目前不支持 Kubernetes [topologySpreadConstraints](https://kubernetes.io/docs/concepts/scheduling-eviction/topology-spread-constraints/)。
Amazon EKS 和 Fargate 将容器组（pod）分布在 Fargate 配置文件定义的每个子网中。但是，最终可能会出现不均匀的分布。如果您必须获得均匀的分布，请使用两个 Fargate 配置文件。在您希望部署两个副本并且不希望造成任何停机的方案中，均匀的分布非常重要。我们建议每个配置文件只有一个子网。
## Fargate 配置文件组件
Fargate 配置文件中包含以下组件。
**Pod 执行角色**
当您的集群在 AWS Fargate 上创建容器组（pod）时，在 Fargate 基础设施上运行的 `kubelet` 必须代表您调用 AWS API。例如，它需要调用才能从 Amazon ECR 提取容器镜像。Amazon EKS 容器组（pod）执行角色提供执行此操作的 IAM 权限。
创建 Fargate 配置文件时，必须指定要用于容器组（pod）的容器组（pod）执行角色。此角色将被添加到集群的 Kubernetes [基于角色的访问控制](https://kubernetes.io/docs/reference/access-authn-authz/rbac/)（RBAC）以进行授权。这允许在 Fargate 基础设施上运行的 `kubelet` 注册到您的 Amazon EKS 集群，以便它可以作为节点显示在您的集群中。有关更多信息，请参阅 [Amazon EKS 容器组（pod）执行 IAM 角色](pod-execution-role.md)。
**子网**
将容器组（pod）启动到其中的使用此配置文件的子网的 ID。目前，在 Fargate 上运行的容器组（pod）没有分配公有 IP 地址。因此，此参数仅接受私有子网（没有到互联网网关的直接路由）。
**选择器**
要匹配容器组（pod）以使用此 Fargate 配置文件的选择器。您最多可以在 Fargate 配置文件中指定五个选择器。选择器具有以下组件：
+ **命名空间** – 您必须为选择器指定命名空间。选择器仅匹配在此命名空间中创建的容器组（pod）。但是，您可以创建多个选择器来定位多个命名空间。
+ **标签** – 您可以选择指定 Kubernetes 标签来匹配选择器。选择器只匹配具有在选择器中指定的所有标签的容器组（pod）。
## Fargate 配置文件通配符
除了 Kubernetes 允许的字符外，您还可以在命名空间、标签键和标签值的选择器标准中使用 `*` 和 `?`：
+ `*` 表示无、一个或多个字符。例如，`prod*` 可以表示 `prod` 和 `prod-metrics`。
+ `?` 表示单个字符（例如，`value?` 可以表示 `valuea`)。但是，它不能表示 `value` 和 `value-a`，因为 `?` 只能准确地表示一个字符。
这些通配符可以在任何位置组合使用（例如，`prod*`、`*dev` 以及 `frontend*?`)。不支持其他通配符和模式匹配形式，例如正则表达式。
如果容器组（pod）规范中有多个配置文件与命名空间和标签匹配，Fargate 会根据配置文件名称的字母数字排序来选取配置文件。例如，如果配置文件 A（名称为 `beta-workload`）和配置文件 B（名称为 `prod-workload`）都有匹配的选择器可供要启动的容器组（pod）使用，Fargate 会为容器组（pod）选取配置文件 A (`beta-workload`)。容器组（pod）具有标签，显示容器组（pod）上有配置文件 A（例如 `eks.amazonaws.com/fargate-profile=beta-workload`）。
如果要将现有 Fargate 容器组（pod）迁移到使用通配符的新配置文件中，有两种方法可执行此操作：
+ 使用匹配的选择器创建一个新的配置文件，然后删除旧的配置文件。标有旧配置文件的容器组（pod）将被重新安排到新的匹配配置文件中。
+ 若要迁移工作负载，但不确定每个 Fargate 容器组（pod）上有哪些 Fargate 标签，则可以使用以下方法。创建一个新的配置文件，首先在同一个集群上的配置文件中按字母数字排序配置文件名称。然后，回收需要迁移到新配置文件的 Fargate 容器组（pod）。
## 创建 Fargate 配置文件
这一部分介绍如何创建 Fargate 配置文件。您还必须已经创建了要用于 Fargate 配置文件的容器组（pod）执行角色。有关更多信息，请参阅 [Amazon EKS 容器组（pod）执行 IAM 角色](pod-execution-role.md)。在 Fargate 上运行的容器组（pod）仅在私有子网上受支持（对 AWS 服务具有 [NAT 网关](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html)访问权限，但没有到互联网网关的直接路由）。因此，您的集群的 VPC 必须有可用的私有子网。
您可以使用以下工具创建配置文件。
+ [`eksctl`](#eksctl_create_a_fargate_profile)
+ [AWS 管理控制台](#console_create_a_fargate_profile)
## `eksctl`
**使用 `eksctl` 创建 Fargate 配置文件**
使用以下 `eksctl` 命令创建 Fargate 配置文件，并将所有示例值替换为您自己的值。您需要指定命名空间。但是，`--labels` 选项不是必选。
```
eksctl create fargateprofile \
--cluster my-cluster \
--name my-fargate-profile \
--namespace my-kubernetes-namespace \
--labels key=value
```
您可以将某些通配符用于 `my-kubernetes-namespace` 和 `key=value` 标签。有关更多信息，请参阅 [Fargate 配置文件通配符](#fargate-profile-wildcards)。
## AWS 管理控制台
**使用 AWS 管理控制台 创建 Fargate 配置文件**
1. 打开 [Amazon EKS 控制台](https://console.aws.amazon.com/eks/home#/clusters)。
1. 选择要为其创建 Fargate 配置文件的集群。
1. 请选择 **Compute**（计算）选项卡。
1. 在 **Fargate profiles（Fargate 配置文件）**下，选择 **Add Fargate profile（添加 Fargate 配置文件）**。
1. 在 **Configure Fargate profile**（配置 Fargate 配置文件）页面上，执行以下操作：
1. 对于 **Name**（名称），为 Fargate 配置文件输入唯一名称，例如 `my-profile`。
1. 对于**容器组（pod）执行角色**，选择要用于您 Fargate 配置文件的容器组（pod）执行角色。将仅显示具有 `eks-fargate-pods.amazonaws.com` 服务委托人的 IAM 角色。如果您未看到列出的任何角色，则必须创建一个角色。有关更多信息，请参阅 [Amazon EKS 容器组（pod）执行 IAM 角色](pod-execution-role.md)。
1. 根据需要修改选定的**子网**。
**注意**
Fargate 上运行的容器组（pod）仅支持私有子网。
1. 对于 **Tags（标签）**，您可以自行选择是否为 Fargate 配置文件添加标签。这些标签不会传播到与配置文件关联的其他资源，例如容器组（pod）。
1. 选择**下一步**。
1. 在**配置容器组（pod）选择**页面上，执行以下操作：
1. 对于**命名空间**，输入与容器组（pod）匹配的命名空间。
+ 您可以使用匹配的特定命名空间，例如 `kube-system` 或 `default`。
+ 您可以使用某些通配符（例如 `prod-*`）以匹配多个命名空间（例如，`prod-deployment` 和 `prod-test`)。有关更多信息，请参阅 [Fargate 配置文件通配符](#fargate-profile-wildcards)。
1. （可选）将 Kubernetes 标签添加到选择器中。特别是将它们添加到指定命名空间中的容器组（pod）需要匹配的那个。
+ 您可以将标签 `infrastructure: fargate` 添加到选择器中，以便只有指定命名空间中也具有 `infrastructure: fargate` Kubernetes 标签的容器组（pod）与选择器匹配。
+ 您可以使用某些通配符（例如 `key?: value?`）以匹配多个命名空间（例如，`keya: valuea` 和 `keyb: valueb`)。有关更多信息，请参阅 [Fargate 配置文件通配符](#fargate-profile-wildcards)。
1. 选择**下一步**。
1. 在 **Review and create（查看和创建）**页面上，查看 Fargate 配置文件的信息，然后选择 **Create（创建）**。
# 删除 Fargate 配置文件
本主题介绍如何删除 Fargate 配置文件。当您删除 Fargate 配置文件时，使用该配置文件调度到 Fargate 的所有容器组（pod）都将被删除。如果这些容器组（pod）与另一个 Fargate 配置文件匹配，则将使用该配置文件在 Fargate 上调度这些容器组（pod）。如果它们不再匹配任何 Fargate 配置文件，则不会被安排到 Fargate，并仍可能处于待处理状态。
集群中一次只能有一个 Fargate 配置文件处于 `DELETING` 状态。等待 Fargate 配置文件完成删除，然后才能删除该集群中的任何其他配置文件。
可以使用以下任一工具删除配置文件：
+ [`eksctl`](#eksctl_delete_a_fargate_profile)
+ [AWS 管理控制台](#console_delete_a_fargate_profile)
+ [AWS CLI](#awscli_delete_a_fargate_profile)
## `eksctl`
**使用 `eksctl` 删除 Fargate 配置文件**
使用以下命令从集群中删除配置文件。将所有 *example value* 替换为您自己的值。
```
eksctl delete fargateprofile --name my-profile --cluster my-cluster
```
## AWS 管理控制台
**使用 AWS 管理控制台删除 Fargate 配置文件**
1. 打开 [Amazon EKS 控制台](https://console.aws.amazon.com/eks/home#/clusters)。
1. 在左侧导航窗格中，选择**集群**。在集群列表中，选择要从中删除 Fargate 配置文件的集群。
1. 请选择 **Compute**（计算）选项卡。
1. 选择要删除的 Fargate 配置文件，然后选择 **Delete**（删除）。
1. 在 **Delete Fargate profile**（删除 Fargate 配置文件）页面上，输入配置文件的名称，然后选择 **Delete**（删除）。
## AWS CLI
**使用 AWS CLI 删除 Fargate 配置文件**
使用以下命令从集群中删除配置文件。将所有 *example value* 替换为您自己的值。
```
aws eks delete-fargate-profile --fargate-profile-name my-profile --cluster-name my-cluster
```
# 了解 Fargate 容器组（pod）配置详细信息
本节介绍在 AWS Fargate 上运行 Kubernetes 容器组（pod）的一些唯一容器组（pod）配置详细信息。
## Pod CPU 和内存
使用 Kubernetes，您可以定义请求、最低 vCPU 量以及分配给容器组（pod）中每个容器的内存资源。Kubernetes 会调度容器组（pod），确保至少每个容器组（pod）的请求资源可用于计算资源。有关更多信息，请参阅 Kubernetes 文档中的[管理容器的计算资源](https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/)。
**注意**
由于 Amazon EKS Fargate 对每个节点只运行一个容器组（pod），因此在资源较少的情况下不会出现驱逐容器组（pod）的情况。所有 Amazon EKS Fargate 容器组（pod）都以担保优先级运行，因此请求的 CPU 和内存必须等于所有容器的限制。有关更多信息，请参阅 Kubernetes 文档中的[为 Pod（一组容器）配置服务质量](https://kubernetes.io/docs/tasks/configure-pod-container/quality-service-pod/)。
在 Fargate 上调度容器组（pod）后，容器组（pod）规格中的 vCPU 和内存预留将确定为容器组（pod）预置的 CPU 和内存量。
+ 超出所有 Init 容器的最大请求用于确定 Init 请求 vCPU 和内存要求。
+ 将所有长时间运行的容器的请求相加来确定长时间运行的请求的 vCPU 和内存要求。
+ 然后为要用于容器组（pod）的 vCPU 和内存请求选择先前两个值中较大的值。
+ Fargate 会为所需 Kubernetes 组件（`kubelet`、`kube-proxy` 和 `containerd`）的每个容器组（pod）的内存预留增加 256 MB。
Fargate 向上舍入到下列最接近 vCPU 与内存请求总和的计算配置，确保容器组（pod）始终拥有运行所需的资源。
如果未指定 vCPU 和内存组合，则使用最小的可用组合（0.25 vCPU 和 0.5GB 内存）。
下表显示了 Fargate 上运行的容器组（pod）可以使用的 vCPU 和内存组合。
| vCPU 值 | 内存值 |
| --- | --- |
| .25 vCPU | 0.5GB、1GB、2GB |
| .5 vCPU | 1GB、2GB、3GB、4GB |
| 1 个 vCPU | 2GB、3GB、4GB、5GB、6GB、7GB、8GB |
| 2 个 vCPU | 4GB 到 16GB 之间（以 1GB 为增量） |
| 4 个 vCPU | 8GB 到 30GB 之间（以 1GB 为增量） |
| 8 个 vCPU | 介于 16GB 到 60GB 之间（以 4GB 为增量） |
| 16 个 vCPU | 介于 32GB 到 120GB 之间（以 8GB 为增量） |
为 Kubernetes 组件保留的额外内存可能会导致 Fargate 任务的 vCPUs 数量超过请求预置的 vCPU 数量。例如，由于没有具有 1 个 vCPU 和 9 GB 内存的任务可用，因此如果请求内容为 1 个 vCPU 和 8 GB 内存，则会为其内存请求增加 256 MB，并会为 Fargate 任务预置 2 个 vCPU 和 9 GB 内存。
Fargate 上运行的容器组（pod）大小与 Kubernetes 使用 `kubectl get nodes` 报告的节点大小之间没有相关性。报告的节点大小通常大于容器组（pod）的容量。您可以使用以下命令验证容器组（pod）容量。将 *default* 替换为容器组（pod）的命名空间，并将 *pod-name* 替换为容器组（pod）的名称。
```
kubectl describe pod --namespace default pod-name
```
示例输出如下。
```
[...]
annotations:
CapacityProvisioned: 0.25vCPU 0.5GB
[...]
```
`CapacityProvisioned` 注释表示强制执行的容器组（pod）容量，决定了在 Fargate 上运行的容器组（pod）的成本。有关这些计算配置的定价信息，请参阅 [AWS Fargate 定价](https://aws.amazon.com/fargate/pricing/)。
## Fargate 存储
Fargate 上运行的容器组（pod）会自动挂载 Amazon EFS 文件系统，无需手动执行驱动程序安装步骤。您不能将动态持久性卷预置与 Fargate 节点结合使用，但可以使用静态预置。有关更多信息，请参阅 GitHub 上的 [Amazon EFS CSI 驱动程序](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/docs/README.md)。
完成预置后，在 Fargate 上运行的每个容器组（pod）都会获得 20 GiB 的默认临时存储空间。这种类型的存储将在容器组（pod）停止后被删除。在 Fargate 上启动的新容器组（pod）会默认启用临时存储卷加密。使用 AWS Fargate 托管密钥通过 AES-256 加密算法对临时容器组（pod）存储进行加密。
**注意**
在 Fargate 上运行的 Amazon EKS 容器组（pod）的默认可用存储空间值小于 20 GiB。这是因为部分空间会被 `kubelet` 以及 Kubernetes 内部加载的其他容器组（pod）模块使用。
您最高可以将临时存储总量增加到 175GiB。要使用 Kubernetes 配置大小，请指定一个容器组（pod）中每个容器的 `ephemeral-storage` 资源请求数。在调度容器组（pod）时，Kubernetes 会确保每个容器组（pod）的资源请求总和小于 Fargate 任务的容量。有关更多信息，请参阅 Kubernetes 文档中的[为 Pod 和容器管理资源](https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/)。
Amazon EKS Fargate 预置的临时存储空间会高于请求的容量，以满足系统使用的需要。例如，假设您请求 100GiB 的空间，则系统会为 Fargate 任务预置 115GiB 的临时存储空间。
# 为 AWS Fargate 操作系统补丁事件设置操作
Amazon EKS 定期修补 AWS Fargate 节点的操作系统以确保它们的安全。作为修补过程的一部分，我们会回收节点来安装操作系统补丁。尝试更新的方式对您的服务造成的影响最小。但是，如果容器组（pod）没有成功被驱逐，有时必须删除容器组。以下是您可以采取的最大限度减少潜在中断的操作：
+ 设置适当的容器组（pod）中断预算（PDB），控制同时关闭的容器组（pod）数量。
+ 创建 Amazon EventBridge 规则，在删除容器组（pod）之前处理失败的驱逐。
+ 在您所收通知中发布的驱逐日期之前，手动重启受影响的容器组（pod）。
+ 在 AWS 用户通知中创建通知配置。
Amazon EKS 与 Kubernetes 社区密切合作，以便尽快提供错误修复和安全补丁。所有 Fargate 容器组（pod）都从最新的 Kubernetes 修补程序版本开始，可从集群的 Kubernetes 版本的 Amazon EKS 中获取。如果您的容器组（pod）具有较旧的修补程序版本，Amazon EKS 可能会回收容器组，以便将其更新到最新版本。这可以确保您的容器组（pod）配备了最新的安全更新。这样一来，如果存在关键[常见漏洞和风险](https://cve.mitre.org/)（CVE）问题，您可以随时了解最新信息以降低安全风险。
AWS Fargate 操作系统更新后，Amazon EKS 将向您发送通知，其中包含受影响的资源和即将驱逐容器组（pod）的日期。如果提供的日期不便进行驱逐，您可以在通知中于选择发布的驱逐日期之前，手动重启受影响的容器组（pod）。系统将驱逐您在收到通知之前创建的任何容器组（pod）。有关如何手动重启容器组（pod）的更多说明，请参阅 [Kubernetes 文档](https://kubernetes.io/docs/reference/kubectl/generated/kubectl_rollout/kubectl_rollout_restart)。
要限制在回收容器组（pod）时同时停机的容器组数量，您可以设置容器组（pod）中断预算（PDB）。您可以使用 PDB 根据每个应用程序的要求定义最低可用性，同时仍允许进行更新。PDB 的最低可用性必须低于 100%。有关更多信息，请参阅 Kubernetes 文档中的[为应用程序设置干扰预算](https://kubernetes.io/docs/tasks/run-application/configure-pdb/)。
Amazon EKS 使用[驱逐 API](https://kubernetes.io/docs/tasks/administer-cluster/safely-drain-node/#eviction-api) 在遵守您为应用程序设置的 PDB 的同时安全地耗尽容器组（pod）。容器组（pod）被可用区驱逐出来，以最大限度地减少影响。如果驱逐成功，新容器组（pod）将获得最新的补丁，无需进一步操作。
当容器组（pod）的驱逐失败时，Amazon EKS 会向您的账户发送一个事件，其中包含驱逐失败的容器组（pod）的详细信息。您可以在计划的终止时间之前对消息采取行动。具体时间根据补丁的紧迫性而有所不同。时间一到，Amazon EKS 会尝试再次驱逐容器组（pod）。但是，如果驱逐失败，这次不会发送新的事件。如果驱逐再次失败，则会定期删除您现有的容器组（pod），以便新容器组（pod）可以拥有最新的补丁。
以下是在容器组（pod）驱逐失败时收到的示例事件。其中包含有关集群、容器组（pod）名称、容器组（pod）命名空间、Fargate 配置文件和计划终止时间的详细信息。
```
{
"version": "0",
"id": "12345678-90ab-cdef-0123-4567890abcde",
"detail-type": "EKS Fargate Pod Scheduled Termination",
"source": "aws.eks",
"account": "111122223333",
"time": "2021-06-27T12:52:44Z",
"region": "region-code",
"resources": [
"default/my-database-deployment"
],
"detail": {
"clusterName": "my-cluster",
"fargateProfileName": "my-fargate-profile",
"podName": "my-pod-name",
"podNamespace": "default",
"evictErrorMessage": "Cannot evict pod as it would violate the pod's disruption budget",
"scheduledTerminationTime": "2021-06-30T12:52:44.832Z[UTC]"
}
}
```
此外，将多个 PDB 与一个容器组（pod）关联可能会导致驱逐失败事件。此事件将返回以下错误消息。
```
"evictErrorMessage": "This pod has multiple PodDisruptionBudget, which the eviction subresource does not support",
```
您可以基于此事件创建所需的操作。例如，要控制驱逐容器组（pod）的方式，您可以调整容器组（pod）中断预算（PDB）。更具体地说，假设您从指定可用容器组（pod）的目标百分比的 PDB 开始。在升级期间强制终止容器组（pod）之前，您可以将 PDB 调整为不同百分比的容器组（pod）。要接收此事件，您必须在 AWS 账户和集群所属的 AWS 区域中创建 Amazon EventBridge 规则。该规则必须使用以下**自定义模式**。有关更多信息，请参阅《Amazon EventBridge 用户指南》中的[创建对事件作出反应的 Amazon EventBridge 规则](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule.html)。
```
{
"source": ["aws.eks"],
"detail-type": ["EKS Fargate Pod Scheduled Termination"]
}
```
可以为事件设置合适的目标来捕获它。有关可用目标的完整列表，请参阅《Amazon EventBridge 用户指南》中的 [Amazon EventBridge 目标](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-targets.html)。您还可以在 AWS 用户通知中创建通知配置。使用 AWS 管理控制台创建通知时，在**事件规则**下，为 **AWS 服务名称**选择 **Elastic Kubernetes Service（EKS）**，为**事件类型**选择 **EKS Fargate 容器组（pod）计划的终止**。有关更多信息，请参阅《AWS 用户通知用户指南》中的[AWS 用户通知入门](https://docs.aws.amazon.com/notifications/latest/userguide/getting-started.html)。
有关 EKS 容器组（pod）驱逐的常见问题，请参阅 *AWS re:Post* 中的[常见问题解答：Fargate 容器组（pod）驱逐通知](https://repost.aws/knowledge-center/fargate-pod-eviction-notice)。
# 收集 AWS Fargate 应用程序和使用情况指标
您可以收集系统指标和 AWS Fargate 的 CloudWatch 使用量指标。
## 应用程序指标
对于在 Amazon EKS 和 AWS Fargate 上运行的应用程序，您可以使用适用于 OpenTelemetry 的 AWS Distro（ADOT）。ADOT 允许您收集系统指标并将其发送到 CloudWatch Container Insights 控制面板。要开始为在 Fargate 上运行的应用程序使用 ADOT，请参阅 ADOT 文档中的[将 CloudWatch Container Insights 与 AWS Distro for OpenTelemetry 结合使用](https://aws-otel.github.io/docs/getting-started/container-insights)。
## 使用情况指标
您可以使用 CloudWatch 使用情况指标来提供账户资源使用情况的可见性。这些指标可在 CloudWatch 图表和控制面板上直观呈现当前的服务使用情况。
AWS Fargate 用量指标与 AWS 服务配额对应。您可以配置警报，以在用量接近服务配额时向您发出警报。有关 Fargate 服务配额的更多信息，请参阅 [查看和管理 Amazon EKS 和 Fargate 服务配额](service-quotas.md)。
AWS Fargate 在 ` AWS/Usage` 命名空间中发布以下指标。
| 指标 | 说明 |
| --- | --- |
| `ResourceCount` | 您账户中运行的指定资源的总数量。资源由与指标关联的维度定义。 |
以下维度用于优化由 AWS Fargate 发布的使用情况指标。
| 维度 | 描述 |
| --- | --- |
| `Service` | 包含该资源的 AWS 服务的名称。对于 AWS Fargate 用量指标，此维度的值为 `Fargate`。 |
| `Type` | 正在报告的实体的类型。目前，AWS Fargate 用量指标的唯一有效值为 `Resource`。 |
| `Resource` | 正在运行的资源的类型。 目前，AWS Fargate 会返回有关 Fargate 按需使用情况的信息。Fargate 按需使用情况的资源值为 `OnDemand`。 [注意] ==== Fargate 按需使用情况结合了使用 Fargate 的 Amazon EKS Pod、使用 Fargate 启动类型的 Amazon ECS 任务和使用 `FARGATE` 容量提供程序的 Amazon ECS 任务。 ==== |
| `Class` | 所跟踪的资源的类。目前，AWS Fargate 不使用类维度。 |
### 创建 CloudWatch 警报以监控 Fargate 资源使用情况指标
AWS Fargate 提供 CloudWatch 使用情况指标，这些指标与 Fargate 按需资源使用情况的 AWS 服务配额相对应。在 Service Quotas 控制台中，您可以在图表上可视化您的使用情况。还可以配置警报，以在用量接近服务配额时向您发出警报。有关更多信息，请参阅 [收集 AWS Fargate 应用程序和使用情况指标](#monitoring-fargate-usage)。
使用以下步骤根据 Fargate 资源使用情况指标创建 CloudWatch 警报。
1. 访问 https://console.aws.amazon.com/servicequotas/，打开服务配额控制台。
1. 在左侧导航窗格中，选择 **AWS 服务**。
1. 从 **AWS 服务**列表中，搜索并选择 **AWS Fargate**。
1. 在 **Service quotas**（服务配额）列表中，选择要为其创建警报的 Fargate 使用情况配额。
1. 在 Amazon CloudWatch 警报部分中，选择 **Create**（创建）。
1. 对于**警报阈值**，选择要设置为警报值的适用配额值的百分比。
1. 对于**警报名称**，输入警报名称，然后选择**创建**。
# 为集群启动 AWS Fargate 日志记录
Fargate 上的 Amazon EKS 提供了一个基于 Fluent Bit 的内置日志路由器。这意味着您没有明确地将 Fluent Bit 容器作为边车容器运行，但 Amazon 会为您运行该容器。您只需配置日志路由器即可。通过必须满足以下条件的专用 `ConfigMap` 进行配置：
+ 名为 `aws-logging`
+ 在名为 `aws-observability` 的专用命名空间中创建
+ 不能超过 5300 个字符。
一旦您创建了 `ConfigMap`，Fargate 上的 Amazon EKS 会自动检测到它并使用它来配置日志路由器。Fargate 使用 AWS for Fluent Bit 的版本是 Fluent Bit 的一种上游合规发行版，由AWS托管。有关更多信息，请参阅 GitHub 上的 [AWS for Fluent Bit](https://github.com/aws/aws-for-fluent-bit)。
日志路由器允许您使用广泛的AWS服务进行日志分析和存储。您可以将日志从 Fargate 直接流式传输到 Amazon CloudWatch、Amazon OpenSearch Service。您还可以通过 [Amazon Data Firehose](https://aws.amazon.com/kinesis/data-firehose/) 将日志流式传输到 [Amazon S3](https://aws.amazon.com/s3/)、[Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/) 和合作伙伴工具等目标。
+ 现有的 Fargate 配置文件，用于指定您将 Fargate 容器组（pod）部署到的现有 Kubernetes 命名空间。有关更多信息，请参阅 [第 3 步：为集群创建 Fargate 配置文件](fargate-getting-started.md#fargate-gs-create-profile)。
+ 现有的 Fargate 容器组（pod）执行角色。有关更多信息，请参阅 [第 2 步：创建 Fargate 容器组（pod）执行角色](fargate-getting-started.md#fargate-sg-pod-execution-role)。
## 日志路由器配置
**重要**
要成功发布日志，必须允许集群所在的 VPC 对日志目标的网络访问权限。这主要涉及用户为其 VPC 自定义出口规则。有关使用 CloudWatch 的示例，请参阅《Amazon CloudWatch Logs 用户指南》中的 [Using CloudWatch Logs with interface VPC endpoints](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch-logs-and-interface-VPC.html)**。
在以下步骤中，将所有 *example value* 替换为您自己的值。
1. 创建一个名为 `aws-observability` 的专用 Kubernetes 命名空间。
1. 将以下内容保存到计算机上名为 `aws-observability-namespace.yaml` 的文件中。`name` 的值必须为 `aws-observability`，并且 `aws-observability: enabled` 标注是必需的。
```
kind: Namespace
apiVersion: v1
metadata:
name: aws-observability
labels:
aws-observability: enabled
```
1. 创建命名空间。
```
kubectl apply -f aws-observability-namespace.yaml
```
1. 创建带有 `Fluent Conf` 数据值的 `ConfigMap`，以将容器日志发送到某个目标。Fluent Conf 为 Fluent Bit，是一种快速轻量级日志处理器配置语言，用于将容器日志路由到您选择的日志目标。有关更多信息，请参阅 Fluent Bit 文档中的[配置文件](https://docs.fluentbit.io/manual/administration/configuring-fluent-bit/classic-mode/configuration-file)。
**重要**
典型 `Fluent Conf` 中包含的主要部分为 `Service`、`Input`、`Filter` 和 `Output`。但是，Fargate 日志路由器仅接受：
`Filter` 和 `Output` 部分。
`Parser` 部分。
如果您提供任何其他部分，将被拒绝。
Fargate 日志路由器管理 `Service` 和 `Input` 部分。它包含以下 `Input` 部分，无法修改，并且您的 `ConfigMap` 也不需要该部分。但是，您可以从中获取见解，例如内存缓冲区限制和应用于日志的标签。
```
[INPUT]
Name tail
Buffer_Max_Size 66KB
DB /var/log/flb_kube.db
Mem_Buf_Limit 45MB
Path /var/log/containers/*.log
Read_From_Head On
Refresh_Interval 10
Rotate_Wait 30
Skip_Long_Lines On
Tag kube.*
```
在创建 `ConfigMap` 时，请考虑 Fargate 用于验证字段的以下规则：
+ `[FILTER]`、`[OUTPUT]` 和 `[PARSER]` 应该在每个相应的键下指定。例如，`[FILTER]` 必须在 `filters.conf` 下。在 `filters.conf` 下可以有一个或多个 `[FILTER]`。`[OUTPUT]` 和 `[PARSER]` 部分也应在其相应的键下。通过指定多个 `[OUTPUT]` 部分，您可以同时将日志路由到不同的目标。
+ Fargate 会验证每个部分所需的键。`Name` 和 `match` 是每个 `[FILTER]` 和 `[OUTPUT]` 所必需的。`Name` 和 `format` 是每个 `[PARSER]` 所必需的。键不区分大小写。
+ 在 `ConfigMap` 中不允许使用环境变量（例如 `${ENV_VAR}`）。
+ 对于每个 `filters.conf`、`output.conf` 和 `parsers.conf` 中的指令或键值对，缩进必须是相同的。键值对的缩进必须多于指令。
+ Fargate 根据以下受支持的筛选条件进行验证：`grep`、`parser`、`record_modifier`、`rewrite_tag`、`throttle`、`nest`、`modify` 和 `kubernetes`。
+ Fargate 根据以下受支持的输出进行验证：`es`、`firehose`、`kinesis_firehose`、`cloudwatch`、`cloudwatch_logs` 和 `kinesis`。
+ `ConfigMap` 中必须至少提供一个受支持的 `Output` 插件才能启用日志记录。不需要 `Filter` 和 `Parser` 即可启用日志记录。
您还可以使用所需的配置在 Amazon EC2 上运行 Fluent Bit，以对验证过程中出现的任何问题进行故障排除。使用以下示例之一创建您的 `ConfigMap`。
**重要**
Amazon EKS Fargate 日志记录不支持 `ConfigMap` 的动态配置。对 `ConfigMap` 所做的任何更改都只会应用于新容器组（pod）。不会将更改应用于现有容器组（pod）。
使用所需日志目标的示例创建 `ConfigMap`。
**注意**
您也可以将 Amazon Kinesis Data Streams 用作您的日志目的地。如果您使用 Kinesis Data Streams，则请确保容器组（pod）执行角色已被授予 `kinesis:PutRecords` 权限。有关更多信息，请参阅《Fluent Bit：官方手册》**中的 Amazon Kinesis Data Streams [权限](https://docs.fluentbit.io/manual/pipeline/outputs/kinesis#permissions)。
**Example**
------
#### [ CloudWatch ]
使用 CloudWatch 视时，您有两个输出选项：
+ [用 C 语言编写的输出插件](https://docs.fluentbit.io/manual/v/1.5/pipeline/outputs/cloudwatch)
+ [用 Golang 编写的输出插件](https://github.com/aws/amazon-cloudwatch-logs-for-fluent-bit)
以下示例为您展示了如何使用 `cloudwatch_logs` 插件将日志发送到 CloudWatch。
1. 将以下内容保存到名为 `aws-logging-cloudwatch-configmap.yaml` 的文件中。将 *region-code* 替换为您的集群所在的 AWS 区域。`[OUTPUT]` 下的参数是必需的。
```
kind: ConfigMap
apiVersion: v1
metadata:
name: aws-logging
namespace: aws-observability
data:
flb_log_cw: "false" # Set to true to ship Fluent Bit process logs to CloudWatch.
filters.conf: |
[FILTER]
Name parser
Match *
Key_name log
Parser crio
[FILTER]
Name kubernetes
Match kube.*
Merge_Log On
Keep_Log Off
Buffer_Size 0
Kube_Meta_Cache_TTL 300s
output.conf: |
[OUTPUT]
Name cloudwatch_logs
Match kube.*
region region-code
log_group_name my-logs
log_stream_prefix from-fluent-bit-
log_retention_days 60
auto_create_group true
parsers.conf: |
[PARSER]
Name crio
Format Regex
Regex ^(?