Tutorial: Hinzufügen von Hinweisen zur Azure OpenAI-Textvervollständigung zu Ihren Funktionen in Visual Studio Code

  • Artikel

In diesem Artikel wird gezeigt, wie Sie Visual Studio Code verwenden, um der Funktions-App, die Sie im vorherigen Schnellstartartikel erstellt haben, einen HTTP-Endpunkt hinzuzufügen. Wenn ausgelöst, verwendet dieser neue HTTP-Endpunkt eine Eingabebindung für die Azure OpenAI-Textvervollständigung, um Hinweise zur Textvervollständigung aus Ihrem Datenmodell abzurufen.

In diesem Tutorial erfahren Sie, wie Sie diese Aufgaben ausführen:

  • Erstellen von Ressourcen in Azure OpenAI.
  • Bereitstellen eines Modells in der OpenAI-Ressource.
  • Festlegen von Zugriffsberechtigungen für die Modellressource.
  • Aktivieren Ihrer Funktions-App, um eine Verbindung mit OpenAI herzustellen.
  • Hinzufügen von OpenAI-Bindungen zu Ihrer ausgelösten HTTP-Funktion.

1. Überprüfen der Voraussetzungen

  • Verschaffen Sie sich Zugriff auf Azure OpenAI in Ihrem Azure-Abonnement. Wenn Ihnen noch kein Zugriff gewährt wurde, füllen Sie dieses Formular aus, um Zugriff anzufordern.
  • Azurite-Speicheremulator. Sie können auch ein tatsächliches Azure-Speicherkonto verwenden, aber in diesem Artikel wird davon ausgegangen, dass Sie diesen Emulator verwenden.

2. Erstellen Ihrer Azure OpenAI-Ressourcen

Die folgenden Schritte zeigen, wie Sie ein Azure OpenAI-Datenmodell im Azure-Portal erstellen.

  1. Melden Sie sich mit Ihrem Azure-Abonnement im Azure-Portal an.

  2. Wählen Sie Ressource erstellen aus, und suchen Sie nach Azure OpenAI. Wenn Sie den Dienst gefunden haben, wählen Sie Erstellen aus.

  3. Geben Sie auf der Seite Azure OpenAI-Ressource erstellen die folgenden Informationen für die Felder auf der Registerkarte Grundlagen an:

    Feld BESCHREIBUNG
    Abonnement Ihr Abonnement, das für die Verwendung von Azure OpenAI integriert wurde.
    Ressourcengruppe Die Ressourcengruppe, die Sie im vorherigen Artikel für die Funktions-App erstellt haben. Sie finden diesen Ressourcengruppennamen, indem Sie im Azure-Ressourcen-Browser mit der rechten Maustaste auf die Funktions-App klicken, „Eigenschaften“ auswählen und dann in der zurückgegebenen JSON-Ressourcendatei nach der Einstellung resourceGroup suchen.
    Region Im Idealfall im gleichen Speicherort wie die Funktions-App.
    Name Ein aussagekräftiger Name für Ihre Azure OpenAI Service-Ressource, z. B. mySampleOpenAI.
    Tarif Der Tarif für die Ressource. Derzeit ist nur der Tarif „Standard“ für Azure OpenAI Service verfügbar. Weitere Informationen zum Preis finden Sie auf der Preisseite zu Azure OpenAI.

    Screenshot: Konfigurieren einer Azure OpenAI-Ressource im Azure-Portal

  4. Wählen Sie zweimal Weiter aus, um die Standardwerte für die Registerkarten Netzwerk und Tags zu akzeptieren. Der von Ihnen erstellte Dienst hat keine Netzwerkeinschränkungen, auch nicht für das Internet.

  5. Wählen Sie ein letztes Mal Weiter aus, um zur letzten Phase des Prozesses zu wechseln: Überprüfen und übermitteln.

  6. Überprüfen Sie Ihre Konfigurationseinstellungen, und wählen Sie Erstellen aus.

    Im Azure-Portal wird eine Benachrichtigung angezeigt, wenn die neue Ressource verfügbar ist. Wählen Sie in der Benachrichtigung Zur Ressource wechseln aus, oder suchen Sie anhand des Namens nach Ihrer neuen Azure OpenAI-Ressource.

  7. Wählen Sie auf der Azure OpenAI-Ressourcenseite für Ihre neue Ressource unter Zusammenfassung>Endpunkte die Option Klicken Sie hier, um Endpunkte anzuzeigen aus. Kopieren Sie die Endpunkt-URL und die Schlüssel. Speichern Sie diese Werte, Sie benötigen sie später.

