Início Rápido: Crie e implante um aplicativo usando o Cache do Azure para Redis com o GitHub Copilot para Azure e o Azure MCP Server

Este início rápido mostra como criar um aplicativo Python simples que:

• Conecta-se ao Cache do Azure para Redis
• Grava a data e a hora atuais no Redis
• Lê o valor de volta
• Imprime o resultado no console

Você usa GitHub Copilot para gerar a maioria das etapas de código e provisionamento.

Pré-requisitos

Para obter instruções completas de configuração, consulte o artigo Introdução. Verifique se você tem os seguintes itens:

Compilando o aplicativo

Siga estas etapas descritas neste artigo:

1. Crie um arquivo .env em seu workspace para armazenar informações de implantação Azure como variáveis de ambiente.
2. Escreva um prompt para criar uma instância de Cache do Azure para Redis em sua assinatura. As informações de conexão do Redis também são armazenadas no .env arquivo.
3. Valide se o recurso e o .env arquivo foram criados corretamente.
4. Escreva um prompt para criar um aplicativo Python para recuperar, gravar e ler do cache usando variáveis de ambiente.
5. Valide se o aplicativo funciona.
6. Limpe os recursos em Azure.

Verifique se você tem as ferramentas certas selecionadas

Você deve ter o servidor MCP Azure instalado e GitHub Copilot para Azure instalado.

Criar variáveis de ambiente local

Uma prática de desenvolvimento comum é armazenar chaves importantes e outras configurações como variáveis de ambiente em um .env arquivo na pasta do workspace. Isso mantém toda a configuração autocontida dentro do projeto.

Nesta etapa, crie um .env arquivo em seu workspace 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 assinatura de Azure. Copilot pesquisa as IDs de assinatura e de locatário para você, gera um nome e prefixo do grupo de recursos e cria o arquivo .env.

Depois que o arquivo for criado, abra-o e verifique se os valores parecem 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>

Criação de 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 cria um arquivo .env contendo o nome do host, a chave primária e as outras variáveis de ambiente.

Valide se o arquivo .env tem as configurações do Redis

1. Abra o .env arquivo na pasta do projeto e valide se ele tem valores.

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

2. Valide se a instância de Cache do Azure para Redis está em execução usando o prompt a seguir.

   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.
   

Pedir para escrever o app em Python

Use o prompt a seguir para criar o aplicativo Python que grava e lê 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 o aplicativo Python

1. Verifique se os arquivos solicitados no prompt existem. Inspecione visualmente os arquivos para ver se eles têm valores que parecem razoáveis.

2. Inspecione o arquivo main.py para garantir que ele recupere valores do arquivo .env, importe o pacote redis e conecte-se ao Cache do Azure para Redis. Verifique se ele grava e lê o cache. Você pode ver um código semelhante ao seguinte código:

   
   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 você não obtém o mesmo código gerado duas vezes. No entanto, em um aplicativo simples como este, a abordagem básica, a sintaxe e o resultado final devem estar próximos, embora não exatamente o mesmo.

Executar o aplicativo

No terminal, execute o aplicativo:

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

Você deverá ver uma saída semelhante à esta:

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

Limpar os recursos

Use o prompt a seguir:

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 funciona.
• Siga o quickstart para entender como incluir GitHub Copilot para Azure em seu fluxo de trabalho de desenvolvimento de software. O início rápido descreve como implantar serviços no Azure, monitorar seu status e solucionar problemas.
• Consulte os prompts de exemplo para aprender mais sobre o Azure e entender sua conta do Azure, assinatura e recursos.
• Confira prompts de exemplo para projetar e desenvolver aplicativos para o Azure.
• Consulte os prompts de exemplo para implantar seu aplicativo no Azure.
• Consulte os prompts de exemplo para solução de problemas de seus recursos do Azure.