Adicionar Logic Apps como plug-ins

Geralmente, em uma empresa, você já tem um conjunto de fluxos de trabalho que executam um trabalho real nos Aplicativos Lógicos. Eles podem ser usados por outros serviços de automação ou aplicativos front-end de energia com os quais os humanos interagem. Em Kernel semântico, você pode adicionar exatamente esses mesmos fluxos de trabalho que os plug-ins para que seus agentes também possam usá-los.

Veja, por exemplo, os fluxos de trabalho do Logic Apps usados pela equipe do Kernel semântico para responder a perguntas sobre novas PRs. Com os fluxos de trabalho a seguir, um agente tem tudo o que precisa para recuperar alterações de código, pesquisar arquivos relacionados e verificar logs de falhas.

Aplicativos Lógicos

Pesquisar arquivos – para localizar snippets de código relevantes para um determinado problema
Get file – para recuperar o conteúdo de um arquivo no repositório GitHub
Obter detalhes de PR – para recuperar os detalhes de uma PR (por exemplo, o título de PR, a descrição e o autor)
Obter arquivos de PR – para recuperar os arquivos que foram alterados em uma PR
Obter falhas de build e teste – para obter as falhas de build e teste de uma determinada execução do GitHub Actions
Get log file – para recuperar o arquivo de log para uma determinada execução de ação GitHub

Usar o Logic Apps para plug-ins do Kernel semântico também é uma ótima forma de aproveitar os mais de 1.400 conectores disponíveis no Logic Apps. Isso significa que você pode se conectar facilmente a uma ampla variedade de serviços e sistemas sem escrever nenhum código.

Importante

Hoje, você só pode adicionar aplicativos lógicos padrão (também conhecidos como Aplicativos Lógicos de locatário único) como plug-ins. Os Logic Apps de Consumo estarão disponíveis em breve.

Importando Logic Apps como plugins

Para adicionar fluxos de trabalho do Logic Apps ao Kernel semântico, você usará os mesmos métodos usados para carregar especificações OpenAPI. Veja abaixo alguns códigos de exemplo.

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

Configurando aplicativos lógicos para Kernel semântico

Antes de importar um Aplicativo Lógico como um plug-in, primeiro você deve configurar o Aplicativo Lógico para ser acessível por Kernel semântico. Isso envolve habilitar os endpoints de metadados e configurar seu aplicativo para o Easy Auth antes de, por fim, importar o Logic App como um plugin com autenticação.

Habilitar endpoints de metadados

Para facilitar a configuração, você pode habilitar o acesso não autenticado aos endpoints de metadados da sua Logic App. Isso permitirá que você importe seu Aplicativo Lógico como um plug-in para Kernel semântico sem a necessidade de criar um cliente HTTP personalizado para lidar com a autenticação para a importação inicial.

O arquivo host.json abaixo criará dois endpoints sem autenticação. Você pode fazer isso no portal do Azure acessando o console do Kudu e editando o arquivo de host.json localizado em C:\home\site\wwwroot\host.js.

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

Configurar seu aplicativo para Autenticação Fácil

Agora você deseja proteger seus fluxos de trabalho do Aplicativo Lógico para que somente usuários autorizados possam acessá-los. Você pode fazer isso habilitando o Easy Auth em seu Aplicativo Lógico. Isso permitirá que você use o mesmo mecanismo de autenticação que seus outros serviços de Azure, facilitando o gerenciamento de suas políticas de segurança.

Para obter um passo a passo detalhado sobre como configurar o Easy Auth, consulte este tutorial intitulado Disparar fluxos de trabalho em aplicativos lógicos Standard com o Easy Auth.

Para aqueles que já estão familiarizados com o Easy Auth (e já têm um aplicativo cliente do Entra que desejam usar), esta é a configuração que vocês devem enviar para o gerenciamento do 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"

Usar Logic Apps com o Kernel semântico como um plug-in

Agora que sua Logic App está protegida e os endpoints de metadados estão habilitados, você já concluiu toda a parte difícil. Agora você pode importar seu Aplicativo Lógico como um plug-in para Kernel semântico usando o método de importação OpenAPI.

Ao criar seu plug-in, você desejará fornecer um cliente HTTP personalizado que possa lidar com a autenticação para seu Aplicativo Lógico. Isso permitirá que você use o plug-in em seus agentes de IA sem precisar se preocupar com a autenticação.

Veja abaixo um exemplo em C# que aproveita a autenticação interativa para adquirir um token e autenticar o usuário para o Aplicativo Lógico.

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

Próximas Etapas

Agora que você sabe como criar um plug-in, agora você pode aprender a usá-los com seu agente de IA. Dependendo do tipo de funções que você adicionou aos plug-ins, há padrões diferentes que você deve seguir. Para funções de recuperação, consulte o artigo usando funções de recuperação . Para funções de automação de tarefas, consulte o artigo usando funções de automação de tarefas .

Saiba mais sobre como usar funções de recuperação

Last updated on 2026-05-26