Announcing the new solution import experience with connections and environment variables

Casey Burke, Senior Program Manager, Selasa, 15 September 2020

Today we’re excited to announce a broad set of new ALM capabilities for importing solutions. In addition to these modern new interfaces, now you can establish connections as well as set values for environment variables while importing solutions. We’re also excited to announce that environment variables are now generally available. Together, these features address some of the largest application lifecycle management problems facing the Power Platform.

Key benefits over classic

Provide different values for Environment variables, which are used as input parameters to various other components and are likely to change between environments.
Connections can now be set. They’re set once during the initial solution import and no longer require editing Canvas apps and Flows after importing a solution.
- When upgrading your solutions, connections set during previous imports do not need to be re-established.
- This also helps prevent creation of an unmanaged (active) row on a component. For context, an active row would make it difficult to service and update the component via the underlying managed solution layers as they would would be hidden by the active layer.
Flows get activated and both apps and Flows are using the intended connections.
If you need to change the connection being used in apps and flows, you can edit it once by updating the connection associated with the connection reference. All apps and flows bound to that connection reference will then be leveraging the new connection.
Maintain connection separation when using multiple connections of same type.
- For example, if your app uses 3 different SQL Server connections you can now disambiguate these during import as opposed to editing the app post import.
Specify your own names and descriptions for connection references. This will be visible within the solution interfaces as well as in source control and helps identify different uses for connections of the same type.
Import now runs asynchronously, freeing your time to complete other tasks.
Supports custom connector connections.

Key concepts

Connection references

Connection references are a new solution component that add a layer of abstraction between the connection and component leveraging the connection. Because connections are unique per environment, connection references ensure that connections can participate in ALM by removing hard-coded identifiers within components and allowing new connections to be associated as you migrate solutions across environments.

Now canvas apps & operations within Flows bind to connection references – in contrast to binding to connections directly.
- Canvas apps and Flows handle connections differently. Flows now use connection references for ALL types of connections, whereas canvas apps only use them for implicitly shared connections such as SQL Server.
Connection instance identifiers are not exported as they’re guaranteed to change across environments. Instead, connection references are exported and new connections can be associated within the new solution import experience, the modern solution interface, or programmatically via Common data service API’s.
Maps 1 instance of a connection to N actions in N apps and Flows (allows for reuse).
To change a specific connection associated with an app or Flow, you can do so within the solution by editing the connection reference. You no longer need to edit the app or Flow directly.
Connection references will automatically be created when creating new connections from Flow and canvas app designers.
- You may also create them directly from a solution and use them in your Flows. Choose this option if you’d like to provide your own name and descriptions.
Dependencies are logged between apps and flows and the connection reference(s) they depend on. Be sure to include both the apps/flows as well as their associated connection references in your solution before exporting.
Connection references can only be used for apps and Flows that are in a solution.
- When adding pre-existing connections to canvas apps, a connection reference will not be associated with the app unless the connection is associated with a connection reference.

For more information on using connection references in Power Automate, check out this post.

Solution import

Modern, accessible user interface.
Allows associating connections with connection references (and ultimately the apps and Flows that use them) during import.
- Connections do not get exported, only connection references.
- You will only be prompted the first time a solution is imported – unless new connection references are included your solution upgrade.
Allows setting environment variable values during import.
- Sets the ‘value’ property on the environmentvariablevalue entity.
- You will not be prompted if the environment variables already have either a default value or value present – whether values are part of your solution or are already present in CDS.

What’s preview vs GA?

This blog covers a series of features that work together in unison. However, features each have they’re own lifecycle and maturity dates.

Solution import should be considered generally available. It is an existing product capability with a new interface and additional enhancements.
Environment variables are generally available.
Connection references as well as their usage in Canvas apps and Flows are in preview.

What’s next

While we’re very excited about these new features, there are things we’re still improving upon.

Existing apps and flows will not automatically be upgraded to use connection references. However, today you may do the following:
1. For canvas apps, remove the data sources from your app, then add them back and re-publish the app. Note the connection(s) must already have associated connection reference(s). You can either delete the connections and re-create them or create a new connection reference within the solution and associate the existing connection.
2. For flows, export the unmanaged solution that has flows with connections set up. Re-import the exported solution on the same environment. This will clean up the connections on flows. Now edit the flows and set connection references on every action or reuse the ones created from solution explorer and Save the flows. These flows have been now set to use connection references.
The connection name and connection reference name are not currently synchronized. They can be different. Therefore it’s best to keep the naming conventions the same. Don’t set different names for connections and their associated connection references.
1. The flow designer will display the connection reference name.
2. The canvas app designer will display the connection name.
Environment variables of type “data source” will soon be available. While environment variables can often be used today in canvas apps and flows, these improvements will include an intuitive experience for changing input parameters specific to a connector. For example, changing the “Site” and “List” parameters for SharePoint connections as you migrate solutions across environments.
1. In addition to supporting data sources, new API’s will be available to simplify interacting with environment variables programmatically.
Power Platform build tools for Azure DevOps will soon be extended to support the above features.
Soon you’ll be able to see component level dependencies for solution import failures. Currently, you will only see solution level dependencies.
1. If you see an error stating there’s a missing dependency on “Active”, this means components included in your solution have unmanaged dependencies on other component(s) from your source environment that were not included in the solution and they’re not already present in the target environment (“Active” refers to the active or unmanaged layer).
2. To fix dependency issues, go back to your source environment and add the dependencies to your solution and export it again. You can view dependencies at the component level by selecting a component and clicking “Show dependencies”.