Udostępnij przez

Samouczek: tworzenie czatbota przy użyciu usług Azure App Service i Azure OpenAI (Flask)

W tym samouczku utworzysz inteligentną aplikację sztucznej inteligencji, integrując usługę Azure OpenAI z aplikacją internetową w języku Python i wdrażając ją w usłudze Azure App Service. Utworzysz aplikację platformy Flask, która wysyła żądania ukończenia czatu do modelu w usłudze Azure OpenAI.

Zrzut ekranu przedstawiający czatbota uruchomionego w usłudze Azure App Service.

W tym poradniku nauczysz się, jak:

  • Utwórz zasób usługi Azure OpenAI i wdróż model językowy.
  • Utwórz aplikację platformy Flask łączącą się z usługą Azure OpenAI.
  • Wdróż aplikację w usłudze Azure App Service.
  • Zaimplementuj bezpieczne uwierzytelnianie bez hasła zarówno w środowisku projektowym, jak i na platformie Azure.

Prerequisites

1. Tworzenie zasobu usługi Azure OpenAI

W tej sekcji użyjesz usługi GitHub Codespaces do utworzenia zasobu usługi Azure OpenAI za pomocą interfejsu wiersza polecenia platformy Azure.

  1. Przejdź do usługi GitHub Codespaces i zaloguj się przy użyciu konta usługi GitHub.

  2. Znajdź pusty szablon według usługi GitHub i wybierz pozycję Użyj tego szablonu , aby utworzyć nową pustą przestrzeń kodu.

  3. W terminalu usługi Codespace zainstaluj interfejs wiersza polecenia platformy Azure:

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

  4. Zaloguj się do swojego konta platformy Azure:

    az login

    Postępuj zgodnie z instrukcjami w terminalu, aby się uwierzytelnić.

  5. Ustaw zmienne środowiskowe dla nazwy grupy zasobów, nazwy usługi Azure OpenAI i lokalizacji:

    export RESOURCE_GROUP="<group-name>"
export OPENAI_SERVICE_NAME="<azure-openai-name>"
export APPSERVICE_NAME="<app-name>"
export LOCATION="eastus2"

    Important

    Region ma kluczowe znaczenie, ponieważ jest powiązany z regionalną dostępnością wybranego modelu. Dostępność modelu i dostępność typu wdrożenia różnią się w zależności od regionu do regionu. W tym samouczku jest używany element gpt-4o-mini, który jest dostępny w eastus2 w typie wdrożenia Standardowym. W przypadku wdrożenia w innym regionie ten model może być niedostępny lub może wymagać innej warstwy. Przed zmianą regionów zapoznaj się z tabelą podsumowania modelu i dostępnością regionów , aby sprawdzić obsługę modelu w preferowanym regionie.

  6. Utwórz grupę zasobów i zasób usługi Azure OpenAI z domeną niestandardową, a następnie dodaj model 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

Teraz, gdy masz zasób usługi Azure OpenAI, utworzysz aplikację internetową do interakcji z nią.

2. Tworzenie i konfigurowanie aplikacji platformy Flask

  1. W terminalu usługi Codespace utwórz środowisko wirtualne i zainstaluj potrzebne pakiety PIP.

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

  2. W katalogu głównym obszaru roboczego utwórz app.py i skopiuj do niego następujący kod, aby wykonać proste wywołanie ukończenia czatu za pomocą Azure OpenAI.

    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()

  3. Utwórz w nim katalog szablonów i plik index.html . Skopiuj do niego następujący kod dla prostego interfejsu czatu:

    <!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>

  4. W terminalu pobierz punkt końcowy OpenAI.

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

  5. Uruchom aplikację, dodając AZURE_OPENAI_ENDPOINT z wartością uzyskaną z danych wyjściowych CLI (interfejsu wiersza polecenia):

    AZURE_OPENAI_ENDPOINT=<output-from-previous-cli-command> flask run

  6. Wybierz pozycję Otwórz w przeglądarce, aby uruchomić aplikację na nowej karcie przeglądarki. Prześlij pytanie i sprawdź, czy otrzymasz komunikat odpowiedzi.

3. Wdrażanie w usłudze Azure App Service i konfigurowanie połączenia OpenAI

