Configuração do ajuste de escala automático orientado por eventos no Amazon EKS usando o Identidade de Pods do Amazon EKS e o KEDA - Recomendações da AWS

Configuração do ajuste de escala automático orientado por eventos no Amazon EKS usando o Identidade de Pods do Amazon EKS e o KEDA

Dipen Desai, Abhay Diwan, Kamal Joshi e Mahendra Revanasiddappa, Amazon Web Services

Resumo

Plataformas de orquestração, como o Amazon Elastic Kubernetes Service (Amazon EKS), simplificaram o gerenciamento do ciclo de vida de aplicações baseadas em contêineres. Isso ajuda as organizações a se concentrarem na criação, proteção, operação e manutenção de aplicações baseadas em contêineres. À medida que as implantações orientadas por eventos se tornam mais comuns, as organizações estão escalando com mais frequência as implantações do Kubernetes com base em várias fontes de eventos. Esse método, combinado com o ajuste de escala automático, pode resultar em economias de custo significativas ao fornecer recursos computacionais sob demanda e escalabilidade eficiente, adaptada à lógica da aplicação.

O KEDA é um autoescalador baseado no Kubernetes orientado por eventos. O KEDA ajuda você a escalar qualquer contêiner no Kubernetes com base no número de eventos que precisam ser processados. Ele é leve e se integra a qualquer cluster do Kubernetes. Ele também funciona com componentes padrão do Kubernetes, como o ajuste de escala automático de pod horizontal (HPA). O KEDA também oferece TriggerAuthentication, que é um recurso que ajuda você a delegar a autenticação. Ele permite que você descreva os parâmetros de autenticação separados do ScaledObject e dos contêineres de implantação.

A AWS fornece perfis do AWS Identity and Access Management (IAM) que oferecem suporte a diversas opções de implantação do Kubernetes, incluindo o Amazon EKS, o Amazon EKS Anywhere, o Serviço Red Hat OpenShift na AWS (ROSA) e clusters autogerenciados do Kubernetes no Amazon Elastic Compute Cloud (Amazon EC2). Esses perfis usam constructos do IAM, como provedores de identidade do OpenID Connect (OIDC) e políticas de confiança do IAM, para operar em diferentes ambientes sem depender diretamente dos serviços ou APIs do Amazon EKS. Para obter mais informações, consulte Perfis do IAM para contas de serviço na documentação do Amazon EKS.

A Identidade de Pods do Amazon EKS simplifica o processo para que as contas de serviço do Kubernetes assumam perfis do IAM sem exigir provedores de OIDC. Ela fornece a capacidade de gerenciar credenciais para suas aplicações. Em vez de criar e distribuir as credenciais da AWS para os contêineres ou usar o perfil da instância do Amazon EC2, você pode associar um perfil do IAM a uma conta de serviço do Kubernetes e configurar os pods para usar a conta de serviço. Isso ajuda você a usar um perfil do IAM em vários clusters e simplifica o gerenciamento de políticas ao permitir a reutilização de políticas de permissão em todos os perfis do IAM.

Ao implementar o KEDA com a Identidade de Pods do Amazon EKS, as empresas podem implantar o ajuste de escala automático eficiente orientado por eventos e o gerenciamento simplificado de credenciais. As aplicações são dimensionadas com base na demanda, o que otimiza a utilização dos recursos e reduz os custos.

Este padrão ajuda você a integrar a Identidade de Pods do Amazon EKS com o KEDA. Ele mostra como você pode usar a conta de serviço keda-operator e delegar a autenticação com TriggerAuthentication. Também descreve como configurar uma relação de confiança entre um perfil do IAM para o operador do KEDA e um perfil do IAM para a aplicação. Essa relação de confiança permite que o KEDA monitore mensagens nas filas de eventos e ajuste a escala para os objetos do Kubernetes de destino.

Pré-requisitos e limitações

