Schnellstart: Erste Schritte für die Verwendung von GPT-35-Turbo und GPT-4 mit Azure OpenAI Service

Voraussetzungen

• Azure-Abonnement – kostenloses Abonnement erstellen.

• Zugriff auf Azure OpenAI im gewünschten Azure-Abonnement gewährt.

  Derzeit wird der Zugriff auf diesen Dienst nur auf Antrag gewährt. Sie können den Zugriff auf Azure OpenAI beantragen, indem Sie das Formular unter https://aka.ms/oai/access ausfüllen. Öffnen Sie ein Problem in diesem Repository, um uns bei einem Problem zu kontaktieren.

• Eine Azure OpenAI Service-Ressource, in der entweder das Modell gpt-35-turbo oder gpt-4 bereitgestellt ist. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Wechseln Sie zu Azure OpenAI Studio

Navigieren Sie unter „https://oai.azure.com/“ zu Azure OpenAI Studio, und melden Sie sich mit den Anmeldeinformationen an, mit denen Sie Zugriff auf Ihre OpenAI-Ressource haben. Wählen Sie während oder nach dem Anmeldeworkflow das passende Verzeichnis, Azure-Abonnement und die Azure OpenAI-Ressource aus.

Wählen Sie auf der Landing Page von Azure OpenAI Studio die Option Chat-Playground aus.

Playground

Beginnen Sie mit der Erkundung der Azure OpenAI-Funktionen mit einem Ansatz ohne Code mithilfe des OpenAI Studio Chat-Playground. Auf dieser Seite können Sie die Funktionen ganz einfach schrittweise erkunden und mit ihnen experimentieren.

Assistenteneinrichtung

Sie können die Drop-down-Liste Assistenteneinrichtung verwenden, um einige vorab geladene Beispiele für Systemmeldungen auszuwählen, um zu beginnen.

Systemmeldungen geben dem Modell Anweisungen dazu, wie es sich verhalten sollte und auf welchen Kontext es beim Generieren einer Antwort verweisen soll. Sie können die Persönlichkeit des Assistenten beschreiben, ihm sagen, was er beantworten soll und was nicht, und ihm sagen, wie Antworten formatiert werden sollen.

Mit Hinzufügen von Few-Shot-Beispiele können Sie Konversationsbeispiele bereitstellen, die vom Modell für kontextbezogenes Lernen verwendet werden.

Während Sie den Chat-Playground verwenden, können Sie jederzeit Code anzeigen auswählen, um Python-, cURL- und JSON-Codebeispiele anzuzeigen, die basierend auf Ihrer aktuellen Chat-Sitzung und Ihrer Auswahl der Einstellungen vorab ausgefüllt wurden. Sie können dann diesen Code verwenden und eine Anwendung schreiben, um dieselbe Aufgabe auszuführen, die Sie derzeit mit dem Playground ausführen.

Chat-Sitzung

Wählen Sie die Schaltfläche Senden, um den eingegebenen Text an die Vervollständigungs-API zu senden, und die Ergebnisse werden an das Textfeld zurückgegeben.

Wählen Sie die Schaltfläche Chat löschen aus, um den aktuellen Konversationsverlauf zu löschen.

Einstellungen

Anzeigen von Bereichen

Standardmäßig gibt es drei Bereiche: Assistenteneinrichtung, Chat-Sitzung und Einstellungen. Mit Bereiche anzeigen können Sie die Bereiche hinzufügen, entfernen und neu anordnen. Wenn Sie jemals einen Bereich schließen und ihn wiederherstellen müssen, verwenden Sie Bereiche anzeigen, um den geschlossenen Bereich wiederherzustellen.

Starten einer Chat-Sitzung

1. Wählen Sie in der Drop-down-Liste „Assistenteneinrichtung“ die Option Xbox-Kundendienstmitarbeiter aus

2. Sie werden gefragt, ob Sie die Systemmeldung aktualisieren möchten. Wählen Sie Weiter aus.

3. Geben Sie im Bereich „Chat-Sitzung“ Folgendes ein: „Ich bin daran interessiert, eine neue Xbox zu kaufen". Wählen Sie Senden aus.

4. Sie erhalten eine ähnliche Antwort wie diese:

   

5. Geben Sie eine Folgefrage ein, z. B.: Welche Modelle unterstützen 4K?

   

6. Nachdem Sie nun über eine einfache Unterhaltung verfügen, wählen Sie unter Assistenteneinrichtung die Option Code anzeigen aus, und Sie erhalten eine Wiedergabe des Codes der gesamten bisherigen Unterhaltung:

#Note: The openai-python library support for Azure OpenAI is in preview.
import os
import openai
openai.api_type = "azure"
openai.api_base = "https://docs-test-001.openai.azure.com/"
openai.api_version = "2024-02-01"
openai.api_key = os.getenv("OPENAI_API_KEY")

response = openai.ChatCompletion.create(
  engine="gpt-35-turbo", # replace this value with the deployment name you chose when you deployed the associated model.
  messages = [{"role":"system","content":"You are an Xbox customer support agent whose primary goal is to help users with issues they are experiencing with their Xbox devices. You are friendly and concise. You only provide factual answers to queries, and do not provide answers that are not related to Xbox."},{"role":"user","content":"How much is a PS5?"},{"role":"assistant","content":"I apologize, but I do not have information about the prices of other gaming devices such as the PS5. My primary focus is to assist with issues regarding Xbox devices. Is there a specific issue you are having with your Xbox device that I may be able to help with?"},{"role":"user","content":"I am interested in buying an Xbox?"},{"role":"assistant","content":"Great! There are several Xbox models available in the market, including the Xbox Series X, Xbox Series S, and Xbox One. The Xbox Series X is the latest and most powerful console, while the Xbox Series S is a more affordable option that still offers great performance. The Xbox One is the previous generation console, but it still has a large library of games available to play.\n\nBefore purchasing an Xbox, you may want to consider factors such as your budget, the types of games you want to play, and whether you want to play games in 4K resolution. Once you have decided on a console, you can purchase it from a retailer or directly from the Xbox website. Let me know if you have any other questions or concerns!"},{"role":"user","content":"Which models are 4K?"},{"role":"assistant","content":"Both the Xbox Series X and Xbox One X support 4K resolution gaming. The Xbox Series S, on the other hand, supports up to 1440p resolution gaming, but it can upscale games to 4K. It's worth noting that in order to take advantage of 4K gaming, you'll need a 4K TV or monitor that supports HDR (High Dynamic Range) and HDMI 2.0 or higher."}],
  temperature=0,
  max_tokens=350,
  top_p=0.95,
  frequency_penalty=0,
  presence_penalty=0,
  stop=None)