Teraz, gdy aplikacja działa lokalnie, wdróżmy ją w usłudze Azure App Service i skonfigurujmy połączenie usługi z usługą Azure OpenAI przy użyciu tożsamości zarządzanej.

  1. Najpierw wdróż swoją aplikację w usłudze Azure App Service używając polecenia Azure CLI az webapp up. To polecenie tworzy nową aplikację internetową i wdraża w niej kod:

    az webapp up \
  --resource-group $RESOURCE_GROUP \
  --location $LOCATION \
  --name $APPSERVICE_NAME \
  --plan $APPSERVICE_NAME \
  --sku B1 \
  --os-type Linux \
  --track-status false

    Wykonanie tego polecenia może potrwać kilka minut. Tworzy nową aplikację internetową w tej samej grupie zasobów co zasób OpenAI.

  2. Po wdrożeniu aplikacji utwórz połączenie usługi między aplikacją internetową a zasobem usługi Azure OpenAI przy użyciu tożsamości zarządzanej:

    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

    To polecenie tworzy połączenie między aplikacją internetową a zasobem usługi Azure OpenAI przez:

    • Generowanie tożsamości zarządzanej przypisanej przez system dla aplikacji internetowej.
    • Dodanie roli Współautora OpenAI usług Cognitive Services do tożsamości zarządzanej dla zasobu Azure OpenAI.
    • Dodawanie ustawienia AZURE_OPENAI_ENDPOINT do aplikacji internetowej.

  3. Otwórz wdrożoną aplikację internetową w przeglądarce. Znajdź adres URL wdrożonej aplikacji internetowej w danych wyjściowych terminalu. Otwórz przeglądarkę internetową i przejdź do niej.

    az webapp browse

  4. Wpisz wiadomość w polu tekstowym i wybierz pozycję Wyślij, a następnie nadaj aplikacji kilka sekund na odpowiedź z komunikatem z usługi Azure OpenAI.

    Zrzut ekranu przedstawiający czatbota uruchomionego w usłudze Azure App Service.

Twoja aplikacja jest teraz wdrażana i połączona z usługą Azure OpenAI z tożsamością zarządzaną.

Najczęściej zadawane pytania

Co zrobić, jeśli chcę nawiązać połączenie z usługą OpenAI zamiast z usługą Azure OpenAI?

Aby zamiast tego nawiązać połączenie z usługą OpenAI, użyj następującego kodu:

from openai import OpenAI

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

Aby uzyskać więcej informacji, zobacz How to switch between OpenAI and Azure OpenAI endpoints with Python (Jak przełączać się między punktami końcowymi OpenAI i Azure OpenAI przy użyciu języka Python).

Pracując z tajnymi informacjami połączenia w usłudze App Service, należy używać odwołań do Key Vault zamiast przechowywania tajnych danych bezpośrednio w kodzie. Dzięki temu poufne informacje pozostają bezpieczne i są zarządzane centralnie.

Czy zamiast tego mogę nawiązać połączenie z usługą Azure OpenAI za pomocą klucza interfejsu API?

Tak, możesz nawiązać połączenie z usługą Azure OpenAI przy użyciu klucza interfejsu API zamiast tożsamości zarządzanej. Takie podejście jest obsługiwane przez zestawy SDK usługi Azure OpenAI i jądro semantyczne.

Pracując z tajnymi informacjami połączenia w usłudze App Service, należy używać odwołań do Key Vault zamiast przechowywania tajnych danych bezpośrednio w kodzie. Dzięki temu poufne informacje pozostają bezpieczne i są zarządzane centralnie.

Jak działa element DefaultAzureCredential w tym samouczku?

Upraszcza DefaultAzureCredential to uwierzytelnianie, automatycznie wybierając najlepszą dostępną metodę uwierzytelniania:

  • Podczas programowania lokalnego: po uruchomieniu az login, używa lokalnych poświadczeń CLI Azure.
  • Po wdrożeniu w usłudze Azure App Service: używa tożsamości zarządzanej aplikacji do bezpiecznego uwierzytelniania bez hasła.

Takie podejście umożliwia bezpieczne i bezproblemowe uruchamianie kodu zarówno w środowiskach lokalnych, jak i w chmurze bez modyfikacji.

Dalsze kroki

  • Last updated on