在每个月的第三个工作日触发 Azure Logic App

Question

我在使用逻辑应用程序设计重复触发器时遇到问题。据我所知，逻辑应用程序不支持 CRON 表达式，而且运行每天有条件触发似乎还不够，所以我完全不知所措。

编辑：

为了更准确地说明我的问题，逻辑应用程序用于将文件从一台服务器移动到另一台服务器，外部约束规定此移动应每月完成一次，并且移动应在第三个工作日进行（周一至周五）。

我目前正在考虑要么保存一个全局变量来告诉我应用程序本月是否成功运行，要么每天使用条件检查它是否应该在当天运行，或启动运行确定当前日期是否为当前月份的第三个工作日的脚本，并使用它来确定逻辑应用程序是否应执行或终止。

Answer 1

您可以在逻辑应用中使用 recurrence trigger 每三周在星期一触发工作流。

有关重复触发的更多信息，您可以参考 this 文档。

更新答案：

根据要求，我们创建了一个逻辑应用程序，将重复作为触发器，频率作为日期。此工作流每天都会触发，并将验证当前日期是否在 (3,4,5) 之间。如果条件成功，它将进一步执行逻辑应用程序操作。

这是我们创建的逻辑应用程序：

这是逻辑应用程序的代码视图：

{
    "definition": {
        "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
        "actions": {
            "Compose_2": {
                "inputs": "@formatDateTime(utcNow(), 'dd')",
                "runAfter": {},
                "type": "Compose"
            },
            "Condition": {
                "actions": {
                    "Compose": {
                        "inputs": "@utcNow()",
                        "runAfter": {},
                        "type": "Compose"
                    }
                },
                "expression": {
                    "or": [
                        {
                            "equals": [
                                "@int(outputs('Compose_2'))",
                                3
                            ]
                        },
                        {
                            "equals": [
                                "@int(outputs('Compose_2'))",
                                4
                            ]
                        },
                        {
                            "equals": [
                                "@int(outputs('Compose_2'))",
                                5
                            ]
                        }
                    ]
                },
                "runAfter": {
                    "Compose_2": [
                        "Succeeded"
                    ]
                },
                "type": "If"
            }
        },
        "contentVersion": "1.0.0.0",
        "outputs": {},
        "parameters": {},
        "triggers": {
            "Recurrence": {
                "evaluatedRecurrence": {
                    "frequency": "Day",
                    "interval": 1,
                    "schedule": {
                        "hours": [
                            "17"
                        ],
                        "minutes": [
                            16
                        ]
                    },
                    "startTime": "2021-12-28T17:14:00",
                    "timeZone": "India Standard Time"
                },
                "recurrence": {
                    "frequency": "Day",
                    "interval": 1,
                    "startTime": "2021-12-28T17:14:00",
                    "timeZone": "India Standard Time"
                },
                "type": "Recurrence"
            }
        }
    },
    "parameters": {}
}

注：每天执行逻辑应用程序可能会产生更多的账单，而且逻辑应用程序不支持任何 CORN 表达式。在这些场景中，建议使用 Azure 时间触发函数而不是逻辑应用程序。

Answer 2

我可以看到三个主要选项，其中两个我会在这里考虑。主要原因，由于成本，我没有使用 Inline Javascript 操作，因为它需要一个集成帐户，这将比以下任一选项产生更多的成本。

先决条件

触发器应该是每天重复一次。它仍然需要运行，只是它是否做任何事情。无可避免。

用当前日期初始化String类型的变量。我包含了一个采用 UTC 并将其转换为您当地时区的公式，您只需相应地更改它即可。

convertTimeZone(utcNow(), 'UTC', 'AUS Eastern Standard Time')

选项 1 - Azure 函数

Azure Functions 是迄今为止最简单的方法。创建一个 .NET 函数应用程序（或您熟悉的任何语言，但您将无法使用下面的代码）并从那里创建一个具有以下代码的函数，名为 GetBusinessDayOfMonthForDate ...

public static async Task<IActionResult> Run(HttpRequest req, ILogger log)
{
    DateTime dateToProcess = DateTime.Parse(req.Query["Date"]);
    
    int businessDayCount = 0;
    var tempDate = dateToProcess;

    while (tempDate.Month == dateToProcess.Month)
    {                    
        businessDayCount += (tempDate.DayOfWeek.ToString().Substring(0, 1) != "S") ? 1 : 0;
        tempDate = tempDate.AddDays(-1);
    }

    return new OkObjectResult(businessDayCount.ToString());
}

现在在上一个操作之后直接从逻辑应用调用它...

选项 2 - 标准操作

