Condividi tramite

Esercitazione: Aggiungere suggerimenti di completamento di testo OpenAI di Azure alle funzioni in Visual Studio Code

  • Articolo

Questo articolo illustra come usare Visual Studio Code per aggiungere un endpoint HTTP all'app per le funzioni creata nell'articolo di avvio rapido precedente. Quando viene attivato, questo nuovo endpoint HTTP usa un binding di input di completamento del testo OpenAI di Azure per ottenere suggerimenti di completamento del testo dal modello di dati.

Durante questa esercitazione si apprenderà come eseguire queste attività:

  • Creare risorse in Azure OpenAI.
  • Distribuire un modello nella risorsa OpenAI.
  • Impostare le autorizzazioni di accesso per la risorsa del modello.
  • Abilitare l'app per le funzioni per connettersi a OpenAI.
  • Aggiungere binding OpenAI alla funzione attivata da HTTP.

1. Verificare i prerequisiti

  • Ottenere l'accesso ad Azure OpenAI nella sottoscrizione di Azure. Se l'accesso non è già stato concesso, completare questo modulo per richiederlo.

2. Creare le proprie risorse OpenAI di Azure

I passaggi seguenti illustrano come creare un modello di dati OpenAI di Azure nel portale di Azure.

  1. Accedere con la sottoscrizione di Azure al portale di Azure.

  2. Selezionare Crea una risorsa e cercare Azure OpenAI. Una volta individuato il servizio, selezionare Crea.

  3. Nella pagina Crea Azure OpenAI, specificare le informazioni seguenti per i campi nella scheda Informazioni di base:

    Campo Descrizione
    Abbonamento Sottoscrizione di cui è stato eseguito l'onboarding per usare Azure OpenAI.
    Gruppo di risorse Gruppo di risorse creato per l'app per le funzioni nell'articolo precedente. È possibile trovare questo nome del gruppo di risorse facendo clic con il pulsante destro del mouse sull'app per le funzioni nel browser Risorse di Azure, selezionando proprietà e quindi cercando l'impostazione resourceGroup nel file di risorse JSON restituito.
    Area Idealmente, la stessa posizione dell'app per le funzioni.
    Nome Un nome descrittivo per la risorsa del servizio OpenAI di Azure, ad esempio mySampleOpenAI.
    Piano tariffario Piano tariffario per la risorsa. Attualmente, solo il livello Standard è disponibile per il Servizio OpenAI di Azure. Per altre informazioni sui prezzi, visitare la pagina dei prezzi di Azure OpenAI

    Screenshot che mostra come configurare una risorsa OpenAI di Azure nel portale di Azure.

  4. Selezionare Avanti due volte per accettare i valori predefiniti per le schede Rete e Tag. Il servizio creato non ha restrizioni di rete, tra cui da Internet.

  5. Selezionare Avanti un'ultima volta per passare alla fase finale del processo: Rivedi e invia.

  6. Verificare le impostazioni di configurazione e selezionare Crea.

    Il portale di Azure mostra una notifica quando la nuova risorsa è disponibile. Selezionare Vai alla risorsa nella notifica o cercare la nuova risorsa OpenAI di Azure in base al nome.

  7. Nella pagina della risorsa OpenAI di Azure per la nuova risorsa, selezionare Clicca qui per visualizzare gli endpoint in Essentials>Endpoint. Copiare l'URL dell'endpoint e le chiavi. Salvare questi valori, poiché saranno necessari in un secondo momento.

Dopo aver ottenuto le credenziali per connettersi al modello in Azure OpenAI, è necessario impostare queste credenziali di accesso nelle impostazioni dell'applicazione.

3. Distribuire un modello

È ora possibile distribuire un modello. È possibile selezionare uno dei diversi modelli disponibili in Azure OpenAI Studio.

