Criar um fluxo de trabalho de aplicativo lógico Standard para Aplicativos Lógicos do Azure de locatário único usando Visual Studio Code

Aplica-se a: Aplicativos Lógicos do Azure (Standard)

Este guia de instruções mostra como criar um exemplo de fluxo de trabalho de integração que é executado em Aplicativos lógicos do Azure de locatário único usando o Visual Studio Code com a extensão Aplicativos Lógicos do Azure (Standard). Antes de criar esse fluxo de trabalho, você criará um recurso de aplicativo lógico Standard, que fornece os seguintes recursos:

• Seu aplicativo lógico pode incluir vários fluxos de trabalho com estado e sem estado.

• Os fluxos de trabalho no mesmo aplicativo lógico e locatário são executados no mesmo processo que o runtime dos Aplicativos Lógicos do Azure, para que compartilhem os mesmos recursos e forneçam melhor desempenho.

• Você pode criar, executar e testar localmente os fluxos de trabalho usando o ambiente de desenvolvimento do Visual Studio Code.

  Quando estiver pronto, você poderá implantar seu aplicativo lógico no Azure, no qual seu fluxo de trabalho pode ser executado no ambiente de Aplicativos Lógicos do Azure de locatário único ou em um Ambiente do Serviço de Aplicativo v3 (somente em planos do Serviço de Aplicativos baseados no Windows). Você também pode implantar e executar seu fluxo de trabalho em qualquer lugar em que o Kubernetes possa ser executado, incluindo o Azure, o Serviço de Kubernetes do Azure, localmente ou até mesmo em outros provedores de nuvem, devido ao runtime conteinerizado dos Aplicativos Lógicos do Azure.

  Observação

  A implantação do aplicativo lógico em um cluster do Kubernetes está atualmente em versão prévia pública.

  Para obter mais informações sobre os Aplicativos Lógicos do Azure de locatário único, consulte Locatário único versus multilocatário nos Aplicativos Lógicos do Azure.

Embora o exemplo de fluxo de trabalho seja baseado em nuvem e tenha apenas duas etapas, você pode criar fluxos de trabalho com centenas de operações que podem conectar uma ampla gama de aplicativos, dados, serviços e sistemas em ambientes de nuvem, locais e híbridos. O exemplo de fluxo de trabalho começa com o gatilho de Solicitação interno e segue com uma ação do Outlook do Office 365. O gatilho cria um ponto de extremidade que pode ser chamado para o fluxo de trabalho e aguarda uma solicitação HTTPS de entrada de qualquer chamador. Quando o gatilho recebe uma solicitação e é acionado, a próxima ação é executada enviando um email para o endereço de email especificado com as saídas selecionadas do gatilho.

Dica

Se não tem uma conta do Office 365, você pode usar qualquer outra ação disponível que possa enviar mensagens de sua conta de email, por exemplo, o Outlook.com.

Para criar este exemplo de fluxo de trabalho usando o portal do Azure, siga as etapas em Criar fluxos de trabalho de integração usando Aplicativos Lógicos do Azure de locatário único e o portal do Azure. As duas opções fornecem a capacidade de desenvolver, executar e implantar fluxos de trabalho de aplicativo lógico nos mesmos tipos de ambientes. No entanto, com o Visual Studio Code, você pode desenvolver, testar e executar fluxos de trabalho localmente no ambiente de desenvolvimento.

Durante o percurso, você concluirá estas tarefas de alto nível:

• Criar um projeto para seu aplicativo lógico e um fluxo de trabalhocom estado em branco.
• Adicionar um gatilho e uma ação.
• Executar, testar, depurar e examinar o histórico de execução localmente.
• Localizar os detalhes do nome de domínio para acesso ao firewall.
• Implantar no Azure, que inclui, opcionalmente, a habilitação do Application Insights.
• Gerenciar seu aplicativo lógico implantado no Visual Studio Code e no portal do Azure.
• Habilitar o histórico de execuções para fluxos de trabalho sem estado.
• Após a implantação, habilitar ou abrir o Application Insights.

Pré-requisitos

Conectividade e acesso

• Se você planeja criar projetos de aplicativo lógico Standard localmente e executar fluxos de trabalho usando apenas os conectores internos que funcionam nativamente no runtime dos Aplicativos Lógicos do Azure, você não precisará dos requisitos a seguir. No entanto, verifique se você tem as seguintes credenciais de conectividade e de conta do Azure para publicar ou implantar seu projeto do Visual Studio Code no Azure, usar os conectores gerenciados que funcionam no Azure global ou acessar os recursos e fluxos de trabalho do aplicativo lógico Standard já implantados no Azure:

  • Acesse a Internet para que você possa baixar os requisitos, conectar-se do Visual Studio Code à sua conta do Azure e publicar do Visual Studio Code no Azure.

  • Uma conta e uma assinatura do Azure. Se você não tem uma assinatura, inscreva-se em uma conta gratuita do Azure.

• Para criar o mesmo exemplo de fluxo de trabalho deste artigo, você precisa de uma conta de email do Outlook do Office 365 que use uma conta corporativa ou de estudante da Microsoft para entrar.

  Se você escolher um conector de email diferente, como o Outlook.com, ainda poderá seguir o exemplo, e as etapas gerais serão as mesmas. No entanto, suas opções poderão ser diferentes em alguns aspectos. Por exemplo, ao usar o conector do Outlook.com, use sua conta pessoal da Microsoft para entrar.

Ferramentas

1. Baixe e instale o Visual Studio Code gratuitamente.

2. Baixe e instale a extensão da Conta do Azure para Visual Studio Code para que você tenha uma única experiência comum para entrada do Azure e filtragem de assinatura em todas as extensões do Azure no Visual Studio Code. Este guia de instruções inclui etapas que usam essa experiência.

3. Baixe e instale as seguintes dependências do Visual Studio Code em seu sistema operacional específico usando qualquer um dos métodos:

   • Instalar todas as dependências automaticamente.
   • Baixe e instale cada dependência separadamente.

   Instalar todas as dependências automaticamente

   A partir da versão 2.81.5, a extensão dos Aplicativos Lógicos do Azure (Standard) para Visual Studio Code inclui um instalador de dependência que instala automaticamente todas as dependências necessárias em uma nova pasta binária e deixa as dependências existentes inalteradas. Para obter mais informações, consulte Comece mais facilmente com a extensão dos Aplicativos Lógicos do Azure (Standard) para Visual Studio Code.

   Essa extensão inclui as seguintes dependências:

   Dependência	Descrição
   C# para Visual Studio Code	Permite que a funcionalidade F5 execute seu fluxo de trabalho.
   Azurite para Visual Studio Code	Fornece um armazenamento de dados local e um emulador para usar com o Visual Studio Code para que você possa trabalhar em seu projeto de aplicativo lógico e executar seus fluxos de trabalho em seu ambiente de desenvolvimento local. Se você não quiser que o Azurite seja iniciado automaticamente, você poderá desabilitar essa opção: 1. No menu Arquivo, selecione Preferências>Configurações. 2. Na guia Usuário, selecione Extensões>Aplicativos Lógicos do Azure (Standard). 3. Localize a configuração chamada Aplicativos Lógicos do Azure Standard: Iniciar automaticamente o Azuritee desmarque a caixa de seleção selecionada.
   SDK do .NET 6.x.x	Inclui o Runtime do .NET 6.x.x, um pré-requisito do runtime dos Aplicativos Lógicos do Azure (Standard).
   Azure Functions Core Tools – Versão 4.x	Instala a versão com base no sistema operacional (Windows, macOSou Linux). Essas ferramentas incluem uma versão do mesmo runtime que alimenta o runtime do Azure Functions, que a extensão dos Aplicativos Lógicos do Azure (Standard) usa no Visual Studio Code.
   Node.js versão 16.x.x, a menos que uma versão mais recente já esteja instalada	Necessário para habilitar a ação de Operações de Código Embutido que executa o JavaScript.

   O instalador não executa as seguintes tarefas:

   • Verifique se as dependências necessárias já existem.
   • Instale apenas as dependências ausentes.
   • Atualize versões mais antigas de dependências existentes.

   1. Baixe e instale a extensão dos Aplicativos Lógicos do Azure (Standard) para Visual Studio Code, começando com a versão 2.81.5).

   2. No Visual Studio Code, na barra Atividades, selecione Extensões. (Teclado: Pressione Ctrl+Shift+X)

   3. No painel Extensões, abra o menu de reticências (...) e selecione Instalar no VSIX.

   4. Localize e selecione o arquivo VSIX baixado.

      Após a conclusão da instalação, a extensão ativa e executa automaticamente o comando Validar e instalar binários de dependência. Para exibir os logs de processo, abra a janela Saída.

   5. Quando a solicitação a seguir for exibida, selecione Sim (Recomendado) para confirmar se você deseja instalar automaticamente as dependências necessárias:

      

   6. Recarregue o Visual Studio Code, se necessário.

   7. Confirme se as dependências aparecem corretamente na seguinte pasta:

      C:\Users\<your-user-name>\.azurelogicapps\dependencies\<dependency-name>

   8. Confirme as seguintes configurações de extensão no Visual Studio Code:

      1. No menu Arquivo, selecione Preferências>Configurações.

      2. Na guia Usuário, selecione Extensões>Aplicativos Lógicos do Azure (Standard).

      3. Examine as seguintes configurações:

         Configuração de extensão	Valor
         Caminho de dependências	C:\Users\<your-user-name>\.azurelogicapps\dependencies
         Tempo limite de dependência	60 segundos
         Caminho Binário do Dotnet	C:\Users\<your-user-name>\.azurelogicapps\dependencies\DotNetSDK\dotnet.exe
         Caminho binário das Ferramentas do Func Core	C:\Users\<your-user-name>\.azurelogicapps\dependencies\FuncCoreTools\func
         Caminho binário do JS do nó	C:\Users\<your-user-name>\.azurelogicapps\dependencies\NodeJs\node
         Iniciar automaticamente o Azurite	Enabled
         Tempo de Design de Início Automático	Enabled

   9. Se você tiver um projeto de aplicativo lógico existente com tarefas definidas personalizadas armazenadas no arquivo .vscode/tasks.json, salve o arquivo tasks.json em outro lugar antes de abrir seu projeto.

      Ao abrir seu projeto, você será solicitado a atualizar o arquivo tasks.json para usar as dependências necessárias. Se você optar por continuar, a extensão substituirá o arquivo tasks.json.

   10. Quando você abre seu projeto de aplicativo lógico, as seguintes notificações são exibidas:

       Notificação	Ação
       Sempre iniciar o processo de tempo de design em segundo plano na inicialização?	Para abrir o designer de fluxo de trabalho mais rapidamente, selecione Sim (Recomendado).
       Configurar o Azurite para iniciar automaticamente na inicialização do projeto?	Para que o armazenamento do Azurite seja iniciado automaticamente quando o projeto for aberto, selecione Habilitar Início Automático. Na parte superior do Visual Studio Code, na janela de comando exibida, pressione Enter para aceitar o caminho padrão: C\Users\<your-user-name>\.azurelogicapps\.azurite

   Problemas conhecidos com visualização

   • Se você optou por instalar automaticamente todas as dependências em um computador que não tem nenhuma versão do SDK do .NET Core, a seguinte mensagem será exibida:

     "O SDK do .NET Core não pode ser localizado: erro ao executar dotnet -- info: Erro: falha no comando: dotnet --info 'dotnet não é reconhecido como um comando interno ou externo, programa operável ou arquivo em lote. 'dotnet' não é reconhecido como um comando interno ou externo, programa operável ou arquivo em lote. . A depuração do .NET Core não será habilitada. Verifique se o SDK do .NET Core está instalado e está no caminho."

     Você recebe essa mensagem porque a estrutura do .NET Core ainda está sendo instalada quando a extensão é ativada. Você pode optar por desabilitar essa mensagem com segurança.

     Se você tiver problemas para abrir um projeto de aplicativo lógico existente ou iniciar a tarefa de depuração (tasks.json) para func host start e essa mensagem aparecer, siga essas etapas para resolver o problema:

     1. Adicione o caminho binário do dotnet à variável PATH do ambiente.

        1. Na barra de tarefas do Windows, na caixa de pesquisa, insira variáveis de ambiente e selecione Editar as variáveis de ambiente do sistema.

        2. Na caixa Propriedades do Sistema, na guia Avançado, selecione Variáveis de Ambiente.

        3. Na caixa Variáveis de Ambiente, nas variáveis de usuário para< a lista >your-user-name, selecione PATH e, em seguida, selecione Editar.

        4. Se o seguinte valor não aparecer na lista, selecione Novo para adicionar o seguinte valor:

           C:\Users\<your-user-name>\.azurelogicapps\dependencies\DotNetSDK

        5. Quando terminar, selecione OK.

     2. Feche todas as janelas do Visual Studio Code e reabra seu projeto.

   • Se você tiver problemas para instalar e validar dependências binárias, por exemplo:

     • Problemas de permissões do Linux
     • Você obtém o seguinte erro: <Arquivo ou caminho> não existe
     • A validação fica presa em <dependency-name>.

     Siga essas etapas para executar o comando Validar e instalar dependências binárias novamente:

     1. No menu Exibir, selecione Paleta de Comandos.

     2. Quando a janela de comando for exibida, insira e execute o comando Validar e instalar dependências binárias.

   • Se você não tiver o .NET Core 7 ou uma versão posterior instalada e abrir um workspace dos Aplicativos Lógicos do Azure que contenha um projeto do Azure Functions, receberá a seguinte mensagem:

     Houve problemas ao carregar o projeto [function-name].csproj. Consulte o log para obter detalhes.

     Esse componente ausente não afeta o projeto do Azure Functions, portanto, você pode ignorar essa mensagem com segurança.

   Instalar cada dependência separadamente

   Dependência	Descrição
   SDK do .NET 6.x.x	Inclui o Runtime do .NET 6.x.x, um pré-requisito do runtime dos Aplicativos Lógicos do Azure (Standard).
   Azure Functions Core Tools – Versão 4.x	- Windows: use a versão do MSI (Microsoft Installer), que é func-cli-X.X.XXXX-x*.msi. - macOS - Linux Essas ferramentas incluem uma versão do mesmo runtime que alimenta o runtime do Azure Functions, que a extensão dos Aplicativos Lógicos do Azure (Standard) usa no Visual Studio Code. Se você tiver uma instalação anterior a essas versões, desinstale essa versão primeiro ou verifique se a variável de ambiente PATH aponta para a versão que você baixou e instalou.
   Node.js versão 16.x.x, a menos que uma versão mais recente já esteja instalada	Necessário para habilitar a ação de Operações de Código Embutido que executa o JavaScript. Observação: Para o Windows, baixe a versão do MSI. Se, em vez disso, você usar a versão ZIP, precisará disponibilizar manualmente o Node.js usando uma variável de ambiente PATH para o sistema operacional.