Grundlegendes der Promptstruktur

Wenn Sie das Beispiel unter Code anzeigen untersuchen, werden Sie einige eindeutige Token bemerken, die nicht Teil eines typischen GPT-Vervollständigungsaufrufs waren. GPT-35-Turbo wurde darauf trainiert, verschiedene Teile des Prompts. Inhalte werden für das Modell zwischen <|im_start|>- und <|im_end|>-Token bereitgestellt. Die Eingabeaufforderung beginnt mit einer Systemmeldung, die zum Vorbereiten des Modells verwendet werden kann, indem Kontext oder Anweisungen für das Modell eingeschlossen werden. Danach enthält die Eingabeaufforderung eine Reihe von Nachrichten zwischen dem Benutzer und dem Assistenten.

Die Antwort des Assistenten auf die Eingabeaufforderung wird dann unterhalb des <|im_start|>assistant-Tokens zurückgegeben und endet mit <|im_end|>, was anzeigt, dass der Assistent seine Antwort abgeschlossen hat. Sie können auch die Umschaltfläche Unformatierte Syntax anzeigen verwenden, um diese Token im Bereich „Chat-Sitzung“ anzuzeigen.

Die Schrittanleitung für GPT-35-Turbo und GPT-4 bietet eine ausführliche Einführung in die neue Prompt-Struktur und die effektive Verwendung des gpt-35-turbo-Modells.

Bereitstellen Ihres Modells

Sobald Sie mit der Erfahrung im Azure OpenAI-Studio zufrieden sind, können Sie eine Web-App direkt aus dem Studio bereitstellen, indem Sie die Schaltfläche Bereitstellen in auswählen.

Dadurch können Sie entweder eine eigenständige Webanwendung oder einen Copilot in Copilot Studio (Vorschau) bereitstellen, wenn Sie ihre eigenen Daten im Modell verwenden.

Beispiel: Wenn Sie sich für die Bereitstellung einer Webanwendung entscheiden:

Wenn Sie zum ersten Mal eine Web-App bereitstellen, sollten Sie Neue Web-App erstellen auswählen. Geben Sie der App einen Namen, der Teil der App-URL wird. Beispiel: https://<appname>.azurewebsites.net.

Wählen Sie Ihr Abonnement, Ihre Ressourcengruppe, Ihren Standort und Ihren Preisplan für die veröffentlichte App aus. Um eine bestehende App zu aktualisieren, wählen Sie In einer vorhandenen Web-App veröffentlichen aus, und wählen Sie den Namen Ihrer vorherigen App aus dem Dropdownmenü.

Wenn Sie sich für die Bereitstellung einer Webanwendung entscheiden, lesen Sie diese wichtigen Überlegungen zur Verwendung.

Bereinigen von Ressourcen

Nachdem Sie den Chat-Playground getestet haben, können Sie die Ressource oder Ressourcengruppe löschen, wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten. Wenn Sie die Ressourcengruppe löschen, werden auch alle anderen Ressourcen gelöscht, die ihr zugeordnet sind.

• Portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

• Erfahren Sie mehr über die Arbeit mit dem neuen gpt-35-turbo-Modell in der Schrittanleitung für GPT-35-Turbo und GPT-4.
• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele

Quellcode- | Paket (NuGet) | Beispiele| Retrieval Augmented Generation (RAG) – Vorlage für Unternehmenschat |

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto
• Der Zugriff auf den Azure OpenAI Service im gewünschten Azure-Abonnement wurde erteilt. Derzeit wird der Zugriff auf diesen Dienst nur auf Antrag gewährt. Sie können den Zugriff auf den Azure OpenAI Service beantragen, indem Sie das Formular unter https://aka.ms/oai/access ausfüllen.
• Das .NET 7 SDK
• Eine Azure OpenAI Service-Ressource, in der entweder das Modell gpt-35-turbo oder gpt-4 bereitgestellt ist. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Einrichten

Erstellen einer neuen .NET Core-Anwendung

Verwenden Sie in einem Konsolenfenster (z. B. cmd, PowerShell oder Bash) den Befehl dotnet new zum Erstellen einer neuen Konsolen-App mit dem Namen azure-openai-quickstart. Dieser Befehl erstellt ein einfaches „Hallo Welt“-Projekt mit einer einzigen C#-Quelldatei: Program.cs.

dotnet new console -n azure-openai-quickstart

Wechseln Sie zum Ordner der neu erstellten App. Sie können die Anwendung mit folgendem Befehl erstellen:

dotnet build

Die Buildausgabe sollte keine Warnungen oder Fehler enthalten.

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

Installieren Sie die OpenAI .NET-Clientbibliothek mit:

dotnet add package Azure.AI.OpenAI --prerelease

Abrufen von Schlüssel und Endpunkt

Für erfolgreiche Azure OpenAI-Aufrufe benötigen Sie einen Endpunkt und einen Schlüssel.

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Den Abschnitt Schlüssel und Endpunkt finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Erstellen einer Beispielanwendung

Öffnen Sie im Projektverzeichnis die Datei program.cs, und ersetzen Sie den Inhalt durch den folgenden Code:

Ohne Antwortstreaming

using Azure;
using Azure.AI.OpenAI;
using static System.Environment;

string endpoint = GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
string key = GetEnvironmentVariable("AZURE_OPENAI_API_KEY");

OpenAIClient client = new(new Uri(endpoint), new AzureKeyCredential(key));

var chatCompletionsOptions = new ChatCompletionsOptions()
{
    DeploymentName = "gpt-35-turbo", //This must match the custom deployment name you chose for your model
    Messages =
    {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("Does Azure OpenAI support customer managed keys?"),
        new ChatRequestAssistantMessage("Yes, customer managed keys are supported by Azure OpenAI."),
        new ChatRequestUserMessage("Do other Azure AI services support this too?"),
    },
    MaxTokens = 100
};

