Hinzufügen von Logik-Apps als Plug-Ins

Häufig in einem Unternehmen verfügen Sie bereits über eine Reihe von Workflows, die echte Arbeit in Logik-Apps ausführen. Diese können von anderen Automatisierungsdiensten oder Front-End-Anwendungen verwendet werden, mit denen Menschen interagieren. Im semantischen Kernel können Sie genau diese Workflows wie Plugins hinzufügen, damit Ihre Agents sie auch verwenden können.

Betrachten Sie beispielsweise die Logic Apps-Workflows, die vom Semantikkern-Team genutzt werden, um Fragen zu neuen PRs zu beantworten. Mit den folgenden Workflows verfügt ein Agent über alles, was er benötigt, um Codeänderungen abzurufen, nach verwandten Dateien zu suchen und Fehlerprotokolle zu überprüfen.

Logik-Apps

Suchen von Dateien – um Codeausschnitte zu finden, die für ein bestimmtes Problem relevant sind
Abrufen einer Datei – zum Abrufen des Inhalts einer Datei im GitHub-Repository
Pr-Details abrufen – um die Details einer PR abzurufen (z. B. pr-Titel, Beschreibung und Autor)
Abrufen von PR-Dateien – zum Abrufen der Dateien, die in einer PR geändert wurden
Abrufen von Build- und Testfehlern – zum Abrufen der Build- und Testfehler für eine bestimmte GitHub-Aktion
Abrufen einer Protokolldatei – zum Abrufen der Protokolldatei für eine bestimmte GitHub-Aktion

Die Nutzung von Logik-Apps für semantische Kernel-Plug-Ins ist auch eine hervorragende Möglichkeit, die über 1.400 Connectors zu nutzen, die in Logic Apps verfügbar sind. Dies bedeutet, dass Sie problemlos eine Verbindung mit einer Vielzahl von Diensten und Systemen herstellen können, ohne Code zu schreiben.

Von Bedeutung

Heute können Sie nur Standardlogik-Apps (auch als Single-Tenant Logic Apps bezeichnet) als Plug-Ins hinzufügen. Nutzungslogik-Apps werden in Kürze verfügbar sein.

Importieren von Logik-Apps als Plug-Ins

Um Logik-Apps-Workflows zum semantischen Kernel hinzuzufügen, verwenden Sie dieselben Methoden wie das Laden in openAPI-Spezifikationen. Nachfolgend finden Sie beispielcode.

await kernel.ImportPluginFromOpenApiAsync(
    pluginName: "openapi_plugin",
    uri: new Uri("https://example.azurewebsites.net/swagger.json"),
    executionParameters: new OpenApiFunctionExecutionParameters()
    {
        // Determines whether payload parameter names are augmented with namespaces.
        // Namespaces prevent naming conflicts by adding the parent parameter name
        // as a prefix, separated by dots
        EnablePayloadNamespacing = true
    }
);

Einrichten von Logik-Apps für semantischen Kernel

Bevor Sie eine Logik-App als Plug-In importieren können, müssen Sie zuerst die Logik-App so einrichten, dass sie über den semantischen Kernel zugänglich ist. Dies umfasst das Aktivieren von Metadatenendpunkten und das Konfigurieren Ihrer Anwendung für Easy Auth, bevor sie schließlich die Logik-App als Plug-In mit Authentifizierung importieren.

Aktivieren von Metadatenendpunkten

Für die einfachste Einrichtung können Sie den nicht authentifizierten Zugriff auf die Metadatenendpunkte für Ihre Logik-App aktivieren. Auf diese Weise können Sie Ihre Logik-App als Plug-In in semantischen Kernel importieren, ohne einen benutzerdefinierten HTTP-Client zum Verarbeiten der Authentifizierung für den anfänglichen Import erstellen zu müssen.

Die folgende host.json Datei erstellt zwei nicht authentifizierte Endpunkte. Sie können dies im Azure-Portal tun, indem Sie zur Kudu-Konsole wechseln und die host.json Datei bearbeiten , die sich unter C:\home\site\wwwroot\host.js befindet.

{ 
  "version": "2.0", 
  "extensionBundle": { 
    "id": "Microsoft.Azure.Functions.ExtensionBundle.Workflows", 
    "version": "[1.*, 2.0.0)" 
  }, 
  "extensions": { 
    "http": { 
      "routePrefix": "" 
    }, 
    "workflow": { 
      "MetadataEndpoints": { 
        "plugin": { 
          "enable": true, 
          "Authentication":{ 
              "Type":"Anonymous" 
          } 
        }, 
        "openapi": { 
          "enable": true, 
          "Authentication":{ 
              "Type":"Anonymous" 
          } 
        } 
      }, 
      "Settings": { 
        "Runtime.Triggers.RequestTriggerDefaultApiVersion": "2020-05-01-preview" 
      } 
    } 
  } 
}

Konfigurieren Ihrer Anwendung für easy Auth

Sie möchten jetzt Ihre Logik-App-Workflows sichern, damit nur autorisierte Benutzer darauf zugreifen können. Sie können dies tun, indem Sie Easy Auth für Ihre Logik-App aktivieren. Auf diese Weise können Sie den gleichen Authentifizierungsmechanismus wie Ihre anderen Azure-Dienste verwenden, sodass Sie Ihre Sicherheitsrichtlinien einfacher verwalten können.

Eine ausführliche exemplarische Vorgehensweise zum Einrichten von Easy Auth finden Sie in diesem Lernprogramm mit dem Titel Trigger-Workflows in Standardlogik-Apps mit Easy Auth.

