Criar, editar ou estender o JSON para definições de fluxo de trabalho do aplicativo lógico nos Aplicativos Lógicos do Azure

Artigo
01/04/2024

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

Quando você cria soluções de integração corporativa com fluxos de trabalho automatizados em Aplicativos Lógicos do Azure, as definições de fluxo de trabalho subjacentes usam JSON (JavaScript Object Notation) simples e declarativo, junto com o Esquema de Linguagem de Definição do Fluxo de Trabalho (WDL) para sua descrição e validação. Esses formatos tornam as definições do fluxo de trabalho mais fáceis de ler e entender sem saber muito sobre o código. Quando você quiser automatizar a criação e implantação de recursos de aplicativos lógicos, você pode incluir definições de fluxo de trabalho como recursos do Azure dentro de modelos do Azure Resource Manager. Para criar, gerenciar e implantar aplicativos lógicos, você pode usar Azure PowerShell, CLI do Azure, ou APIs REST de Aplicativo Lógico do Azure.

Para trabalhar com definições de fluxo de trabalho em JSON, abra o editor do modo de exibição de código ao trabalhar no portal do Azure ou no Visual Studio ou copie a definição em qualquer editor que você deseja. Se você for novato nos Aplicativos Lógicos do Azure, leia o artigo Criar um exemplo de fluxo de trabalho de aplicativo lógico de Consumo.

Observação

Alguns recursos de Aplicativos Lógicos do Azure, como parâmetros de definição e vários gatilhos em definições de fluxo de trabalho, estão disponíveis somente em JSON, não no designer do fluxo de trabalho. Portanto, para essas tarefas, você deve trabalhar no modo de exibição de código ou em outro editor.

Editar o JSON - portal do Azure

Entre no portal do Azure.
No menu à esquerda, escolha Todos os serviços. Na caixa de pesquisa, localize "aplicativos lógicos" e, em seguida, nos resultados, selecione seu aplicativo lógico.
No menu do aplicativo lógico, em Ferramentas de desenvolvimento, selecione modo de exibição de código do aplicativo lógico.

A janela do editor do modo de exibição de código é aberta e mostra a definição do fluxo de trabalho no formato JSON.

Editar JSON - Visual Studio

Antes de trabalhar em sua definição do fluxo de trabalho no Visual Studio, certifique-se de que você já instalou as ferramentas necessárias. Para criar um aplicativo lógico com o Visual Studio, examine Início Rápido: automatizar tarefas e processos com os Aplicativos Lógicos do Azure - Visual Studio.

No Visual Studio, é possível abrir aplicativos lógicos que foram criados e implantados diretamente do portal do Azure ou como projetos do Azure Resource Manager do Visual Studio.

Abra a solução do Visual Studio, ou o projeto Grupo de Recursos do Azure, que contém o aplicativo lógico.
Localize e abra a definição fluxo de trabalho, que, por padrão, aparece em um modelo do Resource Manager, denominado LogicApp.json. Você pode usar e personalizar este modelo de implantação para ambientes diferentes.
Abra o menu de atalho para o modelo e a definição do fluxo de trabalho. Selecione Abrir com o Designer de Aplicativo Lógico.

Dica

Caso não tenha esse comando no Visual Studio 2019, verifique se você tem as atualizações mais recentes do Visual Studio.
Na parte inferior do designer do fluxo de trabalho, escolha modo de exibição de código.

A janela do editor do modo de exibição de código é aberta e mostra a definição do fluxo de trabalho no formato JSON.
Para retornar ao modo de exibição designer, na parte inferior do editor de modo de exibição de código, escolha Design.

Parâmetros

O ciclo de vida da implantação geralmente tem ambientes diferentes para desenvolvimento, teste, preparo e produção. Quando você tem valores que deseja reutilizar em seu aplicativo lógico sem hard-coding ou que variam de acordo com suas necessidades de implantação, você pode criar um modelo do Azure Resource Manager para sua definição de fluxo de trabalho para que você também possa automatizar a implantação do aplicativo lógico.