Response<ChatCompletions> response = client.GetChatCompletions(chatCompletionsOptions);

Console.WriteLine(response.Value.Choices[0].Message.Content);

Console.WriteLine();

dotnet run program.cs

Ausgabe

Yes, many of the Azure AI services support customer managed keys. Some examples include Text Analytics, Speech Services, and Translator. However, it's important to note that not all services support customer managed keys, so it's best to check the documentation for each individual service to see if it is supported.

Dadurch wird gewartet, bis das Modell seine gesamte Antwort generiert hat, bevor die Ergebnisse gedruckt werden. Wenn Sie die Antwort asynchron streamen und die Ergebnisse drucken möchten, können Sie alternativ den Inhalt von program.cs durch den Code im nächsten Beispiel ersetzen.

Asynchron mit Streaming

using Azure;
using Azure.AI.OpenAI;
using static System.Environment;

string endpoint = GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
string key = GetEnvironmentVariable("AZURE_OPENAI_API_KEY");

OpenAIClient client = new(new Uri(endpoint), new AzureKeyCredential(key));

var chatCompletionsOptions = new ChatCompletionsOptions()
{
    DeploymentName= "gpt-35-turbo", //This must match the custom deployment name you chose for your model
    Messages =
    {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("Does Azure OpenAI support customer managed keys?"),
        new ChatRequestAssistantMessage("Yes, customer managed keys are supported by Azure OpenAI."),
        new ChatRequestUserMessage("Do other Azure AI services support this too?"),
    },
    MaxTokens = 100
};

await foreach (StreamingChatCompletionsUpdate chatUpdate in client.GetChatCompletionsStreaming(chatCompletionsOptions))
{
    if (chatUpdate.Role.HasValue)
    {
        Console.Write($"{chatUpdate.Role.Value.ToString().ToUpperInvariant()}: ");
    }
    if (!string.IsNullOrEmpty(chatUpdate.ContentUpdate))
    {
        Console.Write(chatUpdate.ContentUpdate);
    }
}

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource löschen. Vor dem Löschen der Ressource müssen Sie zunächst alle bereitgestellten Modelle löschen.

• Portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele

Quellcode | Paket (Go)| Beispiele

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto
• Der Zugriff auf den Azure OpenAI Service im gewünschten Azure-Abonnement wurde erteilt. Derzeit wird der Zugriff auf diesen Dienst nur auf Antrag gewährt. Sie können den Zugriff auf den Azure OpenAI Service beantragen, indem Sie das Formular unter https://aka.ms/oai/access ausfüllen.
• Lokale Installation von Go 1.21.0 oder höher.
• Eine Azure OpenAI Service-Ressource mit dem bereitgestellten Modell gpt-35-turbo. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Einrichten

Abrufen von Schlüssel und Endpunkt

Für erfolgreiche Azure OpenAI-Aufrufe benötigen Sie einen Endpunkt und einen Schlüssel.

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Den Abschnitt Schlüssel und Endpunkt finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Erstellen einer Beispielanwendung

Erstellen Sie eine neue Datei mit dem Namen chat_completions.go. Kopieren Sie den folgenden Code in die Datei chat_completions.go.

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
)

func main() {
	azureOpenAIKey := os.Getenv("AZURE_OPENAI_API_KEY")
    //modelDeploymentID = deployment name, if model name and deployment name do not match change this value to name chosen when you deployed the model.
	modelDeploymentID := "gpt-35-turbo" 

	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
	azureOpenAIEndpoint := os.Getenv("AZURE_OPENAI_ENDPOINT")

	if azureOpenAIKey == "" || modelDeploymentID == "" || azureOpenAIEndpoint == "" {
		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
		return
	}

	keyCredential, err := azopenai.NewKeyCredential(azureOpenAIKey)

	if err != nil {
		//  TODO: Update the following line with your application specific error handling logic
		log.Fatalf("ERROR: %s", err)
	}

	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)

	if err != nil {
		//  TODO: Update the following line with your application specific error handling logic
		log.Fatalf("ERROR: %s", err)
	}

	// This is a conversation in progress.
	// NOTE: all messages, regardless of role, count against token usage for this API.
	messages := []azopenai.ChatMessage{
		// You set the tone and rules of the conversation with a prompt as the system role.
		{Role: to.Ptr(azopenai.ChatRoleSystem), Content: to.Ptr("You are a helpful assistant.")},

		// The user asks a question
		{Role: to.Ptr(azopenai.ChatRoleUser), Content: to.Ptr("Does Azure OpenAI support customer managed keys?")},

		// The reply would come back from the Azure OpenAI model. You'd add it to the conversation so we can maintain context.
		{Role: to.Ptr(azopenai.ChatRoleAssistant), Content: to.Ptr("Yes, customer managed keys are supported by Azure OpenAI")},

		// The user answers the question based on the latest reply.
		{Role: to.Ptr(azopenai.ChatRoleUser), Content: to.Ptr("Do other Azure AI services support this too?")},

		// from here you'd keep iterating, sending responses back from the chat completions API
	}

	resp, err := client.GetChatCompletions(context.TODO(), azopenai.ChatCompletionsOptions{
		// This is a conversation in progress.
		// NOTE: all messages count against token usage for this API.
		Messages:   messages,
		Deployment: modelDeploymentID,
	}, nil)

	if err != nil {
		//  TODO: Update the following line with your application specific error handling logic
		log.Fatalf("ERROR: %s", err)
	}

	for _, choice := range resp.Choices {
		fmt.Fprintf(os.Stderr, "Content[%d]: %s\n", *choice.Index, *choice.Message.Content)
	}

}

Öffnen Sie nun eine Eingabeaufforderung, und führen Sie Folgendes aus:

go mod init chat_completions.go

Nächste Ausführung:

go mod tidy
go run chat_completions.go

Ausgabe

Content[0]: Yes, many Azure AI services also support customer managed keys. These services enable you to bring your own encryption keys for data at rest, which provides you with more control over the security of your data.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource löschen. Vor dem Löschen der Ressource müssen Sie zunächst alle bereitgestellten Modelle löschen.

• Portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele

Quellcode- | Artefakt (Maven) | Beispiele | Retrieval Augmented Generation (RAG) – | Vorlage für Unternehmenschat

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto
• Der Zugriff auf den Azure OpenAI Service im gewünschten Azure-Abonnement wurde erteilt. Derzeit wird der Zugriff auf diesen Dienst nur auf Antrag gewährt. Sie können den Zugriff auf den Azure OpenAI Service beantragen, indem Sie das Formular unter https://aka.ms/oai/access ausfüllen.

• Aktuelle Version des Java Development Kit (JDK)

• Gradle-Buildtool oder einen anderen Abhängigkeit-Manager
• Eine Azure OpenAI Service-Ressource, in der entweder das Modell gpt-35-turbo oder gpt-4 bereitgestellt ist. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Einrichten

Abrufen von Schlüssel und Endpunkt

Für erfolgreiche Azure OpenAI-Aufrufe benötigen Sie einen Endpunkt und einen Schlüssel.

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Den Abschnitt Schlüssel und Endpunkt finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Erstellen einer neuen Java-Anwendung

Erstellen eines neuen Gradle-Projekts

Erstellen Sie in einem Konsolenfenster (etwa cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und rufen Sie es auf.

mkdir myapp && cd myapp

Führen Sie den Befehl gradle init in Ihrem Arbeitsverzeichnis aus. Mit diesem Befehl werden grundlegende Builddateien für Gradle, u. a. die Datei build.gradle.kts, erstellt. Diese Datei wird zur Laufzeit zum Erstellen und Konfigurieren Ihrer Anwendung verwendet.

gradle init --type basic

Wenn Sie zur Auswahl einer DSL aufgefordert werden, wählen Sie Kotlin aus.

Installieren des Java SDK

In dieser Schnellstartanleitung wird der Gradle-Abhängigkeits-Manager verwendet. Die Clientbibliothek und Informationen zu anderen Abhängigkeits-Managern finden Sie im zentralen Maven-Repository.

Navigieren Sie zur Datei build.gradle.kts, und öffnen Sie sie in Ihrer bevorzugten IDE bzw. Ihrem bevorzugten Text-Editor. Kopieren Sie anschließend die folgende Buildkonfiguration. Diese Konfiguration definiert das Projekt als Java-Anwendung, deren Einstiegspunkt die Klasse OpenAIQuickstart ist. Dies importiert die Azure KI Vision-Bibliothek.

plugins {
    java
    application
}
application { 
    mainClass.set("OpenAIQuickstart")
}
repositories {
    mavenCentral()
}
dependencies {
    implementation(group = "com.azure", name = "azure-ai-openai", version = "1.0.0-beta.3")
    implementation("org.slf4j:slf4j-simple:1.7.9")
}

Erstellen einer Beispielanwendung

1. Erstellen einer Java-Datei

   Führen Sie in Ihrem Arbeitsverzeichnis den folgenden Befehl aus, um einen Projektquellordner zu erstellen:

   mkdir -p src/main/java
   

   Navigieren Sie zu dem neuen Ordner, und erstellen Sie eine Datei namens OpenAIQuickstart.java.

2. Öffnen Sie OpenAIQuickstart.java in Ihrem bevorzugten Editor oder ihrer IDE, und fügen Sie den folgenden Code ein.

   import com.azure.ai.openai.OpenAIClient;
   import com.azure.ai.openai.OpenAIClientBuilder;
   import com.azure.ai.openai.models.ChatChoice;
   import com.azure.ai.openai.models.ChatCompletions;
   import com.azure.ai.openai.models.ChatCompletionsOptions;
   import com.azure.ai.openai.models.ChatMessage;
   import com.azure.ai.openai.models.ChatRole;
   import com.azure.ai.openai.models.CompletionsUsage;
   import com.azure.core.credential.AzureKeyCredential;
   
   import java.util.ArrayList;
   import java.util.List;
   
   public class GetChatCompletionsSample {
   
       public static void main(String[] args) {
           String azureOpenaiKey = System.getenv("AZURE_OPENAI_API_KEY");;
           String endpoint = System.getenv("AZURE_OPENAI_ENDPOINT");;
           String deploymentOrModelId = "gpt-35-turbo";
   
         OpenAIClient client = new OpenAIClientBuilder()
               .endpoint(endpoint)
               .credential(new AzureKeyCredential(azureOpenaiKey))
               .buildClient();
   
           List<ChatMessage> chatMessages = new ArrayList<>();
           chatMessages.add(new ChatMessage(ChatRole.SYSTEM, "You are a helpful assistant"));
           chatMessages.add(new ChatMessage(ChatRole.USER, "Does Azure OpenAI support customer managed keys?"));
           chatMessages.add(new ChatMessage(ChatRole.ASSISTANT, "Yes, customer managed keys are supported by Azure OpenAI?"));
           chatMessages.add(new ChatMessage(ChatRole.USER, "Do other Azure AI services support this too?"));
   
           ChatCompletions chatCompletions = client.getChatCompletions(deploymentOrModelId, new ChatCompletionsOptions(chatMessages));
   
           System.out.printf("Model ID=%s is created at %s.%n", chatCompletions.getId(), chatCompletions.getCreatedAt());
           for (ChatChoice choice : chatCompletions.getChoices()) {
               ChatMessage message = choice.getMessage();
               System.out.printf("Index: %d, Chat Role: %s.%n", choice.getIndex(), message.getRole());
               System.out.println("Message:");
               System.out.println(message.getContent());
           }
   
           System.out.println();
           CompletionsUsage usage = chatCompletions.getUsage();
           System.out.printf("Usage: number of prompt token is %d, "
                   + "number of completion token is %d, and number of total tokens in request and response is %d.%n",
               usage.getPromptTokens(), usage.getCompletionTokens(), usage.getTotalTokens());
       }
   }  
   

   Wichtig

   Verwenden Sie für die Produktion eine sichere Art der Speicherung und des Zugriffs auf Ihre Anmeldeinformationen wie Azure Key Vault. Weitere Informationen zur Sicherheit von Anmeldeinformationen finden Sie im Azure KI Services-Artikel Sicherheit.

3. Navigieren Sie zurück zum Projektstammordner, und erstellen Sie die App mit:

   gradle build
   

   Führen Sie ihn dann mit dem gradle run-Befehl aus:

   gradle run
   

Ausgabe

Model ID=chatcmpl-7JYnyE4zpd5gaIfTRH7hNpeVsvAw4 is created at 1684896378.
Index: 0, Chat Role: assistant.
Message:
Yes, most of the Azure AI services support customer managed keys. However, there may be some exceptions, so it is best to check the documentation of each specific service to confirm.

Usage: number of prompt token is 59, number of completion token is 36, and number of total tokens in request and response is 95.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource löschen. Vor dem Löschen der Ressource müssen Sie zunächst alle bereitgestellten Modelle löschen.

• Portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele

Quellcode | Artifacts (Maven) | Beispiel

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto
• Der Zugriff auf den Azure OpenAI Service im gewünschten Azure-Abonnement wurde erteilt. Derzeit wird der Zugriff auf diesen Dienst nur auf Antrag gewährt. Sie können den Zugriff auf den Azure OpenAI Service beantragen, indem Sie das Formular unter https://aka.ms/oai/access ausfüllen.
• Aktuelle Version des Java Development Kit (JDK)
• Das Spring Boot CLI-Tool
• Eine Azure OpenAI Service-Ressource mit dem bereitgestellten Modell gpt-35-turbo. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Einrichten

Abrufen von Schlüssel und Endpunkt

Für erfolgreiche Azure OpenAI-Aufrufe benötigen Sie einen Endpunkt und einen Schlüssel.

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Den Abschnitt Schlüssel und Endpunkt finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

export SPRING_AI_AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export SPRING_AI_AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"
export SPRING_AI_AZURE_OPENAI_MODEL="REPLACE_WITH_YOUR_MODEL_NAME_HERE"

Erstellen einer neuen Spring-Anwendung

Erstellen Sie ein neues Spring-Projekt.

Erstellen Sie in einem Bash-Fenster ein neues Verzeichnis für Ihre App, und navigieren Sie dorthin.

mkdir ai-chat-demo && cd ai-chat-demo

Führen Sie den Befehl spring init in Ihrem Arbeitsverzeichnis aus. Dieser Befehl erstellt eine Standardverzeichnisstruktur für Ihr Spring-Projekt, einschließlich der Hauptquelldatei der Java-Klassen und der Datei pom.xml, die für die Verwaltung von Maven-basierten Projekten verwendet wird.

spring init -a ai-chat-demo -n AIChat --force --build maven -x

Die generierten Dateien und Ordner ähneln der folgenden Struktur:

ai-chat-demo/
|-- pom.xml
|-- mvn
|-- mvn.cmd
|-- HELP.md
|-- src/
    |-- main/
    |   |-- resources/
    |   |   |-- application.properties
    |   |-- java/
    |       |-- com/
    |           |-- example/
    |               |-- aichatdemo/
    |                   |-- AiChatApplication.java
    |-- test/
        |-- java/
            |-- com/
                |-- example/
                    |-- aichatdemo/
                        |-- AiChatApplicationTests.java

Spring-Anwendung bearbeiten

1. Bearbeiten Sie die pom.xml-Datei.

   Öffnen Sie im Stammverzeichnis des Projektverzeichnisses die Datei pom.xml in Ihrem bevorzugten Editor oder Ihrer IDE, und überschreiben Sie die Datei mit folgendem Inhalt:

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>3.2.0</version>
           <relativePath/> <!-- lookup parent from repository -->
       </parent>
       <groupId>com.example</groupId>
       <artifactId>ai-chat-demo</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <name>AIChat</name>
       <description>Demo project for Spring Boot</description>
       <properties>
           <java.version>17</java.version>
       </properties>
       <dependencies>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.experimental.ai</groupId>
               <artifactId>spring-ai-azure-openai-spring-boot-starter</artifactId>
               <version>0.7.0-SNAPSHOT</version>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
               <scope>test</scope>
           </dependency>
       </dependencies>
       <build>
           <plugins>
               <plugin>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-maven-plugin</artifactId>
               </plugin>
           </plugins>
       </build>
       <repositories>
           <repository>
               <id>spring-snapshots</id>
               <name>Spring Snapshots</name>
               <url>https://repo.spring.io/snapshot</url>
               <releases>
                   <enabled>false</enabled>
               </releases>
           </repository>
       </repositories>
   </project>
   

2. Öffnen Sie im Ordner src/main/java/com/example/aicompletiondemoAiCompletionApplication.java in Ihrem bevorzugten Editor oder Ihrer IDE, und fügen Sie den folgenden Code ein:

   package com.example.aichatdemo;
   
   import java.util.ArrayList;
   import java.util.List;
   
   import org.springframework.ai.client.AiClient;
   import org.springframework.ai.prompt.Prompt;
   import org.springframework.ai.prompt.messages.ChatMessage;
   import org.springframework.ai.prompt.messages.Message;
   import org.springframework.ai.prompt.messages.MessageType;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @SpringBootApplication
   public class AiChatApplication implements CommandLineRunner
   {
       private static final String ROLE_INFO_KEY = "role";
   
       @Autowired
       private AiClient aiClient;
   
       public static void main(String[] args) {
           SpringApplication.run(AiChatApplication.class, args);
       }
   
       @Override
       public void run(String... args) throws Exception
       {
           System.out.println(String.format("Sending chat prompts to AI service. One moment please...\r\n"));
   
           final List<Message> msgs = new ArrayList<>();
   
           msgs.add(new ChatMessage(MessageType.SYSTEM, "You are a helpful assistant"));
           msgs.add(new ChatMessage(MessageType.USER, "Does Azure OpenAI support customer managed keys?"));
           msgs.add(new ChatMessage(MessageType.ASSISTANT, "Yes, customer managed keys are supported by Azure OpenAI?"));
           msgs.add(new ChatMessage(MessageType.USER, "Do other Azure AI services support this too?"));
   
           final var resps = aiClient.generate(new Prompt(msgs));
   
           System.out.println(String.format("Prompt created %d generated response(s).", resps.getGenerations().size()));
   
           resps.getGenerations().stream()
             .forEach(gen -> {
                 final var role = gen.getInfo().getOrDefault(ROLE_INFO_KEY, MessageType.ASSISTANT.getValue());
   
                 System.out.println(String.format("Generated respose from \"%s\": %s", role, gen.getText()));
             });
       }
   
   }
   

   Wichtig

   Verwenden Sie für die Produktion eine sichere Art der Speicherung und des Zugriffs auf Ihre Anmeldeinformationen wie Azure Key Vault. Weitere Informationen zur Sicherheit von Anmeldeinformationen finden Sie im Azure KI Services-Artikel Sicherheit.

3. Navigieren Sie zurück zum Projektstammordner, und führen Sie die App mithilfe des folgenden Befehls aus:

   ./mvnw spring-boot:run
   

Output

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v3.1.5)

