Guida introduttiva: Creare e rilasciare un'app utilizzando cache di Azure per Redis con GitHub Copilot per Azure e MCP Server di Azure.

Questa guida introduttiva illustra come creare una semplice app Python che:

• Si connette a cache di Azure per Redis
• Scrive la data e l'ora correnti in Redis
• Legge nuovamente il valore
• Stampa il risultato nella console

Si usa GitHub Copilot per generare la maggior parte del codice e dei passaggi di provisioning.

Prerequisiti

Per istruzioni complete sulla configurazione, vedere l'articolo Introduzione . Assicurarsi di disporre degli elementi seguenti:

Compilazione dell'app

Seguire questi passaggi descritti in questo articolo:

1. Creare un file .env nell'area di lavoro per archiviare le informazioni sulla distribuzione di Azure come variabili d'ambiente.
2. Scrivere un prompt per creare un'istanza di cache di Azure per Redis nella tua sottoscrizione. Le informazioni di connessione Redis vengono archiviate anche nel .env file.
3. Verificare che la risorsa e il .env file siano stati creati correttamente.
4. Scrivere un prompt per creare un'app Python per recuperare, scrivere e leggere dalla cache usando le variabili di ambiente.
5. Convalidare il funzionamento dell'app.
6. Pulire le risorse in Azure.

Assicurarsi di avere selezionato gli strumenti appropriati

È necessario che siano installati sia il server MCP di Azure sia GitHub Copilot per Azure.

Creare variabili di ambiente locali

Una pratica di sviluppo comune consiste nell'archiviare chiavi importanti e altre impostazioni come variabili di ambiente in un .env file nella cartella dell'area di lavoro. In questo modo tutte le configurazioni sono autonome all'interno del progetto.

In questo passaggio creare un .env file nell'area di lavoro usando un prompt simile al seguente:

Create a .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.

Sostituire <your-subscription-name> con il nome della sottoscrizione Azure. Copilot recupera gli ID di sottoscrizione e tenant per te, genera il nome del gruppo di risorse e il prefisso, e crea il file .env.

Dopo aver creato il file, aprirlo e verificare che i valori siano corretti:

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>

Creare cache di Azure per Redis

Aprire GitHub Copilot Chat e incollare il prompt seguente:

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 la risorsa Redis e quindi crea un file .env contenente il nome host, la chiave primaria e le altre variabili di ambiente.

Verificare che il file con estensione env abbia le impostazioni di Redis

1. Aprire il file nella cartella del .env progetto e verificare che contenga valori.

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

2. Verificare che l'istanza di cache di Azure per Redis sia in esecuzione usando il prompt seguente.

   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.
   

Comando per creare l'app Python

Usare il prompt seguente per creare l'app Python che scrive e legge dalla nuova istanza di cache di Azure per 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.

Convalidare l'app Python

1. Assicurarsi che i file richiesti nel prompt esistano. Esaminare visivamente i file per verificare se hanno valori che sembrano ragionevoli.

2. Esaminare il file main.py per assicurarsi che recuperi i valori dal file .env, importa il pacchetto redis e si connette a cache di Azure per Redis. Verificare che scriva e legga la cache. È possibile che venga visualizzato codice simile al codice seguente:

   
   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

   Lo sviluppo di software assistito dall'intelligenza artificiale non è deterministico, ovvero non si ottiene lo stesso codice generato due volte. Tuttavia, in un'applicazione semplice come questa, l'approccio di base, la sintassi e il risultato finale devono essere vicini anche se non esattamente uguali.

Eseguire l'app

Nel terminale eseguire l'app:

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

L'output dovrebbe essere simile al seguente:

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

Pulire le risorse

Immettere il prompt seguente:

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.

Contenuti correlati

• Comprendere cos'è GitHub Copilot per Azure e come funziona.
• Seguire la guida introduttiva per comprendere come includere GitHub Copilot per Azure nel flusso di lavoro di sviluppo software. La guida introduttiva descrive come distribuire i servizi in Azure, monitorarne lo stato e risolvere i problemi.
• Vedere i prompt di esempio per imparare di più su Azure e comprendere l'account Azure, la sottoscrizione e le risorse.
• Consulta i prompt di esempio per progettazione e sviluppo di applicazioni per Azure.
• Vedere i prompt di esempio per distribuire un'applicazione in Azure.
• Consulta i prompt di esempio per la risoluzione dei problemi delle risorse di Azure.