kOps + Karpenter 集成实践：实现 K8s 集群的动态扩展

01/引言

对于实行多云或混合云策略的企业来说，kOps 是一个理想的 Kubernetes 集群管理工具。它通过同一的设置文件（YAML 或 JSON）实现跨多个云环境（如 AWS、GCP、Azure）或本地数据中心的集群管理。
kOps 提供了丰富的自定义选项，包括控制面节点和工作节点的操作体系、网络插件（如 Calico、Cilium）、存储解决方案等，满足企业在复杂场景下的灵活摆设需求。
对于希望进一步优化 Kubernetes 资源服从的企业，开源的 Kubernetes 集群自动扩展工具 Karpenter 则是一个强盛的选择。
Karpenter 能根据 Pod 的资源需求动态设置节点，支持多种实例类型，并可以智能调理 AWS Spot 实例，大幅降低运行成本。其无节点池的设计，使得资源调理更加灵活，特殊适合需要高弹性和高性价比的场景。
然而，kOps 与 Karpenter 的官方集成已克制更新，仅支持较旧的版本。这意味着在最新版本的 kOps 上，用户需要通过手动设置的方式实现与 Karpenter 的集成。
为了解决这一问题，本文将介绍如何在 kOps 摆设的 AWS Kubernetes 集群上摆设 Karpenter，通过具体步骤和技术细节，资助用户在现有架构中实现动态扩展本领，同时最大化利用 Karpenter 的优势，提升集群的弹性与资源利用服从。
为什么选择 kOps

kOps 是一个开源项目，可以创建、销毁、升级和维护一个高可用的生产级 Kubernetes 集群。该项目的开发者将其形貌为“为集群打造的 Kubectl”。
目前，kOps 主要用于摆设 AWS 和 GCE Kubernetes 集群，对 Azure 的支持处于 alpha 阶段。以下是这款工具的主要特性：

• 自动设置高可用 Kubernetes 集群
  
• 支持集群滚动更新
  
• 在命令行中自动补齐命令
  
• 天生 Terraform 设置
  
• 以状态同步模子为底子，实现 dry-runs 和自动幂等性（idempotency）
  
• 创建实例组以支持异构集群
  

相较其他产物 ，kOps更灵活。通过接纳 kOps，企业可以获得 K8s 集群设置的较大控制权，并且能够自定义 K8s 环境以满足特定需求。还能根据自己的偏好设置云环境，并可以完全访问 master 节点以举行微调和故障清除。
别的，对于小型或临时集群，kOps 每每比其他选择更具成本效益。 作为一种开源和免费的解决方案，企业只需付出底层底子设施的费用。
为什么选择 Karpenter

Karpenter 是当前业界最流行的开源 Kubernetes 集群自动扩展工具之一，最初由 AWS 开源，目前已捐献给 CNCF。当前，Karpenter 支持 AWS、Azure及阿里云，针对 GKE 的支持正在紧锣密鼓地开发中。
与传统的自动扩缩不同，Karpenter 能够动态地在及时环境中为集群工作负载提供所需的计算资源。它通过观察未调理 pod 的资源哀求总量，智能决议并启动精准匹配需求的新节点。
Karpenter 项目地址：
https://github.com/kubernetes-sigs/karpenter
02/前期准备

• 具有 IAM 权限的 AWS 账户, 以创建 EC2 Instance.
  
• 安装并设置 AWS CLI.
  
• 安装 Kubernetes CLI (kubectl)
  
• 安装 Helm（Kubernetes 的包管理工具）
  
• 安装 kOps
  

03/通过 kOps 创建集群

设置集群

在创建集群前，您需要设置集群所在的 Region，以及集群的名称。为了简化摆设流程，我们会创建基于 Gossip DNS 的集群。
https://kops.sigs.k8s.io/gossip/
如果您希望利用自己的域名创建集群，您可以参阅下文：
https://kops.sigs.k8s.io/getting_started/aws/#configure-dns

1. export DEPLOY_REGION="us-west-1"
2. export CLUSTER_NAME="demo1"
3. export DEPLOY_ZONE="us-west-1a"
5. export NAME=${CLUSTER_NAME}.k8s.loca

复制代码

创建 kOps IAM User

为了在 AWS 中创建集群，我们将利用 AWS CLI 为 kOps 创建一个专用的 IAM 用户 kops。