Siga estas etapas gerais para parametrizar ou definir e usar parâmetros para esses valores em vez disso. Em seguida, você pode fornecer os valores em um arquivo de parâmetro separado que passa esses valores para o modelo. Dessa forma, você pode alterar esses valores com mais facilidade, sem precisar atualizar e reimplantar seu aplicativo lógico. Para obter detalhes completos, consulte Visão geral: automatizar a implantação para aplicativos lógicos com modelos do Azure Resource Manager.

Em seu modelo, defina parâmetros de modelo e parâmetros de definição de fluxo de trabalho para aceitar os valores a serem usados na implantação e no runtime, respectivamente.

Os parâmetros de modelo são definidos em uma seção de parâmetros que está fora de sua definição de fluxo de trabalho, enquanto parâmetros de definição de fluxo de trabalho são definidos em uma seção de parâmetros que está dentro de sua definição de fluxo de trabalho.
Substitua os valores codificados por expressões que fazem referência a esses parâmetros. As expressões de modelo usam sintaxe que difere das expressões de definição de fluxo de trabalho.

Evite complicar seu código e não use expressões de modelo, que são avaliadas na implantação, dentro de expressões de definição de fluxo de trabalho, que são avaliadas no runtime. Use apenas expressões de modelo fora de sua definição de fluxo de trabalho. Use somente expressões de definição de fluxo de trabalho dentro de sua definição de fluxo de trabalho.

Ao especificar os valores para seus parâmetros de definição de fluxo de trabalho, você pode referenciar parâmetros de modelo usando a seção de parâmetros que está fora de sua definição de fluxo de trabalho, mas ainda dentro da definição de recurso para seu aplicativo lógico. Dessa forma, você pode passar valores de parâmetro de modelo para seus parâmetros de definição de fluxo de trabalho.
Armazene os valores para seus parâmetros em um arquivo de parâmetro separado e inclua esse arquivo com a sua implantação.

Cadeias de caracteres de processo com funções

Os Aplicativos Lógicos do Azure têm várias funções para trabalhar com cadeias de caracteres. Por exemplo, suponha que você deseje passar o nome de uma empresa de um pedido para outro sistema. No entanto, você não tem certeza sobre como tratar adequadamente a codificação de caracteres. Você pode executar a codificação base64 nessa cadeia de caracteres, mas para evitar escapes na URL, você pode substituir alguns caracteres no lugar. Além disso, você só precisa de um substring do nome da empresa, porque os cinco primeiros caracteres não são usados.

{
  "$schema": "https://schema.management.azure.com/schemas/2016-06-01/Microsoft.Logic.json",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "order": {
      "defaultValue": {
        "quantity": 10,
        "id": "myorder1",
        "companyName": "NAME=Contoso"
      },
      "type": "Object"
    }
  },
  "triggers": {
    "request": {
      "type": "Request",
      "kind": "Http"
    }
  },
  "actions": {
    "order": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "https://www.example.com/?id=@{replace(replace(base64(substring(parameters('order').companyName,5,sub(length(parameters('order').companyName), 5) )),'+','-') ,'/' ,'_' )}"
      }
    }
  },
  "outputs": {}
}

Estas etapas descrevem como esse exemplo processa essa cadeia de caracteres, trabalhando de dentro para fora:

"uri": "https://www.example.com/?id=@{replace(replace(base64(substring(parameters('order').companyName,5,sub(length(parameters('order').companyName), 5) )),'+','-') ,'/' ,'_' )}"

Obtenha o length() para o nome da empresa, para obter o número total de caracteres.
Para obter uma cadeia de caracteres mais curta, subtraia 5.
Agora, você obtem substring(). Comece no 5 do índice e siga pelo restante da cadeia de caracteres.
Converter esta subcadeia de caracteres em uma cadeia de caracteres base64().
Agora, replace() todos os + caracteres com - caracteres.
Finalmente, replace() todos os / caracteres com _ caracteres.

Mapeie itens de lista a valores de propriedade e, em seguida, use mapas como parâmetros

Para obter resultados diferentes com base em um valor de propriedade, você pode criar um mapa que corresponda cada valor de propriedade a um resultado e, então, usar esse mapa como parâmetro.

