Create parameters to use in workflows across environments in single-tenant Azure Logic Apps

In Azure Logic Apps, you can abstract values that might change in your workflows across your development, test, and production environments by defining parameters. When you use parameters instead, you can focus more on designing your workflows, and insert your environment-specific variables later.

This article introduces how parameters work in single-tenant Azure Logic Apps and how to edit, reference, and manage environment variables using the single-tenant parameters experience.

Parameters in single-tenant versus multi-tenant

If you've worked with multi-tenant Azure Logic Apps, you might already be familiar with parameters. Parameterizing your workflow inputs in single-tenant Azure Logic Apps works similarly to multi-tenant Azure Logic Apps but with a major difference.

For example, in both the single-tenant and multi-tenant service, you can define parameters when you're working in workflow designer. After you define the parameter, you can reference that parameter from any workflow or connection that's in the same logic app resource. However, in the multi-tenant service, after you create and use parameters in the designer, you define and set the environment variables in your Azure Resource Manager template (ARM template) and template parameters files. In this scenario, you have to define and set the parameters at deployment, which means that even if you only have to change one variable, you have to redeploy your logic app's ARM template.

By comparison, with the single-tenant service, you can work with environment variables both at runtime and deployment by using parameters and app settings. In single-tenant Azure Logic Apps, app settings contain global configuration options for all the workflows in the same logic app. For more information, review Edit host and app settings for single-tenant based logic apps.

For example, you can use app settings to integrate with Azure Key Vault and directly reference secure strings, such as connection strings and keys. Similar to ARM templates, where you can define environment variables at deployment time, you can define app settings within your logic app workflow definition. You can then capture dynamically generated infrastructure values, such as connection endpoints, storage strings, and more.

However, app settings have size limits and can't be referenced from certain areas in Azure Logic Apps. Parameters offers a wider range of use cases than app settings, such as support for large value sizes and complex objects.

For example, if you use Visual Studio Code as your local development tool to run workflows locally, in your logic app project, you can define parameters using the parameters.json file. You can then reference any parameter in this parameters file from any workflow in your project's workflow.json file or from any connection object in your project's connections.json file. The following list describes a couple common use cases:

• Have a test parameters file that includes all the values that you use during testing. At deployment, you can replace your test parameters file with your production parameters file.

• Parameterize different parts of your connections.json file. You can then check your connections.json file into source control, and then manage any connections through your parameters.json file.

• Parameterize complex objects, such as the authentication JSON object. For example, you can replace the authentication object value with a string that holds a single parameters expression, such as @parameters('api-auth').

• Review and edit the app settings in your project's local.settings.json file. You can then reference these app settings in your parameters.

Prerequisites

• An Azure account and subscription. If you don't have a subscription, sign up for a trial Azure subscription.

• A logic app workflow hosted in single-tenant Azure Logic Apps.

  If you don't have a logic app, create your logic app (Standard) in the Azure portal or in Visual Studio Code.

Define, use, and edit parameters

Azure portal

1. In the Azure portal, open your single-tenant based logic app. Under Workflows, select and open your workflow in the designer.

2. From the designer toolbar, select Parameters.

   

3. On the Parameters pane, select Create parameter.

4. Provide the following information about the parameter to create:

   Property	Required	Description
   Name	Yes	The name for the parameter to create.
   Type	Yes	The data type for the parameter, such as Array, Bool, Float, Int, Object, and String. Note: In single-tenant based workflows, secure data types, such as securestring and secureobject aren't supported.
   Value	Yes	The value for the parameter. In single-tenant Azure Logic Apps, you have to specify the parameter value because the the workflow logic, connection information, and parameter values don't exist in a single location. The designer must be able to resolve parameter value before loading.

   The following example shows a definition for a string parameter:

   

5. When you're done, close the Parameters pane, but make sure to save your workflow to save your new parameter definition.

6. To reference the parameter from a trigger or action that's in any workflow within the same logic app, follow these steps:

   1. In the designer, open the workflow that you want, and expand the trigger or action.

   2. In the property where you want to use the parameter, click inside that property's edit box.

   3. From the dynamic content list that opens, under Parameters, select you previously created parameter, for example:

      

7. To view or edit parameters in the same logic app, follow either step:

   • Open any workflow in that logic app. On the workflow menu, select Designer. On the designer toolbar, select Parameters.

     The Parameters pane opens and displays all the parameters that you defined from workflows in that logic app.

   • To view or edit in bulk JSON, on your logic app's main menu, select Parameters.

     The Parameters JSON view opens and displays all the parameters that you defined from workflows in that logic app.

