Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Cómo empezar con Amazon ElastiCache
Usa el tutorial práctico de esta sección para ayudarte a empezar y obtener más información sobre su uso ElastiCache.
**Topics**
+ [Con ElastiCachefiguración](set-up.md)
+ [Creación de una caché sin servidor de Valkey](GettingStarted.serverless-valkey.step1.md)
+ [Creación de una caché sin servidor de Redis OSS](GettingStarted.serverless-redis.step1.md)
+ [Creación de una caché sin servidor de Memcached](create-serverless-cache-mem.md)
+ [Tutoriales: introducción a Python y ElastiCache](ElastiCache-Getting-Started-Tutorials.md)
+ [Tutorial: Configuración de Lambda para acceder a una ElastiCache VPC](LambdaRedis.md)
# Con ElastiCachefiguración
Para usar el servicio ElastiCache web, sigue estos pasos.
**Topics**
+ [Inscríbase en una Cuenta de AWS](#sign-up-for-aws)
+ [Creación de un usuario con acceso administrativo](#create-an-admin)
+ [Conceder acceso programático](#elasticache-set-up-access-key)
+ [Configuración de permisos](#elasticache-set-up-permissions)
+ [Configurar EC2](#elasticache-install-configure-ec2)
+ [Otorgar acceso de red](#elasticache-install-grant-access-VPN)
+ [Configuración del acceso a la línea de comandos](#Download-and-install-cli)
## Inscríbase en una Cuenta de AWS
Si no tiene uno Cuenta de AWS, complete los siguientes pasos para crearlo.
**Para suscribirse a una Cuenta de AWS**
1. Abrir [https://portal.aws.amazon.com/billing/registro](https://portal.aws.amazon.com/billing/signup).
1. Siga las instrucciones que se le indiquen.
Parte del procedimiento de registro consiste en recibir una llamada telefónica o mensaje de texto e indicar un código de verificación en el teclado del teléfono.
Cuando te registras en un Cuenta de AWS, *Usuario raíz de la cuenta de AWS*se crea un. El usuario raíz tendrá acceso a todos los Servicios de AWS y recursos de esa cuenta. Como práctica recomendada de seguridad, asigne acceso administrativo a un usuario y utilice únicamente el usuario raíz para realizar [tareas que requieren acceso de usuario raíz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS te envía un correo electrónico de confirmación una vez finalizado el proceso de registro. En cualquier momento, puede ver la actividad de su cuenta actual y administrarla accediendo a [https://aws.amazon.com/](https://aws.amazon.com/)y seleccionando **Mi cuenta**.
## Creación de un usuario con acceso administrativo
Después de crear un usuario administrativo Cuenta de AWS, asegúrelo Usuario raíz de la cuenta de AWSAWS IAM Identity Center, habilite y cree un usuario administrativo para no usar el usuario root en las tareas diarias.
**Proteja su Usuario raíz de la cuenta de AWS**
1. Inicie sesión [Consola de administración de AWS](https://console.aws.amazon.com/)como propietario de la cuenta seleccionando el **usuario root** e introduciendo su dirección de Cuenta de AWS correo electrónico. En la siguiente página, escriba su contraseña.
Para obtener ayuda para iniciar sesión con el usuario raíz, consulte [Iniciar sesión como usuario raíz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) en la *Guía del usuario de AWS Sign-In*.
1. Active la autenticación multifactor (MFA) para el usuario raíz.
Para obtener instrucciones, consulte [Habilitar un dispositivo MFA virtual para el usuario Cuenta de AWS raíz (consola)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) en la Guía del usuario de *IAM*.
**Creación de un usuario con acceso administrativo**
1. Activar IAM Identity Center.
Consulte las instrucciones en [Activar AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) en la *Guía del usuario de AWS IAM Identity Center*.
1. En IAM Identity Center, conceda acceso administrativo a un usuario.
Para ver un tutorial sobre su uso Directorio de IAM Identity Center como fuente de identidad, consulte [Configurar el acceso de los usuarios con la configuración predeterminada Directorio de IAM Identity Center en la](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) Guía del *AWS IAM Identity Center usuario*.
**Inicio de sesión como usuario con acceso de administrador**
+ Para iniciar sesión con el usuario de IAM Identity Center, use la URL de inicio de sesión que se envió a la dirección de correo electrónico cuando creó el usuario de IAM Identity Center.
Para obtener ayuda para iniciar sesión con un usuario del Centro de identidades de IAM, consulte [Iniciar sesión en el portal de AWS acceso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) en la *Guía del AWS Sign-In usuario*.
**Concesión de acceso a usuarios adicionales**
1. En IAM Identity Center, cree un conjunto de permisos que siga la práctica recomendada de aplicar permisos de privilegios mínimos.
Para conocer las instrucciones, consulte [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) en la *Guía del usuario de AWS IAM Identity Center*.
1. Asigne usuarios a un grupo y, a continuación, asigne el acceso de inicio de sesión único al grupo.
Para conocer las instrucciones, consulte [Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) en la *Guía del usuario de AWS IAM Identity Center*.
## Conceder acceso programático
Los usuarios necesitan acceso programático si quieren interactuar con personas AWS ajenas a.Consola de administración de AWS La forma de conceder el acceso programático depende del tipo de usuario que acceda.AWS
Para conceder acceso programático a los usuarios, elija una de las siguientes opciones.
****
| ¿Qué usuario necesita acceso programático? | Para | Mediante |
| --- | --- | --- |
| IAM | (Recomendado) Utilice las credenciales de la consola como credenciales temporales para firmar las solicitudes programáticas dirigidas al AWS CLIAWS SDKs, o.AWS APIs | Siga las instrucciones de la interfaz que desea utilizar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/set-up.html) |
| Identidad del personal (Usuarios administrados en el IAM Identity Center) | Utilice credenciales temporales para firmar las solicitudes programáticas dirigidas al AWS CLI,AWS SDKs, o AWS APIs. | Siga las instrucciones de la interfaz que desea utilizar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/set-up.html) |
| IAM | Utilice credenciales temporales para firmar las solicitudes programáticas dirigidas al AWS CLIAWS SDKs, o.AWS APIs | Siga las instrucciones de [Uso de credenciales temporales con AWS recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) de la Guía del usuario de IAM. |
| IAM | (No recomendado)Utilice credenciales de larga duración para firmar las solicitudes programáticas dirigidas al AWS CLIAWS SDKs, o.AWS APIs | Siga las instrucciones de la interfaz que desea utilizar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/set-up.html) |
**Temas relacionados:**
+ [¿Qué es IAM?](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) en la *Guía del usuario de IAM*.
+ [AWS Las credenciales de seguridad](https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html) son una *referencia AWS general*.
## Configure sus permisos (solo para ElastiCache usuarios nuevos)
Para dar acceso, agregue permisos a los usuarios, grupos o roles:
+ Usuarios y grupos en AWS IAM Identity Center:
Cree un conjunto de permisos. Siga las instrucciones de [Creación de un conjunto de permisos](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) en la *Guía del usuario de AWS IAM Identity Center*.
+ Usuarios gestionados en IAM a través de un proveedor de identidades:
Cree un rol para la federación de identidades. Siga las instrucciones descritas en [Creación de un rol para un proveedor de identidad de terceros (federación)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) en la *Guía del usuario de IAM*.
+ Usuarios de IAM:
+ Cree un rol que el usuario pueda aceptar. Siga las instrucciones descritas en [Creación de un rol para un usuario de IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) en la *Guía del usuario de IAM*.
+ (No recomendado) Adjunte una política directamente a un usuario o agregue un usuario a un grupo de usuarios. Siga las instrucciones descritas en [Adición de permisos a un usuario (consola)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) de la *Guía del usuario de IAM*.
Amazon ElastiCache crea y utiliza funciones vinculadas a servicios para aprovisionar recursos y acceder a otros AWS recursos y servicios en tu nombre. ElastiCache Para crear un rol vinculado a un servicio para usted, utilice la AWS política administrada denominada. `AmazonElastiCacheFullAccess` Esta función ya está aprovisionada con los permisos que el servicio requiere para crear un rol vinculado a un servicio en su nombre.
Si lo prefiere, puede no utilizar la política predeterminada, sino una administrada de forma personalizada. En este caso, asegúrese de tener los permisos para llamar a `iam:createServiceLinkedRole` o bien de haber creado la función vinculada al servicio de ElastiCache.
Para obtener más información, consulte los siguientes temas:
+ [Creación de una nueva política](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) (IAM)
+ [AWS políticas gestionadas para Amazon ElastiCache](IAM.IdentityBasedPolicies.PredefinedPolicies.md)
+ [Uso de roles vinculados a servicios para Amazon ElastiCache](using-service-linked-roles.md)
## Configurar EC2
Necesitarás configurar una EC2 instancia desde la que te conectarás a tu caché.
+ Si aún no tienes una EC2 instancia, consulta cómo configurarla aquí: [Amazon EC2 Getting Started Guide](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html). EC2
+ La EC2 instancia debe estar en la misma VPC y tener la misma configuración de grupo de seguridad que la caché. De forma predeterminada, Amazon ElastiCache crea una caché en la VPC predeterminada y utiliza el grupo de seguridad predeterminado. Para seguir este tutorial, asegúrate de que la EC2 instancia esté en la VPC predeterminada y tenga el grupo de seguridad predeterminado.
## Otorgar acceso de red desde un grupo de seguridad de Amazon VPC a la memoria caché
ElastiCache Los clústeres basados en nodos utilizan el puerto 6379 para los comandos OSS de Valkey y Redis, y los sistemas ElastiCache sin servidor utilizan los puertos 6379 y 6380. Para conectar y ejecutar correctamente los comandos OSS de Valkey o Redis desde su EC2 instancia, su grupo de seguridad debe permitir el acceso a estos puertos según sea necesario.
ElastiCache para Memcached, utiliza los puertos 11211 y 11212 para aceptar los comandos de Memcached. Para poder conectar y ejecutar correctamente los comandos de Memcached desde su EC2 instancia, su grupo de seguridad debe permitir el acceso a estos puertos.
1. Inicia sesión en la [ EC2 consola de Amazon AWS Command Line Interface](https://console.aws.amazon.com/ec2/) y ábrela.
1. En el panel de navegación, en **Network & Security** (Redes y seguridad), seleccione **Security Groups**(Grupos de seguridad).
1. En la lista de grupos de seguridad, elija el grupo de seguridad para su Amazon VPC. A menos que hayas creado un grupo de seguridad para ElastiCache su uso, este grupo de seguridad se denominará *predeterminado*.
1. Elija la pestaña Entrada y haga lo siguiente:
1. Elija **Edit (Edición de)**.
1. Seleccione **Agregar regla**.
1. En la columna Tipo, elija **Regla TCP personalizada**.
1. Si utiliza Valkey o Redis OSS, en el cuadro **Rango de puertos**, escriba `6379`.
Si usa Memcached, en el cuadro **Rango de puertos**, escriba `11211`.
1. En el cuadro **Fuente**, selecciona Cualquier **lugar** que tenga el rango de puertos (0.0.0.0/0) para que cualquier EC2 instancia de Amazon que lances en tu Amazon VPC pueda conectarse a tu caché.
1. **Si utiliza un sistema ElastiCache sin servidor, añada otra regla. Para ello, seleccione Añadir regla.**
1. En la columna **Type**, elija **Custom TCP rule**.
1. Si la utiliza ElastiCache para Redis OSS, escriba en el cuadro **Rango de puertos**. `6380`
Si lo usa ElastiCache para Memcached, escriba en el cuadro **Rango de puertos**. `11212`
1. En el cuadro **Fuente**, selecciona Cualquier **lugar** que tenga el rango de puertos (0.0.0.0/0) para que cualquier EC2 instancia de Amazon que lances en tu Amazon VPC pueda conectarse a tu caché.
1. Seleccione **Save**.
## Descarga y configuración del acceso a la línea de comandos
**Descargue e instale la utilidad *valkey-cli*.**
Si utilizas Valkey, puede que ElastiCache la utilidad valkey-cli te resulte útil. Si está utilizando ElastiCache Redis OSS con redis-cli, considere la posibilidad de cambiar a valkey-cli, ya que también funciona para Redis OSS.
1. Conéctate a tu EC2 instancia de Amazon mediante la utilidad de conexión que prefieras. Para obtener instrucciones sobre cómo conectarse a una EC2 instancia de Amazon, consulta la [Guía de EC2 introducción de Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html).
1. Descargue e instale la utilidad valkey-cli mediante el comando adecuado para su configuración.
**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**
Al instalar el paquete redis6, se instalará redis6-cli con soporte de cifrado predeterminado.
Es importante contar con soporte de compilación para TLS al instalar valkey-cli o redis-cli. ElastiCache Solo se puede acceder a Serverless cuando TLS está activado.
Si el clúster al que se conecta no está cifrado, no necesita la opción `Build_TLS=yes`.
# Creación de una caché sin servidor de Valkey
En este paso, creará una nueva caché en Amazon ElastiCache.
**Consola de administración de AWS**
Para crear una nueva caché con la consola de ElastiCache:
1. Inicie sesión en la Consola de administración de AWS y abra [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el panel de navegación del lado izquierdo de la consola, elija **Cachés de Valkey**.
1. En el lado derecho de la consola, elija **Crear caché de Valkey**.
1. En **Configuración de caché**, introduzca un **Nombre**. Si lo desea, puede especificar una **descripción** para la caché.
1. Deje seleccionado el ajuste predeterminado.
1. Haga clic en **Crear** para crear la caché.
1. Cuando la caché se encuentre en estado “ACTIVO”, podrá empezar a usarla para leer y escribir.
**AWS CLI**
En el siguiente ejemplo de la AWS CLI, se crea una nueva caché mediante 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
```
Como puede ver, el valor del campo Estado es `CREATING`.
Para comprobar que ElastiCache haya terminado de crear la caché, utilice el comando `describe-serverless-caches`.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Después de crear la caché, continúe con [Lectura y escritura de datos en la caché](GettingStarted.serverless-valkey.step2.md).
# Lectura y escritura de datos en la caché
En esta sección se supone que has creado una EC2 instancia de Amazon y que puedes conectarte a ella. Para obtener instrucciones sobre cómo hacerlo, consulta la [Guía de EC2 introducción de Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html).
En esta sección también se supone que has configurado los ajustes de acceso a la VPC y del grupo de seguridad para la EC2 instancia desde la que te conectas a la caché, y que has configurado valkey-cli en tu instancia. EC2 Para obtener más información sobre este paso, consulte [Con ElastiCachefiguración](set-up.md).
Además de los pasos que se indican a continuación, si tiene una aplicación grande o global, puede aumentar considerablemente el rendimiento de lectura creando réplicas y leyéndolas. Para obtener más información sobre este paso más avanzado, consulte [Prácticas recomendadas para utilizar réplicas de lectura](ReadReplicas.md).
**Buscar el punto de conexión de la caché**
**Consola de administración de AWS**
Para encontrar el punto final de tu caché mediante la consola, sigue estos pasos: ElastiCache
1. Inicia sesión en la ElastiCache consola de Amazon Consola de administración de AWS y ábrela en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el panel de navegación del lado izquierdo de la consola, elija **Cachés de Valkey**.
1. En la parte derecha de la consola, haga clic en el nombre de la caché que acaba de crear.
1. En los **Detalles de la caché**, busque y copie el punto de conexión de la caché.
**AWS CLI**
En el siguiente AWS CLI ejemplo, se muestra cómo encontrar el punto final de la nueva caché mediante el describe-serverless-caches comando. Cuando haya ejecutado el comando, busque el campo “Punto de conexión”.
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Conexión a la caché de Valkey (Linux)
Ahora que tienes el punto final que necesitas, puedes iniciar sesión en tu EC2 instancia y conectarte a la caché. En el siguiente ejemplo, se conecta a un clúster con la utilidad *valkey-cli*. El siguiente comando se conecta a una caché (nota: sustituya cache-endpoint por el punto de conexión que recuperó en el paso 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"
```
## Conexión a la caché de Valkey (Windows)
Ahora que tienes el punto de conexión que necesitas, puedes iniciar sesión en tu EC2 instancia y conectarte a la caché. En el siguiente ejemplo, se conecta a un clúster con la utilidad *valkey-cli*. El siguiente comando se conecta a una caché. Abra el símbolo del sistema, vaya al directorio de Valkey o Redis OSS y ejecute el comando (nota: sustituya Cache\$1Endpoint por el punto de conexión que recuperó en el paso 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"
```
Ahora puede pasar a [(Opcional) Limpieza](GettingStarted.serverless-valkey.step3.md).
# (Opcional) Limpieza
Si ya no necesita la caché de Amazon ElastiCache que creó, puede eliminarla. De este modo, no se le cobrará por recursos que no vaya a utilizar. Para eliminar la caché, puede utilizar la consola de ElastiCache, la AWS CLI o la API de ElastiCache.
**Consola de administración de AWS**
Para eliminar la caché con la consola:
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon ElastiCache en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el panel de navegación del lado izquierdo de la consola, elija **Cachés de Valkey**.
1. Elija el botón de opción situado al lado de la caché que desea eliminar.
1. Seleccione **Acciones**, en la parte superior derecha, y **Eliminar**.
1. Si lo desea, puede tomar una última instantánea antes de eliminar la memoria caché.
1. En la pantalla de confirmación **Eliminar**, vuelva a introducir el nombre de la caché y seleccione **Eliminar**, para eliminar el clúster, o **Cancelar**, para conservarlo.
En cuanto la caché pase al estado **DELETING**, dejará de generar gastos.
**AWS CLI**
En el siguiente ejemplo de la AWS CLI, se elimina una caché mediante el comando delete-serverless-cache.
**Linux**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name CacheName
```
Como puede ver, el valor del campo **Estado** es **DELETING**.
Ahora puede pasar a [Siguientes pasos](GettingStarted.serverless-valkey.next-steps.md).
# Siguientes pasos
Para obtener más información sobre ElastiCache, consulte las siguientes páginas:
+ [Trabajando con ElastiCache](WorkingWithElastiCache.md)
+ [Escalado ElastiCache](Scaling.md)
+ [Registro y Supervisión en Amazon ElastiCache](MonitoringECMetrics.md)
+ [Procedimientos recomendados y estrategias de almacenamiento en caché de ElastiCache](BestPractices.md)
+ [Instantánea y restauración](backups.md)
+ [Supervisión de eventos de ElastiCache en Amazon SNS](ECEvents.md)
# Creación de una caché sin servidor de Redis OSS
En este paso, creará una nueva caché en Amazon ElastiCache.
**Consola de administración de AWS**
Para crear una nueva caché con la consola de ElastiCache:
1. Inicie sesión en la Consola de administración de AWS y abra la consola de ElastiCache en [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el panel de navegación del lado izquierdo de la consola, elija **Cachés de Redis OSS**.
1. En el lado derecho de la consola, elija **Crear una caché de Redis OSS**.
1. En **Configuración de caché**, introduzca un **Nombre**. Si lo desea, puede especificar una **descripción** para la caché.
1. Deje seleccionado el ajuste predeterminado.
1. Haga clic en **Crear** para crear la caché.
1. Cuando la caché se encuentre en estado “ACTIVO”, podrá empezar a usarla para leer y escribir.
**AWS CLI**
En el siguiente ejemplo de la AWS CLI, se crea una nueva caché mediante 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
```
Como puede ver, el valor del campo Estado es `CREATING`.
Para comprobar que ElastiCache haya terminado de crear la caché, utilice el comando `describe-serverless-caches`.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Después de crear la caché, continúe con [Lectura y escritura de datos en la caché](GettingStarted.serverless-redis.step2.md).
# Lectura y escritura de datos en la caché
En esta sección se supone que has creado una EC2 instancia de Amazon y que puedes conectarte a ella. Para obtener instrucciones sobre cómo hacerlo, consulta la [Guía de EC2 introducción de Amazon](https://aws.amazon.com/ec2/getting-started/).
En esta sección también se supone que has configurado los ajustes de acceso a la VPC y del grupo de seguridad para la EC2 instancia desde la que te conectas a la caché, y que has configurado valkey-cli en tu instancia. EC2 Para obtener más información sobre este paso, consulte [Con ElastiCachefiguración](set-up.md).
**Buscar el punto de conexión de la caché**
**Consola de administración de AWS**
Para encontrar el punto final de tu caché mediante la consola, sigue estos pasos: ElastiCache
1. Inicia sesión en la ElastiCache consola de Amazon Consola de administración de AWS y ábrela en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el panel de navegación del lado izquierdo de la consola, elija **Cachés de Valkey** o **Cachés de Redis OSS**.
1. En la parte derecha de la consola, haga clic en el nombre de la caché que acaba de crear.
1. En los **Detalles de la caché**, busque y copie el punto de conexión de la caché.
**AWS CLI**
En el siguiente AWS CLI ejemplo, se muestra cómo encontrar el punto final de la nueva caché mediante el describe-serverless-caches comando. Cuando haya ejecutado el comando, busque el campo “Punto de conexión”.
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Conexión a la caché de Valkey o Redis OSS (Linux)
Ahora que tienes el punto final que necesitas, puedes iniciar sesión en tu EC2 instancia y conectarte a la caché. En el siguiente ejemplo, se conecta a un clúster con la utilidad *valkey-cli*. El siguiente comando se conecta a una caché (nota: sustituya cache-endpoint por el punto de conexión que recuperó en el paso 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"
```
## Conexión a la caché de Valkey o Redis OSS (Windows)
Ahora que tienes el punto de conexión que necesitas, puedes iniciar sesión en tu EC2 instancia y conectarte a la caché. En el siguiente ejemplo, se conecta a un clúster con la utilidad *valkey-cli*. El siguiente comando se conecta a una caché. Abra el símbolo del sistema, vaya al directorio de Valkey y ejecute el comando (nota: sustituya Cache\$1Endpoint por el punto de conexión que recuperó en el paso 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"
```
Ahora puede pasar a [(Opcional) Limpieza](GettingStarted.serverless-redis.step3.md).
# (Opcional) Limpieza
Si ya no necesita la caché de Amazon ElastiCache que creó, puede eliminarla. De este modo, no se le cobrará por recursos que no vaya a utilizar. Para eliminar la caché, puede utilizar la consola de ElastiCache, la AWS CLI o la API de ElastiCache.
**Consola de administración de AWS**
Para eliminar la caché con la consola:
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon ElastiCache en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el panel de navegación de la parte izquierda de la consola, elija **Cachés de Valkey o Redis OSS**.
1. Elija el botón de opción situado al lado de la caché que desea eliminar.
1. Seleccione **Acciones**, en la parte superior derecha, y **Eliminar**.
1. Si lo desea, puede tomar una última instantánea antes de eliminar la memoria caché.
1. En la pantalla de confirmación **Eliminar**, vuelva a introducir el nombre de la caché y seleccione **Eliminar**, para eliminar el clúster, o **Cancelar**, para conservarlo.
En cuanto la caché pase al estado **DELETING**, dejará de generar gastos.
**AWS CLI**
En el siguiente ejemplo de la AWS CLI, se elimina una caché mediante el comando delete-serverless-cache.
**Linux**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name CacheName
```
Como puede ver, el valor del campo **Estado** es **DELETING**.
Ahora puede pasar a [Siguientes pasos](GettingStarted.serverless-redis.next-steps.md).
# Siguientes pasos
Para obtener más información sobre ElastiCache, consulte las siguientes páginas:
+ [Trabajando con ElastiCache](WorkingWithElastiCache.md)
+ [Escalado ElastiCache](Scaling.md)
+ [Registro y Supervisión en Amazon ElastiCache](MonitoringECMetrics.md)
+ [Procedimientos recomendados y estrategias de almacenamiento en caché de ElastiCache](BestPractices.md)
+ [Instantánea y restauración](backups.md)
+ [Supervisión de eventos de ElastiCache en Amazon SNS](ECEvents.md)
# Creación de una caché sin servidor de Memcached
**Consola de administración de AWS**
Para crear una nueva caché sin servidor de Memcached con la consola de ElastiCache:
1. Inicie sesión en la Consola de administración de AWS y abra la consola de ElastiCache en [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el panel de navegación del lado izquierdo de la consola, elija **Cachés de Memcached**.
1. En el lado derecho de la consola, elija **Crear caché de Memcached**.
1. En **Configuración de caché**, introduzca un **Nombre**. Si lo desea, puede especificar una **descripción** para la caché.
1. Deje seleccionado el ajuste predeterminado.
1. Haga clic en **Crear** para crear la caché.
1. Una vez que la caché esté en estado “ACTIVO”, puede empezar a escribir y leer datos en ella.
Para crear una nueva caché con la AWS CLI
En el siguiente ejemplo de la AWS CLI, se crea una nueva caché mediante 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
```
Como puede ver, el valor del campo Estado es `CREATING`.
Para comprobar que ElastiCache haya terminado de crear la caché, utilice el comando `describe-serverless-caches`.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Después de crear la caché, continúe con [Lectura y escritura de datos en la caché](read-write-cache-mem.md).
# Lectura y escritura de datos en la caché
En esta sección se asume que has creado una EC2 instancia de Amazon y que puedes conectarte a ella. Para obtener instrucciones sobre cómo hacerlo, consulta la [Guía de EC2 introducción de Amazon](https://aws.amazon.com/ec2/getting-started/).
De forma predeterminada, ElastiCache crea una memoria caché en la VPC predeterminada. Asegúrese de que la EC2 instancia también se cree en la VPC predeterminada para que pueda conectarse a la memoria caché.
**Buscar el punto de conexión de la caché**
**Consola de administración de AWS**
Para encontrar el punto final de la caché mediante la ElastiCache consola, sigue estos pasos:
1. Inicia sesión en la ElastiCache consola de Amazon Consola de administración de AWS y ábrela en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el panel de navegación del lado izquierdo de la consola, elija **Cachés de Memcached**.
1. En la parte derecha de la consola, haga clic en el nombre de la caché que acaba de crear.
1. En los **Detalles de la caché**, busque y copie el punto de conexión de la caché.
**AWS CLI**
En el siguiente AWS CLI ejemplo, se muestra cómo encontrar el punto final de la nueva caché mediante el describe-serverless-caches comando. Cuando haya ejecutado el comando, busque el campo “Punto de conexión”.
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Conexión mediante OpenSSL
Para obtener información sobre cómo conectarse empleando OpenSSL, consulte [ElastiCache cifrado en tránsito (TLS)](in-transit-encryption.md).
## Conexión mediante el cliente Java de 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");
}
}
```
## Conexión mediante el cliente PHP de 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);
?>
```
## Conexión mediante el cliente Python de Memcached (Pymemcache)
Consulta [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"
```
## Connect mediante el NodeJS/TS cliente Memcached (Electrode-IO memcache)
[https://github.com/electrode-io/Consulte](https://github.com/electrode-io/memcache) memcache y [https://www.npmjs.com/package/memcache-client](https://www.npmjs.com/package/memcache-client)
Instalación mediante `npm i memcache-client`
En la aplicación, cree un cliente TLS de memcached de la siguiente manera:
```
var memcache = require("memcache-client");
const client = new memcache.MemcacheClient({server: "{cluster_endpoint}:11211", tls: {}});
client.set("key", "value");
```
## Conexión mediante el cliente Rust de Memcached (rust-memcache)
[Consulte https://crates. io/crates/memcache](https://crates.io/crates/memcache)y [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();
```
## Conexión mediante el cliente Go de Memcached (Gomemcache)
[https://github.com/bradfitz/Véase 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)
```
## Conexión mediante el cliente Ruby de Memcached (Dalli)
[Ver dalli https://github.com/petergoldstein/](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")
```
## Conéctese mediante el cliente .NET de Memcached () EnyimMemcachedCore
Consulte [https://github.com/cnblogs/EnyimMemcachedCore](https://github.com/cnblogs/EnyimMemcachedCore)
```
"MemcachedClient": {
"Servers": [
{
"Address": "{cluster_endpoint}",
"Port": 11211
}
],
"UseSslStream": true
}
```
Ahora puede pasar a [(Opcional) Limpieza](read-write-cleanup-mem.md).
# (Opcional) Limpieza
**Uso del Consola de administración de AWS**
El siguiente procedimiento elimina una sola caché de su implementación. Para eliminar varias cachés, repita el procedimiento por cada caché que desee eliminar. No es necesario esperar a que una caché se elimine por completo antes de empezar a eliminar otra.
**Para eliminar una caché**
1. Inicia sesión en la ElastiCache consola de Amazon Consola de administración de AWS y ábrela en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el panel de control de la ElastiCache consola, elige el motor que se ejecuta en la memoria caché que deseas eliminar. Se mostrará una lista de todas las cachés que ejecutan ese motor.
1. Para elegir la caché que se va a eliminar, elija el nombre de la caché en la lista.
**importante**
Solo puedes eliminar una caché a la vez desde la ElastiCache consola. Al elegir varias cachés, se deshabilita la operación de eliminación.
1. En **Actions (Acciones)**, seleccione **Delete (Eliminar)**.
1. En la pantalla de confirmación **Eliminar caché**, elija **Eliminar** para eliminar la caché o elija **Cancelar** para conservarla.
1. Si elige **Eliminar**, el estado de la caché cambiará a *eliminando*.
En cuanto la caché pase al estado **DELETING**, dejará de generar gastos.
**Usando el AWS CLI**
El siguiente código elimina my-cache de la caché.
```
aws elasticache delete-serverless-cache --serverless-cache-name my-cache
```
La acción delete-serverless-cache CLI solo elimina una memoria caché sin servidor. Para eliminar varias cachés, llame a delete-serverless-cache cada caché sin servidor que desee eliminar. No es necesario esperar a que una caché sin servidor acabe de eliminarse antes de eliminar otra.
**Para Linux, macOS o Unix**:
```
aws elasticache delete-serverless-cache \
--serverless-cache-name my-cache
```
**Para Windows:**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name my-cache
```
Para obtener más información, consulte el AWS CLI tema ElastiCache delete-serverless-cache
Ahora puede pasar a [Siguientes pasos](next-steps-mem.md).
# Siguientes pasos
Para obtener más información sobre ElastiCache, consulte
+ [Trabajando con ElastiCache](WorkingWithElastiCache.md)
+ [Escalado ElastiCache](Scaling.md)
+ [Cuotas de ElastiCache](quota-limits.md)
+ [Procedimientos recomendados y estrategias de almacenamiento en caché de ElastiCache](BestPractices.md)
+ [Visualización de ElastiCache eventos](ECEvents.Viewing.md)
# Tutoriales: introducción a Python y ElastiCache
Esta sección contiene tutoriales prácticos para ayudar a entender ElastiCache para Valkey y Redis OSS. Recomendamos que realice alguno de los tutoriales específicos de los distintos lenguajes.
**nota**
AWSLos SDK de están disponibles en una amplia variedad de idiomas. Para obtener una lista completa, consulte [Herramientas para Amazon Web Services](https://aws.amazon.com/tools/).
**Topics**
+ [Python y ElastiCache](ElastiCache-Getting-Started-Tutorials-Python.md)
# Python y ElastiCache
En este tutorial, utilizarás el AWS SDK para Python (Boto3) para escribir programas sencillos que realicen las siguientes operaciones: ElastiCache
+ Cree clústeres OSS ElastiCache para Redis (modo de clúster activado y modo de clúster desactivado)
+ Verificar si los usuarios o grupos de usuarios existen; de lo contrario, crearlos. (Esta característica está disponible con Valkey 7.2 en adelante y con Redis OSS 6.0 a 7.1).
+ Connect to ElastiCache
+ Realiza operaciones como configurar y obtener cadenas, leer y escribir en las transmisiones y publicar y suscribirse desde el canal. Pub/Sub
A medida que avance en este tutorial, puede consultar la documentación del AWS SDK para Python (Boto). La siguiente sección es específica para ElastiCache: cliente de [ElastiCache bajo nivel](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/elasticache.html)
## Requisitos previos del tutorial
+ Configure una clave de AWS acceso para usar el.AWS SDKs Para obtener más información, consulte [Con ElastiCachefiguración](set-up.md).
+ Instale Python 3.0 o una versión posterior. Para obtener más información, consulte [https://www.python.org/downloads](https://www.python.org/downloads). Para obtener instrucciones, consulte [Quickstart](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) en la documentación de Boto 3.
**Topics**
+ [Requisitos previos del tutorial](#ElastiCache-Getting-Started-Tutorials-Prerquisites)
+ [Tutorial: Creación de clústeres y usuarios ElastiCache](#ElastiCache-Getting-Started-Tutorials-Create-Cluster-and-Users)
+ [Tutorial: Conectarse a ElastiCache](#ElastiCache-Getting-Started-Tutorials-Connecting)
+ [Ejemplos de uso](#ElastiCache-Getting-Started-Tutorials-Usage)
## Tutorial: Creación de clústeres y usuarios ElastiCache
Los siguientes ejemplos utilizan el SDK boto3 ElastiCache para las operaciones de administración de Redis OSS (creación de clústeres o usuarios) y redis-py-cluster redis-py/ para el manejo de datos.
**Topics**
+ [Crear un clúster en modo de clúster deshabilitado](#ElastiCache-Getting-Started-Tutorials-Create-Cluster)
+ [Crear un clúster en modo de clúster deshabilitado con TLS y RBAC](#ElastiCache-Getting-Started-Tutorials-RBAC)
+ [Crear un clúster en modo de clúster habilitado](#ElastiCache-Getting-Started-Tutorials-Cluster-Enabled)
+ [Crear un clúster en modo de clúster habilitado con TLS y RBAC](#ElastiCache-Getting-Started-Tutorials-Cluster-RBAC)
+ [Comprueba si users/usergroup existen, de lo contrario créalos](#ElastiCache-Getting-Started-Tutorials-Users)
### Crear un clúster en modo de clúster deshabilitado
*Copie el siguiente programa y péguelo en un archivo denominado .py. CreateClusterModeDisabledCluster*
```
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 ejecutar el programa, introduzca el siguiente comando:
`python CreateClusterModeDisabledCluster.py`
Para obtener más información, consulte [Administración de clústeres en ElastiCache](Clusters.md).
### Crear un clúster en modo de clúster deshabilitado con TLS y RBAC
Para garantizar la seguridad, puede utilizar Transport Layer Security (TLS) y el control de acceso basado en roles (RBAC) al crear un clúster en modo de clúster deshabilitado. A diferencia de AUTH de Valkey o Redis OSS, donde todos los clientes autenticados tienen acceso completo al grupo de replicación si su token se encuentra autenticado, RBAC permite controlar el acceso al clúster a través de grupos de usuarios. Estos grupos de usuarios se han diseñado como una forma de organizar el acceso a los grupos de reproducción. Para obtener más información, consulte [Control de acceso basado en roles (RBAC)](Clusters.RBAC.md).
Copie el siguiente programa y péguelo en un archivo denominado *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 ejecutar el programa, introduzca el siguiente comando:
`python ClusterModeDisabledWithRBAC.py`
Para obtener más información, consulte [Administración de clústeres en ElastiCache](Clusters.md).
### Crear un clúster en modo de clúster habilitado
Copie el siguiente programa y péguelo en un archivo denominado *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 ejecutar el programa, introduzca el siguiente comando:
`python ClusterModeEnabled.py`
Para obtener más información, consulte [Administración de clústeres en ElastiCache](Clusters.md).
### Crear un clúster en modo de clúster habilitado con TLS y RBAC
Para garantizar la seguridad, puede utilizar Transport Layer Security (TLS) y el control de acceso basado en roles (RBAC) al crear un clúster en modo de clúster habilitado. A diferencia de AUTH de Valkey o Redis OSS, donde todos los clientes autenticados tienen acceso completo al grupo de replicación si su token se encuentra autenticado, RBAC permite controlar el acceso al clúster a través de grupos de usuarios. Estos grupos de usuarios se han diseñado como una forma de organizar el acceso a los grupos de reproducción. Para obtener más información, consulte [Control de acceso basado en roles (RBAC)](Clusters.RBAC.md).
Copie el siguiente programa y péguelo en un archivo denominado *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 ejecutar el programa, introduzca el siguiente comando:
`python ClusterModeEnabledWithRBAC.py`
Para obtener más información, consulte [Administración de clústeres en ElastiCache](Clusters.md).
### Comprueba si users/usergroup existen, de lo contrario créalos
Con el RBAC, puede crear usuarios y asignarles permisos específicos mediante una cadena de acceso. Los usuarios se asignan a grupos de usuarios alineados con una función específica (administradores, recursos humanos) y, a continuación, se despliegan en uno o más grupos de replicación ElastiCache de OSS de Redis. Al hacerlo, puede establecer límites de seguridad entre clientes que utilicen el mismo grupo o grupos de replicación de Valkey o Redis OSS e impedir que los clientes accedan a los datos de los demás. Para obtener más información, consulte [Control de acceso basado en roles (RBAC)](Clusters.RBAC.md).
Copie el siguiente programa y péguelo en un archivo denominado *UserAndUserGroups.py.* Actualice el mecanismo de suministro de credenciales. Las credenciales de este ejemplo se muestran como reemplazables y se les asigna un elemento no declarado. Evite codificar las credenciales de forma rígida.
En este ejemplo, se utiliza una cadena de acceso con los permisos del usuario. Para obtener más información sobre cadenas de acceso, consulte [Especificación de permisos mediante una cadena de acceso](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 ejecutar el programa, introduzca el siguiente comando:
`python UserAndUserGroups.py`
## Tutorial: Conectarse a ElastiCache
Los siguientes ejemplos utilizan el cliente OSS de Valkey o Redis para conectarse a. ElastiCache
**Topics**
+ [Conexión a un clúster en modo de clúster deshabilitado](#ElastiCache-Getting-Started-Tutorials-Connecting-cluster-mode-disabled)
+ [Conexión a un clúster en modo de clúster habilitado](#ElastiCache-Getting-Started-Tutorials-Connecting-cluster-mode-enabled)
### Conexión a un clúster en modo de clúster deshabilitado
Copie el siguiente programa y péguelo en un archivo denominado *ConnectClusterModeDisabled.py.* Actualice el mecanismo de suministro de credenciales. Las credenciales de este ejemplo se muestran como reemplazables y se les asigna un elemento no declarado. Evite codificar las credenciales de forma 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 ejecutar el programa, introduzca el siguiente comando:
`python ConnectClusterModeDisabled.py`
### Conexión a un clúster en modo de clúster habilitado
Copie el siguiente programa y péguelo en un archivo denominado *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 ejecutar el programa, introduzca el siguiente comando:
`python ConnectClusterModeEnabled.py`
## Ejemplos de uso
Los siguientes ejemplos utilizan el SDK boto3 ElastiCache para trabajar con ElastiCache Redis OSS.
**Topics**
+ [Establecer y obtener cadenas](#ElastiCache-Getting-Started-Tutorials-set-strings)
+ [Establecer y obtener un hash con varios elementos](#ElastiCache-Getting-Started-Tutorials-set-hash)
+ [Publica (escribe) y suscríbete (lee) desde un canal Pub/Sub](#ElastiCache-Getting-Started-Tutorials-pub-sub)
+ [Escribir y leer a partir de un flujo](#ElastiCache-Getting-Started-Tutorials-read-write-stream)
### Establecer y obtener cadenas
*Copie el siguiente programa y péguelo en un archivo denominado .py. SetAndGetStrings*
```
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 ejecutar el programa, introduzca el siguiente comando:
`python SetAndGetStrings.py`
### Establecer y obtener un hash con varios elementos
Copie el siguiente programa y péguelo en un archivo denominado *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 ejecutar el programa, introduzca el siguiente comando:
`python SetAndGetHash.py`
### Publica (escribe) y suscríbete (lee) desde un canal Pub/Sub
Copie el siguiente programa y péguelo en un archivo denominado *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 ejecutar el programa, introduzca el siguiente comando:
`python PubAndSub.py`
### Escribir y leer a partir de un flujo
Copie el siguiente programa y péguelo en un archivo denominado *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 ejecutar el programa, introduzca el siguiente comando:
`python ReadWriteStream.py`
# Tutorial: Configuración de Lambda para acceder a una ElastiCache VPC
En este tutorial, puede aprender a crear una caché ElastiCache sin servidor, crear una función Lambda, probar la función Lambda y, opcionalmente, limpiarla después.
**Topics**
+ [Paso 1: Crear una ElastiCache caché sin servidor.](#LambdaRedis.step1)
+ [Paso 2: Crear una función Lambda para ElastiCache](#LambdaRedis.step2)
+ [Paso 3: Pruebe la función Lambda con ElastiCache](#LambdaRedis.step3)
+ [Paso 4: limpieza (opcional)](#LambdaRedis.step4)
## Paso 1: Crear una ElastiCache caché sin servidor.
Siga estos pasos para crear una caché sin servidor.
### Paso 1.1: creación de una caché sin servidor
En este paso, crea una caché sin servidor en la Amazon VPC predeterminada de la región us-east-1 de su cuenta mediante la (CLI).AWS Command Line Interface Para obtener información sobre cómo crear una caché sin servidor mediante la ElastiCache consola o la API, consulte. [Creación de una caché sin servidor de Redis OSS](GettingStarted.serverless-redis.step1.md)
```
aws elasticache create-serverless-cache \
--serverless-cache-name cache-01 \
--description "ElastiCache IAM auth application" \
--engine valkey
```
Como puede ver, el valor del campo Estado es `CREATING`. Terminar de crear la caché puede tardar un minuto. ElastiCache
### Paso 1.2: copia del punto de conexión de caché sin servidor
Compruebe que ElastiCache Redis OSS haya terminado de crear la caché con el `describe-serverless-caches` comando.
```
aws elasticache describe-serverless-caches \
--serverless-cache-name cache-01
```
Copie la dirección del punto de conexión que aparece en el resultado. Necesitará esta dirección cuando cree el paquete de implementación para la función de Lambda.
### Paso 1.3: creación de un rol de IAM
1. Cree un documento de política de confianza de IAM, como se muestra a continuación, para el rol que permita a la cuenta asumir el nuevo rol. Guarde la política en un archivo denominado *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. Cree un documento de política de IAM, como se muestra a continuación. Guarde la política en un archivo denominado *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. Crear un rol de IAM.
```
aws iam create-role \
--role-name "elasticache-iam-auth-app" \
--assume-role-policy-document file://trust-policy.json
```
1. Creación de la política de IAM.
```
aws iam create-policy \
--policy-name "elasticache-allow-all" \
--policy-document file://policy.json
```
1. Adjunte la política de IAM al rol.
```
aws iam attach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
```
### Paso 1.4: creación de un usuario predeterminado
1. Cree un nuevo usuario predeterminado.
```
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. Cree un nuevo usuario habilitado para 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. Cree un grupo de usuarios y asocie al usuario.
```
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
```
## Paso 2: Crear una función Lambda para ElastiCache
Para crear una función Lambda para acceder a la ElastiCache memoria caché, siga estos pasos.
### Paso 2.1: creación de una función de Lambda
En este tutorial, proporcionamos código de ejemplo en Python para su función de Lambda.
**Python**
El siguiente ejemplo de código Python lee y escribe un elemento en la ElastiCache caché. Copie el código y guárdelo en un archivo con el nombre `app.py`. Asegúrese de reemplazar el valor `elasticache_endpoint` del código por la dirección del punto de conexión que copió en el paso 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"
```
Este código usa la biblioteca redis-py de Python para colocar elementos en la caché y recuperarlos. Este código usa cachetools para almacenar en caché durante 15 minutos los tokens de autenticación de IAM generados. Para crear un paquete de implementación que contenga redis-py y cachetools, siga estos pasos.
En el directorio del proyecto que contiene el archivo de código fuente app.py, cree un paquete de carpetas en el que instalar las bibliotecas redis-py y cachetools.
```
mkdir package
```
Instale redis-py y cachetools usando pip.
```
pip install --target ./package redis
pip install --target ./package cachetools
```
Cree un archivo .zip que contenga las bibliotecas redis-py y cachetools. En Linux y macOS, ejecute el siguiente comando. En Windows, cree un archivo .zip con las bibliotecas redis-py y cachetools en la raíz con la utilidad de compresión zip que prefiera.
```
cd package
zip -r ../my_deployment_package.zip .
```
Añada el código de función al archivo .zip. En Linux y macOS, ejecute el siguiente comando. En Windows, añada app.py al directorio raíz del archivo .zip con la utilidad de compresión zip que prefiera.
```
cd ..
zip my_deployment_package.zip app.py
```
### Paso 2.2: crear el rol de IAM (rol de ejecución)
Adjunta la política AWS administrada nombrada `AWSLambdaVPCAccessExecutionRole` al rol.
```
aws iam attach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"
```
### Paso 2.3: cargar el paquete de despliegue (crear la función de Lambda)
En este paso, se crea la función Lambda (AccessValkey) mediante el comando AWS CLI create-function.
Desde el directorio del proyecto que contiene el archivo.zip del paquete de implementación, ejecute el siguiente comando `create-function` de la CLI de Lambda.
Para la opción del rol, utilice el ARN del rol de ejecución que creó en el paso anterior. Para vpc-config, introduzca listas separadas por comas de las subredes de la VPC predeterminada y el ID del grupo de seguridad de la VPC predeterminada. Puede encontrar estos valores en la Consola de Amazon VPC. Para buscar las subredes de su VPC predeterminada, elija **Su** VPC y, a continuación VPCs, elija la VPC predeterminada de su AWS cuenta. Para buscar el grupo de seguridad de esta VPC, vaya a **Seguridad** y elija **Grupos de seguridad**. Compruebe que ha seleccionado la región 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
```
## Paso 3: Pruebe la función Lambda con ElastiCache
En este paso, invocará la función de Lambda manualmente utilizando el comando de invocación. Cuando se ejecuta la función Lambda, genera un UUID y lo escribe en la ElastiCache caché que especificó en el código Lambda. A continuación, la función de Lambda recupera el elemento de la caché.
1. Invoque la función Lambda AccessValkey () mediante AWS Lambda el comando invoke.
```
aws lambda invoke \
--function-name AccessValkey \
--region us-east-1 \
output.txt
```
1. Compruebe que la función de Lambda se ha ejecutado correctamente del modo siguiente:
+ Revise el archivo output.txt.
+ Verifique los resultados en los CloudWatch registros abriendo la CloudWatch consola y eligiendo el grupo de registros para su función (/). aws/lambda/AccessValkey El flujo de registro debería contener una salida similar a lo siguiente:
```
Success: Inserted 826e70c5f4d2478c8c18027125a3e01e. Fetched 826e70c5f4d2478c8c18027125a3e01e from Valkey.
```
+ Revise los resultados en la AWS Lambda consola.
## Paso 4: limpieza (opcional)
Para limpiar, siga estos pasos.
### Paso 4.1: eliminación de la función de Lambda
```
aws lambda delete-function \
--function-name AccessValkey
```
### Paso 4.2: eliminación de la caché sin servidor
Elimine la caché.
```
aws elasticache delete-serverless-cache \
--serverless-cache-name cache-01
```
Quite usuarios y grupos de usuarios.
```
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
```
### Paso 4.3: eliminación de políticas y el rol de 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"
```