Nachdem Sie nun über die Anmeldeinformationen zum Herstellen einer Verbindung mit Ihrem Modell in Azure OpenAI verfügen, müssen Sie diese Zugriffsanmeldeinformationen in den Anwendungseinstellungen festlegen.

3. Bereitstellen eines Modells

Jetzt können Sie ein Modell bereitstellen. Sie können eines von mehreren verfügbaren Modellen in Azure OpenAI Studio auswählen.

Gehen Sie folgendermaßen vor, um ein Modell bereitzustellen:

  1. Melden Sie sich bei Azure OpenAI Studio an.

  2. Wählen Sie das Abonnement und die Azure OpenAI-Ressource aus, die Sie erstellt haben, und wählen Sie Ressource verwenden aus.

  3. Wählen Sie unter Verwaltung die Option Bereitstellungen aus.

  4. Wählen Sie Neue Bereitstellung erstellen aus, und konfigurieren Sie die folgenden Felder:

    Feld Beschreibung
    Bereitstellungsname Wählen Sie den Namen sorgfältig aus. Der Bereitstellungsname wird in Ihrem Code verwendet, um das Modell mithilfe der Clientbibliotheken und der REST-APIs aufzurufen. Daher müssen Sie ihn für eine spätere Verwendung speichern.
    Modell auswählen Die Modellverfügbarkeit variiert je nach Region. Eine Liste der verfügbaren Modelle pro Region finden Sie unter Tabelle mit Modellzusammenfassung und Regionsverfügbarkeit.

    Wichtig

    Wenn Sie über die API auf das Modell zugreifen, müssen Sie in API-Aufrufen auf den Bereitstellungsnamen und nicht auf den zugrunde liegenden Modellnamen verweisen. Dies ist einer der wichtigsten Unterschiede zwischen OpenAI und Azure OpenAI. OpenAI erfordert nur den Modellnamen. Azure OpenAI erfordert immer den Bereitstellungsnamen, auch wenn der model-Parameter verwendet wird. In unserer Dokumentation gibt es häufig Beispiele, in denen die Bereitstellungsnamen mit den Modellnamen identisch sind, um zu verdeutlichen, welches Modell mit einem bestimmten API-Endpunkt funktioniert. Letztendlich können Ihre Bereitstellungsnamen der Benennungskonvention folgen, die für Ihren Anwendungsfall am besten geeignet ist.

  5. Übernehmen Sie bei den restlichen Einstellungen die Standardwerte, und klicken Sie auf Erstellen.

    In der Bereitstellungstabelle wird ein neuer Eintrag angezeigt, der dem neu erstellten Modell entspricht.

Sie haben jetzt alles, was Sie zum Hinzufügen von Azure OpenAI-basierten Textvervollständigungen zu Ihrer Funktions-App benötigen.

4. Aktualisieren der Anwendungseinstellungen

  1. Öffnen Sie in Visual Studio Code das lokale Codeprojekt, das Sie erstellt haben, als Sie den vorherigen Artikel bearbeitet haben.

  2. Aktualisieren Sie in der Datei „local.settings.json“ im Projektstammordner die Einstellung AzureWebJobsStorage auf UseDevelopmentStorage=true. Sie können diesen Schritt überspringen, wenn die Einstellung AzureWebJobsStorage in der Datei local.settings.json auf die Verbindungszeichenfolge für ein vorhandenes Azure Storage-Konto statt auf UseDevelopmentStorage=true festgelegt ist.

  3. Fügen Sie in der Datei „local.settings.json“ die folgenden Einstellungswerte hinzu:

    • AZURE_OPENAI_ENDPOINT: erforderlich für die Bindungserweiterung. Legen Sie diesen Wert auf den Endpunkt der zuvor erstellten Azure OpenAI-Ressource fest.
    • AZURE_OPENAI_KEY: erforderlich für die Bindungserweiterung. Legen Sie diesen Wert auf den Schlüssel für die Azure OpenAI-Ressource fest.
    • CHAT_MODEL_DEPLOYMENT_NAME: wird verwendet, um die Eingabebindung zu definieren. Legen Sie diesen Wert auf den Namen fest, den Sie für die Modellbereitstellung ausgewählt haben.

  4. Speichern Sie die Datei . Wenn Sie eine Bereitstellung in Azure vornehmen, müssen Sie diese Einstellungen auch Ihrer Funktions-App hinzufügen.