1. aws iam create-group --group-name kops
3. aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonEC2FullAccess --group-name kops
4. aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonRoute53FullAccess --group-name kops
5. aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess --group-name kops
6. aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/IAMFullAccess --group-name kops
7. aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonVPCFullAccess --group-name kops
8. aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonSQSFullAccess --group-name kops
9. aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonEventBridgeFullAccess --group-name kops
11. aws iam create-user --user-name kops
12. aws iam add-user-to-group --user-name kops --group-name kops
13. aws iam create-access-key --user-name kops

复制代码

导出 AWS AccessKey/SecretKey

我们需要利用 AccessKey 和 SecretKey，需要将其导出。为了简化摆设，本教程中没有切换用户，您可以手动通过 aws configure 切换到 kops 用户。

1. export AWS_ACCESS_KEY_ID=$(aws configure get aws_access_key_id)
2. export AWS_SECRET_ACCESS_KEY=$(aws configure get aws_secret_access_key)

复制代码

创建集群状态存储 Bucket

为了保存集群的状态信息以及形貌集群的设置信息，我们需要创建一个专用的 S3 存储桶供 kOps 利用。这个存储桶将成为保存集群设置的唯一可信来源。

1. export KOPS_STATE_STORE_NAME=kops-state-store-${CLUSTER_NAME}
2. export KOPS_OIDC_STORE_NAME=kops-oidc-store-${CLUSTER_NAME}
3. export KOPS_STATE_STORE=s3://${KOPS_STATE_STORE_NAME}
5. aws s3api create-bucket \
6.     --bucket ${KOPS_STATE_STORE_NAME} \
7.     --region ${DEPLOY_REGION} \
8.     --create-bucket-configuration LocationConstraint=${DEPLOY_REGION}
10. aws s3api create-bucket \
11.     --bucket ${KOPS_OIDC_STORE_NAME} \
12.     --region ${DEPLOY_REGION} \
13.     --create-bucket-configuration LocationConstraint=${DEPLOY_REGION} \
14.     --object-ownership BucketOwnerPreferred
15. aws s3api put-public-access-block \
16.     --bucket ${KOPS_OIDC_STORE_NAME} \
17.     --public-access-block-configuration BlockPublicAcls=false,IgnorePublicAcls=false,BlockPublicPolicy=false,RestrictPublicBuckets=false
18. aws s3api put-bucket-acl \
19.     --bucket ${KOPS_OIDC_STORE_NAME} \
20.     --acl public-read

复制代码

创建集群

以下是创建集群的命令。我们将利用最基本的示例，以下命令将天生集群设置，但不会开始构建它。

1. kops create cluster \
2.     --name=${NAME} \
3.     --cloud=aws \
4.     --node-count=1 \
5.     --control-plane-count=1 \
6.     --zones=${DEPLOY_ZONE} \
7.     --discovery-store=s3://${KOPS_OIDC_STORE_NAME}/${NAME}/discovery

复制代码

如今我们进入现实构建集群的末了一步，这需要一段时间。完成后，您将需要等待更长时间，直到启动的实例完成下载 Kubernetes 组件并到达“停当”状态。

1. kops update cluster --name ${NAME} --yes --admin
2. kops export kubeconfig
3. # 等待集群状态 Ready
4. kops validate cluster --wait 10m --name ${NAME}

复制代码

04/摆设 Karpenter

准备须要的内容

我们需要这些环境变量来摆设 Karpenter 和创建 NodePool/NodeClass。
通过 AWS CLI 获取 OIDC Provider 的信息、Issuer 地址和 AWS 账户 ID，确保后续摆设正常举行。

1. export OIDC_PROVIDER_ID=$(aws iam list-open-id-connect-providers \
2.     --query "OpenIDConnectProviderList[?contains(Arn, '${NAME}')].Arn" \
3.     --output text | awk -F'/' '{print $NF}')
4. export OIDC_ISSUER=${KOPS_OIDC_STORE_NAME}.s3.${DEPLOY_REGION}.amazonaws.com/${NAME}/discovery/${NAME}
6. export AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query 'Account' \
7.     --output text)
9. export AWS_INSTANCE_PROFILE_NAME=nodes.${NAME}
10. export KARPENTER_ROLE_NAME=karpenter.kube-system.sa.${NAME}
11. export CLUSTER_ENDPOINT=$(kubectl config view -o jsonpath="{.clusters[?(@.name=='${NAME}')].cluster.server}")
13. # 储存后续需要的临时文件
14. export TMP_DIR=$(mktemp -d)