Pré-requisitos

  • AWS Command Line Interface (AWS CLI) versão 2.13.17 ou posterior, instalado

  • Python versão 3.11.5 ou posterior, instalado

  • AWS SDK para Python (Boto3) versão 1.34.135 ou posterior, instalado

  • Helm versão 3.12.3 ou posterior, instalado

  • kubectl versão 1.25.1 ou posterior, instalado

  • Docker Engine versão 26.1.1 ou posterior, instalado

  • Um cluster do Amazon EKS versão 1.24 ou posterior, criado

  • Pré-requisitos para criar o agente da Identidade de Pods do Amazon EKS, atendidos

Limitações

  • É necessário que você estabeleça uma relação de confiança entre o perfil keda-operator e o perfil keda-identity. As instruções são fornecidas na seção Épicos deste padrão.

Arquitetura

Neste padrão, você criará os seguintes recursos AWS:

  • Repositório do Amazon Elastic Container Registry (Amazon ECR): neste padrão, esse repositório se chama keda-pod-identity-registry. Esse repositório privado é usado para armazenar imagens do Docker da aplicação de exemplo.

  • Fila do Amazon Simple Queue Service (Amazon SQS): neste padrão, essa fila se chama event-messages-queue. A fila funciona como um buffer de mensagens que coleta e armazena as mensagens recebidas. O KEDA monitora as métricas da fila, como contagem de mensagens ou comprimento da fila, e escala automaticamente a aplicação com base nessas métricas.

  • Perfil do IAM para a aplicação: neste padrão, esse perfil se chama keda-identity. O perfil keda-operator assume esse perfil. Esse perfil permite o acesso à fila do Amazon SQS.

  • Perfil do IAM para o operador do KEDA: neste padrão, esse perfil se chama keda-operator. O operador do KEDA usa esse perfil para fazer as chamadas da API da AWS necessárias. Esse perfil tem permissões para assumir o perfil keda-identity. Devido à relação de confiança entre o keda-operator e os perfis keda-identity, o perfil keda-operator tem permissões do Amazon SQS.

Por meio dos recursos personalizados TriggerAuthentication e ScaledObject do Kubernetes, o operador usa o perfil keda-identity para se conectar a uma fila do Amazon SQS. Com base no tamanho da fila, o KEDA escala automaticamente a implantação da aplicação. Ele adiciona um pod para cada cinco mensagens não lidas na fila. Na configuração padrão, se não houver mensagens não lidas na fila do Amazon SQS, a escala da aplicação é reduzida verticalmente para zero pods. O operador do KEDA monitora a fila em um intervalo especificado.

 

A imagem a seguir mostra como você usa a Identidade de Pods do Amazon EKS para fornecer ao perfil keda-operator acesso seguro à fila do Amazon SQS.

Usando o KEDA e a Identidade de Pods do Amazon EKS para escalar automaticamente uma aplicação baseada em Kubernetes.

O diagrama mostra o seguinte fluxo de trabalho:

  1. Você instala o agente da Identidade de Pods do Amazon EKS no cluster do Amazon EKS.

  2. Você implanta o operador do KEDA no namespace do cluster do Amazon EKS.

  3. Você cria os perfis do IAM keda-operator e keda-identity na conta de destino Conta da AWS.

  4. Você estabelece uma relação de confiança entre os perfis do IAM.

  5. Você implanta a aplicação no namespace security.

  6. O operador do KEDA enfileira as mensagens em uma fila do Amazon SQS.

  7. O KEDA inicia o HPA, que escala automaticamente a aplicação com base no tamanho da fila.

Ferramentas

Serviços da AWS

Outras ferramentas

  • O KEDA é um autoescalador baseado no Kubernetes orientado por eventos.

Repositório de código

O código para este padrão está disponível no repositório Event-driven auto scaling using EKS Pod Identity and KEDA do GitHub.

Práticas recomendadas

