Självstudie: Lägga till tips om att slutföra Azure OpenAI-text i dina funktioner i Visual Studio Code

Den här artikeln visar hur du använder Visual Studio Code för att lägga till en HTTP-slutpunkt i funktionsappen som du skapade i föregående snabbstartsartikel. När den här nya HTTP-slutpunkten utlöses använder den en indatabindning i Azure OpenAI för att få tips om textkomplettering från datamodellen.

Under den här självstudien får du lära dig hur du utför följande uppgifter:

• Skapa resurser i Azure OpenAI.
• Distribuera en modell i OpenAI-resursen.
• Ange åtkomstbehörigheter till modellresursen.
• Aktivera funktionsappen för att ansluta till OpenAI.
• Lägg till OpenAI-bindningar till din HTTP-utlösta funktion.

1. Kontrollera kraven

• Slutför stegen i del 1 i Visual Studio Code-snabbstarten.

• Slutför stegen i del 1 i Visual Studio Code-snabbstarten.

• Slutför stegen i del 1 i Visual Studio Code-snabbstarten.

• Slutför stegen i del 1 i Visual Studio Code-snabbstarten.

• Slutför stegen i del 1 i Visual Studio Code-snabbstarten.

• Slutför stegen i del 1 i Visual Studio Code-snabbstarten.

• Få åtkomst till Azure OpenAI i din Azure-prenumeration. Om du inte redan har beviljats åtkomst fyller du i det här formuläret för att begära åtkomst.

• Installera .NET Core CLI-verktyg.

• Azurite Storage-emulatorn. Även om du också kan använda ett verkligt Azure Storage-konto förutsätter artikeln att du använder den här emulatorn.

2. Skapa dina Azure OpenAI-resurser

Följande steg visar hur du skapar en Azure OpenAI-datamodell i Azure-portalen.

1. Logga in med din Azure-prenumeration i Azure-portalen.

2. Välj Skapa en resurs och sök efter Azure OpenAI. När du hittar tjänsten väljer du Skapa.

3. På sidan Skapa Azure OpenAI anger du följande information för fälten på fliken Grundläggande :

   Fält	beskrivning
   Abonnemang	Din prenumeration, som har registrerats för att använda Azure OpenAI.
   Resursgrupp	Den resursgrupp som du skapade för funktionsappen i föregående artikel. Du hittar det här resursgruppens namn genom att högerklicka på funktionsappen i Webbläsaren Azure-resurser, välja egenskaper och sedan söka resourceGroup efter inställningen i den returnerade JSON-resursfilen.
   Region	Helst samma plats som funktionsappen.
   Namn	Ett beskrivande namn för din Azure OpenAI Service-resurs, till exempel mySampleOpenAI.
   Prisnivå	Prisnivån för resursen. För närvarande är endast standardnivån tillgänglig för Azure OpenAI-tjänsten. Mer information om priser finns på prissättningssidan för Azure OpenAI

   

4. Välj Nästa två gånger för att acceptera standardvärdena för flikarna Nätverk och Taggar . Tjänsten du skapar har inga nätverksbegränsningar, inklusive från Internet.

5. Välj Nästa sista gång för att gå vidare till det sista steget i processen: Granska + skicka.

6. Bekräfta konfigurationsinställningarna och välj Skapa.

   Azure-portalen visar ett meddelande när den nya resursen är tillgänglig. Välj Gå till resurs i meddelandet eller sök efter din nya Azure OpenAI-resurs efter namn.

7. På sidan Azure OpenAI-resurs för den nya resursen väljer du Klicka här för att visa slutpunkter under Essentials-slutpunkter>. Kopiera slutpunkts-URL:en och nycklarna. Spara dessa värden. Du behöver dem senare.

Nu när du har autentiseringsuppgifterna för att ansluta till din modell i Azure OpenAI måste du ange dessa autentiseringsuppgifter för åtkomst i programinställningarna.

3. Distribuera en modell

Nu kan du distribuera en modell. Du kan välja från någon av flera tillgängliga modeller i Azure OpenAI Studio.

Följ dessa steg för att distribuera en modell:

