Criar e gerenciar clusters do Amazon EKS com o Step Functions

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Saiba como integrar o Step Functions ao Amazon EKS para gerenciar clusters do Kubernetes. O Step Functions fornece dois tipos de integração de serviços APIs para integração com o Amazon Elastic Kubernetes Service. Uma delas permite que você use o Amazon EKS APIs para criar e gerenciar um cluster do Amazon EKS. A outra permite que você interaja com seu cluster usando a API Kubernetes e execute trabalhos como parte do fluxo de trabalho do seu aplicativo.

Você pode usar as integrações da API do Kubernetes com clusters do Amazon EKS criados usando Step Functions, com clusters do Amazon EKS criados pela ferramenta eksctl ou pelo console do Amazon EKS ou métodos similares. Para obter mais informações, consulte Criação de um cluster para o Amazon EKS no Guia do usuário do Amazon EKS.

Para saber mais sobre a integração com AWS serviços no Step Functions, consulte Integração de produtos da e. Transmitir parâmetros a uma API de serviço no Step Functions

O Step Functions não encerra automaticamente um cluster do Amazon EKS se a execução for interrompida. Se sua máquina de estado parar antes do encerramento do cluster Amazon EKS, seu cluster poderá continuar funcionando indefinidamente e poderá acumular cobranças adicionais. Para evitar isso, certifique-se de que qualquer cluster do Amazon EKS que você criar seja encerrado corretamente. Para obter mais informações, consulte:

Integrações da API do Kubernetes

O Step Functions é compatível com os seguintes APIs Kubernetes:

RunJob

A integração do serviço eks:runJob permite que você execute um trabalho no cluster do Amazon EKS. A variante eks:runJob.sync permite que você aguarde a conclusão do trabalho e, opcionalmente, recupere os registros.

Seu servidor da API do Kubernetes deve conceder permissões para o perfil do IAM usado pela sua máquina de estado. Para obter mais informações, consulte Permissões.

Para o padrão Executar um trabalho (.sync), o status do trabalho é determinado por meio de pesquisa. O Step Functions pesquisa inicialmente a uma taxa de aproximadamente 1 pesquisa por minuto. Por fim, essa taxa diminui para aproximadamente 1 pesquisa a cada 5 minutos. Se você precisar de pesquisas mais frequentes ou precisar de mais controle sobre a estratégia de pesquisa, poderá usar a integração eks:call para consultar o status do trabalho.

A integração eks:runJob é específica para batch/v1 Tarefas no Kubernetes. Para obter mais informações, consulte Tarefas na documentação do Kubernetes. Se você quiser gerenciar outros recursos do Kubernetes, incluindo recursos personalizados, use a integração de serviços eks:call. Você pode usar o Step Functions para criar ciclos de pesquisa, conforme demonstrado no projeto de exemplo de Pesquisa sobre a situação do trabalho na Lambda e AWS Batch.

Os parâmetros compatíveis incluem:

O exemplo a seguir inclui um estado Task que executa um trabalho, aguarda sua conclusão e, em seguida, recupera os logs do trabalho:

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

A integração do serviço eks:call permite que você use a API do Kubernetes para ler e gravar objetos de recursos do Kubernetes por meio de um endpoint da API do Kubernetes.

Seu servidor da API do Kubernetes deve conceder permissões para o perfil do IAM usado pela sua máquina de estado. Para obter mais informações, consulte Permissões.

Para obter mais informações sobre as operações disponíveis, consulte a Referência de API do Kubernetes.

Os parâmetros compatíveis para Call incluem:

Veja a seguir um estado Task que utiliza eks:call para listar os pods pertencentes à tarefa 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
    }
  }
}

Veja a seguir um estado Task que utiliza eks:call para excluir a tarefa example-job e define o propagationPolicy para garantir que os pods da tarefa também sejam excluídos.

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

A APIs sintaxe e o Amazon EKS compatíveis incluem:

Veja a seguir um Task que cria um cluster do 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
    }
  }
}

Veja a seguir um estado Task que exclui um cluster do Amazon EKS.

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

Veja a seguir um estado Task que cria um perfil do 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
    }
  }
}

Veja a seguir um estado Task que exclui um perfil do Fargate.

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

Veja a seguir um estado Task que cria um grupo de nós.

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

Veja a seguir um estado Task que exclui um grupo de nós.

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

Permissões

Quando um cluster do Amazon EKS é criado usando a integração do serviço eks:createCluster, o perfil do IAM é adicionado à tabela de autorização RBAC do Kubernetes como o administrador, com permissões do system:masters. Inicialmente, somente a entidade do IAM pode fazer chamadas para o servidor da API do Kubernetes. Por exemplo, você não poderá usar o kubectl para interagir com seu servidor de API do Kubernetes, a menos que assuma a mesma função da sua máquina de estado Step Functions ou configure o Kubernetes para conceder permissões a entidades adicionais do IAM. Para obter mais informações, consulte Gerenciar usuários ou funções do IAM para o seu cluster no Guia do Usuário do Amazon EKS.

Você pode adicionar permissão para entidades adicionais do IAM, como usuários ou funções, adicionando-as ao namespace aws-auth ConfigMap no kube-system. Se você estiver criando seu cluster a partir do Step Functions, use a integração de serviços eks:call.

Veja a seguir um estado Task que cria aws-auth ConfigMap e concede permissão system:masters ao usuário arn:aws:iam::123456789012:user/my-user e ao perfil do IAMarn: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
    }
  }

Quando seu cluster for criado pela primeira vez, o aws-auth ConfigMap não existirá, mas será adicionado automaticamente se você criar um perfil do Fargate. Você pode recuperar o valor atual deaws-auth, adicionar as permissões adicionais e PUT uma nova versão. Normalmente, é mais fácil criar aws-auth antes do perfil do Fargate.

Se seu cluster foi criado fora do Step Functions, você pode configurar o kubectl para se comunicar com seu servidor de API do Kubernetes. Em seguida, crie um novo aws-auth ConfigMap usando kubectl apply -f aws-auth.yaml ou edite um que já exista usandokubectl edit -n kube-system configmap/aws-auth. Para obter mais informações, consulte:

Se seu perfil do IAM não tiver permissões suficientes no Kubernetes, as integrações dos serviços eks:call ou eks:runJob falharão com o seguinte erro:

Error:
EKS.401

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

            

Políticas do IAM para chamar o Amazon EKS

Os modelos de exemplo a seguir mostram como AWS Step Functions gera políticas do IAM com base nos recursos na definição da sua máquina de estado. Para ter mais informações, consulte Como o Step Functions gera políticas do IAM para serviços integrados e Descobrir padrões de integração de serviços no 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 ver mais informações sobre o uso do Amazon EKS com o Step Functions, consulte Criar e gerenciar clusters do Amazon EKS com o Step Functions.