Integrazioni Kubernetes API Amazon supportato EKS APIs Autorizzazioni IAMpolitiche

Crea e gestisci EKS cluster Amazon con Step Functions

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

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

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

Caratteristiche principali dell'EKSintegrazione ottimizzata con Amazon

Il modello di Esegui un processo (.sync) integrazione è supportato.
Non ci sono ottimizzazioni per il modello di Richiesta e risposta integrazione.
Il modello di Attendi una richiamata con Task Token integrazione non è supportato.

Nota

L'EKSintegrazione Step Functions supporta solo Kubernetes APIs con accesso pubblico agli endpoint. Per impostazione predefinita, gli endpoint EKS dei API server dei cluster hanno accesso pubblico. Per ulteriori informazioni, consulta Amazon EKS Cluster Endpoint Access Control nella Amazon EKS User Guide.

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

Eliminazione di un cluster nella Amazon EKS User Guide.
Esegui un processo (.sync)in Modelli di integrazione dei servizi.

Nota

Esiste una quota per la dimensione massima dei dati di input o risultato per un'attività in Step Functions. Ciò limita a 256 KB di dati come stringa con codifica UTF -8 quando si inviano o si ricevono dati da un altro servizio. Per informazioni, consulta Quote relative alle esecuzioni di macchine a stati.

Integrazioni Kubernetes API

Step Functions supporta i seguenti Kubernetes: APIs

RunJob

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

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

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

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

I parametri supportati includono:

ClusterName: il nome del EKS cluster Amazon che desideri chiamare.
- Type: String
- Obbligatorio: sì
CertificateAuthority: I dati del certificato con codifica Base64 necessari per comunicare con il cluster. Puoi ottenere questo valore dalla EKSconsole Amazon o utilizzando Amazon EKS DescribeClusterAPI.
- Type: String
- Obbligatorio: sì
Endpoint: L'endpoint URL per il tuo server KubernetesAPI. Puoi ottenere questo valore dalla EKSconsole Amazon o utilizzando Amazon EKS DescribeClusterAPI.
- Type: String
- Obbligatorio: sì
Namespace: lo spazio dei nomi in cui eseguire il processo. Se non viene fornito, viene utilizzato lo spazio dei nomidefault.
- Type: String
- Obbligatorio: no
Job: La definizione di Kubernetes Job. Vedi Jobs nella documentazione di Kubernetes.
- Type: JSON o String
- Obbligatorio: sì
LogOptions: Un insieme di opzioni per controllare il recupero opzionale dei log. Applicabile solo se si utilizza il modello di integrazione del servizio Run a Job (.sync) per attendere il completamento del processo.
- Type: JSON
- Obbligatorio: no
- I log sono inclusi nella risposta sotto la chiave. logs All'interno del job possono essere presenti più pod, ciascuno con più contenitori.
```
{ 
  ...
  "logs": { 
    "pods": { 
      "pod1": { 
        "containers": { 
          "container1": { 
            "log": <log> 
          },
          ...
        }
      },
      ...
    }
  }
```
- 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. JSON Per impostazione predefinita, i log vengono deserializzati, se possibile. JSON 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: Il Read Log di Kubernetes API supporta i API 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 di API Kubernetes 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",
      "Parameters": {
        "ClusterName": "MyCluster",
        "CertificateAuthority": "ANPAJ2UCCR6DPCEXAMPLE",
        "Endpoint": "https://AKIAIOSFODNN7EXAMPLE.yl4.us-east-1.eks.amazonaws.com",
        "LogOptions": {
          "RetrieveLogs": true
        },
        "Job": {
          "apiVersion": "batch/v1",
          "kind": "Job",
          "metadata": {
            "name": "example-job"
          },
          "spec": {
            "backoffLimit": 0,
            "template": {
              "metadata": {
                "name": "example-job"
              },
              "spec": {
                "containers": [
                  {
                    "name": "pi-2000",
                    "image": "perl",
                    "command": [ "perl" ],
                    "args": [
                      "-Mbignum=bpi",
                      "-wle",
                      "print bpi(2000)"
                    ]
                  }
                ],
                "restartPolicy": "Never"
              }
            }
          }
        }
      },
      "End": true
    }
  }
}

`Call`

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

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

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

I parametri supportati includono: Call

ClusterName: il nome del EKS cluster Amazon che desideri chiamare.
- Type: Stringa
- Campo obbligatorio: sì
CertificateAuthority: I dati del certificato con codifica Base64 necessari per comunicare con il cluster. Puoi ottenere questo valore dalla EKSconsole Amazon o utilizzando Amazon EKS DescribeClusterAPI.
- Type: String
- Campo obbligatorio: sì
Endpoint: L'endpoint URL per il tuo server KubernetesAPI. Puoi trovare questo valore sulla EKSconsole Amazon o utilizzando Amazon EKS ' DescribeCluster API.
- Type: String
- Campo obbligatorio: sì
Method: Il HTTP metodo della tua richiesta. Uno tra: GET, POST, PUT, DELETE, HEAD, o PATCH.
- Type: String
- Campo obbligatorio: sì
Path: il HTTP percorso dell'operazione Kubernetes RESTAPI.
- Type: String
- Campo obbligatorio: sì
QueryParameters: i parametri di HTTP interrogazione dell'operazione Kubernetes. REST API
- Type: Mappa di String List of Strings
- Campo obbligatorio: no
- Esempio:
```
"QueryParameters": {
  "labelSelector": [ "job-name=example-job" ]
}
```
RequestBody: il corpo del HTTP messaggio dell'operazione Kubernetes RESTAPI.
- Type: JSON o String
- Campo 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",
      "Parameters": {
        "ClusterName": "MyCluster",
        "CertificateAuthority": "ANPAJ2UCCR6DPCEXAMPLE",
        "Endpoint": "https://444455556666.yl4.us-east-1.eks.amazonaws.com",
        "Method": "GET",
        "Path": "/api/v1/namespaces/default/pods",
        "QueryParameters": {
          "labelSelector": [
            "job-name=example-job"
          ]
        }
      },
      "End": true
    }
  }
}

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


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