1. Logga in på Azure OpenAI Studio.

2. Välj prenumerationen och Den Azure OpenAI-resurs som du skapade och välj Använd resurs.

3. Under Hantering väljer du Distributioner.

4. Välj Skapa ny distribution och konfigurera följande fält:

   Fält	beskrivning
   Distributionsnamn	Välj ett namn noggrant. Distributionsnamnet används i koden för att anropa modellen med hjälp av klientbiblioteken och REST-API:erna, så du måste spara för användning senare.
   Välj en modell	Modelltillgängligheten varierar beroende på region. En lista över tillgängliga modeller per region finns i Tabellen för modellsammanfattning och regiontillgänglighet.

   Viktigt!

   När du kommer åt modellen via API:et måste du referera till distributionsnamnet i stället för det underliggande modellnamnet i API-anrop, vilket är en av de viktigaste skillnaderna mellan OpenAI och Azure OpenAI. OpenAI kräver endast modellnamnet. Azure OpenAI kräver alltid distributionsnamn, även när du använder modellparametern. I våra dokument har vi ofta exempel där distributionsnamn representeras som identiska med modellnamn för att ange vilken modell som fungerar med en viss API-slutpunkt. I slutändan kan dina distributionsnamn följa den namngivningskonvention som passar bäst för ditt användningsfall.

5. Acceptera standardvärdena för resten av inställningen och välj Skapa.

   Distributionstabellen visar en ny post som motsvarar din nyligen skapade modell.

Nu har du allt du behöver för att lägga till Azure OpenAI-baserad text i funktionsappen.

4. Uppdatera programinställningar

1. I Visual Studio Code öppnar du det lokala kodprojektet som du skapade när du slutförde föregående artikel.

2. I filen local.settings.json i projektrotmappen AzureWebJobsStorage uppdaterar du inställningen till UseDevelopmentStorage=true. Du kan hoppa över det här steget om AzureWebJobsStorage inställningen i local.settings.json är inställd på niska veze för ett befintligt Azure Storage-konto i stället för UseDevelopmentStorage=true.

3. Lägg till följande inställningsvärden i filen local.settings.json:

   • AZURE_OPENAI_ENDPOINT: krävs av bindningstillägget. Ange det här värdet till slutpunkten för den Azure OpenAI-resurs som du skapade tidigare.
   • AZURE_OPENAI_KEY: krävs av bindningstillägget. Ange det här värdet till nyckeln för Azure OpenAI-resursen.
   • CHAT_MODEL_DEPLOYMENT_NAME: används för att definiera indatabindningen. Ange det här värdet till det namn som du valde för modelldistributionen.

4. Spara filen. När du distribuerar till Azure måste du också lägga till de här inställningarna i funktionsappen.

5. Registrera bindningstillägg

Eftersom du använder en Azure OpenAI-utdatabindning måste du ha motsvarande bindningstillägg installerat innan du kör projektet.

Förutom HTTP- och timerutlösare implementeras bindningar som tilläggspaket. Om du vill lägga till Azure OpenAI-tilläggspaketet i projektet kör du det här dotnet add package-kommandot i terminalfönstret :

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

5. Uppdatera tilläggspaketet

För att få åtkomst till förhandsversionen av Azure OpenAI-bindningar måste du använda en förhandsversion av tilläggspaketet som innehåller det här tillägget.

Ersätt inställningen extensionBundle i den aktuella host.json filen med följande JSON:

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

Nu kan du använda Azure OpenAI-utdatabindningen i projektet.

6. Returnera textavslut från modellen

Koden du lägger till skapar en whois HTTP-funktionsslutpunkt i ditt befintliga projekt. I den här funktionen används data som skickas i en URL-parameter för en GET-begäran name för att dynamiskt skapa en slutförandeprompt. Den här dynamiska prompten är bunden till en indatabindning för text som returnerar ett svar från modellen baserat på prompten. Slutförandet från modellen returneras i HTTP-svaret.

1. Lägg till den här using instruktionen i din befintliga HttpExample klassfil:

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

