Wie installiere ich Karpenter in meinem Amazon-EKS-Cluster?

Kurzbeschreibung

Karpenter ist ein Open-Source-Projekt zur Bereitstellung von Knoten, das für Kubernetes entwickelt wurde. Das Hinzufügen von Karpenter zu einem Kubernetes-Cluster kann die Effizienz und die Kosten der Ausführung von Workloads auf diesem Cluster erheblich verbessern. Weitere Informationen finden Sie in der Karpenter-Dokumentation.

Die folgenden Schritte zeigen Ihnen, wie Sie Karpenter in einem Amazon-EKS-Cluster bereitstellen.

Lösung

Voraussetzungen

Bevor Sie beginnen, sollten Sie Folgendes durchführen:

• Installieren Sie Helm-Client 3.11.0 oder höher. Weitere Informationen zu den Installationsverfahren finden Sie in den Helm Docs.
• Installieren Sie eksctl. Weitere Informationen zu den Installationsverfahren finden Sie im eksctl-Benutzerhandbuch.
• Erstellen Sie diese Umgebungsvariablen:

export CLUSTER_NAME=your_cluster_name
    
export KARPENTER_VERSION=your_required_version
    
export CLUSTER_ENDPOINT="$(aws eks describe-cluster --name ${CLUSTER_NAME} --query "cluster.endpoint" --output text)"
    
export AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query 'Account' --output text)

Hinweis: Geben Sie Ihren EKS-Clusternamen unter your_cluster_name und Ihre erforderliche Karpenter-Versionsnummer für your_required_version ein. Suchen Sie in karpenter/releases nach Karpenter-Versionen.

IAM-Rollen für Karpenter und den Karpenter Controller erstellen

1.    Erstellen Sie die Rollen für AWS Identity and Access Management (IAM) für die mit Karpenter bereitgestellten Knoten. Die Karpenter-Knoten-Rolle (KarpenterInstanceNodeRole) ähnelt der IAM-Rolle von Amazon-EKS-Knoten. Unter Amazon EKS Node IAM role finden Sie Informationen zum Erstellen der KapenterInstanceNodeRole mithilfe der AWS-Managementkonsole oder dem AWS Command Line Interface (AWS CLI).

Hinweis: Wenn beim Ausführen der CLI-Befehle Fehler auftreten, stellen Sie sicher, dass Sie die neueste Version von AWS CLI verwenden. Siehe Behebung von AWS-CLI-Fehlern – AWS Command Line Interface.

2.    Fügen Sie diese IAM-Richtlinien zu der von Ihnen erstellten IAM KarpenterInstanceNodeRole hinzu.

AmazonEKSWorkerNodePolicy
AmazonEKS_CNI_Policy
AmazonEC2ContainerRegistryReadOnly
AmazonSSMManagedInstanceCore

Konfigurieren Sie die IAM-Rolle für den Karpenter Controller

Erstellen Sie eine IAM-Rolle für KarpenterControllerRole. Der Karpenter Controller verwendet die IAM-Rollen für Service-Konten (IRSA).

1.    Erstellen Sie ein controller-policy.json-Dokument mit den folgenden Berechtigungen:

echo '{
    "Statement": [
        {
            "Action": [
                "ssm:GetParameter",
                "iam:PassRole",
                "ec2:DescribeImages",
                "ec2:RunInstances",
                "ec2:DescribeSubnets",
                "ec2:DescribeSecurityGroups",
                "ec2:DescribeLaunchTemplates",
                "ec2:DescribeInstances",
                "ec2:DescribeInstanceTypes",
                "ec2:DescribeInstanceTypeOfferings",
                "ec2:DescribeAvailabilityZones",
                "ec2:DeleteLaunchTemplate",
                "ec2:CreateTags",
                "ec2:CreateLaunchTemplate",
                "ec2:CreateFleet",
                "ec2:DescribeSpotPriceHistory",
                "pricing:GetProducts"
            ],
            "Effect": "Allow",
            "Resource": "*",
            "Sid": "Karpenter"
        },
        {
            "Action": "ec2:TerminateInstances",
            "Condition": {
                "StringLike": {
                    "ec2:ResourceTag/Name": "*karpenter*"
                }
            },
            "Effect": "Allow",
            "Resource": "*",
            "Sid": "ConditionalEC2Termination"
        }
    ],
    "Version": "2012-10-17"
}' > controller-policy.json

2.    Erstellen Sie eine IAM-Richtlinie mit diesem controller-policy.json-Dokument.

aws iam create-policy --policy-name KarpenterControllerPolicy-${CLUSTER_NAME} --policy-document file://controller-policy.json

3.    Erstellen Sie mit diesem eksctl-Befehl einen IAM-OIDC-Identitätsanbieter für Ihren Cluster

