Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Crea y gestiona EKS clústeres de Amazon con Step Functions

Aprenda a integrar Step Functions con Amazon EKS para gestionar los clústeres de Kubernetes. Step Functions ofrece dos tipos de integración de servicios APIs para la integración con Amazon Elastic Kubernetes Service. Una te permite usar Amazon EKS APIs para crear y administrar un EKS clúster de Amazon. La otra le permite interactuar con su clúster mediante Kubernetes API y ejecutar trabajos como parte del flujo de trabajo de su aplicación.

Puede usar las API integraciones de Kubernetes con clústeres de EKS Amazon creados con Step Functions, con clústeres de EKS Amazon creados con la herramienta eksctl o la consola de EKSAmazon, o métodos similares. Para obtener más información, consulta Cómo crear un EKS clúster de Amazon en la Guía del EKS usuario de Amazon.

Para obtener información sobre la integración con AWS servicios en Step Functions, consulte Integración de los servicios de yPasar parámetros a un servicio API en Step Functions.

Step Functions no termina un EKS clúster de Amazon automáticamente si se detiene la ejecución. Si tu máquina de estado se detiene antes de que tu EKS clúster de Amazon finalice, es posible que el clúster siga ejecutándose indefinidamente y que se acumulen cargos adicionales. Para evitarlo, asegúrate de que cualquier EKS clúster de Amazon que crees finalice correctamente. Para obtener más información, consulte:

Integraciones de Kubernetes API

Step Functions es compatible con los siguientes KubernetesAPIs:

RunJob

La integración eks:runJob de servicios te permite ejecutar un trabajo en tu EKS clúster de Amazon. Con la variante eks:runJob.sync, puede esperar a que se complete el trabajo y, opcionalmente, recuperar los registros.

El API servidor de Kubernetes debe conceder permisos al IAM rol que utilice la máquina de estado. Para obtener más información, consulte Permisos.

Para el patrón Ejecutar un trabajo (.sync), el estado del trabajo se determina mediante un sondeo. Step Functions sondea inicialmente a una velocidad de aproximadamente 1 sondeo por minuto. Con el tiempo, esta velocidad se reduce a aproximadamente 1 encuesta cada 5 minutos. Si necesita sondeos más frecuentes o necesita tener más control sobre la estrategia de sondeo, puede utilizar la integración eks:call para consultar el estado del trabajo.

La integracióneks:runJob es específica de los trabajos de Kubernetes batch/v1. Para obtener más información, consulte Trabajos en la documentación de Kubernetes. Si quiere gestionar otros recursos de Kubernetes, incluidos los recursos personalizados, utilice la integración del servicio eks:call. Puede usar Step Functions para crear bucles de sondeo, como se ilustra en el proyecto de muestra Encuesta sobre la situación laboral con Lambda y AWS Batch.

Entre los parámetros admitidos se incluyen:

En el siguiente ejemplo se incluye un estado Task que ejecuta un trabajo, espera a que se complete y, posteriormente, recupera los registros del trabajo:

{
  "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

La integración del eks:call servicio le permite usar Kubernetes para leer y escribir objetos de recursos de Kubernetes API a través de un punto final de Kubernetes. API

El API servidor de Kubernetes debe conceder permisos al rol que utilice la máquina de estado. IAM Para obtener más información, consulte Permisos.

Para obtener más información sobre las operaciones disponibles, consulta la Referencia de Kubernetes. API

Entre los parámetros admitidos para Call se incluyen:

El ejemplo siguiente incluye un estado Task que utiliza eks:call para enumerar los pods que pertenecen al trabajo 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
    }
  }
}

El ejemplo siguiente incluye un estado Task que utiliza eks:call para eliminar el trabajo example-job y establece la propagationPolicy para garantizar que también se eliminan los pods del trabajo.

{
  "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 compatible EKS APIs

Amazon EKS APIs y la sintaxis compatibles incluyen:

A continuación se incluye una Task que crea un EKS clúster de 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
    }
  }
}

A continuación se incluye un Task estado que elimina un EKS clúster de Amazon.

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

El ejemplo siguiente incluye un estado Task que crea un perfil de 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
    }
  }
}

El ejemplo siguiente incluye un estado Task que elimina un perfil de Fargate.

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

El ejemplo siguiente incluye un estado Task que crea un grupo de nodos.

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

El ejemplo siguiente incluye un estado Task que elimina un grupo de nodos.

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

Permisos

Cuando se crea un EKS clúster de Amazon mediante la integración de eks:createCluster servicios, el IAM rol se añade a la tabla de RBAC autorizaciones de Kubernetes como administrador, con permisos. system:masters Inicialmente, solo esa IAM entidad puede realizar llamadas al servidor de Kubernetes. API Por ejemplo, no podrás usar kubectl para interactuar con tu API servidor de Kubernetes, a menos que asumas la misma función que tu máquina de estados de Step Functions o si configuras Kubernetes para conceder permisos a entidades adicionales. IAM Para obtener más información, consulta Administrar usuarios o IAM roles para tu clúster en la Guía del EKS usuario de Amazon.

Puedes añadir permisos para IAM entidades adicionales, como usuarios o roles, añadiéndolas al espacio de nombres aws-auth ConfigMap del sistema kube. Si va a crear el clúster a partir de Step Functions, utilice la integración del servicio eks:call.

A continuación se incluye un Task estado que crea aws-auth ConfigMap y otorga system:masters permisos al usuario y al rol. arn:aws:iam::123456789012:user/my-user IAM arn: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
    }
  }

Cuando el clúster se crea por primera vez, aws-auth ConfigMap no existirá, sino que se agregará automáticamente si crea un perfil de Fargate. Puede recuperar el valor actual de aws-auth, añadir los permisos adicionales y PUT una nueva versión. Por lo general, es más sencillo crear aws-auth antes que el perfil de Fargate.

Si tu clúster se creó fuera de Step Functions, puedes configurar kubectl para que se comunique con tu servidor de Kubernetes. API A continuación, se crea un nuevo aws-auth ConfigMap mediante kubectl apply -f aws-auth.yaml o se edita uno que ya exista mediante kubectl edit -n kube-system configmap/aws-auth. Para obtener más información, consulte:

Si tu IAM rol no tiene permisos suficientes en Kubernetes, las integraciones eks:call o los eks:runJob servicios fallarán y se mostrará el siguiente error:

Error:
EKS.401

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

            

IAMpolíticas para llamar a Amazon EKS

En las siguientes plantillas de ejemplo se muestra cómo AWS Step Functions genera IAM políticas en función de los recursos de la definición de su máquina de estados. Para obtener más información, consulte Cómo Step Functions genera IAM políticas para servicios integrados y Descubra los patrones de integración de servicios en Step Functions.

CreateCluster

Recursos

{
    "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

Recursos

{
    "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

Recursos

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

DeleteNodegroup

Recursos

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

Para obtener más información sobre el uso de Amazon EKS con Step Functions, consulteCrea y gestiona EKS clústeres de Amazon con Step Functions.