Tutorial: Criar um chatbot com o Serviço de Aplicativo do Azure e o Azure OpenAI (Flask)

2025-05-20

Neste tutorial, você criará um aplicativo de IA inteligente integrando o Azure OpenAI a um aplicativo Web Python e implantando-o no Serviço de Aplicativo do Azure. Você criará um aplicativo Flask que envia solicitações de conclusão de chat para um modelo no Azure OpneAI.

Captura de tela mostrando o chatbot em execução no Serviço de Aplicativo do Azure.

Neste tutorial, você aprenderá como:

Crie um recurso do Azure OpenAI e implante um modelo de linguagem.
Crie um aplicativo Flask que se conecta ao Azure OpenAI.
Implante o aplicativo no Serviço de Aplicativo do Azure.
Implemente a autenticação segura sem senha no ambiente de desenvolvimento e no Azure.

Pré-requisitos

Uma conta do Azure com uma assinatura ativa
Uma conta do GitHub para usar os Codespaces do GitHub

1. Criar um recurso do Azure OpenAI

Nesta seção, você usará os Codespaces do GitHub para criar um recurso do Azure OpenAI com a CLI do Azure.

Acesse os Codespaces do GitHub e entre com sua conta do GitHub.
Localize o modelo em branco pelo GitHub e selecione Usar este modelo para criar um novo Codespace em branco.

No terminal do Codespace, instale a CLI do Azure:

curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

Entre na sua conta do Azure:
```
az login
```
Siga as instruções no terminal para autenticar.
Defina variáveis de ambiente para o nome do grupo de recursos, o nome do serviço do Azure OpenAI e a localização:
```
export RESOURCE_GROUP="<group-name>"
export OPENAI_SERVICE_NAME="<azure-openai-name>"
export APPSERVICE_NAME="<app-name>"
export LOCATION="eastus2"
```
Importante

A região é crítica, pois está vinculada à disponibilidade regional do modelo escolhido. A disponibilidade do modelo e a disponibilidade do tipo de implantação variam de região para região. Este tutorial usa gpt-4o-mini, que está disponível em eastus2 no tipo de implantação Standard. Se você implantar em uma região diferente, esse modelo pode não estar disponível ou pode exigir uma camada diferente. Antes de alterar as regiões, consulte a tabela de resumo do modelo e a disponibilidade da região para verificar o suporte ao modelo em sua região preferida.

Crie um grupo de recursos e um recurso do Azure OpenAI com um domínio personalizado e adicione um modelo gpt-4o-mini:

# Resource group
az group create --name $RESOURCE_GROUP --location $LOCATION
# Azure OpenAI resource
az cognitiveservices account create \
  --name $OPENAI_SERVICE_NAME \
  --resource-group $RESOURCE_GROUP \
  --location $LOCATION \
  --custom-domain $OPENAI_SERVICE_NAME \
  --kind OpenAI \
  --sku s0
# gpt-4o-mini model
az cognitiveservices account deployment create \
  --name $OPENAI_SERVICE_NAME \
  --resource-group $RESOURCE_GROUP \
  --deployment-name gpt-4o-mini \
  --model-name gpt-4o-mini \
  --model-version 2024-07-18 \
  --model-format OpenAI \
  --sku-name Standard \
  --sku-capacity 1
# Cognitive Services OpenAI User role that lets the signed in Azure user to read models from Azure OpenAI
az role assignment create \
  --assignee $(az ad signed-in-user show --query id -o tsv) \
  --role "Cognitive Services OpenAI User" \
  --scope /subscriptions/$(az account show --query id -o tsv)/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.CognitiveServices/accounts/$OPENAI_SERVICE_NAME

Agora que você tem um recurso do Azure OpenAI, criará um aplicativo Web para interagir com ele.

2. Criar e configurar um aplicativo Flask

No terminal do codespace, crie um ambiente virtual e instale os pacotes PIP necessários.

python3 -m venv .venv
source .venv/bin/activate
pip install flask openai azure.identity dotenv
pip freeze > requirements.txt

Na raiz do workspace, crie um app.py e copie o código a seguir para uma chamada de conclusão de chat simples com o OpenAI do Azure.

import os
from flask import Flask, render_template, request
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import AzureOpenAI

app = Flask(__name__)

# Initialize the Azure OpenAI client with Microsoft Entra authentication
token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://cognitiveservices.azure.com/.default"
)
client = AzureOpenAI(
    api_version="2024-10-21",
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
    azure_ad_token_provider=token_provider,
)

@app.route('/', methods=['GET', 'POST'])
def index():
    response = None
    if request.method == 'POST': # Handle form submission
        user_message = request.form.get('message')
        if user_message:
            try:
                # Call the Azure OpenAI API with the user's message
                completion = client.chat.completions.create(
                    model="gpt-4o-mini",
                    messages=[{"role": "user", "content": user_message}]
                )
                ai_message = completion.choices[0].message.content
                response = ai_message
            except Exception as e:
                response = f"Error: {e}"
    return render_template('index.html', response=response)

if __name__ == '__main__':
    app.run()

Crie um diretório de modelos e um arquivo index.html nele. Copie o seguinte código para uma interface de chat simples:

<!doctype html>
<html>
<head>
    <title>Azure OpenAI Chat</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">
