Developer samples available?

[jlcate]

Hi Yvan,

I'd like to extend AzureCP and do it your approved way. I see that you have a developer samples download for LDAPCP, but can't find the same for AzureCP. I've looked over the developer sample for LDAPCP and LDAPCP itself, but am not sure if I can just follow that same pattern with AzureCP or not.

My specific project is to have multiple SP web applications in my farm, each with a tenant-specific AzureCP-based custom claims provider. AzureCP OOB works perfectly for the first tenant\first web application. Now I need the same functionality on the 2nd web application for the 2nd tenant, and so forth. It seems like the way to do this is create a farm solution for each web application, that inherits the base AzureCP class and uses a unique claim provider name and modifies the configuration for the specific tenant.

Am I headed in the right direction? Would you be able to publish a downloadable developer sample for how to extend this way?

Thanks,

Jeff

[Yvand]

Hi @jlcate, if you need to create multiple SPTrustedIdentityTokenIssuer, then yes, you need a unique custom claims provider for each. As you noticed there is no sample available, but this project is getting more popular and I'm currently working on a major update that will use Microsoft Graph instead of the old Azure AD Graph API. It will also be aligned with all improvements I made to LDAPCP over time. And with this new version I'll probably publish a sample to show how to inherit AzureCP

[jlcate]

Thanks for the response, Yvand.

Jeff

[JosephSaad]

Hello Yvand, Have you ever got to releasing this sample code if I need multiple Trusted Identity Providers?

Joseph.

[Yvand]

@JosephSaad thank you for bringing this to my attention, tbh I thought I did but I actually did not. I'm currently moving the build pipelines to GitHub and I will soon release a new version, I'll publish the sample along with this new version.

[vargasfe]

Hello Yvand, for those of us whose developer days are far behind, could we get you to create a package that contains say 10 unique claims providers e.g. AzureCP (The master), AzureCP01, AzureCP02... AzureCP09, that can be installed individually as needed to fulfill the requirement of the use case described by this issue? Since the child packages, AzureCP01.wsp etc all would inherit from the original, they would always work with whatever version of AzureCP is installed, right?

This would be a lifesaver for me. Thanks, Fernando

[Yvand]

@vargasfe understood, I will publish it asap

[Yvand]

@vargasfe I just added file "AzureCP.Developers.zip" to latest release

[vargasfe]

Thank you Yvand for the Developer sample. I peeked inside and saw the AzureCP.Custom project. From what little I understand of the code, I gather this would make an AzureCP.Custom solution (WSP package including the AzureCP.Custom.dll) and this dll would use a customconfiguration object named "MyCustomAzureCPConfig". THat all sounds just like what I need except I don't really know how to do it. How would I replicate the project so it gets new GUIDs?

I want 7 projects named AzureCP.CP01, AzureCP.CP02,...AzureCP.CP07 and each of those projects would use a custom configurations named the same way AzureCPConfigurationCP01,AzureCPConfigurationCP02,...AzureCPConfigurationCP07.

All of those projects would depend on and inherit from the original AzureCP.dll

How can we persuade you to do this for us?

Thanks,

[Yvand]

@vargasfe what you plan to do is probably not a good idea: You would create multiple wsp packages which all deploy the same assemblies in SharePoint farm. This is opening a door to big problems each time you want to update a package.

Instead, you could group all your custom claims providers in a single package. A claims provider is mostly defined by its farm feature, you will find one in the package that you can duplicate as many times as needed.

1 thing you should keep in mind: For the same reason I mentioned above, never deploy the standard AzureCP.wsp in the same farm as your custom package (since they share common assemblies).

With all that said, I am quite curious to understand why you want so many different versions of AzureCP, it does not look like the most optimized approach.

[vargasfe]

Hello Yvan,

The reason for all this is quite simple. In a single farm I have multiple web applications and each of those needs to use a distinct AzureCP that is connected to a distinct Azure Tenant. This is a different use case from having multiple Azure AD tenants associated with a single AzureCP.

My plan was to have multiple AzureCP.Custom projects all of which would reuse code but use different configurations. This way I could deploy only the ones needed, 2, 3,…7.

But, I see your point. If all it takes is multiple features in the project, then I can add all of them to one project and simply configure the ones I need and leave the others alone.

