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á.
# Começando com a Amazon ElastiCache
Use o tutorial prático nesta seção para ajudar você a começar e aprender mais sobre como usar. ElastiCache
**Topics**
+ [Conf ElastiCacheiguração](set-up.md)
+ [Criar um cache de tecnologia sem servidor do Valkey](GettingStarted.serverless-valkey.step1.md)
+ [Criar um cache de tecnologia sem servidor Redis OSS](GettingStarted.serverless-redis.step1.md)
+ [Criar um cache de tecnologia sem servidor do Memcached](create-serverless-cache-mem.md)
+ [Tutoriais: conceitos básicos do Python e do ElastiCache](ElastiCache-Getting-Started-Tutorials.md)
+ [Tutorial: Configurando o Lambda para ElastiCache acesso em uma VPC](LambdaRedis.md)
# Conf ElastiCacheiguração
Para usar o serviço ElastiCache web, siga estas etapas.
**Topics**
+ [Inscreva-se para um Conta da AWS](#sign-up-for-aws)
+ [Criar um usuário com acesso administrativo](#create-an-admin)
+ [Conceder acesso programático](#elasticache-set-up-access-key)
+ [Configurar permissões](#elasticache-set-up-permissions)
+ [Configurar EC2](#elasticache-install-configure-ec2)
+ [Conceder acesso de rede](#elasticache-install-grant-access-VPN)
+ [Configurar o acesso à linha de comando](#Download-and-install-cli)
## Inscreva-se para um Conta da AWS
Se você não tiver um Conta da AWS, conclua as etapas a seguir para criar um.
**Para se inscrever em um Conta da AWS**
1. Abra a [https://portal.aws.amazon.com/billing/inscrição.](https://portal.aws.amazon.com/billing/signup)
1. Siga as instruções online.
Parte do procedimento de inscrição envolve receber uma chamada telefônica ou uma mensagem de texto e inserir um código de verificação pelo teclado do telefone.
Quando você se inscreve em um Conta da AWS, um *Usuário raiz da conta da AWS*é criado. O usuário-raiz tem acesso a todos os Serviços da AWS e recursos na conta. Como prática recomendada de segurança, atribua o acesso administrativo a um usuário e use somente o usuário-raiz para executar [tarefas que exigem acesso de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS envia um e-mail de confirmação após a conclusão do processo de inscrição. A qualquer momento, você pode visualizar a atividade atual da sua conta e gerenciar sua conta acessando [https://aws.amazon.com/e](https://aws.amazon.com/) escolhendo **Minha conta**.
## Criar um usuário com acesso administrativo
Depois de se inscrever em um Conta da AWS, proteja seu Usuário raiz da conta da AWSCentro de Identidade do AWS IAM, habilite e crie um usuário administrativo para que você não use o usuário root nas tarefas diárias.
**Proteja seu Usuário raiz da conta da AWS**
1. Faça login [Console de gerenciamento da AWS](https://console.aws.amazon.com/)como proprietário da conta escolhendo **Usuário raiz** e inserindo seu endereço de Conta da AWS e-mail. Na próxima página, insira a senha.
Para obter ajuda ao fazer login usando o usuário-raiz, consulte [Fazer login como usuário-raiz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) no *Guia do usuário do Início de Sessão da AWS*.
1. Habilite a autenticação multifator (MFA) para o usuário-raiz.
Para obter instruções, consulte [Habilitar um dispositivo de MFA virtual para seu usuário Conta da AWS raiz (console) no Guia](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) do *usuário do IAM*.
**Criar um usuário com acesso administrativo**
1. Habilita o Centro de Identidade do IAM.
Para obter instruções, consulte [Habilitar o Centro de Identidade do AWS IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) no *Guia do usuário do Centro de Identidade do AWS IAM*.
1. No Centro de Identidade do IAM, conceda o acesso administrativo a um usuário.
Para ver um tutorial sobre como usar o Diretório do Centro de Identidade do IAM como fonte de identidade, consulte [Configurar o acesso do usuário com o padrão Diretório do Centro de Identidade do IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) no *Guia Centro de Identidade do AWS IAM do usuário*.
**Iniciar sessão como o usuário com acesso administrativo**
+ Para fazer login com o seu usuário do Centro de Identidade do IAM, use o URL de login enviado ao seu endereço de e-mail quando o usuário do Centro de Identidade do IAM foi criado.
Para obter ajuda para fazer login usando um usuário do IAM Identity Center, consulte Como [fazer login no portal de AWS acesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) no *Guia Início de Sessão da AWS do usuário*.
**Atribuir acesso a usuários adicionais**
1. No Centro de Identidade do IAM, crie um conjunto de permissões que siga as práticas recomendadas de aplicação de permissões com privilégio mínimo.
Para obter instruções, consulte [Criar um conjunto de permissões](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) no *Guia do usuário do Centro de Identidade do AWS IAM*.
1. Atribua usuários a um grupo e, em seguida, atribua o acesso de logon único ao grupo.
Para obter instruções, consulte [Adicionar grupos](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) no *Guia do usuário do Centro de Identidade do AWS IAM*.
## Conceder acesso programático
Os usuários precisam de acesso programático se quiserem interagir com pessoas AWS fora do Console de gerenciamento da AWS. A forma de conceder acesso programático depende do tipo de usuário que está acessando AWS.
Para conceder acesso programático aos usuários, selecione uma das seguintes opções:
****
| Qual usuário precisa de acesso programático? | Para | Por |
| --- | --- | --- |
| IAM | (Recomendado) Use as credenciais do console como credenciais temporárias para assinar solicitações programáticas para o AWS CLI,AWS SDKs ou.AWS APIs | Siga as instruções da interface que deseja utilizar. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/set-up.html) |
| Identidade da força de trabalho (Usuários gerenciados no Centro de Identidade do IAM) | Use credenciais temporárias para assinar solicitações programáticas para o AWS CLIAWS SDKs, ou.AWS APIs | Siga as instruções da interface que deseja utilizar. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/set-up.html) |
| IAM | Use credenciais temporárias para assinar solicitações programáticas para o AWS CLIAWS SDKs, ou.AWS APIs | Siga as instruções em [Como usar credenciais temporárias com AWS recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) no Guia do usuário do IAM. |
| IAM | (Não recomendado)Use credenciais de longo prazo para assinar solicitações programáticas para o AWS CLI,AWS SDKs, ou.AWS APIs | Siga as instruções da interface que deseja utilizar. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/set-up.html) |
**Tópicos relacionados:**
+ [O que é o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) no *Guia do usuário do IAM*
+ [AWS Credenciais de segurança](https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html) em *referência AWS geral*.
## Configure suas permissões (somente para novos ElastiCache usuários)
Para conceder acesso, adicione as permissões aos seus usuários, grupos ou perfis:
+ Usuários e grupos em Centro de Identidade do AWS IAM:
Crie um conjunto de permissões. Siga as instruções em [Criação de um conjunto de permissões](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) no *Guia do usuário do Centro de Identidade do AWS IAM*.
+ Usuários gerenciados no IAM com provedor de identidades:
Crie um perfil para a federação de identidades. Siga as instruções em [Criando um perfil para um provedor de identidades de terceiros (federação)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) no *Guia do Usuário do IAM*.
+ Usuários do IAM:
+ Crie um perfil que seu usuário possa assumir. Siga as instruções em [Criação de um perfil para um usuário do IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) no *Guia do usuário do IAM*.
+ (Não recomendado) Vincule uma política diretamente a um usuário ou adicione um usuário a um grupo de usuários. Siga as instruções em [Adição de permissões a um usuário (console)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) no *Guia do usuário do IAM*.
ElastiCache A Amazon cria e usa funções vinculadas a serviços para provisionar recursos e acessar outros AWS recursos e serviços em seu nome. ElastiCache Para criar uma função vinculada ao serviço para você, use a política AWS gerenciada chamada. `AmazonElastiCacheFullAccess` Essa função é pré-provisionada com uma permissão que o serviço requer para criar uma função vinculada a serviço em seu nome.
Talvez você decida usar uma política gerenciada personalizada, em vez de uma política padrão. Nesse caso, confirme se você tem permissão para chamar `iam:createServiceLinkedRole` ou se criou a função vinculada a serviço do ElastiCache.
Para saber mais, consulte:
+ [Criar uma política](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) (IAM)
+ [AWS políticas gerenciadas para a Amazon ElastiCache](IAM.IdentityBasedPolicies.PredefinedPolicies.md)
+ [Uso de funções vinculadas ao serviço para o Amazon ElastiCache](using-service-linked-roles.md)
## Configurar EC2
Você precisará configurar uma EC2 instância a partir da qual se conectará ao seu cache.
+ Se você ainda não tem uma EC2 instância, saiba como configurar uma EC2 instância aqui: [Amazon EC2 Getting Started Guide](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html).
+ Sua EC2 instância deve estar na mesma VPC e ter as mesmas configurações de grupo de segurança do seu cache. Por padrão, a Amazon ElastiCache cria um cache na sua VPC padrão e usa o grupo de segurança padrão. Para seguir este tutorial, certifique-se de que sua EC2 instância esteja na VPC padrão e tenha o grupo de segurança padrão.
## Conceder acesso de rede de um grupo de segurança do Amazon VPC para o cache
ElastiCache clusters baseados em nós usam a porta 6379 para comandos Valkey e Redis OSS, e os sem ElastiCache servidor usam a porta 6379 e a porta 6380. Para se conectar e executar com êxito os comandos Valkey ou Redis OSS da sua EC2 instância, seu grupo de segurança deve permitir o acesso a essas portas conforme necessário.
ElastiCache para Memcached usa as portas 11211 e 11212 para aceitar comandos do Memcached. Para se conectar e executar com êxito os comandos do Memcached a partir da sua EC2 instância, seu grupo de segurança deve permitir o acesso a essas portas.
1. Faça login no AWS Command Line Interface e abra o [ EC2 console da Amazon](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, em **Network & Security**, escolha **Security Groups**.
1. Na lista de grupos de segurança, escolha o de segurança para a sua Amazon VPC. A menos que você tenha criado um grupo de segurança para ElastiCache uso, esse grupo de segurança será denominado *padrão*.
1. Escolha a guia Entrada e, em seguida:
1. Escolha **Editar**.
1. Escolha **Adicionar regra**.
1. Na coluna Tipo, escolha **Regra TCP personalizada**.
1. Se estiver usando Valkey ou Redis OSS, na caixa **Intervalo de portas**, digite `6379`.
Se estiver usando o Memcached, na caixa **Intervalo de portas**, digite `11211`.
1. Na caixa **Fonte**, escolha **Qualquer lugar** que tenha o intervalo de portas (0.0.0.0/0) para que qualquer EC2 instância da Amazon que você iniciar na sua Amazon VPC possa se conectar ao seu cache.
1. Se você estiver usando ElastiCache sem servidor, adicione outra regra escolhendo **Adicionar** regra.
1. Na coluna **Tipo**, escolha **Regra TCP personalizada**.
1. Se estiver usando ElastiCache para Redis OSS, na caixa **Intervalo de portas**, digite. `6380`
Se estiver usando ElastiCache para Memcached, na caixa **Intervalo de portas**, digite. `11212`
1. Na caixa **Fonte**, escolha **Qualquer lugar** que tenha o intervalo de portas (0.0.0.0/0) para que qualquer EC2 instância da Amazon que você iniciar na sua Amazon VPC possa se conectar ao seu cache.
1. Escolha **Salvar**
## Baixar e configurar o acesso à linha de comando
**Baixe e instale o utilitário *valkey-cli*.**
Se você usa ElastiCache o Valkey, talvez ache útil o utilitário valkey-cli. Se você estiver usando o Redis OSS com redis-cli, considere mudar ElastiCache para valkey-cli, pois ele também funciona para o Redis OSS.
1. Conecte-se à sua EC2 instância da Amazon usando o utilitário de conexão de sua escolha. Para obter instruções sobre como se conectar a uma EC2 instância da Amazon, consulte o [Amazon EC2 Getting Started Guide](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html).
1. Baixe e instale o utilitário valkey-cli executando o comando indicado para a configuração.
**Amazon Linux 2**
```
sudo amazon-linux-extras install epel -y
sudo yum install gcc jemalloc-devel openssl-devel tcl tcl-devel -y
wget https://github.com/valkey-io/valkey/archive/refs/tags/8.0.0.tar.gz
tar xvzf valkey-8.0.0.tar.gz
cd valkey-8.0.0
make BUILD_TLS=yes
```
**nota**
Quando você instala o pacote redis6, ele instala o redis6-cli com suporte à criptografia padrão.
É importante ter suporte de compilação para TLS ao instalar valkey-cli ou redis-cli. ElastiCache O Serverless só pode ser acessado quando o TLS está ativado.
Se estiver se conectando a um cluster não criptografado, você não precisará da opção `Build_TLS=yes`.
# Criar um cache de tecnologia sem servidor do Valkey
Nesta etapa, você cria um novo cache no Amazon ElastiCache.
**Console de gerenciamento da AWS**
Para criar um novo cache usando o console do ElastiCache:
1. Faça login no Console de gerenciamento da AWS e abra [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No painel de navegação, no lado esquerdo do console, escolha **Caches do Valkey**.
1. No lado direito do console, escolha **Criar cache do Valkey**.
1. Nas **Configurações de cache**, insira um **Nome**. Também é possível inserir uma **descrição** para o cache.
1. Deixe Visualizar configurações padrão selecionado.
1. Clique em **Criar** para criar o cache.
1. Quando o cache estiver em status “ATIVO”, é possível começar a gravar e ler dados no cache.
**AWS CLI**
O exemplo de AWS CLI a seguir cria um novo cache usando create-serverless-cache.
**Linux**
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine valkey
```
**Windows**
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine valkey
```
O valor do campo Status está definido como `CREATING`.
Para verificar se o ElastiCache terminou a criação do cache, use o comando `describe-serverless-caches`.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Depois de criar o novo cache, avance até [Ler e gravar dados no cache](GettingStarted.serverless-valkey.step2.md).
# Ler e gravar dados no cache
Esta seção pressupõe que você criou uma EC2 instância da Amazon e pode se conectar a ela. Para obter instruções sobre como fazer isso, consulte o [Amazon EC2 Getting Started Guide](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html).
Esta seção também pressupõe que você tenha definido o acesso à VPC e as configurações do grupo de segurança para EC2 a instância a partir da qual você está se conectando ao cache e configurado valkey-cli na sua instância. EC2 Para obter mais informações sobre essa etapa, consulte [Conf ElastiCacheiguração](set-up.md).
Além das etapas abaixo, se você tiver um aplicativo grande ou global, poderá aumentar consideravelmente o desempenho de leitura criando e lendo réplicas. Para obter mais informações sobre essa etapa mais avançada, consulte [Práticas recomendadas para usar réplicas de leitura](ReadReplicas.md).
**Encontre o endpoint do cache**
**Console de gerenciamento da AWS**
Para encontrar o endpoint do seu cache usando o ElastiCache 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 painel de navegação, no lado esquerdo do console, escolha **Caches do Valkey**.
1. No lado direito do console, clique no nome do cache que você acabou de criar.
1. Nos **Detalhes do cache**, localize e copie o endpoint do cache.
**AWS CLI**
O AWS CLI exemplo a seguir mostra como encontrar o endpoint para seu novo cache usando o describe-serverless-caches comando. Depois de executar o comando, procure o campo “Endpoint”.
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Conectar ao cache do Valkey (Linux)
Agora que você tem o endpoint de que precisa, pode fazer login na sua EC2 instância e se conectar ao cache. No exemplo a seguir, você usa o utilitário *valkey-cli* para se conectar a um cluster. O comando a seguir se conecta a um cache (observação: substitua cache-endpoint pelo endpoint que você recuperou na etapa anterior).
```
src/valkey-cli -h cache-endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
## Conectar ao cache do Valkey (Windows)
Agora que você tem o endpoint de que precisa, pode fazer login na sua EC2 instância e se conectar ao cache. No exemplo a seguir, você usa o utilitário *valkey-cli* para se conectar a um cluster. O comando a seguir conecta a um cache. Abra o prompt de comando, mude para o diretório do Valkey ou Redis OSS e execute o comando (observação: substitua Cache\$1Endpoint pelo endpoint que você recuperou na etapa anterior).
```
c:\Valkey>valkey-cli -h Valkey_Cluster_Endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
Agora você já pode avançar para [Limpar (opcional)](GettingStarted.serverless-valkey.step3.md).
# Limpar (opcional)
Se não precisar mais do cache do Amazon ElastiCache criado, você poderá excluí-lo. Esta etapa ajuda a garantir que você não será cobrado pelos recursos que não está utilizando. Você pode usar o console do ElastiCache, a AWS CLI ou a API do ElastiCache para excluir o cache.
**Console de gerenciamento da AWS**
Para excluir o cache usando o console:
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No painel de navegação, no lado esquerdo do console, escolha **Caches do Valkey**.
1. Escolha o botão de opção ao lado do cache que você deseja excluir.
1. Selecione **Ações** no canto superior direito e **Excluir**.
1. Também é possível optar por fazer um snapshot final antes de excluir o cache.
1. Na tela de confirmação **Excluir**, reinsira o nome do cache e escolha **Excluir** para excluir o cluster ou escolha **Cancelar** para mantê-lo.
Assim que o cache avança para o estado de **EXCLUSÃO**, você deixa de receber cobranças por ele.
**AWS CLI**
O exemplo da AWS CLI a seguir exclui um cache usando o comando delete-serverless-cache.
**Linux**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name CacheName
```
O valor do campo **Status** está definido como **EXCLUSÃO**.
Agora você já pode avançar para [Próximas etapas](GettingStarted.serverless-valkey.next-steps.md).
# Próximas etapas
Para obter mais informações sobre o ElastiCache, consulte as seguintes páginas:
+ [Trabalhando com ElastiCache](WorkingWithElastiCache.md)
+ [Dimensionamento ElastiCache](Scaling.md)
+ [Registros e monitoramento no Amazon ElastiCache](MonitoringECMetrics.md)
+ [Práticas recomendadas e estratégias de armazenamento em cache do ElastiCache](BestPractices.md)
+ [Snapshots e restauração](backups.md)
+ [Monitoramento de eventos do ElastiCache pelo Amazon SNS](ECEvents.md)
# Criar um cache de tecnologia sem servidor Redis OSS
Nesta etapa, você cria um novo cache no Amazon ElastiCache.
**Console de gerenciamento da AWS**
Para criar um novo cache usando o console do ElastiCache:
1. Faça login no Console de gerenciamento da AWS e abra o console do ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No painel de navegação, no lado esquerdo do console, escolha **Caches do Redis OSS**.
1. No lado direito do console, escolha **Criar cache do Redis OSS**.
1. Nas **Configurações de cache**, insira um **Nome**. Também é possível inserir uma **descrição** para o cache.
1. Deixe Visualizar configurações padrão selecionado.
1. Clique em **Criar** para criar o cache.
1. Quando o cache estiver em status “ATIVO”, é possível começar a gravar e ler dados no cache.
**AWS CLI**
O exemplo de AWS CLI a seguir cria um novo cache usando create-serverless-cache.
**Linux**
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine redis
```
**Windows**
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine redis
```
O valor do campo Status está definido como `CREATING`.
Para verificar se o ElastiCache terminou a criação do cache, use o comando `describe-serverless-caches`.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Depois de criar o novo cache, avance até [Ler e gravar dados no cache](GettingStarted.serverless-redis.step2.md).
# Ler e gravar dados no cache
Esta seção pressupõe que você criou uma EC2 instância da Amazon e pode se conectar a ela. Para obter instruções sobre como fazer isso, consulte o [Amazon EC2 Getting Started Guide](https://aws.amazon.com/ec2/getting-started/).
Esta seção também pressupõe que você tenha definido o acesso à VPC e as configurações do grupo de segurança para EC2 a instância a partir da qual você está se conectando ao cache e configurado valkey-cli na sua instância. EC2 Para obter mais informações sobre essa etapa, consulte [Conf ElastiCacheiguração](set-up.md).
**Encontre o endpoint do cache**
**Console de gerenciamento da AWS**
Para encontrar o endpoint do seu cache usando o ElastiCache 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 painel de navegação, no lado esquerdo do console, escolha **Caches do Valkey** ou **Caches do Redis OSS**.
1. No lado direito do console, clique no nome do cache que você acabou de criar.
1. Nos **Detalhes do cache**, localize e copie o endpoint do cache.
**AWS CLI**
O AWS CLI exemplo a seguir mostra como encontrar o endpoint para seu novo cache usando o describe-serverless-caches comando. Depois de executar o comando, procure o campo “Endpoint”.
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Conectar ao cache do Valkey ou Redis OSS (Linux)
Agora que você tem o endpoint de que precisa, pode fazer login na sua EC2 instância e se conectar ao cache. No exemplo a seguir, você usa o utilitário *valkey-cli* para se conectar a um cluster. O comando a seguir se conecta a um cache (observação: substitua cache-endpoint pelo endpoint que você recuperou na etapa anterior).
```
src/valkey-cli -h cache-endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
## Conectar ao cache do Valkey ou Redis OSS (Windows)
Agora que você tem o endpoint de que precisa, pode fazer login na sua EC2 instância e se conectar ao cache. No exemplo a seguir, você usa o utilitário *valkey-cli* para se conectar a um cluster. O comando a seguir conecta a um cache. Abra o prompt de comando, mude para o diretório do Valkey e execute o comando (observação: substitua Cache\$1Endpoint pelo endpoint que você recuperou na etapa anterior).
```
c:\Redis>valkey-cli -h Redis_Cluster_Endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
Agora você já pode avançar para [Limpar (opcional)](GettingStarted.serverless-redis.step3.md).
# Limpar (opcional)
Se não precisar mais do cache do Amazon ElastiCache criado, você poderá excluí-lo. Esta etapa ajuda a garantir que você não será cobrado pelos recursos que não está utilizando. Você pode usar o console do ElastiCache, a AWS CLI ou a API do ElastiCache para excluir o cache.
**Console de gerenciamento da AWS**
Para excluir o cache usando o console:
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No painel de navegação, no lado esquerdo do console, escolha **Caches do Valkey ou Redis OSS**.
1. Escolha o botão de opção ao lado do cache que você deseja excluir.
1. Selecione **Ações** no canto superior direito e **Excluir**.
1. Também é possível optar por fazer um snapshot final antes de excluir o cache.
1. Na tela de confirmação **Excluir**, reinsira o nome do cache e escolha **Excluir** para excluir o cluster ou escolha **Cancelar** para mantê-lo.
Assim que o cache avança para o estado de **EXCLUSÃO**, você deixa de receber cobranças por ele.
**AWS CLI**
O exemplo da AWS CLI a seguir exclui um cache usando o comando delete-serverless-cache.
**Linux**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name CacheName
```
O valor do campo **Status** está definido como **EXCLUSÃO**.
Agora você já pode avançar para [Próximas etapas](GettingStarted.serverless-redis.next-steps.md).
# Próximas etapas
Para obter mais informações sobre o ElastiCache, consulte as seguintes páginas:
+ [Trabalhando com ElastiCache](WorkingWithElastiCache.md)
+ [Dimensionamento ElastiCache](Scaling.md)
+ [Registros e monitoramento no Amazon ElastiCache](MonitoringECMetrics.md)
+ [Práticas recomendadas e estratégias de armazenamento em cache do ElastiCache](BestPractices.md)
+ [Snapshots e restauração](backups.md)
+ [Monitoramento de eventos do ElastiCache pelo Amazon SNS](ECEvents.md)
# Criar um cache de tecnologia sem servidor do Memcached
**Console de gerenciamento da AWS**
Para criar um novo cache de tecnologia sem servidor do Memcached usando o console do ElastiCache:
1. Faça login no Console de gerenciamento da AWS e abra o console do ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. No painel de navegação, no lado esquerdo do console, escolha **Caches do Memcached**.
1. No lado direito do console, escolha **Criar Clustert Memcached**.
1. Nas **Configurações de cache**, insira um **Nome**. Também é possível inserir uma **descrição** para o cache.
1. Deixe Visualizar configurações padrão selecionado.
1. Clique em **Criar** para criar o cache.
1. Quando o cache estiver em status “ATIVO”, é possível começar a gravar e ler dados no cache.
Para criar um novo cache usando a AWS CLI
O exemplo de AWS CLI a seguir cria um novo cache usando create-serverless-cache.
**Linux**
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine memcached
```
**Windows**
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine memcached
```
O valor do campo Status está definido como `CREATING`.
Para verificar se o ElastiCache terminou a criação do cache, use o comando `describe-serverless-caches`.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Depois de criar o novo cache, avance até [Ler e gravar dados no cache](read-write-cache-mem.md).
# Ler e gravar dados no cache
Esta seção pressupõe que você criou uma EC2 instância da Amazon e pode se conectar a ela. Para obter instruções sobre como fazer isso, consulte o [Amazon EC2 Getting Started Guide](https://aws.amazon.com/ec2/getting-started/).
Por padrão, ElastiCache cria um cache na sua VPC padrão. Certifique-se de que sua EC2 instância também seja criada na VPC padrão, para que ela possa se conectar ao cache.
**Encontre o endpoint do cache**
**Console de gerenciamento da AWS**
Para encontrar o endpoint do seu cache usando o ElastiCache 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 painel de navegação, no lado esquerdo do console, escolha **Caches do Memcached**.
1. No lado direito do console, clique no nome do cache que você acabou de criar.
1. Nos **Detalhes do cache**, localize e copie o endpoint do cache.
**AWS CLI**
O AWS CLI exemplo a seguir mostra como encontrar o endpoint para seu novo cache usando o describe-serverless-caches comando. Depois de executar o comando, procure o campo “Endpoint”.
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Conectar usando OpenSSL
Para obter informações sobre como se conectar usando o OpenSSL, consulte [ElastiCache criptografia em trânsito (TLS)](in-transit-encryption.md).
## Conectar usando o cliente Java do Memcached
```
import java.security.KeyStore;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import net.spy.memcached.AddrUtil;
import net.spy.memcached.ConnectionFactoryBuilder;
import net.spy.memcached.FailureMode;
import net.spy.memcached.MemcachedClient;
public class TLSDemo {
public static void main(String[] args) throws Exception {
ConnectionFactoryBuilder connectionFactoryBuilder = new ConnectionFactoryBuilder();
// Build SSLContext
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init((KeyStore) null);
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, tmf.getTrustManagers(), null);
// Create the client in TLS mode
connectionFactoryBuilder.setSSLContext(sslContext);
// Set Failure Mode to Retry
connectionFactoryBuilder.setFailureMode(FailureMode.Retry);
MemcachedClient client = new MemcachedClient(connectionFactoryBuilder.build(), AddrUtil.getAddresses("mycluster-fnjyzo.serverless.use1.cache.amazonaws.com:11211"));
// Store a data item for an hour.
client.set("theKey", 3600, "This is the data value");
}
}
```
## Conectar usando o cliente PHP do Memcached
```
addServer($cluster_endpoint, $server_port);
if(!$tls_client->setOption(Memcached::OPT_USE_TLS, 1)) {
echo $tls_client->getLastErrorMessage(), "\n";
exit(1);
}
$tls_config = new MemcachedTLSContextConfig();
$tls_config->hostname = '*.serverless.use1.cache.amazonaws.com';
$tls_config->skip_cert_verify = false;
$tls_config->skip_hostname_verify = false;
$tls_client->createAndSetTLSContext((array)$tls_config);
/* store the data for 60 seconds in the cluster */
$tls_client->set('key', 'value', 60);
?>
```
## Conectar usando o cliente Python do Memcached (Pymemcache)
Consulte [https://pymemcache.readthedocs. io/en/latest/getting](https://pymemcache.readthedocs.io/en/latest/getting_started.html)\$1started.html
```
import ssl
from pymemcache.client.base import Client
context = ssl.create_default_context()
cluster_endpoint =
target_port = 11211
memcached_client = Client(("{cluster_endpoint}", target_port), tls_context=context)
memcached_client.set("key", "value", expire=500, noreply=False)
assert self.memcached_client.get("key").decode() == "value"
```
## Conecte-se usando o NodeJS/TS cliente Memcached (Electrode-IO memcache)
[Consulte [https://github.com/electrode-io/memcache e https://www.npmjs.com/package/ memcache-client](https://github.com/electrode-io/memcache)](https://www.npmjs.com/package/memcache-client)
Instalar por meio de `npm i memcache-client`
Na aplicação, crie um cliente TLS do Memcached assim:
```
var memcache = require("memcache-client");
const client = new memcache.MemcacheClient({server: "{cluster_endpoint}:11211", tls: {}});
client.set("key", "value");
```
## Conectar usando o cliente Rust do Memcached (rust-memcache)
Consulte [https://crates. io/crates/memcache](https://crates.io/crates/memcache)e [https://github.com/aisk/rust-memcache](https://github.com/aisk/rust-memcache).
```
// create connection with to memcached server node:
let client = memcache::connect("memcache+tls://:11211?verify_mode=none").unwrap();
// set a string value
client.set("foo", "bar", 0).unwrap();
```
## Conectar usando o cliente Go do Memcached (Gomemcache)
Veja [https://github.com/bradfitz/gomemcache](https://github.com/bradfitz/gomemcache)
```
c := New(net.JoinHostPort("{cluster_endpoint}", strconv.Itoa(port)))
c.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
var td tls.Dialer
td.Config = &tls.Config{}
return td.DialContext(ctx, network, addr)
}
foo := &Item{Key: "foo", Value: []byte("fooval"), Flags: 123}
err := c.Set(foo)
```
## Conectar usando o cliente Ruby do Memcached (Dalli)
Veja [https://github.com/petergoldstein/dalli](https://github.com/petergoldstein/dalli)
```
require 'dalli'
ssl_context = OpenSSL::SSL::SSLContext.new
ssl_context.ssl_version = :SSLv23
ssl_context.verify_hostname = true
ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
client = Dalli::Client.new(":11211", :ssl_context => ssl_context);
client.get("abc")
```
## Conecte-se usando o cliente Memcached .NET () EnyimMemcachedCore
Consulte [https://github.com/cnblogs/EnyimMemcachedCore](https://github.com/cnblogs/EnyimMemcachedCore)
```
"MemcachedClient": {
"Servers": [
{
"Address": "{cluster_endpoint}",
"Port": 11211
}
],
"UseSslStream": true
}
```
Agora você já pode avançar para [Limpar (opcional)](read-write-cleanup-mem.md).
# Limpar (opcional)
**Usando o Console de gerenciamento da AWS**
O procedimento a seguir exclui um único cache da sua implantação. Para excluir vários caches, repita o procedimento para cada cache que deseja excluir. Você não precisa esperar a finalização da exclusão de um cache antes de iniciar o procedimento para excluir outro.
**Para excluir um cache**
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 painel do ElastiCache console, escolha o mecanismo em execução no cache que você deseja excluir. É exibida uma lista de todos os caches que executam esse mecanismo.
1. Para escolher o cache a ser excluído, escolha o nome do cache na lista de caches.
**Importante**
Você só pode excluir um cache por vez do ElastiCache console. Escolher vários caches desabilita a operação de exclusão.
1. Em **Ações**, escolha **Excluir**.
1. Na tela de confirmação **Excluir cache**, escolha **Excluir** para excluir o cache ou **Cancelar** para mantê-lo.
1. Se você escolheu **Excluir**, o status do cache muda para *excluindo*.
Assim que o cache avança para o estado de **EXCLUSÃO**, você deixa de receber cobranças por ele.
**Usando o AWS CLI**
O código a seguir exclui o cache my-cache.
```
aws elasticache delete-serverless-cache --serverless-cache-name my-cache
```
A ação da delete-serverless-cache CLI exclui somente um cache sem servidor. Para excluir vários caches, chame delete-serverless-cache cada cache sem servidor que você deseja excluir. Você não precisa esperar a finalização da exclusão de um cache sem servidor antes de excluir outro.
**Para Linux, macOS ou Unix**:
```
aws elasticache delete-serverless-cache \
--serverless-cache-name my-cache
```
**Para Windows:**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name my-cache
```
Para obter mais informações, consulte o ElastiCache tópico AWS CLI for delete-serverless-cache.
Agora você já pode avançar para [Próximas etapas](next-steps-mem.md).
# Próximas etapas
Para obter mais informações sobre o ElastiCache, consulte:
+ [Trabalhando com ElastiCache](WorkingWithElastiCache.md)
+ [Dimensionamento ElastiCache](Scaling.md)
+ [Cotas do ElastiCache](quota-limits.md)
+ [Práticas recomendadas e estratégias de armazenamento em cache do ElastiCache](BestPractices.md)
+ [Visualizando ElastiCache eventos](ECEvents.Viewing.md)
# Tutoriais: conceitos básicos do Python e do ElastiCache
Esta seção contém tutoriais práticos para ajudar você a aprender sobre o ElastiCache para Valkey e Redis OSS. Encorajamos você a trabalhar em um dos tutoriais de linguagem específica.
**nota**
AWSOs SDKs da estão disponíveis para uma ampla variedade de linguagens. Para obter uma lista completa, consulte [Ferramentas para a Amazon Web Services](https://aws.amazon.com/tools/).
**Topics**
+ [Python e ElastiCache](ElastiCache-Getting-Started-Tutorials-Python.md)
# Python e ElastiCache
Neste tutorial, você usa o AWS SDK para Python (Boto3) para escrever programas simples e realizar as seguintes operações: ElastiCache
+ Crie ElastiCache para clusters Redis OSS (modo de cluster ativado e modo de cluster desativado)
+ Verifique se existem usuários ou grupos de usuários, caso contrário, crie-os. (Esse atributo está disponível com o Valkey 7.2 e versões posteriores e com o Redis OSS 6.0 a 7.1.)
+ Conecte-se a ElastiCache
+ Execute operações como definir e obter strings, ler e gravar em streams e publicar e se inscrever no canal. Pub/Sub
Ao trabalhar neste tutorial, você pode consultar a documentação do AWS SDK para Python (Boto). A seção a seguir é específica para ElastiCache: cliente [ElastiCache de baixo nível](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/elasticache.html)
## Pré-requisitos do tutorial
+ Configure uma chave de AWS acesso para usar AWS SDKs o. Para obter mais informações, consulte [Conf ElastiCacheiguração](set-up.md).
+ Instalar o Python 3.0 ou versões posteriores. Para obter mais informações, consulte [https://www.python.org/downloads](https://www.python.org/downloads). Para obter instruções, consulte [Início rápido](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) na documentação do Boto 3.
**Topics**
+ [Pré-requisitos do tutorial](#ElastiCache-Getting-Started-Tutorials-Prerquisites)
+ [Tutorial: Criação de ElastiCache clusters e usuários](#ElastiCache-Getting-Started-Tutorials-Create-Cluster-and-Users)
+ [Tutorial: Conectando-se a ElastiCache](#ElastiCache-Getting-Started-Tutorials-Connecting)
+ [Exemplos de uso](#ElastiCache-Getting-Started-Tutorials-Usage)
## Tutorial: Criação de ElastiCache clusters e usuários
Os exemplos a seguir usam o SDK boto3 ElastiCache para operações de gerenciamento do Redis OSS (criação de cluster ou usuário) e redis-py/ para tratamento de dados. redis-py-cluster
**Topics**
+ [Criar um cluster com modo cluster desabilitado](#ElastiCache-Getting-Started-Tutorials-Create-Cluster)
+ [Criar um cluster com modo cluster desabilitado com TLS e RBAC](#ElastiCache-Getting-Started-Tutorials-RBAC)
+ [Criar um cluster com modo cluster habilitado](#ElastiCache-Getting-Started-Tutorials-Cluster-Enabled)
+ [Criar um cluster com modo cluster habilitado com TLS e RBAC](#ElastiCache-Getting-Started-Tutorials-Cluster-RBAC)
+ [Verifique se users/usergroup existe, caso contrário, crie-os](#ElastiCache-Getting-Started-Tutorials-Users)
### Criar um cluster com modo cluster desabilitado
Copie o programa a seguir e cole-o em um arquivo chamado *CreateClusterModeDisabledCluster.py.*
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_disabled(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumCacheClusters=2,ReplicationGroupDescription='Sample cluster',ReplicationGroupId=None):
"""Creates an ElastiCache Cluster with cluster mode disabled
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumCacheClusters: Number of nodes in the cluster. Minimum 1 (just a primary node) and maximun 6 (1 primary and 5 replicas).
If not specified, cluster will be created with 1 primary and 1 replica.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Name for the cluster
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return 'ReplicationGroupId parameter is required'
response = client.create_replication_group(
AutomaticFailoverEnabled=True,
CacheNodeType=CacheNodeType,
Engine='valkey',
EngineVersion=EngineVersion,
NumCacheClusters=NumCacheClusters,
ReplicationGroupDescription=ReplicationGroupDescription,
ReplicationGroupId=ReplicationGroupId,
SnapshotRetentionLimit=30,
)
return response
if __name__ == '__main__':
# Creates an ElastiCache Cluster mode disabled cluster, based on cache.m6g.large nodes, Valkey 8.0, one primary and two replicas
elasticacheResponse = create_cluster_mode_disabled(
#CacheNodeType='cache.m6g.large',
EngineVersion='8.0',
NumCacheClusters=3,
ReplicationGroupDescription='Valkey cluster mode disabled with replicas',
ReplicationGroupId='valkey202104053'
)
logging.info(elasticacheResponse)
```
Para executar o programa, digite o comando a seguir:
`python CreateClusterModeDisabledCluster.py`
Para obter mais informações, consulte [Gerenciamento de clusters no ElastiCache](Clusters.md).
### Criar um cluster com modo cluster desabilitado com TLS e RBAC
Para garantir a segurança, você pode usar Transport Layer Security (TLS) e o Controle de acesso baseado em função (RBAC) ao criar um cluster no modo cluster desabilitado. Ao contrário do AUTH do Valkey ou do Redis OSS, onde todos os clientes autenticados têm acesso total ao grupo de replicação se o token for autenticado, o RBAC permite controlar o acesso ao cluster por meio de grupos de usuários. Esses grupos de usuários são projetados como uma maneira de organizar o acesso a grupos de replicação. Para obter mais informações, consulte [Regras de controle de acesso com base em função (RBAC)](Clusters.RBAC.md).
Copie o programa a seguir e cole-o em um arquivo chamado *ClusterModeDisabledWithRBAC.py*.
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_disabled_rbac(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumCacheClusters=2,ReplicationGroupDescription='Sample cluster',ReplicationGroupId=None, UserGroupIds=None, SecurityGroupIds=None,CacheSubnetGroupName=None):
"""Creates an ElastiCache Cluster with cluster mode disabled and RBAC
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumCacheClusters: Number of nodes in the cluster. Minimum 1 (just a primary node) and maximun 6 (1 primary and 5 replicas).
If not specified, cluster will be created with 1 primary and 1 replica.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Mandatory name for the cluster.
:param UserGroupIds: The ID of the user group to be assigned to the cluster.
:param SecurityGroupIds: List of security groups to be assigned. If not defined, default will be used
:param CacheSubnetGroupName: subnet group where the cluster will be placed. If not defined, default will be used.
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return {'Error': 'ReplicationGroupId parameter is required'}
elif not isinstance(UserGroupIds,(list)):
return {'Error': 'UserGroupIds parameter is required and must be a list'}
params={'AutomaticFailoverEnabled': True,
'CacheNodeType': CacheNodeType,
'Engine': 'valkey',
'EngineVersion': EngineVersion,
'NumCacheClusters': NumCacheClusters,
'ReplicationGroupDescription': ReplicationGroupDescription,
'ReplicationGroupId': ReplicationGroupId,
'SnapshotRetentionLimit': 30,
'TransitEncryptionEnabled': True,
'UserGroupIds':UserGroupIds
}
# defaults will be used if CacheSubnetGroupName or SecurityGroups are not explicit.
if isinstance(SecurityGroupIds,(list)):
params.update({'SecurityGroupIds':SecurityGroupIds})
if CacheSubnetGroupName:
params.update({'CacheSubnetGroupName':CacheSubnetGroupName})
response = client.create_replication_group(**params)
return response
if __name__ == '__main__':
# Creates an ElastiCache Cluster mode disabled cluster, based on cache.m6g.large nodes, Valkey 8.0, one primary and two replicas.
# Assigns the existent user group "mygroup" for RBAC authentication
response=create_cluster_mode_disabled_rbac(
CacheNodeType='cache.m6g.large',
EngineVersion='8.0',
NumCacheClusters=3,
ReplicationGroupDescription='Valkey cluster mode disabled with replicas',
ReplicationGroupId='valkey202104',
UserGroupIds=[
'mygroup'
],
SecurityGroupIds=[
'sg-7cc73803'
],
CacheSubnetGroupName='default'
)
logging.info(response)
```
Para executar o programa, digite o comando a seguir:
`python ClusterModeDisabledWithRBAC.py`
Para obter mais informações, consulte [Gerenciamento de clusters no ElastiCache](Clusters.md).
### Criar um cluster com modo cluster habilitado
Copie o programa a seguir e cole-o em um arquivo chamado *ClusterModeEnabled.py.*
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_enabled(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumNodeGroups=1,ReplicasPerNodeGroup=1, ReplicationGroupDescription='Sample cache with cluster mode enabled',ReplicationGroupId=None):
"""Creates an ElastiCache Cluster with cluster mode enabled
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumNodeGroups: Number of shards in the cluster. Minimum 1 and maximun 90.
If not specified, cluster will be created with 1 shard.
:param ReplicasPerNodeGroup: Number of replicas per shard. If not specified 1 replica per shard will be created.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Name for the cluster
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return 'ReplicationGroupId parameter is required'
response = client.create_replication_group(
AutomaticFailoverEnabled=True,
CacheNodeType=CacheNodeType,
Engine='valkey',
EngineVersion=EngineVersion,
ReplicationGroupDescription=ReplicationGroupDescription,
ReplicationGroupId=ReplicationGroupId,
# Creates a cluster mode enabled cluster with 1 shard(NumNodeGroups), 1 primary node (implicit) and 2 replicas (replicasPerNodeGroup)
NumNodeGroups=NumNodeGroups,
ReplicasPerNodeGroup=ReplicasPerNodeGroup,
CacheParameterGroupName='default.valkey7.2.cluster.on'
)
return response
# Creates a cluster mode enabled
response = create_cluster_mode_enabled(
CacheNodeType='cache.m6g.large',
EngineVersion='6.0',
ReplicationGroupDescription='Valkey cluster mode enabled with replicas',
ReplicationGroupId='valkey20210',
# Creates a cluster mode enabled cluster with 1 shard(NumNodeGroups), 1 primary (implicit) and 2 replicas (replicasPerNodeGroup)
NumNodeGroups=2,
ReplicasPerNodeGroup=1,
)
logging.info(response)
```
Para executar o programa, digite o comando a seguir:
`python ClusterModeEnabled.py`
Para obter mais informações, consulte [Gerenciamento de clusters no ElastiCache](Clusters.md).
### Criar um cluster com modo cluster habilitado com TLS e RBAC
Para garantir a segurança, você pode usar Transport Layer Security (TLS) e o Controle de acesso baseado em função (RBAC) ao criar um cluster no modo cluster habilitado. Ao contrário do AUTH do Valkey ou do Redis OSS, onde todos os clientes autenticados têm acesso total ao grupo de replicação se o token for autenticado, o RBAC permite controlar o acesso ao cluster por meio de grupos de usuários. Esses grupos de usuários são projetados como uma maneira de organizar o acesso a grupos de replicação. Para obter mais informações, consulte [Regras de controle de acesso com base em função (RBAC)](Clusters.RBAC.md).
Copie o programa a seguir e cole-o em um arquivo chamado *ClusterModeEnabledWithRBAC.py*.
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_enabled(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumNodeGroups=1,ReplicasPerNodeGroup=1, ReplicationGroupDescription='Sample cache with cluster mode enabled',ReplicationGroupId=None,UserGroupIds=None, SecurityGroupIds=None,CacheSubnetGroupName=None,CacheParameterGroupName='default.valkey7.2.cluster.on'):
"""Creates an ElastiCache Cluster with cluster mode enabled and RBAC
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumNodeGroups: Number of shards in the cluster. Minimum 1 and maximun 90.
If not specified, cluster will be created with 1 shard.
:param ReplicasPerNodeGroup: Number of replicas per shard. If not specified 1 replica per shard will be created.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Name for the cluster.
:param CacheParameterGroupName: Parameter group to be used. Must be compatible with the engine version and cluster mode enabled.
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return 'ReplicationGroupId parameter is required'
elif not isinstance(UserGroupIds,(list)):
return {'Error': 'UserGroupIds parameter is required and must be a list'}
params={'AutomaticFailoverEnabled': True,
'CacheNodeType': CacheNodeType,
'Engine': 'valkey',
'EngineVersion': EngineVersion,
'ReplicationGroupDescription': ReplicationGroupDescription,
'ReplicationGroupId': ReplicationGroupId,
'SnapshotRetentionLimit': 30,
'TransitEncryptionEnabled': True,
'UserGroupIds':UserGroupIds,
'NumNodeGroups': NumNodeGroups,
'ReplicasPerNodeGroup': ReplicasPerNodeGroup,
'CacheParameterGroupName': CacheParameterGroupName
}
# defaults will be used if CacheSubnetGroupName or SecurityGroups are not explicit.
if isinstance(SecurityGroupIds,(list)):
params.update({'SecurityGroupIds':SecurityGroupIds})
if CacheSubnetGroupName:
params.update({'CacheSubnetGroupName':CacheSubnetGroupName})
response = client.create_replication_group(**params)
return response
if __name__ == '__main__':
# Creates a cluster mode enabled cluster
response = create_cluster_mode_enabled(
CacheNodeType='cache.m6g.large',
EngineVersion='7.2',
ReplicationGroupDescription='Valkey cluster mode enabled with replicas',
ReplicationGroupId='valkey2021',
# Creates a cluster mode enabled cluster with 1 shard(NumNodeGroups), 1 primary (implicit) and 2 replicas (replicasPerNodeGroup)
NumNodeGroups=2,
ReplicasPerNodeGroup=1,
UserGroupIds=[
'mygroup'
],
SecurityGroupIds=[
'sg-7cc73803'
],
CacheSubnetGroupName='default'
)
logging.info(response)
```
Para executar o programa, digite o comando a seguir:
`python ClusterModeEnabledWithRBAC.py`
Para obter mais informações, consulte [Gerenciamento de clusters no ElastiCache](Clusters.md).
### Verifique se users/usergroup existe, caso contrário, crie-os
Com o RBAC, você cria usuários e atribui a eles permissões específicas usando uma string de acesso. Você atribui os usuários a grupos de usuários alinhados com uma função específica (administradores, recursos humanos) que são então implantados em um ou mais grupos de replicação do Redis ElastiCache OSS. Ao fazer isso, você pode estabelecer limites de segurança entre clientes usando o mesmo grupo ou grupos de replicação do Valkey ou Redis OSS e impedir que os clientes acessem os dados uns dos outros. Para obter mais informações, consulte [Regras de controle de acesso com base em função (RBAC)](Clusters.RBAC.md).
Copie o programa a seguir e cole-o em um arquivo chamado *UserAndUserGroups.py.* Atualize o mecanismo para fornecer credenciais. As credenciais neste exemplo são mostradas como substituíveis e atribuídas a um item não declarado. Evite credenciais de codificação rígida.
Este exemplo usa uma string de acesso com as permissões do usuário. Para obter mais informações sobre strings de acesso, consulte [Especificação de permissões usando uma string de acesso](Clusters.RBAC.md#Access-string).
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def check_user_exists(UserId):
"""Checks if UserId exists
Returns True if UserId exists, otherwise False
:param UserId: ElastiCache User ID
:return: True|False
"""
try:
response = client.describe_users(
UserId=UserId,
)
if response['Users'][0]['UserId'].lower() == UserId.lower():
return True
except Exception as e:
if e.response['Error']['Code'] == 'UserNotFound':
logging.info(e.response['Error'])
return False
else:
raise
def check_group_exists(UserGroupId):
"""Checks if UserGroupID exists
Returns True if Group ID exists, otherwise False
:param UserGroupId: ElastiCache User ID
:return: True|False
"""
try:
response = client.describe_user_groups(
UserGroupId=UserGroupId
)
if response['UserGroups'][0]['UserGroupId'].lower() == UserGroupId.lower():
return True
except Exception as e:
if e.response['Error']['Code'] == 'UserGroupNotFound':
logging.info(e.response['Error'])
return False
else:
raise
def create_user(UserId=None,UserName=None,Password=None,AccessString=None):
"""Creates a new user
Returns the ARN for the newly created user or the error message
:param UserId: ElastiCache user ID. User IDs must be unique
:param UserName: ElastiCache user name. ElastiCache allows multiple users with the same name as long as the associated user ID is unique.
:param Password: Password for user. Must have at least 16 chars.
:param AccessString: Access string with the permissions for the user.
:return: user ARN
"""
try:
response = client.create_user(
UserId=UserId,
UserName=UserName,
Engine='Redis',
Passwords=[Password],
AccessString=AccessString,
NoPasswordRequired=False
)
return response['ARN']
except Exception as e:
logging.info(e.response['Error'])
return e.response['Error']
def create_group(UserGroupId=None, UserIds=None):
"""Creates a new group.
A default user is required (mandatory) and should be specified in the UserIds list
Return: Group ARN
:param UserIds: List with user IDs to be associated with the new group. A default user is required
:param UserGroupId: The ID (name) for the group
:return: Group ARN
"""
try:
response = client.create_user_group(
UserGroupId=UserGroupId,
Engine='Redis',
UserIds=UserIds
)
return response['ARN']
except Exception as e:
logging.info(e.response['Error'])
if __name__ == '__main__':
groupName='mygroup2'
userName = 'myuser2'
userId=groupName+'-'+userName
# Creates a new user if the user ID does not exist.
for tmpUserId,tmpUserName in [ (userId,userName), (groupName+'-default','default')]:
if not check_user_exists(tmpUserId):
response=create_user(UserId=tmpUserId, UserName=EXAMPLE,Password=EXAMPLE,AccessString='on ~* +@all')
logging.info(response)
# assigns the new user ID to the user group
if not check_group_exists(groupName):
UserIds = [ userId , groupName+'-default']
response=create_group(UserGroupId=groupName,UserIds=UserIds)
logging.info(response)
```
Para executar o programa, digite o comando a seguir:
`python UserAndUserGroups.py`
## Tutorial: Conectando-se a ElastiCache
Os exemplos a seguir usam o cliente Valkey ou Redis OSS para se conectar a. ElastiCache
**Topics**
+ [Conexão a um cluster com modo cluster desabilitado](#ElastiCache-Getting-Started-Tutorials-Connecting-cluster-mode-disabled)
+ [Conexão a um cluster com modo cluster habilitado](#ElastiCache-Getting-Started-Tutorials-Connecting-cluster-mode-enabled)
### Conexão a um cluster com modo cluster desabilitado
Copie o programa a seguir e cole-o em um arquivo chamado *ConnectClusterModeDisabled.py.* Atualize o mecanismo para fornecer credenciais. As credenciais neste exemplo são mostradas como substituíveis e atribuídas a um item não declarado. Evite credenciais de codificação rígida.
```
from redis import Redis
import logging
logging.basicConfig(level=logging.INFO)
redis = Redis(host='primary.xxx.yyyyyy.zzz1.cache.amazonaws.com', port=6379, decode_responses=True, ssl=True, username=example, password=EXAMPLE)
if redis.ping():
logging.info("Connected to Redis")
```
Para executar o programa, digite o comando a seguir:
`python ConnectClusterModeDisabled.py`
### Conexão a um cluster com modo cluster habilitado
Copie o programa a seguir e cole-o em um arquivo chamado *ConnectClusterModeEnabled.py.*
```
from rediscluster import RedisCluster
import logging
logging.basicConfig(level=logging.INFO)
redis = RedisCluster(startup_nodes=[{"host": "xxx.yyy.clustercfg.zzz1.cache.amazonaws.com","port": "6379"}], decode_responses=True,skip_full_coverage_check=True)
if redis.ping():
logging.info("Connected to Redis")
```
Para executar o programa, digite o comando a seguir:
`python ConnectClusterModeEnabled.py`
## Exemplos de uso
Os exemplos a seguir usam o SDK boto3 ElastiCache para trabalhar com ElastiCache o Redis OSS.
**Topics**
+ [Definir e obter strings](#ElastiCache-Getting-Started-Tutorials-set-strings)
+ [Definir e obter um hash com vários itens](#ElastiCache-Getting-Started-Tutorials-set-hash)
+ [Publique (escreva) e assine (leia) em um Pub/Sub canal](#ElastiCache-Getting-Started-Tutorials-pub-sub)
+ [Gravar e ler de uma stream](#ElastiCache-Getting-Started-Tutorials-read-write-stream)
### Definir e obter strings
Copie o programa a seguir e cole-o em um arquivo chamado *SetAndGetStrings.py.*
```
import time
import logging
logging.basicConfig(level=logging.INFO,format='%(asctime)s: %(message)s')
keyName='mykey'
currTime=time.ctime(time.time())
# Set the key 'mykey' with the current date and time as value.
# The Key will expire and removed from cache in 60 seconds.
redis.set(keyName, currTime, ex=60)
# Sleep just for better illustration of TTL (expiration) value
time.sleep(5)
# Retrieve the key value and current TTL
keyValue=redis.get(keyName)
keyTTL=redis.ttl(keyName)
logging.info("Key {} was set at {} and has {} seconds until expired".format(keyName, keyValue, keyTTL))
```
Para executar o programa, digite o comando a seguir:
`python SetAndGetStrings.py`
### Definir e obter um hash com vários itens
Copie o programa a seguir e cole-o em um arquivo chamado *SetAndGetHash.py.*
```
import logging
import time
logging.basicConfig(level=logging.INFO,format='%(asctime)s: %(message)s')
keyName='mykey'
keyValues={'datetime': time.ctime(time.time()), 'epochtime': time.time()}
# Set the hash 'mykey' with the current date and time in human readable format (datetime field) and epoch number (epochtime field).
redis.hset(keyName, mapping=keyValues)
# Set the key to expire and removed from cache in 60 seconds.
redis.expire(keyName, 60)
# Sleep just for better illustration of TTL (expiration) value
time.sleep(5)
# Retrieves all the fields and current TTL
keyValues=redis.hgetall(keyName)
keyTTL=redis.ttl(keyName)
logging.info("Key {} was set at {} and has {} seconds until expired".format(keyName, keyValues, keyTTL))
```
Para executar o programa, digite o comando a seguir:
`python SetAndGetHash.py`
### Publique (escreva) e assine (leia) em um Pub/Sub canal
Copie o programa a seguir e cole-o em um arquivo chamado *PubAndSub.py.*
```
import logging
import time
def handlerFunction(message):
"""Prints message got from PubSub channel to the log output
Return None
:param message: message to log
"""
logging.info(message)
logging.basicConfig(level=logging.INFO)
redis = Redis(host="redis202104053.tihewd.ng.0001.use1.cache.amazonaws.com", port=6379, decode_responses=True)
# Creates the subscriber connection on "mychannel"
subscriber = redis.pubsub()
subscriber.subscribe(**{'mychannel': handlerFunction})
# Creates a new thread to watch for messages while the main process continues with its routines
thread = subscriber.run_in_thread(sleep_time=0.01)
# Creates publisher connection on "mychannel"
redis.publish('mychannel', 'My message')
# Publishes several messages. Subscriber thread will read and print on log.
while True:
redis.publish('mychannel',time.ctime(time.time()))
time.sleep(1)
```
Para executar o programa, digite o comando a seguir:
`python PubAndSub.py`
### Gravar e ler de uma stream
Copie o programa a seguir e cole-o em um arquivo chamado *ReadWriteStream.py.*
```
from redis import Redis
import redis.exceptions as exceptions
import logging
import time
import threading
logging.basicConfig(level=logging.INFO)
def writeMessage(streamName):
"""Starts a loop writting the current time and thread name to 'streamName'
:param streamName: Stream (key) name to write messages.
"""
fieldsDict={'writerId':threading.currentThread().getName(),'myvalue':None}
while True:
fieldsDict['myvalue'] = time.ctime(time.time())
redis.xadd(streamName,fieldsDict)
time.sleep(1)
def readMessage(groupName=None,streamName=None):
"""Starts a loop reading from 'streamName'
Multiple threads will read from the same stream consumer group. Consumer group is used to coordinate data distribution.
Once a thread acknowleges the message, it won't be provided again. If message wasn't acknowledged, it can be served to another thread.
:param groupName: stream group were multiple threads will read.
:param streamName: Stream (key) name where messages will be read.
"""
readerID=threading.currentThread().getName()
while True:
try:
# Check if the stream has any message
if redis.xlen(streamName)>0:
# Check if if the messages are new (not acknowledged) or not (already processed)
streamData=redis.xreadgroup(groupName,readerID,{streamName:'>'},count=1)
if len(streamData) > 0:
msgId,message = streamData[0][1][0]
logging.info("{}: Got {} from ID {}".format(readerID,message,msgId))
#Do some processing here. If the message has been processed sucessfuly, acknowledge it and (optional) delete the message.
redis.xack(streamName,groupName,msgId)
logging.info("Stream message ID {} read and processed successfuly by {}".format(msgId,readerID))
redis.xdel(streamName,msgId)
else:
pass
except:
raise
time.sleep(0.5)
# Creates the stream 'mystream' and consumer group 'myworkergroup' where multiple threads will write/read.
try:
redis.xgroup_create('mystream','myworkergroup',mkstream=True)
except exceptions.ResponseError as e:
logging.info("Consumer group already exists. Will continue despite the error: {}".format(e))
except:
raise
# Starts 5 writer threads.
for writer_no in range(5):
writerThread = threading.Thread(target=writeMessage, name='writer-'+str(writer_no), args=('mystream',),daemon=True)
writerThread.start()
# Starts 10 reader threads
for reader_no in range(10):
readerThread = threading.Thread(target=readMessage, name='reader-'+str(reader_no), args=('myworkergroup','mystream',),daemon=True)
readerThread.daemon = True
readerThread.start()
# Keep the code running for 30 seconds
time.sleep(30)
```
Para executar o programa, digite o comando a seguir:
`python ReadWriteStream.py`
# Tutorial: Configurando o Lambda para ElastiCache acesso em uma VPC
Neste tutorial, você pode aprender como criar um cache ElastiCache sem servidor, criar uma função Lambda, testar a função Lambda e, opcionalmente, limpá-la depois.
**Topics**
+ [Etapa 1: Criar um cache ElastiCache sem servidor.](#LambdaRedis.step1)
+ [Etapa 2: criar uma função Lambda para ElastiCache](#LambdaRedis.step2)
+ [Etapa 3: Teste a função Lambda com ElastiCache](#LambdaRedis.step3)
+ [Etapa 4: limpar (opcional)](#LambdaRedis.step4)
## Etapa 1: Criar um cache ElastiCache sem servidor.
Para criar um cache de tecnologia sem servidor, siga estas etapas.
### Etapa 1.1: criar um cache de tecnologia sem servidor
Nesta etapa, você cria um cache sem servidor na Amazon VPC padrão na região us-east-1 em sua conta usando a (CLI).AWS Command Line Interface Para obter informações sobre como criar cache sem servidor usando o ElastiCache console ou a API, consulte. [Criar um cache de tecnologia sem servidor Redis OSS](GettingStarted.serverless-redis.step1.md)
```
aws elasticache create-serverless-cache \
--serverless-cache-name cache-01 \
--description "ElastiCache IAM auth application" \
--engine valkey
```
O valor do campo Status está definido como `CREATING`. Pode levar um minuto para concluir ElastiCache a criação do cache.
### Etapa 1.2: copiar o endpoint do cache de tecnologia sem servidor
Verifique se, ElastiCache para Redis, o OSS terminou de criar o cache com o `describe-serverless-caches` comando.
```
aws elasticache describe-serverless-caches \
--serverless-cache-name cache-01
```
Copie o endereço do endpoint mostrado na saída. Você precisará desse endereço ao criar o pacote de implantação da função do Lambda.
### Etapa 1.3: criar o perfil do IAM
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",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::*:role/*"
},
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::*:role/*"
}]
}
```
------
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"
```
### Etapa 1.4: criar um usuário padrão
1. Crie um novo usuário padrão.
```
aws elasticache create-user \
--user-name default \
--user-id default-user-disabled \
--engine redis \
--authentication-mode Type=no-password-required \
--access-string "off +get ~keys*"
```
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-user-disabled iam-user-01
aws elasticache modify-serverless-cache \
--serverless-cache-name cache-01 \
--user-group-id iam-user-group-01
```
## Etapa 2: criar uma função Lambda para ElastiCache
Para criar uma função Lambda para acessar o ElastiCache cache, siga estas etapas.
### Etapa 2.1: criar uma função do Lambda
Neste tutorial, fornecemos um exemplo de código em Python para sua função do Lambda.
**Python**
O exemplo a seguir, o código Python lê e grava um item no seu ElastiCache cache. Copie o código e o salve em um arquivo chamado `app.py`. Não se esqueça de substituir o valor `elasticache_endpoint` no código pelo endereço do endpoint que você copiou na etapa anterior.
```
from typing import Tuple, Union
from urllib.parse import ParseResult, urlencode, urlunparse
import botocore.session
import redis
from botocore.model import ServiceId
from botocore.signers import RequestSigner
from cachetools import TTLCache, cached
import uuid
class ElastiCacheIAMProvider(redis.CredentialProvider):
def __init__(self, user, cache_name, is_serverless=False, region="us-east-1"):
self.user = user
self.cache_name = cache_name
self.is_serverless = is_serverless
self.region = region
session = botocore.session.get_session()
self.request_signer = RequestSigner(
ServiceId("elasticache"),
self.region,
"elasticache",
"v4",
session.get_credentials(),
session.get_component("event_emitter"),
)
# Generated IAM tokens are valid for 15 minutes
@cached(cache=TTLCache(maxsize=128, ttl=900))
def get_credentials(self) -> Union[Tuple[str], Tuple[str, str]]:
query_params = {"Action": "connect", "User": self.user}
if self.is_serverless:
query_params["ResourceType"] = "ServerlessCache"
url = urlunparse(
ParseResult(
scheme="https",
netloc=self.cache_name,
path="/",
query=urlencode(query_params),
params="",
fragment="",
)
)
signed_url = self.request_signer.generate_presigned_url(
{"method": "GET", "url": url, "body": {}, "headers": {}, "context": {}},
operation_name="connect",
expires_in=900,
region_name=self.region,
)
# RequestSigner only seems to work if the URL has a protocol, but
# Elasticache only accepts the URL without a protocol
# So strip it off the signed URL before returning
return (self.user, signed_url.removeprefix("https://"))
def lambda_handler(event, context):
username = "iam-user-01" # replace with your user id
cache_name = "cache-01" # replace with your cache name
elasticache_endpoint = "cache-01-xxxxx.serverless.use1.cache.amazonaws.com" # replace with your cache endpoint
creds_provider = ElastiCacheIAMProvider(user=username, cache_name=cache_name, is_serverless=True)
redis_client = redis.Redis(host=elasticache_endpoint, port=6379, credential_provider=creds_provider, ssl=True, ssl_cert_reqs="none")
key='uuid'
# create a random UUID - this will be the sample element we add to the cache
uuid_in = uuid.uuid4().hex
redis_client.set(key, uuid_in)
result = redis_client.get(key)
decoded_result = result.decode("utf-8")
# check the retrieved item matches the item added to the cache and print
# the results
if decoded_result == uuid_in:
print(f"Success: Inserted {uuid_in}. Fetched {decoded_result} from Valkey.")
else:
raise Exception(f"Bad value retrieved. Expected {uuid_in}, got {decoded_result}")
return "Fetched value from Valkey"
```
Esse código usa a biblioteca redis-py do Python para colocar itens no cache e recuperá-los. Esse código usa cachetools para armazenar em cache os tokens IAM Auth gerados por 15 minutos. Para criar um pacote de implantação contendo redis-py e cachetools, realize as etapas a seguir.
No diretório do projeto que contém o arquivo de código-fonte app.py, crie um pacote de pasta no qual instalar as bibliotecas redis-py e cachetools.
```
mkdir package
```
Instale redis-py, cacheetools usando pip.
```
pip install --target ./package redis
pip install --target ./package cachetools
```
Crie um arquivo .zip contendo as bibliotecas redis-py e cachetools. No Linux e no MacOS, execute o comando a seguir. No Windows, use o utilitário zip preferencial para criar um arquivo .zip com as bibliotecas redis-py and cachetools na raiz.
```
cd package
zip -r ../my_deployment_package.zip .
```
Adicione o código de função ao arquivo .zip. No Linux e no MacOS, execute o comando a seguir. No Windows, use o utilitário zip preferencial para adicionar app.py à raiz do arquivo .zip.
```
cd ..
zip my_deployment_package.zip app.py
```
### Etapa 2.2: Criar o perfil do IAM (perfil de execução)
Anexe a política AWS gerenciada nomeada `AWSLambdaVPCAccessExecutionRole` à função.
```
aws iam attach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"
```
### Etapa 2.3: fazer upload do pacote de implantação (criar função do Lambda)
Nesta etapa, você cria a função Lambda (AccessValkey) usando o comando AWS CLI create-function.
No diretório do projeto que contém o arquivo .zip do pacote de implantação, execute o seguinte comando `create-function` da CLI do Lambda.
Para a opção de perfil, use o ARN da função de execução criada na etapa anterior. Para vpc-config, insira listas separadas por vírgulas das sub-redes da VPC padrão e o ID do grupo de segurança da VPC padrão. É possível encontrar esses valores no console do Amazon VPC. Para encontrar as sub-redes da sua VPC padrão, escolha **Sua** e, em seguida VPCs, escolha a VPC padrão AWS da sua conta. Para localizar o grupo de segurança dessa VPC, vá para **Segurança** e escolha **Grupos de segurança**. Não se esqueça de selecionar a região us-east-1.
```
aws lambda create-function \
--function-name AccessValkey \
--region us-east-1 \
--zip-file fileb://my_deployment_package.zip \
--role arn:aws:iam::123456789012:role/elasticache-iam-auth-app \
--handler app.lambda_handler \
--runtime python3.12 \
--timeout 30 \
--vpc-config SubnetIds=comma-separated-vpc-subnet-ids,SecurityGroupIds=default-security-group-id
```
## Etapa 3: Teste a função Lambda com ElastiCache
Nesta etapa, você invoca a função do Lambda manualmente usando o comando de invocação. Quando a função Lambda é executada, ela gera um UUID e o grava no ElastiCache cache que você especificou no seu código Lambda. Depois, a função do Lambda recupera o item do cache.
1. Invoque a função Lambda AccessValkey () usando AWS Lambda o comando invoke.
```
aws lambda invoke \
--function-name AccessValkey \
--region us-east-1 \
output.txt
```
1. Verifique se a função do Lambda foi executada com êxito, da seguinte forma:
+ Analise o arquivo output.txt.
+ Verifique os resultados em CloudWatch Logs abrindo o CloudWatch console e escolhendo o grupo de registros para sua função (/aws/lambda/AccessValkey). O fluxo de logs deve conter uma saída semelhante à mostrada a seguir:
```
Success: Inserted 826e70c5f4d2478c8c18027125a3e01e. Fetched 826e70c5f4d2478c8c18027125a3e01e from Valkey.
```
+ Analise os resultados no AWS Lambda console.
## Etapa 4: limpar (opcional)
Para limpar, siga estas etapas.
### Etapa 4.1: excluir a função do Lambda
```
aws lambda delete-function \
--function-name AccessValkey
```
### Etapa 4.2: excluir o cache de tecnologia sem servidor
Excluir o cache.
```
aws elasticache delete-serverless-cache \
--serverless-cache-name cache-01
```
Remover usuários e grupos de usuários.
```
aws elasticache delete-user \
--user-id default-user-disabled
aws elasticache delete-user \
--user-id iam-user-01
aws elasticache delete-user-group \
--user-group-id iam-user-group-01
```
### Etapa 4.3: remover políticas e o perfil do IAM
```
aws iam detach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
aws iam detach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"
aws iam delete-role \
--role-name "elasticache-iam-auth-app"
aws iam delete-policy \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
```