2023-11-07T13:31:10.884-06:00  INFO 6248 --- [           main] c.example.aichatdemo.AiChatApplication   : No active profile set, falling back to 1 default profile: "default"
2023-11-07T13:31:11.595-06:00  INFO 6248 --- [           main] c.example.aichatdemo.AiChatApplication   : Started AiChatApplication in 0.994 seconds (process running for 1.28)
Sending chat prompts to AI service. One moment please...

Prompt created 1 generated response(s).
Generated respose from "assistant": Yes, other Azure AI services also support customer managed keys. Azure AI Services, Azure Machine Learning, and other AI services in Azure provide options for customers to manage and control their encryption keys. This allows customers to have greater control over their data and security.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource löschen. Vor dem Löschen der Ressource müssen Sie zunächst alle bereitgestellten Modelle löschen.

• Portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele

Quellcode- | Paket (npm) | Beispiele | Retrieval Augmented Generation (RAG) – Vorlage für Unternehmenschat|

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto
• Der Zugriff auf den Azure OpenAI Service im gewünschten Azure-Abonnement wurde erteilt. Derzeit wird der Zugriff auf diesen Dienst nur auf Antrag gewährt. Sie können den Zugriff auf den Azure OpenAI Service beantragen, indem Sie das Formular unter https://aka.ms/oai/access ausfüllen.
• LTS-Versionen von Node.js
• Eine Azure OpenAI Service-Ressource, in der entweder das Modell gpt-35-turbo oder gpt-4 bereitgestellt ist. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Einrichten