Convém seguir estas práticas recomendadas:

Épicos

TarefaDescriçãoHabilidades necessárias

Crie o perfil do IAM para o operador do KEDA.

  1. Faça login no Console de gerenciamento da AWS e, em seguida, abra o console do IAM.

  2. No painel de navegação, selecione Perfis.

  3. Escolha Criar Perfil.

  4. Selecione o tipo de função Custom trust policy (Política de confiança personalizada).

  5. Na seção Política de confiança personalizada, insira a seguinte política de confiança personalizada nesse perfil:

    { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "pods.eks.amazonaws.com" }, "Action": [ "sts:AssumeRole", "sts:TagSession" ] } ] }
  6. Na página Adicionar permissões, escolha Próximo. Você não adiciona nenhuma política a esse perfil.

  7. Em Nome do perfil, insira keda-operator.

  8. Escolha Create role (Criar função).

Administrador da AWS

Crie um perfil do IAM para a aplicação de exemplo.

  1. No console do IAM, selecione Perfis no painel de navegação.

  2. Selecione Criar perfil.

  3. Selecione o tipo de função Custom trust policy (Política de confiança personalizada).

  4. Na seção Política de confiança personalizada, insira a seguinte política de confiança personalizada nesse perfil. Substitua <account number> pelo número da sua conta de destino:

    { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "pods.eks.amazonaws.com", "AWS": "arn:aws:iam::<account number>:role/keda-operator" }, "Action": [ "sts:AssumeRole", "sts:TagSession" ] } ] }
  5. Na página Adicionar permissões, adicione as seguintes políticas gerenciadas AWS ao perfil:

    • AmazonSQSReadOnlyAccess

    • AWSLambdaSQSQueueExecutionRole

  6. Escolha Próximo.

  7. Em Nome do perfil, insira keda-identity.

  8. Escolha Create role (Criar função).

Administrador da AWS

Crie uma fila do Amazon SQS.

  1. Abra o console do Amazon SQS.

  2. Selecione Criar fila.

  3. Em Tipo, escolha Padrão.

  4. Na página Criar fila, em Nome, insira event-messages-queue.

  5. Selecione Criar fila. Você não altera nenhuma das configurações padrão dessa fila.

AWS geral

Crie um repositório do Amazon ECR.

  1. Abra o console do Amazon ECR.

  2. Escolha Criar repositório.

  3. Em Nome do repositório, insira keda-pod-identity-registry.

  4. Escolha Criar repositório. Você não altera nenhuma das configurações padrão desse repositório.

AWS geral
TarefaDescriçãoHabilidades necessárias

Implante o agente da Identidade de Pods do Amazon EKS.

Para o cluster de destino do Amazon EKS, configure o agente da Identidade de Pods do Amazon EKS. Siga as instruções em Configurar o atendente da Identidade de Pods do Amazon EKS na documentação do Amazon EKS.

AWS DevOps

Implante o KEDA.

  1. Insira os seguintes comandos para implantar o KEDA no cluster de destino do Amazon EKS:

    # Add Helm Repo for Keda helm repo add kedacore https://kedacore.github.io/charts # Update Helm repo helm repo update # Install Keda helm install keda kedacore/keda --namespace keda --create-namespace

    Para obter mais informações, consulte Deploying with Helm na documentação do KEDA.

  2. Após a implantação bem-sucedida, na saída, valide se três implantações foram criadas para o operador do KEDA. Este é um exemplo de saída:

    NAME READY UP-TO-DATE AVAILABLE AGE keda-admission-webhooks 1/1 1 1 89s keda-operator 1/1 1 1 89s keda-operator-metrics-apiserver 1/1 1 1 89s
Engenheiro de DevOps

Atribua o perfil do IAM à conta de serviço do Kubernetes.

