Azure

Dataverse / Dynamics 365 : Azure Managed Identities from Plugins. Step by Step.

julien.biedermann — Thu, 17 Jul 2025 12:47:18 +0000

Dataverse / Dynamics 365 : Azure Managed Identities from Plugins. Step by Step. julien.biedermann Thu, 07/17/2025 - 14:47

Body

Introduction

The days of storing Client ID and secret of your Key Vault in Dynamics are coming to an end. With Power Platform Managed Identity, Dataverse plug-ins can now connect to Azure resources that support managed identity without the need for credentials. Please note that at the time of writing this article, this feature is still in preview and is not intended for production use.

This marks a significant improvement in security and access management, eliminating the risks associated with storing credentials while simplifying integration between Dataverse and Azure. In this article, we’ll explore how this feature works and the process for implementing it.

How to implement it

Microsoft’s documentation is missing some details that can make the configuration process challenging. In this article, I’ll provide a clear, step-by-step guide with practical examples to help you set everything up quickly and efficiently. My goal is to simplify the process and ensure you have a smooth experience getting it to work.

Step 1 : Create a new app registration or user-assigned managed identity

Create new "User Assigned Managed Identity". You can follow this documentation to create it.

Copy and save the "Client ID" value of your managed identity to be used in step 6

Step 2 : Create Key Vault

Create a key vault
Create a secret with name "DynamicsChroniclesSecret" and with secret value = "Managed identity for Power Platform is working"
In "Access control (IAM)" of your key vault, add the role assignment "Key Vault Secrets User" to the User Assigned Managed Identity created in step 1

Step 3 : Create a certificate

Open Powershell to create a certificate using this script

# Generate a self-signed certificate
$cert = New-SelfSignedCertificate -Subject "CN=dynamicschronicles, O=corp, C=dynamicschronicles.ch" -DnsName "www.dynamicschronicles.ch" -Type CodeSigning -KeyUsage DigitalSignature -CertStoreLocation Cert:\CurrentUser\My -FriendlyName "dynamicschronicles"
# Set a password for the private key
$pw = ConvertTo-SecureString -String "complexpwd12345" -Force -AsPlainText
# Export the certificate as a PFX file
Export-PfxCertificate -Cert $cert -FilePath 'C:\temp\dynamicschronicles_certificate.pfx' -Password $pw
Write-Host "Self-signed certificate exported as C:\temp\dynamicschronicles_certificate.pfx."
# Display thumbprint
$cert.Thumbprint

Copy and save the "Thumbprint" value to be used in step 5

Step 4 : Create a plug-in assembly, sign it and register it

Create a new plug-in using Visual Studio. Here is an example of code :

using Microsoft.Xrm.Sdk;
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;

namespace ManagedPlugin
{
    public class ManagedPlugin : IPlugin
    {
        public void Execute(IServiceProvider serviceProvider)
        {
            // Obtain the tracing service
            ITracingService tracingService =
            (ITracingService)serviceProvider.GetService(typeof(ITracingService));

            // Obtain the execution context from the service provider.  
            IManagedIdentityService managedIdentityService = (IManagedIdentityService)
                serviceProvider.GetService(typeof(IManagedIdentityService));

            // Obtain the execution context from the service provider.  
            IPluginExecutionContext context = (IPluginExecutionContext)
                serviceProvider.GetService(typeof(IPluginExecutionContext));
            
            // Initialize empty token
            string token = string.Empty;
            string[] scopes = new string[] { "https://YOUR-DYNAMICS-ORG-URL.crm4.dynamics.com/.default" };

            try
            {
                tracingService.Trace("Scopes in GetAccessTokenManagedIdentity: " + string.Join(", ", scopes));
                token = managedIdentityService.AcquireToken(scopes);
                tracingService.Trace($"MANAGED IDENTITY TOKEN : {token}");
            }
            catch (Exception ex)
            {
                tracingService.Trace($"Failed to acquire token {ex.Message}");
            }

            var keyvaultname = "YOUR-KEYVAULT-NAME";
            var secretname = "DynamicsChroniclesSecret";

            // Get Token
            var kv_scopes = new List<string> { "https://vault.azure.net/.default" };
            var kv_token = managedIdentityService.AcquireToken(kv_scopes);
            tracingService.Trace($"KV TOKEN : {kv_token}");

            var keyvaultsecretUrl = $"https://{keyvaultname}.vault.azure.net/secrets/{secretname}?api-version=7.4";

            try
            {
                using (HttpClient client = new HttpClient())
                {
                    client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", kv_token);
                    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

                    var request = new HttpRequestMessage(HttpMethod.Get, new Uri(keyvaultsecretUrl));
                    var response = client.SendAsync(request).Result;

                    string json = response.Content.ReadAsStringAsync().Result;

                    var keyVaultResponse = System.Text.Json.JsonSerializer.Deserialize<KeyVaultResponse>(json);

                    tracingService.Trace($"KV SECRET VALUE : {keyVaultResponse.value}");

                }
            }
            catch (Exception ex)
            {
                tracingService.Trace($"Failed to acquire token {ex.Message}");
            }

        }

    }
}
public class KeyVaultResponse
{
    public string value { get; set; }
    public string id { get; set; }

}

Replace the following values with yours
1. Line 27 => "https://YOUR-DYNAMICS-ORG-URL.crm4.dynamics.com/.default"
2. Line 40 => "YOUR-KEYVAULT-NAME" (name of the key vault created in step 2)
Build the plugin
Sign the plugin using signtool and the following Powershell command

.\signtool sign /f "C:\temp\dynamicschronicles_certificate.pfx" /p "complexpwd12345"  "C:\Path_to_your_plugin\bin\Debug\ManagedPlugin.dll"

Step 5 : Configure federated identity credentials

Open the User Assigned Managed Identity created in step 1
Navigate to "Settings/Federated credentials" and click on "Add Credential"

Select "Other" for "Federated credential scenario"
Set "Issuer" = https://[Dynamics environment ID prefix].[Dynamics environment ID suffix].environment.api.powerplatform.com/sts
1. Replace "[Dynamics Environment ID prefix]" with your environment ID (except the last two characters and without dashes)
2. Replace "[Dynamics Environment ID suffix]" with the two last characters of the environment ID
Set "Subject identifier" = component:pluginassembly,thumbprint:[Thumbprint],environment:[Dynamics environment ID]
1. Replace "[Thumbprint]" with Thumbprint value copied in step 2
2. Replace "[Dynamics environment ID]" with your environment ID (with dashes)
Set "Name" to whatever you want
For "Audience", you can keep the default value

Click on "Add" to create the Federated Credential

Step 6 : Create managed identity record in Dataverse

Open "XRMToolbox" and open the tool "Plugin Identity Manager" (you can also create it manually if you want, see documentation here)
Select your plugin assembly (1)
Click on "Link to New Identity"

Fill in the following information and click on "Create and Link"
1. ApplicationId = "Client ID" value of your managed identity copied in step 1
2. TenantId = Your tenant Id (Directory ID in Azure)

Verification

Good news ! You're ready to go and check if everything is working well. To do so:

Trigger your plugin. In our case, it will be the creation of an account
Open Plugin Trace Log and check the plugin execution and if the secret is correctly retrieved

Everything is working well — we are now able to connect and retrieve secrets from Key Vault without having to store or manage any credentials in Dataverse.

I hope this step-by-step guide was clear and helped you configure everything easily on your end. If that’s not the case or if any steps need further clarification, please let me know in the comments.

Image

/sites/default/files/2025-07/article.png

Managed Identities from Azure to Dataverse

joao.neto — Thu, 29 Aug 2024 12:48:14 +0000

Managed Identities from Azure to Dataverse joao.neto Thu, 08/29/2024 - 14:48

Body

Introduction

A common challenge for developers is the management of secrets, credentials, certificates, and keys used to secure communication between services

One common practice while designing and architecturing authentication for Apps in the Azure Universe is the use of a App Registration as a controlled way to securely access resources in the the Azure universe and it's been for the last years a common pattern in my designs, perhaps yours also!

And if there would be another way of securing access to the Dataverse web services without the need to manage the complexity of secrets, credentials or certificates ?

What are

Managed Indentities

Managed identities eliminate the need for developers to manage credentials

Managed identities provides automatically a managed identity in Microsoft Entra ID for applications to use when connecting to resources that support Microsoft Entra authentication.