Per distribuire un modello, seguire questa procedura:

  1. Accedere ad Azure OpenAI Studio.

  2. Scegliere la sottoscrizione e la risorsa OpenAI di Azure creata e selezionare Usa risorsa.

  3. In Gestione selezionare Distribuzioni.

  4. Selezionare Crea nuova distribuzione e configurare i campi seguenti:

    Campo Descrizione
    Nome distribuzione Scegliere un nome con attenzione. Il nome della distribuzione viene usato nel codice per chiamare il modello usando le librerie client e le API REST, quindi è necessario salvarlo per usarlo in un secondo momento.
    Seleziona un modello La disponibilità del modello varia in base all'area geografica. Per un elenco dei modelli disponibili per area, vedere Tabella di riepilogo dei modelli e disponibilità in base all'area.

    Importante

    Quando si accede al modello tramite l'API, è necessario fare riferimento al nome della distribuzione anziché al nome del modello sottostante nelle chiamate API, il che è una delle differenze principali tra OpenAI e Azure OpenAI. OpenAI richiede solo il nome del modello. Azure OpenAI richiede sempre il nome della distribuzione, anche quando si sta usando il parametro del modello. Nella documentazione sono spesso disponibili esempi in cui i nomi di distribuzione sono rappresentati come identici ai nomi di modelli per indicare quale modello funziona con un determinato endpoint API. In definitiva, i nomi di distribuzione possono seguire qualsiasi convenzione di denominazione risulti ottimale per il caso d'uso.

  5. Accettare i valori predefiniti per il resto dell'impostazione e selezionare Crea.

    La tabella distribuzioni mostra una nuova voce corrispondente al modello appena creato.

Ora si dispone di tutti gli elementi necessari per aggiungere il completamento del testo basato su OpenAI di Azure all'app per le funzioni.

4. Aggiornare le impostazioni dell'applicazione

  1. In Visual Studio Code, aprire il progetto di codice locale creato al termine dell'articolo precedente.

  2. Nel file local.settings.json nella cartella radice del progetto, aggiornare l'impostazione AzureWebJobsStorage a UseDevelopmentStorage=true. Ignorare questo passaggio se l'impostazione AzureWebJobsStorage in local.settings.json è impostata sulla stringa di connessione per un account di archiviazione di Azure esistente anziché su UseDevelopmentStorage=true.

  3. Nel file local.settings.json, aggiungere questi valori di impostazioni:

    • AZURE_OPENAI_ENDPOINT: richiesto dall'estensione di binding. Impostare questo valore sull'endpoint della risorsa OpenAI di Azure creata in precedenza.
    • AZURE_OPENAI_KEY: richiesto dall'estensione di binding. Impostare questo valore sulla chiave per la risorsa OpenAI di Azure.
    • CHAT_MODEL_DEPLOYMENT_NAME: usato per definire il binding di input. Impostare questo valore sul nome scelto per la distribuzione del modello.

  4. Salvare il file. Quando si esegue la distribuzione in Azure, è necessario aggiungere anche queste impostazioni all'app per le funzioni.

5. Registrare le estensioni delle associazioni

Poiché si usa un'associazione di output OpenAI di Azure, è necessario che l'estensione di binding corrispondente sia installata prima di eseguire il progetto.

Ad eccezione dei trigger HTTP e timer, i binding vengono implementati come pacchetti di estensione. Per aggiungere il pacchetto di estensione Azure OpenAI al progetto, eseguire questo comando dotnet add package nella finestra Terminale:

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

5. Aggiornare il bundle di estensione

Per accedere alle associazioni OpenAI di Azure in anteprima, è necessario usare una versione di anteprima del bundle di estensione che contenga questa estensione.

Sostituire l'impostazione extensionBundle nel file corrente host.json con questo codice JSON:

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

È ora possibile usare il binding di output OpenAI di Azure nel progetto.

6. Restituire il completamento del testo dal modello