Siga as instruções em Atribuir um perfil do IAM a uma conta de serviço do Kubernetes na documentação do Amazon EKS. Use os seguintes valores:

  • Para o perfil do IAM, insira keda-operator.

  • Em Namespace do Kubernetes, insira keda.

  • Para a Conta de serviço do Kubernetes, insira keda-operator.

AWS DevOps

Crie o namespace.

Insira o seguinte comando para criar um namespace security no cluster do Amazon EKS de destino:

kubectl create ns security
Engenheiro de DevOps
TarefaDescriçãoHabilidades necessárias

Clone os arquivos da aplicação.

Insira o seguinte comando para clonar o repositório Event-driven auto scaling using EKS Pod Identity and KEDA repository do GitHub:

git clone https://github.com/aws-samples/event-driven-autoscaling-using-podidentity-and-keda.git
Engenheiro de DevOps

Crie a imagem do Docker.

  1. Insira o seguinte comando para navegar até o repositório clonado:

    cd event-driven-autoscaling-using-podidentity-and-keda
  2. Insira o seguinte comando para compilar a imagem do Docker para a aplicação de exemplo:

    docker build -t keda-pod-identity-registry .
Engenheiro de DevOps

Envie a imagem do Docker para o Amazon ECR.

  1. No terminal em que você compilou a imagem do Docker, insira o comando a seguir para fazer login no Amazon ECR. Substitua <AWS_REGION> e <AWS_ACCOUNT_ID> pelos valores do seu ambiente da AWS:

    aws ecr get-login-password \ --region <AWS_REGION> | docker login \ --username AWS \ --password-stdin <AWS_ACCOUNT_ID>.dkr.ecr.<AWS_REGION>.amazonaws.com
  2. Insira o comando a seguir para marcar a imagem. Substitua <AWS_REGION> e <AWS_ACCOUNT_ID> pelos valores do seu ambiente da AWS:

    docker tag keda-pod-identity-registry:latest <AWS_ACCOUNT_ID>.dkr.ecr.<AWS_REGION>.amazonaws.com/keda-pod-identity-registry:latest

  3. Insira o comando a seguir para enviar a imagem por push ao Amazon ECR. Substitua <AWS_REGION> e <AWS_ACCOUNT_ID> pelos valores do seu ambiente da AWS:

    docker push <AWS_ACCOUNT_ID>.dkr.ecr.<AWS_REGION>.amazonaws.com/keda-pod-identity-registry:latest

nota

Você pode encontrar comandos push navegando até a página do repositório do Amazon ECR e, em seguida, escolhendo Visualizar comandos push.

Engenheiro de DevOps

Implante a aplicação de exemplo.

  1. No repositório clonado, abra o arquivo deploy.yaml.

  2. Substitua <AWS_ACCOUNT_ID> e <AWS_REGION> pelos valores do seu ambiente.

  3. Salve e feche o arquivo deploy.yaml.

  4. Insira o seguinte comando para implantar a aplicação de exemplo no cluster do Amazon EKS de destino:

    kubectl apply -f deploy.yaml

    Esse comando cria uma conta de implantação e serviço no cluster.

Engenheiro de DevOps

Atribua o perfil do IAM à conta de serviço da aplicação.

Siga uma destas etapas para associar o perfil keda-identity do IAM à conta de serviço da aplicação de exemplo:

  • Siga as instruções em Atribuir um perfil do IAM a uma conta de serviço do Kubernetes na documentação do Amazon EKS. Use os seguintes valores:

    • Para o perfil do IAM, insira keda-identity.

    • Em Namespace do Kubernetes, insira security.

    • Para a Conta de serviço do Kubernetes, insira my-sqs-read-msgs.

  • Insira o comando da AWS CLI a seguir. Substitua <cluster-name> pelo nome do cluster do Amazon EKS de destino e substitua <role-ARN> pelo nome do recurso da Amazon (ARN) do perfil keda-identity:

    aws eks create-pod-identity-association \ --cluster-name <cluster-name> \ --role-arn <role-ARN> \ --namespace security \ --service-account my-sqs-read-msgs