Abrufen von Schlüssel und Endpunkt

Für erfolgreiche Azure OpenAI-Aufrufe benötigen Sie einen Endpunkt und einen Schlüssel.

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Den Abschnitt Schlüssel und Endpunkt finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Erstellen einer Node.-Anwendung

Erstellen Sie in einem Konsolenfenster (etwa cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und rufen Sie es auf. Führen Sie dann den Befehl npm init aus, um eine Knotenanwendung mit einer Datei des Typs package.json zu erstellen.

npm init

Installieren der Clientbibliothek

Installieren Sie die Azure OpenAI-Clientbibliothek für JavaScript mit npm:

npm install @azure/openai

Die Datei package.json Ihrer App wird mit den Abhängigkeiten aktualisiert.

Erstellen einer Beispielanwendung

Öffnen Sie am gewünschten Speicherort für das neue Projekt eine Eingabeaufforderung, und erstellen Sie eine neue Datei mit dem Namen ChatCompletion.js. Kopieren Sie den folgenden Code in die Datei ChatCompletion.js.

const { OpenAIClient, AzureKeyCredential } = require("@azure/openai");
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] ;
const azureApiKey = process.env["AZURE_OPENAI_API_KEY"] ;

const messages = [
  { role: "system", content: "You are a helpful assistant." },
  { role: "user", content: "Does Azure OpenAI support customer managed keys?" },
  { role: "assistant", content: "Yes, customer managed keys are supported by Azure OpenAI" },
  { role: "user", content: "Do other Azure AI services support this too" },
];

async function main() {
  console.log("== Chat Completions Sample ==");

  const client = new OpenAIClient(endpoint, new AzureKeyCredential(azureApiKey));
  const deploymentId = "gpt-35-turbo";
  const result = await client.getChatCompletions(deploymentId, messages);

  for (const choice of result.choices) {
    console.log(choice.message);
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

module.exports = { main };

Führen Sie das Skript mit dem folgenden Befehl aus:

node.exe ChatCompletion.js

Ausgabe

== Chat Completions Sample ==
{
  role: 'assistant',
  content: 'Yes, most Azure AI services support customer managed keys. It is always best to check the specific service documentation to confirm this.'
}

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource löschen. Vor dem Löschen der Ressource müssen Sie zunächst alle bereitgestellten Modelle löschen.

• Portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

• Übersicht über Azure OpenAI
• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele

Bibliotheksquellcode- | Paket (PyPi) | Retrieval Augmented Generation (RAG) – Vorlage für Unternehmenschat |

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto
• Der Zugriff auf Azure OpenAI Service im gewünschten Azure-Abonnement wird gewährt. Derzeit wird der Zugriff auf diesen Dienst nur auf Antrag gewährt. Sie können den Zugriff auf den Azure OpenAI Service beantragen, indem Sie das Formular unter https://aka.ms/oai/access ausfüllen.
• Python 3.8 oder eine höhere Version.
• Die folgenden Python-Bibliotheken: os.
• Eine Azure OpenAI Service-Ressource, in der entweder das Modell gpt-35-turbo oder gpt-4 bereitgestellt ist. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Einrichten

Installieren Sie die Python-Clientbibliothek mit:

pip install openai

pip install openai==0.28.1

Abrufen von Schlüssel und Endpunkt

Für erfolgreiche Azure OpenAI-Aufrufe benötigen Sie einen Endpunkt und einen Schlüssel.

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Den Abschnitt Schlüssel und Endpunkt finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Erstellen einer neuen Python-Anwendung

1. Erstellen Sie eine neue Python-Datei namens „quickstart.py“. Öffnen Sie diese anschließend in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE.

2. Ersetzen Sie den Inhalt von „quickstart.py“ durch den folgenden Code.

import os
from openai import AzureOpenAI

client = AzureOpenAI(
  azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
  api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version="2024-02-01"
)

response = client.chat.completions.create(
    model="gpt-35-turbo", # model = "deployment_name".
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
        {"role": "user", "content": "Do other Azure AI services support this too?"}
    ]
)

print(response.choices[0].message.content)

import os
import openai
openai.api_type = "azure"
openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") 
openai.api_key = os.getenv("AZURE_OPENAI_API_KEY")
openai.api_version = "2024-02-01"

response = openai.ChatCompletion.create(
    engine="gpt-35-turbo", # engine = "deployment_name".
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
        {"role": "user", "content": "Do other Azure AI services support this too?"}
    ]
)

