Processar mensagens grandes em fluxos de trabalho com a segmentação de dados no Azure Logic Apps

Artigo
01/04/2024

Aplica-se a: Azure Logic Apps (Consumo)

O Azure Logic Apps tem diferentes limites máximos no tamanho do conteúdo da mensagem que os acionadores e as ações podem processar nos fluxos de trabalho da aplicação lógica, com base no tipo de recurso da aplicação lógica e no ambiente em que esse fluxo de trabalho da aplicação lógica é executado. Estes limites ajudam a reduzir qualquer sobrecarga que resulte do armazenamento e processamento de mensagens grandes. Para obter mais informações sobre os limites de tamanho da mensagem, veja Limites de mensagens no Azure Logic Apps.

Se estiver a utilizar ações HTTP incorporadas ou ações de conectores geridos específicas e precisar que o Azure Logic Apps funcione com mensagens maiores do que os limites predefinidos, pode ativar a segmentação de dados, o que divide uma mensagem grande em mensagens mais pequenas. Desta forma, ainda pode transferir ficheiros grandes em condições específicas. Na verdade, quando utiliza estas ações HTTP incorporadas ou ações de conectores geridos específicas, a segmentação de segmentos é a única forma de o Azure Logic Apps poder consumir mensagens grandes. Este requisito significa que a troca de mensagens HTTP subjacente entre o Azure Logic Apps e outros serviços tem de utilizar a segmentação de dados ou que as ligações criadas pelos conectores geridos que pretende utilizar também têm de suportar a segmentação de segmentos.

Nota

O Azure Logic Apps não suporta a segmentação de segmentos nos acionadores devido ao aumento da sobrecarga da troca de várias mensagens. Além disso, o Azure Logic Apps implementa a segmentação de segmentos para ações HTTP com o seu próprio protocolo, conforme descrito neste artigo. Por isso, mesmo que o seu web site ou serviço Web suporte a segmentação de segmentos, não funcionarão com a segmentação de ações HTTP. Para utilizar o agrupamento de ações HTTP com o seu web site ou serviço Web, tem de implementar o mesmo protocolo que é utilizado pelo Azure Logic Apps. Caso contrário, não ative a segmentação de segmentos na ação HTTP.

Este artigo fornece uma descrição geral sobre como funciona a segmentação de segmentos no Azure Logic Apps e como configurar a segmentação de segmentos em ações suportadas.

O que torna as mensagens "grandes"?

As mensagens são "grandes" com base no serviço que está a processar essas mensagens. O limite de tamanho exato em mensagens grandes difere entre o Logic Apps e os conectores. Tanto o Logic Apps como os conectores não podem consumir diretamente mensagens grandes, que têm de ser segmentadas. Para o limite de tamanho da mensagem do Logic Apps, veja Limites e configuração do Logic Apps. Para obter o limite de tamanho da mensagem de cada conector, veja a documentação de referência do conector.

Processamento de mensagens segmentadas para o Logic Apps

O Logic Apps não pode utilizar diretamente saídas de mensagens segmentadas que sejam superiores ao limite de tamanho da mensagem. Apenas as ações que suportam a segmentação de dados podem aceder ao conteúdo da mensagem nestas saídas. Assim, uma ação que processa mensagens grandes tem de cumprir estes critérios:

Nativamente, suporta a segmentação de segmentos quando essa ação pertence a um conector.
Tenha o suporte de segmentação ativado na configuração de runtime dessa ação.

Caso contrário, obtém um erro de runtime quando tenta aceder à saída de conteúdo grande. Para ativar a segmentação de segmentos, veja Configurar o suporte de segmentação de segmentos.

Processamento de mensagens segmentadas para conectores

Os serviços que comunicam com o Logic Apps podem ter os seus próprios limites de tamanho de mensagens. Estes limites são, muitas vezes, inferiores ao limite do Logic Apps. Por exemplo, partindo do princípio de que um conector suporta a segmentação de dados, um conector pode considerar uma mensagem de 30 MB como grande, enquanto o Logic Apps não. Para cumprir o limite deste conector, o Logic Apps divide qualquer mensagem com mais de 30 MB em segmentos mais pequenos.

Para os conectores que suportam a segmentação de segmentos, o protocolo de segmentação subjacente é invisível para os utilizadores finais. No entanto, nem todos os conectores suportam a segmentação de dados, pelo que estes conectores geram erros de runtime quando as mensagens recebidas excedem os limites de tamanho dos conectores.