5. Registrieren von Bindungserweiterungen

Da Sie eine Azure OpenAI-Ausgabebindung verwenden, müssen Sie vor dem Ausführen des Projekts die entsprechende Bindungserweiterung installieren.

Mit Ausnahme von HTTP- und Timertriggern werden Bindungen als Erweiterungspakete implementiert. Um das Azure OpenAI-Erweiterungspaket zu Ihrem Projekt hinzuzufügen, führen Sie den Befehl dotnet add package im Terminalfenster aus:

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.OpenAI --prerelease

5. Aktualisieren des Erweiterungspakets

Um auf die Vorschau der Azure OpenAI-Bindungen zuzugreifen, müssen Sie eine Vorschauversion des Erweiterungspakets verwenden, das diese Erweiterung enthält.

Ersetzen Sie die Einstellung extensionBundle in Ihrer aktuellen Datei host.json durch diesen JSON-Code:

 "extensionBundle": {
   "id": "Microsoft.Azure.Functions.ExtensionBundle.Preview",
   "version": "[4.*, 5.0.0)"
 }

Jetzt können Sie die Azure OpenAI-Ausgabebindung in Ihrem Projekt verwenden.

6. Zurückgeben der Textvervollständigung aus dem Modell

Der von Ihnen hinzugefügte Code erstellt einen whois-HTTP-Funktionsendpunkt in Ihrem vorhandenen Projekt. In dieser Funktion werden Daten verwendet, die in einem name-URL-Parameter einer GET-Anforderung übergeben werden, um dynamisch einen Vervollständigungs-Prompt zu erstellen. Dieser dynamische Prompt ist an eine Eingabebindung für Textvervollständigen gebunden, die eine Antwort vom Modell basierend auf dem Prompt zurückgibt. Die Vervollständigung aus dem Modell wird in der HTTP-Antwort zurückgegeben.

  1. Fügen Sie in der vorhandenen HttpExample-Klassendatei diese using-Anweisung hinzu:

    using Microsoft.Azure.Functions.Worker.Extensions.OpenAI.TextCompletion;

  2. Fügen Sie in derselben Datei diesen Code hinzu, der einen neuen HTTP-Triggerendpunkt namens whois definiert:

    [Function(nameof(WhoIs))]
public IActionResult WhoIs([HttpTrigger(AuthorizationLevel.Function, Route = "whois/{name}")] HttpRequest req,
[TextCompletionInput("Who is {name}?", Model = "%CHAT_MODEL_DEPLOYMENT_NAME%")] TextCompletionResponse response)
{
    if(!String.IsNullOrEmpty(response.Content))
    {
        return new OkObjectResult(response.Content);
    }
    else
    {
        return new NotFoundObjectResult("Something went wrong.");
    }
}

  1. Aktualisieren Sie die Projektdatei pom.xml, um diesen Verweis auf die Sammlung properties hinzuzufügen:

    <azure-functions-java-library-openai>0.4.0-preview</azure-functions-java-library-openai>

  2. Fügen Sie in derselben Datei diese Abhängigkeit zur Sammlung dependencies hinzu:

    <dependency>
    <groupId>com.microsoft.azure.functions</groupId>
    <artifactId>azure-functions-java-library-openai</artifactId>
    <version>${azure-functions-java-library-openai}</version>
</dependency>

  3. Fügen Sie in der vorhandenen Projektdatei Function.java die folgenden import-Anweisungen hinzu:

    import com.microsoft.azure.functions.openai.annotation.textcompletion.TextCompletion;