print(response)
print(response['choices'][0]['message']['content'])

3. Führen Sie die Anwendung mit dem Befehl python für die Schnellstartdatei aus:

   python quickstart.py
   

Ausgabe

{
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "content": "Yes, most of the Azure AI services support customer managed keys. However, not all services support it. You can check the documentation of each service to confirm if customer managed keys are supported.",
        "role": "assistant"
      }
    }
  ],
  "created": 1679001781,
  "id": "chatcmpl-6upLpNYYOx2AhoOYxl9UgJvF4aPpR",
  "model": "gpt-3.5-turbo-0301",
  "object": "chat.completion",
  "usage": {
    "completion_tokens": 39,
    "prompt_tokens": 58,
    "total_tokens": 97
  }
}
Yes, most of the Azure AI services support customer managed keys. However, not all services support it. You can check the documentation of each service to confirm if customer managed keys are supported.

Grundlegendes zur Nachrichtenstruktur

Die GPT-35-Turbo- und GPT-4-Modelle sind für die Verwendung von Eingaben optimiert, die als Unterhaltung formatiert sind. Die Variable messages übergibt ein Array von Wörterbüchern mit verschiedenen Rollen in der Unterhaltung, die nach System, Benutzer und Assistent abgegrenzt sind. Die Systemnachricht kann zum Vorbereiten des Modells verwendet werden, indem Kontext oder Anweisungen für die Antworten des Modells eingeschlossen werden.

Die Schrittanleitung für GPT-35-Turbo und GPT-4 bietet eine ausführliche Einführung in die Optionen für die Kommunikation mit diesen neuen Modellen.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource löschen. Vor dem Löschen der Ressource müssen Sie zunächst alle bereitgestellten Modelle löschen.

• Portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

• Erfahren Sie mehr über die Arbeit mit dem GPT-35-Turbo und den GPT-4-Modellen in unserem Leitfaden.
• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele

REST-API-Spezifikation |

Voraussetzungen

• Azure-Abonnement – kostenloses Abonnement erstellen.
• Der Zugriff auf Azure OpenAI Service im gewünschten Azure-Abonnement wird gewährt. Derzeit wird der Zugriff auf diesen Dienst nur auf Antrag gewährt. Sie können den Zugriff auf den Azure OpenAI Service beantragen, indem Sie das Formular unter https://aka.ms/oai/access ausfüllen.
• Eine Azure OpenAI Service-Ressource, in der entweder das Modell gpt-35-turbo oder gpt-4 bereitgestellt ist. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Einrichten

Abrufen von Schlüssel und Endpunkt

Für erfolgreiche Azure OpenAI-Aufrufe benötigen Sie einen Endpunkt und einen Schlüssel.

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Den Abschnitt Schlüssel und Endpunkt finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

REST-API

Führen Sie in der Bash-Shell die folgenden Befehle aus. Sie müssen gpt-35-turbo durch den Bereitstellungsnamen ersetzen, den Sie bei der Bereitstellung der GPT-35-Turbo- oder GPT-4-Modelle ausgewählt haben. Die Eingabe des Modellnamens führt zu einem Fehler, es sei denn, Sie haben einen Bereitstellungsnamen ausgewählt, der mit dem zugrunde liegenden Modellnamen identisch ist.

curl $AZURE_OPENAI_ENDPOINT/openai/deployments/gpt-35-turbo/chat/completions?api-version=2024-02-01 \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -d '{"messages":[{"role": "system", "content": "You are a helpful assistant."},{"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},{"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},{"role": "user", "content": "Do other Azure AI services support this too?"}]}'

Das Format Ihrer ersten Zeile des Befehls mit einem Beispielendpunkt wird wie folgt angezeigt: curl https://docs-test-001.openai.azure.com/openai/deployments/{YOUR-DEPLOYMENT_NAME_HERE}/chat/completions?api-version=2024-02-01 \ Wenn ein Fehler auftritt, überprüfen Sie, ob eine Verdoppelung von / bei der Trennung zwischen Ihrem Endpunkt und /openai/deployments vorliegt.

Wenn Sie diesen Befehl an einer normalen Windows-Eingabeaufforderung ausführen möchten, müssen Sie den Text ändern, um \ und Zeilenumbrüche zu entfernen.

Ausgabe

{"id":"chatcmpl-6v7mkQj980V1yBec6ETrKPRqFjNw9",
"object":"chat.completion","created":1679072642,
"model":"gpt-35-turbo",
"usage":{"prompt_tokens":58,
"completion_tokens":68,
"total_tokens":126},
"choices":[{"message":{"role":"assistant",
"content":"Yes, other Azure AI services also support customer managed keys. Azure AI services offer multiple options for customers to manage keys, such as using Azure Key Vault, customer-managed keys in Azure Key Vault or customer-managed keys through Azure Storage service. This helps customers ensure that their data is secure and access to their services is controlled."},"finish_reason":"stop","index":0}]}

Die Ausgabeformatierung wurde zur erleichterten Lesbarkeit angepasst, die tatsächliche Ausgabe ist ein einzelner Textblock ohne Zeilenumbrüche.

Grundlegendes zur Nachrichtenstruktur

Die GPT-35-Turbo- und GPT-4-Modelle sind für die Verwendung von Eingaben optimiert, die als Unterhaltung formatiert sind. Die Variable messages übergibt ein Array von Wörterbüchern mit verschiedenen Rollen in der Unterhaltung, die nach System, Benutzer und Assistent abgegrenzt sind. Die Systemnachricht kann zum Vorbereiten des Modells verwendet werden, indem Kontext oder Anweisungen für die Antworten des Modells eingeschlossen werden.

Die Schrittanleitung für GPT-35-Turbo und GPT-4 bietet eine ausführliche Einführung in die Optionen für die Kommunikation mit diesen neuen Modellen.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource löschen. Vor dem Löschen der Ressource müssen Sie zunächst alle bereitgestellten Modelle löschen.

