Ajouter Logic Apps en tant que plug-ins
Souvent dans une entreprise, vous disposez déjà d’un ensemble de flux de travail qui effectuent un travail réel dans Logic Apps. Ceux-ci peuvent être utilisés par d’autres services d’automatisation ou par des applications front-end avec lesquelles les humains interagissent. Dans le noyau sémantique, vous pouvez ajouter ces mêmes flux de travail que les plug-ins afin que vos agents puissent également les utiliser.
Prenons l’exemple des flux de travail Logic Apps utilisés par l’équipe de noyau sémantique pour répondre aux questions sur les nouveaux PR. Avec les flux de travail suivants, un agent a tout ce dont il a besoin pour récupérer les modifications de code, rechercher des fichiers connexes et vérifier les journaux d’échec.
- Rechercher des fichiers : pour rechercher des extraits de code pertinents pour un problème donné
- Obtenir un fichier : pour récupérer le contenu d’un fichier dans le référentiel GitHub
- Obtenir les détails de la demande de tirage : pour récupérer les détails d’une demande de tirage (par exemple, le titre, la description et l’auteur)
- Obtenir des fichiers de demande de tirage : pour récupérer les fichiers qui ont été modifiés dans une demande de tirage
- Obtenir les échecs de génération et de test : pour récupérer les échecs de build et de test pour une exécution d’action GitHub donnée
- Obtenir le fichier journal : pour récupérer le fichier journal pour une exécution d’action GitHub donnée
L’utilisation des plug-ins logic Apps pour noyau sémantique est également un excellent moyen de tirer parti des plus de 1 400 connecteurs disponibles dans Logic Apps. Cela signifie que vous pouvez facilement vous connecter à un large éventail de services et de systèmes sans écrire de code.
Important
Aujourd’hui, vous pouvez uniquement ajouter des applications logiques standard (également appelées applications logiques à locataire unique) en tant que plug-ins. La consommation d’applications logiques sera bientôt disponible.
Importation de Logic Apps en tant que plug-ins
Pour ajouter des flux de travail Logic Apps au noyau sémantique, vous allez utiliser les mêmes méthodes que le chargement dans des spécifications OpenAPI. Vous trouverez ci-dessous un exemple de code.
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
}
);
Configuration de Logic Apps pour le noyau sémantique
Avant de pouvoir importer une application logique en tant que plug-in, vous devez d’abord configurer l’application logique pour qu’elle soit accessible par le noyau sémantique. Cela implique l’activation des points de terminaison de métadonnées et la configuration de votre application pour Easy Auth avant d’importer enfin l’application logique en tant que plug-in avec l’authentification.
Activer les points de terminaison de métadonnées
Pour la configuration la plus simple, vous pouvez activer l’accès non authentifié aux points de terminaison de métadonnées de votre application logique. Cela vous permet d’importer votre application logique en tant que plug-in dans le noyau sémantique sans avoir à créer un client HTTP personnalisé pour gérer l’authentification pour l’importation initiale.
Le fichier host.json ci-dessous crée deux points de terminaison non authentifiés. Pour ce faire, accédez à la console kudu et modifiez le fichier host.json situé sur 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"
}
}
}
}
Configurer votre application pour Easy Auth
Vous souhaitez maintenant sécuriser vos flux de travail d’application logique afin que seuls les utilisateurs autorisés puissent y accéder. Pour ce faire, activez l’authentification facile sur votre application logique. Cela vous permettra d’utiliser le même mécanisme d’authentification que vos autres services Azure, ce qui facilite la gestion de vos stratégies de sécurité.
Pour obtenir une procédure pas à pas détaillée sur la configuration de l’authentification simple, reportez-vous à ce didacticiel intitulé Flux de travail déclencheur dans les applications logiques Standard avec authentification simple.
Pour ceux qui connaissent déjà Easy Auth (et disposent déjà d’une application cliente Entra que vous souhaitez utiliser), il s’agit de la configuration que vous souhaitez publier dans la gestion 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"
Utiliser Logic Apps avec le noyau sémantique comme plug-in
Maintenant que votre application logique est sécurisée et que les points de terminaison de métadonnées sont activés, vous avez terminé toutes les parties matérielles. Vous pouvez maintenant importer votre application logique en tant que plug-in dans le noyau sémantique à l’aide de la méthode d’importation OpenAPI.
Lorsque vous créez votre plug-in, vous devez fournir un client HTTP personnalisé qui peut gérer l’authentification pour votre application logique. Cela vous permettra d’utiliser le plug-in dans vos agents IA sans avoir à vous soucier de l’authentification.
Voici un exemple en C# qui tire parti de l’authentification interactive pour acquérir un jeton et authentifier l’utilisateur pour l’application logique.
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)
}
},
}
));
Étapes suivantes
Maintenant que vous savez comment créer un plug-in, vous pouvez maintenant apprendre à les utiliser avec votre agent IA. Selon le type de fonctions que vous avez ajoutées à vos plug-ins, vous devez suivre différents modèles. Pour les fonctions de récupération, reportez-vous à l’article sur l’utilisation des fonctions de récupération. Pour les fonctions d’automatisation des tâches, reportez-vous à l’article utilisation des fonctions d’automatisation des tâches .