4. Se você já instalou a versão da extensão dos Aplicativos Lógicos do Azure (Standard) que instala automaticamente todas as dependências (versão prévia), ignore essa etapa. Caso contrário, baixe e instale a extensão dos Aplicativos Lógicos do Azure (Standard) para Visual Studio Code.

   1. No Visual Studio Code, na barra de ferramentas esquerda, selecione Extensões.

   2. Na caixa de pesquisa de extensões, insira aplicativos lógicos do azure standard. Na lista de resultados, selecione Aplicativos Lógicos do Azure (Standard) > Instalar.

      Após a conclusão da instalação, a extensão aparecerá na lista Extensões: instaladas.

      

      Dica

      Se a extensão não aparecer na lista instalada, tente reiniciar o Visual Studio Code.

   No momento, você pode ter extensões de Consumo (multilocatário) e Standard (locatário único) instaladas ao mesmo tempo. As experiências de desenvolvimento diferem uma da outra de algumas maneiras, mas sua assinatura do Azure pode incluir os tipos de aplicativo lógico Standard e Consumo. No Visual Studio Code, a janela do Azure mostra todos os aplicativos lógicos implantados e hospedados no Azure em sua assinatura do Azure, mas organiza seus aplicativos das seguintes maneiras:

   • Seção Aplicativos Lógicos (Consumo): todos os aplicativos lógicos de consumo em sua assinatura.

   • Seção Recursos: todos os aplicativos lógicos Standard em sua assinatura. Anteriormente, esses aplicativos lógicos apareciam na seção Aplicativos Lógicos (Standard), que agora foi movida para a seção Recursos.

5. Para executar localmente gatilhos e ações baseados em webhook, como o gatilho interno de Webhook HTTP, no Visual Studio Code, você precisa configurar o encaminhamento para a URL de retorno de chamada.

6. Ao criar seus recursos de aplicativo lógico com configurações compatíveis com o uso do Application Insights, é possível habilitar o log de diagnóstico e o rastreamento para o recurso de aplicativo lógico. Isso pode ser feito ao criar o aplicativo lógico ou após a implantação. É necessário ter uma instância do Application Insights, mas esse recurso pode ser criado com antecedência ao criar seu aplicativo lógico, ou após a implantação.

7. Instale ou use uma ferramenta que pode enviar solicitações HTTP para testar sua solução, por exemplo:

   • Visual Studio Code com uma extensão do Visual Studio Marketplace
   • Invoke-RestMethod do PowerShell
   • Microsoft Edge – ferramenta Console de Rede
   • Bruno
   • curl

   Cuidado

   Para cenários em que você tem dados confidenciais, como credenciais, segredos, tokens de acesso, chaves de API e outras informações semelhantes, use uma ferramenta que proteja seus dados com os recursos de segurança necessários, funcione offline ou localmente, não sincronize seus dados com a nuvem e não exija que você entre em uma conta online. Dessa forma, você reduz o risco de expor dados confidenciais ao público.

Configurar o Visual Studio Code

1. Para certificar-se de que todas as extensões estejam instaladas corretamente, recarregue ou reinicie o Visual Studio Code.

2. Confirme se o Visual Studio Code localiza e instala automaticamente as atualizações de extensão para que todas as suas extensões recebam as últimas atualizações. Caso contrário, você precisará desinstalar manualmente a versão desatualizada e instalar a versão mais recente.

   1. No menu Arquivo, acesse Preferências > Configurações.

   2. Na guia Usuário, acesse Recursos > Extensões.

   3. Confirme se a opção Atualizações de Verificação Automática está selecionada e se aAtualização Automática está definida como Todas as Extensões.

3. Confirme se a configuraçãoAplicativos Lógicos do Azure Standard: Runtime do Projeto dos Aplicativos Lógicos do Azure (Standard) está definida como versão ~4:

   Observação

   Esta versão é necessária para usar as ações de Operações de Código Embutido.

   1. No menu Arquivo, acesse Preferências > Configurações.

   2. Na guia Usuário, acesse > Extensões > Aplicativos Lógicos do Azure (Standard).

      Por exemplo, você pode encontrar a configuração Aplicativos Lógicos do Azure Standard: Runtime do Projeto aqui ou usar a caixa de pesquisa para localizar outras configurações:

      

Conectar-se à sua conta do Azure

1. Na Barra de Atividade do Visual Studio Code, selecione o ícone do Azure.

   

2. Na janela do Azure, em Recursos, selecione Entrar no Azure. Quando a página de autenticação do Visual Studio Code for exibida, entre com sua conta do Azure.

   

   Depois de entrar, a janela do Azure mostra as assinaturas do Azure associadas à sua conta do Azure. Se as assinaturas esperadas não aparecerem ou se você quiser que o painel mostre apenas assinaturas específicas, siga estas etapas:

   1. Na lista de assinaturas, mova o ponteiro ao lado da primeira assinatura até que o botão Selecionar Assinaturas (ícone de filtro) seja exibido. Selecione o ícone de filtro.

      

      Ou, na barra de status do Visual Studio Code, selecione sua conta do Azure.

   2. Quando outra lista de assinaturas for exibida, escolha as assinaturas desejadas e selecione OK.

Criar um projeto local

Antes de criar seu aplicativo lógico, crie um projeto local para que você possa gerenciar, executar e implantar seu aplicativo lógico do Visual Studio Code. O projeto subjacente é semelhante a um projeto do Azure Functions, também conhecido como um projeto de aplicativo de funções. No entanto, esses tipos de projeto são separados uns dos outros, assim, os aplicativos lógicos e os aplicativos de função não podem existir no mesmo projeto.

1. Em seu computador, crie uma pasta local vazia a ser usada para o projeto que você criará posteriormente no Visual Studio Code.

2. No Visual Studio Code, feche todas as pastas abertas.

3. Na janela do Azure, na barra de ferramentas da seção Workspace, no menu Aplicativos Lógicos do Azure, selecione Criar Novo Projeto.

   

4. Se o Windows Defender Firewall solicitar que você conceda acesso à rede para Code.exe, que é o Visual Studio Code, e para func.exe, que é o Azure Functions Core Tools, selecione Redes privadas, como minha rede doméstica ou de trabalho > Permitir acesso.

5. Navegue até o local no qual você criou a pasta do projeto, selecione essa pasta e continue.

   

6. Na lista de modelos exibida, selecione Fluxo de Trabalho com Estado ou Fluxo de Trabalho sem Estado. Este exemplo seleciona Fluxo de Trabalho com Estado.

   

7. Forneça um nome para seu fluxo de trabalho e pressione Enter. Este exemplo usa Stateful-Workflow como o nome.

   

   Observação

   Você poderá receber um erro chamado azureLogicAppsStandard.createNewProject com a mensagem de erro Não é possível fazer gravações nas configurações do workspace porque azureFunctions.suppressProject não é uma configuração registrada. Nesse caso, tente instalar a extensão do Azure Functions para Visual Studio Code, diretamente do Visual Studio Marketplace ou por meio do Visual Studio Code.

8. Se o Visual Studio Code solicitar que você abra seu projeto no Visual Studio Code atual ou em uma nova janela do Visual Studio Code, selecione Abrir na janela atual. Caso contrário, selecione Abrir em uma nova janela.

   O Visual Studio Code termina de criar o seu projeto.