import com.microsoft.azure.functions.openai.annotation.textcompletion.TextCompletionResponse;

  4. Fügen Sie in derselben Datei diesen Code hinzu, der einen neuen HTTP-Triggerendpunkt namens whois definiert:

    @FunctionName("WhoIs")
public HttpResponseMessage whoIs(
    @HttpTrigger(
        name = "req", 
        methods = {HttpMethod.GET},
        authLevel = AuthorizationLevel.ANONYMOUS, 
        route = "whois/{name}") 
        HttpRequestMessage<Optional<String>> request,
    @BindingName("name") String name,
    @TextCompletion(prompt = "Who is {name}?", model = "%CHAT_MODEL_DEPLOYMENT_NAME%", name = "response") TextCompletionResponse response,
    final ExecutionContext context) {
    return request.createResponseBuilder(HttpStatus.OK)
        .header("Content-Type", "application/json")
        .body(response.getContent())
        .build();
}

  1. Drücken Sie in Visual Studio Code F1, und geben Sie in der Befehlspalette Azure Functions: Create Function... ein, wählen Sie HTTP-Trigger aus, geben Sie den Funktionsnamen whois ein, und drücken Sie die EINGABETASTE.

  2. Ersetzen Sie in der neuen Codedatei whois.js den Inhalt der Datei durch diesen Code:

    const { app, input } = require("@azure/functions");

// This OpenAI completion input requires a {name} binding value.
const openAICompletionInput = input.generic({
    prompt: 'Who is {name}?',
    maxTokens: '100',
    type: 'textCompletion',
    model: '%CHAT_MODEL_DEPLOYMENT_NAME%'
})

app.http('whois', {
    methods: ['GET'],
    route: 'whois/{name}',
    authLevel: 'function',
    extraInputs: [openAICompletionInput],
    handler: async (_request, context) => {
        var response = context.extraInputs.get(openAICompletionInput)
        return { body: response.content.trim() }
    }
});

  1. Drücken Sie in Visual Studio Code F1, und geben Sie in der Befehlspalette Azure Functions: Create Function... ein, wählen Sie HTTP-Trigger aus, geben Sie den Funktionsnamen whois ein, und drücken Sie die EINGABETASTE.

  2. Ersetzen Sie in der neuen Codedatei whois.ts den Inhalt der Datei durch diesen Code:

    import { app, input } from "@azure/functions";

// This OpenAI completion input requires a {name} binding value.
const openAICompletionInput = input.generic({
    prompt: 'Who is {name}?',
    maxTokens: '100',
    type: 'textCompletion',
    model: '%CHAT_MODEL_DEPLOYMENT_NAME%'
})

app.http('whois', {
    methods: ['GET'],
    route: 'whois/{name}',
    authLevel: 'function',
    extraInputs: [openAICompletionInput],
    handler: async (_request, context) => {
        var response: any = context.extraInputs.get(openAICompletionInput)
        return { body: response.content.trim() }
    }
});

  1. Fügen Sie in der vorhandenen Projektdatei function_app.py diese import-Anweisung hinzu:

    import json

  2. Fügen Sie in derselben Datei diesen Code hinzu, der einen neuen HTTP-Triggerendpunkt namens whois definiert:

    @app.route(route="whois/{name}", methods=["GET"])
@app.text_completion_input(arg_name="response", prompt="Who is {name}?", max_tokens="100", model = "%CHAT_MODEL_DEPLOYMENT_NAME%")
def whois(req: func.HttpRequest, response: str) -> func.HttpResponse:
    response_json = json.loads(response)
    return func.HttpResponse(response_json["content"], status_code=200)