复制代码

创建 Karpenter IAM Role

我们需要为 Karpenter 创建和设置专用的 IAM Role 和 Policy，答应 Karpenter 通过 OIDC 身份验证该角色，并为该角色添加须要的权限，使其能够动态创建、管理和删除AWS资源（如EC2实例），以满足 Kubernetes 工作负载的需求。

1. aws iam create-role \
2.     --role-name ${KARPENTER_ROLE_NAME} \
3.     --assume-role-policy-document "{
4.         "Version": "2012-10-17",
5.         "Statement": [
6.             {
7.                 "Effect": "Allow",
8.                 "Principal": {
9.                     "Federated": "arn:aws:iam::${AWS_ACCOUNT_ID}:oidc-provider/oidc.eks.${DEPLOY_REGION}.amazonaws.com/id/${OIDC_PROVIDER_ID}"
10.                 },
11.                 "Action": "sts:AssumeRoleWithWebIdentity",
12.                 "Condition": {
13.                     "StringEquals": {
14.                         "oidc.eks.${DEPLOY_REGION}.amazonaws.com/id/${OIDC_PROVIDER_ID}:sub": "system:serviceaccount:kube-system:karpenter"
15.                     }
16.                 }
17.             }
18.         ]
19.     }"
21. aws iam create-role \
22.     --role-name ${KARPENTER_ROLE_NAME} \
23.     --assume-role-policy-document "{
24.         "Version": "2012-10-17",
25.         "Statement": [
26.             {
27.                 "Effect": "Allow",
28.                 "Principal": {
29.                     "Federated": "arn:aws:iam::${AWS_ACCOUNT_ID}:oidc-provider/${KOPS_OIDC_STORE_NAME}.s3.us-west-1.amazonaws.com/${NAME}/discovery/${NAME}"
30.                 },
31.                 "Action": "sts:AssumeRoleWithWebIdentity",
32.                 "Condition": {
33.                     "StringEquals": {
34.                         "${OIDC_ISSUER}:sub": "system:serviceaccount:kube-system:karpenter"
35.                     }
36.                 }
37.             }
38.         ]
39.     }"
41. aws iam put-role-policy \
42.     --role-name ${KARPENTER_ROLE_NAME} \
43.     --policy-name InlineKarpenterPolicy \
44.     --policy-document '{
45.         "Version": "2012-10-17",
46.         "Statement": [
47.             {
48.                 "Effect": "Allow",
49.                 "Action": [
50.                     "ec2:CreateFleet",
51.                     "ec2:CreateTags",
52.                     "ec2:DescribeAvailabilityZones",
53.                     "ec2:DescribeImages",
54.                     "ec2:DescribeInstanceTypeOfferings",
55.                     "ec2:DescribeInstanceTypes",
56.                     "ec2:DescribeInstances",
57.                     "ec2:DescribeLaunchTemplates",
58.                     "ec2:DescribeSecurityGroups",
59.                     "ec2:DescribeSpotPriceHistory",
60.                     "ec2:DescribeSubnets",
61.                     "ec2:RunInstances",
62.                     "ec2:TerminateInstances",
63.                     "iam:PassRole",
64.                     "pricing:GetProducts",
65.                     "ssm:GetParameter",
66.                     "ec2:CreateLaunchTemplate",
67.                     "ec2:DeleteLaunchTemplate",
68.                     "sts:AssumeRoleWithWebIdentity"
69.                 ],
70.                 "Resource": "*"
71.             }
72.         ]
73.     }'

复制代码

摆设 Karpenter

起首，我们需要设置一些额外的内容从而限定 Karpenter 仅在控制面运行，并且绑定和传入我们之前设置的内容，如 clusterEndpoint / clusterName 以及最重要的 IAM Role。