Il codice aggiunto crea un endpoint della funzione HTTP whois nel progetto esistente. In questa funzione, i dati passati in un parametro URL name di una richiesta GET vengono usati per creare dinamicamente una richiesta di completamento. Questo prompt dinamico è associato a un binding di input di completamento del testo che restituisce una risposta dal modello in base alla richiesta. Il completamento del modello viene restituito nella risposta HTTP.

  1. Nel file di classe HttpExample esistente, aggiungere questa istruzione using:

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

  2. Nello stesso file, aggiungere questo codice che definisce un nuovo endpoint del trigger HTTP denominato 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. Aggiornare il file di progetto pom.xml per aggiungere questo riferimento alla raccolta properties:

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

  2. Nello stesso file, aggiungere questa dipendenza alla raccoltadependencies:

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

  3. Nel file di progetto esistente Function.java, aggiungere queste istruzioniimport:

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

  4. Nello stesso file, aggiungere questo codice che definisce un nuovo endpoint del trigger HTTP denominato 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. In Visual Studio Code, premere F1 e nel riquadro comandi digitare Azure Functions: Create Function..., selezionare trigger HTTP, digitare il nome whois della funzione e premere INVIO.

  2. Sostituire il contenuto del file di codice whois.js con il codice seguente:

    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. In Visual Studio Code, premere F1 e nel riquadro comandi digitare Azure Functions: Create Function..., selezionare trigger HTTP, digitare il nome whois della funzione e premere INVIO.

  2. Sostituire il contenuto del file di codice whois.ts con il codice seguente:

    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. Nel file di progetto function_app.py esistente, aggiungere questa istruzione import:

    import json

  2. Nello stesso file, aggiungere questo codice che definisce un nuovo endpoint del trigger HTTP denominato 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. In Visual Studio Code, premere F1 e nel riquadro comandi digitare Azure Functions: Create Function..., selezionare trigger HTTP, digitare il nome whois della funzione, selezionare Anonimo e premere INVIO.

  2. Aprire il nuovo file di codice whois/function.json e sostituirne il contenuto con questo codice, che aggiunge una definizione per il binding di input 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. Sostituire il contenuto del file di codice whois/run.ps1 con questo codice, che restituisce la risposta di binding di input:

    using namespace System.Net

param($Request, $TriggerMetadata, $TextCompletionResponse)

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

7. Eseguire la funzione

  1. In Visual Studio Code, premere F1 e nel riquadro comandi digitare Azurite: Start e premere INVIO per avviare l'emulatore di archiviazione Azurite.

  2. Premere F5 per avviare il progetto dell'app per le funzioni e Core Tools in modalità di debug.

  3. Con Core Tools in esecuzione, inviare una richiesta GET alla funzione endpoint whois con un nome nel percorso simile all’URL seguente:

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

    Sostituire la stringa <NAME> con il valore che si desidera passare alla richiesta "Who is {name}?". <NAME> deve essere il nome con codifica URL di una figura pubblica, ad esempio Abraham%20Lincoln.

    La risposta visualizzata è la risposta di completamento del testo del modello OpenAI di Azure.

  4. Dopo la restituzione di una risposta, premere CTRL+C per arrestare Core Tools.

8. Pulire le risorse

In Azure il termine risorse si riferisce ad app per le funzioni, funzioni, account di archiviazione e così via. Le risorse sono raggruppate in gruppi di risorse, ed è possibile eliminare tutti gli elementi in un gruppo eliminando il gruppo.

Per completare queste guide introduttive sono state create risorse. Per tali risorse potrebbero venire addebitati costi, a seconda dello stato dell'account e dei prezzi dei servizi. Se le risorse non sono più necessarie, ecco come eliminarle:

  1. In Visual Studio Code premere F1 per aprire il riquadro comandi. Nel riquadro comandi cercare e selezionare Azure: Open in portal.

  2. Scegliere l'app per le funzioni e premere INVIO. La pagina dell'app per le funzioni viene aperta nel portale di Azure.

  3. Nella scheda Panoramica selezionare il collegamento accanto a Gruppo di risorse.

    Screenshot di Selezionare il gruppo di risorse da eliminare nella pagina dell'app per le funzioni.

  4. Nella pagina Gruppo di risorse, esaminare l'elenco delle risorse incluse e verificare che siano quelle da eliminare.

  5. Selezionare Elimina gruppo di risorse e seguire le istruzioni.

    L'eliminazione potrebbe richiedere alcuni minuti. Al termine, viene visualizzata una notifica per pochi secondi. È anche possibile selezionare l'icona a forma di campana nella parte superiore della pagina per visualizzare la notifica.

Contenuto correlato