Azure Managed Identities are a feature of Azure Active Directory (Azure AD) that allows Azure services to authenticate to other Azure services securely without storing credentials in code or configuration files. They are essentially service principals managed by Azure, providing an identity for applications to use when connecting to resources that support Azure AD authentication.

Types of Managed Identities:
System-Assigned Managed Identity: This identity is enabled directly on an Azure service instance. Azure automatically manages the lifecycle of this identity, and it's tied to the lifecycle of the service instance. When the resource is deleted, the identity is also deleted.

User-Assigned Managed Identity: Created as a standalone Azure resource, this identity can be assigned to one or more Azure service instances. It exists independently of the resources its assigned to, allowing greater flexibility and reusability.

Benefits of Using Managed Identities:

Applications can use managed identities to obtain Microsoft Entra ID tokens without having to manage any credentials and:

You don't need to manage credentials. Credentials aren’t even accessible to you.
You can use managed identities to authenticate to any resource that supports Microsoft Entra authentication, including your own applications.
Managed identities can be used at no extra cost.

How to use them

To show how to use managed identities to authenticate an Azure app managed by Azure Entra ID into other Azure Entra ID managed resource I'll use the scenario of an Azure Function that access Dataverse to create a contact.

The following diagram show us the intended scenario.

1- Create Managed Identity

Let's create a managed identity and for that I got another good news that's we don't need to have Entra ID management permissions to create a new one just collaboration on a Azure Resource.

In a resource group lets create a new managed identity:
Once created get the generated "Client ID"

2- Configure Power Apps

Go to the Power Platform admin center
Then the "Application Users" and select "New app user"
Use the "Client ID" from the previous step to find the app, because managed identities aren't displayed yet by default!
Then complete with the Business Unit (use a custom one) and the Security Roles (use a custom one).

3- Azure Function

Now its time to create our Azure Function that will authenticate in Dataverse using the managed identity!

For this purpose I've created an Azure HTTP Function in a consumption plan
Then I've used the following code to authenticate in Dataverse:

   var tokenCredential = new DefaultAzureCredential();

   var ConfigServiceDataverseURI = new Uri("https://yyyyyyy.crm4.dynamics.com");
   
   log.LogInformation("ConfigServiceDataverseURI: " + ConfigServiceDataverseURI);

   var serviceClient = new ServiceClient(ConfigServiceDataverseURI, async (string dataverseUri) =>
   {
       dataverseUri = new Uri(dataverseUri).GetComponents(UriComponents.SchemeAndServer, UriFormat.UriEscaped);
       return (await tokenCredential.GetTokenAsync(new TokenRequestContext(new[] { dataverseUri }), default)).Token;
   }, true);

And then the create account record part

try
{

    if (!serviceClient.IsReady) throw new Exception("Authentication Failed!");

    Random random = new Random();
    int randomNumber = random.Next(100000, 999999 + 1);


    log.LogInformation("randomNumber " + randomNumber);

    var registration = new Entity("contact");
    registration["firstname"] = "model.FirstName - " + randomNumber;
    registration["lastname"] = "model.LastName";

    serviceClient.Create(registration);

}
catch (Exception ex)
{

    log.LogError(ex.Message);
}

Now lets configure a User assigned Managed Identity for our Azure Function with the created Managed Identity in the step 1

And then add to the Environmental variables the "AZURE_CLIENT_ID" with the created Managed Identity client ID in the step 1

Publish you Azure Function and test it, contacts are created without any secret or certificate!

One point that needs attention is that in my example I'm using the DefaultAzureCredential that allows our code to use the credential use locally, in another words it allows to run and debug the code locally.

Either the way using the DefaultAzureCredential will have our application to search for the credentials using the following pipeline (order):

EnvironmentCredential,
ManagedIdentityCredential,
SharedTokenCacheCredential,
VisualStudioCredential,
VisualStudioCodeCredential,
AzureCliCredential,
AzurePowerShellCredential,
InteractiveBrowserCredential

Using the ManagedIdentityCredential will make our code to directly use the Managed Identity declared in our Azure resource.

Why to Use it

Azure Managed Identities provide a secure and streamlined way to authenticate Azure resources with Dataverse, eliminating the need for manual credential management.

By leveraging Managed Identities, developers can enhance security, simplify configuration, and reduce the overhead associated with traditional authentication methods

Comparison with App Registration Authentication
While both Managed Identities and App Registrations can be used for authenticating with Dataverse, there are significant differences:

Managed Identity: Credentials are automatically managed by Azure, removing the need for manual handling and reducing the risk of credential leaks.

Lifecycle and Scope

App Registration: Exists independently within Azure AD and can be used by applications running anywhere, including outside Azure.
Managed Identity: Tied to an Azure resource (system-assigned) or managed as a resource (user-assigned). Primarily intended for use within Azure.

Security

App Registration: Higher risk due to manual credential management. If credentials are compromised, it can lead to unauthorized access.
Managed Identity: Provides enhanced security by avoiding hard-coded credentials, and the credentials are not accessible to developers or users.

Complexity

App Registration: Involves more steps to set up, including creating the app registration, generating secrets or certificates, and configuring permissions.
Managed Identity: Simpler to configure, with Azure handling the creation and rotation of credentials automatically.

In summary

Azure Managed Identities offer a more secure and easy approach for authenticating Azure resources with Dataverse compared to App Registrations.

They are ideal for applications running within Azure that require secure access to other Azure resources without the overhead of managing credentials.

However, App Registrations are still very relevant for scenarios where applications run outside of Azure or require specific access scopes.

Image

/sites/default/files/2024-11/icon.png

Power Platform Dataflow Tutorial Deep Dive

Stephane Pelhatre — Mon, 17 Jun 2024 12:35:36 +0000

Power Platform Dataflow Tutorial Deep Dive Stephane Pelhatre Mon, 06/17/2024 - 14:35

Body

Power Platform Dataflow Tutorial Deep Dive

Introduction

Dataflows are a self-service, cloud-based, data preparation technology. Dataflows enable customers to ingest, transform, and load data into Dataverse environments, Power BI workspaces, or an organization's Azure Data Lake Storage account.
Dataflows are authored by using Power Query, a unified data connectivity and preparation experience already featured in many Microsoft products, including Excel and Power BI.
Customers can trigger dataflows to run either on demand or automatically on a schedule.

Dataflows are featured in multiple Microsoft products and don't require a dataflow-specific license to be created or run. They are available in Power Apps, Power BI, and Dynamics 365 Customer Insights.

The previous image shows an overall view of how a dataflow is defined.
A dataflow gets data from different data sources.
Then, based on the transformations configured with the Power Query editor, the dataflow transforms the data by using the dataflow engine.
Finally, data are loaded to the output destination, which can be a Power Platform environment, a Power BI workspace, or the organization's Azure Data Lake Storage account.

Dataflows are cloud-based. A dataflow is stored and runs in the cloud. However, if a data source is on-premises, an on-premises data gateway can be used to extract the data to the cloud.

Power Query is the data transformation engine used in dataflow. This engine supports many transformations. It also uses a graphical user interface called Power Query Editor.

In this article we will study the use of dataflow in the Power Platform through a tutorial.

Dataflow in practice

In this tutorial we will import a CSV file into a Dataverse custom table.

Create a dataflow

To create a dataflow just go to make.powerapps.com on your Power Platform environment and select 'Dataflows' in the left pane.
Then click on '+ New dataflow' on the top.

You will get the following screen:

I named my dataflow 'Import persons'.

If you want to load data to an Azure data lake for analytical purposes check 'Analytical entities only'.
In this tutorial I leave the checkbox unchecked as I want to load data into a Dataverse table.

Data sources

First step is to select a data source.
Around 50 data sources are available as you can see below.

Main types of source:

Files : Excel, Text/CSV, XML/JSON, ...
Databases : SQL Server, Oracle, MySQL, PostgreSQL, ...
Azure : Azure SQL Database, Synapse Analytics, Blobs, Data Lake Storage Gen2, ...
Online services : Sharepoint, Exchange, Google Analytics, ...

In this tutorial I will use a CSV file. You can directly drag&drop your file in the interface.

You get a preview of your file. Then click on 'Transform Data'.

Data filtering

You get the screen of Power Query Editor

At the top we have the formula bar (as in Excel or Power-fx). We will see in this article that we can display the current formula, the full script or hide this formula bar.
Below you can see your data.
And on the right side we have the 'Applied steps' pane with all steps/actions performed. It's a little empty because we've just started, but don't worry it will fill up:

We have several tabs:

Home : functionalities to filter data and some features of other tabs
Transform: data transformations
Add column: add a new column to apply a transformation
View : display settings

In this tutorial I first click on 'Use first column as headers' in the ribbon as the first line of my CSV file contains column names.

The tab 'Home' contains several interesting features: for instance you can filter rows.
To perform that action you first have to select a column and then click on the button 'Filter Rows'.
Another interesting feature is the possibility to remove duplicates.
As previously you first have to select a column and then click on the command 'Remove duplicates' in the menu 'Remove rows'.
In my example I apply this command on the column LastName : we can see in the screenshot below that we have a duplicate in this column (raley - lines 1 and 4)

And we obtain the expected result:

You can also remove blank rows or lines with errors.

Transformations

When you have filtered your data you can now apply some transformations.
Click on 'Transform' tab. You will get a ribbon dedicated to transformation features.

You can perform many data transformations. This is a non-exhaustive list of transformation features:

Transform any column:
- Replace values
- Change type
- Detect data type
- Mark column as key
- Rename column
- Pivot/Unpivot columns
- Fill up/down
- Move column
Transform text column
- Split (by delimiter, number of characters, lower/upper case and more)
- Format (lower/upper case capitalize words, trim, clean and more)
- Extract (length, first/last characters, range and more)
- Statistics (count/distinct values)

As a first example let's remove the characters 'xxx' in the column Firstname (in rickiexxx or xxxryan).
Select column Firstname and then select the command 'Replace values...' in the menu 'Replace values'
In my example I want to remove 'xxx' so I leave 'Replace with' empty.

And we obtain the expected result:

Note that at the top in the formula bar you can see the source code (Power Query M) of the last command :
Table.ReplaceValue(#"Removed duplicates", "xxx", "", Replacer.ReplaceText, {"Firstname"})

Now let's change data type of column Age. It is currently a text column and I will change it to a whole number column.
We can see that in line 3 the column Age contains 'abc' : let's say that it is an error as this column should contain only whole numbers.
So I first select column Age and then in the menu 'Data type' I select the item 'Whole number'.
This is the result:

We get an error in line 3. This makes sense as original data 'abc' is not a number.
To solve this problem I select the column Age and select the command 'Replace errors...' in the menu 'Replace values'.
In my example I set value to 99

And I get the expected result:

The menu 'Format' contains several interesting commands:

We have the classic commands lowercase, uppercase, trim.
But we also have the nice command 'Capitalize Each Word' (first letter of each word converted into an uppercase letter) and the command 'Clean' that removes all non-printable characters.

Now I apply the command 'Capitalize Each Word' on column FirstName and the command UPPERCASE on the column Lastname.
This is the result:

Add new column

Click on 'Add column' tab, you will get a ribbon dedicated to new columns.

With commands in tab 'Transform' you apply the transformation to the original column (in-place) as we have seen previously.
Commands in tab 'Add column' store the result of the transformation in a new column.
The menu 'Format' we used previously in tab 'Transform' is also in tab 'Add column'.
But if you use one the commands (for instance UPPERCASE) you will see that a new column is created.

With the command 'Custom column' you add a new column but you cannot select a built-in command : you have to write your code (formula) in Power Query M language.

As an example, let's create a column Fullname that concatenates columns Firstname and Lastname separated by a comma.
Click on the command 'Custom column' and set the parameters:

New column name : Fullname
Datatype : Text
Custom column formula: I use the Power Query M functionText.Combine() with the 2 columns Firstname and Lastname and comma as separator
You only have to type your function in the editor and click on fields in the section 'Available columns(s)' on the right to add the columns to the formula.

And we obtain the expected result:

Another interesting feature is Conditional column : with this feature you can create new columns whose values are based on one or more conditions applied to other columns.

Let's create a conditional column named 'Is too young' : the result will be set to TRUE is Age < 18 otherwise result will be FALSE.

You just have to click on the command 'Conditional column' and fill the data as below.

In my example I use a static value (18) but it is possible to specify another column as value.

And this is the result:

And now I change the data type of column 'Is too young'. I select the command 'Detect data type' in tab 'Transform': it automatically detects the best data type for the selected column.

As this column contains only strings 'TRUE' or 'FALSE' the best data type is logical true/false (boolean).
And as you can see below it worked : the icon in the header of the column has changed to indicates that the column is now a logical column.

'Applied steps' pane

And what about the 'Applied steps' pane on the right side?
It displays all the steps executed until now.

If you want to view the content of a specific step, simply click on the gear wheel on the right.
To remove a step click on the cross on the left.

If you right-click on a step you access a context menu : rename the step, insert a new step, move the step, ...

At the bottom of the pane you have a menu 'Step'. If you click on it you will have 3 choices: Off, Query script, Step script (default).
This defines what is displayed in the formula bar.

'Off' : hide the formula bar

'Step script' : display in the formula bar the formula (code M) of the selected step.

'Query script' : display in the formula bar the full script (all steps).

Next to the 'Step' button there is 'Diagram view' button. It displays in the formula bar the diagram of all steps.

If you click on the '+' in the diagram a context menu is displayed : you can filter data, add a step, etc...

The 'View' tab contains several display settings including those we have just seen (step script, query script, diagram view),

Importing data into Dataverse

When you have finished applying transformations to you data you can click on button 'Next' at the bottom of the screen and move to next step to import transformed data into a Dataverse table.

You can choose whether you want to load data into a new table or an existing one.
In my example I create a new table Person.
To do that simply name the table and choose which column is your unique primary column.
An automatic mapping is performed.

Then click on 'Publish'.
If the publish is successful you get the following screen:

Finally you can schedule your dataflow : click on the 3 dots '...' and select 'Edit Refresh settings'

You can run your dataflow manually or schedule it based on a specific frequency.

Note that you can get the following message if your refresh frequency exceeds the allowed limit of 48 refreshes per day.

And the result in the Power Platform:

Dataflow refresh

Each time you refresh a dataflow, it fetches records from the source and loads data into Dataverse.
If you run the dataflow more than once you can:

Create new records for each dataflow refresh, even if such records already exist in the destination table. In this case you will create duplicates.
Create new records if they don't already exist in the table, or update existing records if they already exist in the table. This behavior is called upsert.

Using an alternate key column indicates to the dataflow to upsert records into the destination table, while not selecting a key indicates to the dataflow to create new records in the destination table.

For instance if your data source has a column that is different for all rows (a guid or any unique identifier) you can use this column has an alternate key in your Dataverse table.

You can get details here: https://learn.microsoft.com/en-us/power-query/dataflows/get-best-of-standard-dataflows

Power Query M language

As mentioned previously Dataflow is based on Power Query and its related language.
The Power Query editor contains many built-in commands to perform basic operations and transformations.
But you will probably have to use the language to write your own transformations. It is what we call 'writing code M'.
The M stands for data Mash-up, as Power Query is all about connecting to various different data sources and “Mashing” them up.
The Power Query M formula language is optimized for building flexible data mashup queries. It's a functional, case sensitive language similar to F#.
Power Query Formula Language is used in a number of Microsoft products such as Power BI Desktop, Excel, and Analysis Services.

Details about Power Query M language are out of the scope of this article.
Specifications of the language can be found here:
https://download.microsoft.com/download/8/1/A/81A62C9B-04D5-4B6D-B162-D28E4D848552/Power%20Query%20M%20Formula%20Language%20Specification%20(July%202019).pdf

The specification describes the values, expressions, environments and variables, identifiers, and the evaluation model that form the Power Query M language’s basic concepts.

The official reference guide : https://learn.microsoft.com/en-gb/powerquery-m/power-query-m-function-reference

Many categories are available:

Accessing data functions
Binary functions
Combiner functions
Comparer functions
Date functions
DateTime functions
DateTimeZone functions
Duration functions
Error handling
Expression functions
Function values
List functions
Lines functions
Logical functions
Number functions
Record functions
Replacer functions
Splitter functions
Table functions
Text functions
Time functions
Type functions
Uri functions
Value functions

Some basics about the language:

A Power Query M formula language query is composed of formula expression steps that create a mashup query.
A formula expression can be evaluated (computed), yielding a value.
The let expression encapsulates a set of values to be computed, assigned names, and then used in a subsequent expression that follows the in statement.
For example, a let expression could contain a Source variable that equals the value of Text.Proper() and yields a text value in proper case.

let
    Source = Text.Proper("hello world")
in
    Source

In this tutorial we wrote a formula to concatenate first name and last name:

Text.Combine({[Firstname],[Lastname]}, " , ")

Note that function name (Combine) is prefixed by the category name (Text).
For example : Date.AddMonths(), Splitter.SplitTextByDelimiter()

Below the full script of this tutorial:

let
  Source = Csv.Document(Web.Contents("https://crm315857-my.sharepoint.com/personal/admin_crm315857_onmicrosoft_com/Documents/Apps/Microsoft Power Query/Uploaded Files/example1 8.csv"), [Delimiter = ";", Columns = 3, QuoteStyle = QuoteStyle.None]),
  #"Promoted headers" = Table.PromoteHeaders(Source, [PromoteAllScalars = true]),
  #"Removed duplicates" = Table.Distinct(#"Promoted headers", {"Lastname"}),
  #"Replaced value" = Table.ReplaceValue(#"Removed duplicates", "xxx", "", Replacer.ReplaceText, {"Firstname"}),
  #"Changed column type" = Table.TransformColumnTypes(#"Replaced value", {{"Age", Int64.Type}}),
  #"Replaced errors" = Table.ReplaceErrorValues(#"Changed column type", {{"Age", 99}}),
  #"Capitalized each word" = Table.TransformColumns(#"Replaced errors", {{"Firstname", each Text.Proper(_), type nullable text}}),
  #"Uppercased text" = Table.TransformColumns(#"Capitalized each word", {{"Lastname", each Text.Upper(_), type nullable text}}),
  #"Added custom" = Table.TransformColumnTypes(Table.AddColumn(#"Uppercased text", "Fullname", each Text.Combine({[Firstname], [Lastname]}, " , ")), {{"Fullname", type text}}),
  #"Inserted conditional column" = Table.AddColumn(#"Added custom", "Is too young", each if [Age] < 18 then true else false),
  #"Changed column type 1" = Table.TransformColumnTypes(#"Inserted conditional column", {{"Is too young", type logical}})
in
  #"Changed column type 1"

A major drawback of Power Query editor :
There is no intellisense/auto-completion when you type a formula (like in Microsoft Visual Studio or with Power-fx editor).
This technology is very useful when you do not know the exact name of a function.
And don't forget that code M language is case sensitive: so any case error in a function name and your code will not work.

Mass import

In order to evaluate the performance I have imported to Dataverse a CSV file with 100'000 rows.

Format of each row:

Id : incremental number (unique value in order to perform updates)
Firstname : string
Lastname: string
Age : integer

Transformations applied:

Firstname : Capitalize Each Word
Lastname : Uppercase
Add new column : Fullname = Firstname , Lastname

The Dataverse custom table has a column Id as primary column and alternate key to be able to perform updates.

I performed the import first in creation mode : import of transformed data into an empty Dataverse table.
Then I performed an import in update mode : I modified all data in the CSV file (firstname/lastname/age but not Id of course) and imported transformed data in the same Dataverse table.

Creation mode : the 100'000 transformed rows have been imported in 58 minutes.
Update mode : the 100'000 transformed rows have been imported in 52 minutes.

Licenses

To create dataflows in Power Apps a license is required (per-user or per-app).

If you want to create analytical dataflows that store data in your organization's Azure Data Lake Storage Gen2 account, you or your administrator need access to an Azure subscription and an Azure Data Lake Storage Gen2 account.

Limitations

Maximum of 48 runs per day for a dataflow
Only one owner is currently enabled. If another user wants to modify the dataflow you must change the owner
Mapping to polymorphic lookup fields is currently not supported.
Mapping to Status and Status Reason fields is currently not supported.
Mapping data into multi-line text that includes line break characters isn't supported and the line breaks get removed. Instead, you could use the line break tag <br> to load and preserve multi-line text
Mapping to Choice fields configured with the multiple select option enabled is only supported under certain conditions. The dataflow only loads data to Choice fields with the multiple select option enabled, and a comma-separated list of values (integers) of the labels are used.
For example, if the labels are "Choice1, Choice2, Choice3" with corresponding integer values of "1, 2, 3", then the column values should be "1,3" to select the first and last choices.

Power Platform Dataflow Tutorial Deep Dive

Image

/sites/default/files/2024-06/Designer.jpeg

Azure Peering Service for Dataverse

joao.neto — Wed, 03 Apr 2024 12:43:58 +0000

Azure Peering Service for Dataverse joao.neto Wed, 04/03/2024 - 14:43

Body

Azure Peering Service for Dataverse:

Introduction

Requirements for Enterprise cloud services access are constantly evolving in terms of number of connections/users, data payload, multi-region/multi-continent access, ....

To overcome this different types of Enterprise architectures are often used : Geo-Partitioned/Hybrid-Cloud/Global load balancing/CDN architectures.

Nonetheless one question remains, how to enhance and improve network performance between Enterprise office locations and Microsoft cloud services?

Microsoft says that MAPS, Microsoft Azure Peering Service, is one of the answers.

What is

A straightforward and easy way to establish direct peering with Microsoft

MAPS is a service that enhances the connectivity to Microsoft cloud services such as Microsoft 365, Dynamics 365, software as a service (SaaS) services, Azure, or any Microsoft services accessible via the public internet.

It uses a partnership between ISP's, IXP's and SDCI providers worldwide to provide optimal routing and high-performing connectivity between Enterprise office locations and Microsoft cloud services.

How it works

Microsoft 365, Dynamics 365, and any other Microsoft SaaS services are hosted in multiple Microsoft datacenters and can be accessed from any geographic location.

The Microsoft global network has Microsoft Edge point-of-presence (PoP) locations around the world where it can connect to an end user via their service providers.

Microsoft and partner service providers ensure that the traffic for the prefixes registered with a Peering Service connection enters and exits the nearest Microsoft Edge PoP locations on the Microsoft global network.

Microsoft ensures that the networking traffic egressing from the prefixes registered with Peering Service connections takes the nearest Microsoft Edge PoP locations on the Microsoft global network (Cold-Potato routing).

Why use it

If Microsoft services performance are business critical to an Enterprise
To provide the shortest path (optimal routing) to Microsoft SaaS products, including Dynamics 365, Microsoft 365, Azure and all Microsoft services accessible from the public Internet
Avoid the enormous hops between Enterprise office locations and Microsoft
Geo-Redundancy: Microsoft’s interconnected service providers across multiple metro locations allow traffic to reroute via alternate sites if an Edge node experiences performance degradation
Monitoring Platform: Service monitoring analyzes user traffic and routing using Microsoft Telemetry
Redundancy: With primary and secondary connections, redundancy ensures reliability
Route Analytics: Events related to BGP route anomalies (leak or hijack detection) and suboptimal routing are tracked
Often in the Peering service partners offer but not in the Microsoft Peering service:
- Integrated distributed denial-of-service (DDos) protection
- Traffic isolated from the public Internet
- SLA's to ensure service availability

How to use it

In what concerns the technical management of the Peering services Microsoft has services available on the following 3 platforms:

Azure Portal
Azure PowerShell
Azure CLI

Before getting started let's state the Requirements for creating a new Peering service connection using the Azure Portal:

An Azure account with an active subscription
A connectivity provider from the Peering Service partners
- The Peering provider partner should be the closest to each office location
- A complete list of the Peering Service partners can be found here in this link

In the Azure portal search box select Peering Services in the search results and then create
On the Basics of Create a peering service connection, enter or select the following information:
Next, let's configure the Service connection:
1. Will need to provide the country, State/Province the Provider (from the available Peering service partners)
2. Select the provider primary peering location the and ideally the closest one to the target Office network location to enhance
3. Select the provider backup peering location as the next closest to your network location. A peering service will be active via the backup peering location only in the event of failure of primary peering service location for disaster recovery. If None is selected, internet is the default failover route in the event of primary peering service location failure
4. Under the Prefixes section, select Create new prefix. In Name, enter a name for the prefix resource. Enter the prefixes that are associated with the service provider in Prefix. In Prefix key, enter the prefix key that was given to you by your provider (ISP or IXP). This key allows Microsoft to validate the prefix and provider who have allocated your IP prefix. If your provider is a Route Server partner, you can create all of your prefixes with the same Peering Service prefix key
5. Select Review + Create and after creating a Peering Service connection, additional validation is performed on the included prefixes. You can review the validation status under the Prefixes section of your Peering Service

Note: For multi-region Enterprise scenarios a unique Peering service connection should be created per office region

Conclusion

another piece of the puzzle

With this offer Microsoft releases another piece of the puzzle regarding network latency performance optimization over cloud services (SaaS), however Peering services isn't the so wished silver bullet while architecturing new PowerApps/Dataverse solutions for complex multi-region Enterprise scenarios, and here's why:

Peering services aren't accountable for establishing a private secure network to Microsoft services, though it uses the public infrastructure to route Microsoft services traffic
Geographic Power Apps environment distribution will still affect network performance for end-users accessing Apps hover a far distant office location, despite of the overall network performance optimization
Regarding custom Power Apps solutions and Apps, Peering services won't improve design patterns with performance and calculation problems
Azure Peering Services aren't available as trial

As a final word MAPS is a crucial service for Enterprises having business critical services over Microsoft with a multi-region office distribution and looking for network performance improvement and in solution architectural design.

Azure Peering Service for Dataverse

Image

/sites/default/files/2024-03/MAPS_logo.png

Create a service principal with Power Platform CLI

Stephane Pelhatre — Thu, 28 Mar 2024 13:46:41 +0000

Create a service principal with Power Platform CLI Stephane Pelhatre Thu, 03/28/2024 - 14:46

Body

Create a service principal with Power Platform CLI

Introduction

To perform an integration with Dynamics 365 you typically need to set up a service principal in Azure.
To achieve this goal you must complete several steps:

Create an Azure App Registration
Create a secret for that App Registration
Set up API permissions for Dynamics 365
Create an Application User in the Power Platform Admin Center
Assign permissions to the Application User

A tutorial to perform those actions : https://dynamics-chronicles.com/article/step-step-connect-d365-clientsecret-use-apis

All these manual steps take time. But you can perform them with a Powershell command (pac admin create-service-principal).

Create your service principal

First you have to install Power Platform CLI on your machine.
Power Platform CLI is a command-line interface used to perform various operations in the Power Platform related to environment lifecycle, authentication, and work with Dataverse environments, solution packages, portals, code components.

You can download the MSI file here : https://aka.ms/PowerAppsCLI
Power Platform CLI reference guide : https://learn.microsoft.com/en-us/power-platform/developer/cli/reference/tool

After installing Power Platform CLI open a Powershell command prompt and type the command pac to check that the installation was successful.

Then type the following command to update to the latest version.

 pac install latest

Next step is to connect to your Dataverse environment with an authentication profile.
To get a list of all authentication profiles type the following command :

pac auth list

As you can see I have no authentication profile installed.
To create a profile type the following command:

pac auth create -env <env id>

<env Id> is the environment id of your organisation, which you will find in the Power Platform Admin Center.

You will be asked to provide your credentials. Below the result :

The last step is to use the command below :

pac admin create-service-principal  --environment <env id>

Now you can check the result in your Azure Portal.
As you can see below a new App Registration has been created.

A secret with one year validity has been created for the App Registration.

And correct permissions have also be added.

You can see your new application user in the Power Platform Admin Center.

The application user has the security role 'System administrator'.
It is the default security role when you use the command pac admin create-service-principal.
If you want to associate another security role you have to use the option --role.

pac admin create-service-principal  --environment <env id> --role <role>

Where <role> is the name or ID of security role to be applied to the application user.
Below the command to create a service principal with security role 'Sales Manager' assigned to the application user.

Create a service principal with Power Platform CLI

Dataverse Dynamics 365 Load testing for Model-driven app

julien.biedermann — Fri, 19 Jan 2024 15:00:24 +0000

Dataverse Dynamics 365 Load testing for Model-driven app julien.biedermann Fri, 01/19/2024 - 16:00

Body

Dataverse Dynamics 365 Load testing for Model-driven app

Introduction

In today's digital landscape, where user expectations for seamless, high-performing applications are at an all-time high, ensuring the reliability and scalability of software systems is paramount. Performance testing emerges as a critical practice in the software development lifecycle, aimed at evaluating the responsiveness, stability, and scalability of applications under various conditions.

Performance testing encompasses various types, each serving specific objectives in evaluating the performance characteristics of a system. Here are some common performance test types:

Load Testing: Determines how a system behaves under expected load conditions by subjecting it to a specific number of users or transactions, assessing its response times and resource utilization.
Stress Testing: Pushes the system beyond its normal operational capacity to identify its breaking point and understand how it behaves under extreme conditions, helping determine its resilience and stability.
Soak Testing (Endurance Testing): Evaluates the system's performance over an extended period under a consistent load to detect memory leaks, resource depletion, or degradation of performance over time.
Spike Testing: Assesses the system's ability to handle sudden increases or spikes in load, such as traffic surges, to ensure it can scale appropriately and maintain performance without crashing or slowing down.
Scalability Testing: Measures how well the system can scale up or down to accommodate changes in load or user demand, helping determine its capacity to handle growth or fluctuations in traffic.

In this article, we will focus how to conduct a load testing of a Dynamics 365 Model-driven App.

What is Load Testing ?

Load testing is a crucial aspect of performance testing focused on evaluating how a system behaves under specific levels of concurrent user activity or workload. The primary objective of load testing is to assess the system's performance, reliability, and scalability by subjecting it to simulated loads that represent expected usage patterns in real-world scenarios.

During load testing, the system is subjected to various levels of load, typically represented by a specific number of concurrent users, transactions, or requests per unit of time. By gradually increasing the load, testers can observe how the system responds and identify any performance issues, such as slow response times, errors, or system crashes.

When performing a load test, several important factors should be considered to ensure its effectiveness and relevance to the application's performance goals. Here are some key considerations:

Define Clear Objectives: Clearly define the objectives and goals of the load test. Understand what aspects of the application's performance you are testing, such as response times, throughput, scalability, or resource utilization.
Identify Key Scenarios: Identify the critical user scenarios or workflows that are most representative of real-world usage patterns. Focus the load test on these scenarios to simulate realistic user behavior.
Set Realistic Load Levels: Determine the appropriate load levels based on expected traffic volumes, peak usage periods, and scalability requirements. Ensure that the load levels accurately reflect the anticipated production environment.
Simulate Production Environment: Mimic the production environment as closely as possible during the load test. Consider factors such as network latency, hardware configurations, and software dependencies to create a realistic testing environment.
Analyze Results: Analyze the results of the load test thoroughly to identify performance issues, bottlenecks, and areas for improvement. Look for patterns in system behavior and correlate performance metrics to identify root causes of performance degradation.

How to load test a model-driven app ?

Microsoft is providing the following documentation : https://learn.microsoft.com/en-us/dynamics365/guidance/resources/test-scale-dynamics-365-solution

In this article, we're gonna walk through using those test samples from Microsoft, step by step.

Requirements

Microsoft Dynamics 365 Customer Service environment with Customer Service-Hub model-driven application
At least one user account with multi-factor authentication disabled
Sample data in Dataverse
- Min. 10 active accounts
- Min. 10 active products
- Min. 10 active subjects
Azure subscription (optional): It's a requirement if you plan to load test in Azure Load Testing (https://azure.microsoft.com/en-us/products/load-testing).

1. Download samples files

You will find all the samples files here : https://github.com/microsoft/Dynamics-365-FastTrack-Implementation-Assets/tree/master/Customer%20Service/Testing/At%20Scale/Samples

In this walkthrough, we will use the CreateCase sample. To start, you can download the following files :

CaseCreate.csv
CreateCase.docx
CreateCase.jmx

2. Install Apache JMeter

First, you need to install Apache JMeter https://jmeter.apache.org/usermanual/get-started.html#lets_start.

Apache JMeter is an open-source, Java-based software designed for load testing, performance testing, and functional testing of web applications.

JMeter is not a browser, it works at protocol level. As far as web-services and remote services are concerned, JMeter looks like a browser (or rather, multiple browsers); however JMeter does not perform all the actions supported by browsers. In particular, JMeter does not execute the Javascript found in HTML pages. Nor does it render the HTML pages as a browser does (it's possible to view the response as HTML etc., but the timings are not included in any samples, and only one sample in one thread is ever displayed at a time).

Apache JMeter has two modes, GUI mode and CLI mode.

Use GUI mode for test creation, editing, and debugging.
Use CLI mode to run a load test.

3. Populate CSV file

The file CaseCreate.csv contains the test user's information (username and password). Open the file and add your test user's credentials.

Be careful, if the passwords contain special characters like % or #, it can be misinterpreted during test execution and generate errors.

4. Edit load test script

Run Apache JMeter in GUI mode by opening jmeter.bat in the bin folder.

Open the CreateCase.jmx file.

In Apache JMeter, click File – Open
Use the explorer window to navigate to file or repository containing the CreateCase.jmx file.
Select the CreateCase.jmx file and click Open.

Update User Defined Variables

Click on the User Defined Variables element
Update the following values
1. host – your Microsoft Dataverse environment url (e.g., yourorg.crm.dynamics.com)
2. tenantId - your Microsoft 365 tenantid.
3. cshAppId - the GUID of your Customer Service Hub model-driven application

Update the Thread Group Properties

Click on the CreateCase element
Update the following values
1. Number of Threads (users) – total concurrent users to simulate.
2. Ramp up period (seconds) – duration to increase the threads to the total number of threads.
3. Loop Count – number of times to execute a single thread.

Configure the CSV Data Source

Click on the CSV Data Set Config
Update the filename value with your updated csv file

5. Execute in GUI mode

Test can be started in GUI mode using one of the following methods:

In the Run menu, click Start
Click the Start button in the toolbar
Right-click on CreateCase element and click Start

Before running the test in GUI mode, ensure to reduce the number of threads (users). GUI mode should only be used for test creation, editing and debugging.

You can use the View Results Tree to monitor the progress of the test and to debug, checking the request and response of the calls.

6. Execute in CLI mode

GUI mode has limitations that might impact the performance of a load test. Use CLI mode when executing a load test at full scale.

Test can be started in CLI mode following the steps below:

Open CMD and change the directory to the jmeter bin folder
Enter the following command

jmeter -n -t path\CreateCase.jmx -l path\testresults.csv -e -o path\Results

Option	Definition
-n	This specifies JMeter is to run in cli mode.
-t	Name of JMX file that contains the Test Plan
-l	Name of JTL or CSV file to log sample results to
-e	Generate report dashboard after load test
-o	Output folder where to generate the report dashboard after load test. The folder must not exist or be empty.

Sometimes, JMeter throws a heap dump along with an ‘out of memory’ error while executing the load test. In this case, you need to increase the heap size by editing the jmeter.bat file. The size has been updated to 8 GB in the example below:

if not defined HEAP (
    rem See the unix startup file for the rationale of the following parameters,
    rem including some tuning recommendations
    set HEAP=-Xms1g -Xmx8g -XX:MaxMetaspaceSize=256m
)

6.1 Report

After running the load test using CLI mode with the command above, a HTML report is generated in the folder defined.

This report offers valuable insights into all requests conducted during the testing phase, presenting a comprehensive overview of the test execution. Additionally, it includes a detailed table illustrating the APDEX.

APDEX (Application Performance Index) is a metric used to evaluate the user satisfaction of an application based on its response times. APDEX is a standardized method for measuring and reporting the satisfaction level of users with the responsiveness of web applications or services.

APDEX categorizes response times into three zones:

Satisfied: Response times that meet or exceed the user's expectations.
Tolerating: Response times that are acceptable but not ideal.
Frustrated: Response times that are considered unacceptable by users.

The APDEX score is calculated based on the following formula:

In JMeter, APDEX can be calculated using the following steps:

Define the thresholds for response times that determine whether a sample is categorized as satisfied, tolerating, or frustrated. These thresholds are typically defined based on the application's performance goals and user expectations.
Configure JMeter to track the response times of requests during the test execution.
After the test execution, JMeter calculates the APDEX score based on the collected response times and the defined thresholds.
The APDEX score provides a standardized measure of user satisfaction with the application's performance, helping testers and developers assess whether the application meets its performance goals and user expectations.

By using APDEX in JMeter, testers can quantitatively measure and report the user satisfaction level of web applications or services, allowing them to identify performance issues and prioritize improvements to enhance the overall user experience.

7. Execute in Azure Load Testing

First, you need to deploy Azure Load Testing using your Azure subscription.

Now, before diving into creating a load test in Azure Load Testing with a JMeter script, there are a few configurations we need to tweak:

7.1 Update CSV Data Set Config

In Azure Load Testing the JMX file and all related files are uploaded in a single folder. When you reference an external file in your JMeter script, verify that you only use the file name and remove any file path references.

Remove any file path and reference the filename only in the filename field
Set "Ignore first line" to False
Remove the header row (userName,password) from CreateCase.csv

7.2 Update User Defined Variables

Replace User Defined Variables with the following values :

${__BeanShell(System.getenv("host"))}
${__BeanShell(System.getenv("tenantId"))}
${__BeanShell(System.getenv("cshAppId"))}

7.3 Create and run the test in Azure Load Testing

In Microsoft Azure, navigate to and open your Azure Load Testing resource.
From "Get started" dashboard, select "Create" with the option "Upload a JMeter script" or create it from Tests menu.
On the Basic tab, enter a test name and description
On the Test plan tab, upload both CreateCase.jmx (the one adapted for Azure Load Testing) and CreateCase.csv (without header row)
1. Uncheck "Run test after create" if you don't want to run it directly after creation
On the Parameters tab
1. Add the correct values for the variables host, tenantId and cshAppId
On the Load tab
1. Configure the test engine instances to a meet the target load for the test. The number of threads specified in the jmx file represents the number of thread (virtual users) executed by one test engine instance.
2. Network traffic to Power Platform applications will be routed through Public networks.
On the Test criteria tab
1. (Optional) Define the criteria to specify the performance expectations of the system under test. Use the defined criteria to determine the failure conditions for the test when the criteria evaluate to true.
On the Monitoring tab
1. (Optional) Configure application components to monitor server-side metrics during the test run.
Once all tabs completed, you can review and create your test.
Then, if you have unchecked the box at point 4.1, you need to open and run your test manually
Once the test is executed, you can open it to see the load test results

I'd like to note that I conducted the load test within a trial environment. This could account for the observed performance not meeting expected standards.

Conclusion

I hope you enjoyed this tutorial on running a load test sample in a model-driven app. This article provided an overview of load testing using JMeter and Azure Load Testing, and perhaps it will inspire other bloggers to delve into topics such as:

How to build his own test case in JMeter ?
How to analyze the results ?

In conclusion, it's crucial to recognize that JMeter has limitations when it comes to measuring user experience elements occurring at the client side, such as load time or page rendering. JMeter functions as a performance testing tool but does not emulate a real browser. If we aim to test the user interface (UI) using JMeter, we'd need to incorporate tools like the WebDriver Sampler. This component facilitates integration with the Selenium browser automation framework, enabling more comprehensive UI testing capabilities within the performance testing context. Essentially, JMeter, while proficient at server-side performance assessments, requires additional tools like WebDriver Sampler for thorough evaluation of user interface aspects.

Dataverse Dynamics 365 Load testing for Model-driven app

Image

/sites/default/files/2024-02/article1.png

PowerApps Model Driven UI Testing with Playwright

zsoltzombik — Thu, 07 Dec 2023 15:16:37 +0000

PowerApps Model Driven UI Testing with Playwright zsoltzombik Thu, 12/07/2023 - 16:16

Body

PowerApps Model Driven UI Testing with Playwright

Introduction

In the ever-evolving landscape of software development, test automation has emerged as a pivotal trend, revolutionizing the way we build and deploy software. For businesses embracing Agile and DevOps methodologies, automated testing has become a cornerstone practice, enabling faster development and deployment cycles. In this article, we embark on a journey to explore the profound benefits of automated testing and why it holds such paramount importance in the context of software development, particularly within Dynamics 365 Model Driven Apps. We'll also touch upon the pivotal role of Playwright in automating UI testing within this environment. So, let’s discover the major benefits of automated testing and why automation in software testing matters:

Accelerated Development and Delivery: UI Test automation significantly reduces testing time, as automated tests can be executed rapidly and repeatedly. This results in shorter software development cycles, more frequent releases, quicker updates, and faster time-to-market delivery. The integration of automation, particularly with Playwright, expedites the testing process within Dynamics 365 Model Driven Apps, enhancing the development speed.
Enhanced Productivity: Automated tests operate without human intervention, enabling testing at any time, even during non-working hours. This autonomy minimizes the time software developers and quality assurance teams spend on testing, allowing them to focus on critical tasks. With automation, engineers can prioritize the creation of new features and improvements, ultimately boosting productivity.
Precision and Accuracy: Automated testing reduces the risk of human errors during the testing process. Unlike human testers who may make mistakes, automated tests execute precisely according to predefined criteria. This precision contributes to more reliable and error-free releases, minimizing the risk of failure.
Superior App Quality and Performance: Automated testing offers extensive test coverage, ensuring high-quality and high-performance applications. It allows for simultaneous testing of thousands of test cases across multiple platforms and devices, a feat difficult to achieve manually. With automation, complex and lengthy test cases can be created quickly, elevating the overall quality of applications.
Immediate Feedback: Automated testing provides instant feedback to developers, enabling quick response to failures. This immediate feedback accelerates the bug-fixing process and ensures a better user experience, leading to higher customer satisfaction. In contrast, manual testing can slow down the development and update process.
Enabling CI/CD and DevOps: Test automation is pivotal for implementing Continuous Integration (CI) and Continuous Delivery (CD) practices. In the CI/CD pipeline, every code commit needs to be tested swiftly and efficiently, a task perfectly suited for automation. Automation, including Playwright for UI testing, streamlines the transition to Continuous Testing and Delivery.

Incorporating test automation, especially within the context of Dynamics 365 Model Driven Apps, is not just a trend; it's a necessity. The benefits of automated testing continue to expand as tools and testing frameworks evolve. Beyond traditional automated testing, new areas like model-based testing, predictive analysis, robotics automation, and API test-case automation are emerging. To stay at the forefront of technological evolution, implementing test automation is imperative. It accelerates development, enhances efficiency, accuracy, and productivity, all while maintaining the highest standards of app quality and performance. Partnering automation with a robust testing solution and integrating it with your CI/CD tools ensures that you harness its full potential efficiently on real devices, propelling your software development to new heights without compromising on quality or performance.

Setting Up Your Environment for Playwright in Dynamics 365

Prerequisites for Playwright Setup

Before diving into using Playwright for UI testing, ensure you have the following prerequisites in place:

Native Installation

Playwright Test for Visual Studio Code: This is available on Visual Studio Marketplace. Make sure you have version 1.19 or newer to leverage the full capabilities of Playwright in Visual Studio Code.

Playwright NPM Package

Cross Platform Support: Playwright is designed for versatility, supporting Windows, Linux, and macOS. It can be used for testing both locally and on Continuous Integration (CI) platforms such as Azure DevOps, GitHub.
Browser Testing Flexibility: It offers extensive testing capabilities, including both headless and headed modes. For mobile testing, Playwright provides native mobile emulation for Google Chrome on Android and Mobile Safari, ensuring comprehensive coverage across devices.

Azure Subscription (Optional)

Enhanced Testing with Microsoft Azure: While not mandatory, an active Microsoft Azure subscription is recommended for a more robust testing framework. It becomes essential if you're planning to conduct automated tests within Azure or integrate load testing into your CI/CD pipelines. Utilizing Azure enhances your testing scope and efficiency, particularly for complex Dynamics 365 environments.

Having these prerequisites in place sets a solid foundation for effective and efficient use of Playwright in your Dynamics 365 UI testing projects.

Installation and Configuration

Before you start, you will need install the following:

NodeJS - https://bit.ly/getnodejs
VSCode - https://bit.ly/downloadvscode

When installing Node, select the LTS version and accept the defaults.

After installation, you should check you have Node installed correctly, at command line type:

npm

You should see the npm command help information displayed.

To check you had the VSCode installed correctly, at the command line type:

Code .

This should open VSCode at the code folder location you are currently in.

UI Test Project folder setup

Playwright UI Test project do not have a project file like C# (.csproj) so you can simply create a new folder with the name of your project. I will use UITest.

At the command line, type:

Mkdir UITest
Cd UITest

Install Playwright Test for Visual Studio Code

Open Visual Studio Code.

Select Extension, then search for Playwright Test for VSCode.

Then click on Install.

Open the command panel (Ctrl + Shift + P), and then enter the following command: Install Playwright.

On the next screen, select the browser(s) you want to run your tests in. You can change the setting later in the playwright.config file.

Finally you created your first Playwright test project.

Get a Test Environment

Next, you need a Dynamics 365 environment that you can run tests in. If you're finalizing an implementation project, you probably have a test environment already. If you don't, you can get a free 30-day trial (for this article, we provisioned a trial Dynamics 365 Customer Service Environment.

Setting up Test Environment

To optimize the test environment for automated testing, especially when using Playwright with a model driven app, follow these steps:

Disable Security Defaults

Adjust Security Defaults: For the purpose of automated testing it's necessary to turn off security defaults. This ensures that the automated tests can run without unnecessary interruptions interruptions or blocks, which are typically in place for security reasons. Please follow this link: https://learn.microsoft.com/en-us/entra/fundamentals/security-defaults

Create and Configure User Accounts

Access Microsoft 365 Admin Center: Utilize the Microsoft 365 admin center to set up the required user account(s) for testing.
Assign Security Roles: Properly assign the necessary security roles to these accounts to ensure they have the appropriate access levels for testing.

By carefully configuring the test environment as described, you create a more controlled and effective setting for conducting automated tests using Playwright in Dynamics 365.

First Playwright Test

Let's create our first test! Playwright provides convenient utilities for capturing your browser interactions and generating test scripts. To accomplish this, simply execute the Playwright Node command with the codegen argument. When you include the URL of your model-driven Power App as a parameter, it initiates a browser session that records the user's actions within the Playwright Inspector.

To inititate the recording a new test, type this command on Visual Studio Code Terminal window:

npx playwright codegen https://<you-crm-org>.crm4.dynamics.com/main.aspx?appid=<app guid>

Playwright open a new browser instance and launch Playwright Inspector:

Enter the credentials.

Then select Service -> Cases.

Click on New Case button.

Fill the form, then click on the Save button.

Finally, take a look at the Playwright inspector window, it generated the code of our test.

After the test script generated, we need to create a new test file under the tests folder such as and copy the code generated by Playwright Inspector.

Select the Test icon on Visual Studio Code.

Find the test we created previously.

Click in Debug Test button.

It kicks off by running tests in debug mode, and eventually, you'll spot the test results right in the terminal window.

Here's a small preview of the upcoming articles on Playwright.

The upcoming article, Writing Effective UI Tests with Playwright in Dynamics 365 will focus on mastering Playwright's testing capabilities, including automated browser testing and managing dynamic content. It will provide a step-by-step guide to developing test scripts specifically tailored for Dynamics 365 UI, complete with example scripts and scenarios, and conclude with strategies for debugging and troubleshooting these tests.
Third article Advanced Playwright Features for Dynamics 365 Testing will cover sophisticated techniques for working with multiple browsers and devices, including cross-browser and responsive testing. It will also delve into Playwright's advanced capabilities like network interception, mocking, and visual regression testing, along with their integration in CI/CD pipelines.
Fourth article titled Best Practices and Optimizing Test Performance focuses on creating maintainable test code with well-organized structure and reusable components. It will discuss strategies to enhance test performance, such as parallel testing and methods to reduce test flakiness, and will conclude with approaches for monitoring and reporting test results.

PowerApps Model Driven UI Testing with Playwright

Image

/sites/default/files/2023-11/1970%27s%20sci%20robot%20testing%20software%2C%20studio%20light%2C%20on%20an%20emerald%20colored%20background.jpg

The User Name in D365 CRM is different from that in Office 365

Guowei — Wed, 22 Feb 2023 06:56:12 +0000

The User Name in D365 CRM is different from that in Office 365 Guowei Wed, 02/22/2023 - 07:56

Body

The User Name in D365 CRM is different from that in Office 365

Table of Contents

Issue Description
Root Cause
More Information

Today, I'd like to show a note about the User Name sync mechanism from AAD(Azure Active Directory ) to Dynamics 365 CRM.

Issue Description

An end-user reported that her name was updated to "Dayana Andrade Zavala", however, in D365, it still shows Dayana Yamileth Andrade Zavala.

In AAD:

In O365:

In D365 CRM:

Root Cause

By further checking, we found she updated the user's Display Name, Not updated her first and last names in AAD.

In AAD, we can see this user’s display name is “Dayana Andrade Zavala”, but her “First name + Last name” is still “Dayana Yamileth Andrade Zavala”.

O365 uses AAD's Display Name as Name.

So, we change the First Name and Last name in AAD, then it will sync to D365 15 mins later.

More Information

By default, the system users will be synced from AAD(for which settings are either managed in the Office 365 or Azure portals) every 15 mins.

In the default sync, only a static set of attributes is synced with Dynamics 365.

For example, when the user is synchronized from AAD/O365 to D365 CRM, the manager property is not synchronized.

For the details of the attributes please refer to the table below.

CDS SystemUser Property	Azure AD Property
DomainName	UserPrincipalName
WindowsLiveId	UserPrincipalName
FirstName	First Name
LastName	Last Name
Address1_Country	Country
Address1_City	City
Address1_StateOrProvince	State
Address1_Line1	StreetAddress
Address1_PostalCode	PostalCode
Address1_Telephone1	BusinessPhones
MobilePhone	MobilePhone
Title	JobTitle
InternalEmailAddress	Mail
azureactivedirectoryobjectid	objectId

The End.

Hope this is helpful.

Thanks.

The User Name in D365 CRM is different from that in Office 365

Dataverse : Azure Functions .Net Framework vs .Net Core / Runtime 1 vs 4 - Migration Steps

Lloyd Sebag — Tue, 25 Oct 2022 14:48:49 +0000

Dataverse : Azure Functions .Net Framework vs .Net Core / Runtime 1 vs 4 - Migration Steps Lloyd Sebag Tue, 10/25/2022 - 16:48

Body

Dataverse : Azure Functions .Net Framework vs .Net Core / Runtime 1 vs 4 - Migration Steps:

Do you have a FunctionApp in Runtime 1 targeting a .Net Framework project and want to migrate it to a newer Runtime like 4?

This is possible! But not so simple if you don't read this article! ;)

Azure Function Runtim 4 and .Net Framework?

First of all, we must clarify a gray area introduced by Microsoft. In the official Azure Function Runtime documentation, there is a table suggesting that Runtime 4 is natively compatible with the .Net Framework. It's partially true...

In fact it seems possible but through the option to run the App in isolated process.
Here is the doc.

I have been able to try to follow the steps to do so, without success at the time of writing this article. Indeed, my version of Visual Studio doesn't seem to handle this correctly...
Here's a GitHub thread speaking about it.

So how to do?

The King is Dead, Long Live the King!

For years we have all used the Dynamics NuGet package allowing us to connect to the service and use the API. Microsoft.CrmSdk.XrmTooling.CoreAssembly

Except that this great package is only available from version 4.6.2 of the .Net Framework!

Until recently, there was no solution to use these DLLs with .Net Core...Then the Microsoft.PowerPlatform.Dataverse.Client project appeared. It's been in preview for a while, but it's now been in GA since June 2022!

This package will not only allow you to retrieve your development habits but will also offer you new methods and others to come.

Here is a sample code allowing you to connect to Dataverse and do a WhoAmI. You will notice that the code is not changing a lot between the old version CrmServiceClient and the new ServiceClient!

var service = new ServiceClient($@"AuthType=ClientSecret;url=URL;ClientId=ID;ClientSecret=SECRET");
var userId = (WhoAmIResponse)service .Execute(new WhoAmIRequest());
log.LogTrace("UserId : " + userId.UserId);

WARNING : Check this article to know about the non support of IFD + ADFS

Ready for Azure Runtime 4!

Thanks to this, you can now fully consider migrating your FunctionApps from runtime 1 to 4 and thus be up to date in your PaaS.

You will obviously have to consider skipping the following points:

Change the Runtime on Azure Function.
Modify your VS project to point to the correct framework and runtime version.
Modify your NuGet packages to remove the old and reference the new.
Modify the code to resolve the errors.
And more...

Step by Step

1. Change the Runtime on Azure Function.

Log in to your Azure Portal and navigate to your Function App.
Go to the Configuration section and then to the Function Runtime Settings tab.
Here you will have a drop-down list to choose the Runtime version.

If ever you cannot select version 4. Here is a procedure allowing you to carry out the modification by CLI script.

az login
az functionapp config set --net-framework-version v6.0 -g <ResourceGroup> -n <FunctionAppName>
az functionapp config appsettings set --settings FUNCTIONS_EXTENSION_VERSION=~4 -g <ResourceGroup> -n <FunctionAppName>

2. Modify your VS project to point to the correct framework and runtime version

Open your Visual Studio project and open the .csproj file.
Modify these two nodes as follows.

3. Other steps

I think you know how to modify the NuGet packages and migrate your code. No trap here. :)

Enjoy !

Dataverse : Azure Functions .Net Framework vs .Net Core / Runtime 1 vs 4 - Migration Steps

Image

/sites/default/files/2022-10/chro.png

How to use Azure Table Storage with C#

Lloyd Sebag — Wed, 14 Sep 2022 08:32:50 +0000

How to use Azure Table Storage with C# Lloyd Sebag Wed, 09/14/2022 - 10:32

Body

How to use Azure Table Storage with C#

Azure Table Storage is a very useful solution present in the Azure Storage Account component. The service is a NoSQL datastore which accepts authenticated calls from inside and outside the Azure cloud. While remaining scalable and maintained by the Azure Cloud.
It is therefore a real accelerator for projects that need to store unstructured data.

You can obviously manipulate the data manually from the Azure portal, however, here I will show you that you can mainly use the API to manipulate the data from your C# code.

The first thing to do is to go to your Azure Portal on your Storage Account to retrieve its name and AccessKey.

Then you can go into your code to do the following CRUD: Don't forget to use the NuGet package : Microsoft.WindowsAzure.Storage.

Using and Auth :

using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Auth;
using Microsoft.WindowsAzure.Storage.Table;

// Get Storage Information
var accountName = "YourAzureStorageAccountName";
var creds = "AccessKeyOfYourStorageAccount";

// Set Auth
var creds = new StorageCredentials(accountName, accountKey);
var account = new CloudStorageAccount(creds, useHttps: true);

// Connect to Storage
var client = account.CreateCloudTableClient();
var table = client.GetTableReference("YourAzureTableName");

Retrieve Data :

// RETRIEVE DATA FROM AZURE TABLE
var condition = TableQuery.GenerateFilterCondition("ColumnA", QueryComparisons.Equal, "Something");
var condition2 = TableQuery.GenerateFilterCondition("ColumnB", QueryComparisons.Equal, "Anotherthing");
var finalFilter = TableQuery.CombineFilters(condition, TableOperators.And, condition2);
var query = new TableQuery<YourCustomClassThatRepresentTheObject>().Where(condition).Where(finalFilter);
var result = table.ExecuteQuery(query);

var obj = result.FirstOrDefault();
obj.ColumnC;

Create Data :

// INSERT DATA IN AZURE TABLE
var obj = new YourCustomClassThatRepresentTheObject()
{
	PartitionKey = Guid.NewGuid().ToString(), // Must be unique
	RowKey = Guid.NewGuid().ToString(), // Must be unique
    ColumnA = "ValueA",
    ColumnB = true,
    ColumnC = "ValueB"
};
var insertOperation = TableOperation.Insert(obj);
table.Execute(insertOperation);

Update Data :

// UPDATE DATA IN AZURE TABLE
var obj = new YourCustomClassThatRepresentTheObject()
{
	PartitionKey = PartitionKeyValue, // Must be the one of the record you want to update. You can retrieve it before. 
	RowKey = RowKeyValue, // Must be the one of the record you want to update. You can retrieve it before. 
    ColumnA = "UpdateValueA",
    ColumnB = false,
    ColumnC = "UpdateValueB"
	ETag = "*"
};
var mergeOperation = TableOperation.Merge(obj);
table.Execute(mergeOperation);

Class definition :

// YourCustomClassThatRepresentTheObject Class definition
public class YourCustomClassThatRepresentTheObject : TableEntity
{
	public string PartitionKey { get; set; }
	public string RowKey { get; set; }
    public string ColumnA { get; set; }
    public Boolean ColumnB { get; set; }
    public string ColumnC { get; set; }
}

Voila ! Your code can now communicate with Azure Table and manipulate the data.

How to use Azure Table Storage with C#

Image

/sites/default/files/2022-09/How%20to%20use%20Azure%20Table%20Storage%20with%20C%23.jpg