},
...
}
},
...
}
}
```
+ Il recupero dei log viene eseguito con la massima diligenza possibile. Se si verifica un errore durante il recupero di un registro, al posto del `log` campo ci saranno i campi e. `error` `cause`
+ `LogOptions.RetrieveLogs`: Abilita il recupero dei log dopo il completamento del processo. Per impostazione predefinita, i log non vengono recuperati.
+ `Type`: `Boolean`
+ Obbligatorio: no
+ `LogOptions.RawLogs`: Se `RawLogs` è impostato su true, i log verranno restituiti come stringhe non elaborate senza tentare di analizzarli in JSON. Per impostazione predefinita, i log vengono deserializzati in JSON, se possibile. In alcuni casi tale analisi può introdurre modifiche indesiderate, come la limitazione della precisione dei numeri contenenti molte cifre.
+ `Type`: `Boolean`
+ Obbligatorio: no
+ `LogOptions.LogParameters`: L'API Read Log dell'API Kubernetes supporta i parametri di query per controllare il recupero dei log. Ad esempio, è possibile utilizzare `tailLines` o `limitBytes` limitare la dimensione dei log recuperati e rimanere entro la quota di dimensione dei dati di Step Functions. Per ulteriori informazioni, consulta la sezione [Read Log](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#read-log-pod-v1-core) del Kubernetes API Reference.
+ `Type: `Mappa di `String` `List of Strings`
+ Obbligatorio: no
+ Esempio:
```
"LogParameters": {
"tailLines": [ "6" ]
}
```
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",
"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`
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 [Permissions](#connect-eks-permissions).
[Per ulteriori informazioni sulle operazioni disponibili, consulta il Kubernetes API Reference.](https://kubernetes.io/docs/reference/kubernetes-api/)
I parametri supportati includono: `Call`
+ `ClusterName`: il nome del cluster Amazon EKS che desideri chiamare.
+ `Type`: Stringa
+ Obbligatorio: sì
+ `CertificateAuthority`: I dati del certificato con codifica Base64 necessari per comunicare con il cluster. Puoi ottenere questo valore dalla [console Amazon EKS](https://console.aws.amazon.com/eks/home) o utilizzando l'[DescribeCluster](https://docs.aws.amazon.com/eks/latest/APIReference/API_DescribeCluster.html)API Amazon EKS.
+ `Type`: `String`
+ Obbligatorio: sì
+ `Endpoint`: L'URL dell'endpoint per il tuo server API Kubernetes. Puoi trovare questo valore sulla [console Amazon EKS](https://console.aws.amazon.com/eks/home) o utilizzando l' DescribeCluster API di Amazon EKS.
+ `Type`: `String`
+ Obbligatorio: sì
+ `Method`: il metodo HTTP della tua richiesta. Uno tra: `GET`, `POST`, `PUT`, `DELETE`, `HEAD`, o `PATCH`.
+ `Type`: `String`
+ Obbligatorio: sì
+ `Path`: Il percorso HTTP dell'operazione dell'API REST di Kubernetes.
+ `Type`: `String`
+ Obbligatorio: sì
+ `QueryParameters`: i parametri di query HTTP dell'operazione dell'API REST di Kubernetes.
+ `Type: `Mappa di `String` `List of Strings`
+ Obbligatorio: no
+ Esempio:
```
"QueryParameters": {
"labelSelector": [ "job-name=example-job" ]
}
```
+ `RequestBody`: il corpo del messaggio HTTP dell'operazione dell'API REST di Kubernetes.
+ `Type`: `JSON` o `String`
+ Obbligatorio: no
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",
"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
}
}
}
```
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",
"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
}
}
}
```
## Amazon EKS ottimizzato APIs
Amazon EKS APIs e la sintassi supportate includono:
+ [https://docs.aws.amazon.com/eks/latest/APIReference/API_CreateCluster.html](https://docs.aws.amazon.com/eks/latest/APIReference/API_CreateCluster.html)
+ [Sintassi della richiesta](https://docs.aws.amazon.com/eks/latest/APIReference/API_CreateCluster.html#API_CreateCluster_RequestSyntax)
+ [Sintassi della risposta](https://docs.aws.amazon.com/eks/latest/APIReference/API_CreateCluster.html#API_CreateCluster_ResponseSyntax)
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. Per ulteriori informazioni, consulta:
+ [Gestione degli utenti o dei ruoli IAM per il tuo cluster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) nella *Amazon EKS User Guide*
+ La [Permissions](#connect-eks-permissions) sezione
Amazon EKS utilizza ruoli collegati ai servizi che contengono le autorizzazioni richieste da Amazon EKS per chiamare altri servizi per tuo conto. Se questi ruoli collegati ai servizi non esistono già nel tuo account, devi aggiungere l'`iam:CreateServiceLinkedRole`autorizzazione al ruolo IAM utilizzato da Step Functions. Per ulteriori informazioni, consulta [Using Service-Linked Roles](https://docs.aws.amazon.com/eks/latest/userguide/using-service-linked-roles.html) nella *Amazon EKS User Guide*.
Il ruolo IAM utilizzato da Step Functions deve disporre `iam:PassRole` delle autorizzazioni per passare il ruolo IAM del cluster ad Amazon EKS. Per ulteriori informazioni, consulta il [ruolo IAM del cluster Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/service_IAM_role.html) nella *Guida per l'utente di Amazon EKS*.
+ [https://docs.aws.amazon.com/eks/latest/APIReference/API_DeleteCluster.html](https://docs.aws.amazon.com/eks/latest/APIReference/API_DeleteCluster.html)
+ [Sintassi della richiesta](https://docs.aws.amazon.com/eks/latest/APIReference/API_DeleteCluster.html#API_DeleteCluster_RequestSyntax)
+ [Sintassi della risposta](https://docs.aws.amazon.com/eks/latest/APIReference/API_DeleteCluster.html#API_DeleteCluster_ResponseSyntax)
È necessario eliminare qualsiasi profilo o gruppo di nodi Fargate prima di eliminare un cluster.
+ [https://docs.aws.amazon.com/eks/latest/APIReference/API_CreateFargateProfile.html](https://docs.aws.amazon.com/eks/latest/APIReference/API_CreateFargateProfile.html)
+ [Sintassi della richiesta](https://docs.aws.amazon.com/eks/latest/APIReference/API_CreateFargateProfile.html#API_CreateFargateProfile_RequestSyntax)
+ [Sintassi della risposta](https://docs.aws.amazon.com/eks/latest/APIReference/API_CreateFargateProfile.html#API_CreateFargateProfile_ResponseSyntax)
Amazon EKS utilizza ruoli collegati ai servizi che contengono le autorizzazioni richieste da Amazon EKS per chiamare altri servizi per tuo conto. Se questi ruoli collegati ai servizi non esistono già nel tuo account, devi aggiungere l'`iam:CreateServiceLinkedRole`autorizzazione al ruolo IAM utilizzato da Step Functions. Per ulteriori informazioni, consulta [Using Service-Linked Roles](https://docs.aws.amazon.com/eks/latest/userguide/using-service-linked-roles.html) nella *Amazon EKS User Guide*.
Amazon EKS su Fargate potrebbe non essere disponibile in tutte le regioni. Per informazioni sulla disponibilità delle regioni, consulta la sezione [Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate.html) nella Guida per *l'utente di Amazon EKS*.
Il ruolo IAM utilizzato da Step Functions deve disporre `iam:PassRole` delle autorizzazioni per passare il ruolo IAM di esecuzione del pod ad Amazon EKS. Per ulteriori informazioni, consulta il [ruolo di esecuzione del Pod](https://docs.aws.amazon.com/eks/latest/userguide/pod-execution-role.html) nella *Guida per l'utente di Amazon EKS*.
+ [https://docs.aws.amazon.com/eks/latest/APIReference/API_DeleteFargateProfile.html](https://docs.aws.amazon.com/eks/latest/APIReference/API_DeleteFargateProfile.html)
+ [Sintassi della richiesta](https://docs.aws.amazon.com/eks/latest/APIReference/API_DeleteFargateProfile.html#API_DeleteFargateProfile_RequestSyntax)
+ [Sintassi della risposta](https://docs.aws.amazon.com/eks/latest/APIReference/API_DeleteFargateProfile.html#API_DeleteFargateProfile_ResponseSyntax)
+ [https://docs.aws.amazon.com/eks/latest/APIReference/API_CreateNodegroup.html](https://docs.aws.amazon.com/eks/latest/APIReference/API_CreateNodegroup.html)
+ [Sintassi della richiesta](https://docs.aws.amazon.com/eks/latest/APIReference/API_CreateNodegroup.html#API_CreateNodegroup_RequestSyntax)
+ [Sintassi della risposta](https://docs.aws.amazon.com/eks/latest/APIReference/API_CreateNodegroup.html#API_CreateNodegroup_ResponseSyntax)
Amazon EKS utilizza ruoli collegati ai servizi che contengono le autorizzazioni richieste da Amazon EKS per chiamare altri servizi per tuo conto. Se questi ruoli collegati ai servizi non esistono già nel tuo account, devi aggiungere l'`iam:CreateServiceLinkedRole`autorizzazione al ruolo IAM utilizzato da Step Functions. Per ulteriori informazioni, consulta [Using Service-Linked Roles](https://docs.aws.amazon.com/eks/latest/userguide/using-service-linked-roles.html) nella *Amazon EKS User Guide*.
Il ruolo IAM utilizzato da Step Functions deve disporre `iam:PassRole` delle autorizzazioni per passare il ruolo IAM del nodo ad Amazon EKS. Per ulteriori informazioni, consulta [Using Service-Linked Roles](https://docs.aws.amazon.com/eks/latest/userguide/create-node-role.html) nella *Amazon EKS User Guide*.
+ [https://docs.aws.amazon.com/eks/latest/APIReference/API_DeleteNodegroup.html](https://docs.aws.amazon.com/eks/latest/APIReference/API_DeleteNodegroup.html)
+ [Sintassi della richiesta](https://docs.aws.amazon.com/eks/latest/APIReference/API_DeleteNodegroup.html#API_DeleteNodegroup_RequestSyntax)
+ [Sintassi della risposta](https://docs.aws.amazon.com/eks/latest/APIReference/API_DeleteNodegroup.html#API_DeleteNodegroup_ResponseSyntax)
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",
"Arguments": {
"Name": "MyCluster",
"ResourcesVpcConfig": {
"SubnetIds": [
"subnet-053e7c47012341234",
"subnet-027cfea4b12341234"
]
},
"RoleArn": "arn:aws:iam::account-id: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",
"Arguments": {
"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",
"Arguments": {
"ClusterName": "MyCluster",
"FargateProfileName": "MyFargateProfile",
"PodExecutionRoleArn": "arn:aws:iam::account-id: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",
"Arguments": {
"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",
"Arguments": {
"ClusterName": "MyCluster",
"NodegroupName": "MyNodegroup",
"NodeRole": "arn:aws:iam::account-id: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",
"Arguments": {
"ClusterName": "MyCluster",
"NodegroupName": "MyNodegroup"
},
"End": true
}
}
}
```
## Permissions
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](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) 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:masters`autorizzazione all'utente `arn:aws:iam::account-id:user/my-user` e al ruolo `arn:aws:iam::account-id:role/my-role` IAM.
```
{
"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
}
}
```
**Nota**
Potresti vedere l'ARN per un ruolo IAM visualizzato in un formato che include il percorso **/service-role/**, ad esempio. `arn:aws:iam::account-id:role/service-role/my-role` Questo token del percorso del **ruolo di servizio** non deve essere incluso nell'elenco del ruolo in. `aws-auth`
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 di`aws-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, consulta:
+ [Crea un kubeconfig per Amazon EKS nella Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html) User *Guide*.
+ [Gestione degli utenti o dei ruoli IAM per il tuo cluster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) nella *Amazon EKS User Guide*.
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"
}
```
## Politiche IAM per le chiamate ad Amazon EKS
I seguenti modelli di esempio mostrano come AWS Step Functions generare le politiche IAM in base alle risorse nella definizione della macchina a stati. Per ulteriori informazioni, consultare [In che modo Step Functions genera policy IAM per servizi integrati](service-integration-iam-templates.md) e [Scopri i modelli di integrazione dei servizi in Step Functions](connect-to-resource.md).
### `CreateCluster`
*Risorse*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"eks:CreateCluster"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"eks:DescribeCluster",
"eks:DeleteCluster"
],
"Resource": "arn:aws:eks:us-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:us-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:us-east-1:444455556666:cluster/ExampleCluster"
]
}
]
}
```
### `DeleteNodegroup`
*Risorse*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"eks:DeleteNodegroup",
"eks:DescribeNodegroup"
],
"Resource": [
"arn:aws:eks:us-east-1:444455556666:nodegroup/ExampleCluster/ExampleNodegroup/*"
]
}
]
}
```
Per ulteriori informazioni sull'uso di Amazon EKS con Step Functions, consulta[Crea e gestisci cluster Amazon EKS con Step Functions](#connect-eks).
# Crea e gestisci cluster Amazon EMR con Step Functions
Scopri come integrarti AWS Step Functions con Amazon EMR utilizzando l'integrazione del servizio Amazon EMR fornito. APIs L'integrazione APIs del servizio è simile a quella del corrispondente Amazon EMR APIs, con alcune differenze nei campi che vengono passati e nelle risposte restituite.
Per ulteriori informazioni sull'integrazione con AWS i servizi in Step Functions, vedere [Integrazione dei servizi ](integrate-services.md) e[Passaggio di parametri a un'API di servizio in Step Functions](connect-parameters.md).
**Caratteristiche principali dell'integrazione ottimizzata con Amazon EMR**
L'integrazione ottimizzata del servizio Amazon EMR dispone di un set personalizzato APIs che racchiude l'Amazon EMR APIs sottostante, descritto di seguito. Per questo motivo, si differenzia in modo significativo dall'integrazione del servizio SDK Amazon AWS EMR.
Il modello di [Esegui un processo (.sync)](connect-to-resource.md#connect-sync) integrazione è supportato.
Step Functions non termina automaticamente un cluster Amazon EMR se l'esecuzione viene interrotta. Se la macchina a stati si arresta prima della chiusura del cluster Amazon EMR, il cluster potrebbe continuare a funzionare a tempo indeterminato e potrebbe comportare costi aggiuntivi. Per evitare ciò, assicurati che tutti i cluster Amazon EMR che crei siano terminati correttamente. Per ulteriori informazioni, consulta:
+ [Controlla la terminazione del cluster](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-termination.html) nella Guida per l'utente di Amazon EMR.
+ La sezione Service Integration Patterns. [Esegui un processo (.sync)](connect-to-resource.md#connect-sync)
**Nota**
A partire da `emr-5.28.0` ora, puoi specificare il parametro `StepConcurrencyLevel` durante la creazione di un cluster per consentire l'esecuzione di più passaggi in parallelo su un singolo cluster. È possibile utilizzare Step Functions `Map` e `Parallel` gli stati per inviare il lavoro in parallelo al cluster.
La disponibilità dell'integrazione del servizio Amazon EMR è soggetta alla disponibilità di Amazon EMR. APIs Consulta la documentazione di [Amazon EMR](https://docs.aws.amazon.com//govcloud-us/latest/UserGuide/govcloud-emr.html) per le limitazioni nelle regioni speciali.
**Nota**
Per l'integrazione con Amazon EMR, Step Functions utilizza una frequenza di polling dei job codificata di 60 secondi per i primi 10 minuti e per i 300 secondi successivi.
## Amazon EMR ottimizzato APIs
La tabella seguente descrive le differenze tra ogni API di integrazione del servizio Amazon EMR e Amazon EMR corrispondente. APIs
| API di integrazione dei servizi Amazon EMR | API EMR corrispondente | Differenze |
| --- | --- | --- |
| createCluster Crea e avvia l'esecuzione di un cluster (flusso di lavoro). Amazon EMR è collegato direttamente a un tipo unico di ruolo IAM noto come ruolo collegato ai servizi. Perché `createCluster` e `createCluster.sync` funzionino, è necessario aver configurato le autorizzazioni necessarie per creare il ruolo collegato al servizio `AWSServiceRoleForEMRCleanup`. Per ulteriori informazioni su questo argomento, inclusa una dichiarazione che puoi aggiungere alla tua politica di autorizzazioni IAM, consulta [Using the Service-Linked Role for Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/using-service-linked-roles.html). | [runJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html) | createClusterutilizza la stessa sintassi di richiesta di [runJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html), ad eccezione di quanto segue: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/connect-emr.html)La risposta è: {
"ClusterId": "string"
} Amazon EMR utilizza questo: {
"JobFlowId": "string"
} |
| createCluster.sync Crea e avvia l'esecuzione di un cluster (flusso di lavoro). | [runJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html) | Lo stesso di createCluster, ma attende che il cluster raggiunga lo stato WAITING. |
| setClusterTerminationProtezione Blocca un cluster (flusso di lavoro) in modo che le EC2 istanze nel cluster non possano essere terminate dall'intervento dell'utente, da una chiamata API o da un errore del flusso di lavoro. | [setTerminationProtection](https://docs.aws.amazon.com/emr/latest/APIReference/API_SetTerminationProtection.html) | La richiesta utilizza questo:{
"ClusterId": "string"
} Amazon EMR utilizza questo:{
"JobFlowIds": ["string"]
} |
| terminateCluster Arresta un cluster (flusso di lavoro). | [terminateJobFlows](https://docs.aws.amazon.com/emr/latest/APIReference/API_TerminateJobFlows.html) | La richiesta utilizza questo:{
"ClusterId": "string"
} Amazon EMR utilizza questo:{
"JobFlowIds": ["string"]
} |
| terminateCluster.syncArresta un cluster (flusso di lavoro). | [terminateJobFlows](https://docs.aws.amazon.com/emr/latest/APIReference/API_TerminateJobFlows.html) | Lo stesso di terminateCluster, ma attende che il cluster venga terminato. |
| addStep Aggiunge un nuovo passaggio a un cluster in esecuzione. Facoltativamente, puoi anche specificare il `[ExecutionRoleArn](https://docs.aws.amazon.com/emr/latest/APIReference/API_AddJobFlowSteps.html#EMR-AddJobFlowSteps-request-ExecutionRoleArn)` parametro durante l'utilizzo di questa API. | [addJobFlowFasi](https://docs.aws.amazon.com/emr/latest/APIReference/API_AddJobFlowSteps.html) | La richiesta utilizza la chiave"ClusterId". Usi di Amazon EMR. "JobFlowId" La richiesta utilizza un singolo passaggio.{
"Step": <"StepConfig object">
} Amazon EMR utilizza questo:{
"Steps": []
} La risposta è:{
"StepId": "string"
} Amazon EMR restituisce questo:{
"StepIds": []
} |
| addStep.sync Aggiunge un nuovo passaggio a un cluster in esecuzione. Facoltativamente, puoi anche specificare il `[ExecutionRoleArn](https://docs.aws.amazon.com/emr/latest/APIReference/API_AddJobFlowSteps.html#EMR-AddJobFlowSteps-request-ExecutionRoleArn)` parametro durante l'utilizzo di questa API. | [addJobFlowFasi](https://docs.aws.amazon.com/emr/latest/APIReference/API_AddJobFlowSteps.html) | Come addStep, ma attende il completamento del passaggio. |
| cancelStep Annulla un passaggio in sospeso in un cluster in esecuzione. | [cancelSteps](https://docs.aws.amazon.com/emr/latest/APIReference/API_CancelSteps.html) | La richiesta utilizza questo:{
"StepId": "string"
} Amazon EMR utilizza questo:{
"StepIds": []
} La risposta è:{
"CancelStepsInfo":
} Amazon EMR utilizza questo:{
"CancelStepsInfoList": []
} |
| modifyInstanceFleetByName Modifica le capacità Spot target e on demand per il parco di istanze con il `InstanceFleetName` specificato. | [modifyInstanceFleet](https://docs.aws.amazon.com/emr/latest/APIReference/API_ModifyInstanceFleet.html) | La richiesta è la stessa di quella di modifyInstanceFleet, ad eccezione di quanto segue: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/connect-emr.html) |
| modifyInstanceGroupByName Modifica il numero di nodi e le impostazioni di configurazione di un gruppo di istanze. | [modifyInstanceGroups](https://docs.aws.amazon.com/emr/latest/APIReference/API_ModifyInstanceGroups.html) | La richiesta è questa:{
"ClusterId": "string",
"InstanceGroup":
} Amazon EMR utilizza un elenco: {
"ClusterId": ["string"],
"InstanceGroups": []
} All'interno dell'oggetto `InstanceGroupModifyConfig` il campo `InstanceGroupId` non è consentito. È stato aggiunto un nuovo campo, `InstanceGroupName`. In fase di esecuzione `InstanceGroupId` viene determinato automaticamente dall'integrazione del servizio chiamando `ListInstanceGroups` e analizzando il risultato. |
## Esempio di workflow
L'esempio seguente include uno stato `Task` che crea un cluster.
```
"Create_Cluster": {
"Type": "Task",
"Resource": "arn:aws:states:::elasticmapreduce:createCluster.sync",
"Arguments": {
"Name": "MyWorkflowCluster",
"VisibleToAllUsers": true,
"ReleaseLabel": "emr-5.28.0",
"Applications": [
{
"Name": "Hive"
}
],
"ServiceRole": "EMR_DefaultRole",
"JobFlowRole": "EMR_EC2_DefaultRole",
"LogUri": "s3n://aws-logs-account-id-us-east-1/elasticmapreduce/",
"Instances": {
"KeepJobFlowAliveWhenNoSteps": true,
"InstanceFleets": [
{
"InstanceFleetType": "MASTER",
"Name": "MASTER",
"TargetOnDemandCapacity": 1,
"InstanceTypeConfigs": [
{
"InstanceType": "m4.xlarge"
}
]
},
{
"InstanceFleetType": "CORE",
"Name": "CORE",
"TargetOnDemandCapacity": 1,
"InstanceTypeConfigs": [
{
"InstanceType": "m4.xlarge"
}
]
}
]
}
},
"End": true
}
```
Di seguito è riportato uno stato `Task` che consente la protezione di terminazione.
```
"Enable_Termination_Protection": {
"Type": "Task",
"Resource": "arn:aws:states:::elasticmapreduce:setClusterTerminationProtection",
"Arguments": {
"ClusterId": "{% $ClusterId %}",
"TerminationProtected": true
},
"End": true
}
```
Di seguito è riportato uno stato `Task` che invia un passaggio a un cluster.
```
"Step_One": {
"Type": "Task",
"Resource": "arn:aws:states:::elasticmapreduce:addStep.sync",
"Arguments": {
"ClusterId": "{% $ClusterId %}",
"ExecutionRoleArn": "arn:aws:iam::account-id:role/myEMR-execution-role",
"Step": {
"Name": "The first step",
"ActionOnFailure": "TERMINATE_CLUSTER",
"HadoopJarStep": {
"Jar": "command-runner.jar",
"Args": [
"hive-script",
"--run-hive-script",
"--args",
"-f",
"s3://region.elasticmapreduce.samples/cloudfront/code/Hive_CloudFront.q",
"-d",
"INPUT=s3://region.elasticmapreduce.samples",
"-d",
"OUTPUT=s3:///MyHiveQueryResults/"
]
}
}
},
"End": true
}
```
Di seguito è riportato uno stato `Task` che annulla un passaggio.
```
"Cancel_Step_One": {
"Type": "Task",
"Resource": "arn:aws:states:::elasticmapreduce:cancelStep",
"Arguments": {
"ClusterId": "{% $ClusterId %}",
"StepId": "{% $AddStepsResult.StepId %}"
},
"End": true
}
```
Di seguito è riportato uno stato `Task` che termina un cluster.
```
"Terminate_Cluster": {
"Type": "Task",
"Resource": "arn:aws:states:::elasticmapreduce:terminateCluster.sync",
"Arguments": {
"ClusterId": "{% $ClusterId %}",
},
"End": true
}
```
Di seguito è riportato uno stato `Task` che consente di scalare un cluster verso l'alto o verso il basso per un gruppo di istanze.
```
"ModifyInstanceGroupByName": {
"Type": "Task",
"Resource": "arn:aws:states:::elasticmapreduce:modifyInstanceGroupByName",
"Arguments": {
"ClusterId": "j-account-id3",
"InstanceGroupName": "MyCoreGroup",
"InstanceGroup": {
"InstanceCount": 8
}
},
"End": true
}
```
Di seguito è riportato uno stato `Task` che consente di scalare un cluster verso l'alto o verso il basso per un parco di istanze.
```
"ModifyInstanceFleetByName": {
"Type": "Task",
"Resource": "arn:aws:states:::elasticmapreduce:modifyInstanceFleetByName",
"Arguments": {
"ClusterId": "j-account-id3",
"InstanceFleetName": "MyCoreFleet",
"InstanceFleet": {
"TargetOnDemandCapacity": 8,
"TargetSpotCapacity": 0
}
},
"End": true
}
```
## Politiche IAM per le chiamate ad Amazon EMR
I seguenti modelli di esempio mostrano come AWS Step Functions generare le politiche IAM in base alle risorse nella definizione della macchina a stati. Per ulteriori informazioni, consultare [In che modo Step Functions genera policy IAM per servizi integrati](service-integration-iam-templates.md) e [Scopri i modelli di integrazione dei servizi in Step Functions](connect-to-resource.md).
### `addStep`
*Risorse statiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticmapreduce:AddJobFlowSteps",
"elasticmapreduce:DescribeStep",
"elasticmapreduce:CancelSteps"
],
"Resource": [
"arn:aws:elasticmapreduce:us-east-1:123456789012:cluster/clusterId"
]
}
]
}
```
*Risorse dinamiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticmapreduce:AddJobFlowSteps",
"elasticmapreduce:DescribeStep",
"elasticmapreduce:CancelSteps"
],
"Resource": "arn:aws:elasticmapreduce:*:*:cluster/*"
}
]
}
```
### `cancelStep`
*Risorse statiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "elasticmapreduce:CancelSteps",
"Resource": [
"arn:aws:elasticmapreduce:us-east-1:123456789012:cluster/myCluster-id"
]
}
]
}
```
*Risorse dinamiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "elasticmapreduce:CancelSteps",
"Resource": "arn:aws:elasticmapreduce:*:*:cluster/*"
}
]
}
```
### `createCluster`
*Risorse statiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticmapreduce:RunJobFlow",
"elasticmapreduce:DescribeCluster",
"elasticmapreduce:TerminateJobFlows"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": [
"arn:aws:iam::123456789012:role/myRoleName"
]
}
]
}
```
### `setClusterTerminationProtection`
*Risorse statiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "elasticmapreduce:SetTerminationProtection",
"Resource": [
"arn:aws:elasticmapreduce:us-east-1:123456789012:cluster/myCluster-id"
]
}
]
}
```
*Risorse dinamiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "elasticmapreduce:SetTerminationProtection",
"Resource": "arn:aws:elasticmapreduce:*:*:cluster/*"
}
]
}
```
### `modifyInstanceFleetByName`
*Risorse statiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticmapreduce:ModifyInstanceFleet",
"elasticmapreduce:ListInstanceFleets"
],
"Resource": [
"arn:aws:elasticmapreduce:us-east-1:123456789012:cluster/myCluster-id"
]
}
]
}
```
*Risorse dinamiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticmapreduce:ModifyInstanceFleet",
"elasticmapreduce:ListInstanceFleets"
],
"Resource": "arn:aws:elasticmapreduce:*:*:cluster/*"
}
]
}
```
### `modifyInstanceGroupByName`
*Risorse statiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticmapreduce:ModifyInstanceGroups",
"elasticmapreduce:ListInstanceGroups"
],
"Resource": [
"arn:aws:elasticmapreduce:us-east-1:123456789012:cluster/myCluster-id"
]
}
]
}
```
*Risorse dinamiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticmapreduce:ModifyInstanceGroups",
"elasticmapreduce:ListInstanceGroups"
],
"Resource": "*"
}
]
}
```
### `terminateCluster`
*Risorse statiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticmapreduce:TerminateJobFlows",
"elasticmapreduce:DescribeCluster"
],
"Resource": [
"arn:aws:elasticmapreduce:us-east-1:123456789012:cluster/myCluster-id"
]
}
]
}
```
*Risorse dinamiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticmapreduce:TerminateJobFlows",
"elasticmapreduce:DescribeCluster"
],
"Resource": "arn:aws:elasticmapreduce:*:*:cluster/*"
}
]
}
```
# Crea e gestisci cluster Amazon EMR su EKS con AWS Step Functions
Scopri come effettuare l'integrazione AWS Step Functions con Amazon EMR su EKS utilizzando l'integrazione dei servizi Amazon EMR su EKS. APIs L'integrazione dei APIs servizi è la stessa del corrispondente Amazon EMR su EKS APIs, ma non tutti APIs supportano tutti i modelli di integrazione, come mostrato nella tabella seguente.
Per ulteriori informazioni sull'integrazione con AWS i servizi in Step Functions, vedere [Integrazione dei servizi ](integrate-services.md) e[Passaggio di parametri a un'API di servizio in Step Functions](connect-parameters.md).
**In che modo l'integrazione ottimizzata di Amazon EMR su EKS è diversa dall'integrazione Amazon EMR su EKS SDK AWS**
Il modello di [Esegui un processo (.sync)](connect-to-resource.md#connect-sync) integrazione è supportato.
Non esistono ottimizzazioni specifiche per il modello di [Richiesta e risposta](connect-to-resource.md#connect-default) integrazione.
Il modello di [Attendi una richiamata con Task Token](connect-to-resource.md#connect-wait-token) integrazione non è supportato.
**Nota**
Per l'integrazione con Amazon EMR, Step Functions utilizza una frequenza di polling dei job codificata di 60 secondi per i primi 10 minuti e per i 300 secondi successivi.
| "Hello, World\$1" | Richiesta di risposta | Esegui un lavoro (.sync) |
| --- | --- | --- |
| CreateVirtualCluster | Supportata | Non supportato |
| DeleteVirtualCluster | Supportato | Supportato |
| StartJobRun | Supportato | Supportata |
Amazon EMR supportato su EKS: APIs
**Quota per i dati di input o di risultato**
Quando si inviano o si ricevono dati tra servizi, l'input o il risultato massimo per un'attività è di 256 KB di dati come stringa con codifica UTF-8. Per informazioni, consulta [Quote relative alle esecuzioni di macchine a stati](service-quotas.md#service-limits-state-machine-executions).
+ [https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_CreateVirtualCluster.html](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_CreateVirtualCluster.html)
+ [Sintassi della richiesta](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_CreateVirtualCluster.html#API_CreateVirtualCluster_RequestSyntax)
+ [Parametri supportati](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_CreateVirtualCluster.html#API_CreateVirtualCluster_RequestBody)
+ [Sintassi della risposta](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_CreateVirtualCluster.html#API_CreateVirtualCluster_ResponseSyntax)
+ [https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_DeleteVirtualCluster.html](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_DeleteVirtualCluster.html)
+ [Sintassi della richiesta](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_DeleteVirtualCluster.html#API_DeleteVirtualCluster_RequestSyntax)
+ [Parametri supportati](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_DeleteVirtualCluster.html#API_DeleteVirtualCluster_RequestParameters)
+ [Sintassi della risposta](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_CreateVirtualCluster.html#API_CreateVirtualCluster_ResponseSyntax)
+ [https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_StartJobRun.html](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_StartJobRun.html)
+ [Sintassi della richiesta](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_StartJobRun.html#API_StartJobRun_RequestSyntax)
+ [Parametri supportati](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_StartJobRun.html#API_StartJobRun_RequestParameters)
+ [Sintassi della risposta](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_StartJobRun.html#API_StartJobRun_ResponseSyntax)
Quanto segue include uno `Task` stato che crea un cluster virtuale.
```
"Create_Virtual_Cluster": {
"Type": "Task",
"Resource": "arn:aws:states:::emr-containers:createVirtualCluster",
"Arguments": {
"Name": "MyVirtualCluster",
"ContainerProvider": {
"Id": "EKSClusterName",
"Type": "EKS",
"Info": {
"EksInfo": {
"Namespace": "Namespace"
}
}
}
},
"End": true
}
```
Quanto segue include uno `Task` stato che invia un processo a un cluster virtuale e attende che venga completato.
```
"Submit_Job": {
"Type": "Task",
"Resource": "arn:aws:states:::emr-containers:startJobRun.sync",
"Arguments": {
"Name": "MyJobName",
"VirtualClusterId": "{% $VirtualClusterId %}",
"ExecutionRoleArn": "arn:aws:iam:::role/job-execution-role",
"ReleaseLabel": "emr-6.2.0-latest",
"JobDriver": {
"SparkSubmitJobDriver": {
"EntryPoint": "s3:///jobs/trip-count.py",
"EntryPointArguments": [
"60"
],
"SparkSubmitParameters": "--conf spark.driver.cores=2 --conf spark.executor.instances=10 --conf spark.kubernetes.pyspark.pythonVersion=3 --conf spark.executor.memory=10G --conf spark.driver.memory=10G --conf spark.executor.cores=1 --conf spark.dynamicAllocation.enabled=false"
}
},
"ConfigurationOverrides": {
"ApplicationConfiguration": [
{
"Classification": "spark-defaults",
"Properties": {
"spark.executor.instances": "2",
"spark.executor.memory": "2G"
}
}
],
"MonitoringConfiguration": {
"PersistentAppUI": "ENABLED",
"CloudWatchMonitoringConfiguration": {
"LogGroupName": "MyLogGroupName",
"LogStreamNamePrefix": "MyLogStreamNamePrefix"
},
"S3MonitoringConfiguration": {
"LogUri": "s3://"
}
}
},
"Tags": {
"taskType": "jobName"
}
},
"End": true
}
```
Quanto segue include uno `Task` stato che elimina un cluster virtuale e attende il completamento dell'eliminazione.
```
"Delete_Virtual_Cluster": {
"Type": "Task",
"Resource": "arn:aws:states:::emr-containers:deleteVirtualCluster.sync",
"Arguments": {
"Id": "{% $states.input.VirtualClusterId %}",
},
"End": true
}
```
Per ulteriori informazioni sulla configurazione delle IAM autorizzazioni durante l'utilizzo Step Functions con altri AWS servizi, consulta. [In che modo Step Functions genera policy IAM per servizi integrati](service-integration-iam-templates.md)
# Crea e gestisci Amazon EMR Serverless applicazioni con Step Functions
Scopri come creare, avviare, interrompere ed eliminare applicazioni su EMR Serverless utilizzando Step Functions. Questa pagina elenca gli `Task` stati supportati APIs e fornisce esempi per eseguire casi d'uso comuni.
Per ulteriori informazioni sull'integrazione con AWS i servizi in Step Functions, vedere [Integrazione dei servizi ](integrate-services.md) e[Passaggio di parametri a un'API di servizio in Step Functions](connect-parameters.md).
**Caratteristiche principali dell'integrazione ottimizzata EMR Serverless**
L'integrazione ottimizzata dei EMR Serverless servizi dispone di un set personalizzato [APIs](#connect-emr-serverless-custom-apis)che racchiude le funzionalità sottostanti EMR Serverless APIs. Grazie a questa personalizzazione, l'EMR Serverlessintegrazione ottimizzata differisce in modo significativo dall'integrazione del servizio AWS SDK.
Inoltre, l'EMR Serverlessintegrazione ottimizzata supporta [Esegui un processo (.sync)](connect-to-resource.md#connect-sync) il modello di integrazione.
Il modello di [Attendi una richiamata con Task Token](connect-to-resource.md#connect-wait-token) integrazione **non** è supportato.
## EMR Serverlessintegrazione del servizio APIs
Per l'integrazione AWS Step Functions conEMR Serverless, è possibile utilizzare i seguenti sei EMR Serverless servizi di integrazione APIs. Queste integrazioni di servizi APIs sono simili a quelle corrispondenti EMR Serverless APIs, con alcune differenze nei campi passati e nelle risposte restituite.
La tabella seguente descrive le differenze tra ogni API EMR Serverless di integrazione dei servizi e l'EMR ServerlessAPI corrispondente.
| EMR ServerlessAPI di integrazione dei servizi | EMR ServerlessAPI corrispondente | Differenze |
| --- | --- | --- |
| *Crea applicazione* Crea un’applicazione . EMR Serverlessè collegato a un tipo di IAM ruolo univoco noto come ruolo collegato al servizio. Perché `createApplication` e `createApplication.sync` funzionino, è necessario aver configurato le autorizzazioni necessarie per creare il ruolo collegato al servizio `AWSServiceRoleForAmazonEMRServerless`. Per ulteriori informazioni su questo argomento, inclusa una dichiarazione che puoi aggiungere alla tua politica di IAM autorizzazioni, vedi [Utilizzo di ruoli collegati al servizio](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/using-service-linked-roles.html) per. EMR Serverless | [CreateApplication](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_CreateApplication.html) | Nessuno |
| *CreateApplication.sync* Crea un’applicazione . | [CreateApplication](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_CreateApplication.html) | Nessuna differenza tra le richieste e le risposte dell'API e dell'EMR ServerlessAPI di integrazione dei servizi. EMR Serverless Tuttavia, *CreateApplication.sync* attende che l'applicazione raggiunga lo stato. `CREATED` |
| *Avvia l'applicazione* Avvia un'applicazione specificata e inizializza la capacità iniziale dell'applicazione, se configurata. | [StartApplication](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_StartApplication.html) | La risposta dell'EMR ServerlessAPI non contiene dati, ma la risposta dell'API EMR Serverless di integrazione del servizio include i seguenti dati. {
"ApplicationId": "string"
} |
| *Avvia Application.sync* Avvia un'applicazione specificata e inizializza la capacità iniziale, se configurata. | [StartApplication](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_StartApplication.html) | La risposta dell'EMR ServerlessAPI non contiene dati, ma la risposta dell'API EMR Serverless di integrazione del servizio include i seguenti dati. {
"ApplicationId": "string"
} Inoltre, *StartApplication.sync* attende che l'applicazione raggiunga lo stato. `STARTED` |
| *Arresta l'applicazione* Arresta un'applicazione specificata e rilascia la capacità iniziale, se configurata. Tutti i processi pianificati e in esecuzione devono essere completati o annullati prima di interrompere un'applicazione. | [StopApplication](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_StopApplication.html) | La risposta dell'EMR ServerlessAPI non contiene dati, ma la risposta dell'API EMR Serverless di integrazione del servizio include i seguenti dati. {
"ApplicationId": "string"
} |
| *Arresta Application.sync* Arresta un'applicazione specificata e rilascia la capacità iniziale, se configurata. Tutti i processi pianificati e in esecuzione devono essere completati o annullati prima di interrompere un'applicazione. | [StopApplication](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_StopApplication.html) | La risposta dell'EMR ServerlessAPI non contiene dati, ma la risposta dell'API EMR Serverless di integrazione del servizio include i seguenti dati. {
"ApplicationId": "string"
} Inoltre, *StopApplication.sync* attende che l'applicazione raggiunga lo stato. `STOPPED` |
| *Elimina applicazione* Elimina un'applicazione. Un'applicazione deve trovarsi nello `CREATED` stato `STOPPED` o per poter essere eliminata. | [DeleteApplication](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_DeleteApplication.html) | La risposta dell'EMR ServerlessAPI non contiene dati, ma la risposta dell'API di integrazione del EMR Serverless servizio include i seguenti dati. {
"ApplicationId": "string"
} |
| *Elimina Application.sync* Elimina un'applicazione. Un'applicazione deve trovarsi nello `CREATED` stato `STOPPED` o per poter essere eliminata. | [DeleteApplication](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_DeleteApplication.html) | La risposta dell'EMR ServerlessAPI non contiene dati, ma la risposta dell'API di integrazione del EMR Serverless servizio include i seguenti dati. {
"ApplicationId": "string"
} Inoltre, *StopApplication.sync* attende che l'applicazione raggiunga lo stato. `TERMINATED` |
| *startJobRun* Avvia l'esecuzione di un processo. | [StartJobRun](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_StartJobRun.html) | Nessuno |
| *startJobRun.sync* Avvia l'esecuzione di un processo. | [StartJobRun](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_StartJobRun.html) | Nessuna differenza tra le richieste e le risposte dell'EMR ServerlessAPI e dell'API EMR Serverless di integrazione dei servizi. Tuttavia, *startJobRun.sync* attende che l'applicazione raggiunga lo `SUCCESS` stato. |
| *cancelJobRun* Annulla l'esecuzione di un processo. | [CancelJobRun](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_CancelJobRun.html) | Nessuno |
| *cancelJobRun.sync* Annulla l'esecuzione di un processo. | [CancelJobRun](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_CancelJobRun.html) | Nessuna differenza tra le richieste e le risposte dell'EMR ServerlessAPI e dell'API di integrazione dei EMR Serverless servizi. Tuttavia, *cancelJobRun.sync* attende che l'applicazione raggiunga lo `CANCELLED` stato. |
## Casi d'uso dell'integrazione EMR Serverless
Per l'integrazione ottimizzata dei EMR Serverless servizi, si consiglia di creare una singola applicazione e quindi di utilizzarla per eseguire più processi. Ad esempio, in una macchina a stato singolo, è possibile includere più [startJobRun](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_StartJobRun.html)richieste, che utilizzano tutte la stessa applicazione. I seguenti esempi di [Stato del flusso di lavoro delle attività](state-task.md) stato mostrano i casi d'uso EMR Serverless APIs con cui eseguire l'integrazioneStep Functions. Per informazioni su altri casi d'uso diEMR Serverless, vedere [What is Amazon EMR Serverless](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/emr-serverless.html).
**Suggerimento**
Per distribuire un esempio di macchina a stati che si integra con EMR Serverless per l'esecuzione di più lavori;, vedere. [Esegui un EMR Serverless lavoro](sample-emr-serverless-job.md)
+ [Creazione di un'applicazione](#connect-emr-serverless-task-state-createapp)
+ [Avviare un'applicazione](#connect-emr-serverless-task-state-startapp)
+ [Arresta un'applicazione](#connect-emr-serverless-task-state-stopapp)
+ [Eliminazione di un'applicazione](#connect-emr-serverless-task-state-deleteapp)
+ [Avviare un processo in un'applicazione](#connect-emr-serverless-task-state-startjobrun)
+ [Annullare un lavoro in un'applicazione](#connect-emr-serverless-task-state-canceljobrun)
Per ulteriori informazioni sulla configurazione delle IAM autorizzazioni durante l'utilizzo Step Functions con altri AWS servizi, consulta. [In che modo Step Functions genera policy IAM per servizi integrati](service-integration-iam-templates.md)
Negli esempi mostrati nei seguenti casi d'uso, sostituisci il *italicized* testo con informazioni specifiche sulla risorsa. Ad esempio, sostituiscilo *yourApplicationId* con l'ID della tua EMR Serverless applicazione, ad esempio. `00yv7iv71inak893`
### Creazione di un'applicazione
Il seguente esempio di stato Task crea un'applicazione utilizzando l'API di integrazione del *servizio CreateApplication.sync.*
```
"Create_Application": {
"Type": "Task",
"Resource": "arn:aws:states:::emr-serverless:createApplication.sync",
"Arguments": {
"Name": "MyApplication",
"ReleaseLabel": "emr-6.9.0",
"Type": "SPARK"
},
"End": true
}
```
### Avviare un'applicazione
Il seguente esempio di stato Task avvia un'applicazione utilizzando l'API di integrazione del *servizio StartApplication.sync.*
```
"Start_Application": {
"Type": "Task",
"Resource": "arn:aws:states:::emr-serverless:startApplication.sync",
"Arguments": {
"ApplicationId": "yourApplicationId"
},
"End": true
}
```
### Arresta un'applicazione
Il seguente esempio di stato Task interrompe un'applicazione utilizzando l'API di integrazione del *servizio StopApplication.sync.*
```
"Stop_Application": {
"Type": "Task",
"Resource": "arn:aws:states:::emr-serverless:stopApplication.sync",
"Arguments": {
"ApplicationId": "yourApplicationId"
},
"End": true
}
```
### Eliminazione di un'applicazione
*Il seguente esempio di stato Task elimina un'applicazione utilizzando l'API di integrazione del servizio DeleteApplication.sync.*
```
"Delete_Application": {
"Type": "Task",
"Resource": "arn:aws:states:::emr-serverless:deleteApplication.sync",
"Arguments": {
"ApplicationId": "yourApplicationId"
},
"End": true
}
```
### Avviare un processo in un'applicazione
Il seguente esempio di stato Task avvia un processo in un'applicazione utilizzando l'API di integrazione del servizio *startJobRun.sync.*
```
"Start_Job": {
"Type": "Task",
"Resource": "arn:aws:states:::emr-serverless:startJobRun.sync",
"Arguments": {
"ApplicationId": "yourApplicationId",
"ExecutionRoleArn": "arn:aws:iam::account-id:role/myEMRServerless-execution-role",
"JobDriver": {
"SparkSubmit": {
"EntryPoint": "s3:///sample.py",
"EntryPointArguments": ["1"],
"SparkSubmitParameters": "--conf spark.executor.cores=4 --conf spark.executor.memory=4g --conf spark.driver.cores=2 --conf spark.driver.memory=4g --conf spark.executor.instances=1"
}
}
},
"End": true
}
```
### Annullare un lavoro in un'applicazione
Il seguente esempio di stato Task annulla un processo in un'applicazione utilizzando l'API di integrazione del servizio *cancelJobRun.sync.*
```
"Cancel_Job": {
"Type": "Task",
"Resource": "arn:aws:states:::emr-serverless:cancelJobRun.sync",
"Arguments": {
"ApplicationId": "{% $states.input.ApplicationId %}",
"JobRunId": "{% $states.input.JobRunId %}"
},
"End": true
}
```
## Politiche IAM per le chiamate Amazon EMR Serverless
Quando crei una macchina a stati utilizzando la console, crea Step Functions automaticamente un ruolo di esecuzione per la tua macchina a stati con i privilegi minimi richiesti. Questi IAM ruoli generati automaticamente sono validi per il momento Regione AWS in cui si crea la macchina a stati.
I seguenti modelli di esempio mostrano come AWS Step Functions generare le politiche IAM in base alle risorse nella definizione della macchina a stati. Per ulteriori informazioni, consultare [In che modo Step Functions genera policy IAM per servizi integrati](service-integration-iam-templates.md) e [Scopri i modelli di integrazione dei servizi in Step Functions](connect-to-resource.md).
Quando crei delle IAM policy, ti consigliamo di non includere caratteri jolly nelle policy. Come best practice in materia di sicurezza, è consigliabile limitare il più possibile le policy. È consigliabile utilizzare politiche dinamiche solo quando determinati parametri di input non sono noti durante il runtime.
Inoltre, gli utenti amministratori devono prestare attenzione quando concedono a utenti non amministratori ruoli di esecuzione per l'esecuzione delle macchine a stati. Ti consigliamo di includere le politiche PassRole nei ruoli di esecuzione se stai creando politiche da solo. Ti consigliamo inoltre di aggiungere le chiavi `aws:SourceARN` e di `aws:SourceAccount` contesto nei ruoli di esecuzione.
### Esempi di policy IAM per l'integrazione EMR Serverless con Step Functions
+ [Esempio di policy IAM per CreateApplication](#emr-serverless-policy-createapp)
+ [Esempio di policy IAM per StartApplication](#emr-serverless-policy-startapp)
+ [Esempio di policy IAM per StopApplication](#emr-serverless-policy-stopapp)
+ [Esempio di policy IAM per DeleteApplication](#emr-serverless-policy-deleteapp)
+ [Esempio di policy IAM per StartJobRun](#emr-serverless-policy-startjobrun)
+ [Esempio di policy IAM per CancelJobRun](#emr-serverless-policy-canceljobrun)
#### Esempio di policy IAM per CreateApplication
Di seguito è riportato un esempio di policy IAM per una macchina a stati con uno CreateApplication [Stato del flusso di lavoro delle attività](state-task.md) stato.
**Nota**
È necessario specificare le CreateServiceLinkedRole autorizzazioni nelle politiche IAM durante la creazione della prima applicazione in assoluto nel proprio account. Successivamente, non è necessario aggiungere questa autorizzazione. Per informazioni su CreateServiceLinkedRole, vedere [CreateServiceLinkedRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateServiceLinkedRole.html)nella versione più https://docs.aws.amazon.com/IAM/ APIReference recente/ /.
Le risorse statiche e dinamiche per le seguenti politiche sono le stesse.
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:CreateApplication"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/*"
]
},
{
"Effect": "Allow",
"Action": [
"emr-serverless:GetApplication",
"emr-serverless:DeleteApplication"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/*"
]
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForEMRServerlessApplicationRule"
]
},
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::123456789012:role/aws-service-role/ops.emr-serverless.amazonaws.com/AWSServiceRoleForAmazonEMRServerless*",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "ops.emr-serverless.amazonaws.com"
}
}
}
]
}
```
------
#### [ Request Response ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:CreateApplication"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/*"
]
},
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::123456789012:role/aws-service-role/ops.emr-serverless.amazonaws.com/AWSServiceRoleForAmazonEMRServerless*",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "ops.emr-serverless.amazonaws.com"
}
}
}
]
}
```
------
#### Esempio di policy IAM per StartApplication
**Risorse statiche**
Di seguito sono riportati esempi di policy IAM per risorse statiche quando si utilizza una macchina a stati con uno StartApplication [Stato del flusso di lavoro delle attività](state-task.md) stato.
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:StartApplication",
"emr-serverless:GetApplication",
"emr-serverless:StopApplication"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/applicationId"
]
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForEMRServerlessApplicationRule"
]
}
]
}
```
------
#### [ Request Response ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:StartApplication"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/applicationId"
]
}
]
}
```
------
**Risorse dinamiche**
Di seguito sono riportati alcuni esempi di policy IAM per risorse dinamiche quando si utilizza una macchina a stati con uno StartApplication [Stato del flusso di lavoro delle attività](state-task.md) stato.
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:StartApplication",
"emr-serverless:GetApplication",
"emr-serverless:StopApplication"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/*"
]
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForEMRServerlessApplicationRule"
]
}
]
}
```
------
#### [ Request Response ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:StartApplication"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/*"
]
}
]
}
```
------
#### Esempio di policy IAM per StopApplication
**Risorse statiche**
Di seguito sono riportati esempi di policy IAM per risorse statiche quando si utilizza una macchina a stati con uno StopApplication [Stato del flusso di lavoro delle attività](state-task.md) stato.
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:StopApplication",
"emr-serverless:GetApplication"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/applicationId"
]
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForEMRServerlessApplicationRule"
]
}
]
}
```
------
#### [ Request Response ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:StopApplication"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/applicationId"
]
}
]
}
```
------
**Risorse dinamiche**
Di seguito sono riportati alcuni esempi di policy IAM per risorse dinamiche quando si utilizza una macchina a stati con uno StopApplication [Stato del flusso di lavoro delle attività](state-task.md) stato.
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:StopApplication",
"emr-serverless:GetApplication"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/*"
]
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForEMRServerlessApplicationRule"
]
}
]
}
```
------
#### [ Request Response ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:StopApplication"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/*"
]
}
]
}
```
------
#### Esempio di policy IAM per DeleteApplication
**Risorse statiche**
Di seguito sono riportati esempi di policy IAM per risorse statiche quando si utilizza una macchina a stati con uno DeleteApplication [Stato del flusso di lavoro delle attività](state-task.md) stato.
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:DeleteApplication",
"emr-serverless:GetApplication"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/applicationId"
]
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForEMRServerlessApplicationRule"
]
}
]
}
```
------
#### [ Request Response ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:DeleteApplication"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/applicationId"
]
}
]
}
```
------
**Risorse dinamiche**
Di seguito sono riportati alcuni esempi di policy IAM per risorse dinamiche quando si utilizza una macchina a stati con uno DeleteApplication [Stato del flusso di lavoro delle attività](state-task.md) stato.
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:DeleteApplication",
"emr-serverless:GetApplication"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/*"
]
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForEMRServerlessApplicationRule"
]
}
]
}
```
------
#### [ Request Response ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:DeleteApplication"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/*"
]
}
]
}
```
------
#### Esempio di policy IAM per StartJobRun
**Risorse statiche**
Di seguito sono riportati esempi di policy IAM per risorse statiche quando si utilizza una macchina a stati con uno StartJobRun [Stato del flusso di lavoro delle attività](state-task.md) stato.
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:StartJobRun"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/applicationId"
]
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": [
"arn:aws:iam::123456789012:role/jobExecutionRoleArn"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "emr-serverless.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Action": [
"emr-serverless:GetJobRun",
"emr-serverless:CancelJobRun"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/applicationId/jobruns/*"
]
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForEMRServerlessJobRule"
]
}
]
}
```
------
#### [ Request Response ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:StartJobRun"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/applicationId"
]
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": [
"arn:aws:iam::123456789012:role/jobExecutionRoleArn"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "emr-serverless.amazonaws.com"
}
}
}
]
}
```
------
**Risorse dinamiche**
Di seguito sono riportati alcuni esempi di policy IAM per risorse dinamiche quando si utilizza una macchina a stati con uno StartJobRun [Stato del flusso di lavoro delle attività](state-task.md) stato.
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:StartJobRun",
"emr-serverless:GetJobRun",
"emr-serverless:CancelJobRun"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/*"
]
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": [
"arn:aws:iam::123456789012:role/jobExecutionRoleArn"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "emr-serverless.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForEMRServerlessJobRule"
]
}
]
}
```
------
#### [ Request Response ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:StartJobRun"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/*"
]
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": [
"arn:aws:iam::123456789012:role/jobExecutionRoleArn"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "emr-serverless.amazonaws.com"
}
}
}
]
}
```
------
#### Esempio di policy IAM per CancelJobRun
**Risorse statiche**
Di seguito sono riportati esempi di policy IAM per risorse statiche quando si utilizza una macchina a stati con uno CancelJobRun [Stato del flusso di lavoro delle attività](state-task.md) stato.
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:CancelJobRun",
"emr-serverless:GetJobRun"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/applicationId/jobruns/jobRunId"
]
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForEMRServerlessJobRule"
]
}
]
}
```
------
#### [ Request Response ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:CancelJobRun"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/applicationId/jobruns/jobRunId"
]
}
]
}
```
------
**Risorse dinamiche**
Di seguito sono riportati alcuni esempi di policy IAM per risorse dinamiche quando si utilizza una macchina a stati con uno CancelJobRun [Stato del flusso di lavoro delle attività](state-task.md) stato.
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:CancelJobRun",
"emr-serverless:GetJobRun"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/*"
]
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForEMRServerlessJobRule"
]
}
]
}
```
------
#### [ Request Response ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:CancelJobRun"
],
"Resource": [
"arn:aws:emr-serverless:us-east-1:123456789012:/applications/*"
]
}
]
}
```
------
# Aggiungi EventBridge eventi con Step Functions
Step Functions fornisce un'API di integrazione dei servizi per l'integrazione con Amazon EventBridge. Scopri come creare applicazioni basate sugli eventi inviando eventi personalizzati direttamente dai flussi di lavoro di Step Functions.
Per ulteriori informazioni sull'integrazione con AWS i servizi in Step Functions, vedere [Integrazione dei servizi ](integrate-services.md) e[Passaggio di parametri a un'API di servizio in Step Functions](connect-parameters.md).
**Caratteristiche principali dell'integrazione ottimizzata EventBridge**
L'ARN di esecuzione e l'ARN della macchina a stati vengono aggiunti automaticamente al campo di ciascuno. `Resources` `PutEventsRequestEntry`
Se la risposta di `PutEvents` contiene un valore diverso da zero, `FailedEntryCount` lo `Task` stato fallisce con l'errore. `EventBridge.FailedEntry`
Per utilizzare l'`PutEvents`API, dovrai creare una EventBridge regola nel tuo account che corrisponda allo schema specifico degli eventi che invierai. È ad esempio possibile:
+ Crea una funzione Lambda nel tuo account che riceva e stampa un evento che corrisponde a una EventBridge regola.
+ Crea una EventBridge regola nel tuo account sul bus eventi predefinito che corrisponda a uno schema di eventi specifico e abbia come destinazione la funzione Lambda.
Per ulteriori informazioni, consulta:
+ [Aggiungere EventBridge eventi Amazon PutEvents](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-putevents.html) nella Guida per l' EventBridge utente.
+ [Attendi una richiamata con Task Token](connect-to-resource.md#connect-wait-token)in Modelli di integrazione dei servizi.
Quanto segue include un messaggio `Task` che invia un evento personalizzato:
```
{
"Type": "Task",
"Resource": "arn:aws:states:::events:putEvents",
"Arguments": {
"Entries": [
{
"Detail": {
"Message": "MyMessage"
},
"DetailType": "MyDetailType",
"EventBusName": "MyEventBus",
"Source": "my.source"
}
]
},
"End": true
}
```
**Quota per i dati di input o di risultato**
Quando si inviano o si ricevono dati tra servizi, l'input o il risultato massimo per un'attività è di 256 KB di dati come stringa con codifica UTF-8. Per informazioni, consulta [Quote relative alle esecuzioni di macchine a stati](service-quotas.md#service-limits-state-machine-executions).
## API ottimizzata EventBridge
EventBridge L'API e la sintassi supportate includono:
+ [https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEvents.html](https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEvents.html)
## Gestione degli errori
L'`PutEvents`API accetta una serie di voci come input, quindi restituisce una matrice di voci di risultati. Se l'`PutEvents`azione ha avuto esito positivo, `PutEvents` restituirà una risposta HTTP 200, anche se una o più voci non sono riuscite. `PutEvents`restituisce il numero di immissioni non riuscite nel `FailedEntryCount` campo.
Step Functions verifica se `FailedEntryCount` è maggiore di zero. Se è maggiore di zero, Step Functions non riporta lo stato con l'errore`EventBridge.FailedEntry`. Ciò consente di utilizzare la gestione degli errori integrata di Step Functions sugli stati delle attività per rilevare o riprovare in caso di immissioni non riuscite, anziché dover utilizzare uno stato aggiuntivo per analizzare i risultati `FailedEntryCount` della risposta.
**Nota**
Se hai implementato l'idempotenza e puoi riprovare in sicurezza su tutte le voci, puoi utilizzare la logica di riprova di Step Functions. Step Functions non rimuove le voci riuscite dall'array `PutEvents` di input prima di riprovare. Riprova invece con l'array di voci originale.
## Politiche IAM per le chiamate EventBridge
I seguenti modelli di esempio mostrano come AWS Step Functions generare politiche IAM in base alle risorse nella definizione della macchina a stati. Per ulteriori informazioni, consultare [In che modo Step Functions genera policy IAM per servizi integrati](service-integration-iam-templates.md) e [Scopri i modelli di integrazione dei servizi in Step Functions](connect-to-resource.md).
### `PutEvents`
*Risorse statiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"events:PutEvents"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:event-bus/my-project-eventbus"
],
"Effect": "Allow"
}
]
}
```
*Risorse dinamiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"events:PutEvents"
],
"Resource": "arn:aws:events:*:*:event-bus/*"
}
]
}
```
# Inizia un AWS Glue lavoro con Step Functions
Impara a usare Step Functions per avviare un jobAWS Glue. Questa pagina elenca le azioni API supportate e fornisce un esempio di `Task` stato per avviare un AWS Glue processo.
Per ulteriori informazioni sull'integrazione con AWS i servizi in Step Functions, vedere [Integrazione dei servizi ](integrate-services.md) e[Passaggio di parametri a un'API di servizio in Step Functions](connect-parameters.md).
**Caratteristiche principali dell'integrazione ottimizzata AWS Glue**
Il modello di [Esegui un processo (.sync)](connect-to-resource.md#connect-sync) integrazione è disponibile.
Il `JobName` campo viene estratto dalla richiesta e inserito nella risposta, che normalmente contiene `JobRunID` solo.
Quanto segue include uno `Task` stato che avvia un AWS Glue processo.
```
"Glue StartJobRun": {
"Type": "Task",
"Resource": "arn:aws:states:::glue:startJobRun.sync",
"Arguments": {
"JobName": "GlueJob-JTrRO5l98qMG"
},
"Next": "ValidateOutput"
},
```
**I parametri in Step Functions sono espressi in PascalCase**
Anche se l'API del servizio nativo è in CamelCase, ad esempio l'`startSyncExecution`azione API, si specificano parametri PascalCase in, ad esempio:. `StateMachineArn`
## Ottimizzato AWS Glue APIs
+ [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-runs.html#aws-glue-api-jobs-runs-StartJobRun](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-runs.html#aws-glue-api-jobs-runs-StartJobRun)
## Politiche IAM per le chiamate AWS Glue
I seguenti modelli di esempio mostrano come AWS Step Functions generare le politiche IAM in base alle risorse nella definizione della macchina a stati. Per ulteriori informazioni, consultare [In che modo Step Functions genera policy IAM per servizi integrati](service-integration-iam-templates.md) e [Scopri i modelli di integrazione dei servizi in Step Functions](connect-to-resource.md).
AWS Gluenon ha un controllo basato sulle risorse.
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:StartJobRun",
"glue:GetJobRun",
"glue:GetJobRuns",
"glue:BatchStopJobRun"
],
"Resource": "*"
}
]
}
```
------
#### [ Request Response and Callback (.waitForTaskToken) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:StartJobRun"
],
"Resource": "*"
}
]
}
```
------
# Inizia a AWS Glue DataBrew lavorare con Step Functions
Scopri come utilizzare l' DataBrew integrazione per aggiungere passaggi di pulizia e normalizzazione dei dati nei flussi di lavoro di analisi e apprendimento automatico con Step Functions.
Per ulteriori informazioni sull'integrazione con AWS i servizi in Step Functions, vedere [Integrazione dei servizi ](integrate-services.md) e[Passaggio di parametri a un'API di servizio in Step Functions](connect-parameters.md).
Quanto segue include `Task` uno stato che avvia un processo di richiesta-risposta DataBrew.
```
"DataBrew StartJobRun": {
"Type": "Task",
"Resource": "arn:aws:states:::databrew:startJobRun",
"Arguments": {
"Name": "sample-proj-job-1"
},
"Next": "NEXT_STATE"
},
```
Quanto segue include `Task` uno stato che avvia un processo di sincronizzazione DataBrew .
```
"DataBrew StartJobRun": {
"Type": "Task",
"Resource": "arn:aws:states:::databrew:startJobRun.sync",
"Arguments": {
"Name": "sample-proj-job-1"
},
"Next": "NEXT_STATE"
},
```
**I parametri in Step Functions sono espressi in PascalCase**
Anche se l'API del servizio nativo è in CamelCase, ad esempio l'`startSyncExecution`azione API, si specificano parametri PascalCase in, ad esempio:. `StateMachineArn`
## Supportato DataBrew APIs
+ `[https://docs.aws.amazon.com/databrew/latest/dg/API_StartJobRun.html](https://docs.aws.amazon.com/databrew/latest/dg/API_StartJobRun.html)`
## Politiche IAM per le chiamate DataBrew
I seguenti modelli di esempio mostrano come AWS Step Functions generare le politiche IAM in base alle risorse nella definizione della macchina a stati. Per ulteriori informazioni, consultare [In che modo Step Functions genera policy IAM per servizi integrati](service-integration-iam-templates.md) e [Scopri i modelli di integrazione dei servizi in Step Functions](connect-to-resource.md).
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"databrew:startJobRun",
"databrew:listJobRuns",
"databrew:stopJobRun"
],
"Resource": [
"arn:aws:databrew:us-east-1:123456789012:job/*"
]
}
]
}
```
------
#### [ Request Response ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"databrew:startJobRun"
],
"Resource": [
"arn:aws:databrew:us-east-1:123456789012:job/*"
]
}
]
}
```
------
# Invoca una AWS Lambda funzione con Step Functions
Scopri come usare Step Functions per richiamare le funzioni Lambda in modo sincrono o asincrono come parte di un'applicazione serverless basata sugli eventi.
Per ulteriori informazioni sull'integrazione con AWS i servizi in Step Functions, vedere [Integrazione dei servizi ](integrate-services.md) e[Passaggio di parametri a un'API di servizio in Step Functions](connect-parameters.md).
**Caratteristiche principali dell'integrazione Optimized Lambda**
Il `Payload` campo della risposta viene analizzato da Json in escape a Json.
Se viene sollevata un'eccezione all'interno della funzione Lambda, il Task avrà esito negativo. Per un esempio pratico, vedi[Gestione delle condizioni di errore in una macchina a stati Step Functions](tutorial-handling-error-conditions.md).
## Lambda ottimizzata APIs
+ [https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html)
## Esempi di flussi di lavoro
Quanto segue include uno `Task` stato che richiama una funzione Lambda.
```
{
"StartAt":"CallLambda",
"States":{
"CallLambda":{
"Type":"Task",
"Resource":"arn:aws:states:::lambda:invoke",
"Arguments":{
"FunctionName":"arn:aws:lambda:region:account-id:function:MyFunction"
},
"End":true
}
}
}
```
L’esempio seguente include uno stato `Task` che implementa il modello di integrazione del servizio di [callback](connect-to-resource.md#connect-wait-token).
```
{
"StartAt":"GetManualReview",
"States":{
"GetManualReview":{
"Type":"Task",
"Resource":"arn:aws:states:::lambda:invoke.waitForTaskToken",
"Arguments":{
"FunctionName":"arn:aws:lambda:region:account-id:function:get-model-review-decision",
"Payload":{
"model":"{% $states.input.my-model %}",
"TaskToken": "{% $states.context.Task.Token %}"
},
"Qualifier":"prod-v1"
},
"End":true
}
}
}
```
Quando richiami una funzione Lambda, l'esecuzione attenderà il completamento della funzione. Se si richiama la funzione Lambda con un'attività di callback, il timeout del battito cardiaco inizia a contare solo dopo che la funzione Lambda non ha completato l'esecuzione e restituito un risultato. Finché la funzione Lambda è in esecuzione, il timeout del battito cardiaco non viene applicato.
È anche possibile chiamare Lambda in modo asincrono utilizzando il `InvocationType` parametro, come illustrato nell'esempio seguente:
```
{
"Comment": "A Hello World example of the Amazon States Language using Pass states",
"StartAt": "Hello",
"States": {
"Hello": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Arguments": {
"FunctionName": "arn:aws:lambda:region:account-id:function:echo",
"InvocationType": "Event"
},
"End": true
}
}
}
```
**Nota**
Per le chiamate asincrone delle funzioni Lambda, il periodo di timeout dell'heartbeat inizia immediatamente.
Quando viene restituito il `Task` risultato, l'output della funzione viene annidato all'interno di un dizionario di metadati. Esempio:
```
{
"ExecutedVersion":"$LATEST",
"Payload":"FUNCTION OUTPUT",
"SdkHttpMetadata":{
"HttpHeaders":{
"Connection":"keep-alive",
"Content-Length":"4",
"Content-Type":"application/json",
"Date":"Fri, 26 Mar 2021 07:42:02 GMT",
"X-Amz-Executed-Version":"$LATEST",
"x-amzn-Remapped-Content-Length":"0",
"x-amzn-RequestId":"0101aa0101-1111-111a-aa55-1010aaa1010",
"X-Amzn-Trace-Id":"root=1-1a1a000a2a2-fe0101aa10ab;sampled=0"
},
"HttpStatusCode":200
},
"SdkResponseMetadata":{
"RequestId":"6b3bebdb-9251-453a-ae45-512d9e2bf4d3"
},
"StatusCode":200
}
```
## Risorsa funzionale specificata direttamente
In alternativa, puoi richiamare una funzione Lambda specificando l'ARN di una funzione direttamente nel campo «Risorsa». Quando si richiama una funzione Lambda in questo modo, non è possibile `.waitForTaskToken` specificare e il risultato dell'attività contiene solo l'output della funzione.
```
{
"StartAt":"CallFunction",
"States":{
"CallFunction": {
"Type":"Task",
"Resource":"arn:aws:lambda:region:account-id:function:HelloFunction",
"End": true
}
}
}
```
Con questa forma di integrazione, la funzione potrebbe avere successo ma inviare una risposta che contiene un `FunctionError` campo. In questo scenario, l'operazione del flusso di lavoro avrà esito negativo.
Puoi richiamare una versione o un alias specifico della funzione Lambda specificando tali opzioni nell'ARN nel campo. `Resource` Vedi quanto segue nella documentazione di Lambda:
+ [Funzione Versioni multiple di AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/versioning-intro.html)
+ [AWS Lambdaalias](https://docs.aws.amazon.com/lambda/latest/dg/aliases-intro.html)
## politiche IAM per le chiamate AWS Lambda
I seguenti modelli di esempio mostrano come AWS Step Functions generare le politiche IAM in base alle risorse nella definizione della macchina a stati. Per ulteriori informazioni, consultare [In che modo Step Functions genera policy IAM per servizi integrati](service-integration-iam-templates.md) e [Scopri i modelli di integrazione dei servizi in Step Functions](connect-to-resource.md).
Nell'esempio seguente, una macchina a stati con due stati di AWS Lambda attività che chiamano `function1` e`function2`, la politica generata automaticamente include l'`lambda:Invoke`autorizzazione per entrambe le funzioni.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:us-east-1:123456789012:function:myFn1",
"arn:aws:lambda:us-east-1:123456789012:function:myFn2"
]
}
]
}
```
# Crea un AWS Elemental MediaConvert lavoro con Step Functions
Scopri come utilizzare Step Functions per creare un AWS Elemental MediaConvert lavoro utilizzando l'[https://docs.aws.amazon.com/mediaconvert/latest/apireference/jobs.html#jobspost](https://docs.aws.amazon.com/mediaconvert/latest/apireference/jobs.html#jobspost)API.
**Sperimenta con Step Functions e MediaConvert**
Scopri come utilizzare l'integrazione MediaConvert ottimizzata in un flusso di lavoro che rileva e rimuove le barre di colore SMTPE di lunghezza sconosciuta dall'inizio di un video clip. [https://aws.amazon.com/blogs/media/low-code-workflows-with-aws-elemental-mediaconvert/](https://aws.amazon.com/blogs/media/low-code-workflows-with-aws-elemental-mediaconvert/)
Per ulteriori informazioni sull'integrazione con AWS i servizi in Step Functions, vedere [Integrazione dei servizi ](integrate-services.md) e[Passaggio di parametri a un'API di servizio in Step Functions](connect-parameters.md).
**Caratteristiche principali dell'integrazione ottimizzata MediaConvert**
I modelli di [Richiesta e risposta](connect-to-resource.md#connect-default) integrazione [Esegui un processo (.sync)](connect-to-resource.md#connect-sync) e sono supportati.
Step Functions aggiungerà il seguente tag personalizzato ai MediaConvert lavori: `ManagedByService: AWSStepFunctions`
Non esiste un'ottimizzazione specifica per i modelli di [Attendi una richiamata con Task Token](connect-to-resource.md#connect-wait-token) integrazione.
Quanto segue include uno `Task` stato che invia un MediaConvert lavoro e attende che venga completato.
```
{
"StartAt": "MediaConvert_CreateJob",
"States": {
"MediaConvert_CreateJob": {
"Type": "Task",
"Resource": "arn:aws:states:::mediaconvert:createJob.sync",
"Arguments": {
"Role": "arn:aws:iam::111122223333:role/Admin",
"Settings": {
"OutputGroups": [
{
"Outputs": [
{
"ContainerSettings": {
"Container": "MP4"
},
"VideoDescription": {
"CodecSettings": {
"Codec": "H_264",
"H264Settings": {
"MaxBitrate": 1000,
"RateControlMode": "QVBR",
"SceneChangeDetect": "TRANSITION_DETECTION"
}
}
},
"AudioDescriptions": [
{
"CodecSettings": {
"Codec": "AAC",
"AacSettings": {
"Bitrate": 96000,
"CodingMode": "CODING_MODE_2_0",
"SampleRate": 48000
}
}
}
]
}
],
"OutputGroupSettings": {
"Type": "FILE_GROUP_SETTINGS",
"FileGroupSettings": {
"Destination": "s3://amzn-s3-demo-destination-bucket/"
}
}
}
],
"Inputs": [
{
"AudioSelectors": {
"Audio Selector 1": {
"DefaultSelection": "DEFAULT"
}
},
"FileInput": "s3://amzn-s3-demo-bucket/DOC-EXAMPLE-SOURCE_FILE"
}
]
}
},
"End": true
}
}
}
```
**I parametri in Step Functions sono espressi in PascalCase**
Anche se l'API del servizio nativo è in CamelCase, ad esempio l'`startSyncExecution`azione API, si specificano parametri PascalCase in, ad esempio:. `StateMachineArn`
## Ottimizzato MediaConvert APIs
+ [https://docs.aws.amazon.com/mediaconvert/latest/apireference/jobs.html#jobspost](https://docs.aws.amazon.com/mediaconvert/latest/apireference/jobs.html#jobspost)
+ [Sintassi della richiesta](https://docs.aws.amazon.com/mediaconvert/latest/apireference/jobs.html#jobs-request-body-post-example)
+ Parametri supportati:
+ [https://docs.aws.amazon.com/mediaconvert/latest/apireference/jobs.html#jobs-prop-createjobrequest-role](https://docs.aws.amazon.com/mediaconvert/latest/apireference/jobs.html#jobs-prop-createjobrequest-role) (Obbligatorio)
+ [https://docs.aws.amazon.com/mediaconvert/latest/apireference/jobs.html#jobs-prop-createjobrequest-settings](https://docs.aws.amazon.com/mediaconvert/latest/apireference/jobs.html#jobs-prop-createjobrequest-settings) (Obbligatorio)
+ [https://docs.aws.amazon.com/mediaconvert/latest/apireference/jobs.html#jobs-model-createjobrequest](https://docs.aws.amazon.com/mediaconvert/latest/apireference/jobs.html#jobs-model-createjobrequest) (facoltativo).
+ [Sintassi della risposta](https://docs.aws.amazon.com/mediaconvert/latest/apireference/jobs.html#jobs-response-examples)**: vedi schema CreateJobResponse **
## Politiche IAM per le chiamate AWS Elemental MediaConvert
I seguenti modelli di esempio mostrano come AWS Step Functions generare le politiche IAM in base alle risorse nella definizione della macchina a stati. Per ulteriori informazioni, consultare [In che modo Step Functions genera policy IAM per servizi integrati](service-integration-iam-templates.md) e [Scopri i modelli di integrazione dei servizi in Step Functions](connect-to-resource.md).
La policy `GetJob` e le `CancelJob` azioni IAM hanno lo scopo di consentire l'accesso solo ai lavori con il `ManagedByService: AWSStepFunctions` tag.
**Politica basata su tag**
La modifica del `ManagedByService: AWSStepFunctions` tag generato automaticamente causerà il fallimento delle esecuzioni delle macchine a stati.
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "MediaConvertCreateJob",
"Effect": "Allow",
"Action": [
"mediaconvert:CreateJob"
],
"Resource": [
"arn:aws:mediaconvert:us-east-1:123456789012:queues/*",
"arn:aws:mediaconvert:us-east-1:123456789012:jobTemplates/*",
"arn:aws:mediaconvert:us-east-1:123456789012:presets/*"
]
},
{
"Sid": "MediaConvertManageJob",
"Effect": "Allow",
"Action": [
"mediaconvert:GetJob",
"mediaconvert:CancelJob"
],
"Resource": "arn:aws:mediaconvert:us-east-1:123456789012:jobs/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/ManagedByService": "AWSStepFunctions"
}
}
},
{
"Sid": "IamPassRole",
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::123456789012:role/myRoleName"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"mediaconvert.amazonaws.com"
]
}
}
},
{
"Sid": "EventBridgeManageRule",
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForMediaConvertJobRule"
]
}
]
}
```
------
#### [ Request Response ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "MediaConvertCreateJob",
"Effect": "Allow",
"Action": [
"mediaconvert:CreateJob"
],
"Resource": [
"arn:aws:mediaconvert:us-east-1:123456789012:queues/*",
"arn:aws:mediaconvert:us-east-1:123456789012:jobTemplates/*",
"arn:aws:mediaconvert:us-east-1:123456789012:presets/*"
]
},
{
"Sid": "IamPassRole",
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::123456789012:role/myRoleName"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"mediaconvert.amazonaws.com"
]
}
}
}
]
}
```
------
# Crea e gestisci lavori Amazon SageMaker AI con Step Functions
Scopri come utilizzare Step Functions per creare e gestire lavori sull' SageMaker intelligenza artificiale. Questa pagina elenca le azioni API SageMaker AI supportate e fornisce esempi di `Task` stati per creare processi di trasformazione, formazione, etichettatura ed elaborazione dell' SageMaker IA.
Per ulteriori informazioni sull'integrazione con AWS i servizi in Step Functions, vedere [Integrazione dei servizi ](integrate-services.md) e[Passaggio di parametri a un'API di servizio in Step Functions](connect-parameters.md).
**Caratteristiche principali dell'integrazione SageMaker AI ottimizzata**
Il modello di [Esegui un processo (.sync)](connect-to-resource.md#connect-sync) integrazione è supportato.
Non esistono ottimizzazioni specifiche per il modello di [Richiesta e risposta](connect-to-resource.md#connect-default) integrazione.
Il modello di [Attendi una richiamata con Task Token](connect-to-resource.md#connect-wait-token) integrazione non è supportato.
## SageMaker AI ottimizzata APIs
+ [https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateEndpoint.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateEndpointConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateHyperParameterTuningJob.html](https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateHyperParameterTuningJob.html)- Supporta il modello di `.sync` integrazione.
+ [https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateLabelingJob.html](https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateLabelingJob.html)- Supporta il modello di `.sync` integrazione.
+ [https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateModel.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateProcessingJob.html](https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateProcessingJob.html)- Supporta il modello di `.sync` integrazione.
+ [https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateTrainingJob.html)- Supporta il modello di `.sync` integrazione.
+ [https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateTransformJob.html)- Supporta il modello di `.sync` integrazione.
+ [https://docs.aws.amazon.com/sagemaker/latest/dg/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/dg/API_UpdateEndpoint.html)
**Nota**
AWS Step Functionsnon creerà automaticamente una politica per`CreateTransformJob`. Devi allegare una policy inline al ruolo creato. Per ulteriori informazioni, consulta questo esempio di politica IAM:[`CreateTrainingJob`](#sagemaker-iam-createtrainingjob).
## SageMaker Esempio di lavoro con AI Transform
Quanto segue include uno `Task` stato che crea un processo di trasformazione Amazon SageMaker AI, specificando la posizione `DataSource` Amazon S3 per e. `TransformOutput`
```
{
"SageMaker CreateTransformJob": {
"Type": "Task",
"Resource": "arn:aws:states:::sagemaker:createTransformJob.sync",
"Arguments": {
"ModelName": "SageMakerCreateTransformJobModel-9iFBKsYti9vr",
"TransformInput": {
"CompressionType": "None",
"ContentType": "text/csv",
"DataSource": {
"S3DataSource": {
"S3DataType": "S3Prefix",
"S3Uri": "s3://amzn-s3-demo-source-bucket1/TransformJobDataInput.txt"
}
}
},
"TransformOutput": {
"S3OutputPath": "s3://amzn-s3-demo-source-bucket1/TransformJobOutputPath"
},
"TransformResources": {
"InstanceCount": 1,
"InstanceType": "ml.m4.xlarge"
},
"TransformJobName": "sfn-binary-classification-prediction"
},
"Next": "ValidateOutput"
},
```
## SageMaker Esempio di lavoro di AI Training
Quanto segue include uno `Task` stato che crea un processo di formazione Amazon SageMaker AI.
```
{
"SageMaker CreateTrainingJob":{
"Type":"Task",
"Resource":"arn:aws:states:::sagemaker:createTrainingJob.sync",
"Arguments":{
"TrainingJobName":"search-model",
"ResourceConfig":{
"InstanceCount":4,
"InstanceType":"ml.c4.8xlarge",
"VolumeSizeInGB":20
},
"HyperParameters":{
"mode":"batch_skipgram",
"epochs":"5",
"min_count":"5",
"sampling_threshold":"0.0001",
"learning_rate":"0.025",
"window_size":"5",
"vector_dim":"300",
"negative_samples":"5",
"batch_size":"11"
},
"AlgorithmSpecification":{
"TrainingImage":"...",
"TrainingInputMode":"File"
},
"OutputDataConfig":{
"S3OutputPath":"s3://amzn-s3-demo-destination-bucket1/doc-search/model"
},
"StoppingCondition":{
"MaxRuntimeInSeconds":100000
},
"RoleArn":"arn:aws:iam::account-id:role/docsearch-stepfunction-iam-role",
"InputDataConfig":[
{
"ChannelName":"train",
"DataSource":{
"S3DataSource":{
"S3DataType":"S3Prefix",
"S3Uri":"s3://amzn-s3-demo-destination-bucket1/doc-search/interim-data/training-data/",
"S3DataDistributionType":"FullyReplicated"
}
}
}
]
},
"Retry":[
{
"ErrorEquals":[
"SageMaker.AmazonSageMakerException"
],
"IntervalSeconds":1,
"MaxAttempts":100,
"BackoffRate":1.1
},
{
"ErrorEquals":[
"SageMaker.ResourceLimitExceededException"
],
"IntervalSeconds":60,
"MaxAttempts":5000,
"BackoffRate":1
},
{
"ErrorEquals":[
"States.Timeout"
],
"IntervalSeconds":1,
"MaxAttempts":5,
"BackoffRate":1
}
],
"Catch":[
{
"ErrorEquals":[
"States.ALL"
],
"Next":"Sagemaker Training Job Error"
}
],
"Next":"Delete Interim Data Job"
}
}
```
## SageMaker Esempio di lavoro di etichettatura AI
Quanto segue include uno `Task` stato che crea un processo di etichettatura Amazon SageMaker AI.
```
{
"StartAt": "SageMaker CreateLabelingJob",
"TimeoutSeconds": 3600,
"States": {
"SageMaker CreateLabelingJob": {
"Type": "Task",
"Resource": "arn:aws:states:::sagemaker:createLabelingJob.sync",
"Arguments": {
"HumanTaskConfig": {
"AnnotationConsolidationConfig": {
"AnnotationConsolidationLambdaArn": "arn:aws:lambda:region:123456789012:function:ACS-TextMultiClass"
},
"NumberOfHumanWorkersPerDataObject": 1,
"PreHumanTaskLambdaArn": "arn:aws:lambda:region:123456789012:function:PRE-TextMultiClass",
"TaskDescription": "Classify the following text",
"TaskKeywords": [
"tc",
"Labeling"
],
"TaskTimeLimitInSeconds": 300,
"TaskTitle": "Classify short bits of text",
"UiConfig": {
"UiTemplateS3Uri": "s3://amzn-s3-demo-bucket/TextClassification.template"
},
"WorkteamArn": "arn:aws:sagemaker:region:123456789012:workteam/private-crowd/ExampleTesting"
},
"InputConfig": {
"DataAttributes": {
"ContentClassifiers": [
"FreeOfPersonallyIdentifiableInformation",
"FreeOfAdultContent"
]
},
"DataSource": {
"S3DataSource": {
"ManifestS3Uri": "s3://amzn-s3-demo-bucket/manifest.json"
}
}
},
"LabelAttributeName": "Categories",
"LabelCategoryConfigS3Uri": "s3://amzn-s3-demo-bucket/labelcategories.json",
"LabelingJobName": "example-job-name",
"OutputConfig": {
"S3OutputPath": "s3://amzn-s3-demo-bucket/output"
},
"RoleArn": "arn:aws:iam::123456789012:role/service-role/AmazonSageMaker-ExecutionRole",
"StoppingConditions": {
"MaxHumanLabeledObjectCount": 10000,
"MaxPercentageOfInputDatasetLabeled": 100
}
},
"Next": "ValidateOutput"
},
"ValidateOutput": {
"Type": "Choice",
"Choices": [
{
"Next": "Success",
"Condition": "{% $states.input.LabelingJobArn != '' %}"
}
],
"Default": "Fail"
},
"Success": {
"Type": "Succeed"
},
"Fail": {
"Type": "Fail",
"Error": "InvalidOutput",
"Cause": "Output is not what was expected. This could be due to a service outage or a misconfigured service integration."
}
}
}
```
## SageMaker Esempio di lavoro di elaborazione AI
Quanto segue include uno `Task` stato che crea un processo di elaborazione Amazon SageMaker AI.
```
{
"StartAt": "SageMaker CreateProcessingJob Sync",
"TimeoutSeconds": 3600,
"States": {
"SageMaker CreateProcessingJob Sync": {
"Type": "Task",
"Resource": "arn:aws:states:::sagemaker:createProcessingJob.sync",
"Arguments": {
"AppSpecification": {
"ImageUri": "737474898029.dkr.ecr.sa-east-1.amazonaws.com/sagemaker-scikit-learn:0.20.0-cpu-py3"
},
"ProcessingResources": {
"ClusterConfig": {
"InstanceCount": 1,
"InstanceType": "ml.t3.medium",
"VolumeSizeInGB": 10
}
},
"RoleArn": "arn:aws:iam::account-id:role/SM-003-CreateProcessingJobAPIExecutionRole",
"ProcessingJobName.$": "$.id"
},
"Next": "ValidateOutput"
},
"ValidateOutput": {
"Type": "Choice",
"Choices": [
{
"Not": {
"Variable": "$.ProcessingJobArn",
"StringEquals": ""
},
"Next": "Succeed"
}
],
"Default": "Fail"
},
"Succeed": {
"Type": "Succeed"
},
"Fail": {
"Type": "Fail",
"Error": "InvalidConnectorOutput",
"Cause": "Connector output is not what was expected. This could be due to a service outage or a misconfigured connector."
}
}
}
```
## Politiche IAM per le chiamate ad Amazon SageMaker AI
I seguenti modelli di esempio mostrano come AWS Step Functions generare politiche IAM in base alle risorse nella definizione della macchina a stati. Per ulteriori informazioni, consultare [In che modo Step Functions genera policy IAM per servizi integrati](service-integration-iam-templates.md) e [Scopri i modelli di integrazione dei servizi in Step Functions](connect-to-resource.md).
**Nota**
Per questi esempi, fai `roleArn` riferimento all'Amazon Resource Name (ARN) del ruolo IAM che l' SageMaker intelligenza artificiale utilizza per accedere agli artefatti del modello e alle immagini docker per la distribuzione su istanze di calcolo ML o per lavori di trasformazione in batch. Per ulteriori informazioni, consulta [Amazon SageMaker Roles](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html).
### `CreateTrainingJob`
*Risorse statiche*
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:CreateTrainingJob",
"sagemaker:DescribeTrainingJob",
"sagemaker:StopTrainingJob"
],
"Resource": [
"arn:aws:sagemaker:us-east-1:123456789012:training-job/myJobName*"
]
},
{
"Effect": "Allow",
"Action": [
"sagemaker:ListTags",
"sagemaker:AddTags"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::123456789012:role/MyExampleRole"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "sagemaker.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForSageMakerTrainingJobsRule"
]
}
]
}
```
------
#### [ Request Response and Callback (.waitForTaskToken) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:CreateTrainingJob"
],
"Resource": [
"arn:aws:sagemaker:us-east-1:123456789012:training-job/myJobName*"
]
},
{
"Effect": "Allow",
"Action": [
"sagemaker:ListTags",
"sagemaker:AddTags"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::123456789012:role/MyExampleRole"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "sagemaker.amazonaws.com"
}
}
}
]
}
```
------
*Risorse dinamiche*
------
#### [ .sync or .waitForTaskToken ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:CreateTrainingJob",
"sagemaker:DescribeTrainingJob",
"sagemaker:StopTrainingJob"
],
"Resource": [
"arn:aws:sagemaker:us-east-1:123456789012:training-job/*"
]
},
{
"Effect": "Allow",
"Action": [
"sagemaker:ListTags",
"sagemaker:AddTags"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::123456789012:role/MyExampleRole"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "sagemaker.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForSageMakerTrainingJobsRule"
]
}
]
}
```
------
#### [ Request Response and Callback (.waitForTaskToken) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:CreateTrainingJob"
],
"Resource": [
"arn:aws:sagemaker:us-east-1:123456789012:training-job/*"
]
},
{
"Effect": "Allow",
"Action": [
"sagemaker:ListTags",
"sagemaker:AddTags"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::123456789012:role/MyExampleRole"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "sagemaker.amazonaws.com"
}
}
}
]
}
```
------
### `CreateTransformJob`
**Nota**
AWS Step Functionsnon creerà automaticamente una policy per `CreateTransformJob` quando crei una macchina a stati che si integra con l' SageMaker intelligenza artificiale. È necessario allegare una policy in linea al ruolo creato sulla base di uno dei seguenti esempi IAM.
*Risorse statiche*
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:CreateTransformJob",
"sagemaker:DescribeTransformJob",
"sagemaker:StopTransformJob"
],
"Resource": [
"arn:aws:sagemaker:us-east-1:123456789012:transform-job/myJobName*"
]
},
{
"Effect": "Allow",
"Action": [
"sagemaker:ListTags",
"sagemaker:AddTags"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::123456789012:role/MyExampleRole"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "sagemaker.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForSageMakerTransformJobsRule"
]
}
]
}
```
------
#### [ Request Response and Callback (.waitForTaskToken) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:CreateTransformJob"
],
"Resource": [
"arn:aws:sagemaker:us-east-1:123456789012:transform-job/myJobName*"
]
},
{
"Effect": "Allow",
"Action": [
"sagemaker:ListTags",
"sagemaker:AddTags"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::123456789012:role/MyExampleRole"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "sagemaker.amazonaws.com"
}
}
}
]
}
```
------
*Risorse dinamiche*
------
#### [ Run a Job (.sync) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:CreateTransformJob",
"sagemaker:DescribeTransformJob",
"sagemaker:StopTransformJob"
],
"Resource": [
"arn:aws:sagemaker:us-east-1:123456789012:transform-job/*"
]
},
{
"Effect": "Allow",
"Action": [
"sagemaker:ListTags",
"sagemaker:AddTags"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::123456789012:role/MyExampleRole"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "sagemaker.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForSageMakerTransformJobsRule"
]
}
]
}
```
------
#### [ Request Response and Callback (.waitForTaskToken) ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:CreateTransformJob"
],
"Resource": [
"arn:aws:sagemaker:us-east-1:123456789012:transform-job/*"
]
},
{
"Effect": "Allow",
"Action": [
"sagemaker:ListTags",
"sagemaker:AddTags"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::123456789012:role/MyExampleRole"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "sagemaker.amazonaws.com"
}
}
}
]
}
```
------
# Pubblica messaggi su un argomento Amazon SNS con Step Functions
Scopri come usare Step Functions per pubblicare messaggi su un argomento di Amazon SNS. Questa pagina elenca le azioni API di Amazon SNS supportate e fornisce esempi di `Task` stati per pubblicare messaggi su Amazon SNS.
Per ulteriori informazioni sull'integrazione con AWS i servizi in Step Functions, vedere [Integrazione dei servizi ](integrate-services.md) e[Passaggio di parametri a un'API di servizio in Step Functions](connect-parameters.md).
**Caratteristiche principali dell'integrazione ottimizzata di Amazon SNS**
Non esistono ottimizzazioni specifiche per i modelli [Richiesta e risposta](connect-to-resource.md#connect-default) di [Attendi una richiamata con Task Token](connect-to-resource.md#connect-wait-token) integrazione.
Quanto segue include uno `Task` stato che pubblica su un argomento di Amazon Simple Notification Service (Amazon SNS).
```
{
"StartAt": "Publish to SNS",
"States": {
"Publish to SNS": {
"Type": "Task",
"Resource": "arn:aws:states:::sns:publish",
"Arguments": {
"TopicArn": "arn:aws:sns:region:account-id:myTopic",
"Message": "{% states.input.message %}",
"MessageAttributes": {
"my_attribute_no_1": {
"DataType": "String",
"StringValue": "value of my_attribute_no_1"
},
"my_attribute_no_2": {
"DataType": "String",
"StringValue": "value of my_attribute_no_2"
}
}
},
"End": true
}
}
}
```
**Passaggio di valori dinamici**. Puoi modificare l'esempio precedente per passare dinamicamente un attributo da questo payload JSON:
```
{
"message": "Hello world",
"SNSDetails": {
"attribute1": "some value",
"attribute2": "some other value",
}
}
```
Quanto segue imposta i valori utilizzando JSONata le espressioni per i campi: `StringValue`
```
"MessageAttributes": {
"my_attribute_no_1": {
"DataType": "String",
"StringValue": "{% $states.input.SNSDetails.attribute1 %}"
},
"my_attribute_no_2": {
"DataType": "String",
"StringValue": "{% $states.input.SNSDetails.attribute2 %}"
}
```
Quanto segue include uno `Task` stato che pubblica su un argomento di Amazon SNS e quindi attende la restituzione del token dell'attività. Per informazioni, consulta [Attendi una richiamata con Task Token](connect-to-resource.md#connect-wait-token).
```
{
"StartAt":"Send message to SNS",
"States":{
"Send message to SNS":{
"Type":"Task",
"Resource":"arn:aws:states:::sns:publish.waitForTaskToken",
"Arguments":{
"TopicArn":"arn:aws:sns:region:account-id:myTopic",
"Message":{
"Input":"{% states.input.message %}",
"TaskToken": "{% $states.context.Task.Token %}"
}
},
"End":true
}
}
}
```
## Amazon SNS ottimizzato APIs
+ [https://docs.aws.amazon.com/sns/latest/api/API_Publish.html](https://docs.aws.amazon.com/sns/latest/api/API_Publish.html)
**I parametri in Step Functions sono espressi in PascalCase**
Anche se l'API del servizio nativo è in CamelCase, ad esempio l'`startSyncExecution`azione API, si specificano parametri PascalCase in, ad esempio:. `StateMachineArn`
**Quota per i dati di input o di risultato**
Quando si inviano o si ricevono dati tra servizi, l'input o il risultato massimo per un'attività è di 256 KB di dati come stringa con codifica UTF-8. Per informazioni, consulta [Quote relative alle esecuzioni di macchine a stati](service-quotas.md#service-limits-state-machine-executions).
## Politiche IAM per le chiamate ad Amazon SNS
I seguenti modelli di esempio mostrano come AWS Step Functions generare le politiche IAM in base alle risorse nella definizione della macchina a stati. Per ulteriori informazioni, consultare [In che modo Step Functions genera policy IAM per servizi integrati](service-integration-iam-templates.md) e [Scopri i modelli di integrazione dei servizi in Step Functions](connect-to-resource.md).
*Risorse statiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sns:Publish"
],
"Resource": [
"arn:aws:sns:us-east-1:123456789012:myTopicName"
]
}
]
}
```
*Risorse basate su un percorso o che pubblicano in `TargetArn` o `PhoneNumber`*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sns:Publish"
],
"Resource": "*"
}
]
}
```
# Invia messaggi a una coda Amazon SQS con Step Functions
Puoi inviare messaggi a una coda Amazon SQS utilizzando le seguenti azioni API Amazon SQS e un codice di stato di esempio `Task` per i flussi di lavoro Step Functions.
Per ulteriori informazioni sull'integrazione con AWS i servizi in Step Functions, vedere [Integrazione dei servizi ](integrate-services.md) e[Passaggio di parametri a un'API di servizio in Step Functions](connect-parameters.md).
Per ulteriori informazioni sulla ricezione di messaggi in Amazon SQS, consulta Receive [and Delete Your Message](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/step-receive-delete-message.html) nella *Amazon Simple Queue Service* Developer Guide.
L'esempio seguente include uno `Task` state (JSONata) che invia un messaggio Amazon Simple Queue Service (Amazon SQS) con opzione: **MessageAttributes**
```
{
"StartAt": "Send to SQS",
"States": {
"Send to SQS": {
"Type": "Task",
"Resource": "arn:aws:states:::sqs:sendMessage",
"Arguments": {
"QueueUrl": "https://sqs.us-east-1.amazonaws.com/account-id/myQueue",
"MessageBody": "{% $states.input.message %}",
"MessageAttributes": {
"my_attribute_no_1": {
"DataType": "String",
"StringValue": "attribute1"
},
"my_attribute_no_2": {
"DataType": "String",
"StringValue": "attribute2"
}
}
},
"End": true
}
}
}
```
La seguente macchina a stati include uno `Task` stato che pubblica su una coda Amazon SQS e quindi attende la restituzione del token dell'attività. Per informazioni, consulta [Attendi una richiamata con Task Token](connect-to-resource.md#connect-wait-token).
```
{
"StartAt":"Send message to SQS",
"States":{
"Send message to SQS":{
"Type":"Task",
"Resource":"arn:aws:states:::sqs:sendMessage.waitForTaskToken",
"Arguments":{
"QueueUrl":"https://sqs.us-east-1.amazonaws.com/account-id/myQueue",
"MessageBody":{
"Input" : "{% $states.input.message %}",
"MyTaskToken" : "{% $states.context.Task.Token %}"
}
},
"End":true
}
}
}
```
## Amazon SQS ottimizzato APIs
+ [https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)
**I parametri in Step Functions sono espressi in PascalCase**
Anche se l'API del servizio nativo è in CamelCase, ad esempio l'`startSyncExecution`azione API, si specificano parametri PascalCase in, ad esempio:. `StateMachineArn`
**Quota per i dati di input o di risultato**
Quando si inviano o si ricevono dati tra servizi, l'input o il risultato massimo per un'attività è di 256 KB di dati come stringa con codifica UTF-8. Per informazioni, consulta [Quote relative alle esecuzioni di macchine a stati](service-quotas.md#service-limits-state-machine-executions).
## Politiche IAM per le chiamate ad Amazon SQS
I seguenti modelli di esempio mostrano come AWS Step Functions generare le politiche IAM in base alle risorse nella definizione della macchina a stati. Per ulteriori informazioni, consultare [In che modo Step Functions genera policy IAM per servizi integrati](service-integration-iam-templates.md) e [Scopri i modelli di integrazione dei servizi in Step Functions](connect-to-resource.md).
*Risorse statiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sqs:SendMessage"
],
"Resource": [
"arn:aws:sqs:us-east-1:123456789012:myQueueName"
]
}
]
}
```
*Risorse dinamiche*
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sqs:SendMessage"
],
"Resource": "*"
}
]
}
```
# Avvia una nuova macchina a AWS Step Functions stati da un'esecuzione in esecuzione
Step Functions si integra con la propria API come integrazione di servizi. Scopri come usare Step Functions per avviare una nuova esecuzione di una macchina a stati direttamente dallo stato dell'attività di un'esecuzione in esecuzione. Durante la creazione di nuovi flussi di lavoro, utilizza le [ esecuzioni di flusso di lavoro nidificate](concepts-nested-workflows.md) per ridurre la complessità dei flussi di lavoro principali e riutilizzare i processi comuni.
**Caratteristiche principali dell'integrazione Optimized Step Functions**
Il modello di [Esegui un processo (.sync)](connect-to-resource.md#connect-sync) integrazione è disponibile.
Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Inizia da un'attività](concepts-nested-workflows.md)
+ [Integrazione dei servizi ](integrate-services.md)
+ [Passaggio di parametri a un'API di servizio in Step Functions](connect-parameters.md)
## Step Functions ottimizzate APIs
+ [https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)
## Esempi di flussi di lavoro
Di seguito è incluso uno stato `Task` che avvia l'esecuzione di un'altra macchina a stati e ne attende il completamento.
```
{
"Type":"Task",
"Resource":"arn:aws:states:::states:startExecution.sync:2",
"Arguments":{
"Input":{
"Comment": "Hello world!"
},
"StateMachineArn":"arn:aws:states:region:account-id:stateMachine:HelloWorld",
"Name":"ExecutionName"
},
"End":true
}
```
Di seguito è incluso uno stato `Task` che avvia l'esecuzione di un'altra macchina a stati.
```
{
"Type":"Task",
"Resource":"arn:aws:states:::states:startExecution",
"Arguments":{
"Input":{
"Comment": "Hello world!"
},
"StateMachineArn":"arn:aws:states:region:account-id:stateMachine:HelloWorld",
"Name":"ExecutionName"
},
"End":true
}
```
L’esempio seguente include uno stato `Task` che implementa il modello di integrazione del servizio di [callback](connect-to-resource.md#connect-wait-token).
```
{
"Type":"Task",
"Resource":"arn:aws:states:::states:startExecution.waitForTaskToken",
"Arguments":{
"Input":{
"Comment": "Hello world!",
"token": "{% $states.context.Task.Token %}"
},
"StateMachineArn":"arn:aws:states:region:account-id:stateMachine:HelloWorld",
"Name":"ExecutionName"
},
"End":true
}
```
Per associare un'esecuzione annidata del workflow all'esecuzione principale che l'ha avviata, passate un parametro con nome speciale che include l'ID di esecuzione estratto dall'oggetto [Context](input-output-contextobject.md). Quando si avvia un'esecuzione nidificata, utilizza un parametro denominato `AWS_STEP_FUNCTIONS_STARTED_BY_EXECUTION_ID`. Passa l'ID di esecuzione e fai riferimento all'ID nell'oggetto Context con. `$states.context.Execution.Id` Per ulteriori informazioni, consulta [Accesso all'oggetto Context](input-output-contextobject.md#contextobject-access).
```
{
"Type":"Task",
"Resource":"arn:aws:states:::states:startExecution.sync",
"Arguments":{
"Input":{
"Comment": "Hello world!",
"AWS_STEP_FUNCTIONS_STARTED_BY_EXECUTION_ID": "{% $states.context.Execution.Id %}"
},
"StateMachineArn":"arn:aws:states:region:account-id:stateMachine:HelloWorld",
"Name":"ExecutionName"
},
"End":true
}
```
Le macchine a stato nidificato restituiscono quanto segue:
| Risorsa | Output |
| --- | --- |
| startExecution.sync | Stringa |
| startExecution.sync:2 | JSON |
Entrambi attenderanno il completamento della macchina a stati nidificati, ma restituiscono formati `Output` diversi. Ad esempio, se crei una funzione Lambda che restituisce l'oggetto`{ "MyKey": "MyValue" }`, otterrai le seguenti risposte:
Per startExecution.sync:
```
{
"Output": "{ \"MyKey\": \"MyValue\" }"
}
```
Per startExecution.sync:2:
```
{
"Output": {
"MyKey": "MyValue"
}
}
```
### Configurazione delle autorizzazioni IAM per macchine a stati annidate
Una macchina a stati principale determina se una macchina a stati figlio ha completato l'esecuzione utilizzando polling ed eventi. Il polling richiede l'autorizzazione `states:DescribeExecution` mentre gli eventi inviati EventBridge a Step Functions richiedono le autorizzazioni per `events:PutTargets``events:PutRule`, e. `events:DescribeRule` Se nel tuo ruolo IAM mancano queste autorizzazioni, potrebbe verificarsi un ritardo prima che una macchina a stati principale venga a conoscenza del completamento dell'esecuzione della macchina a stati secondari.
Per una macchina a stati che richiede `StartExecution` l'esecuzione di un singolo flusso di lavoro annidato, utilizza una policy IAM che limiti le autorizzazioni a quella macchina a stati.
## Politiche IAM per chiamare flussi di lavoro Step Functions annidati
Per una macchina a stati che richiede `StartExecution` l'esecuzione di un singolo flusso di lavoro nidificato, utilizza una policy IAM che limiti le autorizzazioni a quella macchina a stati.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"states:StartExecution"
],
"Resource": [
"arn:aws:states:us-east-1:123456789012:stateMachine:myStateMachineName"
]
}
]
}
```
Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Integrazione dei servizi con Step Functions](integrate-services.md)
+ [Passaggio di parametri a un'API di servizio in Step Functions](connect-parameters.md)
+ [Avvia una nuova macchina a AWS Step Functions stati da un'esecuzione in esecuzione](#connect-stepfunctions)
------
#### [ Synchronous ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"states:StartExecution"
],
"Resource": [
"arn:aws:states:us-east-1:123456789012:stateMachine:stateMachineName"
]
},
{
"Effect": "Allow",
"Action": [
"states:DescribeExecution",
"states:StopExecution"
],
"Resource": [
"arn:aws:states:us-east-1:123456789012:execution:myStateMachineName:*"
]
},
{
"Effect": "Allow",
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": [
"arn:aws:events:us-east-1:123456789012:rule/StepFunctionsGetEventsForStepFunctionsExecutionRule"
]
}
]
}
```
------
#### [ Asynchronous ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"states:StartExecution"
],
"Resource": [
"arn:aws:states:us-east-1:123456789012:stateMachine:myStateMachineName"
]
}
]
}
```
------
**Tipi di ARN richiesti**
Nella politica per **Synchronous**, si noti che `states:StartExecution` richiede un ARN per una macchina a stati `states:DescribeExecution` mentre `states:StopExecution` e richiede un ARN di esecuzione.
Se combini erroneamente tutte e tre le azioni, il JSON sarà valido ma la policy IAM non sarà corretta. Una policy errata può causare problemi di and/or accesso ai flussi di lavoro bloccati durante l'esecuzione del flusso di lavoro.
Per ulteriori informazioni sulle esecuzioni di flussi di lavoro nidificati, consulta [Avvia le esecuzioni del flusso di lavoro da uno stato di attività in Step Functions](concepts-nested-workflows.md).