Inicio rápido: Creación e implementación de una aplicación mediante Azure Cache for Redis mediante GitHub Copilot para Azure y Azure servidor MCP

En este inicio rápido se muestra cómo crear una aplicación de Python sencilla que:

• Se conecta a Azure Cache for Redis
• Escribe la fecha y hora actuales en Redis.
• Lee el valor de nuevo.
• Imprime el resultado en la consola

Use GitHub Copilot para generar la mayor parte del código y los pasos de aprovisionamiento.

Prerequisites

Para obtener instrucciones de configuración completas, consulte el artículo Comenzar . Asegúrese de que tiene los siguientes elementos:

Compilar la aplicación

Siga estos pasos descritos en este artículo:

1. Cree un archivo .env en su área de trabajo para almacenar la información de implementación de Azure como variables de entorno.
2. Escriba un mensaje para crear una instancia de Azure Cache for Redis en tu suscripción. La información de conexión de Redis también se almacena en el .env archivo .
3. Compruebe que el recurso y el .env archivo se crean correctamente.
4. Escriba un mensaje para crear una aplicación de Python para recuperar, escribir y leer desde la memoria caché mediante variables de entorno.
5. Valide que la aplicación funciona.
6. Limpie los recursos en Azure.

Asegúrese de seleccionar las herramientas adecuadas.

Debe instalar Azure servidor MCP y GitHub Copilot para Azure.

Creación de variables de entorno locales

Almacene claves importantes y otras opciones de configuración como variables de entorno en un .env archivo de la carpeta del área de trabajo. Esta práctica mantiene toda la configuración independiente dentro del proyecto.

Cree un archivo .env en su espacio de trabajo usando una instrucción como la del siguiente ejemplo:

Create an `.env` file in this workspace with the following environment variables filled in:

AZURE_SUBSCRIPTION_ID
AZURE_TENANT_ID
AZURE_LOCATION
AZURE_RESOURCE_GROUP
AZURE_RESOURCE_PREFIX

Use my <your-subscription-name> subscription and I want to put everything in eastus.

Reemplace <your-subscription-name> por el nombre de la suscripción de Azure. Copilot busca por ti los ID de suscripción y de inquilino, genera un nombre y un prefijo para el grupo de recursos y crea el archivo .env.

Una vez creado el archivo, ábralo y compruebe que los valores son correctos:

AZURE_SUBSCRIPTION_ID=<your-azure-subscription-id>
AZURE_TENANT_ID=<your-azure-tenant-id>
AZURE_LOCATION=eastus
AZURE_RESOURCE_GROUP=<resource-group>
AZURE_RESOURCE_PREFIX=<resource-prefix>

Crear el Azure Cache for Redis

Abra GitHub Copilot Chat y pegue la siguiente sugerencia.

You have access to Azure MCP tools.

Use the variables in the `.env` file in this workspace to create an Azure Cache for Redis instance.

Tasks:
1. Ensure the resource group exists.
2. Create Azure Cache for Redis:
    - Name: {AZURE_RESOURCE_PREFIX}-redis
    - SKU: Basic C0
    - TLS enabled (port 6380)
3. Write the following values into the `.env` file:
    REDIS_HOST
    REDIS_PORT=6380
    REDIS_PASSWORD (primary key)
    REDIS_SSL=true

Important:
- Use Azure MCP to create resources and fetch keys.

Copilot crea el recurso de Redis y, a continuación, crea un archivo /.env que contiene el nombre de host, la clave principal y las demás variables de entorno.

Compruebe que el archivo .env tiene la configuración de Redis.

1. Abra el archivo en la carpeta del .env proyecto y compruebe que tiene valores.

   REDIS_HOST=<your-cache-name>.redis.cache.windows.net
   REDIS_PORT=6380
   REDIS_PASSWORD=<primary-key>
   REDIS_SSL=true
   

