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:

Importante

GitHub Copilot é uma assinatura separada gerenciada por GitHub. Para perguntas sobre assinaturas do GitHub Copilot e suporte, consulte Começando com um plano do GitHub Copilot.

  • Uma conta do Azure e acesso a uma assinatura do Azure. Para obter detalhes sobre como configurá-los, consulte a página de preços para contas do Azure.

  • Uma conta do GitHub e uma assinatura do GitHub Copilot. Para obter detalhes sobre como configurá-los, consulte Criar uma conta no GitHub e Início Rápido para o GitHub Copilot, respectivamente.

  • Visual Studio 2022 (Qualquer edição). Para obter detalhes sobre como baixá-lo e instalá-lo, consulte Instalar Visual Studio.

Importante

GitHub Copilot é uma assinatura separada gerenciada por GitHub. Para perguntas sobre assinaturas do GitHub Copilot e suporte, consulte Começando com um plano do GitHub Copilot.

  • Uma conta do Azure e acesso a uma assinatura do Azure. Para obter detalhes sobre como configurá-los, consulte a página de preços para contas do Azure.

  • Uma conta do GitHub e uma assinatura do GitHub Copilot. Para obter detalhes sobre como configurá-los, consulte Criar uma conta no GitHub e Início Rápido para o GitHub Copilot, respectivamente.

  • Visual Studio 2026 (Qualquer edição). Para obter detalhes sobre como baixá-lo e instalá-lo, consulte Instalar Visual Studio.

Importante

GitHub Copilot é uma assinatura separada gerenciada por GitHub. Para perguntas sobre assinaturas do GitHub Copilot e suporte, consulte Começando com um plano do GitHub Copilot.

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.

  1. Selecione o ícone Configurar ferramentas... no painel de chat.
  2. As ferramentas de configuração são exibidas na Paleta de Comandos. Verifique se os nós principais para "Azure MCP" e "GitHub Copilot para Azure" estão selecionados.
  1. Selecione o ícone Selecionar ferramentas... no painel de chat.
  2. O menu Selecionar ferramentas é exibido. Verifique se o nó superior "Azure MCP Server" está selecionado.
  1. Selecione o ícone Selecionar ferramentas no painel de chat.
  2. O menu Selecionar ferramentas é exibido. Verifique se os principais nós de "Azure" e "Azure MCP" estão selecionados.

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.

Importante

Verifique se o arquivo .gitignore inclui .env para evitar enviar segredos acidentalmente ao controle de versão.

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

  • Last updated on