Ideally, AzureCP would have the ability to instantiate named CPs with their unique configurations.

Just like you create a tenant, you would start with Create CP and configuring each indificually. Can you see this? I used a similar approach many years ago implementing multi-language UIs that could be switched on the fly without closing and reopening the application.

Fernando

From: Yvan Duhamel @.> Sent: Tuesday, May 2, 2023 4:55 AM To: Yvand/AzureCP @.> Cc: vargasfe @.>; Mention @.> Subject: Re: [Yvand/AzureCP] Developer samples available? (#15)

@vargasfe https://github.com/vargasfe what you plan to do is probably not a good idea: You would create multiple wsp packages which all deploy the same assemblies in SharePoint farm. This is opening a door to big problems each time you want to update a package.

Instead, you could group all your custom claims providers in a single package. A claims provider is mostly defined by its farm feature, you will find one in the package that you can duplicate as many times as needed.

1 thing you should keep in mind: For the same reason I mentioned above, never deploy the standard AzureCP.wsp in the same farm as your custom package (since they share common assemblies).

With all that said, I am quite curious to understand why you want so many different versions of AzureCP, it does not look like the most optimized approach.

— Reply to this email directly, view it on GitHub https://github.com/Yvand/AzureCP/issues/15#issuecomment-1531113493 , or unsubscribe https://github.com/notifications/unsubscribe-auth/ACUI3YEUSAUORZUIYTZW273XEDDUVANCNFSM4EXHTNLQ . You are receiving this because you were mentioned. https://github.com/notifications/beacon/ACUI3YHEJ3WHGXPBFIUGW6LXEDDUVA5CNFSM4EXHTNL2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOLNBPAFI.gif Message ID: @. @.> >

[vargasfe]

Yvan,

I’ve been trying to create an AzureMCP (Multiple Claim Providers) project using the following strategy:

A CustomConfiguration that takes a paramenter indicating the instance number

An AzureMCP that takes two parameters (configName, displayName)

Several Features where the feature receives instantiates the CustomConfiguration and matching CP:

            AzureMCP-CP01

            AzureMCP-CP02

The solution actually builds and deploys and I end up with two CPs but they are not what I expected.

I just don’t know enough C# to pull this off.

Any thoughts on the code below?

Thanks,

F.

AzureMCP-CP01.EventReceiver.cs

using System;

using System.Collections.Generic;

using System.Runtime.InteropServices;

using System.Security.Permissions;

using Microsoft.SharePoint;

using Microsoft.SharePoint.Administration;

using Microsoft.SharePoint.Administration.Claims;

namespace azurecp.AzureMCP.Features.AzureMCP_CP01

{

/// <summary>

/// This class handles events raised during feature activation, deactivation, installation, uninstallation, and upgrade.

/// </summary>

/// <remarks>

/// The GUID attached to this class may be used during packaging and should not be modified.

/// </remarks>

[Guid("369a8687-b350-4a95-bf55-02e858236646")]

public class AzureCPEventReceiver : SPClaimProviderFeatureReceiver

{

    public AzureCP AzureCP = new AzureMCP("CP01Configuration", "AzureMCP-CP01");

    public CustomConfiguration CustomConfiguration = new CustomConfiguration("1");

    public override string ClaimProviderAssembly => CustomConfiguration.AZURECPTYPE.Assembly.FullName;

    public override string ClaimProviderDescription => CustomConfiguration.ClaimsProviderName;

    public override string ClaimProviderDisplayName => CustomConfiguration.ClaimsProviderName;

    public override string ClaimProviderType => CustomConfiguration.AZURECPTYPE.FullName;

    public override void FeatureActivated(SPFeatureReceiverProperties properties)

    {

        ExecBaseFeatureActivated(properties);

    }

    private void ExecBaseFeatureActivated(Microsoft.SharePoint.SPFeatureReceiverProperties properties)

    {

        // Wrapper function for base FeatureActivated. 

        // Used because base keywork can lead to unverifiable code inside lambda expression

        base.FeatureActivated(properties);

        SPSecurity.RunWithElevatedPrivileges(delegate ()

        {

            try

            {

                ClaimsProviderLogging svc = ClaimsProviderLogging.Local;

                ClaimsProviderLogging.Log($"[{CustomConfiguration.ClaimsProviderName}] Activating farm-scoped feature for claims provider \"{CustomConfiguration.ClaimsProviderName}\"", TraceSeverity.High, EventSeverity.Information, ClaimsProviderLogging.TraceCategory.Configuration);

                var spTrust = AzureCP.GetSPTrustAssociatedWithCP(CustomConfiguration.ClaimsProviderName);

                if (spTrust != null)

                {

                    AzureCPConfig existingConfig = AzureCPConfig.GetConfiguration(CustomConfiguration.CONFIG_NAME);

                    if (existingConfig == null)

                        AzureCPConfig.CreateConfiguration(CustomConfiguration.CONFIG_ID, CustomConfiguration.CONFIG_NAME, spTrust.Name);

                    else

                        ClaimsProviderLogging.Log($"[{CustomConfiguration.ClaimsProviderName}] Use configuration \"{CustomConfiguration.ClaimsProviderName}\" found in the configuration database", TraceSeverity.High, EventSeverity.Information, ClaimsProviderLogging.TraceCategory.Configuration);

                }

            }

            catch (Exception ex)

            {

                ClaimsProviderLogging.LogException(CustomConfiguration.ClaimsProviderName, $"activating farm-scoped feature for claims provider \"{CustomConfiguration.ClaimsProviderName}\"", ClaimsProviderLogging.TraceCategory.Configuration, ex);

            }

        });

    }

    public override void FeatureUninstalling(SPFeatureReceiverProperties properties)

    {

        SPSecurity.RunWithElevatedPrivileges(delegate ()

        {

            try

            {

                ClaimsProviderLogging.Log($"[{CustomConfiguration.ClaimsProviderName}] Uninstalling farm-scoped feature for claims provider \"{CustomConfiguration.ClaimsProviderName}\": Deleting configuration from the farm", TraceSeverity.High, EventSeverity.Information, ClaimsProviderLogging.TraceCategory.Configuration);

                AzureCPConfig.DeleteConfiguration(CustomConfiguration.CONFIG_NAME);

                ClaimsProviderLogging.Unregister();

            }

            catch (Exception ex)

            {

                ClaimsProviderLogging.LogException(CustomConfiguration.ClaimsProviderName, $"deactivating farm-scoped feature for claims provider \"{CustomConfiguration.ClaimsProviderName}\"", ClaimsProviderLogging.TraceCategory.Configuration, ex);

            }

        });

    }

    public override void FeatureDeactivating(SPFeatureReceiverProperties properties)

    {

        SPSecurity.RunWithElevatedPrivileges(delegate ()

        {

            try

            {

                ClaimsProviderLogging.Log($"[{CustomConfiguration.ClaimsProviderName}] Deactivating farm-scoped feature for claims provider \"{CustomConfiguration.ClaimsProviderName}\": Removing claims provider from the farm (but not its configuration)", TraceSeverity.High, EventSeverity.Information, ClaimsProviderLogging.TraceCategory.Configuration);

                base.RemoveClaimProvider(CustomConfiguration.ClaimsProviderName);

            }

            catch (Exception ex)

            {

                ClaimsProviderLogging.LogException(CustomConfiguration.ClaimsProviderName, $"deactivating farm-scoped feature for claims provider \"{CustomConfiguration.ClaimsProviderName}\"", ClaimsProviderLogging.TraceCategory.Configuration, ex);

            }

        });

    }

}

}

AzureMCP.cs

namespace azurecp.AzureMCP

{

public class AzureMCP : azurecp.AzureCP

{

    /// <summary>

    /// _ProviderInternalName must be redefined this way and value must be unique

    /// This value must be set in (Get-SPTrustedIdentityTokenIssuer).ClaimProviderName property

    /// </summary>

    public new const string _ProviderInternalName = "AzureMCP";

    /// <summary>

    /// Do not remove or change this property

    /// </summary>

    public override string ProviderInternalName { get; } //CustomConfiguration.ClaimsProviderName; ///_ProviderInternalName;

    /// <summary>

    /// Override this property to set the name of the custom persisted object that holds the custom configuration

    /// </summary>

    public override string PersistedObjectName { get; } // => CustomConfiguration.CONFIG_NAME;

    /// <summary>

    /// This constructor must exist

    /// </summary>

    /// <param name="displayName"></param>

    public AzureMCP(string configName, string displayName) : base(displayName)

    {

        ProviderInternalName = displayName;

        PersistedObjectName = configName;

    }

    /// <summary>

    /// Uncomment this method ONLY if you don't want to store the configuration in config database, or/and if you don't want to use AzureCP admin pages

    /// The configuration returned by this method will never be saved in config database and will always override configuration stored in config database (if there is one)

    /// </summary>

    /// <param name="context"></param>

    /// <param name="entityTypes"></param>

    /// <param name="persistedObjectName"></param>

    /// <param name="spTrustName"></param>

    /// <returns></returns>

    //protected override IAzureCPConfiguration GetConfiguration(Uri context, string[] entityTypes, string persistedObjectName, string spTrustName)

    //{

    //    IAzureCPConfiguration config = AzureCPConfig.ReturnDefaultConfiguration(SPTrust.Name);

    //    AzureTenant tenant = new AzureTenant();

    //    tenant.TenantName = "TENANT.onMicrosoft.com";

    //    tenant.ClientId = "ClientId";

    //    tenant.ClientSecret = "SECRET";

    //    config.AzureTenants = new List<AzureTenant>();

    //    config.AzureTenants.Add(tenant);

    //    return config;

    //}

}

}

CustomConfiguration.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace azurecp.AzureMCP

{

public class CustomConfiguration

{

    public string CONFIG_NAME { get; private set; }

    public string CONFIG_ID { get; private set; }

    public Type AZURECPTYPE { get; private set; }

    public string ClaimsProviderName { get; private set; }

    public CustomConfiguration(string parameter)

    {

        switch (parameter)

        {

            case "1":

                CONFIG_NAME = "CP01Configuration";

                CONFIG_ID = "72A744B5-A4C1-4F9B-A2DE-CE09451D06F0";

                AZURECPTYPE = typeof(AzureMCP);

                ClaimsProviderName = "AzureMCP-CP01";

                break;

            case "2":

                CONFIG_NAME = "CP02Configuration";

                CONFIG_ID = "593E30C0-5FCF-4DB2-BAB6-1058F1B9EE2F";

                AZURECPTYPE = typeof(AzureMCP);

                ClaimsProviderName = "AzureMCP-CP02";

                break;

            case "3":

                CONFIG_NAME = "CP03Configuration";

                CONFIG_ID = "50D9CC24-5235-4A5A-98E9-9E8DE1FC9287";

                AZURECPTYPE = typeof(AzureMCP);

                ClaimsProviderName = "AzureMCP-CP03";

                break;

            case "4":

                CONFIG_NAME = "CP04Configuration";

                CONFIG_ID = "FEC8CDCC-DDE1-4B88-9F37-A74E7C1A1AAD";

                AZURECPTYPE = typeof(AzureMCP);

                ClaimsProviderName = "AzureMCP-CP04";

                break;

            case "5":

                CONFIG_NAME = "CP05Configuration";

                CONFIG_ID = "4A88D447-C8A1-4BE0-849B-9515FCDC4443";

                AZURECPTYPE = typeof(AzureMCP);

                ClaimsProviderName = "AzureMCP-CP05";

                break;

            case "6":

                CONFIG_NAME = "CP06Configuration";

                CONFIG_ID = "B492D101-72FC-4C77-B5C5-DEBE63EE5CA4";

                AZURECPTYPE = typeof(AzureMCP);

                ClaimsProviderName = "AzureMCP-CP06";

                break;

            case "7":

                CONFIG_NAME = "CP07Configuration";

                CONFIG_ID = "9A25F5C7-CC0A-4E68-B9DA-B0CDCBAD9D98";

                AZURECPTYPE = typeof(AzureMCP);

                ClaimsProviderName = "AzureMCP-CP07";

                break;

            default:

                throw new ArgumentException("Invalid parameter value");

        }

    }

}

}

From: Yvan Duhamel @.> Sent: Tuesday, May 2, 2023 4:55 AM To: Yvand/AzureCP @.> Cc: vargasfe @.>; Mention @.> Subject: Re: [Yvand/AzureCP] Developer samples available? (#15)

@vargasfe https://github.com/vargasfe what you plan to do is probably not a good idea: You would create multiple wsp packages which all deploy the same assemblies in SharePoint farm. This is opening a door to big problems each time you want to update a package.

Instead, you could group all your custom claims providers in a single package. A claims provider is mostly defined by its farm feature, you will find one in the package that you can duplicate as many times as needed.

1 thing you should keep in mind: For the same reason I mentioned above, never deploy the standard AzureCP.wsp in the same farm as your custom package (since they share common assemblies).

With all that said, I am quite curious to understand why you want so many different versions of AzureCP, it does not look like the most optimized approach.

— Reply to this email directly, https://github.com/Yvand/AzureCP/issues/15#issuecomment-1531113493 view it on GitHub, or https://github.com/notifications/unsubscribe-auth/ACUI3YEUSAUORZUIYTZW273XEDDUVANCNFSM4EXHTNLQ unsubscribe. You are receiving this because you were mentioned. https://github.com/notifications/beacon/ACUI3YHEJ3WHGXPBFIUGW6LXEDDUVA5CNFSM4EXHTNL2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOLNBPAFI.gif Message ID: < @.> @.>

[Yvand]

A claims provider is defined by:

• A farm feature
• A class that inherits SPClaimProvider. AzureCP inherits SPClaimProvider, so any class that inherits AzureCP is de facto a claims provider

You need to have both for each unique claims provider you want to create. Then, each class can define its own configuration according to your needs.

Does that make sense?

[vargasfe]

Hello Yvan,

Yes, what you say makes sense to me. The problem is I am not competent enough to implement.

Can you provide me with a custom solution with 7 features, each a claim provider with its own name and configuration?

We can discuss compensation for your efforts.

Please let me know. This is a high priority for me.

Fernando

From: Yvan Duhamel @.> Sent: Wednesday, May 10, 2023 6:37 AM To: Yvand/AzureCP @.> Cc: vargasfe @.>; Mention @.> Subject: Re: [Yvand/AzureCP] Developer samples available? (#15)

A claims provider is defined by:

• A farm feature
• A class that inherits SPClaimProvider. AzureCP inherits SPClaimProvider, so any class that inherits AzureCP is de facto a claims provider

You need to have both for each unique claims provider you want to create. Then, each class can define its own configuration according to your needs.

Does that make sense?

— Reply to this email directly, view it on GitHub https://github.com/Yvand/AzureCP/issues/15#issuecomment-1541899369 , or unsubscribe https://github.com/notifications/unsubscribe-auth/ACUI3YGVAYQLFKUR3BNTL6DXFNVTJANCNFSM4EXHTNLQ . You are receiving this because you were mentioned. https://github.com/notifications/beacon/ACUI3YHOIRFAG5K77RBWV4DXFNVTJA5CNFSM4EXHTNL2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOLPTYI2I.gif Message ID: @. @.> >

[vargasfe]

Hello Yvan, It turned out I was competent enough to create the package I wanted with 7 CPs and their individual configurations. Thanks for AzureCP and the Custom template.

If someone would like to have this let me know and I'll make it available.

[Yvand]

This is very good news, sorry I wasn't responsive, I was on vacation

[vargasfe]

Hello Yvan, with the original AzureCP, i am able to configure tenants programmatically like this: Add-Type -AssemblyName "AzureCP, Version=1.0.0.0, Culture=neutral, PublicKeyToken=65dc6b5903b51636" $config = [azurecp.AzureCPConfig]::GetConfiguration("AzureCPConfig")

Add a new Azure AD tenant

$newAADTenant = New-Object azurecp.AzureTenant $newAADTenant.Name = $tenantName $newAADTenant.CloudInstance = $CloudInstance $newAADTenant.ApplicationId = $applicationID $newAADTenant.ApplicationSecret = $applicationSecret $config.AzureTenants.Add($newAADTenant) $config.Update()

However, this doesn't work with the AzureCP_Custom. What would be the right way? Also, with the AzureCP_Custom, the persisted configuration object seems to set a property for the Authentication Provider Name, which once set cannot be changed. HOw to fix that?

Thanks, Fernando

[Yvand]

@vargasfe that is probably because you created the configuration with a different name, for example "AzureCPConfig_Custom" So you need to pass that name to [azurecp.AzureCPConfig]::GetConfiguration("<AzureCP Config Name>")

[vargasfe]

Yvan,

I used the same configuration name I set in the code.

The [azurecp.AzureCPConfig]::GetConfiguration() method doesn’t return anything. I’d expect it to return all the configuration objects.

Configuring the tenant through the UI works fine however.

From: Yvan Duhamel @.> Sent: Tuesday, June 20, 2023 11:34 AM To: Yvand/AzureCP @.> Cc: vargasfe @.>; Mention @.> Subject: Re: [Yvand/AzureCP] Developer samples available? (#15)

@vargasfe https://github.com/vargasfe that is probably because you created the configuration with a different name, for example "AzureCPConfig_Custom" So you need to pass that name to [azurecp.AzureCPConfig]::GetConfiguration("")

— Reply to this email directly, view it on GitHub https://github.com/Yvand/AzureCP/issues/15#issuecomment-1599031442 , or unsubscribe https://github.com/notifications/unsubscribe-auth/ACUI3YC6ZEJLQOCK3G722Q3XMG7GFANCNFSM4EXHTNLQ . You are receiving this because you were mentioned.Message ID: @.***>

[Yvand]

@vargasfe if the config pages can find it, then it should be also possible in PowerShell. Did you notice that in the sample project the config name is hardcoded in CustomConfiguration.CONFIG_NAME : MyCustomAzureCPConfig ?

Did you try this: [azurecp.AzureCPConfig]::GetConfiguration("MyCustomAzureCPConfig")

[vargasfe]

Yvan,

That is exactly what I am doing.

Once the tenant is added through the UI, then I can get the configuration by name in PowerShell.

Calling azurecp.AzureCPConfig::GetConfiguration() still doesn’t return anything, even after a tenant is added by the UI.

I also tried using the GUID instead of the name but that doesn’t work either.

I checked the database and the persisted object “AzureCP_CP02_Config” doesn’t exist which makes sense as to why PowerShell doesn’t return it.

So when does the object get created?

F.

From: Yvan Duhamel @.> Sent: Friday, June 23, 2023 8:29 AM To: Yvand/AzureCP @.> Cc: vargasfe @.>; Mention @.> Subject: Re: [Yvand/AzureCP] Developer samples available? (#15)

@vargasfe https://github.com/vargasfe if the config pages can find it, then it should be also possible in PowerShell. Did you notice that in the sample project the config name is hardcoded in CustomConfiguration.CONFIG_NAME : MyCustomAzureCPConfig ?

Did you try this:

— Reply to this email directly, view it on GitHub https://github.com/Yvand/AzureCP/issues/15#issuecomment-1604214334 , or unsubscribe https://github.com/notifications/unsubscribe-auth/ACUI3YCI3JLEVUCWKZVDAXTXMWD2PANCNFSM4EXHTNLQ . You are receiving this because you were mentioned. https://github.com/notifications/beacon/ACUI3YCTYA6XICVI2656ZLLXMWD2PA5CNFSM4EXHTNL2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOL6PF4PQ.gif Message ID: @.***>

[Yvand]

@vargasfe the object is created as soon as you visit the AzureCP configuration page. You can find it by running this SQL command on SPS config db:

SELECT *, convert (xml, [Properties]) as PropertiesInXML FROM [SPS_Config].[dbo].[Objects] WHERE Name = '<AzureCPConfig name>'

Or:

SELECT *, convert (xml, [Properties]) as PropertiesInXML FROM [SPS_Config].[dbo].[Objects] WHERE Id LIKE '<AzureCPConfig ID>'

Are you able to find it?

[vargasfe]

Hello Yvan,

I am still using AzureCP, the July 2023 release, and I am not getting Azure groups in people picker.

The configuration is set to return groups (augmentation is set to true) and security groups only is blank.

If I run the graph requests directly I get all users and I get groups so it’s not a permission issue.

Your suggestions on troubleshooting this are greatly appreciated.

Fernando

[Yvand]

Hello Fernando, it's been a while since I looked at AzureCP. Can you set the AzureCP logs in verbose, and copy the output of what is recorded when you repro the issue?

"AzureCP:*"| Set-SPLogLevel -TraceSeverity Verbose