Come faccio a installare Karpenter nel cluster Amazon EKS?

Breve descrizione

Karpenter è un progetto open source di provisioning di nodi creato per Kubernetes. L'aggiunta di Karpenter a un cluster Kubernetes può migliorare notevolmente l'efficienza e i costi di esecuzione dei carichi di lavoro sul cluster. Per ulteriori informazioni, consultare la documentazione di Karpenter.

I passaggi seguenti mostrano come implementare Karpenter in un cluster Amazon EKS.

Risoluzione

Prerequisiti

Prima di iniziare, completa i seguenti passaggi:

• Installa il client Helm, versione 3.11.0 o successive. Consulta Helm Docs per ulteriori informazioni sulle procedure di installazione.
• Installa eksctl. Consulta la guida utente di eksctl per ulteriori informazioni sulle procedure di installazione.
• Crea queste variabili di ambiente:

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)

Nota: inserisci il nome del cluster EKS in your_cluster_name e il numero di versione Karpenter richiesto in your_required_version. Controlla karpenter/releases per le versioni di Karpenter.

Crea ruoli IAM per Karpenter e il controller Karpenter

1.    Crea i ruoli AWS Identity and Access Management (IAM) per i nodi forniti con Karpenter. Il ruolo del nodo Karpenter (KarpenterInstanceNodeRole) è simile al ruolo IAM del nodo Amazon EKS. Consulta Ruolo IAM del nodo Amazon EKS per creare KapenterInstanceNodeRole utilizzando la Console di gestione AWS o l'Interfaccia della linea di comando AWS (AWS CLI).

Nota: se riscontri errori nell'esecuzione dei comandi della CLI, assicurati di utilizzare la versione più recente di AWS CLI. Consulta Troubleshooting AWS CLI errors - AWS Command Line Interface (Risoluzione degli errori di AWS CLI - Interfaccia della linea di comando AWS).

2.    Aggiungi queste policy IAM al ruolo IAM KarpenterInstanceNodeRole che hai creato.

AmazonEKSWorkerNodePolicy
AmazonEKS_CNI_Policy
AmazonEC2ContainerRegistryReadOnly
AmazonSSMManagedInstanceCore

Configura il ruolo IAM per il controller Karpenter

Crea un ruolo IAM per KarpenterControllerRole. Il controller Karpenter utilizza i ruoli IAM per gli account di servizio (IRSA).

1.    Crea un documento controller-policy.json con le seguenti autorizzazioni:

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.    Crea una policy IAM utilizzando il documento controller-policy.json.

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

3.    Crea un provider di identità IAM OIDC per il cluster usando questo comando eksctl

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

Nota: assicurati che la versione eksctl sia 0.32.0 o successiva.

4.    Crea il ruolo IAM per il controller Karpenter utilizzando il comando eksctl. Associa l'account di servizio Kubernetes al ruolo IAM utilizzando IRSA.

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

Aggiungi tag a sottoreti e gruppi di sicurezza

1.    Aggiungi tag alle sottoreti di gruppi di nodi in modo che Karpenter conosca quali sottoreti utilizzare.

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.    Aggiungi tag ai gruppi di sicurezza.

Nota: i comandi seguenti aggiungono tag solo ai gruppi di sicurezza del primo gruppo di nodi. Se disponi di più gruppi di nodi o più gruppi di sicurezza, devi scegliere il gruppo di sicurezza che Karpenter utilizzerà.

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}

Aggiorna aws-auth ConfigMap

1.    Aggiorna aws-auth ConfigMap nel cluster per consentire ai nodi che utilizzano il ruolo IAM KarpenterInstanceNodeRole di unirsi al cluster. Esegui il seguente comando:

kubectl edit configmap aws-auth -n kube-system

2.    Aggiungi a mapRoles una sezione simile a questo esempio:

Nota: sostituisci la variabile ${AWS_ACCOUNT_ID} con il tuo account, ma non sostituire {{EC2PrivateDNSName}}.

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

La versione completa di aws-auth ConfigMap ora ha due gruppi: uno per il ruolo del nodo Karpenter e uno per il gruppo di nodi esistente.

Implementa Karpenter

1.    Verifica la versione di Karpenter che desideri implementare usando questo comando:

echo $KARPENTER_VERSION

Se non vedi alcun output o vedi una versione diversa da quella desiderata, esegui:

export KARPENTER_VERSION=your_required_version

Nota: sostituisci your_required_version con il numero di versione desiderato in questo esempio. Consulta aws/karpenter per le versioni di Karpenter sul sito web di GitHub.

2.    Genera un file yaml di implementazione Karpenter completo dal grafico Helm. Prima di iniziare, assicurati che la versione del client Helm sia la v3.11.0 o successiva.

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.    Imposta l'affinità in modo che Karpenter venga eseguito su uno dei nodi del gruppo di nodi esistente. Trova la regola di affinità di implementazione e modificala nel file karpenter.yaml appena creato:

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

Crea il namespace Karpenter

Crea il namespace Karpenter richiesto e il CRD del provisioner. Quindi, implementa il resto delle risorse di Karpenter.

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

Crea un provisioner predefinito

Crea un provisioner predefinito in modo che Karpenter conosca i tipi di nodi selezionati per i carichi di lavoro non pianificati. Per ulteriori informazioni su esempi specifici, consulta aws/karpenter sul sito web di GitHub.

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

Scala e verifica Karpenter

Utilizza i seguenti passaggi per scalare il gruppo di nodi fino a una dimensione minima di almeno due nodi per supportare Karpenter e altri servizi importanti.

1.    Configura la scalabilità:

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

2.    Scala i carichi di lavoro e verifica che Karpenter stia creando i nuovi nodi per il provisioning dei carichi di lavoro:

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

Nota: se noti un errore webhook.DefaultingWebhook Reconcile nei log del controller, riavvia i pod Karpenter per correggerlo.

3.    Esegui il seguente comando per verificare lo stato dei nodi:

kubectl get nodes

---