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à.

Chiama Amazon EKS con Step Functions

Step Functions può controllare determinati AWS servizi direttamente da Amazon States Language (ASL). Per ulteriori informazioni, consultare Uso di altri servizi e Passa i parametri a un'API di servizio.

Per informazioni su come configurare IAM le autorizzazioni quando vengono utilizzate Step Functions con altri AWS servizi, vederePolitiche IAM per servizi integrati.

Step Functions fornisce due tipi di API di integrazione dei servizi per l'integrazione con Amazon Elastic Kubernetes Service. One ti consente di utilizzare le API di Amazon EKS per creare e gestire un cluster Amazon EKS. L'altro ti consente di interagire con il cluster utilizzando l'API Kubernetes ed eseguire lavori come parte del flusso di lavoro dell'applicazione. Puoi utilizzare le integrazioni API Kubernetes con i cluster Amazon EKS creati con Step Functions, con i cluster Amazon EKS creati dallo strumento eksctl o dalla console Amazon EKS o metodi simili. Per ulteriori informazioni, consulta Creazione di un cluster Amazon EKS nella Guida per l'utente di Amazon EKS.

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

Integrazioni API Kubernetes

Step Functions supporta le seguenti API Kubernetes:

RunJob

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

Il tuo server API Kubernetes deve concedere le autorizzazioni per il ruolo IAM utilizzato dalla tua 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 per Job Status ( AWS Batch Lambda,) 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 l'API Kubernetes per leggere e scrivere oggetti di risorse Kubernetes tramite un endpoint dell'API Kubernetes.

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

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

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
    }
  }
}

API Amazon EKS supportate

Le API e la sintassi di Amazon EKS supportate includono:

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

{
  "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 cluster Amazon EKS.

{
  "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 un cluster Amazon EKS viene creato utilizzando l'integrazione del eks:createCluster servizio, il ruolo IAM viene aggiunto alla tabella di autorizzazione RBAC di Kubernetes come amministratore, con autorizzazioni. system:masters Inizialmente, solo quell'entità IAM può effettuare chiamate al server API Kubernetes. Ad esempio, non sarai in grado di utilizzare kubectl per interagire con il tuo server API 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à IAM aggiuntive. Per ulteriori informazioni, consulta la sezione Gestione degli utenti o dei ruoli IAM per il tuo cluster nella Amazon EKS User Guide.

Puoi aggiungere l'autorizzazione per altre entità IAM, come utenti o ruoli, aggiungendole allo spazio dei nomi aws-auth ConfigMap nel sistema kube. 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 ruolo arn:aws:iam::123456789012:role/my-role IAM.

{
  "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 API Kubernetes. 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 ruolo IAM non dispone di autorizzazioni sufficienti in Kubernetes, le integrazioni eks:call o di eks:runJob servizio 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"
}