9. Na Barra de Atividades do Visual Studio, abra o painel do Explorer, se ainda não estiver aberto.

   O painel Explorer mostra seu projeto, que agora inclui arquivos de projeto gerados automaticamente. Por exemplo, o projeto tem uma pasta que mostra o nome do fluxo de trabalho. Dentro dessa pasta, o arquivo workflow.json contém a definição de JSON subjacente do fluxo de trabalho.

   

   No Visual Studio Code, seu projeto de aplicativo lógico tem um dos seguintes tipos:

   • Baseado em pacote de extensão (Node.js), que é o tipo padrão
   • Baseado em pacote NuGet (.NET), que você pode converter pelo tipo padrão

   Com base nesses tipos, o projeto incluirá pastas e arquivos ligeiramente diferentes. Um projeto baseado em NuGet inclui uma pasta .bin que contém pacotes e outros arquivos de biblioteca. Um projeto baseado em pacote não inclui a pasta .bin e outros arquivos. Alguns cenários exigem um projeto baseado em NuGet para que o aplicativo seja executado, como quando você deseja desenvolver e executar operações personalizadas. Para obter mais informações sobre como converter o projeto para usar o NuGet, confira Habilitar a criação de conector integrado.

   Para o projeto padrão baseado em pacote, seu projeto tem uma estrutura de pasta e arquivo semelhante ao seguinte exemplo:

   MyBundleBasedLogicAppProjectName
   | .vscode
   | Artifacts
     || Maps 
        ||| MapName1
        ||| ...
     || Schemas
        ||| SchemaName1
        ||| ...
   | WorkflowName1
     || workflow.json
     || ...
   | WorkflowName2
     || workflow.json
     || ...
   | workflow-designtime
   | .funcignore
   | connections.json
   | host.json
   | local.settings.json
   

   No nível raiz do projeto, você pode encontrar os seguintes arquivos e pastas com outros itens:

   Nome	Pasta ou arquivo	Descrição
   .vscode	Pasta	Contém os arquivos de configurações relacionadas ao Visual Studio Code, como os arquivos extensions.json, launch.json, settings.json e tasks.json.
   Artefatos	Pasta	Contém artefatos de conta de integração que você define e usa em fluxos de trabalho que suportam cenários B2B (entre empresas). Por exemplo, a estrutura de exemplo inclui mapas e esquemas para operações de transformação e validação XML.
   <WorkflowName>	Pasta	Para cada fluxo de trabalho, a pasta <WorkflowName> inclui um arquivo workflow.json, que contém a definição JSON subjacente desse fluxo de trabalho.
   workflow-designtime	Pasta	Contém arquivos de configurações relacionados ao ambiente de desenvolvimento.
   .funcignore	Arquivo	Contém informações relacionadas ao Azure Functions Core Tools instalado.
   connections.json	Arquivo	Contém os metadados, pontos de extremidade e chaves para conexões gerenciadas e funções do Azure usados pelos fluxos de trabalho. Importante: para usar diferentes conexões e funções para cada ambiente, certifique-se de parametrizar esse arquivo connections.json e atualizar os pontos de extremidade.
   host. JSON	Arquivo	Contém definições e valores de configuração específicos do runtime, como limites padrão para a plataforma de Aplicativos Lógicos do Azure de locatário único, aplicativos lógicos, fluxos de trabalho, gatilhos e ações. No nível raiz do projeto de aplicativo lógico, o arquivo de metadados host.json contém as definições de configuração e os valores padrão que todos os fluxos de trabalho no mesmo aplicativo lógico usam durante a execução, seja localmente ou no Azure. Observação: quando você cria seu aplicativo lógico, o Visual Studio Code cria um arquivo host.snapshot.*.json em seu contêiner de armazenamento. Se você excluir seu aplicativo lógico, esse arquivo de backup não será excluído. Se você criar outro aplicativo lógico com o mesmo nome, outro arquivo de instantâneo será criado. Você pode ter apenas até dez instantâneos para o mesmo aplicativo lógico. Se ultrapassar esse limite, você verá o seguinte erro: Microsoft.Azure.WebJobs.Script.WebHost: Repository has more than 10 non-decryptable secrets backups (host)) Para resolver esse erro, exclua os arquivos de instantâneo adicionais do seu contêiner de armazenamento.
   local.settings.json	Arquivo	Contém configurações de aplicativo, cadeias de conexão e outras configurações usadas pelos fluxos de trabalho ao serem executados localmente. Ou seja, essas configurações e valores se aplicam somente quando você executa seus projetos no ambiente de desenvolvimento local. Durante a implantação para o Azure, o arquivo e as configurações são ignorados e não são incluídos na implantação. Esse arquivo armazena configurações e valores como variáveis de ambiente local que são usadas pelas ferramentas de desenvolvimento local como os valores appSettings. Você pode chamar e fazer referência a essas variáveis de ambiente no runtime e durante a implantação usando configurações de aplicativo e parâmetros. Importante: o arquivo local.settings.json pode conter segredos; verifique se você também excluiu esse arquivo do seu controle do código-fonte do projeto.

   Observação

   A configuração de aplicativo FUNCTIONS_WORKER_RUNTIME é necessária para o aplicativo lógico Standard e o valor foi definido anteriormente como nó. No entanto, o valor necessário agora é dotnet para todos os aplicativos lógicos Standard implantados, novos e atuais. Essa alteração no valor não deve afetar o runtime do fluxo de trabalho e tudo deve funcionar da mesma maneira. Para obter mais informações, consulte a configuração do aplicativo FUNCTIONS_WORKER_RUNTIME .

   A configuração do aplicativo APP_KIND é necessária para o aplicativo lógico Standard e o valor deve ser workflowApp. No entanto, em alguns cenários, essa configuração de aplicativo pode estar ausente, por exemplo, devido à automação com modelos do Azure Resource Manager ou a outros cenários em que ela não é incluída. Se determinadas ações não funcionarem, como a ação Executar código JavaScript, ou o fluxo de trabalho parar de funcionar, verifique se a configuração de aplicativo APP_KIND existe e está definida como workflowApp. Para obter mais informações, confira a configuração de aplicativo APP_KIND.

Converter seu projeto em .NET (baseado em pacote NuGet)

Por padrão, o Visual Studio Code cria um projeto de aplicativo lógico Node.js (baseado em pacote de extensão) e não em .NET (baseado em pacote NuGet). Caso precise de um projeto de aplicativo lógico .NET (baseado em pacote NuGet), por exemplo, para habilitar a criação interna do conector, será necessário converter seu projeto de Node.js (baseado em pacote de extensão) para .NET (baseado em pacote NuGet).

Importante

Essa ação é uma operação unidirecional que não pode ser desfeita.

1. No painel do Explorer, na raiz do seu projeto, mova o ponteiro do mouse sobre qualquer área em branco abaixo de todos os outros arquivos e pastas, abra o menu de atalho e selecione Converter em projeto de Aplicativo lógico baseado em NuGet.

   

2. Quando o prompt for exibido, confirme a conversão do projeto.

Habilitar a criação de conectores internos

Você pode criar seus conectores internos para qualquer serviço necessário usando a estrutura de extensibilidade dos Aplicativos Lógicos do Azure de locatário único. De maneira semelhante a conectores internos como o Barramento de Serviço do Azure e o SQL Server, esses conectores fornecem maior taxa de transferência, baixa latência, conectividade local e execução nativa no mesmo processo que o runtime dos Aplicativos Lógicos do Azure de locatário único.

No momento, a capacidade de criação está disponível apenas no Visual Studio Code, mas não está habilitada por padrão. Para criar esses conectores, siga estas etapas:

1. Caso ainda não tenha feito isso, converta seu projeto de Node.js (baseado em pacote de extensão) em .NET (baseado em pacote NuGet).

2. Examine e siga as etapas no artigo, Aplicativos Lógicos do Azure em Execução em Qualquer Lugar – Extensibilidade de conector interno.

Adicionar artefatos personalizados ao seu projeto

Em um fluxo de trabalho de aplicativo lógico, alguns conectores têm dependências de artefatos, como mapas, esquemas ou assemblies. No Visual Studio Code, você pode carregar esses artefatos em seu projeto de aplicativo lógico, semelhante a como você pode carregar esses artefatos no portal do Azure por meio do menu de recursos do aplicativo lógico em Artefatos, por exemplo:

Adicionar mapas ao seu projeto

Para adicionar mapas ao seu projeto, na hierarquia do projeto, expanda Artefatos>Mapas, que é a pasta em que você pode colocar seus mapas.

Adicionar esquemas ao seu projeto

Para adicionar esquemas ao projeto, na hierarquia do projeto, expanda Artefatos>Esquemas, que é a pasta em que você pode colocar seus esquemas.

Adicionar assemblies ao seu projeto

Um aplicativo lógico Standard pode usar ou referenciar tipos específicos de assemblies, que podem ser carregados no projeto no Visual Studio Code. No entanto, você deve adicioná-las a pastas específicas em seu projeto. A tabela a seguir fornece mais informações sobre cada tipo de assembly e onde exatamente colocá-los em seu projeto.

Tipo de assembly	Descrição
Assembly de cliente/SDK (.NET Framework)	Esse tipo de assembly fornece armazenamento e implantação de cliente e SDK personalizado para o .NET Framework. Por exemplo, o conector interno do SAP usa esses assemblies para carregar os arquivos da DLL não redistribuíveis do SAP NCo. Adicione esses assemblies à seguinte pasta: \lib\builtinOperationSdks\net472
Assembly de cliente/SDK (Java)	Esse tipo de assembly fornece armazenamento e implantação do SDK personalizado para Java. Por exemplo, o conector interno JDBC usa esses arquivos JAR para localizar drivers JDBC para RDBs (bancos de dados relacionais personalizados). Adicione esses assemblies na seguinte pasta: \lib\builtinOperationSdks\JAR
Assembly personalizado (.NET Framework)	Esse tipo de assembly fornece armazenamento e implantação de DLLs personalizadas. Por exemplo, a operação Transform XML usa esses assemblies para as funções de transformação personalizadas necessárias durante a transformação XML. Adicione esses assemblies à seguinte pasta: \lib\custom\net472

A imagem a seguir mostra onde colocar cada tipo de assembly em seu projeto:

Para obter mais informações sobre como carregar assemblies no recurso de aplicativo lógico no portal do Azure, consulte Adicionar assemblies referenciados.

Migrar projetos baseados em NuGet para usar assemblies "lib\*"

Importante

Essa tarefa é necessária apenas para projetos de aplicativo lógico baseado em NuGet.

Se você criou seu projeto de aplicativo lógico quando o suporte a assemblies não estava disponível para fluxos de trabalho de aplicativo lógico Standard, você pode adicionar as seguintes linhas ao arquivo <project-name>.csproj para trabalhar com projetos que usam assemblies:

  <ItemGroup>
    <LibDirectory Include="$(MSBuildProjectDirectory)\lib\**\*"/>
  </ItemGroup>
  <Target Name="CopyDynamicLibraries" AfterTargets="_GenerateFunctionsExtensionsMetadataPostPublish">
    <Copy SourceFiles="@(LibDirectory)" DestinationFiles="@(LibDirectory->'$(MSBuildProjectDirectory)\$(PublishUrl)\lib\%(RecursiveDir)%(Filename)%(Extension)')"/>
  </Target>

Importante

Para um projeto executado no Linux ou macOS, atualize o separador de diretório. Por exemplo, examine a imagem a seguir que mostra o código anterior adicionado ao arquivo <project-name>.csproj.

Abrir o arquivo de definição de fluxo de trabalho no designer

1. Expanda a pasta de projeto do fluxo de trabalho, que é denominada Stateful-Workflow neste exemplo, e abra o arquivo workflow.json.

2. Abra o menu de atalho do arquivo workflow.json e selecione Abrir Designer.

   

3. Depois que a lista Habilitar conectores no Azure for aberta, selecione Usar conectores do Azure, que se aplica a todos os conectores gerenciados ou "compartilhados", que são hospedados e executados no Azure versus os conectores internos, nativos ou "no aplicativo", que são executados diretamente com o runtime dos Aplicativos Lógicos do Azure.

   

   Observação

   Atualmente, os fluxos de trabalho sem estado suportam apenas ações de conectores gerenciados, não gatilhos. Embora você tenha a opção de habilitar conectores no Azure para seu fluxo de trabalho sem estado, o designer não mostra nenhum gatilho de conector gerenciado para você selecionar.

