Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Crea e gestisci EKS cluster Amazon con Step Functions

Scopri come integrare Step Functions con Amazon EKS per gestire i cluster Kubernetes. Step Functions offre due tipi di integrazione dei servizi APIs per l'integrazione con Amazon Elastic Kubernetes Service. One ti consente di utilizzare Amazon EKS APIs per creare e gestire un EKS cluster Amazon. L'altro ti consente di interagire con il tuo cluster utilizzando Kubernetes API ed eseguire lavori come parte del flusso di lavoro dell'applicazione.

Puoi utilizzare le API integrazioni Kubernetes con i cluster EKS Amazon creati utilizzando Step Functions, con i cluster EKS Amazon creati dallo strumento eksctl o dalla console Amazon o metodi simili. EKS Per ulteriori informazioni, consulta la sezione Creazione di un EKS cluster Amazon nella Amazon EKS User Guide.

Per saperne di più sull'integrazione con AWS servizi in Step Functions, vedere Integrazione dei servizi e. Passaggio di parametri a un servizio API in Step Functions

Step Functions non termina automaticamente un EKS cluster Amazon se l'esecuzione viene interrotta. Se la tua macchina a stati si arresta prima che il EKS cluster Amazon sia terminato, il cluster potrebbe continuare a funzionare a tempo indeterminato e potrebbe comportare costi aggiuntivi. Per evitare ciò, assicurati che tutti i EKS cluster Amazon che crei siano terminati correttamente. Per ulteriori informazioni, consultare:

Integrazioni Kubernetes API

Step Functions supporta i seguenti Kubernetes: APIs

RunJob

L'integrazione del eks:runJob servizio ti consente di eseguire un job sul tuo EKS cluster Amazon. La eks:runJob.sync variante consente di attendere il completamento del processo e, facoltativamente, di recuperare i log.

Il API server Kubernetes deve concedere le autorizzazioni per il ruolo utilizzato dalla IAM macchina a stati. Per ulteriori informazioni, consulta Autorizzazioni.

Per il pattern Run a Job (.sync), lo stato del lavoro è determinato dal polling. Step Functions effettua inizialmente sondaggi a una velocità di circa 1 sondaggio al minuto. Questa frequenza alla fine rallenta a circa 1 sondaggio ogni 5 minuti. Se hai bisogno di sondaggi più frequenti o hai bisogno di un maggiore controllo sulla strategia di polling, puoi utilizzare l'eks:callintegrazione per interrogare lo stato del lavoro.

L'eks:runJobintegrazione è specifica per batch/v1 Kubernetes Jobs. Per ulteriori informazioni, consulta Jobs nella documentazione di Kubernetes. Se desideri gestire altre risorse Kubernetes, incluse le risorse personalizzate, utilizza l'integrazione del servizio. eks:call È possibile utilizzare Step Functions per creare cicli di polling, come dimostrato nel progetto di Sondaggio sullo stato del lavoro con Lambda e AWS Batch esempio.

I parametri supportati includono:

L'esempio seguente include uno Task stato che esegue un processo, attende il suo completamento, quindi recupera i log del processo:

{
  "StartAt": "Run a job on EKS",
  "States": {
    "Run a job on EKS": {
      "Type": "Task",
      "Resource": "arn:aws:states:::eks:runJob.sync",
      "Parameters": {
        "ClusterName": "MyCluster",
        "CertificateAuthority": "ANPAJ2UCCR6DPCEXAMPLE",
        "Endpoint": "https://AKIAIOSFODNN7EXAMPLE.yl4.us-east-1.eks.amazonaws.com",
        "LogOptions": {
          "RetrieveLogs": true
        },
        "Job": {
          "apiVersion": "batch/v1",
          "kind": "Job",
          "metadata": {
            "name": "example-job"
          },
          "spec": {
            "backoffLimit": 0,
            "template": {
              "metadata": {
                "name": "example-job"
              },
              "spec": {
                "containers": [
                  {
                    "name": "pi-2000",
                    "image": "perl",
                    "command": [ "perl" ],
                    "args": [
                      "-Mbignum=bpi",
                      "-wle",
                      "print bpi(2000)"
                    ]
                  }
                ],
                "restartPolicy": "Never"
              }
            }
          }
        }
      },
      "End": true
    }
  }
}