eksctl utils associate-iam-oidc-provider --cluster ${CLUSTER_NAME} --approve

Hinweis: Stellen Sie sicher, dass Ihre eksctl-Version 0.32.0 oder höher ist.

4.    Erstellen Sie die IAM-Rolle für Karpenter Controller mit dem Befehl eksctl. Ordnen Sie das Kubernetes-Service-Konto und die IAM-Rolle mithilfe von IRSA zu.

eksctl create iamserviceaccount \
  --cluster "${CLUSTER_NAME}" --name karpenter --namespace karpenter \
  --role-name "$KarpenterControllerRole-${CLUSTER_NAME}" \
  --attach-policy-arn "arn:aws:iam::${AWS_ACCOUNT_ID}:policy/KarpenterControllerPolicy-${CLUSTER_NAME}" \
  --role-only \
  --approve

Tags zu Subnetzen und Sicherheitsgruppen hinzufügen

1.    Fügen Sie den Subnetzen der Knotengruppe Tags hinzu, damit Karpenter die zu verwendenden Subnetze erkennt.

for NODEGROUP in $(aws eks list-nodegroups --cluster-name ${CLUSTER_NAME} \
    --query 'nodegroups' --output text); do aws ec2 create-tags \
        --tags "Key=karpenter.sh/discovery,Value=${CLUSTER_NAME}" \
        --resources $(aws eks describe-nodegroup --cluster-name ${CLUSTER_NAME} \
        --nodegroup-name $NODEGROUP --query 'nodegroup.subnets' --output text )
done

2.    Tags zu Sicherheitsgruppen hinzufügen.

Hinweis: Die folgenden Befehle fügen nur den Sicherheitsgruppen der ersten Knotengruppe Tags hinzu. Wenn Sie mehrere Knotengruppen oder mehrere Sicherheitsgruppen haben, müssen Sie die Sicherheitsgruppe festlegen, die Karpenter verwenden wird.

NODEGROUP=$(aws eks list-nodegroups --cluster-name ${CLUSTER_NAME} \
    --query 'nodegroups[0]' --output text)
 
LAUNCH_TEMPLATE=$(aws eks describe-nodegroup --cluster-name ${CLUSTER_NAME} \
    --nodegroup-name ${NODEGROUP} --query 'nodegroup.launchTemplate.{id:id,version:version}' \
    --output text | tr -s "\t" ",")
 
# If your EKS setup is configured to use only Cluster security group, then please execute -
 
SECURITY_GROUPS=$(aws eks describe-cluster \
    --name ${CLUSTER_NAME} --query cluster.resourcesVpcConfig.clusterSecurityGroupId | tr -d '"')
 
# If your setup uses the security groups in the Launch template of a managed node group, then :
 