@app.route(route="genericcompletion", methods=["POST"])
@app.text_completion_input(arg_name="response", prompt="{Prompt}", model = "%CHAT_MODEL_DEPLOYMENT_NAME%")
def genericcompletion(req: func.HttpRequest, response: str) -> func.HttpResponse:
    response_json = json.loads(response)
    return func.HttpResponse(response_json["content"], status_code=200)

  1. Drücken Sie in Visual Studio Code F1, und geben Sie in der Befehlspalette Azure Functions: Create Function... ein, wählen Sie HTTP-Trigger aus, geben Sie den Funktionsnamen whois ein, wählen Sie Anonym aus, und drücken Sie die EINGABETASTE.

  2. Öffnen Sie die neue Codedatei whois/function.json, und ersetzen Sie den Inhalt durch diesen Code, der eine Definition für die Eingabebindung TextCompletionResponse hinzufügt:

    {
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "route": "whois/{name}",
      "methods": [
        "get"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    },
    {
      "type": "textCompletion",
      "direction": "in",
      "name": "TextCompletionResponse",
      "prompt": "Who is {name}?",
      "maxTokens": "100",
      "model": "%CHAT_MODEL_DEPLOYMENT_NAME%"
    }
  ]
}

  3. Ersetzen Sie den Inhalt der Codedatei whois/run.ps1 durch diesen Code, der die Antwort auf die Eingabebindung zurückgibt:

    using namespace System.Net

param($Request, $TriggerMetadata, $TextCompletionResponse)

Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
        StatusCode = [HttpStatusCode]::OK
        Body       = $TextCompletionResponse.Content
    })

7. Ausführen der Funktion

  1. Drücken Sie in Visual Studio Code F1, und geben Sie in der Befehlspalette Azurite: Start ein, und drücken Sie die EINGABETASTE, um den Azurite-Speicheremulator zu starten.

  2. Drücken Sie F5, um das Funktions-App-Projekt und die Core Tools im Debugmodus zu starten.

  3. Wenn die Core Tools ausgeführt werden, senden Sie eine GET-Anforderung an die Endpunktfunktion whois mit einem Namen im Pfad, z. B. diese URL:

    http://localhost:7071/api/whois/<NAME>

    Ersetzen Sie die Zeichenfolge <NAME> durch den Wert, den Sie an den Prompt "Who is {name}?" übergeben möchten. <NAME> muss der URL-codierte Name einer öffentlichen Figur sein, z. B. Abraham%20Lincoln.

    Die angezeigte Antwort ist die Antwort zur Textvervollständigung Ihres Azure OpenAI-Modells.

  4. Drücken Sie nach der Rückgabe einer Antwort STRG+C, um Core Tools zu beenden.

8. Bereinigen von Ressourcen

In Azure wird die Bezeichnung Ressourcen für Funktions-Apps, Funktionen, Speicherkonten usw. verwendet. Sie werden in Ressourcengruppen zusammengefasst, und sämtliche Inhalte einer Gruppe können durch das Löschen der Gruppe gelöscht werden.

Im Rahmen dieser Schnellstartanleitungen haben Sie Ressourcen erstellt. Für diese Ressourcen können je nach Kontostatus und Dienstpreisen Kosten anfallen. Nicht mehr benötigte Ressourcen können wie folgt gelöscht werden:

  1. Drücken Sie in Visual Studio Code F1, um die Befehlspalette zu öffnen. Suchen Sie in der Befehlspalette den Befehl Azure: Open in portal, und wählen Sie ihn aus.

  2. Wählen Sie Ihre Funktions-App aus, und drücken Sie die EINGABETASTE. Die Seite der Funktions-App wird im Azure-Portal geöffnet.

  3. Wählen Sie auf der Registerkarte Übersicht den benannten Link neben Ressourcengruppe aus.

    Screenshot: Auswählen der Ressourcengruppe, die von der Funktions-App-Seite gelöscht werden soll.

  4. Überprüfen Sie auf der Seite Ressourcengruppe die Liste mit den enthaltenen Ressourcen, und vergewissern Sie sich, dass es sich dabei um die Ressourcen handelt, die Sie löschen möchten.

  5. Klicken Sie auf Ressourcengruppe löschen, und folgen Sie den Anweisungen.

    Der Löschvorgang kann einige Minuten dauern. Nach Abschluss des Vorgangs wird kurz eine Benachrichtigung angezeigt. Sie können auch am oberen Seitenrand auf das Glockensymbol klicken, um die Benachrichtigung anzuzeigen.

Zugehöriger Inhalt