• Portal
• Azure-Befehlszeilenschnittstelle

Nächste Schritte

• Erfahren Sie mehr über die Arbeit mit dem GPT-35-Turbo und den GPT-4-Modellen in unserem Leitfaden.
• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele

Voraussetzungen

• Azure-Abonnement: Kostenloses Azure-Konto
• Der Zugriff auf Azure OpenAI Service im gewünschten Azure-Abonnement wird gewährt. Derzeit wird der Zugriff auf diesen Dienst nur auf Antrag gewährt. Sie können den Zugriff auf den Azure OpenAI Service beantragen, indem Sie das Formular unter https://aka.ms/oai/access ausfüllen.
• Sie können entweder die neueste Version, PowerShell 7, oder Windows PowerShell 5.1 verwenden.
• Eine Azure OpenAI Service-Ressource mit einem bereitgestellten Modell. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.
• Eine Azure OpenAI Service-Ressource, in der entweder das Modell gpt-35-turbo oder gpt-4 bereitgestellt ist. Weitere Informationen zur Modellimplementierung finden Sie im Leitfaden zur Ressourcenbereitstellung.

Abrufen von Schlüssel und Endpunkt

Für erfolgreiche Azure OpenAI-Aufrufe benötigen Sie einen Endpunkt und einen Schlüssel.

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Die Werte für Endpunkt und Schlüssel finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

Umgebungsvariablen

$Env:AZURE_OPENAI_API_KEY = 'YOUR_KEY_VALUE'
$Env:AZURE_OPENAI_ENDPOINT = 'YOUR_ENDPOINT'

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

echo export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE" >> /etc/environment && source /etc/environment
echo export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE" >> /etc/environment && source /etc/environment

Erstellen eines neuen PowerShell-Skripts

1. Erstellen Sie eine neue PowerShell-Datei mit dem Namen „quickstart.ps1“. Öffnen Sie diese anschließend in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE.

2. Ersetzen Sie den Inhalt von quickstart.ps1 durch den folgenden Code. Sie müssen die Variable engine auf den Bereitstellungsnamen festlegen, den Sie bei der Bereitstellung der GPT-35-Turbo- oder GPT-4-Modelle ausgewählt haben. Die Eingabe des Modellnamens führt zu einem Fehler, es sei denn, Sie haben einen Bereitstellungsnamen ausgewählt, der mit dem zugrunde liegenden Modellnamen identisch ist.

   # Azure OpenAI metadata variables
   $openai = @{
      api_key     = $Env:AZURE_OPENAI_API_KEY
      api_base    = $Env:AZURE_OPENAI_ENDPOINT # your endpoint should look like the following https://YOUR_RESOURCE_NAME.openai.azure.com/
      api_version = '2024-02-01' # this may change in the future
      name        = 'YOUR-DEPLOYMENT-NAME-HERE' #This will correspond to the custom name you chose for your deployment when you deployed a model.
   }
   
   # Completion text
   $messages = @()
   $messages += @{
     role = 'system'
     content = 'You are a helpful assistant.'
   }
   $messages += @{
     role = 'user'
     content = 'Does Azure OpenAI support customer managed keys?'
   }
   $messages += @{
     role = 'assistant'
     content = 'Yes, customer managed keys are supported by Azure OpenAI.'
   }
   $messages += @{
     role = 'user'
     content = 'Do other Azure AI services support this too?'
   }
   
   # Header for authentication
   $headers = [ordered]@{
      'api-key' = $openai.api_key
   }
   
   # Adjust these values to fine-tune completions
   $body = [ordered]@{
      messages = $messages
   } | ConvertTo-Json
   
   # Send a request to generate an answer
   $url = "$($openai.api_base)/openai/deployments/$($openai.name)/chat/completions?api-version=$($openai.api_version)"
   
   $response = Invoke-RestMethod -Uri $url -Headers $headers -Body $body -Method Post -ContentType 'application/json'
   return $response
   

   Wichtig

   Verwenden Sie für die Produktion eine sichere Art der Speicherung und des Zugriffs auf Ihre Anmeldeinformationen wie die PowerShell-Geheimnisverwaltung mit Azure Key Vault. Weitere Informationen zur Sicherheit von Anmeldeinformationen finden Sie im Azure KI Services-Artikel Sicherheit.

3. Führen Sie das Skript mit PowerShell aus:

   ./quickstart.ps1
   

Ausgabe

# the output of the script will be a .NET object containing the response
id      : chatcmpl-7sdJJRC6fDNGnfHMdfHXvPkYFbaVc
object  : chat.completion
created : 1693255177
model   : gpt-35-turbo
choices : {@{index=0; finish_reason=stop; message=}}
usage   : @{completion_tokens=67; prompt_tokens=55; total_tokens=122}

# convert the output to JSON
./quickstart.ps1 | ConvertTo-Json -Depth 3

# or to view the text returned, select the specific object property
$reponse = ./quickstart.ps1
$response.choices.message.content

Grundlegendes zur Nachrichtenstruktur

Die GPT-35-Turbo- und GPT-4-Modelle sind für die Verwendung von Eingaben optimiert, die als Unterhaltung formatiert sind. Die Variable messages übergibt ein Array von Wörterbüchern mit verschiedenen Rollen in der Unterhaltung, die nach System, Benutzer und Assistent abgegrenzt sind. Die Systemnachricht kann zum Vorbereiten des Modells verwendet werden, indem Kontext oder Anweisungen für die Antworten des Modells eingeschlossen werden.

Die Schrittanleitung für GPT-35-Turbo und GPT-4 bietet eine ausführliche Einführung in die Optionen für die Kommunikation mit diesen neuen Modellen.

Bereinigen von Ressourcen

Wenn Sie eine Azure OpenAI-Ressource bereinigen und entfernen möchten, können Sie die Ressource löschen. Vor dem Löschen der Ressource müssen Sie zunächst alle bereitgestellten Modelle löschen.

• Portal
• Azure PowerShell

Nächste Schritte

• Erfahren Sie mehr über die Arbeit mit dem GPT-35-Turbo und den GPT-4-Modellen in unserem Leitfaden.
• Weitere Beispiele finden Sie im GitHub-Repository für Azure OpenAI-Beispiele