Azure Logic Apps for Developers

Azure Logic Apps is a cloud-based platform for creating and running automated workflows that integrate apps, data, services, and systems. It is part of the Azure Integration Services portfolio alongside API Management, Service Bus, and Event Grid. Logic Apps is designed for developers and IT professionals who need to build complex integrations without writing extensive code. It provides a visual designer and hundreds of prebuilt connectors for common services like Office 365, Salesforce, SQL Server, and Azure Blob Storage. The core value proposition is reducing development time for integrations that would otherwise require custom code, while providing enterprise-grade reliability, scaling, and monitoring.

From an exam perspective, you should know that Logic Apps is a serverless offering — you don't manage infrastructure. It scales automatically and you pay per execution. There are two execution models: Consumption (pay-per-action) and Standard (fixed pricing with dedicated resources). The AZ-204 exam focuses primarily on Consumption plans, but you should be aware of Standard for scenarios requiring VNet integration or custom connectors.

A Logic App is defined by a workflow — a series of steps (actions) that execute in a defined order. Each workflow is triggered by an event (trigger) and processes data through actions. The workflow definition is stored as JSON in the Azure Resource Manager, following the Workflow Definition Language schema. When a trigger fires, the Logic Apps runtime creates a run instance for each event. The runtime orchestrates execution, handling state, retries, and concurrency.

Here's the step-by-step internal flow:

- Triggers: - Recurrence: Default interval = 1 hour. Minimum interval = 1 second (but not recommended). Frequency: Second, Minute, Hour, Day, Week, Month. - HTTP Request: Generates a callback URL. Default timeout for waiting for trigger payload = 1 minute (configurable up to 1 hour). - Service Bus Queue: Polling interval default = 30 seconds. Max message count = 10 per poll. - Blob Storage: Polling interval default = 30 seconds. Triggers on new or modified blobs. - Actions: - HTTP Action: Default timeout = 2 minutes (Consumption), 5 minutes (Standard). Max timeout = 2 minutes for Consumption, 5 for Standard (configurable up to 30 minutes with async pattern). - Response Action: Required for synchronous HTTP triggers. Must complete within 120 seconds (Consumption) or 5 minutes (Standard). - Connectors: There are over 450 connectors. Connectors are either Standard (Microsoft-managed, included) or Enterprise (premium, additional cost). Custom connectors can be created for REST APIs. - Limits (Consumption):

To create a Logic App in Azure Portal: 1. Navigate to 'Create a resource' > Integration > Logic App. 2. Select Consumption or Standard plan. 3. Provide resource group, name, region. 4. After creation, open Logic Apps Designer to build workflow.

To deploy via ARM template, you define a resource of type Microsoft.Logic/workflows with a definition property containing the workflow JSON.

To verify a Logic App's health:

CLI commands (Azure CLI):

# List Logic Apps in a resource group
az logic workflow list --resource-group myRG --output table

# Trigger a Logic App
az logic workflow trigger --resource-group myRG --name myLogicApp --trigger-name manual

# Show run history
az logic workflow run list --resource-group myRG --name myLogicApp

# Show run details
az logic workflow run show --resource-group myRG --name myLogicApp --run-id <runId>

{
    "definition": {
        "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
        "actions": {
            "HTTP": {
                "type": "Http",
                "inputs": {
                    "method": "GET",
                    "uri": "https://api.example.com/data"
                },
                "runAfter": {}
            }
        },
        "triggers": {
            "Recurrence": {
                "type": "Recurrence",
                "recurrence": {
                    "frequency": "Hour",
                    "interval": 1
                }
            }
        }
    }
}

A large e-commerce company uses Logic Apps to automate order processing. When a customer places an order, the e-commerce platform sends an HTTP request to a Logic App with order details. The Logic App first validates the order (check inventory via a SQL Server connector), then creates a record in a Dynamics 365 CRM, sends a confirmation email via Office 365, and finally posts a message to a Service Bus queue for fulfillment. This replaces a custom .NET service that was brittle and hard to maintain. In production, the Logic App processes 10,000 orders per day. Key considerations: The HTTP trigger must respond within 120 seconds (Consumption) to avoid timeout. The SQL Server connector uses a connection string stored in Key Vault. The Logic App is deployed using ARM templates with parameters for environment-specific endpoints. Common issues: The SQL connector throttles during peak hours (max 100 concurrent connections). Solution: Increase concurrency and use retry policies. Another issue: The Office 365 connector has a limit of 30 requests per minute per user; if exceeded, messages queue up and cause delays. Mitigation: Use a dedicated service account and implement a 'For each' loop with concurrency of 10.

A healthcare provider integrates patient data from multiple sources using Logic Apps. A Logic App triggers on new blobs in Azure Blob Storage (HL7 messages). It parses the message (using custom JavaScript via Azure Functions), transforms it (using Liquid templates), and writes to a FHIR server. The workflow also sends alerts to a Slack channel if validation fails. Deployed in a Standard plan to enable VNet integration (FHIR server is inside a VNet). Scale: Processes 500 messages per hour. Performance: Blob trigger polling interval set to 10 seconds (minimum). Chunking enabled for large files (>1 MB). Error handling: If FHIR server is unavailable, the Logic App retries 5 times with exponential backoff; after that, the message is moved to a poison queue (Service Bus). Monitoring: Application Insights tracks custom events for each message. Cost: Standard plan costs more per month but avoids per-action charges.