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á. # `AWSSupport-SetupK8sApiProxyForEKS` **Descrição** O runbook de automação do **AWSSupport-SetupK8 sApiProxy ForEks** fornece uma maneira de criar uma AWS Lambda função que atua como proxy para fazer chamadas de API do plano de controle para o endpoint do cluster Amazon Elastic Kubernetes Service. Ele serve como um alicerce para runbooks que exigem a realização de chamadas de API no plano de controle para automatizar tarefas e solucionar problemas com um cluster Amazon EKS. **Importante** Todos os recursos criados por essa automação são marcados para que possam ser facilmente encontrados. As tags usadas são: `AWSSupport-SetupK8sApiProxyForEKS`: true **nota** A automação é um runbook auxiliar e não pode ser executada como um runbook independente. Ela é invocada como uma automação secundária para runbooks que exigem chamadas de API de plano de controle para o cluster Amazon EKS. Certifique-se de executar a `Cleanup` operação após o uso para evitar custos indesejados. **Tipo de documento** Automação **Proprietário** Amazon **Plataformas** Linux **Parâmetros** + AutomationAssumeRole Tipo: String Descrição: (opcional) o nome do recurso da Amazon (ARN) do perfil do AWS Identity and Access Management (IAM) que permite que o Systems Manager Automation realize ações em seu nome. Se nenhum perfil for especificado, o Systems Manager Automation usa as permissões do usuário que inicia este runbook. + ClusterName Tipo: string Descrição: (Obrigatório) O nome do cluster Amazon Elastic Kubernetes Service. + Operation Tipo: string Descrição: (Obrigatório) Operação a ser executada: `Setup` provisiona a função Lambda na conta, `Cleanup` desprovisionará recursos criados como parte da fase de configuração. Valores permitidos: `Setup` \$1 `Cleanup` Padrão: Configuração + LambdaRoleArn Tipo: string Descrição: (Opcional) O ARN da função do IAM que permite que a AWS Lambda função acesse os AWS serviços e recursos necessários. Se nenhuma função for especificada, esse Systems Manager Automation criará uma função do IAM para Lambda em sua conta com o nome `Automation-K8sProxy-Role-` que inclui as políticas gerenciadas: e. `AWSLambdaBasicExecutionRole` `AWSLambdaVPCAccessExecutionRole` **Como funciona?** O runbook executa as seguintes etapas: + Valida se a automação está sendo executada como uma execução secundária. O runbook não funcionará quando invocado como um runbook autônomo, pois ele não executa nenhum trabalho significativo sozinho. + Verifica a CloudFormation pilha existente da função proxy Lambda para o cluster especificado. + Se a pilha existir, a infraestrutura existente será reutilizada em vez de recriá-la. + Um contador de referência é mantido usando tags para garantir que um runbook não exclua a infraestrutura se ela estiver sendo reutilizada por outro runbook para o mesmo cluster. + Execute o tipo de operação (`Setup`/`Cleanup`) especificado para a invocação: + **Configuração:** cria ou descreve os recursos existentes. **Limpeza:** remove os recursos provisionados, se a infraestrutura não estiver sendo usada por nenhum outro runbook. **Permissões obrigatórias do IAM** O `AutomationAssumeRole` parâmetro exige que as seguintes permissões concedidas ` LambdaRoleArn` não sejam passadas: + `cloudformation:CreateStack` + `cloudformation:DescribeStacks` + `cloudformation:DeleteStack` + `cloudformation:UpdateStack` + `ec2:CreateNetworkInterface` + `ec2:DescribeNetworkInterfaces` + `ec2:DescribeRouteTables` + `ec2:DescribeSecurityGroups` + `ec2:DescribeSubnets` + `ec2:DescribeVpcs` + `ec2:DeleteNetworkInterface` + `eks:DescribeCluster` + `lambda:CreateFunction` + `lambda:DeleteFunction` + `lambda:ListTags` + `lambda:GetFunction` + `lambda:ListTags` + `lambda:TagResource` + `lambda:UntagResource` + `lambda:UpdateFunctionCode` + `logs:CreateLogGroup` + `logs:PutRetentionPolicy` + `logs:TagResource` + `logs:UntagResource` + `logs:DescribeLogGroups` + `logs:DescribeLogStreams` + `logs:ListTagsForResource` + `iam:CreateRole` + `iam:AttachRolePolicy` + `iam:DetachRolePolicy` + `iam:PassRole` + `iam:GetRole` + `iam:DeleteRole` + `iam:TagRole` + `iam:UntagRole` + `tag:GetResources` + `tag:TagResources` Quando `LambdaRoleArn` fornecida, a automação não precisa criar a função e as seguintes permissões podem ser excluídas: + `iam:CreateRole` + `iam:DeleteRole` + `iam:TagRole` + `iam:UntagRole` + `iam:AttachRolePolicy` + `iam:DetachRolePolicy` Abaixo está um exemplo de política que demonstra as permissões necessárias para ` AutomationAssumeRole` quando não `LambdaRoleArn` é aprovada: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Action": [ "tag:GetResources", "tag:TagResources", "ec2:CreateNetworkInterface", "ec2:DescribeNetworkInterfaces", "ec2:DescribeRouteTables", "ec2:DescribeSecurityGroups", "ec2:DescribeSubnets", "ec2:DescribeVpcs", "ec2:DeleteNetworkInterface", "eks:DescribeCluster", "iam:GetRole", "cloudformation:DescribeStacks", "logs:DescribeLogGroups", "logs:DescribeLogStreams", "lambda:GetFunction", "lambda:ListTags", "logs:ListTagsForResource" ], "Resource": "*", "Effect": "Allow", "Sid": "AllowActionsWithoutConditions" }, { "Condition": { "StringEquals": { "aws:RequestTag/AWSSupport-SetupK8sApiProxyForEKS": "true" } }, "Action": "iam:CreateRole", "Resource": [ "arn:aws:iam::111122223333:role/Automation-K8sProxy*" ], "Effect": "Allow", "Sid": "AllowCreateRoleWithRequiredTag" }, { "Condition": { "StringEquals": { "aws:ResourceTag/AWSSupport-SetupK8sApiProxyForEKS": "true" } }, "Action": [ "iam:DeleteRole", "iam:TagRole", "iam:UntagRole" ], "Resource": [ "arn:aws:iam::111122223333:role/Automation-K8sProxy*" ], "Effect": "Allow", "Sid": "IAMActions" }, { "Condition": { "StringEquals": { "aws:ResourceTag/AWSSupport-SetupK8sApiProxyForEKS": "true" }, "StringLike": { "iam:PolicyARN": [ "arn:aws:iam::111122223333:policy/service-role/AWSLambdaBasicExecutionRole", "arn:aws:iam::111122223333:policy/service-role/AWSLambdaVPCAccessExecutionRole" ] } }, "Action": [ "iam:AttachRolePolicy", "iam:DetachRolePolicy" ], "Resource": [ "arn:aws:iam::111122223333:role/Automation-K8sProxy*" ], "Effect": "Allow", "Sid": "AttachRolePolicy" }, { "Condition": { "StringEquals": { "aws:ResourceTag/AWSSupport-SetupK8sApiProxyForEKS": "true" } }, "Action": [ "lambda:CreateFunction", "lambda:DeleteFunction", "lambda:TagResource", "lambda:UntagResource", "lambda:UpdateFunctionCode" ], "Resource": "arn:aws:lambda:us-east-1:111122223333:function:Automation-K8sProxy*", "Effect": "Allow", "Sid": "LambdaActions" }, { "Condition": { "StringEquals": { "aws:ResourceTag/AWSSupport-SetupK8sApiProxyForEKS": "true" } }, "Action": [ "cloudformation:CreateStack", "cloudformation:DeleteStack", "cloudformation:UpdateStack" ], "Resource": "arn:aws:cloudformation:us-east-1:111122223333:stack/AWSSupport-SetupK8sApiProxyForEKS*", "Effect": "Allow", "Sid": "CloudFormationActions" }, { "Condition": { "StringEquals": { "aws:ResourceTag/AWSSupport-SetupK8sApiProxyForEKS": "true" } }, "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents", "logs:PutRetentionPolicy", "logs:TagResource", "logs:UntagResource" ], "Resource": [ "arn:aws:logs:us-east-1:111122223333:log-group:/aws/lambda/Automation-K8sProxy*", "arn:aws:logs:us-east-1:111122223333:log-group:/aws/lambda/Automation-K8sProxy*:*" ], "Effect": "Allow", "Sid": "LogsActions" }, { "Condition": { "StringLikeIfExists": { "iam:PassedToService": "lambda.amazonaws.com" } }, "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::111122223333:role/Automation-K8sProxy-Role*" ], "Effect": "Allow", "Sid": "PassRoleToLambda" } ] } ``` ------ Caso `LambdaRoleArn` seja aprovado, certifique-se de que ele tenha uma [ AWSLambdaBasicExecutionRole ](https://console.aws.amazon.com/iam/home?region=us-east-1#/policies/details/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2Fservice-role%2FAWSLambdaBasicExecutionRole)política anexada para clusters públicos e, além disso, [ AWSLambdaVPCAccessExecutionRole ](https://console.aws.amazon.com/iam/home?region=us-east-1#/policies/details/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2Fservice-role%2FAWSLambdaVPCAccessExecutionRole)para clusters privados. **Recursos criados** Os seguintes recursos são criados durante a `Setup` operação: 1. AWS Lambda função 1. Função do IAM: função de execução do Lambda, se não for fornecida. 1. CloudWatch Grupo de registros (Lambda Logs) *A função Lambda e a função de execução são mantidas até que a `Cleanup` operação seja executada. O grupo de registros do Lambda será retido por 30 dias ou até que seja excluído manualmente.* **Instruções** O runbook é um utilitário auxiliar projetado para ser executado a partir de outros runbooks como uma automação infantil. Ele facilita a criação de uma infraestrutura que permite que o runbook principal faça chamadas à API do plano de controle do Amazon EKS K8s. Para usar o runbook, você pode seguir as etapas abaixo no contexto da automação principal. 1. **Fase de configuração**: invoque a automação usando a operação de ` aws:executeAutomation` ação do runbook que gostaria de fazer chamadas de API do plano de controle do Amazon EKS K8s com a operação definida como. `Setup` Exemplo de parâmetros de entrada: ``` { "AutomationAssumeRole": "", "ClusterName": "", "Operation": "Setup" } ``` A saída da `aws:executeAutomation` etapa conterá o ARN da função proxy Lambda. 1. **Usando o Lambda Proxy**: invoque a função Lambda dentro da `aws:executeScript` ação usando `boto3`'s ` Lambda.Client.invoke(...)` com uma lista de caminhos de chamada de API e token portador. A função Lambda executará `GET` chamadas HTTP para o caminho especificado passando o token portador como parte do cabeçalho de autorização. Exemplo do evento de invocação do Lambda: ``` { "ApiCalls": ["/api/v1/pods/", ...], "BearerToken": "..." } ``` **nota** O token portador deve ser gerado como parte do script de automação principal. Você precisa garantir que o principal que executa o runbook principal tenha permissão somente de leitura para o cluster Amazon EKS especificado. 1. **Fase de limpeza**: invoque a automação usando a operação de ` aws:executeAutomation` ação do runbook que gostaria de fazer chamadas de API do plano de controle do Amazon EKS K8s com a operação definida como. `Cleanup` Exemplo de parâmetros de entrada: ``` { "AutomationAssumeRole": "", "ClusterName": "", "Operation": "Cleanup" } ``` **Etapas de automação** 1. **ValidateExecution** + Verifica se a automação não está sendo executada como uma execução autônoma. 1. **CheckForExistingStack** + Verifica se uma CloudFormation pilha já foi provisionada para o nome do cluster especificado. + Retorna o status de existência da pilha e se é seguro excluí-la. 1. **BranchOnIsStackExists** + Etapa de decisão que se ramifica com base na existência da pilha. + Rotas para atualizar o nome da pilha existente ou continuar com a ramificação da operação. 1. **UpdateStackName** + Atualiza a `StackName` variável com o nome da pilha existente. + Executado somente se a pilha já existir. 1. **BranchOnOperation** + Encaminha a automação com base no `Operation` parâmetro (`Setup`/`Cleanup`). + Para`Setup`: Rotas para criar uma nova pilha ou descrever os recursos existentes. + Para`Cleanup`: Prossegue com a exclusão da pilha, se for seguro excluir. 1. **GetClusterNetworkConfig** + Descreve o cluster Amazon EKS para obter a configuração da VPC. + Recupera dados do endpoint, da VPC ID, da sub-rede IDs, do grupo de segurança e da CA. 1. **ProvisionResources** + Cria uma CloudFormation pilha com os recursos necessários. + Provisiona a função Lambda com a configuração de rede necessária. + Marca todos os recursos para rastreamento e gerenciamento. 1. **DescribeStackResources** + Recupera informações sobre a created/existing pilha. + Obtém o ARN da função Lambda provisionada. 1. **BranchOnIsLambdaDeploymentRequired** + Determina se a implantação do código Lambda é necessária. + Só prossegue com a implantação de pilhas recém-criadas. 1. **DeployLambdaFunctionCode** + Implanta o código da função Lambda usando o pacote de implantação. + Atualiza a função com a implementação do proxy. 1. **AssertLambdaAvailable** + Verifica se a atualização do código da função Lambda foi bem-sucedida. + Espera que a função esteja no `Successful` estado. 1. **PerformStackCleanup** + Exclui a CloudFormation pilha e os recursos associados. + Executado durante `Cleanup` a operação ou em caso de falha na ` Setup` operação. **Saídas** *LambdaFunctionArn*: ARN da função proxy Lambda **Referências** Automação do Systems Manager + [Executar uma automação](https://docs.aws.amazon.com//systems-manager/latest/userguide/automation-working-executing.html) + [Configurar a automação](https://docs.aws.amazon.com//systems-manager/latest/userguide/automation-setup.html) + [Fluxos de trabalho de automação de suporte](https://aws.amazon.com/premiumsupport/technology/saw/)