Creación y administración de clústeres de Amazon EKS con Step Functions

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.

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.

Aprenda a integrar Step Functions con Amazon EKS para administrar 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 le permite usar Amazon EKS APIs para crear y administrar un clúster de Amazon EKS. El otro le permite interactuar con el clúster mediante la API de Kubernetes y ejecutar trabajos como parte del flujo de trabajo de la aplicación.

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

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

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

Integraciones de API de Kubernetes

Step Functions es compatible con los siguientes Kubernetes APIs:

RunJob

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

El servidor de la API de Kubernetes debe conceder permisos al rol de IAM que utiliza 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 servicio eks:call le permite usar la API de Kubernetes para leer y escribir objetos de recursos de Kubernetes a través de un punto de conexión de la API de Kubernetes.

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

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

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 EKS optimizado APIs

Amazon EKS APIs y la sintaxis compatibles incluyen:

El ejemplo siguiente incluye una Task que crea un clúster de Amazon EKS.

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

El ejemplo siguiente incluye un estado Task que elimina un clúster de Amazon EKS.

{
  "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 clúster de Amazon EKS mediante la integración del servicio eks:createCluster, el rol de IAM se añade a la tabla de autorización de RBAC de Kubernetes como administrador, con permisos system:masters. Inicialmente, solo esa entidad de IAM puede realizar llamadas al servidor de la API de Kubernetes. Por ejemplo, no se podrá usar kubectl para interactuar con el servidor de API de Kubernetes, a menos que se asuma el mismo rol que su máquina de estado de Step Functions o si configura Kubernetes para conceder permisos a entidades de IAM adicionales. Para obtener más información, consulte Administración de usuarios o roles de IAM para su clúster en la Guía del usuario de Amazon EKS.

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

El ejemplo siguiente incluye un estado Task que crea un aws-auth ConfigMap y otorga un permiso system:masters al usuario arn:aws:iam::123456789012:user/my-user y al rol de 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 el clúster se creó fuera de Step Functions, puede configurar kubectl para que se comunique con su servidor de API de Kubernetes. 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 el rol de IAM no tiene permisos suficientes en Kubernetes, las integraciones de servicios eks:call o eks:runJob generarán 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"
}

            

Políticas de IAM para llamar a Amazon EKS

Las siguientes plantillas de ejemplo muestran cómo se AWS Step Functions generan las políticas de IAM en función de los recursos de la definición de su máquina de estados. Para obtener más información, consulte Generación de políticas de IAM para servicios integrados por Steps Functions y Descubrimiento de 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 cómo usar Amazon EKS con Step Functions, consulte Creación y administración de clústeres de Amazon EKS con Step Functions.