Quickstart: Crie e implemente uma aplicação usando o Cache do Azure para Redis usando o GitHub Copilot for Azure e o Azure MCP Server

Este quickstart mostra-lhe como criar uma aplicação Python simples que:

• Liga-se a Cache do Azure para Redis
• Escreve a data e hora atuais em Redis
• Lê o valor de volta
• Imprime o resultado na consola

Usas GitHub Copilot para gerar a maior parte do código e dos passos de provisionamento.

Pré-requisitos

Para obter instruções de configuração completas, consulte o artigo Introdução . Certifique-se de que tem os seguintes itens:

Construção da aplicação

Siga estes passos descritos neste artigo:

1. Crie um ficheiro .env no seu espaço de trabalho para armazenar a informação de implementação do Azure como variáveis de ambiente.
2. Escreve um prompt para criar uma instância de Cache do Azure para Redis na tua subscrição. A informação de ligação Redis também está armazenada no .env ficheiro.
3. Valide que o recurso e o .env ficheiro foram criados corretamente.
4. Escreva um prompt para criar uma aplicação Python para recuperar, escrever e ler da cache usando variáveis de ambiente.
5. Valida que a aplicação funciona.
6. Limpar os recursos no Azure.

Certifique-se de que tem as ferramentas certas selecionadas

Deve ter tanto o Azure MCP Server como o GitHub Copilot para Azure instalados.

Criar variáveis de ambiente local

Uma prática comum de desenvolvimento é armazenar chaves importantes e outras definições como variáveis de ambiente num .env ficheiro na pasta do seu espaço de trabalho. Isto mantém toda a configuração autónoma dentro do projeto.

Neste passo, crie um .env ficheiro no seu espaço de trabalho usando um prompt como o seguinte:

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.

Substitua <your-subscription-name> pelo nome da sua subscrição Azure. Copilot procura os IDs de subscrição e tenant por ti, gera um nome e prefixo de grupo de recursos e cria o ficheiro .env.

Depois de criado o ficheiro, abra-o e verifica se os valores estão corretos:

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>

Criar Cache do Azure para Redis

Abra o GitHub Copilot Chat e cole o seguinte prompt:

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 cria o recurso Redis e depois cria um ficheiro .env contendo o nome do host, a chave primária e as outras variáveis de ambiente.

Valide que o ficheiro .env tem as definições do Redis

1. Abre o .env ficheiro na pasta do teu projeto e valida que tem valores.

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

2. Valide que a instância Cache do Azure para Redis está a correr usando o seguinte prompt.

   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.
   

Prompt para escrever a aplicação Python

Use o seguinte prompt para criar a aplicação Python que escreve e lê a partir da nova instância do Cache do Azure para 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.

Validar a aplicação Python

1. Certifica-te de que os ficheiros que pediste no prompt existem. Inspeciona visualmente os ficheiros para ver se têm valores razoáveis.

2. Inspecione o ficheiro main.py para garantir que recupera valores do ficheiro .env, importa o pacote redis e liga-se ao Cache do Azure para Redis. Verifica se escreve e lê a cache. Pode ver código que se assemelha ao seguinte:

   
   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

   O desenvolvimento de software assistido por IA é não determinístico, o que significa que não se gera o mesmo código duas vezes. No entanto, numa aplicação simples como esta, a abordagem básica, a sintaxe e o resultado final devem ser próximos, embora não exatamente iguais.

Executar o aplicativo

No terminal, executa a aplicação:

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

Você deve ver uma saída semelhante a esta:

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

Limpeza de recursos

Use o seguinte prompt:

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.

Conteúdo relacionado

• Entenda o que é o GitHub Copilot para Azure e como ele funciona.
• Siga o quickstart para perceber como incluir GitHub Copilot para Azure no seu fluxo de trabalho de desenvolvimento de software. O quickstart descreve como implementar serviços no Azure, monitorizar o seu estado e resolver problemas.
• Veja exemplos de prompts para saber mais sobre o Azure e entender sua conta, assinatura e recursos do Azure.
• Veja exemplos de prompts para projetar e desenvolver aplicativos para o Azure.
• Veja exemplos de prompts para implantar seu aplicativo no Azure.
• Veja exemplos de prompts para solucionar problemas de seus recursos do Azure.