Aggiungere App per la logica come plug-in

Spesso in un'azienda è già disponibile un set di flussi di lavoro che eseguono operazioni reali in App per la logica. Questi possono essere usati da altri servizi di automazione o da applicazioni front-end che interagiscono con gli esseri umani. Nel kernel semantico è possibile aggiungere questi stessi flussi di lavoro esattamente come plug-in, in modo che gli agenti possano usarli anche.

Si supponga, ad esempio, che i flussi di lavoro di App per la logica usati dal team del kernel semantico rispondano alle domande sulle nuove richieste pull. Con i flussi di lavoro seguenti, un agente ha tutto il necessario per recuperare le modifiche al codice, cercare i file correlati e controllare i log degli errori.

• File di ricerca: per trovare frammenti di codice rilevanti per un determinato problema
• Ottenere un file : per recuperare il contenuto di un file nel repository GitHub
• Ottenere i dettagli della richiesta pull: per recuperare i dettagli di una richiesta pull, ad esempio il titolo, la descrizione e l'autore della richiesta pull.
• Ottenere i file di richiesta pull: per recuperare i file modificati in una richiesta pull
• Ottenere errori di compilazione e test: per recuperare gli errori di compilazione e test per un'esecuzione specifica dell'azione GitHub
• Ottenere il file di log: per recuperare il file di log per una determinata esecuzione dell'azione GitHub

Sfruttare le app per la logica per i plug-in del kernel semantico è anche un ottimo modo per sfruttare i oltre 1.400 connettori disponibili in App per la logica. Ciò significa che è possibile connettersi facilmente a un'ampia gamma di servizi e sistemi senza scrivere codice.

Importazione di App per la logica come plug-in

Per aggiungere flussi di lavoro di App per la logica al kernel semantico, si useranno gli stessi metodi del caricamento in specifiche OpenAPI. Di seguito è riportato un esempio di codice.

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
    }
);

Configurazione di App per la logica per il kernel semantico

Prima di poter importare un'app per la logica come plug-in, è necessario configurare l'app per la logica in modo che sia accessibile dal kernel semantico. Ciò implica l'abilitazione degli endpoint dei metadati e la configurazione dell'applicazione per Easy Auth prima di importare l'app per la logica come plug-in con l'autenticazione.

Abilitare gli endpoint dei metadati

Per la configurazione più semplice, è possibile abilitare l'accesso non autenticato agli endpoint dei metadati per l'app per la logica. Ciò consentirà di importare l'app per la logica come plug-in nel kernel semantico senza dover creare un client HTTP personalizzato per gestire l'autenticazione per l'importazione iniziale.

Il file di host.json seguente creerà due endpoint non autenticati. È possibile eseguire questa operazione nel portale di Azure passando alla console kudu e modificando il file host.json disponibile in C:\home\site\wwwroot\host.json.

{ 
  "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" 
      } 
    } 
  } 
} 

Configurare l'applicazione per Easy Auth

Si vuole ora proteggere i flussi di lavoro dell'app per la logica in modo che solo gli utenti autorizzati possano accedervi. A tale scopo, abilitare Easy Auth nell'app per la logica. In questo modo sarà possibile usare lo stesso meccanismo di autenticazione degli altri servizi di Azure, semplificando la gestione dei criteri di sicurezza.

Per una procedura dettagliata dettagliata sulla configurazione di Easy Auth, vedere questa esercitazione intitolata Attivare flussi di lavoro nelle app per la logica Standard con Easy Auth.

Per coloro che hanno già familiarità con Easy Auth (e hanno già un'app client Entra che si vuole usare), questa è la configurazione che si vuole pubblicare in Gestione di Azure.

#!/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"

Usare App per la logica con il kernel semantico come plug-in

Ora che l'app per la logica è protetta e gli endpoint dei metadati abilitati, sono state completate tutte le parti difficili. È ora possibile importare l'app per la logica come plug-in nel kernel semantico usando il metodo di importazione OpenAPI.

Quando si crea il plug-in, si vuole fornire un client HTTP personalizzato in grado di gestire l'autenticazione per l'app per la logica. In questo modo sarà possibile usare il plug-in negli agenti di intelligenza artificiale senza doversi preoccupare dell'autenticazione.

Di seguito è riportato un esempio in C# che sfrutta l'autenticazione interattiva per acquisire un token e autenticare l'utente per l'app per la logica.

string ClientId = "[AAD_CLIENT_ID]";
string TenantId = "[TENANT_ID]";
string Authority = $"https://login.microsoftonline.com/{TenantId}";
string[] Scopes = new string[] { "api://[AAD_CIENT_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)
            }
        },
    }
));

Passaggi successivi

Ora che si sa come creare un plug-in, è ora possibile imparare a usarli con l'agente di intelligenza artificiale. A seconda del tipo di funzioni aggiunte ai plug-in, ci sono modelli diversi da seguire. Per le funzioni di recupero, vedere l'articolo uso delle funzioni di recupero. Per le funzioni di automazione delle attività, vedere l'articolo uso delle funzioni di automazione delle attività .