2. Verifique que la instancia de Azure Cache for Redis esté ejecutándose usando el siguiente indicador.

   Use the values in the `.env` file in this workspace to validate that an instance of Azure Cache for Redis is running and ready to be used.
   

Solicitud para escribir la aplicación en Python

Use el siguiente prompt para crear la aplicación de Python que escribe y lee desde la nueva instancia de Azure Cache for Redis.

Create a minimal Python console app in this workspace.

Important:
- Do ALL work directly by editing files.
- Do NOT ask me to copy/paste code.
- Create files if they do not exist.

Goal:
Build a simple app that writes the current date/time to Azure Cache for Redis, reads it back, and prints results to the console.

Project requirements:

1. Create or update these files:

- main.py
- requirements.txt
- .gitignore

2. requirements.txt must include:
- redis
- python-dotenv

3. .gitignore must include:
- .venv/
- __pycache__/
- .env

4. main.py must:

- Load environment variables using python-dotenv
- Read:
    REDIS_HOST
    REDIS_PORT
    REDIS_PASSWORD
    REDIS_SSL
- Connect to Azure Cache for Redis using TLS (ssl=True when REDIS_SSL=true)
- Use decode_responses=True
- Test connection with PING and print:
    Connected to Redis
- Write current datetime (ISO format) to key:
    demo:timestamp
- Read the value back
- Print exactly:

    WROTE: <value>
    READ : <value>

- Wrap connection logic in a try/except and print a helpful error message.

5. Keep the code simple and beginner-friendly:
- Single file
- No classes
- About 40-60 lines

After editing the files:
- Show a summary of what you changed.
- Do NOT print the full file contents unless I ask.

Validación de la aplicación de Python

1. Asegúrese de que los archivos que solicitó en el aviso existan. Inspeccione visualmente los archivos para ver si tienen valores que parecen razonables.

2. Inspeccione el archivo /> y se conecta a Azure Cache for Redis. Compruebe que escribe y lee la memoria caché. Es posible que vea código similar al código siguiente:

   import os
   from datetime import datetime
   from dotenv import load_dotenv
   import redis
   
   # Load local environment variables
   load_dotenv()
   
   host = os.getenv("REDIS_HOST")
   port = int(os.getenv("REDIS_PORT", "6380"))
   password = os.getenv("REDIS_PASSWORD")
   ssl_enabled = os.getenv("REDIS_SSL", "true").lower() == "true"
   
   try:
       client = redis.Redis(
           host=host,
           port=port,
           password=password,
           ssl=ssl_enabled,
           decode_responses=True
       )
   
       # Verify connection
       client.ping()
       print("Connected to Redis")
   
       # Write current time
       now = datetime.now().isoformat()
       client.set("demo:timestamp", now)
       print(f"WROTE: {now}")
   
       # Read value back
       value = client.get("demo:timestamp")
       print(f"READ : {value}")
   
   except Exception as ex:
       print("Connection failed.")
       print(ex)
   

   Importante

   El desarrollo de software asistido por IA no es determinista, lo que significa que no se genera el mismo código dos veces. Sin embargo, en una aplicación sencilla como esta, el enfoque básico, la sintaxis y el resultado final deberían ser similares, aunque no sean idénticos.

Ejecuta la aplicación

En el terminal, ejecute la aplicación:

python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python main.py

Debería mostrarse una salida similar a esta:

Connected to Redis
WROTE: 2026-03-01T10:22:11.452331
READ : 2026-03-01T10:22:11.452331

Limpieza de recursos

Usa la siguiente indicación:

I am finished with this instance. Please remove the Azure Cache for Redis that you created earlier by using the values in the `.env` file. ONLY remove this resource and nothing else.

Contenido relacionado

• ¿Qué es GitHub Copilot para Azure?
• Inicio rápido
• Más información sobre Azure y comprender la cuenta, la suscripción y los recursos de Azure
• Diseñar y desarrollar aplicaciones para Azure
• Implementación de la aplicación en Azure
• Solución de problemas de los recursos de Azure