Visual Studio Code

1. In a project root-level JSON file named parameters.json, define all the parameters and their values. This file has an object that includes key-value pairs. Each key is the name for each parameter, while each value is the structure for each parameter. Each structure needs to include both a type and value declaration.

   Important

   Your parameters.json file must define and include all the parameters and their values that you reference or use elsewhere in your project, for example, in workflow definitions or connections.

   The following example shows a basic parameters file:

   {
       "responseString": { 
           "type": "string", 
           "value": "hello" 
       },
       "functionAuth": { 
           "type": "object", 
           "value": { 
               "type": "QueryString", 
               "name": "Code", 
               "value": "@appsetting('<AzureFunctionsOperation-FunctionAppKey>')" 
           }
       }
   }
   

   Note

   In the parameters.json file, @appsetting is the only valid expression type.

2. To reference parameters in your trigger or action inputs, use the expression @parameters('<parameter-name>').

Parameterize connections file

To parameterize your connections.json file, replace the values for literals, such as ConnectionRuntimeUrl, with a single parameters() expression, for example, @parameters('api-runtimeUrl'). In the connections.json file, the only valid expression types are @parameters and @appsetting.

The following example shows a parameterized connections.json file that uses both app settings and parameters. Although you want to use parameters where possible, this scenario is an exception or edge case where you'd use app settings over parameters because app settings are generated during deployment and are easier to dynamically populate in a development pipeline. This sample file uses a parameter for the complex blob_auth authentication object and app settings for the other values. In this case, you can use a parameter for the authentication object as you're unlikely to reference the parameter in your workflow:

{
   "serviceProviderConnections": {
      "serviceBus": {
         "parameterValues": {
            "connectionString": "@appsetting('serviceBus_connectionString')"
        },
        "serviceProvider": {
           "id": "/serviceProviders/serviceBus"
        },
        "displayName": "servicebus"
     }
   },
   "managedApiConnections": {
      "azureblob": {
         "api": {
            "id": "/subscriptions/@{appsetting('WORKFLOWS_SUBSCRIPTION_ID')}/providers/Microsoft.Web/locations/@{appsetting('WORKFLOWS_LOCATION_NAME')}/managedApis/azureblob"
         },
         "connection": {
            "id": "/subscriptions/@{appsetting('WORKFLOWS_SUBSCRIPTION_ID')}/resourceGroups/@{appsetting('WORKFLOWS_RESOURCE_GROUP_NAME')}/providers/Microsoft.Web/connections/azureblob"
         },
         "connectionRuntimeUrl": "@appsetting('BLOB_CONNECTION_RUNTIMEURL')",
         "authentication": "@parameters('blob_auth')"
      }
   }
}

Manage parameters files

Typically, you need to manage multiple versions of parameters files. You might have targeted values for different deployment environments, such as development, testing, and production. Managing these parameters files often works like managing ARM template parameters files. When you deploy to a specific environment, you promote the corresponding parameters file, generally through a pipeline for DevOps.

To dynamically replace parameters files using the Azure CLI, run the following command:

az functionapp deploy --resource-group MyResourceGroup --name MyLogicApp --src-path C:\parameters.json --type static --target-path parameters.json

If you have a NuGet-based logic app project, you have to update your project file (<logic-app-name>.csproj) to include the parameters file in the build output, for example:

<ItemGroup>
  <None Update="parameters.json">
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
  </None>
</ItemGroup>

For more information about setting up your logic apps for DevOps deployments, review the following documentation:

• DevOps deployment overview for single-tenant based logic apps
• Set up DevOps deployment for single-tenant based logic apps

Manage app settings

In single-tenant Azure Logic Apps, app settings contain global configuration options for all the workflows in the same logic app. When you run workflows locally in Visual Studio Code, you can access these app settings as local environment variables in the local.settings.json file. You can then reference these app settings in your parameters.

To add, update, or delete app settings, select and review the following sections for Visual Studio Code, Azure portal, Azure CLI, or ARM (Bicep) template.

az logicapp config appsettings list --name MyLogicApp --resource-group MyResourceGroup

az logicapp config appsettings set --name MyLogicApp --resource-group MyResourceGroup --settings CUSTOM_LOGIC_APP_SETTING=12345 

"appSettings": [
    {
        "name": "string",
        "value": "string"
    },
    {
        "name": "string",
        "value": "string"
    },
    <...>
], 

Next steps