Für diejenigen, die bereits mit Easy Auth vertraut sind und bereits über eine Entra-Client-App verfügen, die Sie verwenden möchten, ist dies die Konfiguration, die Sie in der Azure-Verwaltung hochladen möchten.

#!/bin/bash

# Variables
subscription_id="[SUBSCRIPTION_ID]"
resource_group="[RESOURCE_GROUP]"
app_name="[APP_NAME]"
api_version="2022-03-01"
arm_token="[ARM_TOKEN]"
tenant_id="[TENANT_ID]"
aad_client_id="[AAD_CLIENT_ID]"
object_ids=("[OBJECT_ID_FOR_USER1]" "[OBJECT_ID_FOR_USER2]" "[OBJECT_ID_FOR_APP1]")

# Convert the object_ids array to a JSON array
object_ids_json=$(printf '%s\n' "${object_ids[@]}" | jq -R . | jq -s .)

# Request URL
url="https://management.azure.com/subscriptions/$subscription_id/resourceGroups/$resource_group/providers/Microsoft.Web/sites/$app_name/config/authsettingsV2?api-version=$api_version"

# JSON payload
json_payload=$(cat <<EOF
{
    "properties": {
        "platform": {
            "enabled": true,
            "runtimeVersion": "~1"
        },
        "globalValidation": {
            "requireAuthentication": true,
            "unauthenticatedClientAction": "AllowAnonymous"
        },
        "identityProviders": {
            "azureActiveDirectory": {
                "enabled": true,
                "registration": {
                    "openIdIssuer": "https://sts.windows.net/$tenant_id/",
                    "clientId": "$aad_client_id"
                },
                "validation": {
                    "jwtClaimChecks": {},
                    "allowedAudiences": [
                        "api://$aad_client_id"
                    ],
                    "defaultAuthorizationPolicy": {
                        "allowedPrincipals": {
                            "identities": $object_ids_json
                        }
                    }
                }
            },
            "facebook": {
                "enabled": false,
                "registration": {},
                "login": {}
            },
            "gitHub": {
                "enabled": false,
                "registration": {},
                "login": {}
            },
            "google": {
                "enabled": false,
                "registration": {},
                "login": {},
                "validation": {}
            },
            "twitter": {
                "enabled": false,
                "registration": {}
            },
            "legacyMicrosoftAccount": {
                "enabled": false,
                "registration": {},
                "login": {},
                "validation": {}
            },
            "apple": {
                "enabled": false,
                "registration": {},
                "login": {}
            }
        }
    }
}
EOF
)

# HTTP PUT request
curl -X PUT "$url" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $arm_token" \
    -d "$json_payload"

Verwenden von Logik-Apps mit semantischem Kernel als Plug-In

Nachdem Ihre Logik-App gesichert ist und die Metadatenendpunkte aktiviert sind, haben Sie alle harten Teile abgeschlossen. Sie können Ihre Logik-App jetzt als Plug-In in semantischen Kernel importieren, indem Sie die OpenAPI-Importmethode verwenden.

Wenn Sie Ihr Plug-In erstellen, sollten Sie einen benutzerdefinierten HTTP-Client bereitstellen, der die Authentifizierung für Ihre Logic App verarbeiten kann. Auf diese Weise können Sie das Plug-In in Ihren KI-Agents verwenden, ohne sich gedanken über die Authentifizierung zu machen.

Im Folgenden finden Sie ein Beispiel in C#, das interaktive Authentifizierung nutzt, um ein Token abzurufen und den Benutzer für die Logik-App zu authentifizieren.

string ClientId = "[AAD_CLIENT_ID]";
string TenantId = "[TENANT_ID]";
string Authority = $"https://login.microsoftonline.com/{TenantId}";
string[] Scopes = new string[] { "api://[AAD_CLIENT_ID]/SKLogicApp" };

var app = PublicClientApplicationBuilder.Create(ClientId)
            .WithAuthority(Authority)
            .WithDefaultRedirectUri() // Uses http://localhost for a console app
            .Build();

AuthenticationResult authResult = null;
try
{
    authResult = await app.AcquireTokenInteractive(Scopes).ExecuteAsync();
}
catch (MsalException ex)
{
    Console.WriteLine("An error occurred acquiring the token: " + ex.Message);
}

// Add the plugin to the kernel with a custom HTTP client for authentication
kernel.Plugins.Add(await kernel.ImportPluginFromOpenApiAsync(
    pluginName: "[NAME_OF_PLUGIN]",
    uri: new Uri("https://[LOGIC_APP_NAME].azurewebsites.net/swagger.json"),
    executionParameters: new OpenApiFunctionExecutionParameters()
    {
        HttpClient = new HttpClient()
        {
            DefaultRequestHeaders =
            {
                Authorization = new AuthenticationHeaderValue("Bearer", authResult.AccessToken)
            }
        },
    }
));

Nächste Schritte

Nachdem Sie nun wissen, wie Sie ein Plug-In erstellen, können Sie jetzt erfahren, wie Sie sie mit Ihrem KI-Agent verwenden können. Abhängig von der Art der Funktionen, die Sie Ihren Plug-Ins hinzugefügt haben, gibt es verschiedene Muster, denen Sie folgen sollten. Informationen zu Abruffunktionen finden Sie im Artikel zur Verwendung von Abruffunktionen . Informationen zu Aufgabenautomatisierungs-Funktionen finden Sie in der verwendung von Aufgabenautomatisierungsfunktionen Artikel.

Informationen zur Verwendung von Abruffunktionen

Last updated on 2025-04-21

Freigeben über