1. cat <<EOF > ${TMP_DIR}/values.yaml
2. serviceAccount:
3.   annotations:
4.     "eks.amazonaws.com/role-arn": "arn:aws:iam::${AWS_ACCOUNT_ID}:role/${KARPENTER_ROLE_NAME}"
6. replicas: 1
8. affinity:
9.   nodeAffinity:
10.     requiredDuringSchedulingIgnoredDuringExecution:
11.       nodeSelectorTerms:
12.         - matchExpressions:
13.           - key: node-role.kubernetes.io/control-plane
14.             operator: Exists
15.   podAntiAffinity:
16.     requiredDuringSchedulingIgnoredDuringExecution:
17.       - topologyKey: "kubernetes.io/hostname"
19. tolerations:
20.   - key: CriticalAddonsOnly
21.     operator: Exists
22.   - key: node-role.kubernetes.io/master
23.     operator: Exists
24.   - key: node-role.kubernetes.io/control-plane
25.     operator: Exists
26.   - effect: NoExecute
27.     key: node.kubernetes.io/not-ready
28.     operator: Exists
29.     tolerationSeconds: 300
30.   - effect: NoExecute
31.     key: node.kubernetes.io/unreachable
32.     operator: Exists
33.     tolerationSeconds: 300
35. extraVolumes:
36.   - name: token-amazonaws-com
37.     projected:
38.       defaultMode: 420
39.       sources:
40.         - serviceAccountToken:
41.             audience: amazonaws.com
42.             expirationSeconds: 86400
43.             path: token
45. controller:
46.   containerName: controller
47.   image:
48.     repository: docker.io/vacanttt/kops-karpenter-provider-aws
49.     tag: latest
50.     digest: sha256:24ef24de6b5565df91539b7782f3ca0e4f899001020f4c528a910cefb3b1c031
51.   env:
52.     - name: AWS_REGION
53.       value: us-west-1
54.     - name: AWS_DEFAULT_REGION
55.       value: us-west-1
56.     - name: AWS_ROLE_ARN
57.       value: arn:aws:iam::${AWS_ACCOUNT_ID}:role/${KARPENTER_ROLE_NAME}
58.     - name: AWS_WEB_IDENTITY_TOKEN_FILE
59.       value: /var/run/secrets/amazonaws.com/token
60.   extraVolumeMounts:
61.     - mountPath: /var/run/secrets/amazonaws.com/
62.       name: token-amazonaws-com
63.       readOnly: true
65. logLevel: debug
67. settings:
68.   clusterName: ${NAME}
69.   clusterEndpoint: ${CLUSTER_ENDPOINT}
70.   featureGates:
71.     spotToSpotConsolidation: true
72.     nodeRepair: false
73. EOF

复制代码

通过 Helm 摆设 Karpenter 到 kube-system Namespace。

1. export KARPENTER_NAMESPACE="kube-system"
3. helm upgrade --install karpenter \
4.   oci://public.ecr.aws/karpenter/karpenter \
5.   --namespace "${KARPENTER_NAMESPACE}" --create-namespace \
6.   --wait -f $TMP_DIR/values.yaml

复制代码

创建 Nodepool/NodeClass

我们需要获取 kOps 管理的 LaunchTemplate，并且利用它的 userData 来作为Karpenter EC2NodeClass 的 userData，从而注册新节点到我们的集群中。

1. export NODE_INSTANCE_GROUP=$(kops get instancegroups --name ${NAME} | grep Node | awk '{print $1}')
2. export NODE_LAUNCH_TEMPLATE_NAME=${NODE_INSTANCE_GROUP}.${NAME}
4. export USER_DATA=$(aws ec2 describe-launch-templates --region ${DEPLOY_REGION} --filters Name=launch-template-name,Values=${NODE_LAUNCH_TEMPLATE_NAME} \
5.     --query "LaunchTemplates[].LaunchTemplateId" --output text | \
6.     xargs -I {} aws ec2 describe-launch-template-versions --launch-template-id {} --region ${DEPLOY_REGION} \
7.     --query "LaunchTemplateVersions[].LaunchTemplateData.UserData" --output text | base64 --decode)

复制代码

将 NodeClass 以及 NodePool 暂存，您可以在应用前查抄或是设置其他需要的内容。