Call

L'integrazione dei eks:call servizi consente di utilizzare Kubernetes per leggere e scrivere oggetti di risorse Kubernetes API tramite un endpoint Kubernetes. API

Il server Kubernetes API deve concedere le autorizzazioni per il ruolo utilizzato dalla macchina a stati. IAM Per ulteriori informazioni, consulta Autorizzazioni.

Per ulteriori informazioni sulle operazioni disponibili, consulta Kubernetes Reference. API

I parametri supportati includono: Call

Quanto segue include uno Task stato che utilizza eks:call per elencare i pod appartenenti al lavoro. example-job

{
  "StartAt": "Call EKS",
  "States": {
    "Call EKS": {
      "Type": "Task",
      "Resource": "arn:aws:states:::eks:call",
      "Parameters": {
        "ClusterName": "MyCluster",
        "CertificateAuthority": "ANPAJ2UCCR6DPCEXAMPLE",
        "Endpoint": "https://444455556666.yl4.us-east-1.eks.amazonaws.com",
        "Method": "GET",
        "Path": "/api/v1/namespaces/default/pods",
        "QueryParameters": {
          "labelSelector": [
            "job-name=example-job"
          ]
        }
      },
      "End": true
    }
  }
}

Quanto segue include uno Task stato che utilizza eks:call per eliminare il lavoro example-job e lo imposta propagationPolicy per garantire che vengano eliminati anche i pod del lavoro.

{
  "StartAt": "Call EKS",
  "States": {
    "Call EKS": {
      "Type": "Task",
      "Resource": "arn:aws:states:::eks:call",
      "Parameters": {
        "ClusterName": "MyCluster",
        "CertificateAuthority": "ANPAJ2UCCR6DPCEXAMPLE",
        "Endpoint": "https://444455556666.yl4.us-east-1.eks.amazonaws.com",
        "Method": "DELETE",
        "Path": "/apis/batch/v1/namespaces/default/jobs/example-job",
        "QueryParameters": {
          "propagationPolicy": [
            "Foreground"
          ]
        }
      },
      "End": true
    }
  }
}

Amazon supportato EKS APIs

Amazon EKS APIs e la sintassi supportate includono:

Quanto segue include un Task che crea un EKS cluster Amazon.

{
  "StartAt": "CreateCluster.sync",
  "States": {
    "CreateCluster.sync": {
      "Type": "Task",
      "Resource": "arn:aws:states:::eks:createCluster.sync",
      "Parameters": {
        "Name": "MyCluster",
        "ResourcesVpcConfig": {
          "SubnetIds": [
            "subnet-053e7c47012341234",
            "subnet-027cfea4b12341234"
          ]
        },
        "RoleArn": "arn:aws:iam::123456789012:role/MyEKSClusterRole"
      },
      "End": true
    }
  }
}

Quanto segue include uno Task stato che elimina un EKS cluster Amazon.

{
  "StartAt": "DeleteCluster.sync",
  "States": {
    "DeleteCluster.sync": {
      "Type": "Task",
      "Resource": "arn:aws:states:::eks:deleteCluster.sync",
      "Parameters": {
        "Name": "MyCluster"
      },
      "End": true
    }
  }
}

Quanto segue include uno Task stato che crea un profilo Fargate.

{
  "StartAt": "CreateFargateProfile.sync",
  "States": {
    "CreateFargateProfile.sync": {
      "Type": "Task",
      "Resource": "arn:aws:states:::eks:createFargateProfile.sync",
      "Parameters": {
        "ClusterName": "MyCluster",
        "FargateProfileName": "MyFargateProfile",
        "PodExecutionRoleArn": "arn:aws:iam::123456789012:role/MyFargatePodExecutionRole",
        "Selectors": [{
            "Namespace": "my-namespace",
            "Labels": { "my-label": "my-value" }
          }]
      },
      "End": true
    }
  }
}