4. Depois que a lista Selecionar assinatura for aberta, selecione a assinatura do Azure a ser usada para o seu projeto de aplicativo lógico.

   

5. Depois que a lista de grupos de recursos for aberta, selecione Criar novo grupo de recursos.

   

6. Forneça um nome para o grupo de recursos e pressione Enter. Este exemplo usa Fabrikam-Workflows-RG.

   

7. Na lista de locais, selecione a região do Azure a ser usada ao criar os recursos e o grupo de recursos. Este exemplo usa Centro-Oeste dos EUA.

   

   Depois de executar essa etapa, o Visual Studio Code abrirá o designer de fluxo de trabalho.

   Observação

   Quando o Visual Studio Code inicia a API de tempo de design do fluxo de trabalho, você pode receber uma mensagem informando que a inicialização pode levar alguns segundos. Você pode ignorar esta mensagem ou selecionar OK.

   Se o designer não abrir, examine a seção de solução de problemas, Falha ao abrir o designer.

   Depois que o designer é exibido, o prompt Adicionar um gatilho é exibido no designer.

8. No designer, selecione Adicionar um gatilho, que abre o painel Adicionar um gatilho e uma galeria mostrando todos os conectores que têm gatilhos para você selecionar.

   

9. Em seguida, adicione um gatilho e ações ao seu fluxo de trabalho.

Adicionar um gatilho e ações

Depois de abrir um fluxo de trabalho em branco no designer, o prompt Adicionar um gatilho é exibido no designer. Agora você pode começar a criar seu fluxo de trabalho adicionando um gatilho e ações.

Importante

Para executar localmente um fluxo de trabalho que usa um gatilho ou ações baseadas em webhook, como o gatilho ou a ação de Webhook HTTP interno, você deve habilitar esse recurso Configurando o encaminhamento para a URL de retorno de chamada do webhook.

O fluxo de trabalho neste exemplo usa o seguinte gatilho e ações:

• O gatilho do conector interno de solicitação nomeado Quando uma solicitação HTTP é recebida, que pode receber chamadas ou solicitações de entrada e cria um terminal que outros serviços ou fluxos de trabalho de aplicativos lógicos podem chamar.

• A ação do conector gerenciada do Outlook do Office 365 denominada Enviar um email. Para seguir este guia de instruções, você precisa de uma conta de email do Outlook do Office 365. Se você tiver uma conta de email compatível com um conector diferente, poderá usar esse conector, mas a experiência do usuário desse conector será diferente das etapas neste exemplo.

• A ação de Solicitação do conector incorporada denominada Resposta, que você usa para enviar uma resposta e retornar os dados de volta ao chamador.

Adicionar o gatilho de Solicitação

1. No designer de fluxo de trabalho, no painel Adicionar um gatilho, abra a lista Runtime e selecione No aplicativo para exibir apenas os gatilhos de conector interno disponíveis.

2. Localize o gatilho de Solicitação chamado Quando uma solicitação HTTP é recebida usando a caixa de pesquisa e adicione esse gatilho ao fluxo de trabalho. Para obter mais informações, confira Criar um fluxo de trabalho com um gatilho e ações.

   

   Quando o gatilho aparece no designer, o painel de informações do gatilho é aberto e mostra os parâmetros, configurações e outras ações relacionadas do gatilho.

   

   Dica

   Se o painel de informações não aparecer, verifique se o gatilho está selecionado no designer.

3. Salve seu fluxo de trabalho. Selecione Salvar na barra de ferramentas do designer.

Se precisar excluir um item, siga as etapas para excluir itens do designer.

Adicionar a ação do Office 365 Outlook

1. No designer, no gatilho da Solicitação, selecione o sinal de adição (+) >Adicionar uma ação.

2. No painel Adicionar uma ação que é aberto, na lista Runtime, selecione Compartilhado para que você exiba apenas as ações do conector gerenciado disponíveis.

3. Localize a ação do conector gerenciado do Outlook do Office 365 chamada Enviar um email (V2) usando a caixa de pesquisa e adicione essa ação ao fluxo de trabalho. Para obter mais informações, confira Criar um fluxo de trabalho com um gatilho e ações.

   

4. Quando o painel de autenticação da ação abrir, selecione Entrar para criar uma conexão com sua conta de email.

   

5. Siga os prompts subsequentes para selecionar sua conta, permitir o acesso e permitir o retorno ao Visual Studio Code.

   Observação

   Se passar muito tempo antes de concluir os prompts, o processo de autenticação atingirá o tempo limite e falhará. Nesse caso, retorne ao designer e tente entrar novamente para criar a conexão.

   1. Quando o prompt da Microsoft for exibido, selecione a conta de usuário para o Outlook do Office 365 e, em seguida, selecione Permitir acesso.

   2. Quando os Aplicativos Lógicos do Azure solicitarem a abertura de um link do Visual Studio Code, selecione Abrir.

      

   3. Quando o Visual Studio Code solicitar a abertura das Ferramentas do Microsoft Azure, selecione Abrir.

      

   Dica

   Para ignorar esses prompts futuros, selecione as seguintes opções quando os prompts associados aparecerem:

   • Permissão para abrir o link para o Visual Studio Code: selecione Sempre permitir que logic-apis-westcentralus.consent.azure-apim.net abra links desse tipo no aplicativo associado. Este domínio é alterado com base na região do Azure que você selecionou para o recurso de aplicativo lógico.

   • Permissão para abrir as Ferramentas do Microsoft Azure: selecione Não solicitar novamente essa extensão.

   Depois que o Visual Studio Code cria sua conexão, alguns conectores mostram a mensagem de que a conexão será válida somente por {n} dias. Esse limite de tempo aplica-se apenas à duração enquanto você cria o seu fluxo de trabalho de aplicativo lógico no Visual Studio Code. Após a implantação, esse limite não se aplica mais porque seu fluxo de trabalho pode autenticar em runtime usando sua identidade gerenciada atribuída pelo sistema habilitada automaticamente. Essa identidade gerenciada difere das credenciais de autenticação ou da cadeia de conexão que você usa ao criar uma conexão. Se você desabilitar essa identidade gerenciada atribuída pelo sistema, as conexões não funcionarão no runtime.

6. No designer, se a ação Enviar um email não aparecer selecionada, selecione essa ação.

7. No painel de informações da ação, na guia Parâmetros, forneça as informações necessárias para a ação, por exemplo:

   

   Propriedade	Obrigatório	Valor	Descrição
   Para	Sim	<your-email-address>	O destinatário do email, que pode ser seu endereço de email para fins de teste. Este exemplo usa o endereço de email fictício sophia.owen@fabrikam.com.
   Assunto	Sim	Um email do seu fluxo de trabalho de exemplo	O assunto do email
   Corpo	Sim	Olá do seu exemplo de fluxo de trabalho!	O conteúdo do corpo do email

   Observação

   Se você fizer alguma alteração na guia Teste, selecione Salvar para confirmar essas alterações antes de alternar as guias ou alterar o foco para o designer. Caso contrário, o Visual Studio Code não manterá suas alterações.

8. Salve seu fluxo de trabalho. No designer, selecione Salvar.

Habilitar webhooks em execução localmente

Quando você usa um gatilho ou uma ação baseada em webhook, como Webhook HTTP, com um fluxo de trabalho de aplicativo lógico em execução no Azure, o runtime dos Aplicativos Lógicos assina o ponto de extremidade de serviço gerando e registrando um URL de retorno de chamada com esse ponto de extremidade. O gatilho ou a ação aguarda o ponto de extremidade de serviço para chamar a URL. No entanto, quando você está trabalhando no Visual Studio Code, a URL de retorno de chamada gerada começa com http://localhost:7071/.... Essa URL é para o servidor localhost, que é privado, para que o ponto de extremidade de serviço não possa chamar essa URL.

Para executar localmente gatilhos e ações baseados em webhook no Visual Studio Code, você precisa configurar uma URL pública que expõe o servidor localhost e encaminha com segurança as chamadas do ponto de extremidade de serviço para a URL de retorno de chamada do webhook. Você pode usar um serviço de encaminhamento e uma ferramenta como ngrok, que abre um túnel HTTP para a porta do localhost, ou pode usar sua ferramenta equivalente.

Configurar o encaminhamento de chamada usando o ngrok

1. Vá para o site do ngrok. Inscreva-se para uma nova conta ou entre em sua conta, se você já tiver uma.

2. Obtenha seu token de autenticação pessoal, que o cliente do ngrok precisa para se conectar e autenticar o acesso à sua conta.

   1. Para localizar sua página do token de autenticação, no menu do painel da sua conta, expanda Autenticação e selecione Seu Authtoken.

   2. Na caixa Seu Authtoken, copie o token para um local seguro.

3. Na página de download do ngrok ou no painel da sua conta, baixe a versão do ngrok que você deseja e extraia o arquivo .zip. Para saber mais, confira Etapa 1: Descompactar para instalar.

4. Em seu computador, abra a ferramenta de prompt de comando. Navegue até o local onde você tem o arquivo ngrok.exe.

5. Conecte o cliente ngrok à sua conta do ngrok executando o comando a seguir. Para saber mais, confira Etapa 2: Conectar sua conta.

   ngrok authtoken <your_auth_token>

6. Abra o túnel HTTP para a porta localhost 7071 executando o comando a seguir. Para saber mais, confira Etapa 3: Acionar.

   ngrok http 7071

7. Da saída, encontre a seguinte linha:

   http://<domain>.ngrok.io -> http://localhost:7071

8. Copie e salve a URL, que tem este formato: http://<domain>.ngrok.io

Configurar a URL de encaminhamento nas configurações do aplicativo

1. No Visual Studio Code, em designer, adicione o gatilho ou ação baseado em webhook que você deseja usar.

   Este exemplo continua com o gatilho HTTP + Webhook.

2. Quando o prompt for exibido pedindo o local do ponto de extremidade do host, insira a URL de encaminhamento (redirecionamento) que você criou anteriormente.

   Observação

   Ignorar o prompt faz com que apareça um aviso de que você deve fornecer a URL de encaminhamento, portanto, selecione Configurare insira a URL. Depois de concluir essa etapa, o prompt não reaparecerá para gatilhos ou ações de webhook subsequentes que você adicionar.

   Para fazer com que o prompt apareça, no nível raiz do seu projeto, abra o menu de atalho do arquivo local.settings.json e selecione Configurar o Ponto de Extremidade de Redirecionamento do Webhook. O prompt agora é exibido para que você possa fornecer a URL de encaminhamento.

   O Visual Studio Code adiciona a URL de encaminhamento ao arquivo local.settings.json na pasta raiz do projeto. No objeto Values, a propriedade chamada Workflows.WebhookRedirectHostUri aparece agora e é definida como a URL de encaminhamento, por exemplo:

   {
      "IsEncrypted": false,
      "Values": {
         "AzureWebJobsStorage": "UseDevelopmentStorage=true",
         "FUNCTIONS_WORKER_RUNTIME": "dotnet",
         "FUNCTIONS_V2_COMPATIBILITY_MODE": "true",
         <...>
         "Workflows.WebhookRedirectHostUri": "http://xxxXXXXxxxXXX.ngrok.io",
         <...>
      }
   }
   

   Observação

   Anteriormente, o valor padrão da configuração FUNCTIONS_WORKER_RUNTIME era node. Agora, dotnet é o valor padrão para todos os aplicativos lógicos Standard novos e existentes implantados, mesmo para aplicativos que tinham um valor diferente. Essa alteração não deve afetar o runtime do fluxo de trabalho e tudo deve funcionar da mesma maneira que antes. Para obter mais informações, consulte a configuração do aplicativo FUNCTIONS_WORKER_RUNTIME .

