Create cross-environment parameters in Azure Logic Apps workflow

Azure Logic Apps Create cross-environment parameters in Azure Logic Apps workflow

In Azure Logic Apps, cross-environment parameters allow you to define reusable inputs (e.g., connection strings, URLs, or configuration values) that can be shared across multiple workflows or environments (e.g., development, staging, production). This is particularly useful for managing environment-specific configurations without hardcoding values into your workflows.

To achieve this, you can use Azure Key Vault or Logic App parameters in combination with Azure Resource Manager (ARM) templates. Below is a step-by-step guide to creating and using cross-environment parameters in Azure Logic Apps.

Step 1: Define Parameters in an ARM Template

ARM templates allow you to define parameters that can be passed to your Logic App during deployment. These parameters can be environment-specific.

Create an ARM template for your Logic App. For example:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "logicAppName": {
      "type": "string",
      "defaultValue": "MyLogicApp"
    },
    "environmentSetting": {
      "type": "string",
      "allowedValues": ["dev", "staging", "prod"],
      "defaultValue": "dev"
    },
    "apiUrl": {
      "type": "string"
    }
  },
  "resources": [
    {
      "type": "Microsoft.Logic/workflows",
      "apiVersion": "2017-07-01",
      "name": "[parameters('logicAppName')]",
      "location": "[resourceGroup().location]",
      "properties": {
        "definition": {
          "$schema": "https://schema.management.azure.com/schemas/2016-06-01/Microsoft.Logic.json",
          "contentVersion": "1.0.0.0",
          "parameters": {
            "apiUrl": {
              "type": "string",
              "defaultValue": "[parameters('apiUrl')]"
            }
          },
          "triggers": {},
          "actions": {},
          "outputs": {}
        },
        "parameters": {
          "apiUrl": {
            "value": "[parameters('apiUrl')]"
          }
        }
      }
    }
  ]
}

In this template:
- environmentSetting is a parameter to specify the environment (e.g., dev, staging, prod).
- apiUrl is a parameter that can be passed to the Logic App.

Step 2: Use Azure Key Vault for Secure Parameter Storage

Azure Key Vault is a secure way to store and retrieve sensitive parameters (e.g., connection strings, API keys).

Create an Azure Key Vault and store your environment-specific values as secrets.
- Example: Store apiUrl as a secret for each environment (e.g., dev-apiUrl, staging-apiUrl, prod-apiUrl).
Grant your Logic App access to the Key Vault:
- Go to the Key Vault in the Azure portal.
- Under Access policies, add your Logic App’s managed identity and grant it Get permission for secrets.
Retrieve the secret in your Logic App:
- Use the Azure Key Vault connector to fetch the secret.
- Example: Use the Get Secret action to retrieve the apiUrl for the current environment.

Step 3: Deploy the Logic App with Environment-Specific Parameters

Create separate parameter files for each environment (e.g., dev-parameters.json, staging-parameters.json, prod-parameters.json).

Example dev-parameters.json:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "environmentSetting": {
      "value": "dev"
    },
    "apiUrl": {
      "value": "https://dev-api.example.com"
    }
  }
}

Deploy the Logic App using the ARM template and parameter file:

Use Azure CLI or PowerShell to deploy the template.

Example using Azure CLI:

az deployment group create \
  --resource-group <ResourceGroupName> \
  --template-file <TemplateFile.json> \
  --parameters <ParameterFile.json>

Step 4: Use Parameters in the Logic App

In your Logic App, reference the parameters defined in the ARM template.

Example: Use the apiUrl parameter in an HTTP action:

{
  "type": "Http",
  "inputs": {
    "method": "GET",
    "uri": "@{parameters('apiUrl')}/endpoint"
  }
}

If using Azure Key Vault, retrieve the secret dynamically in the workflow:
- Add a Get Secret action from the Azure Key Vault connector.
- Use the secret value in subsequent actions.

Step 5: Test the Workflow

Deploy the Logic App to each environment (dev, staging, prod) using the corresponding parameter file.
Test the workflow to ensure it uses the correct environment-specific parameters.

Benefits of Cross-Environment Parameters

Reusability: Use the same Logic App definition across multiple environments.
Security: Store sensitive values securely in Azure Key Vault.
Maintainability: Easily update environment-specific configurations without modifying the Logic App.

Previous Lesson

Back to Course

Next Lesson

Azure Logic Apps