这种方法的基本前提与 Azure Function 相同，但自然要冗长得多。

这是该方法的 JSON 定义，它包括在您自己的环境中测试它所需的一切。

{
    "definition": {
        "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
        "actions": {
            "Condition": {
                "actions": {},
                "else": {
                    "actions": {
                        "Terminate": {
                            "inputs": {
                                "runStatus": "Cancelled"
                            },
                            "runAfter": {},
                            "type": "Terminate"
                        }
                    }
                },
                "expression": {
                    "and": [
                        {
                            "equals": [
                                "@variables('Business Days Up to Today')",
                                3
                            ]
                        }
                    ]
                },
                "runAfter": {
                    "Until_Day_Index_=_-5": [
                        "Succeeded"
                    ]
                },
                "type": "If"
            },
            "Initialize_Business_Days_Up_to_Today": {
                "inputs": {
                    "variables": [
                        {
                            "name": "Business Days Up to Today",
                            "type": "integer",
                            "value": 0
                        }
                    ]
                },
                "runAfter": {
                    "Initialize_Temp_Date": [
                        "Succeeded"
                    ]
                },
                "type": "InitializeVariable"
            },
            "Initialize_Current_Date": {
                "inputs": {
                    "variables": [
                        {
                            "name": "Current Date",
                            "type": "string",
                            "value": "@{convertTimeZone(utcNow(), 'UTC', 'AUS Eastern Standard Time')}"
                        }
                    ]
                },
                "runAfter": {},
                "type": "InitializeVariable"
            },
            "Initialize_Day_Index": {
                "inputs": {
                    "variables": [
                        {
                            "name": "Day Index",
                            "type": "integer",
                            "value": 0
                        }
                    ]
                },
                "runAfter": {
                    "Initialize_Business_Days_Up_to_Today": [
                        "Succeeded"
                    ]
                },
                "type": "InitializeVariable"
            },
            "Initialize_Temp_Date": {
                "inputs": {
                    "variables": [
                        {
                            "name": "Temp Date",
                            "type": "string",
                            "value": "@variables('Current Date')"
                        }
                    ]
                },
                "runAfter": {
                    "Initialize_Current_Date": [
                        "Succeeded"
                    ]
                },
                "type": "InitializeVariable"
            },
            "Until_Day_Index_=_-5": {
                "actions": {
                    "Decrement_Current_Date": {
                        "inputs": {
                            "name": "Temp Date",
                            "value": "@{addDays(variables('Current Date'), variables('Day Index'))}"
                        },
                        "runAfter": {},
                        "type": "SetVariable"
                    },
                    "Decrement_Day_Index": {
                        "inputs": {
                            "name": "Day Index",
                            "value": 1
                        },
                        "runAfter": {
                            "Increment_variable": [
                                "Succeeded"
                            ]
                        },
                        "type": "DecrementVariable"
                    },
                    "Increment_variable": {
                        "inputs": {
                            "name": "Business Days Up to Today",
                            "value": "@if(and(greaterOrEquals(dayOfWeek(variables('Temp Date')), 1), lessOrEquals(dayOfWeek(variables('Temp Date')), 6)), 1, 0)"
                        },
                        "runAfter": {
                            "Decrement_Current_Date": [
                                "Succeeded"
                            ]
                        },
                        "type": "IncrementVariable"
                    }
                },
                "expression": "@equals(variables('Day Index'), -5)",
                "limit": {
                    "count": 60,
                    "timeout": "PT1H"
                },
                "runAfter": {
                    "Initialize_Day_Index": [
                        "Succeeded"
                    ]
                },
                "type": "Until"
            }
        },
        "contentVersion": "1.0.0.0",
        "outputs": {},
        "parameters": {},
        "triggers": {
            "Recurrence": {
                "evaluatedRecurrence": {
                    "frequency": "Day",
                    "interval": 1,
                    "timeZone": "AUS Eastern Standard Time"
                },
                "recurrence": {
                    "frequency": "Day",
                    "interval": 1,
                    "timeZone": "AUS Eastern Standard Time"
                },
                "type": "Recurrence"
            }
        }
    },
    "parameters": {}
}

在所有这些基础上，加入一个条件来检查当前工作日变量是否等于 3，如果是，运行您的逻辑。

这包含在上面的 JSON 定义中。

这些方法之一就是我正在做的，所以我希望这能回答你的问题。

在每个月的第三个工作日触发 Azure Logic App

Trigger Azure Logic App on the third business day of every month

azure

triggers

azure-logic-apps

recurrence

先决条件

选项 1 - Azure 函数

选项 2 - 标准操作