Na primeira vez que você inicia uma sessão de depuração local ou executa o fluxo de trabalho sem depuração, o runtime dos Aplicativos Lógicos do Azure registra o fluxo de trabalho com o ponto de extremidade de serviço e assina esse ponto de extremidade para notificar as operações de webhook. Na próxima vez em que o fluxo de trabalho for executado, o runtime não será registrado ou reassinado porque o registro de assinatura já existe no armazenamento local.

Quando você interrompe a sessão de depuração para uma execução de fluxo de trabalho que usa gatilhos ou ações baseadas em webhook executados localmente, os registros de assinatura existentes não são excluídos. Para cancelar o registro, você precisa remover manualmente ou excluir os registros de assinatura.

Observação

Depois que o fluxo de trabalho começar a ser executado, a janela do terminal poderá mostrar erros como este exemplo:

message='Http request failed with unhandled exception of type 'InvalidOperationException' and message: 'System.InvalidOperationException: Synchronous operations are disallowed. Call ReadAsync or set AllowSynchronousIO to true instead.'

Nesse caso, abra o arquivo local.settings.jsno na pasta raiz do projeto e verifique se a propriedade está definida como true:

"FUNCTIONS_V2_COMPATIBILITY_MODE": "true"

Gerenciar pontos de interrupção para depuração

Antes de executar e testar o fluxo de trabalho do aplicativo lógico iniciando uma sessão de depuração, você pode definir pontos de interrupção dentro do arquivo workflow.json para cada fluxo de trabalho. Nenhuma outra configuração é necessária.

Neste momento, os pontos de interrupção têm suporte apenas para ações, não para gatilhos. Cada definição de ação tem estes locais de ponto de interrupção:

• Defina o ponto de interrupção inicial na linha que mostra o nome da ação. Quando esse ponto de interrupção é atingido durante a sessão de depuração, você pode revisar as entradas da ação antes que elas sejam avaliadas.

• Defina o ponto de interrupção final na linha que mostra a chave de fechamento da ação ( } ). Quando esse ponto de interrupção é atingido durante a sessão de depuração, você pode revisar os resultados da ação antes que a execução da ação seja concluída.

Para adicionar um ponto de interrupção, siga estas etapas:

1. Abra o arquivo workflow.json para o fluxo de trabalho que você deseja depurar.

2. Na linha em que você deseja definir o ponto de interrupção, na coluna à esquerda, selecione dentro dessa coluna. Para remover o ponto de interrupção, selecione esse ponto de interrupção.

   Quando você inicia a sessão de depuração, a exibição da Execução aparece no lado esquerdo da janela de código, enquanto a barra de ferramentas Depurar aparece perto da parte superior.

   Observação

   Se a exibição da Execução não aparecer automaticamente, pressione Ctrl+Shift+D.

3. Para examinar as informações disponíveis quando atinge um ponto de interrupção, na exibição da Execução, examine o painel Variáveis.

4. Para continuar a execução do fluxo de trabalho, na barra de ferramentas Depurar, selecione Continuar (botão reproduzir).

Você pode adicionar e remover pontos de interrupção a qualquer momento durante a execução do fluxo de trabalho. No entanto, se você atualizar o arquivo workflow.json depois que a execução for iniciada, os pontos de interrupção não serão atualizados automaticamente. Para atualizar os pontos de interrupção, reinicie o aplicativo lógico.

Para informações gerais, confira Pontos de interrupção – Visual Studio Code.

Executar, testar e depurar localmente

Para testar seu fluxo de trabalho do aplicativo lógico, siga essas etapas para iniciar uma sessão de depuração e localize a URL do ponto de extremidade criado pelo gatilho de Solicitação. Você precisa dessa URL para que possa enviar posteriormente uma solicitação para esse ponto de extremidade.

1. Para depurar um fluxo de trabalho sem estado com mais facilidade, você pode habilitar o histórico de execução desse fluxo de trabalho.

2. Se o emulador do Azurite já estiver em execução, prossiga para a próxima etapa. Caso contrário, inicie o emulador antes de executar o fluxo de trabalho:

   1. No Visual Studio Code, no menu Exibir, selecione Paleta de Comandos.

   2. Depois que a paleta de comandos for exibida, insira Azurite: Iniciar.

   Para obter mais informações sobre comandos do Azurite, consulte a documentação da extensão do Azurite no Visual Studio Code.

3. Na Barra de Atividade do Visual Studio Code, abra o menu Executar e selecione Iniciar Depuração (F5).

   A janela do Terminal é aberta para que você possa examinar a sessão de depuração.

   Observação

   Se você receber o erro "Há um erro após executar o preLaunchTask 'generateDebugSymbols'" , confira a seção de solução de problemas, Falha na inicialização da sessão de depuração.

4. Agora, localize a URL de retorno de chamada para o ponto de extremidade no gatilho de Solicitação.

   1. Reabra o painel do Explorer para que você possa exibir seu projeto.

   2. No menu de atalho do arquivo workflow.json, selecione Visão geral.

      

   3. Localize o valor da URL de Retorno de Chamada, que é semelhante a esta URL do exemplo do gatilho de Solicitação:

      http://localhost:7071/api/<workflow-name>/triggers/manual/invoke?api-version=2020-05-01&sp=%2Ftriggers%2Fmanual%2Frun&sv=1.0&sig=<shared-access-signature>

      

   4. Copie e salve o valor da propriedade da URL de Retorno de Chamada.

5. Para testar a URL de retorno de chamada e disparar o fluxo de trabalho, envie uma solicitação HTTP para a URL, incluindo o método que o gatilho de Solicitação espera, usando sua ferramenta de solicitação HTTP e suas instruções.

   Esse exemplo usa o método GET com a URL copiada, que se parece com a seguinte amostra:

   GET http://localhost:7071/api/Stateful-Workflow/triggers/manual/invoke?api-version=2020-05-01&sp=%2Ftriggers%2Fmanual%2Frun&sv=1.0&sig=<shared-access-signature>

   Quando o gatilho é acionado, o fluxo de trabalho de exemplo é executado e envia um email semelhante a este exemplo:

   

6. No Visual Studio Code, retorne à página de visão geral do fluxo de trabalho.

   Se você criou um fluxo de trabalho com estado, depois que a solicitação que você enviou disparar o fluxo de trabalho, a página visão geral mostrará o status e o histórico de execução do fluxo de trabalho.

   Dica

   Se o status de execução não for exibido, tente atualizar a página visão geral selecionando Atualizar. A execução de um gatilho ignorado não é realizada devido a critérios não cumpridos ou se não localizar dados.

   

   A seguinte tabela mostra os possíveis status finais que cada execução de fluxo de trabalho pode ter e mostrar no Visual Studio Code:

   Status da execução	Descrição
   Anulado	A execução foi interrompida ou não foi concluída devido a problemas externos, como uma interrupção do sistema ou uma assinatura do Azure vencida.
   Cancelado	A execução foi disparada e iniciada, mas recebeu uma solicitação de cancelamento.
   Com falha	Falha em pelo menos uma ação na execução. Não foi configurada nenhuma ação subsequente no fluxo de trabalho para lidar com a falha.
   Executando	A execução foi disparada e está em andamento, mas esse status também pode aparecer para uma execução restrita devido a limites de ação ou ao plano de preços atual. Dica: ao configurar o log de diagnósticos, é possível receber informações sobre os eventos de restrição que ocorrerem.
   Êxito	A execução foi bem-sucedida. Se alguma ação falhar, uma ação subsequente no fluxo de trabalho lidou com essa falha.
   Tempo limite atingido	A execução atingiu o tempo limite porque a duração atual excedeu o limite de tempo de execução, que é controlado pela configuração Retenção do histórico de execuções em dias. A duração de uma execução é calculada usando a hora de início e o limite de tempo de execução na hora de início. Observação: se o tempo de execução também exceder o limite de retenção do histórico de execução atual, que também é controlado pela configuração Retenção do histórico de execução em dias, a execução será desmarcada do histórico de execuções por um trabalho de limpeza diário. Se a execução atingir o tempo limite ou for concluída, o período de retenção será calculado usando a hora de início e o limite de retenção atual da execução. Portanto, ao reduzir o limite da duração de uma execução em andamento, a execução atingirá o tempo limite. No entanto, ela permanecerá ou será desmarcada do histórico de execuções se o tempo de execução tiver excedido o limite de retenção.
   Aguardando	A execução ainda não foi iniciada ou está em pausa, por exemplo, devido a uma instância de fluxo de trabalho anterior que ainda está em execução.

7. Para examinar os status de cada etapa em uma execução específica e as entradas e saídas da etapa, selecione o botão de reticências (...) para essa execução e selecione Mostrar execução.

   

   O Visual Studio Code abre a exibição de monitoramento e mostra o status de cada etapa na execução.

   

   Observação

   Se uma execução falhar e uma etapa na exibição de monitoramento mostrar o erro 400 Solicitação Inválida, esse problema poderá resultar de um nome de gatilho mais longo ou de um nome de ação que faz com que o URI (Uniform Resource Identifier) subjacente ultrapasse o limite de caracteres padrão. Para saber mais, confira "400 Solicitação Incorreta".

   A seguinte tabela mostra os possíveis status que cada execução de fluxo de trabalho pode ter e mostrar no Visual Studio Code:

   Status da ação	Descrição
   Anulado	A ação foi interrompida ou não foi concluída devido a problemas externos, como uma interrupção do sistema ou uma assinatura do Azure vencida.
   Cancelado	A ação estava em execução, mas recebeu uma solicitação para cancelar.
   Com falha	Falha na ação.
   Executando	A ação está em execução no momento.
   Ignorado	A ação foi ignorada por conta de uma falha na ação imediatamente anterior. Uma ação tem uma runAfter condição que requer que a ação anterior seja concluída com êxito antes que a ação atual possa ser executada.
   Êxito	A ação foi concluída.
   Êxito com novas tentativas	A ação foi concluída, mas somente após uma ou mais tentativas. Para examinar o histórico de novas tentativas na exibição de informações do histórico de execuções, selecione essa ação para exibir as entradas e saídas.
   Tempo limite atingido	A ação foi interrompida devido ao limite de tempo especificado pelas configurações dessa ação ter sido atingido.
   Aguardando	Aplica-se a uma ação de webhook aguardando uma solicitação de entrada de um chamador.

8. Para revisar as entradas e saídas de cada etapa, selecione a etapa que você deseja examinar. Para examinar melhor as entradas e saídas brutas dessa etapa, selecione Mostrar entradas brutas ou Mostrar saídas brutas.

   

9. Para interromper a sessão de depuração, no menu Executar, selecione Parar Depuração (Shift+F5).

Retornar uma resposta

Quando você tem um fluxo de trabalho que começa com o gatilho de Solicitação, pode retornar uma resposta ao chamador que enviou uma solicitação ao fluxo de trabalho usando a ação interna de Solicitação chamada Resposta.

1. No designer de fluxo de trabalho, sob a ação Enviar um email, selecione o sinal de adição (+) >Adicionar uma ação.

   O painel Adicionar uma ação é aberto para que você possa selecionar a próxima ação.

