Partilhar via

Criar, editar ou expandir JSON para definições de fluxo de aplicações lógicas no Azure Logic Apps

  • Artigo

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

Quando você cria soluções de integração empresarial com fluxos de trabalho automatizados nos Aplicativos Lógicos do Azure, as definições de fluxo de trabalho subjacentes usam JSON (JavaScript Object Notation) simples e declarativa, juntamente com o esquema WDL (Workflow Definition Language) para sua descrição e validação. Esses formatos tornam as definições de fluxo de trabalho mais fáceis de ler e entender sem saber muito sobre código. Quando quiser automatizar a criação e a implantação de recursos lógicos do aplicativo, você pode incluir definições de fluxo de trabalho como recursos do Azure dentro dos modelos do Azure Resource Manager. Para criar, gerenciar e implantar aplicativos lógicos, você pode usar o Azure PowerShell, a CLI do Azure ou as APIs REST dos Aplicativos Lógicos do Azure.

Para trabalhar com definições de fluxo de trabalho em JSON, abra o editor de Exibição de Código ao trabalhar no portal do Azure ou no Visual Studio ou copie a definição em qualquer editor desejado. Se você é novo nos Aplicativos Lógicos do Azure, revise Criar um exemplo de fluxo de trabalho do aplicativo lógico de consumo.

Nota

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

Editar JSON - Portal do Azure

  1. Inicie sessão no portal do Azure.

  2. No menu à esquerda, escolha Todos os serviços. Na caixa de pesquisa, encontre "aplicativos lógicos" e, nos resultados, selecione seu aplicativo lógico.

  3. No menu do seu aplicativo lógico, em Ferramentas de Desenvolvimento, selecione Visualização de Código do Aplicativo Lógico.

    O editor de Visualização de código é aberto e mostra a definição do fluxo de trabalho no formato JSON.

Editar JSON - Visual Studio

Antes de trabalhar em sua definição de fluxo de trabalho no Visual Studio, certifique-se de ter instalado as ferramentas necessárias. Para criar um aplicativo lógico com o Visual Studio, consulte Guia de início rápido: automatizar tarefas e processos com os Aplicativos Lógicos do Azure - Visual Studio.

No Visual Studio, você pode abrir aplicativos lógicos que foram criados e implantados diretamente do portal do Azure ou como projetos do Azure Resource Manager do Visual Studio.

  1. Abra a solução do Visual Studio, ou o projeto do Grupo de Recursos do Azure, que contém seu aplicativo lógico.

  2. Localize e abra sua definição de fluxo de trabalho, que, por padrão, aparece em um modelo do Gerenciador de Recursos, chamado LogicApp.json. Você pode usar e personalizar esse modelo para implantação em diferentes ambientes.

  3. Abra o menu de atalho para a definição e o modelo do fluxo de trabalho. Selecione Abrir com o Estruturador da Aplicação Lógica.

    Aplicativo lógico aberto em uma solução do Visual Studio

    Gorjeta

    Se você não tiver esse comando no Visual Studio 2019, verifique se você tem as atualizações mais recentes para o Visual Studio.

  4. Na parte inferior do designer de fluxo de trabalho, escolha Visualização de código.

    O editor de Visualização de código é aberto e mostra a definição do fluxo de trabalho no formato JSON.

  5. Para retornar à visualização do designer, na parte inferior do editor de Visualização de código, escolha Design.

Parâmetros

O ciclo de vida da implantação geralmente tem ambientes diferentes para desenvolvimento, teste, preparação e produção. Quando você tiver valores que deseja reutilizar em todo o seu aplicativo lógico sem codificação rígida ou que variam com base em suas necessidades de implantação, você pode criar um modelo do Azure Resource Manager para sua definição de fluxo de trabalho para que 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 seguida, você pode fornecer os valores em um arquivo de parâmetro separado que passa esses valores para seu modelo. Dessa forma, você pode alterar esses valores mais facilmente sem ter que atualizar e reimplantar seu aplicativo lógico. Para obter detalhes completos, consulte Visão geral: automatizar a implantação de aplicativos lógicos com modelos do Azure Resource Manager.

  1. 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 tempo de execução, respectivamente.

    Os parâmetros do modelo são definidos em uma seção de parâmetros que está fora da sua definição de fluxo de trabalho, enquanto os parâmetros de definição do fluxo de trabalho são definidos em uma seção de parâmetros que está dentro da sua definição de fluxo de trabalho.

  2. Substitua os valores codificados por expressões que façam referência a esses parâmetros. As expressões de modelo usam sintaxe diferente das expressões de definição de fluxo de trabalho.

    Evite complicar seu código não usando 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 em tempo de execução. Use apenas expressões de modelo fora da definição do fluxo de trabalho. Use apenas expressões de definição de fluxo de trabalho dentro de sua definição de fluxo de trabalho.

    Ao especificar os valores para os parâmetros de definição do fluxo de trabalho, você pode fazer referência aos parâmetros do modelo usando a seção de parâmetros que está fora da definição do fluxo de trabalho, mas ainda dentro da definição de recurso para seu aplicativo lógico. Dessa forma, você pode passar valores de parâmetros de modelo para seus parâmetros de definição de fluxo de trabalho.

  3. Armazene os valores para seus parâmetros em um arquivo de parâmetros separado e inclua esse arquivo com sua implantação.

Processar cadeias de caracteres 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ê queira passar o nome de uma empresa de um pedido para outro sistema. No entanto, você não tem certeza sobre o manuseio adequado para codificação de caracteres. Você pode executar a codificação base64 nessa cadeia de caracteres, mas para evitar escapes na URL, você pode substituir vários caracteres. Além disso, você só precisa de uma substring para o 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 este 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) )),'+','-') ,'/' ,'_' )}"

  1. Obtenha o length() nome da empresa, para obter o número total de caracteres.

  2. Para obter uma string mais curta, subtraia 5.

  3. Agora obtenha um substring()arquivo . Comece no índice 5e vá para o restante da cadeia de caracteres.

  4. Converta essa substring em uma base64() cadeia de caracteres.

  5. Agora replace() todos os + personagens com - personagens.

  6. Finalmente, replace() todos os / personagens com _ personagens.

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

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

Por exemplo, esse fluxo de trabalho define algumas categorias como parâmetros e um mapa que corresponde a essas categorias com 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 encontrar o URL correspondente à categoria de cada artigo.

  • A intersection() função verifica se a categoria corresponde a uma categoria definida conhecida.

  • Depois de obter uma categoria correspondente, o exemplo puxa 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 Date

Para obter dados de uma fonte de dados que não oferece suporte nativo a gatilhos, você pode usar as funções Date para trabalhar com horas e datas. Por exemplo, esta expressão localiza quanto tempo as etapas desse fluxo de trabalho estão demorando, trabalhando de dentro para fora:

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

  1. Da ação, extraia o orderstartTimearquivo .

  2. Obtenha a hora atual com utcNow().

  3. Subtraia um segundo:

    addseconds(..., -1)

    Você pode usar outras unidades de tempo, como minutes ou hours.

  4. Agora, você pode comparar esses dois valores.

    Se o primeiro valor for menor que o segundo, mais de um segundo se passou desde que o pedido foi feito pela primeira vez.

Para formatar datas, você pode usar string formatters. Por exemplo, para obter o 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": {}
}

Próximos passos