2. I samma fil lägger du till den här koden som definierar en ny HTTP-utlösarslutpunkt med namnet whois:

   [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. pom.xml Uppdatera projektfilen för att lägga till den här referensen i properties samlingen:

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

2. Lägg till det här beroendet i dependencies samlingen i samma fil:

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

3. Lägg till följande import instruktioner i den befintliga Function.java projektfilen:

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

4. I samma fil lägger du till den här koden som definierar en ny HTTP-utlösarslutpunkt med namnet whois:

   @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. I Visual Studio Code trycker du på F1 och i kommandopaletten Azure Functions: Create Function...väljer du HTTP-utlösare, skriver funktionsnamnet whoisoch trycker på Retur.

2. I den nya whois.js kodfilen ersätter du innehållet i filen med den här koden:

   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. I Visual Studio Code trycker du på F1 och i kommandopaletten Azure Functions: Create Function...väljer du HTTP-utlösare, skriver funktionsnamnet whoisoch trycker på Retur.

2. I den nya whois.ts kodfilen ersätter du innehållet i filen med den här koden:

   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. Lägg till den här import instruktionen i den befintliga function_app.py projektfilen:

   import json
   

2. I samma fil lägger du till den här koden som definierar en ny HTTP-utlösarslutpunkt med namnet whois:

   @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. I Visual Studio Code trycker du på F1 och i kommandopalettens typ Azure Functions: Create Function...väljer du HTTP-utlösare, skriver funktionsnamnet whois, väljer Anonym och trycker på Retur.

2. Öppna den nya whois/function.json kodfilen och ersätt dess innehåll med den här koden, som lägger till en definition för indatabindningen TextCompletionResponse :

   {
     "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. Ersätt innehållet i kodfilen med den whois/run.ps1 här koden, som returnerar indatabindningssvaret:

   using namespace System.Net
   
   param($Request, $TriggerMetadata, $TextCompletionResponse)
   
   Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
           StatusCode = [HttpStatusCode]::OK
           Body       = $TextCompletionResponse.Content
       })
   

7. Kör funktionen

1. I Visual Studio Code trycker du på F1 och i kommandopalettens typ Azurite: Start och trycker på Retur för att starta Azurite Storage-emulatorn.

2. Tryck på F5 för att starta funktionsappsprojektet och Core Tools i felsökningsläge.

3. När Core Tools körs skickar du en GET-begäran till whois slutpunktsfunktionen med ett namn i sökvägen, som den här URL:en:

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

   Ersätt strängen <NAME> med det värde som du vill skicka till prompten "Who is {name}?" . <NAME> Måste vara det URL-kodade namnet på en offentlig figur, till exempel Abraham%20Lincoln.

   Svaret du ser är svaret på textkomplettering från Din Azure OpenAI-modell.

4. När ett svar har returnerats trycker du på Ctrl + C för att stoppa Core Tools.

8. Rensa resurser

I Azure refererar resurser till funktionsappar, funktioner, lagringskonton och så vidare. De är grupperade i resursgrupper och du kan ta bort allt i en grupp genom att ta bort gruppen.

Du skapade resurser för att slutföra de här snabbstarterna. Du kan debiteras för dessa resurser, beroende på kontostatus och tjänstpriser. Om du inte behöver resurserna längre så visar vi hur du tar bort dem här:

1. I Visual Studio Code trycker du på F1 för att öppna kommandopaletten. I kommandopaletten söker du efter och väljer Azure: Open in portal.

2. Välj din funktionsapp och tryck på Retur. Funktionsappsidan öppnas i Azure-portalen.

3. På fliken Översikt väljer du den namngivna länken bredvid Resursgrupp.

   

4. På sidan Resursgrupp granskar du listan över inkluderade resurser och kontrollerar att det är de som du vill ta bort.

5. Välj Ta bort resursgrupp och följ instruktionerna.

   Borttagningen kan ta några minuter. När du är färdig visas ett meddelande i några sekunder. Du kan även välja klockikonen högst upp på sidan för att se meddelandet.

Relaterat innehåll

• Azure OpenAI-tillägg för Azure Functions
• Azure OpenAI-tilläggsexempel
• Maskininlärning och AI