2. No painel Adicionar uma ação, na lista Runtime, selecione No Aplicativo. Localize e adicione a ação Resposta.

   Depois que a ação Resposta aparece no designer, o painel detalhes da ação é aberto automaticamente.

   

3. Na guia Parâmetros, forneça as informações necessárias para a função que você deseja chamar.

   Este exemplo retorna o valor do parâmetro Corpo, que é a saída da ação de Enviar um email.

   1. Para o parâmetro Corpo, selecione dentro da caixa de edição e selecione o ícone de relâmpago, que abre a lista de conteúdo dinâmico. Esta lista mostra os valores de saída disponíveis do gatilho e ações anteriores no fluxo de trabalho.

   2. Na lista conteúdo dinâmico, em Enviar um email, selecione Corpo.

      

      Ao terminar, a propriedade Corpo da ação de Resposta agora será definida como o valor de saída do Corpo da ação Enviar um email.

      

4. No designer, selecione Salvar.

Como testar novamente o seu aplicativo lógico

Depois de fazer atualizações em seu aplicativo lógico, você pode executar outro teste executando novamente o depurador no Visual Studio Code e enviando outra solicitação para disparar seu aplicativo lógico atualizado, semelhante às etapas em Executar, testar e depurar localmente.

1. Na Barra de Atividade do Visual Studio Code, abra o menu Executar e selecione Iniciar Depuração (F5).

2. Em sua ferramenta para criar e enviar solicitação, envie outra solicitação para disparar seu fluxo de trabalho.

3. Se você criou um fluxo de trabalho com estado, na página visão geral do fluxo de trabalho, verifique o status da execução mais recente. Para exibir o status, as entradas e as saídas de cada etapa na execução, selecione o botão de reticências (...) para essa execução e selecione Mostrar execução.

   Por exemplo, aqui está o status passo a passo para uma execução após a atualização do fluxo de trabalho de exemplo com a ação de Resposta.

   

4. Para interromper a sessão de depuração, no menu Executar, selecione Parar Depuração (Shift+F5).

Localizar os nomes de domínio para acesso ao firewall

Antes de implantar e executar o fluxo de trabalho do aplicativo lógico no portal do Azure, se o ambiente tiver requisitos rigorosos de rede ou firewalls que limitem o tráfego, será preciso configurar as permissões para todas as conexões de gatilho ou ação existentes no fluxo de trabalho.

Para localizar os FQDNs (nomes de domínio totalmente qualificados) dessas conexões, siga estas etapas:

1. No seu projeto de aplicativo lógico, abra o arquivo connections.json, que foi criado depois de adicionar o primeiro gatilho ou ação baseado em conexão ao seu fluxo de trabalho, e localize o objeto managedApiConnections.

2. Para cada conexão criada, copie e salve o valor da propriedade connectionRuntimeUrl em um local seguro para que você possa configurar o firewall com essa informação.

   Este exemplo do arquivo connections.json contém duas conexões, uma conexão AS2 e uma conexão do Office 365 com estes valores connectionRuntimeUrl:

   • AS2: "connectionRuntimeUrl": https://9d51d1ffc9f77572.00.common.logic-{Azure-region}.azure-apihub.net/apim/as2/11d3fec26c87435a80737460c85f42ba

   • Office 365: "connectionRuntimeUrl": https://9d51d1ffc9f77572.00.common.logic-{Azure-region}.azure-apihub.net/apim/office365/668073340efe481192096ac27e7d467f

   {
      "managedApiConnections": {
         "as2": {
            "api": {
               "id": "/subscriptions/{Azure-subscription-ID}/providers/Microsoft.Web/locations/{Azure-region}/managedApis/as2"
            },
            "connection": {
               "id": "/subscriptions/{Azure-subscription-ID}/resourceGroups/{Azure-resource-group}/providers/Microsoft.Web/connections/{connection-resource-name}"
            },
            "connectionRuntimeUrl": https://9d51d1ffc9f77572.00.common.logic-{Azure-region}.azure-apihub.net/apim/as2/11d3fec26c87435a80737460c85f42ba,
            "authentication": {
               "type":"ManagedServiceIdentity"
            }
         },
         "office365": {
            "api": {
               "id": "/subscriptions/{Azure-subscription-ID}/providers/Microsoft.Web/locations/{Azure-region}/managedApis/office365"
            },
            "connection": {
               "id": "/subscriptions/{Azure-subscription-ID}/resourceGroups/{Azure-resource-group}/providers/Microsoft.Web/connections/{connection-resource-name}"
            },
            "connectionRuntimeUrl": https://9d51d1ffc9f77572.00.common.logic-{Azure-region}.azure-apihub.net/apim/office365/668073340efe481192096ac27e7d467f,
            "authentication": {
               "type":"ManagedServiceIdentity"
            }
         }
      }
   }
   

Implantar no Azure

No Visual Studio Code, você pode publicar diretamente seu projeto no Azure para implantar seu recurso de aplicativo lógico Standard. Você pode publicar seu aplicativo lógico como um novo recurso, que cria automaticamente todos os recursos necessários, como uma conta de Armazenamento do Azure, semelhante aos requisitos do aplicativo de funções. Ou você pode publicar o aplicativo lógico em um recurso de aplicativo lógico Standard implantado anteriormente, que substitui esse aplicativo lógico.

A implantação para o recurso de aplicativo lógico (Standard) requer um plano de hospedagem e um tipo de preço, que você seleciona durante a implantação. Para saber mais, confira Planos de hospedagem e tipos de preço.

Publicar em um novo recurso de aplicativo lógico Standard

1. Na Barra de Atividades do Visual Studio Code, selecione o ícone do Azure para abrir a janela do Azure.

2. Na janela do Azure, na barra de ferramentas da seção Workspace, no menu Aplicativos Lógicos do Azure, selecione Implantar Aplicativo Lógico.

   

3. Se solicitado, selecione a assinatura do Azure a ser usada para a implantação do aplicativo lógico.

4. Na lista aberta pelo Visual Studio Code, selecione uma destas opções:

   • Criar Aplicativo Lógico (Standard) no Azure (rápido)
   • Criar Aplicativo Lógico (Standard) no Azure Avançado
   • Um recurso de Aplicativo Lógico (Standard) implantado anteriormente, se houver

   Este exemplo continua em Criar Aplicativo Lógico (Standard) no Azure Avançado.

   

5. Para criar seu recurso de aplicativo lógico Standard, siga estas etapas:

   1. Forneça um nome globalmente exclusivo para o aplicativo lógico, que é o nome a ser usado para o recurso de Aplicativo Lógico (Standard) . Este exemplo usa Fabrikam-Workflows-App.

      

   2. Selecione um plano de hospedagem para o novo aplicativo lógico. Crie um nome para seu plano ou selecione um plano existente (somente planos de Serviço de Aplicativo baseados no Windows). Este exemplo seleciona Criar Plano do Serviço de Aplicativo.

      

   3. Forneça um nome para o plano de hospedagem e um tipo de preço para o plano selecionado.

      Para saber mais, confira Planos de hospedagem e tipos de preço.

   4. Para obter o desempenho ideal, selecione o mesmo grupo de recursos que o seu projeto para a implantação.

      Observação

      Embora você possa criar ou usar um grupo de recursos diferente, isso pode afetar o desempenho. Se você criar ou escolher um grupo de recursos diferente, mas cancelar após aparecer o prompt de confirmação, sua implantação também será cancelada.

   5. Para fluxos de trabalho com estado, selecione Criar conta de armazenamento ou uma conta de armazenamento existente.

      

   6. Se as configurações de criação e implantação do aplicativo lógico forem compatíveis com o uso do Application Insights, será possível habilitar o log de diagnóstico e o rastreamento para seu aplicativo lógico. Isso pode ser feito quando você implanta seu aplicativo lógico do Visual Studio Code ou após a implantação. É necessário ter uma instância do Application Insights, mas esse recurso pode ser criado com antecedência ao implantar seu aplicativo lógico ou após a implantação.

      Para habilitar o log e o rastreamento agora, siga estas etapas:

      1. Selecione um recurso existente do Application Insights ou Criar um recurso do Application Insights.

      2. No portal do Azure, vá para o recurso do Application Insights.

      3. No menu de recursos, selecione Visão geral. Localize e copie o valor da Chave de Instrumentação.

      4. No Visual Studio Code, na pasta raiz do projeto, abra o arquivo local.settings.json.

      5. No objeto Values, adicione a propriedade APPINSIGHTS_INSTRUMENTATIONKEY e defina o valor para a chave de instrumentação, por exemplo:

         {
            "IsEncrypted": false,
            "Values": {
               "AzureWebJobsStorage": "UseDevelopmentStorage=true",
               "FUNCTIONS_WORKER_RUNTIME": "dotnet",
               "APPINSIGHTS_INSTRUMENTATIONKEY": <instrumentation-key>
            }
         }
         

         Dica

         Você pode verificar se os nomes do gatilho e da ação aparecem corretamente em sua instância do Application Insights.

         1. No portal do Azure, vá para o recurso do Application Insights.

         2. No menu de recursos, em Investigar, selecione Mapa de aplicativos.

         3. Examine os nomes da operação que aparecem no mapa.

         Algumas solicitações de entrada de gatilhos internos podem aparecer como duplicatas no Mapa do Aplicativo. Em vez de usar o formato WorkflowName.ActionName, essas duplicatas usam o nome do fluxo de trabalho como o nome da operação e são originadas no host do Azure Functions.

      6. Em seguida, você pode, opcionalmente, ajustar o nível de severidade para os dados de rastreamento que seu aplicativo lógico coleta e envia para sua instância de Application Insights.

         Cada vez que ocorre um evento relacionado ao fluxo de trabalho, como quando um fluxo de trabalho é disparado ou quando uma ação é executada, o runtime emite vários rastreamentos. Esses rastreamentos cobrem o tempo de vida do fluxo de trabalho e incluem os seguintes tipos de evento, embora não se limitem a eles:

         • Atividade de serviço, como iniciar, parar e erros.
         • Atividade de trabalhos e dispatcher.
         • Atividade de fluxo de trabalho, como gatilho, ação e execução.
         • Atividade de solicitação de armazenamento, como êxito ou falha.
         • Atividade de solicitação HTTP, como entrada, saída, êxito e falha.
         • Qualquer rastreamento de desenvolvimento, como mensagens de depuração.

         Cada tipo de evento é atribuído a um nível de severidade. Por exemplo, o nível Trace captura as mensagens mais detalhadas, enquanto o nível Information captura a atividade geral no fluxo de trabalho, como quando o aplicativo lógico, o fluxo de trabalho, o gatilho e as ações são iniciados e interrompidos. Esta tabela descreve os níveis de severidade e seus tipos de rastreamento:

         Nível de severidade	Tipo de rastreamento
         Crítico	Logs que descrevem uma falha irrecuperável em seu aplicativo lógico.
         Depurar	Logs que você pode usar para investigação durante o desenvolvimento, por exemplo, chamadas HTTP de entrada e saída.
         Erro	Logs que indicam uma falha na execução do fluxo de trabalho, mas não uma falha geral em seu aplicativo lógico.
         Informações	Logs que acompanham a atividade geral em seu aplicativo lógico ou fluxo de trabalho, por exemplo: – Quando um gatilho, uma ação ou uma execução começa e termina. – Quando o aplicativo lógico começa ou termina.
         Trace	Logs que contêm as mensagens mais detalhadas, por exemplo, solicitações de armazenamento ou atividade do dispatcher, além de todas as mensagens relacionadas à atividade de execução do fluxo de trabalho.
         Aviso	Logs que realçam um estado anormal em seu aplicativo lógico, mas não impedem sua execução.

         Para definir o nível de severidade, no nível raiz do seu projeto, abra o arquivo host.json e localize o objeto logging. Esse objeto controla a filtragem de log de todos os fluxos de trabalho em seu aplicativo lógico e segue o layout de ASP.NET Core para a filtragem de tipo de log.

         {
            "version": "2.0",
            "logging": {
               "applicationInsights": {
                  "samplingExcludedTypes": "Request",
                  "samplingSettings": {
                     "isEnabled": true
                  }
               }
            }
         }
         

         Se o objeto logging não contiver um objeto logLevel que inclua a propriedade Host.Triggers.Workflow, adicione esses itens. Defina a propriedade com o nível de severidade para o tipo de rastreamento desejado, por exemplo:

         {
            "version": "2.0",
            "logging": {
               "applicationInsights": {
                  "samplingExcludedTypes": "Request",
                  "samplingSettings": {
                     "isEnabled": true
                  }
               },
               "logLevel": {
                  "Host.Triggers.Workflow": "Information"
               }
            }
         }
         

   Quando você terminar as etapas de implantação, o Visual Studio Code começará a criar e implantar os recursos necessários para publicar seu aplicativo lógico.