Amazon supportato EKS APIs

Amazon EKS APIs e la sintassi supportate includono:

CreateCluster
- Sintassi della richiesta
- Sintassi della risposta
  
  Quando viene creato un EKS cluster Amazon utilizzando l'integrazione del eks:createCluster servizio, il IAM ruolo viene aggiunto alla tabella di RBAC autorizzazione di Kubernetes come amministratore (con autorizzazioni system:masters). Inizialmente, solo quell'IAMentità può effettuare chiamate al server Kubernetes. API Per ulteriori informazioni, consultare:
  - Gestione di utenti o IAM ruoli per il tuo cluster nella Amazon EKS User Guide
  - La Autorizzazioni sezione
  Amazon EKS utilizza ruoli collegati ai servizi che contengono le autorizzazioni richieste da EKS Amazon per chiamare altri servizi per tuo conto. Se questi ruoli collegati al servizio non esistono già nel tuo account, devi aggiungere l'iam:CreateServiceLinkedRoleautorizzazione al IAM ruolo utilizzato da Step Functions. Per ulteriori informazioni, consulta Using Service-Linked Roles nella Amazon EKS User Guide.
  
  Il IAM ruolo utilizzato da Step Functions deve disporre iam:PassRole delle autorizzazioni per passare il IAM ruolo del cluster ad AmazonEKS. Per ulteriori informazioni, consulta il IAMruolo EKS del cluster Amazon nella Amazon EKS User Guide.
DeleteCluster
- Sintassi della richiesta
- Sintassi della risposta
  
  È necessario eliminare qualsiasi profilo o gruppo di nodi Fargate prima di eliminare un cluster.
CreateFargateProfile
- Sintassi della richiesta
- Sintassi della risposta
  
  Amazon EKS utilizza ruoli collegati ai servizi che contengono le autorizzazioni richieste da EKS Amazon per chiamare altri servizi per tuo conto. Se questi ruoli collegati al servizio non esistono già nel tuo account, devi aggiungere l'iam:CreateServiceLinkedRoleautorizzazione al IAM ruolo utilizzato da Step Functions. Per ulteriori informazioni, consulta Using Service-Linked Roles nella Amazon EKS User Guide.
  
  Amazon EKS on Fargate potrebbe non essere disponibile in tutte le regioni. Per informazioni sulla disponibilità delle regioni, consulta la sezione Fargate della Amazon EKS User Guide.
  
  Il IAM ruolo utilizzato da Step Functions deve disporre iam:PassRole delle autorizzazioni per passare il IAM ruolo di esecuzione del pod ad AmazonEKS. Per ulteriori informazioni, consulta il ruolo di esecuzione del Pod nella Amazon EKS User Guide.
DeleteFargateProfile
- Sintassi della richiesta
- Sintassi della risposta
CreateNodegroup
- Sintassi della richiesta
- Sintassi della risposta
  
  Amazon EKS utilizza ruoli collegati ai servizi che contengono le autorizzazioni richieste da EKS Amazon per chiamare altri servizi per tuo conto. Se questi ruoli collegati al servizio non esistono già nel tuo account, devi aggiungere l'iam:CreateServiceLinkedRoleautorizzazione al IAM ruolo utilizzato da Step Functions. Per ulteriori informazioni, consulta Using Service-Linked Roles nella Amazon EKS User Guide.
  
  Il IAM ruolo utilizzato da Step Functions deve disporre iam:PassRole delle autorizzazioni per passare il IAM ruolo del nodo ad AmazonEKS. Per ulteriori informazioni, consulta Using Service-Linked Roles nella Amazon EKS User Guide.
DeleteNodegroup
- Sintassi della richiesta
- Sintassi della risposta

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


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

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


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

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


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

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


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

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


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

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


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

Autorizzazioni

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

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

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


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

Nota

È possibile che il ARN IAM ruolo venga visualizzato in un formato che include il percorso /service-role/, ad esempio. arn:aws:iam::123456789012: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 diaws-auth, aggiungere le autorizzazioni aggiuntive e PUT una nuova versione. Di solito è più facile da creare aws-auth prima del profilo Fargate.

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

Crea un kubeconfig per Amazon EKS nella Amazon EKS User Guide.
Gestione degli utenti o IAM dei ruoli per il tuo cluster nella Amazon EKS User Guide.

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


Error:
EKS.401

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

IAMpolitiche per le chiamate ad Amazon EKS

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

`CreateCluster`

Risorse


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

`CreateNodeGroup`

Risorse


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

`DeleteCluster`

Risorse


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

`DeleteNodegroup`

Risorse


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

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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

ECSAmazon/Fargate

Amazon EMR