• O AWS Systems Manager CloudWatch Dashboard não estará mais disponível a partir de 30 de abril de 2026. Os clientes podem continuar usando o console do Amazon CloudWatch para visualizar, criar e gerenciar os painéis do Amazon CloudWatch exatamente como fazem hoje. Para obter mais informações, consulte a [documentação do Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Dashboards.html). # Use parâmetros do Parameter Store no Amazon Elastic Kubernetes Service. Para mostrar parâmetros do Parameter Store, uma ferramenta do AWS Systems Manager, como arquivos montados em pods do Amazon EKS, você pode usar o AWS Secrets and Configuration Provider para o driver CSI do Secrets Store do Kubernetes. O ASCP funciona com o Amazon Elastic Kubernetes Service 1.17\$1 executando um grupo de nós do Amazon EC2. Grupos de nós do AWS Fargate não são compatíveis. Com o ASCP, você pode armazenar e gerenciar seu parâmetro no Parameter Store e depois recuperá-lo por meio das workloads executadas no Amazon EKS. Se o parâmetro contiver vários pares de chave/valor no formato JSON, você poderá 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 os segredos do AWS Secrets Manager. 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 perfis do IAM para contas de serviço (IRSA) permite que você monte parâmetros do Parameter Store como arquivos nos pods do Amazon EKS. Essa abordagem é adequada quando: + Você precisa montar parâmetros como arquivos nos 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 parâmetros formatados em JSON. Para obter mais informações, consulte [Usar o CSI do AWS Secrets and Configuration Provider com perfis 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 parâmetros no Parameter Store. Essa abordagem é benéfica quando: + Você precisa de 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 [Usar o CSI do AWS Secrets and Configuration Provider com a Identidade de Pods 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: + Versão do Amazon EKS: a Identidade de Pods 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 Amazon EKS. Com o ASCP, você pode montar parâmetros do Parameter Store e segredos do AWS Secrets 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 + A AWS CLI está instalada e configurada + 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 no GitHub no repositório [secrets-store-csi-driver-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 alterando o valor de `objectType` de `secretsmanager` para `ssmparameter`. Durante a instalação, é possível configurar o ASCP para usar um endpoint do FIPS. Para obter uma lista de endpoints do Systems Manager, consulte [os endpoints do serviço do Systems Manager](https://docs.aws.amazon.com/general/latest/gr/ssm.html#ssm_region) no *Referência geral da Amazon Web Services*. **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. Adicione o gráfico de driver CSI do armazenamento de segredos. ``` helm repo add secrets-store-csi-driver https://kubernetes-sigs.github.io/secrets-store-csi-driver/charts ``` 1. Instale o chart. 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"}'` ``` helm install -n kube-system csi-secrets-store secrets-store-csi-driver/secrets-store-csi-driver ``` 1. Adicione o gráfico ASCP. ``` helm repo add aws-secrets-manager https://aws.github.io/secrets-store-csi-driver-provider-aws ``` 1. Instale o chart. Para usar um endpoint do FIPS, adicione o sinalizador a seguir: `--set useFipsEndpoint=true` ``` helm install -n kube-system secrets-provider-aws aws-secrets-manager/secrets-store-csi-driver-provider-aws ``` **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`. Substitua o *texto do espaço reservado padrão* pelo seu próprio ID do pod: ``` kubectl -n kube-system get pods ``` ``` kubectl -n kube-system logs pod/pod-id ``` 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 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 do Secrets Store no GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws) # Usar o CSI do AWS Secrets and Configuration Provider com a Identidade de Pods para Amazon EKS A integração do AWS Secrets and Configuration Provider com o agente da Identidade de Pods para Amazon Elastic Kubernetes Service fornece segurança aprimorada, configuração simplificada e performance aprimorada para aplicações executadas no Amazon EKS. A Identidade de Pods simplifica a autenticação do AWS Identity and Access Management (IAM) para Amazon EKS ao recuperar parâmetros do Parameter Store do AWS Systems Manager ou segredos do Secrets Manager. 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 todos os perfis, mas também aumenta a segurança ao permitir o acesso a recursos da AWS com base nas tags correspondentes. ## Como funciona 1. A Identidade de Pods atribui um perfil do IAM ao pod. 1. O ASCP usa esse perfil para se autenticar com os Serviços da AWS. 1. Se autorizado, o ASCP recupera os parâmetros 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 à AWS CLI e ao cluster do Amazon EKS por meio do `kubectl` + (Opcional) Acesso a duas 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 da Identidade de Pods no cluster. Substitua o *texto do espaço reservado padrão* pelos seus próprios valores: ``` 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 `ssm:GetParameters` e `ssm:DescribeParameters` aos parâmetros que o pod precisa acessar. 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 à função. Substitua o *texto do espaço reservado padrão* pelos seus próprios valores: ``` 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 o `SecretProviderClass` que especifica quais parâmetros ou segredos devem ser montados no pod: ``` kubectl apply -f 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 parâmetros ou segredos em `/mnt/secrets-store`: ``` kubectl apply -f kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleDeployment-PodIdentity.yaml ``` 1. Se você usar um cluster privado do Amazon EKS, certifique-se de que a VPC na qual o cluster se encontra tenha um endpoint do AWS STS. 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 parâmetro ou o segredo foi montado corretamente, execute o comando a seguir. Substitua o *texto do espaço reservado padrão* pelos seus próprios valores: ``` kubectl exec -it $(kubectl get pods | awk '/pod-identity-deployment/{print $1}' | head -1) -- cat /mnt/secrets-store/MyParameter ``` **Para configurar a Identidade de Pods do Amazon EKS para acessar os parâmetros no Parameter Store** 1. Crie uma política de permissões que conceda as permissões `ssm:GetParameters` e `ssm:DescribeParameters` aos parâmetros que o pod precisa acessar. 1. Crie um parâmetro no Parameter Store, caso ainda não tenha um. Para mais informações, consulte [Criar parâmetros do Parameter Store no Systems Manager](sysman-paramstore-su-create.md). ## 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, em *pod-id*, use o ID dos pods encontrados na etapa anterior. Se você não estiver usando o namespace padrão, use `-n NAMESPACE`. ``` kubectl describe pod/pod-id ``` **Para ver erros para o ASCP** + Para encontrar mais informações nos logs do provedor, no comando a seguir, em *PODID*, use a ID do pod *csi-secrets-store-provedor-aws*. ``` kubectl -n kube-system get pods kubectl -n kube-system logs pod/pod-id ``` # Usar o CSI do AWS Secrets and Configuration Provider com perfis do IAM para contas de serviço (IRSA) **Topics** + [ ## Pré-requisitos ](#prerequisites) + [ ## Configurar o controle de acesso ](#integrating_ascp_irsa_access) + [ ## Identificar quais parâmetros 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 à AWS CLI e ao cluster do Amazon EKS por meio do `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 parâmetros que você autorizou. Outros contêineres não podem acessar os parâmetros, a menos que você também os associe à função do IAM. **Para conceder ao seu pod do Amazon EKS acesso aos parâmetros no Parameter Store** 1. Crie uma política de permissões que conceda as permissões `ssm:GetParameters` e `ssm:DescribeParameters` aos parâmetros que o pod precisa acessar. 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ê usar um cluster privado do Amazon EKS, certifique-se de que a VPC na qual o cluster se encontra tenha um endpoint do AWS STS. 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 parâmetros montar Para determinar quais parâmetros 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 parâmetros 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. ### Montar os parâmetros como arquivos As seguintes instruções mostram como montar parâmetros como arquivos usando exemplos de arquivos YAML: [ExampleSecretProviderClass.yaml](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleSecretProviderClass-IRSA.yaml) e [ExampleDeployment.yaml](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleDeployment-IRSA.yaml). **Para montar parâmetros 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 name-space`. ``` kubectl get pods ``` 1. Para descrever o pod, no comando a seguir, em *pod-id*, use o ID dos pods encontrados na etapa anterior. Se você não estiver usando o namespace padrão, use `-n nameSpace`. ``` kubectl describe pod/pod-id ``` **Para ver erros para o ASCP** + Para encontrar mais informações nos logs do provedor, no comando a seguir, em *pod-id*, use o ID do pod *csi-secrets-store-provider-aws*. ``` kubectl -n kube-system get pods kubectl -n kube-system logs Pod/pod-id ``` + **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 objeto do SecretProviderClass foi criado.** ``` kubectl get secretproviderclass SecretProviderClassName -o yaml ``` # Exemplos de código do provedor de configuração e do AWS Secrets ## 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 parâmetros devem ser montados no Amazon EKS usando o ASCP. Para obter exemplos, consulte [Uso do SecretProviderClass](#ascp-scenarios-secretproviderclass). ### Estrutura SecretProviderClass do 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) A Região da AWS do parâmetro. 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 parâmetro de ambas as regiões. Se qualquer uma das regiões retornar um erro `4xx`, por exemplo, para um problema de autenticação, o ASCP não montará nenhum parâmetro. Se o parâmetro for recuperado com êxito de `region```, o ASCP montará o valor desse parâmetro. Se o parâmetro não for recuperado com êxito de `region`, mas for recuperado com êxito de `failoverRegion`, o ASCP montará o valor desse parâmetro. **`failoverRegion`** (Opcional) Se você incluir este campo, o ASCP tentará recuperar o parâmetro das regiões definidas em `region` e neste campo. Se qualquer uma das regiões retornar um erro `4xx`, por exemplo, para um problema de autenticação, o ASCP não montará nenhum parâmetro. Se o parâmetro for recuperado com êxito de `region`, o ASCP montará o valor desse parâmetro. Se o parâmetro não for recuperado com êxito de `region`, mas for recuperado com êxito de `failoverRegion`, o ASCP montará o valor desse parâmetro. Para obter um exemplo de como usar esse campo, consulte [Failover de parâmetros multirregionais](#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/Parameter` será montado como `My_Path_Parameter`. 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"`: force o uso do endpoint IPv4 do atendente da Identidade de Pods + `"ipv6"`, `"IPv6"` ou `"IPV6"`: force o uso do endpoint IPv6 do atendente da Identidade de Pods + não especificado: use a seleção automática de endpoints, testando primeiro o endpoint IPv4 e voltando para o endpoint IPv6, se o IPv4 falhar **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 Parameter Store, este é 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. 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. **objectType** Necessário se você não usar um ARN do Secrets Manager para `objectName`. Para Parameter Store, use `ssmparameter`. Para o Secrets Manager, use `secretsmanager`. **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. **objectVersion** (Opcional) O ID da versão do parâmetro. Não recomendado porque você deverá atualizar o ID da versão sempre que atualizar o parâmetro. 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`. Se você incluir um `failoverRegion`, esse campo representará o `objectVersionLabel` primário. **jmesPath** (Opcional) Um mapa das chaves no parâmetro para os arquivos a serem montados no Amazon EKS. Para usar esse campo, o valor do parâmetro deve estar no formato JSON. O exemplo a seguir mostra a aparência de um parâmetro codificado em JSON. ``` { "username" : "myusername", "password" : "mypassword" } ``` As chaves são`username`e`password`. O valor associado a`username`é`myusername`, e o valor associado a`password`é`mypassword`. 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 parâmetro. 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"'` **`failoverObject`** (Opcional) Se você especificar este campo, o ASCP tentará recuperar o parâmetro especificado no `objectName` primário e o parâmetro especificado no subcampo `objectName` de `failoverObject`. Se qualquer um retornar um erro `4xx`, por exemplo, para um problema de autenticação, o ASCP não montará nenhum parâmetro. Se o parâmetro for recuperado com êxito do `objectName` primário, o ASCP montará o valor desse parâmetro. Se o parâmetro 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 parâmetro. Se incluir esse campo, será necessário incluir o campo `objectAlias`. Para obter um exemplo de como usar esse campo, consulte [Failover para um parâmetro diferente](#failover-parameter). Normalmente, você usa esse campo quando o parâmetro de failover não é uma réplica. Para obter um exemplo de como especificar uma réplica, consulte [Failover de parâmetros multirregionais](#multi-region-failover). **objectName** O nome ou o ARN completo do parâmetro 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 parâmetro. Deve corresponder ao `objectVersion` primário. Não recomendado porque você deverá atualizar o ID da versão sempre que atualizar o parâmetro. 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`. ### Crie uma configuração básica de SecretProviderClass para montar parâmetros nos pods do Amazon EKS. ------ #### [ Pod Identity ] SecretProviderClass para usar um parâmetro no mesmo cluster do Amazon EKS: ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-parameter-store spec: provider: aws parameters: objects: | - objectName: "MyParameter" objectType: "ssmparameter" usePodIdentity: "true" ``` ------ #### [ IRSA ] ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: deployment-aws-parameter spec: provider: aws parameters: objects: | - objectName: "MyParameter" objectType: "ssmparameter" ``` ------ ### Uso do SecretProviderClass Use estes exemplos para criar configurações de `SecretProviderClass` para diferentes cenários. #### Exemplo: montar parâmetros por nome ou ARN Este exemplo mostra como montar três tipos diferentes de parâmetros: + Um parâmetro especificado por ARN completo + Um parâmetro especificado por nome + Uma versão de parâmetro de um segredo ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-parameters spec: provider: aws parameters: objects: | - objectName: "arn:aws:ssm:us-east-2:777788889999:parameter:MyParameter2-d4e5f6" - objectName: "MyParameter3" objectType: "ssmparameter" - objectName: "MyParameter4" objectType: "ssmparameter" objectVersionLabel: "AWSCURRENT" ``` #### Exemplo: montar pares de chave/valor de um parâmetro Este exemplo mostra como montar pares de chave-valor específicos de um parâmetro formatado em JSON: ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-parameters spec: provider: aws parameters: objects: | - objectName: "arn:aws:ssm:us-east-2:777788889999:parameter:MyParameter-a1b2c3" jmesPath: - path: username objectAlias: dbusername - path: password objectAlias: dbpassword ``` #### Exemplo: exemplos de configuração de failover Estes exemplos mostram como configurar o failover para parâmetros. ##### Failover de parâmetros multirregionais Este exemplo mostra como configurar o failover automático para um parâmetro replicado em várias regiões: ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-parameters spec: provider: aws parameters: region: us-east-1 failoverRegion: us-east-2 objects: | - objectName: "MyParameter" ``` ##### Failover para um parâmetro diferente Este exemplo mostra como configurar o failover para um parâmetro diferente (não uma réplica): ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-parameters spec: provider: aws parameters: region: us-east-1 failoverRegion: us-east-2 objects: | - objectName: "arn:aws:ssm:us-east-1:777788889999:parameter:MyParameter-a1b2c3" objectAlias: "MyMountedParameter" failoverObject: - objectName: "arn:aws:ssm:us-east-2:777788889999:parameter:MyFailoverParameter-d4e5f6" ``` ## Recursos adicionais 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) + [Driver CSI do AWS Secrets Store no GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)