6. Para revisar e monitorar o processo de implantação, no menu Exibir, selecione Saída. Na lista da barra de ferramentas da janela Saída, selecione Aplicativos Lógicos do Azure.

   

   Quando o Visual Studio Code concluir a implantação do aplicativo lógico no Azure, a seguinte mensagem será exibida:

   

   Parabéns, seu aplicativo lógico agora está ativo no Azure e habilitado por padrão.

Em seguida, você pode aprender a executar estas tarefas:

• Adicionar um fluxo de trabalho em branco ao seu projeto.

• Gerenciar aplicativos lógicos implantados no Visual Studio Code ou usando o portal do Azure.

• Habilitar o histórico de execuções em fluxos de trabalho sem estado.

• Habilitar a exibição de monitoramento no portal do Azure para um aplicativo lógico implantado.

Adicionar fluxo de trabalho em branco ao projeto

Você pode ter vários fluxos de trabalho em seu projeto de aplicativo lógico. Para adicionar um fluxo de trabalho em branco ao seu projeto, siga estas etapas:

1. Na Barra de Atividade do Visual Studio Code, selecione o ícone do Azure.

2. Na janela do Azure, na barra de ferramentas da seção Workspace, no menu Aplicativos Lógicos do Azure, selecione Criar Fluxo de trabalho.

3. Selecione o tipo de fluxo de trabalho que você deseja adicionar: Com estado ou Sem estado

4. Forneça um nome para o fluxo de trabalho.

Quando terminar, uma nova pasta de fluxo de trabalho será exibida em seu projeto junto com um arquivo workflow.json para a definição de fluxo de trabalho.

Gerenciar aplicativos lógicos implantados no Visual Studio Code

No Visual Studio Code, você pode exibir todos os aplicativos lógicos implantados em sua assinatura do Azure, sejam eles recursos de aplicativo lógico de Consumo ou Standard, e selecionar tarefas que ajudam a gerenciar esses aplicativos lógicos. No entanto, para acessar os dois tipos de recursos, você precisa das extensões dos Aplicativos Lógicos do Azure (Consumo) e dos Aplicativos Lógicos do Azure (Standard) para o Visual Studio Code.

1. Na Barra de Atividade do Visual Studio Code, selecione o ícone do Azure. Em Recursos, expanda sua assinatura e em seguida expanda Aplicativo Lógico, que mostra todos os aplicativos lógicos implantados no Azure para essa assinatura.

2. Abra o aplicativo lógico que você deseja gerenciar. No menu de atalho do aplicativo lógico, selecione a tarefa que você deseja executar.

   Por exemplo, você pode selecionar tarefas como parar, iniciar, reiniciar ou excluir seu aplicativo lógico implantado. Você pode desabilitar ou habilitar um fluxo de trabalho usando o portal do Azure.

   Observação

   As operações parar aplicativo lógico e excluir aplicativo lógico afetam as instâncias de fluxo de trabalho de maneiras diferentes. Para saber mais, confira Considerações sobre parar aplicativos lógicos e Considerações sobre excluir aplicativos lógicos.

   

3. Para exibir todos os fluxos de trabalho no aplicativo lógico, expanda seu aplicativo lógico e, em seguida, expanda o nó Fluxos de trabalho.

4. Para exibir um fluxo de trabalho específico, abra o menu de atalho do fluxo de trabalho e selecione Abrir no Designer, que abre o fluxo de trabalho no modo somente leitura.

   Para editar o fluxo de trabalho, você tem estas opções:

   • No Visual Studio Code, abra o arquivo workflow.json do projeto no designer de fluxo de trabalho, faça suas edições e reimplante seu aplicativo lógico no Azure.

   • No portal do Azure, abra o aplicativo lógico. Em seguida, você pode abrir, editar e salvar seu fluxo de trabalho.

5. Para abrir o aplicativo lógico implantado no portal do Azure, abra o menu de atalho do aplicativo lógico e selecione Abrir no Portal.

   O portal do Azure é aberto no navegador, você entra no portal automaticamente caso esteja conectado ao Visual Studio Code, e ele mostra seu aplicativo lógico.

   

   Você também pode entrar separadamente no portal do Azure; use a caixa de pesquisa do portal para localizar seu aplicativo lógico e selecione-o na lista de resultados.

   

Considerações sobre parar aplicativos lógicos

Parar um aplicativo lógico afeta as instâncias de fluxo de trabalho das seguintes maneiras:

• Os Aplicativos Lógicos do Azure cancelam imediatamente todas as execuções em andamento e pendentes.

• Os Aplicativos Lógicos do Azure não criam nem executam novas instâncias do fluxo de trabalho.

• O gatilho não será acionado na próxima vez em que as condições forem atendidas. No entanto, os estados do gatilho lembram os pontos em que o aplicativo lógico foi parado. Portanto, se você reiniciar o aplicativo lógico, os gatilhos serão acionados para todos os itens não processados desde a última execução.

  Para impedir que um gatilho seja acionado em itens não processados desde a última execução, limpe o estado do gatilho antes de reiniciar o aplicativo lógico:

  1. Na Barra de Atividades do Visual Studio Code, selecione o ícone do Azure para abrir a janela do Azure.

  2. Na seção Recursos, expanda sua assinatura, que mostra todos os aplicativos lógicos implantados para essa assinatura.

  3. Expanda o aplicativo lógico e o nó chamado Fluxos de trabalho.

  4. Abra um fluxo de trabalho e edite qualquer parte do gatilho dele.

  5. Salve suas alterações. Esta etapa redefine o estado atual do gatilho.

  6. Repita para cada fluxo de trabalho.

  7. Quando terminar, reinicie o aplicativo lógico.

Considerações sobre excluir aplicativos lógicos

A exclusão de um aplicativo lógico afeta as instâncias de fluxo de trabalho das seguintes maneiras:

• O serviço Aplicativos Lógicos do Azure cancela execuções em andamento e pendentes imediatamente, mas não executa as tarefas de limpeza no armazenamento usado pelo aplicativo.

• Os Aplicativos Lógicos do Azure não criam nem executam novas instâncias do fluxo de trabalho.

• Se você excluir um fluxo de trabalho e recriar o mesmo fluxo de trabalho, o fluxo de trabalho recriado não terá os mesmos metadados do fluxo de trabalho excluído. Para atualizar os metadados, você precisará salvar novamente todos os fluxos de trabalho que chamaram o fluxo de trabalho excluído. Dessa forma, o chamador obtém as informações corretas para o fluxo de trabalho recriado. Caso contrário, as chamadas ao fluxo de trabalho recriado falharão com um erro Unauthorized. Esse comportamento também se aplica aos fluxos de trabalho que usam artefatos em contas de integração e fluxos de trabalho que chamam funções do Azure.

Gerenciar aplicativos lógicos implantados no portal

Depois de implantar um aplicativo lógico no portal do Azure a partir do Visual Studio Code, você poderá exibir todos os aplicativos lógicos implantados que estão em sua assinatura do Azure, sejam eles recursos de aplicativo lógico de Consumo ou Standard. Atualmente, cada tipo de recurso é organizado e gerenciado como categorias separadas no Azure. Para localizar aplicativos lógicos Standard, siga estas etapas:

1. Na caixa de pesquisa do portal do Azure, insira aplicativos lógicos. Quando a lista de resultados aparecer, em Serviços, selecione Aplicativos lógicos.

   

2. No painel Aplicativos Lógicos, selecione o aplicativo lógico que você implantou do Visual Studio Code.

   

   O portal do Azure abre a página de recursos individuais para o aplicativo lógico selecionado.

   

3. Para exibir os fluxos de trabalho neste aplicativo lógico, no menu do aplicativo lógico, selecione Fluxos de trabalho.

   O painel Fluxos de trabalho mostra todos os fluxos de trabalho no aplicativo lógico atual. Este exemplo mostra o fluxo de trabalho que você criou no Visual Studio Code.

   

4. Para exibir um fluxo de trabalho, selecione-o no painel Fluxos de trabalho.

   O painel do fluxo de trabalho é aberto e mostra mais informações e tarefas que podem ser executadas nesse fluxo.

   Por exemplo, para exibir as etapas no fluxo de trabalho, selecione Designer.

   

   O designer de fluxo de trabalho é aberto e mostra o fluxo de trabalho que você criou no Visual Studio Code. Agora você pode fazer alterações nesse fluxo de trabalho no portal do Azure.

   

Adicionar outro fluxo de trabalho no portal

No portal do Azure, você pode adicionar fluxos de trabalho em branco a um recurso de aplicativo lógico Standard implantado do Visual Studio Code e criar esses fluxos de trabalho no portal do Azure.

1. No portal do Azure, selecione o recurso de aplicativo lógico Standard implantado.

2. No menu de recurso do aplicativo lógico, selecione Fluxos de trabalho. No painel Fluxos de trabalho, selecione Adicionar.

   

3. No painel Novo fluxo de trabalho, forneça um nome para o fluxo de trabalho. Selecione a opção Com estado ou Sem estado > Criar.

   Depois que o Azure implantar o novo fluxo de trabalho, que aparece no painel Fluxos de trabalho, selecione esse fluxo de trabalho para que você possa gerenciar e executar outras tarefas, como abrir o designer ou a exibição de código.

   

   Por exemplo, abrir o designer com um novo fluxo de trabalho mostra uma tela em branco. Agora você pode criar esse fluxo de trabalho no portal do Azure.

   

Habilite o histórico de execuções para fluxos de trabalho sem estado

Para depurar um fluxo de trabalho sem estado com mais facilidade, habilite o histórico de execução para esse fluxo de trabalho e desabilite o histórico de execução quando terminar. Siga essas etapas para o Visual Studio Code ou, se estiver trabalhando no portal do Azure, confira Criar fluxos de trabalho baseados em locatário único no portal do Azure.

1. No projeto do Visual Studio Code, no nível da pasta raiz, abra o arquivo local.settings.json .

