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á.

Crie e gerencie EKS clusters da Amazon com Step Functions

Saiba como integrar o Step Functions com EKS a Amazon para gerenciar clusters 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 a Amazon EKS APIs para criar e gerenciar um EKS cluster da Amazon. A outra permite que você interaja com seu cluster usando o Kubernetes API e execute trabalhos como parte do fluxo de trabalho do seu aplicativo.

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

Para saber mais sobre a integração com AWS serviços em Step Functions, consulte e. Integração de produtos da Passando parâmetros para um serviço API em Step Functions

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

Integrações com o Kubernetes API

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

RunJob

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

Seu API servidor Kubernetes deve conceder permissões para a IAM função usada 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 eks:call serviço permite que você use o Kubernetes para ler e gravar objetos de recursos do Kubernetes API por meio de um endpoint do Kubernetes. API

Seu API servidor Kubernetes deve conceder permissões para a IAM função usada 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 do Kubernetes API.

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 compatível EKS APIs

A Amazon EKS APIs e a sintaxe suportadas incluem:

O seguinte inclui um Task que cria um EKS cluster da 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
    }
  }
}

O seguinte inclui um Task estado que exclui um EKS cluster da Amazon.

{
  "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 EKS cluster da Amazon é criado usando a integração eks:createCluster de serviços, a IAM função é adicionada à tabela de RBAC autorização do Kubernetes como administrador, com permissões. system:masters Inicialmente, somente essa IAM entidade pode fazer chamadas para o servidor KubernetesAPI. Por exemplo, você não poderá usar o kubectl para interagir com seu API servidor 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. IAM Para obter mais informações, consulte Gerenciamento de usuários ou IAM funções para seu cluster no Guia EKS do usuário da Amazon.

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

O seguinte inclui um Task estado que cria aws-auth ConfigMap e concede system:masters permissão ao usuário arn:aws:iam::123456789012:user/my-user e à IAM funçãoarn: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 API 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 sua IAM função não tiver permissões suficientes no Kubernetes, as integrações eks:call ou eks:runJob serviços 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"
}

            

IAMpolíticas para ligar para a Amazon EKS

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