SECURITY_GROUPS=$(aws ec2 describe-launch-template-versions \
    --launch-template-id ${LAUNCH_TEMPLATE%,*} --versions ${LAUNCH_TEMPLATE#*,} \
    --query 'LaunchTemplateVersions[0].LaunchTemplateData.[NetworkInterfaces[0].Groups||SecurityGroupIds]' \
    --output text)
 
aws ec2 create-tags \
    --tags "Key=karpenter.sh/discovery,Value=${CLUSTER_NAME}" \
    --resources ${SECURITY_GROUPS}

aws-auth ConfigMap aktualisieren

1.    Aktualisieren Sie die aws-auth-ConfigMap im Cluster, damit die Knoten, die die IAM-Rolle KarpenterInstanceNodeRole verwenden, dem Cluster beitreten können. Folgenden Befehl ausführen:

kubectl edit configmap aws-auth -n kube-system

2.    Fügen Sie MapRoles einen Abschnitt hinzu, der diesem Beispiel ähnelt:

Hinweis: Ersetzen Sie die Variable ${AWS_ACCOUNT_ID} durch Ihr Konto, aber ersetzen Sie nicht {{EC2PrivateDNSName}}.

- groups:
  - system:bootstrappers
  - system:nodes
  rolearn: arn:aws:iam::${AWS_ACCOUNT_ID}:role/KarpenterInstanceNodeRole
  username: system:node:{{EC2PrivateDNSName}}

Die vollständige aws-auth-ConfigMap hat jetzt zwei Gruppen: eine für Ihre Karpenter-Knotenrolle und eine für Ihre bestehende Knotengruppe.

Karpenter bereitstellen

1.    Überprüfen Sie die Version von Karpenter, die Sie bereitstellen möchten, mit diesem Befehl:

echo $KARPENTER_VERSION

Wenn Sie keine Ausgabe oder eine andere Version als gewünscht sehen, führen Sie Folgendes aus:

export KARPENTER_VERSION=your_required_version

Hinweis: Ersetzen Sie in diesem Beispiel your_required_version durch die gewünschte Versionsnummer. Unter aws/karpenter finden Sie die Karpenter-Versionen auf der GitHub-Website.

2.    Generieren Sie eine vollständige Yaml-Datei für die Karpenter-Bereitstellung aus der Helm-Chart. Bevor Sie beginnen, stellen Sie sicher, dass die Helm-Client-Version v3.11.0 oder höher ist.

helm template karpenter oci://public.ecr.aws/karpenter/karpenter --version ${KARPENTER_VERSION} --namespace karpenter \
    --set settings.aws.defaultInstanceProfile=KarpenterInstanceProfile \
    --set settings.aws.clusterEndpoint="${CLUSTER_ENDPOINT}" \
    --set settings.aws.clusterName=${CLUSTER_NAME} \
    --set serviceAccount.annotations."eks\.amazonaws\.com/role-arn"="arn:aws:iam::${AWS_ACCOUNT_ID}:role/KarpenterControllerRole-${CLUSTER_NAME}" > karpenter.yaml

3.    Stellen Sie die Affinität so ein, dass Karpenter auf einem der vorhandenen Knotengruppenknoten läuft. Suchen Sie die Bereitstellungs-Affinitätsregel und ändern Sie sie dann in der Datei karpenter.yaml, die Sie gerade erstellt haben:

affinity:
  nodeAffinity:
    requiredDuringSchedulingIgnoredDuringExecution:
      nodeSelectorTerms:
      - matchExpressions:
        - key: karpenter.sh/provisioner-name
          operator: DoesNotExist
      - matchExpressions:
        - key: eks.amazonaws.com/nodegroup
          operator: In
          values:
          - ${NODEGROUP}

Karpenter-Namespace erstellen

Erstellen des erforderlichen Karpenter Namespaces und der Bereitsteller-CRD. Stellen Sie dann die restlichen Ressourcen von Karpenter bereit.

kubectl create namespace karpenter
kubectl create -f https://raw.githubusercontent.com/aws/karpenter/${KARPENTER_VERSION}/pkg/apis/crds/karpenter.sh_provisioners.yaml
kubectl create -f https://raw.githubusercontent.com/aws/karpenter/${KARPENTER_VERSION}/pkg/apis/crds/karpenter.k8s.aws_awsnodetemplates.yaml
kubectl apply -f karpenter.yaml

Erstellen Sie einen Standard-Bereitsteller

Erstellen Sie einen Standard-Bereitsteller, damit Karpenter die Knotentypen kennt, die Sie für ungeplante Workloads benötigen. Weitere Informationen zu bestimmten Beispielen finden Sie unter aws/karpenter auf der GitHub-Website.

cat <<EOF | kubectl apply -f -
apiVersion: karpenter.sh/v1alpha5
kind: Provisioner
metadata:
  name: default
spec:
  requirements:
    - key: karpenter.k8s.aws/instance-category
      operator: In
      values: [c, m, r]
    - key: karpenter.k8s.aws/instance-generation
      operator: Gt
      values: ["2"]
  providerRef:
    name: default
  ttlSecondsAfterEmpty: 30
---
apiVersion: karpenter.k8s.aws/v1alpha1
kind: AWSNodeTemplate
metadata:
  name: default
spec:
  subnetSelector:
    karpenter.sh/discovery: "${CLUSTER_NAME}"
  securityGroupSelector:
    karpenter.sh/discovery: "${CLUSTER_NAME}"
EOF

Skalieren und verifizieren von Karpenter

Verwenden Sie die folgenden Schritte, um Ihre Knotengruppe auf eine Mindestgröße von mindestens zwei Knoten zu skalieren, wodurch Karpenter und andere kritische Services unterstützt werden.

1.    Skalierung konfigurieren:

aws eks update-nodegroup-config --cluster-name ${CLUSTER_NAME} \
    --nodegroup-name ${NODEGROUP} \
    --scaling-config "minSize=2,maxSize=2,desiredSize=2"

2.    Skalieren Sie Ihre Workloads und überprüfen Sie dann, ob Karpenter die neuen Knoten zur Bereitstellung Ihrer Workloads erstellt:

kubectl logs -f -n karpenter -c controller -l app.kubernetes.io/name=karpenter

Hinweis: Wenn Sie einen webhook.DefaultingWebhook Reconcile-Fehler in den Controller-Protokollen feststellen, starten Sie Ihre Karpenter-Pods neu, um ihn zu beheben.

3.    Führen Sie den folgenden Befehl aus, um den Status der Knoten zu überprüfen:

kubectl get nodes

---