Quanto segue include uno Task stato che elimina un profilo Fargate.

{
  "StartAt": "DeleteFargateProfile.sync",
  "States": {
    "DeleteFargateProfile.sync": {
      "Type": "Task",
      "Resource": "arn:aws:states:::eks:deleteFargateProfile.sync",
      "Parameters": {
        "ClusterName": "MyCluster",
        "FargateProfileName": "MyFargateProfile"
      },
      "End": true
    }
  }
}

Quanto segue include uno Task stato che crea un gruppo di nodi.

{
  "StartAt": "CreateNodegroup.sync",
  "States": {
    "CreateNodegroup.sync": {
      "Type": "Task",
      "Resource": "arn:aws:states:::eks:createNodegroup.sync",
      "Parameters": {
        "ClusterName": "MyCluster",
        "NodegroupName": "MyNodegroup",
        "NodeRole": "arn:aws:iam::123456789012:role/MyNodeInstanceRole",
        "Subnets": ["subnet-09fb51df01234", "subnet-027cfea4b1234"] 
      },
      "End": true
    }
  }
}

Quanto segue include uno Task stato che elimina un gruppo di nodi.

{
  "StartAt": "DeleteNodegroup.sync",
  "States": {
    "DeleteNodegroup.sync": {
      "Type": "Task",
      "Resource": "arn:aws:states:::eks:deleteNodegroup.sync",
      "Parameters": {
        "ClusterName": "MyCluster",
        "NodegroupName": "MyNodegroup"
      },
      "End": true
    }
  }
}

Autorizzazioni

Quando viene creato un EKS cluster Amazon utilizzando l'integrazione del eks:createCluster servizio, il IAM ruolo viene aggiunto alla tabella di RBAC autorizzazione Kubernetes come amministratore, con le autorizzazioni. system:masters Inizialmente, solo quell'IAMentità può effettuare chiamate al server Kubernetes. API Ad esempio, non sarai in grado di utilizzare kubectl per interagire con il tuo API server Kubernetes, a meno che non assumi lo stesso ruolo della tua macchina a stati Step Functions o se configuri Kubernetes per concedere autorizzazioni a entità aggiuntive. IAM Per ulteriori informazioni, consulta la sezione Gestione degli utenti o IAM dei ruoli per il tuo cluster nella Amazon EKS User Guide.

Puoi aggiungere autorizzazioni per IAM entità aggiuntive, come utenti o ruoli, aggiungendole allo spazio dei nomi aws-auth ConfigMap nel kube-system. Se stai creando il tuo cluster da Step Functions, utilizza l'integrazione del eks:call servizio.

Quanto segue include uno Task stato che crea aws-auth ConfigMap e concede l'system:mastersautorizzazione all'utente arn:aws:iam::123456789012:user/my-user e al IAM ruoloarn:aws:iam::123456789012:role/my-role.

