Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Amazon EKS-Cluster mit Step Functions erstellen und verwalten

Erfahren Sie, wie Sie Step Functions mit Amazon EKS integrieren, um Kubernetes-Cluster zu verwalten. Step Functions bietet zwei Arten der Serviceintegration APIs für die Integration mit Amazon Elastic Kubernetes Service. Mit einem können Sie Amazon EKS verwenden APIs , um einen Amazon EKS-Cluster zu erstellen und zu verwalten. Mit der anderen können Sie mithilfe der Kubernetes-API mit Ihrem Cluster interagieren und Jobs als Teil des Workflows Ihrer Anwendung ausführen.

Sie können die Kubernetes-API-Integrationen mit Amazon EKS-Clustern verwenden, die mit Step Functions erstellt wurden, mit Amazon EKS-Clustern, die mit dem eksctl-Tool oder der Amazon EKS-Konsole erstellt wurden, oder mit ähnlichen Methoden. Weitere Informationen finden Sie unter Erstellen eines Amazon EKS-Clusters im Amazon EKS-Benutzerhandbuch.

Informationen zur Integration mit AWS Diensten in Step Functions finden Sie unter Integrieren von -Services undÜbergeben von Parametern an eine Service-API in Step Functions.

Step Functions beendet einen Amazon EKS-Cluster nicht automatisch, wenn die Ausführung gestoppt wird. Wenn Ihr State Machine stoppt, bevor Ihr Amazon EKS-Cluster beendet wurde, läuft Ihr Cluster möglicherweise auf unbestimmte Zeit weiter und es können zusätzliche Gebühren anfallen. Um dies zu vermeiden, stellen Sie sicher, dass jeder Amazon EKS-Cluster, den Sie erstellen, ordnungsgemäß beendet wird. Weitere Informationen finden Sie unter:

Kubernetes-API-Integrationen

Step Functions unterstützt die folgenden Kubernetes APIs:

RunJob

Die eks:runJob Service-Integration ermöglicht es Ihnen, einen Job auf Ihrem Amazon EKS-Cluster auszuführen. Bei eks:runJob.sync dieser Variante können Sie warten, bis der Job abgeschlossen ist, und optional Protokolle abrufen.

Ihr Kubernetes-API-Server muss der von Ihrem Zustandsmaschine verwendeten IAM-Rolle Berechtigungen gewähren. Weitere Informationen finden Sie unter Berechtigungen.

Für das Run a Job (.sync) -Muster wird der Status des Jobs durch Abfragen bestimmt. Step Functions fragt zunächst mit einer Geschwindigkeit von ungefähr 1 Umfrage pro Minute ab. Diese Rate verlangsamt sich schließlich auf etwa 1 Umfrage alle 5 Minuten. Wenn Sie häufigere Abfragen benötigen oder mehr Kontrolle über die Abfragestrategie benötigen, können Sie die eks:call Integration verwenden, um den Status des Jobs abzufragen.

Die eks:runJob Integration ist spezifisch für batch/v1 Kubernetes Jobs. Weitere Informationen finden Sie unter Jobs in der Kubernetes-Dokumentation. Wenn Sie andere Kubernetes-Ressourcen, einschließlich benutzerdefinierter Ressourcen, verwalten möchten, verwenden Sie die Serviceintegration. eks:call Sie können Step Functions verwenden, um Abfrageschleifen zu erstellen, wie im Umfrage zum Jobstatus mit Lambda und AWS Batch Beispielprojekt gezeigt.

Zu den unterstützten Parametern gehören:

Das folgende Beispiel enthält einen Task Status, der einen Job ausführt, auf seinen Abschluss wartet und dann die Logs des Jobs abruft:

{
  "StartAt": "Run a job on EKS",
  "States": {
    "Run a job on EKS": {
      "Type": "Task",
      "Resource": "arn:aws:states:::eks:runJob.sync",
      "Arguments": {
        "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

Die eks:call Serviceintegration ermöglicht es Ihnen, die Kubernetes-API zu verwenden, um Kubernetes-Ressourcenobjekte über einen Kubernetes-API-Endpunkt zu lesen und zu schreiben.

Ihr Kubernetes-API-Server muss der von Ihrem Zustandsmaschine verwendeten IAM-Rolle Berechtigungen gewähren. Weitere Informationen finden Sie unter Berechtigungen.

Weitere Informationen zu den verfügbaren Vorgängen finden Sie in der Kubernetes-API-Referenz.

Zu den unterstützten Parametern für gehörenCall:

Im Folgenden finden Sie einen Task Status, der verwendet wird, eks:call um die Pods aufzulisten, die zu dem Job gehören. example-job

{
  "StartAt": "Call EKS",
  "States": {
    "Call EKS": {
      "Type": "Task",
      "Resource": "arn:aws:states:::eks:call",
      "Arguments": {
        "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
    }
  }
}

Der folgende Status enthält einen Task Status, der eks:call zum Löschen des Auftrags verwendet wirdexample-job, und legt den Status fest, propagationPolicy um sicherzustellen, dass die Pods des Auftrags ebenfalls gelöscht werden.

{
  "StartAt": "Call EKS",
  "States": {
    "Call EKS": {
      "Type": "Task",
      "Resource": "arn:aws:states:::eks:call",
      "Arguments": {
        "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
    }
  }
}

Optimiertes Amazon EKS APIs

Zu den unterstützten Amazon EKS APIs und der Syntax gehören:

Das Folgende beinhaltet einenTask, der einen Amazon EKS-Cluster erstellt.

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

Im Folgenden wird ein Task Status beschrieben, der einen Amazon EKS-Cluster löscht.

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

Im Folgenden wird ein Task Bundesstaat beschrieben, der ein Fargate-Profil erstellt.

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

Das Folgende beinhaltet einen Task Status, der ein Fargate-Profil löscht.

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

Im Folgenden wird ein Task Status beschrieben, der eine Knotengruppe erstellt.

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

Das Folgende beinhaltet einen Task Status, der eine Knotengruppe löscht.

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

Berechtigungen

Wenn ein Amazon EKS-Cluster mithilfe der eks:createCluster Service-Integration erstellt wird, wird die IAM-Rolle als Administrator mit Berechtigungen zur Kubernetes-RBAC-Autorisierungstabelle hinzugefügt. system:masters Anfänglich kann nur diese IAM-Entität den Kubernetes-API-Server aufrufen. Beispielsweise können Sie kubectl nicht verwenden, um mit Ihrem Kubernetes-API-Server zu interagieren, es sei denn, Sie übernehmen dieselbe Rolle wie Ihre Step Functions Functions-Zustandsmaschine oder wenn Sie Kubernetes so konfigurieren, dass es zusätzlichen IAM-Entitäten Berechtigungen erteilt. Weitere Informationen finden Sie unter Verwalten von Benutzern oder IAM-Rollen für Ihren Cluster im Amazon EKS-Benutzerhandbuch.

Sie können Berechtigungen für zusätzliche IAM-Entitäten wie Benutzer oder Rollen hinzufügen, indem Sie sie dem Namespace aws-auth ConfigMap in the kube-system hinzufügen. Wenn Sie Ihren Cluster aus Step Functions erstellen, verwenden Sie die eks:call Serviceintegration.

Im Folgenden finden Sie einen Task Status, der eine aws-auth ConfigMap IAM-Rolle arn:aws:iam::account-id:role/my-role erstellt arn:aws:iam::account-id:user/my-user und dem Benutzer eine system:masters entsprechende Berechtigung erteilt.

{
  "StartAt": "Add authorized user",
  "States": {
    "Add authorized user": {
      "Type": "Task",
      "Resource": "arn:aws:states:::eks:call",
      "Arguments": {
        "ClusterName": "MyCluster",
        "CertificateAuthority": "LS0tLS1CRUd...UtLS0tLQo=",
        "Endpoint": "https://444455556666.yl4.region.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::account-id:user/my-user\", \"username\": \"my-user\", \"groups\": [ \"system:masters\" ] } ]",
             "mapRoles": "[{ \"rolearn\": \"arn:aws:iam::account-id:role/my-role\", \"username\": \"my-role\", \"groups\": [ \"system:masters\" ] } ]"
           }
        }
      },
      "End": true
    }
  }

Wenn Ihr Cluster zum ersten Mal erstellt aws-auth ConfigMap wird, ist er nicht vorhanden, wird aber automatisch hinzugefügt, wenn Sie ein Fargate-Profil erstellen. Sie können den aktuellen Wert von abrufenaws-auth, die zusätzlichen Berechtigungen und PUT eine neue Version hinzufügen. Es ist normalerweise einfacher, es aws-auth vor dem Fargate-Profil zu erstellen.

Wenn Ihr Cluster außerhalb von Step Functions erstellt wurde, können Sie kubectl so konfigurieren, dass es mit Ihrem Kubernetes-API-Server kommuniziert. Erstellen Sie dann einen neuen aws-auth ConfigMap mit kubectl apply -f aws-auth.yaml oder bearbeiten Sie einen, der bereits vorhanden ist, mit. kubectl edit -n kube-system configmap/aws-auth Weitere Informationen finden Sie unter:

Wenn Ihre IAM-Rolle nicht über ausreichende Berechtigungen in Kubernetes verfügt, schlagen die eks:call oder eks:runJob Service-Integrationen mit dem folgenden Fehler fehl:

Error:
EKS.401

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

            

IAM-Richtlinien für das Aufrufen von Amazon EKS

Die folgenden Beispielvorlagen zeigen, wie IAM-Richtlinien auf der Grundlage der Ressourcen in Ihrer State-Machine-Definition AWS Step Functions generiert werden. Weitere Informationen erhalten Sie unter So generiert Step Functions IAM-Richtlinien für integrierte Dienste und Entdecken Sie Serviceintegrationsmuster in Step Functions.

CreateCluster

Ressourcen

CreateNodeGroup

Ressourcen

DeleteCluster

Ressourcen

DeleteNodegroup

Ressourcen

Weitere Informationen zur Verwendung von Amazon EKS mit Step Functions finden Sie unterAmazon EKS-Cluster mit Step Functions erstellen und verwalten.