Snabbstart: Skapa och distribuera en app med hjälp av Azure Cache for Redis med hjälp av GitHub Copilot för Azure och Azure MCP Server

Den här snabbstarten visar hur du skapar en enkel Python app som:

• Ansluter till Azure Cache for Redis
• Skriver aktuellt datum och tid till Redis
• Läser tillbaka värdet
• Skriver ut resultatet till konsolen

Du använder GitHub Copilot för att generera de flesta kod- och etableringsstegen.

Förutsättningar

Fullständiga installationsinstruktioner finns i artikeln Kom igång. Kontrollera att du har följande objekt:

Skapa appen

Följ de här stegen som beskrivs i den här artikeln:

1. Skapa en .env-fil på arbetsytan för att lagra Azure distributionsinformation som miljövariabler.
2. Skriv en uppmaning om att skapa en instans av Azure Cache for Redis i din prenumeration. Redis-anslutningsinformationen lagras också i .env filen.
3. Kontrollera att resursen .env och filen har skapats korrekt.
4. Skriv en uppmaning om att skapa en Python app för att hämta, skriva och läsa från cachen med hjälp av miljövariabler.
5. Verifiera att appen fungerar.
6. Rensa resurserna i Azure.

Se till att du har valt rätt verktyg

Du måste ha både Azure MCP Server installerat och GitHub Copilot för Azure installerat.

Skapa lokala miljövariabler

En vanlig utvecklingspraxis är att lagra viktiga nycklar och andra inställningar som miljövariabler i en .env fil i arbetsytans mapp. Detta behåller all konfiguration fristående i projektet.

I det här steget skapar du en .env fil på arbetsytan med hjälp av en uppmaning som liknar följande:

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.

Ersätt <your-subscription-name> med namnet på din Azure-prenumeration. Copilot söker efter prenumerations- och klientorganisations-ID:t åt dig, genererar ett resursgruppsnamn och prefix och skapar filen .env.

När filen har skapats öppnar du den och kontrollerar att värdena ser korrekta ut:

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>

Skapa Azure Cache for Redis

Öppna GitHub Copilot Chat och klistra in följande fråga:

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 skapar Redis-resursen och skapar sedan en .env fil som innehåller värdnamnet, primärnyckeln och de andra miljövariablerna.

Kontrollera att .env-filen har Redis-inställningarna

1. Öppna filen i projektmappen .env och kontrollera att den har värden.

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

2. Kontrollera att Azure Cache for Redis-instansen körs med hjälp av följande kommando.

   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.
   

Uppmaning att skriva Python-appen

Använd följande uppmaning för att skapa den Python app som skriver och läser från den nya instansen av 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.

Validera Python-appen

1. Kontrollera att de filer som du begärde i prompten finns. Granska filerna visuellt för att se om de har värden som verkar rimliga.

2. Granska filen main.py för att se till att den hämtar värden från filen .env, importerar paketet redis och ansluter till Azure Cache for Redis. Kontrollera att den skriver och läser cacheminnet. Du kan se kod som liknar följande kod:

   
   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)
   

   Important

   AI-assisterad programvaruutveckling är icke-deterministisk, vilket innebär att du inte får samma kod genererad två gånger. Men i ett enkelt program som det här bör den grundläggande metoden, syntaxen och slutresultatet vara nära men inte exakt samma.

Kör appen

Kör appen i terminalen:

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

Du bör se utdata som liknar följande:

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

Rensa resurser

Använd följande fråga:

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.

Relaterat innehåll

• Förstå vad GitHub Copilot för Azure är och hur det fungerar.
• Följ quickstart för att förstå hur du inkluderar GitHub Copilot för Azure i arbetsflödet för programvaruutveckling. Snabbstarten beskriver hur du distribuerar tjänster till Azure, övervakar deras status och felsöker problem.
• Se exempeluppmaningar för att lära dig mer om Azure och förstå ditt Azure-konto, din prenumeration och dina resurser.
• Se exempelfrågor för design och utveckling av program för Azure.
• Se exempelprompter för distribuera ditt program till Azure.
• Se exempelkommandon för felsökning av dina Azure-resurser.