{
  "StartAt": "Add authorized user",
  "States": {
    "Add authorized user": {
      "Type": "Task",
      "Resource": "arn:aws:states:::eks:call",
      "Parameters": {
        "ClusterName": "MyCluster",
        "CertificateAuthority": "LS0tLS1CRUd...UtLS0tLQo=",
        "Endpoint": "https://444455556666.yl4.us-east-1.eks.amazonaws.com",
        "Method": "POST",
        "Path": "/api/v1/namespaces/kube-system/configmaps",
        "RequestBody": {
           "apiVersion": "v1",
           "kind": "ConfigMap",
           "metadata": {
              "name": "aws-auth",
              "namespace": "kube-system"
           },
           "data": {
             "mapUsers": "[{ \"userarn\": \"arn:aws:iam::123456789012:user/my-user\", \"username\": \"my-user\", \"groups\": [ \"system:masters\" ] } ]",
             "mapRoles": "[{ \"rolearn\": \"arn:aws:iam::123456789012:role/my-role\", \"username\": \"my-role\", \"groups\": [ \"system:masters\" ] } ]"
           }
        }
      },
      "End": true
    }
  }

Quando il cluster viene creato per la prima volta, non aws-auth ConfigMap esisterà, ma verrà aggiunto automaticamente se si crea un profilo Fargate. È possibile recuperare il valore corrente diaws-auth, aggiungere le autorizzazioni aggiuntive e PUT una nuova versione. Di solito è più facile da creare aws-auth prima del profilo Fargate.

Se il tuo cluster è stato creato al di fuori di Step Functions, puoi configurare kubectl per comunicare con il tuo server Kubernetes. API Quindi, creane un nuovo aws-auth ConfigMap utilizzo kubectl apply -f aws-auth.yaml o modificane uno già esistente utilizzando. kubectl edit -n kube-system configmap/aws-auth Per ulteriori informazioni, consultare:

Se il tuo IAM ruolo non dispone di autorizzazioni sufficienti in Kubernetes, le integrazioni eks:call o i eks:runJob servizi falliranno con il seguente errore:

Error:
EKS.401

Cause:
{
  "ResponseBody": {
    "kind": "Status",
    "apiVersion": "v1",
    "metadata": {},
    "status": "Failure",
    "message": "Unauthorized",
    "reason": "Unauthorized",
    "code": 401
  },
  "StatusCode": 401,
  "StatusText": "Unauthorized"
}

            

IAMpolitiche per le chiamate ad Amazon EKS

I seguenti modelli di esempio mostrano come AWS Step Functions genera IAM politiche basate sulle risorse nella definizione della macchina a stati. Per ulteriori informazioni, consulta In che modo Step Functions genera IAM politiche per servizi integrati e Scopri i modelli di integrazione dei servizi in Step Functions.

CreateCluster

Risorse

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "eks:CreateCluster"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "eks:DescribeCluster",
                "eks:DeleteCluster"
            ],
            "Resource": "arn:aws:eks:sa-east-1:444455556666:cluster/*"
        },
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": [
                "arn:aws:iam::444455556666:role/StepFunctionsSample-EKSClusterManag-EKSServiceRole-ANPAJ2UCCR6DPCEXAMPLE"
            ],
            "Condition": {
                "StringEquals": {
                    "iam:PassedToService": "eks.amazonaws.com"
                }
            }
        }
    ]
}

CreateNodeGroup

Risorse

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ec2:DescribeSubnets",
                "eks:CreateNodegroup"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "eks:DescribeNodegroup",
                "eks:DeleteNodegroup"
            ],
            "Resource": "arn:aws:eks:sa-east-1:444455556666:nodegroup/*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "iam:GetRole",
                "iam:ListAttachedRolePolicies"
            ],
            "Resource": "arn:aws:iam::444455556666:role/*"
        },
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": [
                "arn:aws:iam::444455556666:role/StepFunctionsSample-EKSClusterMan-NodeInstanceRole-ANPAJ2UCCR6DPCEXAMPLE"
            ],
            "Condition": {
                "StringEquals": {
                    "iam:PassedToService": "eks.amazonaws.com"
                }
            }
        }
    ]
}

DeleteCluster

Risorse

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "eks:DeleteCluster",
                "eks:DescribeCluster"
            ],
            "Resource": [
                "arn:aws:eks:sa-east-1:444455556666:cluster/ExampleCluster"
            ]
        }
    ]
}

DeleteNodegroup

Risorse

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "eks:DeleteNodegroup",
                "eks:DescribeNodegroup"
            ],
            "Resource": [
                "arn:aws:eks:sa-east-1:444455556666:nodegroup/ExampleCluster/ExampleNodegroup/*"
            ]
        }
    ]
}

Per ulteriori informazioni sull'utilizzo di Amazon EKS con Step Functions, consultaCrea e gestisci EKS cluster Amazon con Step Functions.