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á.
# Regras de controle de acesso com base em função (RBAC)
Com o comando AUTH do Valkey e Redis OSS, conforme descrito em [Autenticar com o comando AUTH do Valkey e Redis OSS](auth.md), você pode usar o controle de acesso baseado em funções (RBAC). O RBAC também é a única maneira de controlar o acesso a caches sem servidor. Isso está disponível para o Valkey 7.2 e posterior e o Redis OSS 6.0 a 7.2 e posterior.
O RBAC permite que você:
+ Controle o acesso ao cache por meio de grupos de usuários. Esses grupos de usuários foram projetados como uma maneira de organizar o acesso a caches.
+ Com o *authN*, tenha senhas por usuário em vez de tokens de autenticação por cluster.
+ Com o *authZ*, tenha permissões de usuário refinadas.
+ Baseie seu acesso ao cluster em ACLs.
Diferentemente do AUTH do Valkey e do Redis OSS, no qual todos os clientes autenticados têm acesso total ao cache em caso de autenticação do token, o RBAC permite atribuir usuários a sets dependendo das funções desejadas dos usuários. Esses sets foram projetados como uma maneira de organizar o acesso a caches.
Com o RBAC, você cria usuários e atribui a eles permissões específicas usando uma cadeia de acesso, conforme descrito a seguir. Você atribui os usuários a conjuntos alinhados com uma função específica (administradores, recursos humanos) que são então implantados em um ou mais caches. ElastiCache Fazendo isso, você pode estabelecer limites de segurança entre clientes usando o mesmo cache ou caches do Valkey ou Redis OSS e impedir que os clientes acessem os dados uns dos outros.
O RBAC foi projetado para oferecer suporte à introdução da [ACL](https://valkey.io/topics/acl/) no Redis OSS 6. Quando você usa o RBAC com seu cache OSS ElastiCache Valkey ou Redis, há algumas limitações:
+ Um grupo de usuários configurado para o mecanismo “VALKEY” só pode conter usuários que estejam usando um mecanismo de autenticação (senha ou IAM). Isso significa que todos os usuários com o mecanismo “VALKEY” e quaisquer outros usuários com o mecanismo “Redis” que tenham sua configuração definida para autenticação com senha ou IAM podem estar nesse grupo de usuários.
+ Ao usar o RBAC com clusters Valkey, os dois grupos de usuários com o mecanismo “VALKEY” e com o mecanismo “REDIS” podem ser usados.
+ Ao usar o RBAC com clusters Redis OSS, você poderá usar somente grupos de usuários com o mecanismo “REDIS”.
+ Não é possível especificar senhas em uma string de acesso. Você define senhas com [CreateUser](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateUser.html)nossas [ModifyUser](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyUser.html)chamadas.
+ Para direitos de usuário, você habilita ou desabilita usuários com `on` e `off` como parte da string de acesso. Se nenhum deles for especificado na string de acesso, o usuário receberá `off` e não terá direitos de acesso ao cache.
+ Não é possível usar comandos proibidos e renomeados como parte da string de acesso. Se você especificar um comando proibido ou renomeado, será emitida uma exceção. Se você quiser usar listas de controle de acesso (ACLs) para um comando renomeado, especifique o nome original do comando, em outras palavras, o nome do comando antes de ser renomeado.
+ Não é possível usar o comando `reset` como parte de uma string de acesso. Você especifica senhas com parâmetros de API e, ElastiCache para Valkey e Redis, o OSS gerencia senhas. Assim, você não pode usar `reset` porque ele removeria todas as senhas de um usuário.
+ O Redis OSS 6 apresenta o comando [ACL LIST](https://valkey.io/commands/acl-list). Esse comando retorna uma lista de usuários junto com as regras de ACL aplicadas a cada usuário. ElastiCache suporta o `ACL LIST` comando, mas não inclui suporte para hashes de senha, como faz o Redis OSS. Com ElastiCache, você pode usar a [DescribeUsers](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeUsers.html)operação para obter informações semelhantes, incluindo as regras contidas na string de acesso. No entanto, [DescribeUsers](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeUsers.html)não recupera a senha do usuário.
+ [https://valkey.io/commands/acl-users](https://valkey.io/commands/acl-users) ElastiCache para Valkey e Redis, o OSS não oferece suporte a nenhum outro comando ACL baseado em gravação.
+ Os limites a seguir se aplicam ao seguinte:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/Clusters.RBAC.html)
**RBAC com Valkey**
Ao usar o Controle de Acesso Baseado em Função com o Valkey, os usuários e grupos de usuários são criados com o tipo de mecanismo “VALKEY”. Isso é recomendado, pois, por padrão, o Valkey com RBAC oferece maior segurança em comparação com o Redis OSS. Os clusters Valkey provisionados e com tecnologia sem servidor oferecem suporte a associações de usuários e grupos de usuários do VALKEY.
Os principais atributos do Valkey Access Control incluem:
+ Os usuários do Valkey estão restritos somente às associações de grupos de usuários do Valkey.
+ Os grupos de usuários do Valkey podem conter usuários do Valkey e usuários do Redis OSS protegidos por senha ou habilitados para autenticação do IAM.
+ Os usuários do Valkey devem usar proteção por senha ou autenticação do IAM.
+ Os grupos de usuários do VALKEY só podem ser associados aos clusters do VALKEY
+ Não há nenhum requisito de usuário padrão. Quando o grupo de usuários do Valkey é anexado aos clusters, o requisito de usuário padrão é automaticamente desativado. Os clientes verão que o usuário padrão está desativado ao usar o comando ACL LIST.
Veja a seguir mais informações sobre como usar o RBAC com o ElastiCache Valkey e o Redis OSS.
**Topics**
+ [Especificação de permissões usando uma string de acesso](#Access-string)
+ [Aplicando o RBAC a um cache ElastiCache para Valkey ou Redis OSS](#rbac-using)
+ [Migração do AUTH para o RBAC](#Migrate-From-RBAC-to-Auth)
+ [Migração do RBAC para o AUTH](#Migrate-From-RBAC-to-AUTH-1)
+ [Alternância automática de senhas para os usuários](User-Secrets-Manager.md)
+ [Autenticação com o IAM](auth-iam.md)
## Especificação de permissões usando uma string de acesso
Para especificar permissões para um cache OSS ElastiCache Valkey ou Redis, você cria uma string de acesso e a atribui a um usuário por meio do ou.AWS CLIConsole de gerenciamento da AWS
As cadeias de caracteres de acesso são definidas como uma lista de regras delimitadas por espaço que são aplicadas ao usuário. Eles definem quais comandos um usuário pode executar e em quais chaves um usuário pode operar. Para executar um comando, um usuário deve ter acesso ao comando que está sendo executado e todas as chaves que estão sendo acessadas pelo comando. Regras são aplicadas da esquerda para a direita cumulativamente, e uma string mais simples pode ser usada em vez da fornecida se houver redundâncias na string fornecida.
Para obter informações sobre a sintaxe das regras ACL, consulte [ACL](https://valkey.io/topics/acl/).
No exemplo a seguir, a string de acesso representa um usuário ativo com acesso a todas as chaves e comandos disponíveis.
`on ~* +@all`
A sintaxe da cadeia de acesso é dividida da seguinte forma:
+ `on`: o usuário é um usuário ativo.
+ `~*`: o acesso é dado a todas as chaves disponíveis.
+ `+@all`: o acesso é dado a todos os comandos disponíveis.
As configurações anteriores são as menos restritivas. Você pode modificar essas configurações para torná-las mais seguras.
No exemplo a seguir, a string de acesso representa um usuário com acesso restrito ao acesso de leitura em chaves que começam com o keyspace "app::"
`on ~app::* -@all +@read`
Você pode refinar mais essas permissões listando comandos aos quais o usuário tem acesso:
`+command1`: o acesso do usuário aos comandos é limitado a *`command1`*.
`+@category`: o acesso do usuário é limitado a uma categoria de comandos.
Para obter informações sobre como atribuir uma string de acesso a um usuário, consulte [Criação de usuários e grupos de usuários com o console e a CLI](#Users-management).
Se você estiver migrando uma carga de trabalho existente para ElastiCache, poderá recuperar a string de acesso chamando`ACL LIST`, excluindo o usuário e quaisquer hashes de senha.
Para o Redis OSS versão 6.2 e posteriores, a seguinte sintaxe de string de acesso também tem suporte:
+ `&*`: o acesso é dado a todos os canais disponíveis.
Para o Redis OSS versão 7.0 e posteriores, a seguinte sintaxe de string de acesso também tem suporte:
+ `|`: ´pode ser usado para bloquear subcomandos (por exemplo, "-config\$1set").
+ `%R~`: adicione o padrão de chave de leitura especificado. Comporta-se de forma semelhante ao padrão de chave normal, mas só concede permissão para ler chaves que correspondam ao padrão fornecido. Para obter mais informações, consulte [permissões de chave](https://valkey.io/topics/acl/).
+ `%W~`: adicione o padrão de chave de gravação especificado. Comporta-se de forma semelhante ao padrão de chave normal, mas só concede permissão para gravar em chaves que correspondam ao padrão fornecido. Para obter mais informações, consulte [Permissões de chave de ACL](https://valkey.io/topics/acl/).
+ `%RW~`: alias para `~`.
+ `()`: crie um novo seletor para combinar as regras. Os seletores são avaliados após as permissões do usuário e são avaliados de acordo com a ordem em que são definidos. Se um comando corresponder às permissões do usuário ou a qualquer seletor, ele será permitido. Para obter mais informações, consulte [Seletores de ACL](https://valkey.io/topics/acl/).
+ `clearselectors`: exclua todos os seletores associados ao usuário.
## Aplicando o RBAC a um cache ElastiCache para Valkey ou Redis OSS
ElastiCache Para usar o Valkey ou o Redis OSS RBAC, siga as seguintes etapas:
1. Crie um ou mais usuários.
1. Crie um grupo de usuários e adicione usuários ao grupo.
1. Atribua o grupo de usuários a um cache que tenha criptografia em trânsito habilitada.
Essas etapas estão descritas em detalhes a seguir.
**Topics**
+ [Criação de usuários e grupos de usuários com o console e a CLI](#Users-management)
+ [Gerenciamento de grupos de usuários com o console e a CLI](#User-Groups)
+ [Atribuição de grupos de usuários a caches sem servidor](#Users-groups-to-serverless-caches)
+ [Atribuição de grupos de usuários a grupos de replicação](#Users-groups-to-RGs)
### Criação de usuários e grupos de usuários com o console e a CLI
As informações de usuário para usuários do RBAC são um ID de usuário, nome de usuário e, opcionalmente, uma senha e uma string de acesso. A string de acesso fornece o nível de permissão em chaves e comandos. O ID de usuário é exclusivo para o usuário e o nome de usuário é o que é passado para o mecanismo.
Certifique-se de que as permissões do usuário fornecidas fazem sentido com a finalidade pretendida do grupo de utilizadores. Por exemplo, se você criar um grupo de usuários chamado `Administrators`, qualquer usuário que você adicionar a esse grupo deve ter sua string de acesso definida para acesso total a chaves e comandos. Para usuários em um grupo de usuários `e-commerce`, você pode definir suas cadeias de acesso para acesso somente leitura.
ElastiCache configura automaticamente um usuário padrão com ID de usuário e nome de usuário `"default"` e o adiciona a todos os grupos de usuários. Você não pode excluir ou modificar esse usuário. Esse usuário destina-se à compatibilidade com o comportamento padrão das versões anteriores do Redis OSS e tem uma string de acesso que permite chamar todos os comandos e acessar todas as chaves.
Para adicionar um controle de acesso indicado a um cache, substitua esse usuário padrão por um novo que não esteja habilitado ou use uma senha forte. Para alterar o usuário padrão, crie um novo usuário com o nome de usuário definido como `default`. Em seguida, você pode trocá-lo pelo usuário padrão original.
Os seguintes procedimentos mostram como trocar o usuário `default` original por outro usuário `default` que tem uma string de acesso modificada.
**Para modificar o usuário padrão no console**
1. Faça login no Console de gerenciamento da AWS e abra o ElastiCache console da Amazon em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Escolha **Gerenciamento de grupos de usuários** no painel de navegação.
1. Em **ID do grupo de usuários**, escolha o ID que você deseja modificar. Verifique se você escolheu o link e não a caixa de seleção.
1. Escolha **Modificar**.
1. Na janela **Modificar**, escolha **Gerenciar**. Para “selecionar o usuário que você deseja”, selecione o usuário com o **nome de usuário** como padrão.
1. Selecione **Choose (Escolher)**.
1. Escolha **Modificar**. Quando você fizer isso, todas as conexões existentes com um cache que o usuário padrão original tiver serão encerradas.
**Para modificar o usuário padrão com o AWS CLI**
1. Criar um novo usuário com o nome de usuário `default` usando os seguintes comandos.
Para Linux, macOS ou Unix:
```
aws elasticache create-user \
--user-id "new-default-user" \
--user-name "default" \
--engine "VALKEY" \
--passwords "a-str0ng-pa))word" \
--access-string "off +get ~keys*"
```
Para Windows:
```
aws elasticache create-user ^
--user-id "new-default-user" ^
--user-name "default" ^
--engine "VALKEY" ^
--passwords "a-str0ng-pa))word" ^
--access-string "off +get ~keys*"
```
1. Crie um grupo de usuários e adicione o usuário que você criou anteriormente.
Para Linux, macOS ou Unix:
```
aws elasticache create-user-group \
--user-group-id "new-group-2" \
--engine "VALKEY" \
--user-ids "new-default-user"
```
Para Windows:
```
aws elasticache create-user-group ^
--user-group-id "new-group-2" ^
--engine "VALKEY" ^
--user-ids "new-default-user"
```
Ao criar um usuário, você pode configurar até duas senhas. Quando você modifica uma senha, todas as conexões existentes com os caches são mantidas.
Em particular, esteja ciente dessas restrições de senha de usuário ao usar o RBAC ElastiCache para Valkey e Redis OSS:
+ As senhas devem ter de 16 a 128 caracteres imprimíveis.
+ Os seguintes caracteres não alfanuméricos não são permitidos: `,` `""` `/` `@`.
#### Gerenciamento de usuários com o console e a CLI
Use o procedimento a seguir para gerenciar usuários no console.
**Para gerenciar usuários no console**
1. Faça login no Console de gerenciamento da AWS e abra o ElastiCache console da Amazon em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No ElastiCache painel da Amazon, escolha **Gerenciamento de usuários**. As seguintes opções estão disponíveis:
+ **Criar usuário**: ao criar um usuário, você insere um ID de usuário, um nome de usuário, um modo de autenticação e uma string de acesso. A string de acesso define o nível de permissão para quais chaves e comandos o usuário é permitido.
Ao criar um usuário, você pode configurar até duas senhas. Quando você modifica uma senha, todas as conexões existentes com os caches são mantidas.
+ **Modificar usuário**: permite a você atualizar as configurações de um usuário ou alterar a string de acesso.
+ **Excluir usuário**: a conta de usuário será removida de todos os grupos de usuários aos quais ela pertence.
Use o procedimento a seguir para gerenciar usuários na AWS CLI.
**Para modificar um usuário usando a CLI**
+ Use o comando `modify-user` para atualizar a senha ou senhas de um usuário ou alterar as permissões de acesso de um usuário.
Quando um usuário é modificado, os grupos de usuários associados ao usuário são atualizados com todos os caches associados ao grupo de usuários. Todas as conexões existentes são mantidas. Veja os exemplos a seguir.
Para Linux, macOS ou Unix:
```
aws elasticache modify-user \
--user-id user-id-1 \
--access-string "~objects:* ~items:* ~public:*" \
--authentication-mode Type=iam
```
Para Windows:
```
aws elasticache modify-user ^
--user-id user-id-1 ^
--access-string "~objects:* ~items:* ~public:*" ^
--authentication-mode Type=iam
```
**nota**
Não recomendamos usar a opção `nopass`. Se o fizer, recomendamos definir as permissões do usuário como somente de leitura, com acesso a um conjunto limitado de chaves.
**Para excluir um usuário usando a CLI**
+ Use o comando `delete-user` para excluir um usuário. A conta é excluída e removida de todos os grupos de usuários aos quais pertence. Veja um exemplo do a seguir:
Para Linux, macOS ou Unix:
```
aws elasticache delete-user \
--user-id user-id-2
```
Para Windows:
```
aws elasticache delete-user ^
--user-id user-id-2
```
Para ver uma lista de usuários, execute a operação [describe-users](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-users.html).
```
aws elasticache describe-users
```
### Gerenciamento de grupos de usuários com o console e a CLI
É possível criar grupos de usuários para organizar e controlar o acesso de usuários a um ou mais caches, conforme mostrado a seguir.
Use o procedimento a seguir para gerenciar grupos de usuários no console.
**Como gerenciar grupos de usuários usando o console**
1. Faça login no Console de gerenciamento da AWS e abra o ElastiCache console da Amazon em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No ElastiCache painel da Amazon, escolha **Gerenciamento de grupos de usuários**.
As operações a seguir estão disponíveis para criar novos grupos de usuários:
+ **Criar**: ao criar um grupo de usuários, você adiciona usuários e, em seguida, atribui os grupos de usuários a caches. Por exemplo, é possível criar um grupo de usuários `Admin` para usuários que tenham funções administrativas em um cache.
**Importante**
Se você não estiver usando um grupo de usuários Valkey ou Redis OSS, inclua um usuário padrão ao criar um grupo de usuários.
+ **Add Users** (Adicionar usuários): adiciona usuários ao grupo de usuários.
+ **Remove Users** (Remover usuários): remove usuários do grupo de usuários. Quando os usuários são removidos de um grupo de usuários, todas as conexões existentes que eles têm com um cache são encerradas.
+ **Delete** (Excluir): use para excluir um grupo de usuários. Observe que o próprio grupo de usuários, e não os usuários pertencentes ao grupo, serão excluídos.
Para grupos de usuários existentes, você pode fazer o seguinte:
+ **Add Users** (Adicionar usuários): adiciona usuários existentes ao grupo de usuários.
+ **Delete Users** (Excluir usuários): remove usuários existentes do grupo de usuários.
**nota**
Os usuários são removidos do grupo de usuários, mas não excluídos do sistema.
Use os procedimentos a seguir para gerenciar grupos de usuários na CLI.
**Para criar um novo grupo de usuários e adicionar um usuário usando a CLI**
+ Use o comando `create-user-group`, conforme mostrado a seguir.
Para Linux, macOS ou Unix:
```
aws elasticache create-user-group \
--user-group-id "new-group-1" \
--engine "VALKEY" \
--user-ids user-id-1, user-id-2
```
Para Windows:
```
aws elasticache create-user-group ^
--user-group-id "new-group-1" ^
--engine "VALKEY" ^
--user-ids user-id-1, user-id-2
```
**Para modificar um grupo de usuários adicionando novos usuários ou removendo membros atuais usando a CLI**
+ Use o comando `modify-user-group`, conforme mostrado a seguir.
Para Linux, macOS ou Unix:
```
aws elasticache modify-user-group --user-group-id new-group-1 \
--user-ids-to-add user-id-3 \
--user-ids-to-remove user-id-2
```
Para Windows:
```
aws elasticache modify-user-group --user-group-id new-group-1 ^
--user-ids-to-add user-id-3 ^
--user-ids-to-removere user-id-2
```
**nota**
Quaisquer conexões abertas pertencentes a um usuário removido de um grupo de usuários são encerradas por este comando.
**Para excluir um grupo de usuários usando a CLI**
+ Use o comando `delete-user-group`, conforme mostrado a seguir. O grupo de usuários em si, não os usuários pertencentes ao grupo, é excluído.
Para Linux, macOS ou Unix:
```
aws elasticache delete-user-group /
--user-group-id
```
Para Windows:
```
aws elasticache delete-user-group ^
--user-group-id
```
Para ver uma lista de grupos de usuários, você pode chamar a [describe-user-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-user-groups.html)operação.
```
aws elasticache describe-user-groups \
--user-group-id test-group
```
### Atribuição de grupos de usuários a caches sem servidor
Depois que você tiver criado um grupo de usuários e adicionado usuários, a etapa final na implementação do RBAC será atribuir o grupo de usuários a um cache sem servidor.
#### Atribuição de grupos de usuários a caches sem servidor usando o console
Para adicionar um grupo de usuários a um cache sem servidor usando o Console de gerenciamento da AWS, faça o seguinte:
+ Para o modo cluster desabilitado, consulte [Criação de um cluster do Valkey (modo cluster desabilitado) (console)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)
+ Para o modo cluster habilitado, consulte [Criação de um cluster do Valkey ou Redis OSS (modo cluster habilitado) (console)](Clusters.Create.md#Clusters.Create.CON.RedisCluster)
#### Atribuindo grupos de usuários a caches sem servidor usando o AWS CLI
A AWS CLI operação a seguir cria um cache sem servidor usando o **user-group-id** parâmetro com o valor. `my-user-group-id` Substitua o grupo de sub-redes `sng-test` por um grupo de sub-redes que exista.
**Principais parâmetros**
+ **--engine**: precisa ser `VALKEY` ou `REDIS`.
+ **--user-group-id**: este valor fornece o ID do grupo de usuários, composto de usuários com permissões de acesso especificadas para o cache.
Para Linux, macOS ou Unix:
```
aws elasticache create-serverless-cache \
--serverless-cache-name "new-serverless-cache" \
--description "new-serverless-cache" \
--engine "VALKEY" \
--user-group-id "new-group-1"
```
Para Windows:
```
aws elasticache create-serverless-cache ^
--serverless-cache-name "new-serverless-cache" ^
--description "new-serverless-cache" ^
--engine "VALKEY" ^
--user-group-id "new-group-1"
```
A AWS CLI operação a seguir modifica um cache sem servidor com o **user-group-id** parâmetro com o valor. `my-user-group-id`
Para Linux, macOS ou Unix:
```
aws elasticache modify-serverless-cache \
--serverless-cache-name serverless-cache-1 \
--user-group-id "new-group-2"
```
Para Windows:
```
aws elasticache modify-serverless-cache ^
--serverless-cache-name serverless-cache-1 ^
--user-group-id "new-group-2"
```
Eventuais modificações feitas em um cache são atualizadas de maneira assíncrona. Você pode monitorar este progresso visualizando os eventos. Para obter mais informações, consulte [Visualizando ElastiCache eventos](ECEvents.Viewing.md).
### Atribuição de grupos de usuários a grupos de replicação
Depois de criar um grupo de usuários e adicionar usuários, a etapa final na implementação do RBAC é atribuir o grupo de usuários a um grupo de replicação.
#### Atribuição de grupos de usuários a grupos de replicação usando o console
Para adicionar um grupo de usuários a uma replicação usando o Console de gerenciamento da AWS, faça o seguinte:
+ Para o modo cluster desabilitado, consulte [Criação de um cluster do Valkey (modo cluster desabilitado) (console)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)
+ Para o modo cluster habilitado, consulte [Criação de um cluster do Valkey ou Redis OSS (modo cluster habilitado) (console)](Clusters.Create.md#Clusters.Create.CON.RedisCluster)
#### Atribuindo grupos de usuários a grupos de replicação usando o AWS CLI
A AWS CLI operação a seguir cria um grupo de replicação com a criptografia em trânsito (TLS) ativada e o **user-group-ids** parâmetro com o valor. `my-user-group-id` Substitua o grupo de sub-redes `sng-test` por um grupo de sub-redes que exista.
**Principais parâmetros**
+ **--engine**: precisa ser `valkey` ou `redis`.
+ **--engine-version**: deve ser 6.0 ou posterior.
+ **--transit-encryption-enabled**: necessário para autenticação e para associar um grupo de usuários.
+ **--user-group-ids**: este valor fornece o ID do grupo de usuários, composto de usuários com permissões de acesso especificadas para o cache.
+ **--cache-subnet-group**: necessário para associar um grupo de usuários.
Para Linux, macOS ou Unix:
```
aws elasticache create-replication-group \
--replication-group-id "new-replication-group" \
--replication-group-description "new-replication-group" \
--engine "VALKEY" \
--cache-node-type cache.m5.large \
--transit-encryption-enabled \
--user-group-ids "new-group-1" \
--cache-subnet-group "cache-subnet-group"
```
Para Windows:
```
aws elasticache create-replication-group ^
--replication-group-id "new-replication-group" ^
--replication-group-description "new-replication-group" ^
--engine "VALKEY" ^
--cache-node-type cache.m5.large ^
--transit-encryption-enabled ^
--user-group-ids "new-group-1" ^
--cache-subnet-group "cache-subnet-group"
```
A AWS CLI operação a seguir modifica um grupo de replicação com a criptografia em trânsito (TLS) ativada e o **user-group-ids** parâmetro com o valor. `my-user-group-id`
Para Linux, macOS ou Unix:
```
aws elasticache modify-replication-group \
--replication-group-id replication-group-1 \
--user-group-ids-to-remove "new-group-1" \
--user-group-ids-to-add "new-group-2"
```
Para Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id replication-group-1 ^
--user-group-ids-to-remove "new-group-1" ^
--user-group-ids-to-add "new-group-2"
```
Observe o `PendingChanges` na resposta. Eventuais modificações feitas em um cache são atualizadas de maneira assíncrona. Você pode monitorar este progresso visualizando os eventos. Para obter mais informações, consulte [Visualizando ElastiCache eventos](ECEvents.Viewing.md).
## Migração do AUTH para o RBAC
Se você estiver usando o AUTH conforme descrito em [Autenticar com o comando AUTH do Valkey e Redis OSS](auth.md) e deseja migrar para usar o RBAC, use os seguintes procedimentos.
Use o procedimento a seguir para migrar do AUTH para o RBAC usando o console.
**Para migrar do AUTH do Valkey ou Redis OSS para o RBAC usando o console**
1. Faça login no Console de gerenciamento da AWS e abra o ElastiCache console em [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Na lista no canto superior direito, escolha a AWS região em que o cache que você deseja modificar está localizado.
1. No painel de navegação, escolha o mecanismo em execução no cache que você deseja modificar.
Uma lista dos caches do mecanismo escolhido é exibida.
1. Na lista de caches, para o cache que você deseja modificar, escolha o nome.
1. Para **Actions (Ações)**, escolha **Modify (Modificar)**.
A janela **Modificar** é exibida.
1. Para **Controle de acesso**, escolha **Lista de controle de acesso do grupo de usuários**.
1. Em **Lista de controle de acesso do grupo de usuários**, escolha um grupo de usuários.
1. Escolha **Previsualizar alterações** e, na próxima tela, **Modificar**.
Use o procedimento a seguir para migrar do AUTH do Valkey ou Redis OSS para o RBAC usando a CLI.
**Para migrar do AUTH para o RBAC usando a CLI**
+ Use o comando `modify-replication-group`, conforme mostrado a seguir.
Para Linux, macOS ou Unix:
```
aws elasticache modify-replication-group --replication-group-id test \
--auth-token-update-strategy DELETE \
--user-group-ids-to-add user-group-1
```
Para Windows:
```
aws elasticache modify-replication-group --replication-group-id test ^
--auth-token-update-strategy DELETE ^
--user-group-ids-to-add user-group-1
```
## Migração do RBAC para o AUTH
Se você estiver usando o RBAC e desejar migrar para o AUTH do Redis OSS, consulte [Migração do RBAC para o AUTH](auth.md#Migrate-From-RBAC-to-AUTH).
**nota**
Se precisar desativar o controle de acesso em um ElastiCache cache, você precisará fazer isso por meio do AWS CLI. Para obter mais informações, consulte [Desabilitar o controle de acesso em um cache do ElastiCache Valkey ou Redis OSS](in-transit-encryption-disable.md).
# Alternância automática de senhas para os usuários
Com AWS Secrets Manager, você pode substituir as credenciais codificadas em seu código (incluindo senhas) por uma chamada de API para o Secrets Manager para recuperar o segredo programaticamente. Isso ajuda a garantir que o segredo não será comprometido por alguém que esteja examinando seu código, pois o segredo simplesmente não está ali. Além disso, configure o Secrets Manager para alterar automaticamente o segredo para você de acordo com a programação que você especificar. Isso permite substituir segredos de longo prazo por outros de curto prazo, ajudando a reduzir de maneira significativa o risco de comprometimento.
Usando o Secrets Manager, você pode alternar automaticamente suas ElastiCache senhas do OSS do Redis (ou seja, segredos) usando uma AWS Lambda função fornecida pelo Secrets Manager.
Para obter mais informações sobre AWS Secrets Manager, consulte [O que éAWS Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html)
## Como ElastiCache usa segredos
O Valkey 7.2 e superiores têm um conjunto de atributos equivalente ao Redis OSS 7.0. No Redis OSS 6, ElastiCache introduzido [Regras de controle de acesso com base em função (RBAC)](Clusters.RBAC.md) para proteger o cluster Valkey ou Redis OSS. Esse recurso permite que certas conexões sejam limitadas em termos dos comandos que podem ser executados e das chaves que podem ser acessadas. Com o RBAC, enquanto o cliente cria um usuário com senhas, os valores da senha precisam ser inseridos manualmente em texto sem formatação e ficam visíveis para o operador.
Com o Secrets Manager, as aplicações buscam a senha do Secrets Manager em vez de inseri-la manualmente e armazená-la na configuração da aplicação. Para obter informações sobre como fazer isso, consulte [Como ElastiCache os usuários são associados ao segredo](#How-User-Secrets-Manager-Associate).
O uso de segredos tem um custo. Para obter informações sobre preços, consulte [Preços do AWS](https://aws.amazon.com/secrets-manager/pricing/).
## Como ElastiCache os usuários são associados ao segredo
O Secrets Manager manterá uma referência para o usuário associado no campo `SecretString` do segredo. Não haverá nenhuma referência ao segredo do ElastiCache lado de fora.
```
{
"password": "strongpassword",
"username": "user1",
"user_arn": "arn:aws:elasticache:us-east-1:xxxxxxxxxx918:user:user1" //this is the bond between the secret and the user
}
```
## Função de alternância do Lambda
Para habilitar a alternância automática de senhas do Secrets Manager, você criará uma função do Lambda que interagirá com a API [modify-user](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-user.html) para atualizar as senhas do usuário.
Para obter informações sobre como isso funciona, consulte [Como funciona a alternância](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets.html#rotate-secrets_how).
**nota**
Para alguns AWS serviços, para evitar o cenário confuso de substituto,AWS recomenda que você use as chaves de condição `aws:SourceArn` e as chaves de condição `aws:SourceAccount` globais. No entanto, se você incluir a condição `aws:SourceArn` em sua política de função de alternância, a função de alternância só poderá ser usada para alternar o segredo especificado por esse ARN. Recomendamos que inclua apenas a chave de contexto `aws:SourceAccount`, de modo que possa usar a função de alternância para vários segredos.
Para quaisquer problemas que você possa encontrar, consulte [Solucionar problemas de rotação do AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/troubleshoot_rotation.html).
## Como criar um ElastiCache usuário e associá-lo ao Secrets Manager
As seguintes etapas ilustram como criar um usuário e associá-lo ao Secrets Manager:
1. **Criar um usuário inativo**
Para Linux, macOS ou Unix:
```
aws elasticache create-user \
--user-id user1 \
--user-name user1 \
--engine "REDIS" \
--no-password \ // no authentication is required
--access-string "*off* +get ~keys*" // this disables the user
```
Para Windows:
```
aws elasticache create-user ^
--user-id user1 ^
--user-name user1 ^
--engine "REDIS" ^
--no-password ^ // no authentication is required
--access-string "*off* +get ~keys*" // this disables the user
```
Você verá uma resposta semelhante ao seguinte:
```
{
"UserId": "user1",
"UserName": "user1",
"Status": "active",
"Engine": "redis",
"AccessString": "off ~keys* -@all +get",
"UserGroupIds": [],
"Authentication": {
"Type": "no_password"
},
"ARN": "arn:aws:elasticache:us-east-1:xxxxxxxxxx918:user:user1"
}
```
1. **Criar um segredo**
Para Linux, macOS ou Unix:
```
aws secretsmanager create-secret \
--name production/ec/user1 \
--secret-string \
'{
"user_arn": "arn:aws:elasticache:us-east-1:123456xxxx:user:user1",
"username":"user1"
}'
```
Para Windows:
```
aws secretsmanager create-secret ^
--name production/ec/user1 ^
--secret-string ^
'{
"user_arn": "arn:aws:elasticache:us-east-1:123456xxxx:user:user1",
"username":"user1"
}'
```
Você verá uma resposta semelhante ao seguinte:
```
{
"ARN": "arn:aws:secretsmanager:us-east-1:123456xxxx:secret:production/ec/user1-eaFois",
"Name": "production/ec/user1",
"VersionId": "aae5b963-1e6b-4250-91c6-ebd6c47d0d95"
}
```
1. **Configurar uma função do Lambda para alternar sua senha**
1. Faça login no Console de gerenciamento da AWS e abra o console Lambda em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/elasticache/)
1. No painel de navegação, escolha **Functions** (Funções) e escolha a função que você criou. Escolha o nome da função, não a caixa de seleção à esquerda.
1. Escolha a guia **Configuration** (Configuração).
1. Em **General configuration** (Configuração geral), escolha **Edit** (Editar) e defina **Timeout** (Tempo limite) para pelo menos 12 minutos.
1. Escolha **Salvar**.
1. Escolha **Environment variables** (Variáveis de ambiente) e defina o seguinte:
1. SECRETS\$1MANAGER\$1ENDPOINT – https://secretsmanager. **REGION**.amazonaws.com
1. SECRET\$1ARN – O nome de recurso da Amazon (ARN) do segredo que você criou na etapa 2.
1. USER\$1NAME — Nome de usuário do ElastiCache usuário,
1. Escolha **Salvar**.
1. Escolha **Permissions** (Permissões)
1. Em **Execution role** (Função de execução), escolha o nome da função do Lambda para exibição no console do IAM.
1. A função do Lambda precisará da seguinte permissão para modificar os usuários e definir a senha:
ElastiCache
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticache:DescribeUsers",
"elasticache:ModifyUser"
],
"Resource": "arn:aws:elasticache:us-east-1:123456789012:user:user1"
}
]
}
```
------
Secrets Manager
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue",
"secretsmanager:DescribeSecret",
"secretsmanager:PutSecretValue",
"secretsmanager:UpdateSecretVersionStage"
],
"Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:XXXX"
},
{
"Effect": "Allow",
"Action": "secretsmanager:GetRandomPassword",
"Resource": "*"
}
]
}
```
------
1. Configurar a alternância de segredos do Secrets Manager
1. **Usando o Console de gerenciamento da AWS, consulte [Configurar a rotação automática para AWS segredos do Secrets Manager usando o console](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets_turn-on-for-other.html)**
Para obter mais informações sobre como configurar uma programação de alternância, consulte [Programe expressões nas alternâncias do Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets_schedule.html).
1. **Usando o AWS CLI, consulte [Configurar a rotação automática para AWS Secrets Manager usar o AWS Command Line Interface](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets-cli.html)**
# Autenticação com o IAM
**Topics**
+ [Visão geral do](#auth-iam-overview)
+ [Limitações](#auth-iam-limits)
+ [Configuração](#auth-iam-setup)
+ [Conexão](#auth-iam-Connecting)
## Visão geral do
Com a autenticação IAM, você pode autenticar uma conexão ElastiCache para Valkey ou Redis OSS usando identidades AWS IAM, quando seu cache está configurado para usar Valkey ou Redis OSS versão 7 ou superior. Isso possibilita que você fortaleça seu modelo de segurança e simplifique várias tarefas administrativas de segurança. Você também pode usar a autenticação do IAM para configurar um controle de acesso refinado para cada ElastiCache cache e ElastiCache usuário individual, seguindo os princípios de permissões de privilégio mínimo. O IAM Authentication for ElastiCache funciona fornecendo um token de autenticação IAM de curta duração em vez de uma senha de ElastiCache usuário de longa duração no OSS ou comando Valkey ou Redis. `AUTH` `HELLO` Para obter mais informações sobre o token de autenticação do IAM, consulte o [processo de assinatura do Signature versão 4](https://docs.aws.amazon.com//general/latest/gr/signature-version-4.html) no Guia de referência AWS geral e no exemplo de código abaixo.
Você pode usar as identidades do IAM e suas políticas associadas para restringir ainda mais o acesso ao Valkey ou Redis OSS. Também é possível conceder acesso a usuários dos provedores de identidade federados diretamente para caches do Valkey ou Redis OSS.
Para usar o AWS IAM com ElastiCache, primeiro você precisa criar um ElastiCache usuário com o modo de autenticação definido como IAM. Em seguida, você pode criar ou reutilizar uma identidade do IAM. A identidade do IAM precisa de uma política associada para conceder a `elasticache:Connect` ação ao ElastiCache cache e ao ElastiCache usuário. Depois de configurado, você pode criar um token de autenticação do IAM usando AWS as credenciais do usuário ou da função do IAM. Por fim, você precisa fornecer o token de autenticação do IAM de curta duração como uma senha no cliente do Valkey ou Redis OSS ao se conectar ao cache. Um cliente Valkey ou Redis OSS com suporte para provedor de credenciais pode gerar automaticamente as credenciais temporárias automaticamente para cada nova conexão. ElastiCache realizará a autenticação do IAM para solicitações de conexão de ElastiCache usuários habilitados para IAM e validará as solicitações de conexão com o IAM.
## Limitações
Ao usar a autenticação do IAM, as seguintes limitações se aplicam:
+ A autenticação do IAM está disponível quando usada ElastiCache para Valkey 7.2 e superior ou Redis OSS versão 7.0 e superior.
+ Para ElastiCache usuários habilitados para IAM, as propriedades de nome de usuário e ID de usuário devem ser idênticas.
+ O token de autenticação do IAM é válido por 15 minutos. Para conexões de longa duração, recomendamos usar um cliente do Valkey ou Redis OSS que suporte uma interface de provedor de credenciais.
+ Uma conexão autenticada pelo IAM ElastiCache para Valkey ou Redis OSS será automaticamente desconectada após 12 horas. A conexão pode ser prolongada por 12 horas enviando um comando `AUTH` ou `HELLO` com um novo token de autenticação do IAM.
+ A autenticação do IAM não tem suporte em comandos `MULTI EXEC`.
+ Atualmente, a autenticação do IAM não dá suporte às seguintes chaves de contexto de condição global:
+ Durante o uso da autenticação do IAM com caches sem servidor, `aws:VpcSourceIp`, `aws:SourceVpc`, `aws:SourceVpce`, `aws:CurrentTime`, `aws:EpochTime` e `aws:ResourceTag/%s` (de caches sem servidor associados e usuários) são compatíveis.
+ Durante o uso da autenticação do IAM com grupos de replicação, `aws:SourceIp` e `aws:ResourceTag/%s` (de grupos de replicação associados e usuários) são compatíveis.
Para obter mais informações sobre chaves de contexto de condição global, consulte [Chaves de contexto de condição global da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) no Guia do usuário do IAM.
## Configuração
Como configurar a autenticação do IAM
1. Criar um cache
```
aws elasticache create-serverless-cache \
--serverless-cache-name cache-01 \
--description "ElastiCache IAM auth application" \
--engine redis
```
1. Crie um documento de política de confiança do IAM, conforme mostrado abaixo, para o perfil que permita que sua conta assuma o novo perfil. Salve a política em um arquivo chamado *trust-policy.json*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::123456789012:root" },
"Action": "sts:AssumeRole"
}
}
```
------
1. Crie um documento de política do IAM, conforme mostrado abaixo. Salve a política em um arquivo chamado *policy.json*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect" : "Allow",
"Action" : [
"elasticache:Connect"
],
"Resource" : [
"arn:aws:elasticache:us-east-1:123456789012:serverlesscache:cache-01",
"arn:aws:elasticache:us-east-1:123456789012:user:iam-user-01"
]
}
]
}
```
------
1. Criar um perfil do IAM.
```
aws iam create-role \
--role-name "elasticache-iam-auth-app" \
--assume-role-policy-document file://trust-policy.json
```
1. Crie a política do IAM.
```
aws iam create-policy \
--policy-name "elasticache-allow-all" \
--policy-document file://policy.json
```
1. Anexe a política do IAM à função.
```
aws iam attach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
```
1. Crie um novo usuário habilitado para o IAM.
```
aws elasticache create-user \
--user-name iam-user-01 \
--user-id iam-user-01 \
--authentication-mode Type=iam \
--engine redis \
--access-string "on ~* +@all"
```
1. Crie um grupo de usuários e anexe o usuário.
```
aws elasticache create-user-group \
--user-group-id iam-user-group-01 \
--engine redis \
--user-ids default iam-user-01
aws elasticache modify-serverless-cache \
--serverless-cache-name cache-01 \
--user-group-id iam-user-group-01
```
## Conexão
**Conectar com token como senha**
Primeiro, é necessário gerar o token de autenticação do IAM de curta duração usando uma [solicitação pré-assinada do AWS SigV4](https://docs.aws.amazon.com//general/latest/gr/sigv4-signed-request-examples.html). Depois disso, você fornecerá o token de autenticação do IAM como senha ao se conectar a um cache do Valkey ou Redis OSS, conforme mostrado no exemplo abaixo.
```
String userId = "insert user id";
String cacheName = "insert cache name";
boolean isServerless = true;
String region = "insert region";
// Create a default AWS Credentials provider.
// This will look for AWS credentials defined in environment variables or system properties.
AWSCredentialsProvider awsCredentialsProvider = new DefaultAWSCredentialsProviderChain();
// Create an IAM authentication token request and signed it using the AWS credentials.
// The pre-signed request URL is used as an IAM authentication token for ElastiCache with Redis OSS.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userId, cacheName, region, isServerless);
String iamAuthToken = iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
// Construct Redis OSS URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(userId, iamAuthToken)
.build();
// Create a new Lettuce Redis OSS client
RedisClient client = RedisClient.create(redisURI);
client.connect();
```
Veja abaixo a definição de `IAMAuthTokenRequest`.
```
public class IAMAuthTokenRequest {
private static final HttpMethodName REQUEST_METHOD = HttpMethodName.GET;
private static final String REQUEST_PROTOCOL = "http://";
private static final String PARAM_ACTION = "Action";
private static final String PARAM_USER = "User";
private static final String PARAM_RESOURCE_TYPE = "ResourceType";
private static final String RESOURCE_TYPE_SERVERLESS_CACHE = "ServerlessCache";
private static final String ACTION_NAME = "connect";
private static final String SERVICE_NAME = "elasticache";
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final String userId;
private final String cacheName;
private final String region;
private final boolean isServerless;
public IAMAuthTokenRequest(String userId, String cacheName, String region, boolean isServerless) {
this.userId = userId;
this.cacheName = cacheName;
this.region = region;
this.isServerless = isServerless;
}
public String toSignedRequestUri(AWSCredentials credentials) throws URISyntaxException {
Request request = getSignableRequest();
sign(request, credentials);
return new URIBuilder(request.getEndpoint())
.addParameters(toNamedValuePair(request.getParameters()))
.build()
.toString()
.replace(REQUEST_PROTOCOL, "");
}
private Request getSignableRequest() {
Request request = new DefaultRequest<>(SERVICE_NAME);
request.setHttpMethod(REQUEST_METHOD);
request.setEndpoint(getRequestUri());
request.addParameters(PARAM_ACTION, Collections.singletonList(ACTION_NAME));
request.addParameters(PARAM_USER, Collections.singletonList(userId));
if (isServerless) {
request.addParameters(PARAM_RESOURCE_TYPE, Collections.singletonList(RESOURCE_TYPE_SERVERLESS_CACHE));
}
return request;
}
private URI getRequestUri() {
return URI.create(String.format("%s%s/", REQUEST_PROTOCOL, cacheName));
}
private void sign(SignableRequest request, AWSCredentials credentials) {
AWS4Signer signer = new AWS4Signer();
signer.setRegionName(region);
signer.setServiceName(SERVICE_NAME);
DateTime dateTime = DateTime.now();
dateTime = dateTime.plus(Duration.standardSeconds(TOKEN_EXPIRY_SECONDS));
signer.presignRequest(request, credentials, dateTime.toDate());
}
private static List toNamedValuePair(Map> in) {
return in.entrySet().stream()
.map(e -> new BasicNameValuePair(e.getKey(), e.getValue().get(0)))
.collect(Collectors.toList());
}
}
```
**Conectar com o provedor de credenciais**
O código abaixo mostra como se autenticar ElastiCache usando o provedor de credenciais de autenticação do IAM.
```
String userId = "insert user id";
String cacheName = "insert cache name";
boolean isServerless = true;
String region = "insert region";
// Create a default AWS Credentials provider.
// This will look for AWS credentials defined in environment variables or system properties.
AWSCredentialsProvider awsCredentialsProvider = new DefaultAWSCredentialsProviderChain();
// Create an IAM authentication token request. Once this request is signed it can be used as an
// IAM authentication token for ElastiCache with Redis OSS.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userId, cacheName, region, isServerless);
// Create a Redis OSS credentials provider using IAM credentials.
RedisCredentialsProvider redisCredentialsProvider = new RedisIAMAuthCredentialsProvider(
userId, iamAuthTokenRequest, awsCredentialsProvider);
// Construct Redis OSS URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(redisCredentialsProvider)
.build();
// Create a new Lettuce Redis OSS client
RedisClient client = RedisClient.create(redisURI);
client.connect();
```
Abaixo está um exemplo de um cliente Lettuce Redis OSS que envolve um provedor de credenciais para gerar IAMAuth TokenRequest automaticamente credenciais temporárias quando necessário.
```
public class RedisIAMAuthCredentialsProvider implements RedisCredentialsProvider {
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final AWSCredentialsProvider awsCredentialsProvider;
private final String userId;
private final IAMAuthTokenRequest iamAuthTokenRequest;
private final Supplier iamAuthTokenSupplier;
public RedisIAMAuthCredentialsProvider(String userId,
IAMAuthTokenRequest iamAuthTokenRequest,
AWSCredentialsProvider awsCredentialsProvider) {
this.userName = userName;
this.awsCredentialsProvider = awsCredentialsProvider;
this.iamAuthTokenRequest = iamAuthTokenRequest;
this.iamAuthTokenSupplier = Suppliers.memoizeWithExpiration(this::getIamAuthToken, TOKEN_EXPIRY_SECONDS, TimeUnit.SECONDS);
}
@Override
public Mono resolveCredentials() {
return Mono.just(RedisCredentials.just(userId, iamAuthTokenSupplier.get()));
}
private String getIamAuthToken() {
return iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
}
}
```