Por exemplo, esse fluxo de trabalho define algumas categorias como parâmetros e um mapa que corresponde essas categorias a uma URL específica. Primeiro, o fluxo de trabalho obtém uma lista de artigos. Em seguida, o fluxo de trabalho usa o mapa para localizar a URL correspondente à categoria de cada artigo.

A função intersection() verifica se a categoria corresponde a uma categoria definida conhecida.
Depois de obter uma categoria correspondente, o exemplo obtém o item do mapa usando colchetes: parameters[...]

{
  "$schema": "https://schema.management.azure.com/schemas/2016-06-01/Microsoft.Logic.json",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "specialCategories": {
      "defaultValue": [
        "science",
        "google",
        "microsoft",
        "robots",
        "NSA"
      ],
      "type": "Array"
    },
    "destinationMap": {
      "defaultValue": {
        "science": "https://www.nasa.gov",
        "microsoft": "https://www.microsoft.com/en-us/default.aspx",
        "google": "https://www.google.com",
        "robots": "https://en.wikipedia.org/wiki/Robot",
        "NSA": "https://www.nsa.gov/"
      },
      "type": "Object"
    }
  },
  "triggers": {
    "Request": {
      "type": "Request",
      "kind": "http"
    }
  },
  "actions": {
    "getArticles": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "https://ajax.googleapis.com/ajax/services/feed/load?v=1.0&q=https://feeds.wired.com/wired/index"
      }
    },
    "forEachArticle": {
      "type": "foreach",
      "foreach": "@body('getArticles').responseData.feed.entries",
      "actions": {
        "ifGreater": {
          "type": "if",
          "expression": "@greater(length(intersection(item().categories, parameters('specialCategories'))), 0)",
          "actions": {
            "getSpecialPage": {
              "type": "Http",
              "inputs": {
                "method": "GET",
                "uri": "@parameters('destinationMap')[first(intersection(item().categories, parameters('specialCategories')))]"
              }
            }
          }
        }
      },
      "runAfter": {
        "getArticles": [
          "Succeeded"
        ]
      }
    }
  }
}

Obter dados com funções de Data

Para obter dados de uma fonte de dados que não ofereça suporte a gatilhos, você pode, em vez disso, usar funções de Data para trabalhar com tempos de data e datas. Por exemplo, essa expressão descobre quanto tempo estão demorando as etapas do fluxo de trabalho, trabalhando de dentro para fora:

"expression": "@less(actions('order').startTime,addseconds(utcNow(),-1))",

Na ação order, extraia startTime.
Obtenha o tempo atual com utcNow().
Subtraia um segundo:

addseconds(..., -1)

Você pode usar outras unidades de tempo, como minutes ou hours.
Agora, você pode comparar esses dois valores.

Se o primeiro valor for menor que o segundo valor, mais de um segundo terá decorrido desde o primeiro pedido.

Para formatar datas, você pode usar formatadores de cadeia de caracteres. Por exemplo, para obter RFC1123, use utcnow('r'). Saiba mais sobre formatação de data.

{
  "$schema": "https://schema.management.azure.com/schemas/2016-06-01/Microsoft.Logic.json",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "order": {
      "defaultValue": {
        "quantity": 10,
        "id": "myorder-id"
      },
      "type": "Object"
    }
  },
  "triggers": {
    "Request": {
      "type": "request",
      "kind": "http"
    }
  },
  "actions": {
    "order": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "https://www.example.com/?id=@{parameters('order').id}"
      }
    },
    "ifTimingWarning": {
      "type": "If",
      "expression": "@less(actions('order').startTime,addseconds(utcNow(),-1))",
      "actions": {
        "timingWarning": {
          "type": "Http",
          "inputs": {
            "method": "GET",
            "uri": "https://www.example.com/?recordLongOrderTime=@{parameters('order').id}&currentTime=@{utcNow('r')}"
          }
        }
      },
      "runAfter": {
        "order": [
          "Succeeded"
        ]
      }
    }
  },
  "outputs": {}
}