2. Adicione a propriedade Workflows.{yourWorkflowName}.operationOptions e defina o valor como WithStatelessRunHistory, por exemplo:

   Windows

   {
      "IsEncrypted": false,
      "Values": {
         "AzureWebJobsStorage": "UseDevelopmentStorage=true",
         "FUNCTIONS_WORKER_RUNTIME": "dotnet",
         "Workflows.{yourWorkflowName}.OperationOptions": "WithStatelessRunHistory"
      }
   }
   

   macOS ou Linux

   {
      "IsEncrypted": false,
      "Values": {
         "AzureWebJobsStorage": "DefaultEndpointsProtocol=https;AccountName=fabrikamstorageacct; \
             AccountKey=<access-key>;EndpointSuffix=core.windows.net",
         "FUNCTIONS_WORKER_RUNTIME": "dotnet",
         "Workflows.{yourWorkflowName}.OperationOptions": "WithStatelessRunHistory"
      }
   }
   

3. Na pasta do projeto chamada workflow-designtime, abra o arquivo local.settings.json e faça a mesma alteração.

4. Para desabilitar o histórico de execuções quando terminar, defina a propriedade Workflows.{yourWorkflowName}.OperationOptions como None ou exclua a propriedade e seu valor.

Habilitar a exibição de monitoramento no portal do Azure

Depois de implantar um recurso do Aplicativo Lógico (Standard) do Visual Studio Code para o Azure, você pode examinar qualquer histórico de execução disponível e detalhes de um fluxo de trabalho nesse recurso usando o portal do Azure e a experiência de Monitor para esse fluxo de trabalho. No entanto, primeiro você precisa habilitar a funcionalidade de exibição de Monitor no recurso de aplicativo lógico.

1. No portal do Azure, abra o recurso de aplicativo lógico Standard.

2. No menu de recursos do aplicativo lógico, em API, selecione CORS.

3. No painel CORS, em Origens Permitidas, adicione o caractere curinga (*).

4. Quando terminar, na barra de ferramentas CORS, selecione Salvar.

   

Após a implantação, habilite ou abra o Application Insights

Durante a execução do fluxo de trabalho, seu aplicativo lógico emite telemetria junto com outros eventos. Use a telemetria para visualizar o desempenho do fluxo de trabalho e como o tempo de execução dos Aplicativos Lógicos do Azure funciona de várias maneiras. É possível monitorar o fluxo de trabalho usando o Application insights, que fornece telemetria quase em tempo real (métricas ao vivo). Esse recurso pode ajudar a investigar falhas e problemas de desempenho mais facilmente ao usar esses dados para diagnosticar problemas, configurar alertas e criar gráficos.

Se as configurações de criação e implantação do aplicativo lógico forem compatíveis com o uso do Application Insights, será possível habilitar o log de diagnóstico e o rastreamento para seu aplicativo lógico. Isso pode ser feito quando você implanta seu aplicativo lógico do Visual Studio Code ou após a implantação. É necessário ter uma instância do Application Insights, mas esse recurso pode ser criado com antecedência ao implantar seu aplicativo lógico ou após a implantação.

Para habilitar o Application Insights em um aplicativo lógico implantado ou para revisar os dados do Application Insights quando já estiver habilitado, siga estas etapas:

1. No portal do Azure, localize o aplicativo lógico implantado.

2. No menu do aplicativo lógico, em Configurações, selecione Application Insights.

3. Se o Application Insights não estiver habilitado, acesse o painel Application Insights, selecione Ativar o Application Insights. Depois que o painel for atualizado, na parte inferior, selecione Aplicar.

   Se o Application Insights não estiver habilitado, acesse o painel Application Insights, selecione Exibir os dados do Application Insights.

Depois que o Application Insights for aberto, examine várias métricas para seu aplicativo lógico. Para saber mais, confira os tópicos:

• Aplicativos Lógicos do Azure em execução em qualquer lugar – monitoramento com o Application Insights – parte 1
• Aplicativos Lógicos do Azure em execução em qualquer lugar – monitoramento com o Application Insights – parte 2

Exclua os itens do Designer

Para excluir um item no fluxo de trabalho do Designer, siga qualquer uma dessas etapas:

• Selecione o item, abra o menu de atalho do item (Shift + F10) e selecione Excluir. Para confirmar, selecione OK.

• Selecione o item e pressione a tecla Excluir. Para confirmar, selecione OK.

• Selecione o item para que o painel de resultados seja aberto para esse item. No canto superior direito do painel, abra o menu de reticências ( ... ) e selecione Excluir. Para confirmar, selecione OK.

  

  Dica

  Se o menu de reticências não estiver visível, amplie a janela do Visual Studio Code para que o painel de resultados mostre o botão de reticências ( ... ) no canto superior direito.

Solucionar problemas e erros

Falha ao abrir o designer

Ao tentar abrir o designer, você recebe esse erro "Não foi possível iniciar o tempo de design do fluxo de trabalho" . Se você já tentou abrir o designer e depois descontinuou ou excluiu seu projeto, pode ser que o pacote de extensão não esteja sendo baixado corretamente. Para verificar se essa é a causa do problema, siga estas etapas:

1. No Visual Studio Code, abra a janela Saída. No menu Exibir, selecione Saída.

2. Na lista da barra de título da janela de Saída, selecione Aplicativos Lógicos do Azure (Standard) para que você possa examinar a saída da extensão, por exemplo:

   

3. Examine a saída e verifique se esta mensagem de erro é exibida:

   A host error has occurred during startup operation '{operationID}'.
   System.Private.CoreLib: The file 'C:\Users\{userName}\AppData\Local\Temp\Functions\
   ExtensionBundles\Microsoft.Azure.Functions.ExtensionBundle.Workflows\1.1.7\bin\
   DurableTask.AzureStorage.dll' already exists.
   Value cannot be null. (Parameter 'provider')
   Application is shutting down...
   Initialization cancellation requested by runtime.
   Stopping host...
   Host shutdown completed.
   

Para resolver esse erro, exclua a pasta ExtensionBundles neste local ...\Users{seu nome de usuário}\AppData\Local\Temp\Functions\ExtensionBundles e tente abrir novamente o arquivo workflow.json no designer.

Os novos gatilhos e ações estão ausentes no seletor do designer para fluxos de trabalho criados anteriormente

Os Aplicativos Lógicos do Azure com locatário único dão suporte a ações internas para operações do Azure Functions, do Liquid e de XML, como Validação de XML e Transformação XML. No entanto, para aplicativos lógicos criados anteriormente, essas ações podem não aparecer no seletor do designer para que você selecione se o Visual Studio Code deve usar uma versão desatualizada do pacote de extensão, Microsoft.Azure.Functions.ExtensionBundle.Workflows.

Além disso, as ações e o conector Operações do Azure Function não aparecem no seletor de designer, a menos que você tenha habilitado ou selecionado Usar conectores do Azure quando criou seu aplicativo lógico. Se você não tiver habilitado os conectores implantados do Azure no momento da criação do aplicativo, poderá habilitá-los em seu projeto no Visual Studio Code. Abra o menu de atalho workflow.json e selecione Usar Conectores do Azure.

Para corrigir o pacote desatualizado, siga estas etapas para excluir o pacote desatualizado, que faz o Visual Studio Code atualizar automaticamente o pacote de extensão para a versão mais recente.

Observação

Esta solução se aplica apenas aos aplicativos lógicos que você cria e implanta usando o Visual Studio Code com a extensão dos Aplicativos Lógicos do Azure (Standard), não aos aplicativos lógicos que você criou usando o portal do Azure. Confira Gatilhos e ações compatíveis ausentes do designer no portal do Azure.

1. Salve todos os trabalho que você não deseja perder e feche o Visual Studio Code.

2. No seu computador, navegue até a seguinte pasta, que contém pastas de versão para o pacote existente:

   ...\Users\{your-username}\.azure-functions-core-tools\Functions\ExtensionBundles\Microsoft.Azure.Functions.ExtensionBundle.Workflows

3. Exclua a pasta da versão do pacote anterior, por exemplo, se você tiver uma pasta da versão 1.1.3, exclua essa pasta.

4. Agora navegue até a seguinte pasta, que contém pastas de versão para o pacote NuGet existente:

   ...\Users\{your-username}\.nuget\packages\microsoft.azure.workflows.webjobs.extension

5. Exclua a pasta de versão do pacote anterior.

6. Reabra o Visual Studio Code, seu projeto e o arquivo workflow.json no designer.

Os gatilhos e as ações ausentes agora aparecem no designer.

"400 Solicitação Incorreta" aparece em um gatilho ou em uma ação

Quando uma execução falha e você inspeciona a execução na exibição de monitoramento, esse erro pode aparecer em um gatilho ou ação que tenha um nome mais longo, o que faz com que o URI (Uniform Resource Identifier) subjacente exceda o limite de caracteres padrão.

Para resolver esse problema e ajustar para o URI mais longo, edite as chaves do registro UrlSegmentMaxCount e UrlSegmentMaxLength no seu computador seguindo as etapas abaixo. Os valores padrão dessa chave são descritos neste tópico, Configurações do registro Http.sys para Windows.

Importante

Antes de começar, salve seu trabalho. Essa solução exige que você reinicie o computador depois de terminar para que as alterações entrem em vigor.

1. No computador, abra a janela Executar e execute o comando regedit, que abre o editor do registro.

2. Na caixa Controle de Conta de Usuário, selecione Sim para permitir suas alterações no computador.

3. No painel esquerdo, em Computador, expanda os nós ao longo do caminho, HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\HTTP\Parameters e selecione Parâmetros.

4. No painel direito, localize as chaves do registro UrlSegmentMaxCount e UrlSegmentMaxLength.

5. Aumente esses valores de chave o suficiente para que os URIs possam acomodar os nomes que você deseja usar. Se essas chaves não existirem, adicione-as à pasta Parâmetros seguindo estas etapas:

   1. No menu de atalho Parâmetros, selecione Novo>Valor DWORD (32 bits) .

   2. Na caixa de edição que aparece, insira UrlSegmentMaxCount como o novo nome de chave.

   3. Abra o menu de atalho da nova chave e selecione Modificar.

   4. Na caixa Editar Cadeia de Caracteres exibida, insira o valor da chave de Dados do valor desejado no formato hexadecimal ou decimal. Por exemplo, 400 em hexadecimal é equivalente a 1024 em decimal.

   5. Para adicionar o valor da chave UrlSegmentMaxLength, repita essas etapas.

   Depois que você aumentar ou adicionar esses valores de chave, o editor do registro será semelhante a este exemplo:

   

6. Quando estiver pronto, reinicie o computador para que as alterações entrem em vigor.

Falha na inicialização da sessão de depuração

Ao tentar iniciar uma sessão de depuração, você obtém o erro "O erro existe depois de executar preLaunchTask "generateDebugSymbols"" . Para resolver esse problema, edite o arquivo tasks.json em seu projeto para ignorar a geração de símbolos.

1. Em seu projeto, expanda a pasta chamada .vscode e abra o arquivo tasks.json.

2. Na seguinte tarefa, exclua a linha, "dependsOn: "generateDebugSymbols", junto com a vírgula que termina a linha anterior, por exemplo:

   Antes:

    {
      "type": "func",
      "command": "host start",
      "problemMatcher": "$func-watch",
      "isBackground": true,
      "dependsOn": "generateDebugSymbols"
    }
   

   Após:

    {
      "type": "func",
      "command": "host start",
      "problemMatcher": "$func-watch",
      "isBackground": true
    }
   

Próximas etapas

Gostaríamos de conhecer suas experiências com a extensão dos Aplicativos Lógicos do Azure (Standard)!

• Para bugs ou problemas, crie uma publicação no GitHub.
• Para perguntas, solicitações, opiniões e outros tipos de comentários, use este formulário de comentários.