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á. # Use AWS Secrets Manager segredos no Amazon Elastic Kubernetes Service Para mostrar segredos do AWS Secrets Manager (ASCP) como arquivos montados nos pods do Amazon EKS, você pode usar os AWS segredos e o provedor de configuração do driver CSI do Kubernetes Secrets Store. O ASCP funciona com o Amazon Elastic Kubernetes Service 1.17\$1 executando um grupo de nós do Amazon EC2. AWS Fargate grupos de nós não são suportados. Com o ASCP, é possível armazenar e gerenciar segredos no Secrets Manager e, em seguida, recuperá-los por meio de workloads executadas no Amazon EKS. Se seu segredo contiver vários pares de chave-valor no formato JSON, será possível escolher quais montará no Amazon EKS. O ASCP usa a sintaxe JMESPath para consultar os pares de chave/valor no seu segredo. O ASCP também funciona com parâmetros do Parameter Store. O ASCP oferece dois métodos de autenticação com o Amazon EKS. A primeira abordagem usa perfis do IAM para contas de serviço (IRSA). A segunda abordagem usa a Identidade de Pods. Cada abordagem tem seus benefícios e casos de uso. ## ASCP com perfis do IAM para contas de serviço (IRSA) O ASCP com funções do IAM para contas de serviço (IRSA) permite que você monte segredos AWS Secrets Manager como arquivos em seus pods do Amazon EKS. Essa abordagem é adequada quando: + É necessário montar os segredos como arquivos nos seus pods. + Você está usando a versão 1.17 ou posterior do Amazon EKS com grupos de nós do Amazon EC2. + Você deseja recuperar pares de chave-valor específicos de segredos formatados em JSON. Para obter mais informações, consulte [Use AWS segredos e CSI do provedor de configuração com funções do IAM para contas de serviço (IRSA)](integrating_ascp_irsa.md). ## ASCP com Identidade de Pods O método ASCP com Identidade de Pods aumenta a segurança e simplifica a configuração para acessar os segredos no Amazon EKS. Essa abordagem é benéfica quando: + É necessário um gerenciamento de permissões mais granular no nível do pod. + Você está usando a versão 1.24 ou posterior do Amazon EKS. + Você quer performance e escalabilidade aprimorados. Para obter mais informações, consulte [Use AWS segredos e o provedor de configuração CSI com o Pod Identity para Amazon EKS](ascp-pod-identity-integration.md). ## Como escolher a abordagem correta Considere os seguintes fatores ao decidir entre o ASCP com IRSA e o ASCP com Identidade de Pods: + Amazon EKSversion: O Pod Identity requer o Amazon EKS 1.24\$1, enquanto o driver CSI funciona com o Amazon EKS 1.17\$1. + Requisitos de segurança: a Identidade de Pods oferece um controle mais granular no nível do pod. + Performance: a Identidade de Pods geralmente tem melhor performance em ambientes de alta escala. + Complexidade: a Identidade de Pods simplifica a configuração ao eliminar a necessidade de contas de serviço separadas. Escolha o método que melhor se alinhe aos seus requisitos específicos e ao ambiente do Amazon EKS. # Instalar o ASCP para Amazon EKS Esta seção explica como instalar o AWS Secrets and Configuration Provider para o Amazon EKS. Com o ASCP, você pode montar segredos do Secrets Manager e parâmetros AWS Systems Manager como arquivos nos pods do Amazon EKS. ## Pré-requisitos + Um cluster do Amazon EKS + Versão 1.24 ou posterior da Identidade de Pods + Versão 1.17 ou posterior do IRSA + O AWS CLI instalado e configurado + kubectl instalado e configurado para o cluster do Amazon EKS + Helm (versão 3.0 ou superior) ## Instalar e configurar o ASCP O ASCP está disponível GitHub no repositório [secrets-store-csi-provider-aws](https://github.com/aws/secrets-store-csi-driver-provider-aws). O repositório também contém arquivos YAML de exemplo para criar e montar um segredo. Durante a instalação, é possível configurar o ASCP para usar um endpoint do FIPS. Para uma lista de endpoints , consulte [AWS Secrets Manager endpoints](asm_access.md#endpoints). **Para instalar o ASCP como um complemento do EKS** 1. Instalar `eksctl` ([instruções de instalação](https://docs.aws.amazon.com/eks/latest/eksctl/installation.html)) 1. Execute o comando a seguir para instalar o complemento com a [configuração padrão](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/charts/secrets-store-csi-driver-provider-aws/values.yaml): ``` eksctl create addon --cluster --name aws-secrets-store-csi-driver-provider ``` Se você quiser configurar o complemento, execute o seguinte comando de instalação: ``` aws eks create-addon --cluster-name --addon-name aws-secrets-store-csi-driver-provider --configuration-values 'file://path/to/config.yaml' ``` O arquivo de configuração pode ser um arquivo YAML ou JSON. Para ver o esquema de configuração do complemento: 1. Execute o comando a seguir e observe a versão mais recente do complemento: ``` aws eks describe-addon-versions --addon-name aws-secrets-store-csi-driver-provider ``` 1. Execute o comando a seguir para ver o esquema de configuração do complemento, `` substituindo-o pela versão da etapa anterior: ``` aws eks describe-addon-configuration --addon-name aws-secrets-store-csi-driver-provider --addon-version ``` **Para instalar o ASCP usando o Helm** 1. Para garantir que o repositório esteja apontando para os gráficos mais recentes, use `helm repo update.` 1. Instale o chart. Veja a seguir um exemplo do comando `helm install`: ``` helm install -n kube-system secrets-provider-aws aws-secrets-manager/secrets-store-csi-driver-provider-aws ``` 1. Para usar um endpoint do FIPS, adicione o sinalizador a seguir: `--set useFipsEndpoint=true` 1. Para configurar o controle de utilização, adicione o sinalizador a seguir: `--set-json 'k8sThrottlingParams={"qps": "number of queries per second", "burst": "number of queries per second"}'` 1. Se o driver CSI do Secrets Store já estiver instalado em seu cluster, adicione o sinalizador a seguir: `--set secrets-store-csi-driver.install=false`. Isso ignorará a instalação do driver CSI do Secrets Store como uma dependência. **Para instalar usando o YAML no repositório** + Use os seguintes comandos. ``` helm repo add secrets-store-csi-driver https://kubernetes-sigs.github.io/secrets-store-csi-driver/charts helm install -n kube-system csi-secrets-store secrets-store-csi-driver/secrets-store-csi-driver kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/deployment/aws-provider-installer.yaml ``` ## Verificar as instalações Para verificar as instalações do cluster do EKS, do driver CSI do Secrets Store e do plug-in do ASCP, siga estas etapas: 1. Verifique o cluster do EKS: ``` eksctl get cluster --name clusterName ``` Este comando deve retornar informações sobre o cluster. 1. Verifique a instalação do driver CSI do Secrets Store: ``` kubectl get pods -n kube-system -l app=secrets-store-csi-driver ``` É necessário ver pods em execução com nomes como `csi-secrets-store-secrets-store-csi-driver-xxx`. 1. Verifique a instalação do plug-in do ASCP: ------ #### [ YAML installation ] ``` $ kubectl get pods -n kube-system -l app=csi-secrets-store-provider-aws ``` Resultado do exemplo: ``` NAME READY STATUS RESTARTS AGE csi-secrets-store-provider-aws-12345 1/1 Running 0 2m ``` ------ #### [ Helm installation ] ``` $ kubectl get pods -n kube-system -l app=secrets-store-csi-driver-provider-aws ``` Resultado do exemplo: ``` NAME READY STATUS RESTARTS AGE secrets-provider-aws-secrets-store-csi-driver-provider-67890 1/1 Running 0 2m ``` ------ É necessário ver pods no estado `Running`. Depois de executar esses comandos, se tudo estiver configurado corretamente, será necessário ver todos os componentes funcionando sem erros. Se você encontrar algum problema, talvez seja necessário solucionar verificando os logs dos pods específicos que estão com problemas. ## Solução de problemas 1. Para verificar os logs do provedor do ASCP, execute: ``` kubectl logs -n kube-system -l app=csi-secrets-store-provider-aws ``` 1. Verifique o status de todos os pods no namespace `kube-system`. ``` kubectl -n kube-system get pods ``` ``` kubectl -n kube-system logs pod/PODID ``` Todos os pods relacionados ao driver CSI e ao ASCP devem estar no estado “Running”. 1. Verifique a versão do driver CSI: ``` kubectl get csidriver secrets-store.csi.k8s.io -o yaml ``` Este comando deve retornar informações sobre o driver CSI instalado. ## Recursos adicionais do Para obter mais informações sobre o uso do ASCP com o Amazon EKS, consulte os seguintes recursos: + [Uso da Identidade de Pods com o Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html) + [AWS Driver CSI da Secrets Store ativado GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws) # Use AWS segredos e o provedor de configuração CSI com o Pod Identity para Amazon EKS A integração do AWS Secrets and Configuration Provider com o Pod Identity Agent for Amazon Elastic Kubernetes Service fornece segurança aprimorada, configuração simplificada e desempenho aprimorado para aplicativos executados no Amazon EKS. O Pod Identity simplifica a autenticação do IAM para o Amazon EKS ao recuperar segredos do Secrets Manager ou AWS Systems Manager parâmetros do Parameter Store. A Identidade de Pods do Amazon EKS simplifica o processo de configuração de permissões do IAM para aplicações do Kubernetes, possibilitando que as permissões sejam configuradas diretamente por meio das interfaces do Amazon EKS, reduzindo o número de etapas e eliminando a necessidade de alternar entre os serviços do Amazon EKS e do IAM. A Identidade de Pods permite o uso de um único perfil do IAM em vários clusters sem atualizar as políticas de confiança, e oferece suporte a [tags de sessão de perfis](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-abac.html#pod-id-abac-tags) para um controle de acesso mais granular. Essa abordagem não apenas simplifica o gerenciamento de políticas, permitindo a reutilização de políticas de permissão em todas as funções, mas também aumenta a segurança ao permitir o acesso a AWS recursos com base nas tags correspondentes. ## Como funciona 1. A Identidade de Pods atribui um perfil do IAM ao pod. 1. O ASCP usa essa função para se autenticar com. Serviços da AWS 1. Se autorizado, o ASCP recupera os segredos solicitados e os disponibiliza para o pod. Para obter mais informações, consulte [Como a Identidade de Pods do Amazon EKS funciona](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-how-it-works.html) no *Guia do usuário do Amazon EKS*. ## Pré-requisitos **Importante** A Identidade de Pods é compatível somente com o Amazon EKS na nuvem. Ela não é compatível com o [Amazon EKS Anywhere](https://aws.amazon.com/eks/eks-anywhere/), o [Serviço Red Hat OpenShift na AWS](https://aws.amazon.com/rosa/) ou com clusters autogerenciados do Kubernetes em instâncias do Amazon EC2. + Cluster do Amazon EKS (versão 1.24 ou posterior) + Acesso a um AWS CLI cluster Amazon EKS via `kubectl` + Acesso a dois Contas da AWS (para acesso entre contas) ## Instalar o agente da Identidade de Pods do Amazon EKS Para usar a Identidade de Pods com o cluster, é necessário instalar o complemento do agente da Identidade de Pods do Amazon EKS. **Para instalar o complemento agente da Identidade de Pods** + Instale o complemento do agente de Identidade de Pods no seu cluster. ``` eksctl create addon \ --name eks-pod-identity-agent \ --cluster clusterName \ --region region ``` ## Configurar o ASCP com a Identidade de Pods 1. Crie uma política de permissões que conceda as permissões `secretsmanager:GetSecretValue` e `secretsmanager:DescribeSecret` aos segredos que o pod precisa acessar. Para visualizar um exemplo de política, consulte [Exemplo: permissão para ler e descrever segredos individuais](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe). 1. Crie um perfil do IAM que possa ser assumido pela entidade principal do serviço do Amazon EKS para a Identidade de Pods: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "pods.eks.amazonaws.com" }, "Action": [ "sts:AssumeRole", "sts:TagSession" ] } ] } ``` ------ Anexe a política do IAM ao perfil. ``` aws iam attach-role-policy \ --role-name MY_ROLE \ --policy-arn POLICY_ARN ``` 1. Crie uma associação de Identidade de Pods. Para obter um exemplo, consulte [Criar uma associação de Identidade de Pods](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-association.html#pod-id-association-create) no *Guia do usuário do Amazon EKS* 1. Crie a `SecretProviderClass` que especifica quais segredos devem ser montados no pod: ``` kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleSecretProviderClass-PodIdentity.yaml ``` A principal diferença no `SecretProviderClass` entre o IRSA e a Identidade de Pods é o parâmetro opcional `usePodIdentity`. É um campo opcional que determina a abordagem de autenticação. Quando não especificado, o padrão é usar os perfis do IAM para contas de serviço (IRSA). + Para usar a Identidade de Pods do EKS, use qualquer um destes valores: `"true", "True", "TRUE", "t", "T"`. + Para usar explicitamente o IRSA, defina para qualquer um destes valores: `"false", "False", "FALSE", "f", or "F"`. 1. Implante o pod que monta os segredos em `/mnt/secrets-store`: ``` kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleDeployment-PodIdentity.yaml ``` 1. Se você usa um cluster privado do Amazon EKS, certifique-se de que a VPC na qual o cluster está tenha um AWS STS endpoint. Para obter informações sobre a criação de um endpoint, consulte [Endpoints da VPC da interface](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) no *Guia do usuário do AWS Identity and Access Management *. ### Verificar a montagem do segredo Para verificar se o segredo foi montado corretamente, execute o comando a seguir. ``` kubectl exec -it $(kubectl get pods | awk '/pod-identity-deployment/{print $1}' | head -1) -- cat /mnt/secrets-store/MySecret ``` **Para configurar a Identidade de Pods do Amazon EKS para acessar os segredos no Secrets Manager** 1. Crie uma política de permissões que conceda as permissões `secretsmanager:GetSecretValue` e `secretsmanager:DescribeSecret` aos segredos que o pod precisa acessar. Para visualizar um exemplo de política, consulte [Exemplo: permissão para ler e descrever segredos individuais](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe). 1. Crie um segredo no Secrets Manager, caso ainda não tenha um. ## Solução de problemas É possível visualizar a maioria dos erros ao descrever a implantação do pod. **Para ver mensagens de erro para o contêiner** 1. Obtenha uma lista de nomes de pods com o comando a seguir. Se você não estiver usando o namespace padrão, use `-n NAMESPACE`. ``` kubectl get pods ``` 1. Para descrever o pod, no comando a seguir, *PODID* use o ID do pod dos pods que você encontrou na etapa anterior. Se você não estiver usando o namespace padrão, use `-n NAMESPACE`. ``` kubectl describe pod/PODID ``` **Para ver erros para o ASCP** + Para encontrar mais informações nos registros do provedor, no comando a seguir, *PODID* use o ID do *csi-secrets-store-provider-aws* Pod. ``` kubectl -n kube-system get pods kubectl -n kube-system logs pod/PODID ``` # Use AWS segredos e CSI do provedor de configuração com funções do IAM para contas de serviço (IRSA) **Topics** + [Pré-requisitos](#prerequisites) + [Configurar o controle de acesso](#integrating_ascp_irsa_access) + [Identificar quais segredos montar](#integrating_ascp_irsa_mount) + [Solução de problemas](#integrating_ascp_irsa_trouble) ## Pré-requisitos + Cluster do Amazon EKS (versão 1.17 ou posterior) + Acesso a um AWS CLI cluster Amazon EKS via `kubectl` ## Configurar o controle de acesso O ASCP recupera a Identidade de Pods do Amazon EKS e a substitui por um perfil do IAM. Você define permissões em uma política do IAM para esse perfil do IAM. Quando o ASCP assume o perfil do IAM, ele obtém acesso aos segredos que você autorizou. Outros contêineres não podem acessar os segredos, a menos que você também os associe ao perfil do IAM. **Para conceder ao seu pod do Amazon EKS acesso aos segredos no Secrets Manager** 1. Crie uma política de permissões que conceda as permissões `secretsmanager:GetSecretValue` e `secretsmanager:DescribeSecret` aos segredos que o pod precisa acessar. Para visualizar um exemplo de política, consulte [Exemplo: permissão para ler e descrever segredos individuais](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe). 1. Crie um provedor IAM OIDC Connect (OIDC) para o cluster, se você ainda não tiver um. Para obter mais informações, consulte [Criação de um provedor IAM OIDC para o seu cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) no *Guia do Usuário do Amazon EKS*. 1. Crie um [perfil do IAM para conta de serviço](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) e anexe a política a ele. Para obter mais informações, consulte [Criação de um perfil do IAM para uma conta de serviço](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) no *Guia do usuário do Amazon EKS*. 1. Se você usa um cluster privado do Amazon EKS, certifique-se de que a VPC na qual o cluster está tenha um AWS STS endpoint. Para obter informações sobre a criação de um endpoint, consulte [Endpoints da VPC da interface](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) no *Guia do usuário do AWS Identity and Access Management *. ## Identificar quais segredos montar Para determinar quais segredos o ASCP monta no Amazon EKS como arquivos no sistema de arquivos, você cria um arquivo YAML [SecretProviderClass](ascp-examples.md#ascp-examples-secretproviderclass). O `SecretProviderClass` lista os segredos a serem montados e o nome do arquivo no qual montá-los. O`SecretProviderClass` deve estar no mesmo namespace que o pod do Amazon EKS ao qual ele faz referência. ### Montagem dos segredos como arquivos [As instruções a seguir mostram como montar segredos como arquivos usando exemplos de arquivos YAML .yaml e [ExampleSecretProviderClass.yaml](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleSecretProviderClass-IRSA.yaml). ExampleDeployment](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleDeployment-IRSA.yaml) **Para montar segredos no Amazon EKS** 1. Aplique o `SecretProviderClass` ao pod: ``` kubectl apply -f ExampleSecretProviderClass.yaml ``` 1. Implante o pod: ``` kubectl apply -f ExampleDeployment.yaml ``` 1. O ASCP monta os arquivos. ## Solução de problemas É possível visualizar a maioria dos erros ao descrever a implantação do pod. **Para ver mensagens de erro para o contêiner** 1. Obtenha uma lista de nomes de pods com o comando a seguir. Se você não estiver usando o namespace padrão, use `-n nameSpace`. ``` kubectl get pods ``` 1. Para descrever o pod, no comando a seguir, *podId* use o ID do pod dos pods que você encontrou na etapa anterior. Se você não estiver usando o namespace padrão, use `-n nameSpace`. ``` kubectl describe pod/podId ``` **Para ver erros para o ASCP** + Para encontrar mais informações nos registros do provedor, no comando a seguir, *podId* use o ID do *csi-secrets-store-provider-aws* Pod. ``` kubectl -n kube-system get pods kubectl -n kube-system logs Pod/podId ``` + **Verifique se a CRD do `SecretProviderClass` está instalada:** ``` kubectl get crd secretproviderclasses.secrets-store.csi.x-k8s.io ``` Este comando deve retornar informações sobre a definição do recurso personalizado `SecretProviderClass`. + **Verifique se o SecretProviderClass objeto foi criado.** ``` kubectl get secretproviderclass SecretProviderClassName -o yaml ``` # AWS Segredos e exemplos de código do provedor de configuração ## Exemplos de autenticação do ASCP e controle de acesso ### Exemplo: política do IAM que permite que o serviço da Identidade de Pods do Amazon EKS (pods.eks.amazonaws.com) assuma o perfil e marque a sessão: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "pods.eks.amazonaws.com" }, "Action": [ "sts:AssumeRole", "sts:TagSession" ] } ] } ``` ------ ## SecretProviderClass Você usa o YAML para descrever quais segredos devem ser montados no Amazon EKS usando o ASCP. Para obter exemplos, consulte [SecretProviderClass uso](#ascp-scenarios-secretproviderclass). ### SecretProviderClass Estrutura YAML ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: name spec: provider: aws parameters: region: failoverRegion: pathTranslation: usePodIdentity: preferredAddressType: objects: ``` O campo de parâmetros contém os detalhes da solicitação de montagem: **region** (Opcional) O Região da AWS do segredo. Se você não usar esse campo, o ASCP procurará a Região a partir da anotação no nó. Essa pesquisa adiciona sobrecarga às solicitações de montagem, portanto, recomendamos que você forneça a região para clusters que usam um grande número de pods. Se você também especificar `failoverRegion`, o ASCP tentará recuperar o segredo de ambas as regiões. Se qualquer uma das regiões retornar um erro 4xx (p. ex., para um problema de autenticação), o ASCP não montará nenhum segredo. Se o segredo for recuperado com êxito de `region`, o ASCP montará o valor desse segredo. Se o segredo não for recuperado com êxito de `region`, mas for recuperado com êxito de `failoverRegion`, o ASCP montará o valor desse segredo. **failoverRegion** (Opcional) Se você incluir esse campo, o ASCP tentará recuperar o segredo das regiões definidas em `region` e nesse campo. Se qualquer uma das regiões retornar um erro 4xx (p. ex., para um problema de autenticação), o ASCP não montará nenhum segredo. Se o segredo for recuperado com êxito de `region`, o ASCP montará o valor desse segredo. Se o segredo não for recuperado com êxito de `region`, mas for recuperado com êxito de `failoverRegion`, o ASCP montará o valor desse segredo. Para obter um exemplo de como usar esse campo, consulte [Failover multirregiões](#multi-region-failover). **pathTranslation** (Opcional) Um só caractere de substituição para usar se o nome de arquivo no Amazon EKS vá conter o caractere separador de caminho, como barra (/) no Linux. O ASCP não poderá criar um arquivo montado que contenha um caractere separador de caminho. Em vez disso, o ASCP substituirá o caractere separador de caminho por outro caractere. Se você não usar esse campo, o caractere substituto será um sublinhado (\$1), portanto, por exemplo,`My/Path/Secret` será montado como `My_Path_Secret`. Para impedir a substituição de caracteres, digite a string`False`. **usePodIdentity** (Opcional) Determina a abordagem de autenticação. Quando não especificado, o padrão é Perfis do IAM para contas de serviço (IRSA). + Para usar a Identidade de Pods do EKS, use qualquer um destes valores: `"true"`, `"True"`, `"TRUE"`, `"t"` ou `"T"`. + Para usar explicitamente o IRSA, defina qualquer um destes valores: `"false"`, `"False"`, `"FALSE"`, `"f"` ou `"F"`"=. **preferredAddressType** (Opcional) Especifica o tipo de endereço IP preferencial para comunicação de endpoints do atendente da Identidade de Pods. O campo só será aplicável ao usar o recurso de Identidade de Pods do EKS, e será ignorado ao usar perfis do IAM para contas de serviço. Os valores não diferenciam maiúsculas de minúsculas. Os valores válidos são: + `"ipv4"`, `"IPv4"` “, ou `"IPV4"` — Forçar o uso do IPv4 endpoint do Pod Identity Agent + `"ipv6"`,`"IPv6"`, ou `"IPV6"` — Forçar o uso do IPv6 endpoint do Pod Identity Agent + não especificado — Use a seleção automática de endpoint, testando primeiro o IPv4 endpoint e retornando ao IPv6 endpoint se falhar IPv4 **objects** Uma string contendo uma declaração do YAML dos segredos a serem montados. Recomendamos o uso de uma string com várias linhas ou um caractere pipe (\$1) no YAML. **objectName** Obrigatório. Especifica o nome do parâmetro ou segredo a ser buscado. Para o Secrets Manager, este é o parâmetro [https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html#API_GetSecretValue_RequestParameters](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html#API_GetSecretValue_RequestParameters) e pode ser o nome amigável ou o ARN completo do segredo. Para o SSM Parameter Store, esse é o [https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#API_GetParameter_RequestParameters](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#API_GetParameter_RequestParameters) do parâmetro e pode ser o nome ou o ARN completo do parâmetro. **objectType** Necessário se você não usar um ARN do Secrets Manager para`objectName`. Pode ser `secretsmanager` ou `ssmparameter`. **objectAlias** (Opcional) O nome do arquivo do segredo no pod do Amazon EKS. Se você não especificar esse campo, o `objectName` aparece como o nome do arquivo. **filePermission** (Opcional) A string octal de 4 dígitos que especifica a permissão do arquivo para montar o segredo. Se você não especificar esse campo, ele será padronizado como `"0644"`. **objectVersion** (Opcional) O ID da versão do segredo. Não recomendado porque é necessário atualizar o ID da versão sempre que atualizar o segredo. Por padrão, a versão mais recente é usada. Se você incluir um `failoverRegion`, esse campo representará o `objectVersion` primário. **objectVersionLabel** (Opcional) O alias da versão. O padrão é a versão mais recente AWSCURRENT. Para obter mais informações, consulte [Versões do segredo](whats-in-a-secret.md#term_version). Se você incluir um `failoverRegion`, esse campo representará o `objectVersionLabel` primário. **jmesPath** (Opcional) Um mapa das chaves no segredo para os arquivos a serem montados no Amazon EKS. Para usar esse campo, o valor do segredo deve estar no formato JSON. Se você usar esse campo, deverá incluir os subcampos `path` e `objectAlias`. **caminho** Uma chave de um par de chave-valor no JSON do valor do segredo. Se o campo contiver um hífen, use aspas simples para delimitá-lo, por exemplo: `path: '"hyphenated-path"'` **objectAlias** O nome do arquivo a ser montado no pod Amazon EKS. Se o campo contiver um hífen, use aspas simples para delimitá-lo, por exemplo: `objectAlias: '"hyphenated-alias"'` **filePermission** (Opcional) A string octal de 4 dígitos que especifica a permissão do arquivo para montar o segredo. Se você não especificar esse campo, ele será padronizado como a permissão de arquivo do objeto pai. **failoverObject** (Opcional) Se você especificar esse campo, o ASCP tentará recuperar o segredo especificado no `objectName` primário e o segredo especificado no subcampo `objectName` de `failoverObject`. Se qualquer um deles retornar um erro 4xx (p. ex., para um problema de autenticação), o ASCP não montará nenhum segredo. Se o segredo for recuperado com êxito do `objectName` primário, o ASCP montará o valor desse segredo. Se o segredo não for recuperado com êxito do `objectName` primário, mas for recuperado com êxito do `objectName` do failover, o ASCP montará o valor desse segredo. Se incluir esse campo, será necessário incluir o campo `objectAlias`. Para obter um exemplo de como usar esse campo, consulte [Failover para um segredo diferente](#failover-secret). Normalmente, você usa esse campo quando o segredo de failover não for uma réplica. Para obter um exemplo de como especificar uma réplica, consulte [Failover multirregiões](#multi-region-failover). **objectName** O nome ou ARN completo do segredo de failover. Se você usar um ARN, a região no ARN deverá corresponder ao campo `failoverRegion`. **objectVersion** (Opcional) O ID da versão do segredo. Deve corresponder ao `objectVersion` primário. Não recomendado porque é necessário atualizar o ID da versão sempre que atualizar o segredo. Por padrão, a versão mais recente é usada. **objectVersionLabel** (Opcional) O alias da versão. O padrão é a versão mais recente AWSCURRENT. Para obter mais informações, consulte [Versões do segredo](whats-in-a-secret.md#term_version). ### Crie uma SecretProviderClass configuração básica para montar segredos em seus pods do Amazon EKS. ------ #### [ Pod Identity ] SecretProviderClass para usar um segredo no mesmo cluster do Amazon EKS: ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-secrets-manager spec: provider: aws parameters: objects: | - objectName: "mySecret" objectType: "secretsmanager" usePodIdentity: "true" ``` ------ #### [ IRSA ] ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: deployment-aws-secrets spec: provider: aws parameters: objects: | - objectName: "MySecret" objectType: "secretsmanager" ``` ------ ### SecretProviderClass uso Use esses exemplos para criar SecretProviderClass configurações para diferentes cenários. #### Exemplo: montar segredos por nome ou ARN Este exemplo mostra como montar três tipos diferentes de segredos: + Um segredo especificado por um ARN completo + Um segredo especificado pelo nome + Uma versão específica de um segredo ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-secrets spec: provider: aws parameters: objects: | - objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MySecret2-d4e5f6" - objectName: "MySecret3" objectType: "secretsmanager" - objectName: "MySecret4" objectType: "secretsmanager" objectVersionLabel: "AWSCURRENT" ``` #### Exemplo: montar pares de chave-valor a partir de um segredo Este exemplo mostra como montar pares de chave-valor específicos de um segredo formatado em JSON: ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-secrets spec: provider: aws parameters: objects: | - objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MySecret-a1b2c3" jmesPath: - path: username objectAlias: dbusername - path: password objectAlias: dbpassword ``` #### Exemplo: montar segredos por permissão de arquivo Este exemplo mostra como montar um segredo com uma permissão específica de arquivo ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-secrets spec: provider: aws parameters: objects: | - objectName: "mySecret" objectType: "secretsmanager" filePermission: "0600" jmesPath: - path: username objectAlias: dbusername filePermission: "0400" ``` #### Exemplo: exemplos de configuração de failover Estes exemplos mostram como configurar o failover para segredos. ##### Failover multirregiões Este exemplo mostra como configurar o failover automático para um segredo replicado em várias regiões: ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-secrets spec: provider: aws parameters: region: us-east-1 failoverRegion: us-east-2 objects: | - objectName: "MySecret" ``` ##### Failover para um segredo diferente Este exemplo mostra como configurar o failover para um segredo diferente (não uma réplica): ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-secrets spec: provider: aws parameters: region: us-east-1 failoverRegion: us-east-2 objects: | - objectName: "arn:aws:secretsmanager:us-east-1:777788889999:secret:MySecret-a1b2c3" objectAlias: "MyMountedSecret" failoverObject: - objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MyFailoverSecret-d4e5f6" ``` ## Recursos adicionais do Para obter mais informações sobre o uso do ASCP com o Amazon EKS, consulte os seguintes recursos: + [Uso da Identidade de Pods com o Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html) + [Usando AWS segredos e provedor de configuração](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_ascp_csi.html) + [AWS Driver CSI da Secrets Store ativado GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)