@awesome-copilot/copilot-azure-logic-apps-power-automate
Guidelines for developing Azure Logic Apps and Power Automate workflows with best practices for Workflow Definition Language (WDL), integration patterns, and enterprise automation
prpm install @awesome-copilot/copilot-azure-logic-apps-power-automate0 total downloads
📄 Full Prompt Content
---
description: 'Guidelines for developing Azure Logic Apps and Power Automate workflows with best practices for Workflow Definition Language (WDL), integration patterns, and enterprise automation'
applyTo: "**/*.json,**/*.logicapp.json,**/workflow.json,**/*-definition.json,**/*.flow.json"
---
# Azure Logic Apps and Power Automate Instructions
## Overview
These instructions will guide you in writing high-quality Azure Logic Apps and Microsoft Power Automate workflow definitions using the JSON-based Workflow Definition Language (WDL). Azure Logic Apps is a cloud-based integration platform as a service (iPaaS) that provides 1,400+ connectors to simplify integration across services and protocols. Follow these guidelines to create robust, efficient, and maintainable cloud workflow automation solutions.
## Workflow Definition Language Structure
When working with Logic Apps or Power Automate flow JSON files, ensure your workflow follows this standard structure:
```json
{
"definition": {
"$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
"actions": { },
"contentVersion": "1.0.0.0",
"outputs": { },
"parameters": { },
"staticResults": { },
"triggers": { }
},
"parameters": { }
}
```
## Best Practices for Azure Logic Apps and Power Automate Development
### 1. Triggers
- **Use appropriate trigger types** based on your scenario:
- **Request trigger**: For synchronous API-like workflows
- **Recurrence trigger**: For scheduled operations
- **Event-based triggers**: For reactive patterns (Service Bus, Event Grid, etc.)
- **Configure proper trigger settings**:
- Set reasonable timeout periods
- Use pagination settings for high-volume data sources
- Implement proper authentication
```json
"triggers": {
"manual": {
"type": "Request",
"kind": "Http",
"inputs": {
"schema": {
"type": "object",
"properties": {
"requestParameter": {
"type": "string"
}
}
}
}
}
}
```
### 2. Actions
- **Name actions descriptively** to indicate their purpose
- **Organize complex workflows** using scopes for logical grouping
- **Use proper action types** for different operations:
- HTTP actions for API calls
- Connector actions for built-in integrations
- Data operation actions for transformations
```json
"actions": {
"Get_Customer_Data": {
"type": "Http",
"inputs": {
"method": "GET",
"uri": "https://api.example.com/customers/@{triggerBody()?['customerId']}",
"headers": {
"Content-Type": "application/json"
}
},
"runAfter": {}
}
}
```
### 3. Error Handling and Reliability
- **Implement robust error handling**:
- Use "runAfter" configurations to handle failures
- Configure retry policies for transient errors
- Use scopes with "runAfter" conditions for error branches
- **Implement fallback mechanisms** for critical operations
- **Add timeouts** for external service calls
- **Use runAfter conditions** for complex error handling scenarios
```json
"actions": {
"HTTP_Action": {
"type": "Http",
"inputs": { },
"retryPolicy": {
"type": "fixed",
"count": 3,
"interval": "PT20S",
"minimumInterval": "PT5S",
"maximumInterval": "PT1H"
}
},
"Handle_Success": {
"type": "Scope",
"actions": { },
"runAfter": {
"HTTP_Action": ["Succeeded"]
}
},
"Handle_Failure": {
"type": "Scope",
"actions": {
"Log_Error": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['loganalytics']['connectionId']"
}
},
"method": "post",
"body": {
"LogType": "WorkflowError",
"ErrorDetails": "@{actions('HTTP_Action').outputs.body}",
"StatusCode": "@{actions('HTTP_Action').outputs.statusCode}"
}
}
},
"Send_Notification": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['office365']['connectionId']"
}
},
"method": "post",
"path": "/v2/Mail",
"body": {
"To": "support@contoso.com",
"Subject": "Workflow Error - HTTP Call Failed",
"Body": "<p>The HTTP call failed with status code: @{actions('HTTP_Action').outputs.statusCode}</p>"
}
},
"runAfter": {
"Log_Error": ["Succeeded"]
}
}
},
"runAfter": {
"HTTP_Action": ["Failed", "TimedOut"]
}
}
}
```
### 4. Expressions and Functions
- **Use built-in expression functions** to transform data
- **Keep expressions concise and readable**
- **Document complex expressions** with comments
Common expression patterns:
- String manipulation: `concat()`, `replace()`, `substring()`
- Collection operations: `filter()`, `map()`, `select()`
- Conditional logic: `if()`, `and()`, `or()`, `equals()`
- Date/time manipulation: `formatDateTime()`, `addDays()`
- JSON handling: `json()`, `array()`, `createArray()`
```json
"Set_Variable": {
"type": "SetVariable",
"inputs": {
"name": "formattedData",
"value": "@{map(body('Parse_JSON'), item => {
return {
id: item.id,
name: toUpper(item.name),
date: formatDateTime(item.timestamp, 'yyyy-MM-dd')
}
})}"
}
}
```
#### Using Expressions in Power Automate Conditions
Power Automate supports advanced expressions in conditions to check multiple values. When working with complex logical conditions, use the following pattern:
- For comparing a single value: Use the basic condition designer interface
- For multiple conditions: Use advanced expressions in advanced mode
Common logical expression functions for conditions in Power Automate:
| Expression | Description | Example |
|------------|-------------|---------|
| `and` | Returns true if both arguments are true | `@and(equals(item()?['Status'], 'completed'), equals(item()?['Assigned'], 'John'))` |
| `or` | Returns true if either argument is true | `@or(equals(item()?['Status'], 'completed'), equals(item()?['Status'], 'unnecessary'))` |
| `equals` | Checks if values are equal | `@equals(item()?['Status'], 'blocked')` |
| `greater` | Checks if first value is greater than second | `@greater(item()?['Due'], item()?['Paid'])` |
| `less` | Checks if first value is less than second | `@less(item()?['dueDate'], addDays(utcNow(),1))` |
| `empty` | Checks if object, array or string is empty | `@empty(item()?['Status'])` |
| `not` | Returns opposite of a boolean value | `@not(contains(item()?['Status'], 'Failed'))` |
Example: Check if a status is "completed" OR "unnecessary":
```
@or(equals(item()?['Status'], 'completed'), equals(item()?['Status'], 'unnecessary'))
```
Example: Check if status is "blocked" AND assigned to specific person:
```
@and(equals(item()?['Status'], 'blocked'), equals(item()?['Assigned'], 'John Wonder'))
```
Example: Check if a payment is overdue AND incomplete:
```
@and(greater(item()?['Due'], item()?['Paid']), less(item()?['dueDate'], utcNow()))
```
**Note:** In Power Automate, when accessing dynamic values from previous steps in expressions, use the syntax `item()?['PropertyName']` to safely access properties in a collection.
### 5. Parameters and Variables
- **Parameterize your workflows** for reusability across environments
- **Use variables for temporary values** within a workflow
- **Define clear parameter schemas** with default values and descriptions
```json
"parameters": {
"apiEndpoint": {
"type": "string",
"defaultValue": "https://api.dev.example.com",
"metadata": {
"description": "The base URL for the API endpoint"
}
}
},
"variables": {
"requestId": "@{guid()}",
"processedItems": []
}
```
### 6. Control Flow
- **Use conditions** for branching logic
- **Implement parallel branches** for independent operations
- **Use foreach loops** with reasonable batch sizes for collections
- **Apply until loops** with proper exit conditions
```json
"Process_Items": {
"type": "Foreach",
"foreach": "@body('Get_Items')",
"actions": {
"Process_Single_Item": {
"type": "Scope",
"actions": { }
}
},
"runAfter": {
"Get_Items": ["Succeeded"]
},
"runtimeConfiguration": {
"concurrency": {
"repetitions": 10
}
}
}
```
### 7. Content and Message Handling
- **Validate message schemas** to ensure data integrity
- **Implement proper content type handling**
- **Use Parse JSON actions** to work with structured data
```json
"Parse_Response": {
"type": "ParseJson",
"inputs": {
"content": "@body('HTTP_Request')",
"schema": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"data": {
"type": "array",
"items": {
"type": "object",
"properties": { }
}
}
}
}
}
}
```
### 8. Security Best Practices
- **Use managed identities** when possible
- **Store secrets in Key Vault**
- **Implement least privilege access** for connections
- **Secure API endpoints** with authentication
- **Implement IP restrictions** for HTTP triggers
- **Apply data encryption** for sensitive data in parameters and messages
- **Use Azure RBAC** to control access to Logic Apps resources
- **Conduct regular security reviews** of workflows and connections
```json
"Get_Secret": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['keyvault']['connectionId']"
}
},
"method": "get",
"path": "/secrets/@{encodeURIComponent('apiKey')}/value"
}
},
"Call_Protected_API": {
"type": "Http",
"inputs": {
"method": "POST",
"uri": "https://api.example.com/protected",
"headers": {
"Content-Type": "application/json",
"Authorization": "Bearer @{body('Get_Secret')?['value']}"
},
"body": {
"data": "@variables('processedData')"
}
},
"authentication": {
"type": "ManagedServiceIdentity"
},
"runAfter": {
"Get_Secret": ["Succeeded"]
}
}
```
## Performance Optimization
- **Minimize unnecessary actions**
- **Use batch operations** when available
- **Optimize expressions** to reduce complexity
- **Configure appropriate timeout values**
- **Implement pagination** for large data sets
- **Implement concurrency control** for parallelizable operations
```json
"Process_Items": {
"type": "Foreach",
"foreach": "@body('Get_Items')",
"actions": {
"Process_Single_Item": {
"type": "Scope",
"actions": { }
}
},
"runAfter": {
"Get_Items": ["Succeeded"]
},
"runtimeConfiguration": {
"concurrency": {
"repetitions": 10
}
}
}
```
### Workflow Design Best Practices
- **Limit workflows to 50 actions or less** for optimal designer performance
- **Split complex business logic** into multiple smaller workflows when necessary
- **Use deployment slots** for mission-critical logic apps that require zero downtime deployments
- **Avoid hardcoded properties** in trigger and action definitions
- **Add descriptive comments** to provide context about trigger and action definitions
- **Use built-in operations** when available instead of shared connectors for better performance
- **Use an Integration Account** for B2B scenarios and EDI message processing
- **Reuse workflow templates** for standard patterns across your organization
- **Avoid deep nesting** of scopes and actions to maintain readability
### Monitoring and Observability
- **Configure diagnostic settings** to capture workflow runs and metrics
- **Add tracking IDs** to correlate related workflow runs
- **Implement comprehensive logging** with appropriate detail levels
- **Set up alerts** for workflow failures and performance degradation
- **Use Application Insights** for end-to-end tracing and monitoring
## Platform Types and Considerations
### Azure Logic Apps vs Power Automate
While Azure Logic Apps and Power Automate share the same underlying workflow engine and language, they have different target audiences and capabilities:
- **Power Automate**:
- User-friendly interface for business users
- Part of the Power Platform ecosystem
- Integration with Microsoft 365 and Dynamics 365
- Desktop flow capabilities for UI automation
- **Azure Logic Apps**:
- Enterprise-grade integration platform
- Developer-focused with advanced capabilities
- Deeper Azure service integration
- More extensive monitoring and operations capabilities
### Logic App Types
#### Consumption Logic Apps
- Pay-per-execution pricing model
- Serverless architecture
- Suitable for variable or unpredictable workloads
#### Standard Logic Apps
- Fixed pricing based on App Service Plan
- Predictable performance
- Local development support
- Integration with VNets
#### Integration Service Environment (ISE)
- Dedicated deployment environment
- Higher throughput and longer execution durations
- Direct access to VNet resources
- Isolated runtime environment
### Power Automate License Types
- **Power Automate per user plan**: For individual users
- **Power Automate per flow plan**: For specific workflows
- **Power Automate Process plan**: For RPA capabilities
- **Power Automate included with Office 365**: Limited capabilities for Office 365 users
## Common Integration Patterns
### Architectural Patterns
- **Mediator Pattern**: Use Logic Apps/Power Automate as an orchestration layer between systems
- **Content-Based Routing**: Route messages based on content to different destinations
- **Message Transformation**: Transform messages between formats (JSON, XML, EDI, etc.)
- **Scatter-Gather**: Distribute work in parallel and aggregate results
- **Protocol Bridging**: Connect systems with different protocols (REST, SOAP, FTP, etc.)
- **Claim Check**: Store large payloads externally in blob storage or databases
- **Saga Pattern**: Manage distributed transactions with compensating actions for failures
- **Choreography Pattern**: Coordinate multiple services without a central orchestrator
### Action Patterns
- **Asynchronous Processing Pattern**: For long-running operations
```json
"LongRunningAction": {
"type": "Http",
"inputs": {
"method": "POST",
"uri": "https://api.example.com/longrunning",
"body": { "data": "@triggerBody()" }
},
"retryPolicy": {
"type": "fixed",
"count": 3,
"interval": "PT30S"
}
}
```
- **Webhook Pattern**: For callback-based processing
```json
"WebhookAction": {
"type": "ApiConnectionWebhook",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['servicebus']['connectionId']"
}
},
"body": {
"content": "@triggerBody()"
},
"path": "/subscribe/topics/@{encodeURIComponent('mytopic')}/subscriptions/@{encodeURIComponent('mysubscription')}"
}
}
```
### Enterprise Integration Patterns
- **B2B Message Exchange**: Exchange EDI documents between trading partners (AS2, X12, EDIFACT)
- **Integration Account**: Use for storing and managing B2B artifacts (agreements, schemas, maps)
- **Rules Engine**: Implement complex business rules using the Azure Logic Apps Rules Engine
- **Message Validation**: Validate messages against schemas for compliance and data integrity
- **Transaction Processing**: Process business transactions with compensating transactions for rollback
## DevOps and CI/CD for Logic Apps
### Source Control and Versioning
- **Store Logic App definitions in source control** (Git, Azure DevOps, GitHub)
- **Use ARM templates** for deployment to multiple environments
- **Implement branching strategies** appropriate for your release cadence
- **Version your Logic Apps** using tags or version properties
### Automated Deployment
- **Use Azure DevOps pipelines** or GitHub Actions for automated deployments
- **Implement parameterization** for environment-specific values
- **Use deployment slots** for zero-downtime deployments
- **Include post-deployment validation** tests in your CI/CD pipeline
```yaml
# Example Azure DevOps YAML pipeline for Logic App deployment
trigger:
branches:
include:
- main
- release/*
pool:
vmImage: 'ubuntu-latest'
steps:
- task: AzureResourceManagerTemplateDeployment@3
inputs:
deploymentScope: 'Resource Group'
azureResourceManagerConnection: 'Your-Azure-Connection'
subscriptionId: '$(subscriptionId)'
action: 'Create Or Update Resource Group'
resourceGroupName: '$(resourceGroupName)'
location: '$(location)'
templateLocation: 'Linked artifact'
csmFile: '$(System.DefaultWorkingDirectory)/arm-templates/logicapp-template.json'
csmParametersFile: '$(System.DefaultWorkingDirectory)/arm-templates/logicapp-parameters-$(Environment).json'
deploymentMode: 'Incremental'
```
## Cross-Platform Considerations
When working with both Azure Logic Apps and Power Automate:
- **Export/Import Compatibility**: Flows can be exported from Power Automate and imported into Logic Apps, but some modifications may be required
- **Connector Differences**: Some connectors are available in one platform but not the other
- **Environment Isolation**: Power Automate environments provide isolation and may have different policies
- **ALM Practices**: Consider using Azure DevOps for Logic Apps and Solutions for Power Automate
### Migration Strategies
- **Assessment**: Evaluate complexity and suitability for migration
- **Connector Mapping**: Map connectors between platforms and identify gaps
- **Testing Strategy**: Implement parallel testing before cutover
- **Documentation**: Document all configuration changes for reference
```json
// Example Power Platform solution structure for Power Automate flows
{
"SolutionName": "MyEnterpriseFlows",
"Version": "1.0.0",
"Flows": [
{
"Name": "OrderProcessingFlow",
"Type": "Microsoft.Flow/flows",
"Properties": {
"DisplayName": "Order Processing Flow",
"DefinitionData": {
"$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
"triggers": {
"When_a_new_order_is_created": {
"type": "ApiConnectionWebhook",
"inputs": {
"host": {
"connectionName": "shared_commondataserviceforapps",
"operationId": "SubscribeWebhookTrigger",
"apiId": "/providers/Microsoft.PowerApps/apis/shared_commondataserviceforapps"
}
}
}
},
"actions": {
// Actions would be defined here
}
}
}
}
]
}
```
## Practical Logic App Examples
### HTTP Request Handler with API Integration
This example demonstrates a Logic App that accepts an HTTP request, validates the input data, calls an external API, transforms the response, and returns a formatted result.
```json
{
"definition": {
"$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
"actions": {
"Validate_Input": {
"type": "If",
"expression": {
"and": [
{
"not": {
"equals": [
"@triggerBody()?['customerId']",
null
]
}
},
{
"not": {
"equals": [
"@triggerBody()?['requestType']",
null
]
}
}
]
},
"actions": {
"Get_Customer_Data": {
"type": "Http",
"inputs": {
"method": "GET",
"uri": "https://api.example.com/customers/@{triggerBody()?['customerId']}",
"headers": {
"Content-Type": "application/json",
"Authorization": "Bearer @{body('Get_API_Key')?['value']}"
}
},
"runAfter": {
"Get_API_Key": [
"Succeeded"
]
}
},
"Get_API_Key": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['keyvault']['connectionId']"
}
},
"method": "get",
"path": "/secrets/@{encodeURIComponent('apiKey')}/value"
}
},
"Parse_Customer_Response": {
"type": "ParseJson",
"inputs": {
"content": "@body('Get_Customer_Data')",
"schema": {
"type": "object",
"properties": {
"id": { "type": "string" },
"name": { "type": "string" },
"email": { "type": "string" },
"status": { "type": "string" },
"createdDate": { "type": "string" },
"orders": {
"type": "array",
"items": {
"type": "object",
"properties": {
"orderId": { "type": "string" },
"orderDate": { "type": "string" },
"amount": { "type": "number" }
}
}
}
}
}
},
"runAfter": {
"Get_Customer_Data": [
"Succeeded"
]
}
},
"Switch_Request_Type": {
"type": "Switch",
"expression": "@triggerBody()?['requestType']",
"cases": {
"Profile": {
"actions": {
"Prepare_Profile_Response": {
"type": "SetVariable",
"inputs": {
"name": "responsePayload",
"value": {
"customerId": "@body('Parse_Customer_Response')?['id']",
"customerName": "@body('Parse_Customer_Response')?['name']",
"email": "@body('Parse_Customer_Response')?['email']",
"status": "@body('Parse_Customer_Response')?['status']",
"memberSince": "@formatDateTime(body('Parse_Customer_Response')?['createdDate'], 'yyyy-MM-dd')"
}
}
}
}
},
"OrderSummary": {
"actions": {
"Calculate_Order_Statistics": {
"type": "Compose",
"inputs": {
"totalOrders": "@length(body('Parse_Customer_Response')?['orders'])",
"totalSpent": "@sum(body('Parse_Customer_Response')?['orders'], item => item.amount)",
"averageOrderValue": "@if(greater(length(body('Parse_Customer_Response')?['orders']), 0), div(sum(body('Parse_Customer_Response')?['orders'], item => item.amount), length(body('Parse_Customer_Response')?['orders'])), 0)",
"lastOrderDate": "@if(greater(length(body('Parse_Customer_Response')?['orders']), 0), max(body('Parse_Customer_Response')?['orders'], item => item.orderDate), '')"
}
},
"Prepare_Order_Response": {
"type": "SetVariable",
"inputs": {
"name": "responsePayload",
"value": {
"customerId": "@body('Parse_Customer_Response')?['id']",
"customerName": "@body('Parse_Customer_Response')?['name']",
"orderStats": "@outputs('Calculate_Order_Statistics')"
}
},
"runAfter": {
"Calculate_Order_Statistics": [
"Succeeded"
]
}
}
}
}
},
"default": {
"actions": {
"Set_Default_Response": {
"type": "SetVariable",
"inputs": {
"name": "responsePayload",
"value": {
"error": "Invalid request type specified",
"validTypes": [
"Profile",
"OrderSummary"
]
}
}
}
}
},
"runAfter": {
"Parse_Customer_Response": [
"Succeeded"
]
}
},
"Log_Successful_Request": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['applicationinsights']['connectionId']"
}
},
"method": "post",
"body": {
"LogType": "ApiRequestSuccess",
"CustomerId": "@triggerBody()?['customerId']",
"RequestType": "@triggerBody()?['requestType']",
"ProcessingTime": "@workflow()['run']['duration']"
}
},
"runAfter": {
"Switch_Request_Type": [
"Succeeded"
]
}
},
"Return_Success_Response": {
"type": "Response",
"kind": "Http",
"inputs": {
"statusCode": 200,
"body": "@variables('responsePayload')",
"headers": {
"Content-Type": "application/json"
}
},
"runAfter": {
"Log_Successful_Request": [
"Succeeded"
]
}
}
},
"else": {
"actions": {
"Return_Validation_Error": {
"type": "Response",
"kind": "Http",
"inputs": {
"statusCode": 400,
"body": {
"error": "Invalid request",
"message": "Request must include customerId and requestType",
"timestamp": "@utcNow()"
}
}
}
}
},
"runAfter": {
"Initialize_Response_Variable": [
"Succeeded"
]
}
},
"Initialize_Response_Variable": {
"type": "InitializeVariable",
"inputs": {
"variables": [
{
"name": "responsePayload",
"type": "object",
"value": {}
}
]
}
}
},
"contentVersion": "1.0.0.0",
"outputs": {},
"parameters": {
"$connections": {
"defaultValue": {},
"type": "Object"
}
},
"triggers": {
"manual": {
"type": "Request",
"kind": "Http",
"inputs": {
"schema": {
"type": "object",
"properties": {
"customerId": {
"type": "string"
},
"requestType": {
"type": "string",
"enum": [
"Profile",
"OrderSummary"
]
}
}
}
}
}
}
},
"parameters": {
"$connections": {
"value": {
"keyvault": {
"connectionId": "/subscriptions/{subscription-id}/resourceGroups/{resource-group}/providers/Microsoft.Web/connections/keyvault",
"connectionName": "keyvault",
"id": "/subscriptions/{subscription-id}/providers/Microsoft.Web/locations/{location}/managedApis/keyvault"
},
"applicationinsights": {
"connectionId": "/subscriptions/{subscription-id}/resourceGroups/{resource-group}/providers/Microsoft.Web/connections/applicationinsights",
"connectionName": "applicationinsights",
"id": "/subscriptions/{subscription-id}/providers/Microsoft.Web/locations/{location}/managedApis/applicationinsights"
}
}
}
}
}
```
### Event-Driven Process with Error Handling
This example demonstrates a Logic App that processes events from Azure Service Bus, handles the message processing with robust error handling, and implements the retry pattern for resilience.
```json
{
"definition": {
"$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
"actions": {
"Parse_Message": {
"type": "ParseJson",
"inputs": {
"content": "@triggerBody()?['ContentData']",
"schema": {
"type": "object",
"properties": {
"eventId": { "type": "string" },
"eventType": { "type": "string" },
"eventTime": { "type": "string" },
"dataVersion": { "type": "string" },
"data": {
"type": "object",
"properties": {
"orderId": { "type": "string" },
"customerId": { "type": "string" },
"items": {
"type": "array",
"items": {
"type": "object",
"properties": {
"productId": { "type": "string" },
"quantity": { "type": "integer" },
"unitPrice": { "type": "number" }
}
}
}
}
}
}
}
},
"runAfter": {}
},
"Try_Process_Order": {
"type": "Scope",
"actions": {
"Get_Customer_Details": {
"type": "Http",
"inputs": {
"method": "GET",
"uri": "https://api.example.com/customers/@{body('Parse_Message')?['data']?['customerId']}",
"headers": {
"Content-Type": "application/json",
"Authorization": "Bearer @{body('Get_API_Key')?['value']}"
}
},
"runAfter": {
"Get_API_Key": [
"Succeeded"
]
},
"retryPolicy": {
"type": "exponential",
"count": 5,
"interval": "PT10S",
"minimumInterval": "PT5S",
"maximumInterval": "PT1H"
}
},
"Get_API_Key": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['keyvault']['connectionId']"
}
},
"method": "get",
"path": "/secrets/@{encodeURIComponent('apiKey')}/value"
}
},
"Validate_Stock": {
"type": "Foreach",
"foreach": "@body('Parse_Message')?['data']?['items']",
"actions": {
"Check_Product_Stock": {
"type": "Http",
"inputs": {
"method": "GET",
"uri": "https://api.example.com/inventory/@{items('Validate_Stock')?['productId']}",
"headers": {
"Content-Type": "application/json",
"Authorization": "Bearer @{body('Get_API_Key')?['value']}"
}
},
"retryPolicy": {
"type": "fixed",
"count": 3,
"interval": "PT15S"
}
},
"Verify_Availability": {
"type": "If",
"expression": {
"and": [
{
"greater": [
"@body('Check_Product_Stock')?['availableStock']",
"@items('Validate_Stock')?['quantity']"
]
}
]
},
"actions": {
"Add_To_Valid_Items": {
"type": "AppendToArrayVariable",
"inputs": {
"name": "validItems",
"value": {
"productId": "@items('Validate_Stock')?['productId']",
"quantity": "@items('Validate_Stock')?['quantity']",
"unitPrice": "@items('Validate_Stock')?['unitPrice']",
"availableStock": "@body('Check_Product_Stock')?['availableStock']"
}
}
}
},
"else": {
"actions": {
"Add_To_Invalid_Items": {
"type": "AppendToArrayVariable",
"inputs": {
"name": "invalidItems",
"value": {
"productId": "@items('Validate_Stock')?['productId']",
"requestedQuantity": "@items('Validate_Stock')?['quantity']",
"availableStock": "@body('Check_Product_Stock')?['availableStock']",
"reason": "Insufficient stock"
}
}
}
}
},
"runAfter": {
"Check_Product_Stock": [
"Succeeded"
]
}
}
},
"runAfter": {
"Get_Customer_Details": [
"Succeeded"
]
}
},
"Check_Order_Validity": {
"type": "If",
"expression": {
"and": [
{
"equals": [
"@length(variables('invalidItems'))",
0
]
},
{
"greater": [
"@length(variables('validItems'))",
0
]
}
]
},
"actions": {
"Process_Valid_Order": {
"type": "Http",
"inputs": {
"method": "POST",
"uri": "https://api.example.com/orders",
"headers": {
"Content-Type": "application/json",
"Authorization": "Bearer @{body('Get_API_Key')?['value']}"
},
"body": {
"orderId": "@body('Parse_Message')?['data']?['orderId']",
"customerId": "@body('Parse_Message')?['data']?['customerId']",
"customerName": "@body('Get_Customer_Details')?['name']",
"items": "@variables('validItems')",
"processedTime": "@utcNow()",
"eventId": "@body('Parse_Message')?['eventId']"
}
}
},
"Send_Order_Confirmation": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['office365']['connectionId']"
}
},
"method": "post",
"path": "/v2/Mail",
"body": {
"To": "@body('Get_Customer_Details')?['email']",
"Subject": "Order Confirmation: @{body('Parse_Message')?['data']?['orderId']}",
"Body": "<p>Dear @{body('Get_Customer_Details')?['name']},</p><p>Your order has been successfully processed.</p><p>Order ID: @{body('Parse_Message')?['data']?['orderId']}</p><p>Thank you for your business!</p>",
"Importance": "Normal",
"IsHtml": true
}
},
"runAfter": {
"Process_Valid_Order": [
"Succeeded"
]
}
},
"Complete_Message": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['servicebus']['connectionId']"
}
},
"method": "post",
"path": "/messages/complete",
"body": {
"lockToken": "@triggerBody()?['LockToken']",
"sessionId": "@triggerBody()?['SessionId']",
"queueName": "@parameters('serviceBusQueueName')"
}
},
"runAfter": {
"Send_Order_Confirmation": [
"Succeeded"
]
}
}
},
"else": {
"actions": {
"Send_Invalid_Stock_Notification": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['office365']['connectionId']"
}
},
"method": "post",
"path": "/v2/Mail",
"body": {
"To": "@body('Get_Customer_Details')?['email']",
"Subject": "Order Cannot Be Processed: @{body('Parse_Message')?['data']?['orderId']}",
"Body": "<p>Dear @{body('Get_Customer_Details')?['name']},</p><p>We regret to inform you that your order cannot be processed due to insufficient stock for the following items:</p><p>@{join(variables('invalidItems'), '</p><p>')}</p><p>Please adjust your order and try again.</p>",
"Importance": "High",
"IsHtml": true
}
}
},
"Dead_Letter_Message": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['servicebus']['connectionId']"
}
},
"method": "post",
"path": "/messages/deadletter",
"body": {
"lockToken": "@triggerBody()?['LockToken']",
"sessionId": "@triggerBody()?['SessionId']",
"queueName": "@parameters('serviceBusQueueName')",
"deadLetterReason": "InsufficientStock",
"deadLetterDescription": "Order contained items with insufficient stock"
}
},
"runAfter": {
"Send_Invalid_Stock_Notification": [
"Succeeded"
]
}
}
}
},
"runAfter": {
"Validate_Stock": [
"Succeeded"
]
}
}
},
"runAfter": {
"Initialize_Variables": [
"Succeeded"
]
}
},
"Initialize_Variables": {
"type": "InitializeVariable",
"inputs": {
"variables": [
{
"name": "validItems",
"type": "array",
"value": []
},
{
"name": "invalidItems",
"type": "array",
"value": []
}
]
},
"runAfter": {
"Parse_Message": [
"Succeeded"
]
}
},
"Handle_Process_Error": {
"type": "Scope",
"actions": {
"Log_Error_Details": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['applicationinsights']['connectionId']"
}
},
"method": "post",
"body": {
"LogType": "OrderProcessingError",
"EventId": "@body('Parse_Message')?['eventId']",
"OrderId": "@body('Parse_Message')?['data']?['orderId']",
"CustomerId": "@body('Parse_Message')?['data']?['customerId']",
"ErrorDetails": "@result('Try_Process_Order')",
"Timestamp": "@utcNow()"
}
}
},
"Abandon_Message": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['servicebus']['connectionId']"
}
},
"method": "post",
"path": "/messages/abandon",
"body": {
"lockToken": "@triggerBody()?['LockToken']",
"sessionId": "@triggerBody()?['SessionId']",
"queueName": "@parameters('serviceBusQueueName')"
}
},
"runAfter": {
"Log_Error_Details": [
"Succeeded"
]
}
},
"Send_Alert_To_Operations": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['office365']['connectionId']"
}
},
"method": "post",
"path": "/v2/Mail",
"body": {
"To": "operations@example.com",
"Subject": "Order Processing Error: @{body('Parse_Message')?['data']?['orderId']}",
"Body": "<p>An error occurred while processing an order:</p><p>Order ID: @{body('Parse_Message')?['data']?['orderId']}</p><p>Customer ID: @{body('Parse_Message')?['data']?['customerId']}</p><p>Error: @{result('Try_Process_Order')}</p>",
"Importance": "High",
"IsHtml": true
}
},
"runAfter": {
"Abandon_Message": [
"Succeeded"
]
}
}
},
"runAfter": {
"Try_Process_Order": [
"Failed",
"TimedOut"
]
}
}
},
"contentVersion": "1.0.0.0",
"outputs": {},
"parameters": {
"$connections": {
"defaultValue": {},
"type": "Object"
},
"serviceBusQueueName": {
"type": "string",
"defaultValue": "orders"
}
},
"triggers": {
"When_a_message_is_received_in_a_queue": {
"type": "ApiConnectionWebhook",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['servicebus']['connectionId']"
}
},
"body": {
"isSessionsEnabled": true
},
"path": "/subscriptionListener",
"queries": {
"queueName": "@parameters('serviceBusQueueName')",
"subscriptionType": "Main"
}
}
}
}
},
"parameters": {
"$connections": {
"value": {
"keyvault": {
"connectionId": "/subscriptions/{subscription-id}/resourceGroups/{resource-group}/providers/Microsoft.Web/connections/keyvault",
"connectionName": "keyvault",
"id": "/subscriptions/{subscription-id}/providers/Microsoft.Web/locations/{location}/managedApis/keyvault"
},
"servicebus": {
"connectionId": "/subscriptions/{subscription-id}/resourceGroups/{resource-group}/providers/Microsoft.Web/connections/servicebus",
"connectionName": "servicebus",
"id": "/subscriptions/{subscription-id}/providers/Microsoft.Web/locations/{location}/managedApis/servicebus"
},
"office365": {
"connectionId": "/subscriptions/{subscription-id}/resourceGroups/{resource-group}/providers/Microsoft.Web/connections/office365",
"connectionName": "office365",
"id": "/subscriptions/{subscription-id}/providers/Microsoft.Web/locations/{location}/managedApis/office365"
},
"applicationinsights": {
"connectionId": "/subscriptions/{subscription-id}/resourceGroups/{resource-group}/providers/Microsoft.Web/connections/applicationinsights",
"connectionName": "applicationinsights",
"id": "/subscriptions/{subscription-id}/providers/Microsoft.Web/locations/{location}/managedApis/applicationinsights"
}
}
}
}
}
```
## Advanced Exception Handling and Monitoring
### Comprehensive Exception Handling Strategy
Implement a multi-layered exception handling approach for robust workflows:
1. **Preventative Measures**:
- Use schema validation for all incoming messages
- Implement defensive expression evaluations using `coalesce()` and `?` operators
- Add pre-condition checks before critical operations
2. **Runtime Error Handling**:
- Use structured error handling scopes with nested try/catch patterns
- Implement circuit breaker patterns for external dependencies
- Capture and handle specific error types differently
```json
"Process_With_Comprehensive_Error_Handling": {
"type": "Scope",
"actions": {
"Try_Primary_Action": {
"type": "Scope",
"actions": {
"Main_Operation": {
"type": "Http",
"inputs": { "method": "GET", "uri": "https://api.example.com/resource" }
}
}
},
"Handle_Connection_Errors": {
"type": "Scope",
"actions": {
"Log_Connection_Error": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['loganalytics']['connectionId']"
}
},
"method": "post",
"body": {
"LogType": "ConnectionError",
"ErrorCategory": "Network",
"StatusCode": "@{result('Try_Primary_Action')?['outputs']?['Main_Operation']?['statusCode']}",
"ErrorMessage": "@{result('Try_Primary_Action')?['error']?['message']}"
}
}
},
"Invoke_Fallback_Endpoint": {
"type": "Http",
"inputs": { "method": "GET", "uri": "https://fallback-api.example.com/resource" }
}
},
"runAfter": {
"Try_Primary_Action": ["Failed"]
}
},
"Handle_Business_Logic_Errors": {
"type": "Scope",
"actions": {
"Parse_Error_Response": {
"type": "ParseJson",
"inputs": {
"content": "@outputs('Try_Primary_Action')?['Main_Operation']?['body']",
"schema": {
"type": "object",
"properties": {
"errorCode": { "type": "string" },
"errorMessage": { "type": "string" }
}
}
}
},
"Switch_On_Error_Type": {
"type": "Switch",
"expression": "@body('Parse_Error_Response')?['errorCode']",
"cases": {
"ResourceNotFound": {
"actions": { "Create_Resource": { "type": "Http", "inputs": {} } }
},
"ValidationError": {
"actions": { "Resubmit_With_Defaults": { "type": "Http", "inputs": {} } }
},
"PermissionDenied": {
"actions": { "Elevate_Permissions": { "type": "Http", "inputs": {} } }
}
},
"default": {
"actions": { "Send_To_Support_Queue": { "type": "ApiConnection", "inputs": {} } }
}
}
},
"runAfter": {
"Try_Primary_Action": ["Succeeded"]
}
}
}
}
```
3. **Centralized Error Logging**:
- Create a dedicated Logic App for error handling that other workflows can call
- Log errors with correlation IDs for traceability across systems
- Categorize errors by type and severity for better analysis
### Advanced Monitoring Architecture
Implement a comprehensive monitoring strategy that covers:
1. **Operational Monitoring**:
- **Health Probes**: Create dedicated health check workflows
- **Heartbeat Patterns**: Implement periodic check-ins to verify system health
- **Dead Letter Handling**: Process and analyze failed messages
2. **Business Process Monitoring**:
- **Business Metrics**: Track key business KPIs (order processing times, approval rates)
- **SLA Monitoring**: Measure performance against service level agreements
- **Correlated Tracing**: Implement end-to-end transaction tracking
3. **Alerting Strategy**:
- **Multi-channel Alerts**: Configure alerts to appropriate channels (email, SMS, Teams)
- **Severity-based Routing**: Route alerts based on business impact
- **Alert Correlation**: Group related alerts to prevent alert fatigue
```json
"Monitor_Transaction_SLA": {
"type": "Scope",
"actions": {
"Calculate_Processing_Time": {
"type": "Compose",
"inputs": "@{div(sub(ticks(utcNow()), ticks(triggerBody()?['startTime'])), 10000000)}"
},
"Check_SLA_Breach": {
"type": "If",
"expression": "@greater(outputs('Calculate_Processing_Time'), parameters('slaThresholdSeconds'))",
"actions": {
"Log_SLA_Breach": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['loganalytics']['connectionId']"
}
},
"method": "post",
"body": {
"LogType": "SLABreach",
"TransactionId": "@{triggerBody()?['transactionId']}",
"ProcessingTimeSeconds": "@{outputs('Calculate_Processing_Time')}",
"SLAThresholdSeconds": "@{parameters('slaThresholdSeconds')}",
"BreachSeverity": "@if(greater(outputs('Calculate_Processing_Time'), mul(parameters('slaThresholdSeconds'), 2)), 'Critical', 'Warning')"
}
}
},
"Send_SLA_Alert": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['teams']['connectionId']"
}
},
"method": "post",
"body": {
"notificationTitle": "SLA Breach Alert",
"message": "Transaction @{triggerBody()?['transactionId']} exceeded SLA by @{sub(outputs('Calculate_Processing_Time'), parameters('slaThresholdSeconds'))} seconds",
"channelId": "@{if(greater(outputs('Calculate_Processing_Time'), mul(parameters('slaThresholdSeconds'), 2)), parameters('criticalAlertChannelId'), parameters('warningAlertChannelId'))}"
}
}
}
}
}
}
}
```
## API Management Integration
Integrate Logic Apps with Azure API Management for enhanced security, governance, and management:
### API Management Frontend
- **Expose Logic Apps via API Management**:
- Create API definitions for Logic App HTTP triggers
- Apply consistent URL structures and versioning
- Implement API policies for security and transformation
### Policy Templates for Logic Apps
```xml
<!-- Logic App API Policy Example -->
<policies>
<inbound>
<!-- Authentication -->
<validate-jwt header-name="Authorization" failed-validation-httpcode="401" failed-validation-error-message="Unauthorized">
<openid-config url="https://login.microsoftonline.com/{tenant-id}/.well-known/openid-configuration" />
<required-claims>
<claim name="aud" match="any">
<value>api://mylogicapp</value>
</claim>
</required-claims>
</validate-jwt>
<!-- Rate limiting -->
<rate-limit calls="5" renewal-period="60" />
<!-- Request transformation -->
<set-header name="Correlation-Id" exists-action="override">
<value>@(context.RequestId)</value>
</set-header>
<!-- Logging -->
<log-to-eventhub logger-id="api-logger">
@{
return new JObject(
new JProperty("correlationId", context.RequestId),
new JProperty("api", context.Api.Name),
new JProperty("operation", context.Operation.Name),
new JProperty("user", context.User.Email),
new JProperty("ip", context.Request.IpAddress)
).ToString();
}
</log-to-eventhub>
</inbound>
<backend>
<forward-request />
</backend>
<outbound>
<!-- Response transformation -->
<set-header name="X-Powered-By" exists-action="delete" />
</outbound>
<on-error>
<base />
</on-error>
</policies>
```
### Workflow as API Pattern
- **Implement Workflow as API pattern**:
- Design Logic Apps specifically as API backends
- Use request triggers with OpenAPI schemas
- Apply consistent response patterns
- Implement proper status codes and error handling
```json
"triggers": {
"manual": {
"type": "Request",
"kind": "Http",
"inputs": {
"schema": {
"$schema": "http://json-schema.org/draft-04/schema#",
"type": "object",
"properties": {
"customerId": {
"type": "string",
"description": "The unique identifier for the customer"
},
"requestType": {
"type": "string",
"enum": ["Profile", "OrderSummary"],
"description": "The type of request to process"
}
},
"required": ["customerId", "requestType"]
},
"method": "POST"
}
}
}
```
## Versioning Strategies
Implement robust versioning approaches for Logic Apps and Power Automate flows:
### Versioning Patterns
1. **URI Path Versioning**:
- Include version in HTTP trigger path (/api/v1/resource)
- Maintain separate Logic Apps for each major version
2. **Parameter Versioning**:
- Add version parameter to workflow definitions
- Use conditional logic based on version parameter
3. **Side-by-Side Versioning**:
- Deploy new versions alongside existing ones
- Implement traffic routing between versions
### Version Migration Strategy
```json
"actions": {
"Check_Request_Version": {
"type": "Switch",
"expression": "@triggerBody()?['apiVersion']",
"cases": {
"1.0": {
"actions": {
"Process_V1_Format": {
"type": "Scope",
"actions": { }
}
}
},
"2.0": {
"actions": {
"Process_V2_Format": {
"type": "Scope",
"actions": { }
}
}
}
},
"default": {
"actions": {
"Return_Version_Error": {
"type": "Response",
"kind": "Http",
"inputs": {
"statusCode": 400,
"body": {
"error": "Unsupported API version",
"supportedVersions": ["1.0", "2.0"]
}
}
}
}
}
}
}
```
### ARM Template Deployment for Different Versions
```json
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"logicAppName": {
"type": "string",
"metadata": {
"description": "Base name of the Logic App"
}
},
"version": {
"type": "string",
"metadata": {
"description": "Version of the Logic App to deploy"
},
"allowedValues": ["v1", "v2", "v3"]
}
},
"variables": {
"fullLogicAppName": "[concat(parameters('logicAppName'), '-', parameters('version'))]",
"workflowDefinitionMap": {
"v1": "[variables('v1Definition')]",
"v2": "[variables('v2Definition')]",
"v3": "[variables('v3Definition')]"
},
"v1Definition": {},
"v2Definition": {},
"v3Definition": {}
},
"resources": [
{
"type": "Microsoft.Logic/workflows",
"apiVersion": "2019-05-01",
"name": "[variables('fullLogicAppName')]",
"location": "[resourceGroup().location]",
"properties": {
"definition": "[variables('workflowDefinitionMap')[parameters('version')]]"
}
}
]
}
```
## Cost Optimization Techniques
Implement strategies to optimize the cost of Logic Apps and Power Automate solutions:
### Logic Apps Consumption Optimization
1. **Trigger Optimization**:
- Use batching in triggers to process multiple items in a single run
- Implement proper recurrence intervals (avoid over-polling)
- Use webhook-based triggers instead of polling triggers
2. **Action Optimization**:
- Reduce action count by combining related operations
- Use built-in functions instead of custom actions
- Implement proper concurrency settings for foreach loops
3. **Data Transfer Optimization**:
- Minimize payload sizes in HTTP requests/responses
- Use local file operations instead of repeated API calls
- Implement data compression for large payloads
### Logic Apps Standard (Workflow) Cost Optimization
1. **App Service Plan Selection**:
- Right-size App Service Plans for workload requirements
- Implement auto-scaling based on load patterns
- Consider reserved instances for predictable workloads
2. **Resource Sharing**:
- Consolidate workflows in shared App Service Plans
- Implement shared connections and integration resources
- Use integration accounts efficiently
### Power Automate Licensing Optimization
1. **License Type Selection**:
- Choose appropriate license types based on workflow complexity
- Implement proper user assignment for per-user plans
- Consider premium connectors usage requirements
2. **API Call Reduction**:
- Cache frequently accessed data
- Implement batch processing for multiple records
- Reduce trigger frequency for scheduled flows
### Cost Monitoring and Governance
```json
"Monitor_Execution_Costs": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['loganalytics']['connectionId']"
}
},
"method": "post",
"body": {
"LogType": "WorkflowCostMetrics",
"WorkflowName": "@{workflow().name}",
"ExecutionId": "@{workflow().run.id}",
"ActionCount": "@{length(workflow().run.actions)}",
"TriggerType": "@{workflow().triggers[0].kind}",
"DataProcessedBytes": "@{workflow().run.transferred}",
"ExecutionDurationSeconds": "@{div(workflow().run.duration, 'PT1S')}",
"Timestamp": "@{utcNow()}"
}
},
"runAfter": {
"Main_Workflow_Actions": ["Succeeded", "Failed", "TimedOut"]
}
}
```
## Enhanced Security Practices
Implement comprehensive security measures for Logic Apps and Power Automate workflows:
### Sensitive Data Handling
1. **Data Classification and Protection**:
- Identify and classify sensitive data in workflows
- Implement masking for sensitive data in logs and monitoring
- Apply encryption for data at rest and in transit
2. **Secure Parameter Handling**:
- Use Azure Key Vault for all secrets and credentials
- Implement dynamic parameter resolution at runtime
- Apply parameter encryption for sensitive values
```json
"actions": {
"Get_Database_Credentials": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['keyvault']['connectionId']"
}
},
"method": "get",
"path": "/secrets/@{encodeURIComponent('database-connection-string')}/value"
}
},
"Execute_Database_Query": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['sql']['connectionId']"
}
},
"method": "post",
"path": "/datasets/default/query",
"body": {
"query": "SELECT * FROM Customers WHERE CustomerId = @CustomerId",
"parameters": {
"CustomerId": "@triggerBody()?['customerId']"
},
"connectionString": "@body('Get_Database_Credentials')?['value']"
}
},
"runAfter": {
"Get_Database_Credentials": ["Succeeded"]
}
}
}
```
### Advanced Identity and Access Controls
1. **Fine-grained Access Control**:
- Implement custom roles for Logic Apps management
- Apply principle of least privilege for connections
- Use managed identities for all Azure service access
2. **Access Reviews and Governance**:
- Implement regular access reviews for Logic Apps resources
- Apply Just-In-Time access for administrative operations
- Audit all access and configuration changes
3. **Network Security**:
- Implement network isolation using private endpoints
- Apply IP restrictions for trigger endpoints
- Use Virtual Network integration for Logic Apps Standard
```json
{
"resources": [
{
"type": "Microsoft.Logic/workflows",
"apiVersion": "2019-05-01",
"name": "[parameters('logicAppName')]",
"location": "[parameters('location')]",
"identity": {
"type": "SystemAssigned"
},
"properties": {
"accessControl": {
"triggers": {
"allowedCallerIpAddresses": [
{
"addressRange": "13.91.0.0/16"
},
{
"addressRange": "40.112.0.0/13"
}
]
},
"contents": {
"allowedCallerIpAddresses": [
{
"addressRange": "13.91.0.0/16"
},
{
"addressRange": "40.112.0.0/13"
}
]
},
"actions": {
"allowedCallerIpAddresses": [
{
"addressRange": "13.91.0.0/16"
},
{
"addressRange": "40.112.0.0/13"
}
]
}
},
"definition": {}
}
}
]
}
```
## Additional Resources
- [Azure Logic Apps Documentation](https://docs.microsoft.com/en-us/azure/logic-apps/)
- [Power Automate Documentation](https://docs.microsoft.com/en-us/power-automate/)
- [Workflow Definition Language Schema](https://docs.microsoft.com/en-us/azure/logic-apps/logic-apps-workflow-definition-language)
- [Power Automate vs Logic Apps Comparison](https://docs.microsoft.com/en-us/azure/azure-functions/functions-compare-logic-apps-ms-flow-webjobs)
- [Enterprise Integration Patterns](https://docs.microsoft.com/en-us/azure/logic-apps/enterprise-integration-overview)
- [Logic Apps B2B Documentation](https://docs.microsoft.com/en-us/azure/logic-apps/logic-apps-enterprise-integration-b2b)
- [Azure Logic Apps Limits and Configuration](https://docs.microsoft.com/en-us/azure/logic-apps/logic-apps-limits-and-config)
- [Logic Apps Performance Optimization](https://docs.microsoft.com/en-us/azure/logic-apps/logic-apps-performance-optimization)
- [Logic Apps Security Overview](https://docs.microsoft.com/en-us/azure/logic-apps/logic-apps-securing-a-logic-app)
- [API Management and Logic Apps Integration](https://docs.microsoft.com/en-us/azure/api-management/api-management-create-api-logic-app)
- [Logic Apps Standard Networking](https://docs.microsoft.com/en-us/azure/logic-apps/connect-virtual-network-vnet-isolated-environment)
💡 Suggested Test Inputs
Loading suggested inputs...
🎯 Community Test Results
Loading results...
📦 Package Info
- Format
- copilot
- Type
- rule
- Category
- development
- License
- MIT