</head>
<body>
    <main class="container py-4">
        <h1 class="mb-4 text-primary">Azure OpenAI Chat</h1>
        <form method="post" action="/" class="mb-3">
            <div class="input-group">
                <input type="text" name="message" class="form-control" placeholder="Type your message..." required>
                <button type="submit" class="btn btn-primary">Send</button>
            </div>
        </form>
        <div class="card p-3">
            {% if response %}
                <div class="alert alert-info mt-3">{{ response }}</div>
            {% endif %}
        </div>
    </main>
</body>
</html>

No terminal, recupere o ponto de extremidade do OpenAI:

az cognitiveservices account show \
  --name $OPENAI_SERVICE_NAME \
  --resource-group $RESOURCE_GROUP \
  --query properties.endpoint \
  --output tsv

Execute o aplicativo adicionando AZURE_OPENAI_ENDPOINT com seu valor da saída da CLI:
```
AZURE_OPENAI_ENDPOINT=<output-from-previous-cli-command> flask run
```
Selecione Abrir no navegador para iniciar o aplicativo em uma nova guia do navegador. Envie uma pergunta e veja se você recebe uma mensagem de resposta.

3. Implantar no Serviço de Aplicativo do Azure e configurar a conexão OpenAI

Agora que seu aplicativo funciona localmente, vamos implantá-lo no Serviço de Aplicativo do Azure e configurar uma conexão de serviço com o Azure OpenAI usando a identidade gerenciada.

Primeiro, implante seu aplicativo no Serviço de Aplicativo do Azure usando o comando az webapp upda CLI do Azure. Esse comando cria um novo aplicativo Web e implanta seu código nele:
```
az webapp up \
  --resource-group $RESOURCE_GROUP \
  --location $LOCATION \
  --name $APPSERVICE_NAME \
  --plan $APPSERVICE_NAME \
  --sku B1 \
  --os-type Linux \
  --track-status false
```
Esse comando pode levar alguns minutos para ser concluído. Ele cria um novo aplicativo Web no mesmo grupo de recursos que o recurso OpenAI.
Depois que o aplicativo for implantado, crie uma conexão de serviço entre seu aplicativo Web e o recurso do Azure OpenAI usando a identidade gerenciada:
```
az webapp connection create cognitiveservices \
  --resource-group $RESOURCE_GROUP \
  --name $APPSERVICE_NAME \
  --target-resource-group $RESOURCE_GROUP \
  --account $OPENAI_SERVICE_NAME \
  --connection azure-openai \
  --system-identity
```
Esse comando cria uma conexão entre seu aplicativo Web e o recurso do Azure OpenAI:
- Gerando identidade gerenciada atribuída pelo sistema para o aplicativo Web.
- Adicionando a função de Colaborador de OpenAI dos Serviços Cognitivos à identidade gerenciada para o recurso da OpenAI do Azure.
- Adicionando a configuração de aplicativo AZURE_OPENAI_ENDPOINT ao seu aplicativo web.
Abra o aplicativo Web implantado no navegador. Localize a URL do aplicativo Web implantado na saída do terminal. Abra o navegador da Web e navegue até ele.
```
az webapp browse
```
Digite uma mensagem na caixa de texto e selecione "Enviar e dê ao aplicativo alguns segundos para responder com a mensagem do Azure OpenAI.

Seu aplicativo agora está implantado e conectado ao Azure OpenAI com identidade gerenciada.

Perguntas frequentes

E se eu quiser me conectar ao OpenAI em vez do Azure OpenAI?
Posso me conectar ao Azure OpenAI com uma chave de API?
Como o DefaultAzureCredential funciona neste tutorial?

E se eu quiser me conectar ao OpenAI em vez do Azure OpenAI?

Para se conectar ao OpenAI, use o seguinte código:

from openai import OpenAI

client = OpenAI(
    api_key="<openai-api-key>"
)

Para obter mais informações, consulte Como alternar entre pontos de extremidade OpenAI e OpenAI do Azure com Python.

Ao trabalhar com segredos de conexão no Serviço de Aplicativo, você deve usar referências do Key Vault em vez de armazenar segredos diretamente em sua base de código. Isso garante que as informações confidenciais permaneçam seguras e sejam gerenciadas centralmente.

Posso me conectar ao OpenAI do Azure com uma chave de API?

Sim, você pode se conectar ao Azure OpenAI usando uma chave de API em vez de uma identidade gerenciada. Essa abordagem é compatível com os SDKs do Azure OpenAI e o Kernel Semântico.

Para obter detalhes sobre como usar chaves de API com Kernel Semântico: C# Início Rápido do Kernel Semântico.
Para obter detalhes sobre como usar chaves de API com a biblioteca de clientes do Azure OpenAI: Início Rápido: Introdução ao uso de conclusões de chat com o Serviço OpenAI do Azure.

Como o DefaultAzureCredential funciona neste tutorial?

O DefaultAzureCredential simplifica a autenticação selecionando automaticamente o melhor método de autenticação disponível.

Durante o desenvolvimento local: depois de executar az login, ele usa as credenciais da CLI local do Azure.
Quando implantado no Serviço de Aplicativo do Azure: ele usa a identidade gerenciada do aplicativo para autenticação segura e sem senha.

Essa abordagem permite que seu código seja executado de forma segura e direta em ambientes locais e de nuvem sem modificação.

Compartilhar via