Engenheiro de DevOps

Implante ScaledObject e TriggerAuthentication.

  1. No repositório clonado, abra o arquivo keda.yaml.

  2. Substitua {{AWS_ACCOUNT_ID}} pelo ID da sua Conta da AWS de destino.

  3. Substitua {{AWS_REGION}} pela sua Região da AWS de destino.

  4. (Opcional) Nas linhas 21 a 24, atualize os parâmetros da política de escalabilidade ScaledObject. Consulte o seguinte para obter mais informações sobre esses parâmetros:

  5. Salve e feche o arquivo keda.yaml.

  6. Insira o seguinte comando para implantar os recursos ScaledObject e TriggerAuthentication.

    kubectl -n security apply -f keda.yaml
Engenheiro de DevOps
TarefaDescriçãoHabilidades necessárias

Envie mensagens para a fila do Amazon SQS.

  1. Insira o seguinte comando para navegar até o repositório clonado:

    cd event-driven-autoscaling-using-podidentity-and-keda
  2. Insira o seguinte comando para enviar mensagens de teste à fila do Amazon SQS:

    python sqs_send_msg.py

    O script sqs_send_msg.py atua como uma aplicação que gera mensagens para testar o ajuste de escala automático.

    nota

    Se você estiver executando o Python 3, insira python3 sqs_send_msg.py.

Engenheiro de DevOps

Monitore os pods de aplicação.

  1. Em um terminal diferente, insira o seguinte comando para monitorar os pods:

    kubectl -n security get po 
  2. Para cada cinco mensagens não lidas na fila do Amazon SQS, o KEDA adiciona um pod. Na saída do comando anterior, confirme se os novos pods estão sendo adicionados. Este é um exemplo de saída:

    kubectl -n security get po NAME READY STATUS RESTARTS AGE q-read-797f4c7589-2bj76 1/1 Running 0 2s q-read-797f4c7589-4zxph 1/1 Running 0 49s q-read-797f4c7589-cg9dt 1/1 Running 0 18s q-read-797f4c7589-slc69 1/1 Running 0 33s
  3. Ao terminar o teste, no terminal original, digite CTRL + C (Windows) ou CMD + C (macOS). Isso interrompe o script python sqs_send_msg.py.

Engenheiro de DevOps

Solução de problemas

ProblemaSolução

O operador do KEDA não pode escalar a aplicação.

Insira o seguinte comando para verificar os logs do perfil do IAM keda-operator:

kubectl logs -n keda -l app=keda-operator -c keda-operator

 

Se houver um código de resposta HTTP 403, a aplicação e o escalador do KEDA não terão permissões suficientes para acessar a fila do Amazon SQS. Execute as etapas a seguir:

  1. Verifique as declarações e as políticas do IAM do perfil keda-identity para confirmar se o acesso de leitura da fila foi concedido.

  2. Valide a relação de confiança entre os perfis do IAM. Veja um exemplo a seguir:

    { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "pods.eks.amazonaws.com" }, "Action": [ "sts:AssumeRole", "sts:TagSession" ] } ] }

Se houver um erro Assume-Role, um perfil do IAM do nó do Amazon EKS não poderá assumir o perfil do IAM definido para TriggerAuthentication. Execute as etapas a seguir:

  1. Insira o seguinte comando para excluir o pod keda-operator e criar um novo:

    kubectl delete pod keda-operator-<alphenumeric-value> --namespace keda
  2. Insira o seguinte comando para verificar a identidade que o pod assume:

    kubectl describe pod <keda-operator-pod-name> --namespace keda
  3. Quando o pod for reiniciado com sucesso, confirme se as duas variáveis seguintes foram adicionadas à descrição do pod:

    • AWS_CONTAINER_CREDENTIALS_FULL_URI

    • AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE

Recursos relacionados