Para ações que suportam e estão ativadas para segmentação de dados, não pode utilizar corpos de acionadores, variáveis e expressões, como @triggerBody()?['Content'] porque a utilização de qualquer uma destas entradas impede que a operação de segmentação de segmentos aconteça. Em vez disso, utilize a ação Compor. Especificamente, tem de criar um body campo através da ação Compor para armazenar a saída de dados do corpo do acionador, variável, expressão e assim sucessivamente, por exemplo:

"Compose": {
    "inputs": {
        "body": "@variables('myVar1')"
    },
    "runAfter": {
        "Until": [
            "Succeeded"
        ]
    },
    "type": "Compose"
},

Em seguida, para referenciar os dados, na ação de segmentação, utilize @body('Compose') .

"Create_file": {
    "inputs": {
        "body": "@body('Compose')",
        "headers": {
            "ReadFileMetadataFromServer": true
        },
        "host": {
            "connection": {
                "name": "@parameters('$connections')['sftpwithssh_1']['connectionId']"
            }
        },
        "method": "post",
        "path": "/datasets/default/files",
        "queries": {
            "folderPath": "/c:/test1/test1sub",
            "name": "tt.txt",
            "queryParametersSingleEncoded": true
        }
    },
    "runAfter": {
        "Compose": [
            "Succeeded"
        ]
    },
    "runtimeConfiguration": {
        "contentTransfer": {
            "transferMode": "Chunked"
        }
    },
    "type": "ApiConnection"
},

Configurar a segmentação de segmentos através de HTTP

Em cenários HTTP genéricos, pode dividir grandes transferências e carregamentos de conteúdos através de HTTP, para que a sua aplicação lógica e um ponto final possam trocar mensagens grandes. No entanto, tem de segmentar mensagens da forma esperada pelo Logic Apps.

Se um ponto final tiver ativado o agrupamento para transferências ou carregamentos, as ações HTTP na sua aplicação lógica segmentam automaticamente mensagens grandes. Caso contrário, tem de configurar o suporte de segmentação de segmentos no ponto final. Se não for proprietário ou controlar o ponto final ou o conector, poderá não ter a opção de configurar a segmentação de segmentos.

Além disso, se uma ação HTTP ainda não ativar a segmentação de segmentos, também tem de configurar a segmentação na propriedade da runTimeConfiguration ação. Pode definir esta propriedade dentro da ação, diretamente no editor de vista de código, conforme descrito mais tarde, ou no Estruturador de Aplicações Lógicas, conforme descrito aqui:

No canto superior direito da ação HTTP, selecione o botão de reticências (...) e, em seguida, selecione Definições.
Em Transferência de Conteúdo, defina Permitir segmentação de dados como Ativado.
Para continuar a configurar a segmentação de segmentos para transferências ou carregamentos, continue com as secções seguintes.

Transferir conteúdo em segmentos

Muitos pontos finais enviam automaticamente mensagens grandes em segmentos quando transferidos através de um pedido HTTP GET. Para transferir mensagens segmentadas de um ponto final através de HTTP, o ponto final tem de suportar pedidos de conteúdo parciais ou transferências segmentadas. Quando a aplicação lógica envia um pedido HTTP GET para um ponto final para transferir conteúdo e o ponto final responde com um código de estado "206", a resposta contém conteúdo segmentado. O Logic Apps não consegue controlar se um ponto final suporta pedidos parciais. No entanto, quando a sua aplicação lógica obtém a primeira resposta "206", a sua aplicação lógica envia automaticamente vários pedidos para transferir todo o conteúdo.

Para verificar se um ponto final pode suportar conteúdo parcial, envie um pedido HEAD. Este pedido ajuda-o a determinar se a resposta contém o Accept-Ranges cabeçalho. Desta forma, se o ponto final suportar transferências segmentadas mas não enviar conteúdo segmentado, pode sugerir esta opção ao definir o Range cabeçalho no seu pedido HTTP GET.

Estes passos descrevem o processo detalhado que o Logic Apps utiliza para transferir conteúdo segmentado de um ponto final para a sua aplicação lógica:

A sua aplicação lógica envia um pedido HTTP GET para o ponto final.

Opcionalmente, o cabeçalho do pedido pode incluir um Range campo que descreve um intervalo de bytes para pedir segmentos de conteúdo.
O ponto final responde com o código de estado "206" e um corpo de mensagem HTTP.

Os detalhes sobre o conteúdo neste segmento são apresentados no cabeçalho da Content-Range resposta, incluindo informações que ajudam o Logic Apps a determinar o início e o fim do segmento, além do tamanho total de todo o conteúdo antes de segmentar.
A sua aplicação lógica envia automaticamente pedidos HTTP GET de seguimento.