1. cat <<EOF > ${TMP_DIR}/nodeclass.yaml
2. apiVersion: karpenter.k8s.aws/v1
3. kind: EC2NodeClass
4. metadata:
5.   name: default
6. spec:
7.   associatePublicIPAddress: true
8.   amiFamily: AL2
9.   tags:
10.     kops.k8s.io/instancegroup: ${NODE_INSTANCE_GROUP}
11.     KubernetesCluster: ${NAME}
12.     k8s.io/role/node: "1"
13.     aws-node-termination-handler/managed: ""
14.     k8s.io/cluster-autoscaler/node-template/label/node-role.kubernetes.io/node: ""
15.   subnetSelectorTerms:
16.     - tags:
17.         KubernetesCluster: ${NAME}
18.   securityGroupSelectorTerms:
19.     - tags:
20.         Name: nodes.${NAME}
21.         KubernetesCluster: ${NAME}
22.   amiSelectorTerms:
23.     - name: "ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-20241211"
24.   instanceProfile: nodes.${NAME}
25.   userData: |
26. $(echo "$USER_DATA" | sed 's/^/    /')
27. EOF
29. cat <<EOF > ${TMP_DIR}/nodepool.yaml
30. apiVersion: karpenter.sh/v1
31. kind: NodePool
32. metadata:
33.   name: default
34. spec:
35.   template:
36.     spec:
37.       requirements:
38.         - key: kubernetes.io/arch
39.           operator: In
40.           values: ["amd64"]
41.         - key: kubernetes.io/os
42.           operator: In
43.           values: ["linux"]
44.         - key: karpenter.sh/capacity-type
45.           operator: In
46.           values: ["on-demand", "spot"]
47.       nodeClassRef:
48.         group: karpenter.k8s.aws
49.         kind: EC2NodeClass
50.         name: default
51.       expireAfter: 720h
52.   limits:
53.     cpu: 4
54.   disruption:
55.     consolidationPolicy: WhenEmptyOrUnderutilized
56.     consolidateAfter: 1m
57. EOF

复制代码

应用 NodeClass 和 NodePool 到集群中。

1. kubectl apply -f ${TMP_DIR}/nodeclass.yaml
2. kubectl apply -f ${TMP_DIR}/nodepool.yaml

复制代码

05/后续

创建 Workload 测试自动扩缩容

创建一个 4 Replica，并且哀求一定资源的 Workload。在预期的环境下，会有 2 个 Replica 由于资源不敷而 Pending。

1. cat <<EOF > ${TMP_DIR}/workload.yaml
2. apiVersion: apps/v1
3. kind: Deployment
4. metadata:
5.   name: workload
6.   namespace: default
7.   labels:
8.     app: workload
9. spec:
10.   replicas: 4
11.   selector:
12.     matchLabels:
13.       app: workload
14.   template:
15.     metadata:
16.       labels:
17.         app: workload
18.     spec:
19.       containers:
20.         - name: pause
21.           image: public.ecr.aws/eks-distro/kubernetes/pause:3.7
22.           resources:
23.             requests:
24.               cpu: "550m"
25.               memory: "128Mi"
26. EOF

复制代码

1. kubectl apply -f ${TMP_DIR}/workload.yaml

复制代码

您可以查抄是否有 NodeClaim 被创建，在 NodeClaim 被创建约 70 秒后，新节点将注册到集群中。

删除集群

在 AWS 中运行 Kubernetes 集群显然需要连续投入成本，因此如果您完成实验后可能需要删除集群。
   请留意，此命令具有粉碎性，运行后将删除您的集群及其包含的所有内容！
  当您确定要删除集群时，请输入带有--yes标记的删除命令。

1. kops delete cluster --name ${NAME} --yes

复制代码

kOps + Karpenter 的优势和局限

kOps 和 Karpenter 的联合为 Kubernetes 集群的自动化管理带来了强盛的功能，但同时也存在一些局限性。
在优势方面，Karpenter 能够根据 Pod 的现实需求动态设置节点，这不但提高了资源利用率，还能快速响应工作负载的厘革，制止资源浪费或不敷。
同时，支持多样化的实例类型，用户可以根据不同的利用场景选择最佳的实例类型，从而进一步优化性能和成本。
然而，这种组合也有局限性。
起首，由于无法利用 EKS 的 bootstrap.sh 脚本，Kubelet 的设置受限于 kOps 的控制，这意味着无法在 NodeClass 中自定义与 Kubelet 干系的参数。
其次，集群的控制面节点必须利用 ASG（自动扩展组）而非 Karpenter，这在一定水平上限定了对控制面节点的弹性管理。
别的，Karpenter 的正常运行需要指定至少一个 InstanceGroup，未设置时节点将无法成功注册到集群，这增长了设置的复杂性。
只管云云，kOps 和 Karpenter 的联合仍旧是一个强有力的工具组合，适合需要动态扩展和多实例支持的场景，但在实行时需要留意这些局限性并做好干系规划。
推荐阅读

CA 不敷用了？Azure 推 Karpenter + Spot，让 AKS 便宜 80%！
逐层优化！网安独角兽如何在 AWS 上削减 60% 的 K8s 成本
新手攻略！手把手教你安装设置 Karpenter

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。