A sua aplicação lógica envia pedidos GET de seguimento até que todo o conteúdo seja obtido.

Por exemplo, esta definição de ação mostra um pedido HTTP GET que define o Range cabeçalho. O cabeçalho sugere que o ponto final deve responder com conteúdo segmentado:

"getAction": {
    "inputs": {
        "headers": {
            "Range": "bytes=0-1023"
        },
       "method": "GET",
       "uri": "http://myAPIendpoint/api/downloadContent"
    },
    "runAfter": {},
    "type": "Http"
}

O pedido GET define o cabeçalho "Intervalo" como "bytes=0-1023", que é o intervalo de bytes. Se o ponto final suportar pedidos de conteúdo parcial, o ponto final responderá com um segmento de conteúdo do intervalo pedido. Com base no ponto final, o formato exato do campo de cabeçalho "Intervalo" pode ser diferente.

Carregar conteúdo em segmentos

Para carregar conteúdo segmentado a partir de uma ação HTTP, a ação tem de ter ativado o suporte de segmentação de segmentos através da propriedade da runtimeConfiguration ação. Esta definição permite que a ação inicie o protocolo de segmentação de segmentos. Em seguida, a sua aplicação lógica pode enviar uma mensagem POST ou PUT inicial para o ponto final de destino. Depois de o ponto final responder com um tamanho de segmento sugerido, a sua aplicação lógica dá seguimento ao enviar pedidos PATCH HTTP que contêm os segmentos de conteúdo.

Os passos seguintes descrevem o processo detalhado que o Logic Apps utiliza para carregar conteúdo segmentado da sua aplicação lógica para um ponto final:

A sua aplicação lógica envia um pedido HTTP POST ou PUT inicial com um corpo de mensagem vazio. O cabeçalho do pedido inclui as seguintes informações sobre o conteúdo que a sua aplicação lógica quer carregar em segmentos:

Campo de cabeçalho do pedido do Logic Apps	Valor	Tipo	Description
x-ms-transfer-mode	segmentado	String	Indica que o conteúdo é carregado em segmentos
x-ms-content-length	<comprimento do conteúdo>	Número inteiro	O tamanho completo do conteúdo em bytes antes de segmentar

O ponto final responde com o código de estado de êxito "200" e as seguintes informações:

Campo de cabeçalho de resposta de ponto final	Tipo	Necessário	Descrição
Localização	String	Yes	A localização do URL para onde enviar as mensagens PATCH de HTTP
x-ms-chunk-size	Número inteiro	No	O tamanho de segmento sugerido em bytes

A sua aplicação lógica cria e envia mensagens PATCH http de seguimento , cada uma com as seguintes informações:

Um segmento de conteúdo baseado em x-ms-chunk-size ou algum tamanho calculado internamente até que todo o conteúdo que totalize x-ms-content-length seja carregado sequencialmente

As seguintes informações de cabeçalho sobre o segmento de conteúdo enviado em cada mensagem PATCH:

Campo de cabeçalho do pedido do Logic Apps	Valor	Tipo	Description
Intervalo de Conteúdos	<intervalo>	String	O intervalo de bytes para o segmento de conteúdo atual, incluindo o valor inicial, o valor final e o tamanho total do conteúdo, por exemplo: "bytes=0-1023/10100"
Tipo de Conteúdo	<tipo de conteúdo>	String	O tipo de conteúdo segmentado
Comprimento do Conteúdo	<comprimento do conteúdo>	String	O comprimento do tamanho em bytes do segmento atual

Após cada pedido PATCH, o ponto final confirma o recibo de cada segmento ao responder com o código de estado "200" e os seguintes cabeçalhos de resposta:

Campo de cabeçalho de resposta de ponto final	Tipo	Necessário	Descrição
Intervalo	String	Yes	O intervalo de bytes do conteúdo que foi recebido pelo ponto final, por exemplo: "bytes=0-1023"
x-ms-chunk-size	Número inteiro	No	O tamanho de segmento sugerido em bytes

Por exemplo, esta definição de ação mostra um pedido HTTP POST para carregar conteúdo segmentado para um ponto final. Na propriedade da runTimeConfiguration ação, a contentTransfer propriedade define transferMode como chunked:

"postAction": {
    "runtimeConfiguration": {
        "contentTransfer": {
            "transferMode": "chunked"
        }
    },
    "inputs": {
        "method": "POST",
        "uri": "http://myAPIendpoint/api/action",
        "body": "@body('getAction')"
    },
    "runAfter": {
    "getAction": ["Succeeded"]
    },
    "type": "Http"
}