public void NamespaceBYOKCreateGetUpdateDelete()
        {
            using (MockContext context = MockContext.Start(this.GetType()))
            {
                InitializeClients(context);

                var location = "West US 2";

                var resourceGroup = string.Empty;

                var resourceGroupCluster = EventHubManagementHelper.ResourceGroupCluster;

                var testClusterName = "PMTestCluster1";

                var keyVaultName = "SDKTestingKey1";
                var KeyName      = "sdktestingkey11";

                if (string.IsNullOrWhiteSpace(resourceGroup))
                {
                    resourceGroup = TestUtilities.GenerateName(EventHubManagementHelper.ResourceGroupPrefix);
                    this.ResourceManagementClient.TryRegisterResourceGroup(location, resourceGroup);
                }

                var namespaceName = TestUtilities.GenerateName(EventHubManagementHelper.NamespacePrefix);

                try
                {
                    Cluster getClusterResponse = EventHubManagementClient.Clusters.Get(resourceGroupCluster, testClusterName);

                    var checkNameAvailable = EventHubManagementClient.Namespaces.CheckNameAvailability(namespaceName);

                    var createNamespaceResponse = this.EventHubManagementClient.Namespaces.CreateOrUpdate(resourceGroupCluster, namespaceName,
                                                                                                          new EHNamespace()
                    {
                        Location = location,
                        Sku      = new Microsoft.Azure.Management.EventHub.Models.Sku
                        {
                            Name = Microsoft.Azure.Management.EventHub.Models.SkuName.Standard,
                            Tier = SkuTier.Standard
                        },
                        Tags = new Dictionary <string, string>()
                        {
                            { "tag1", "value1" },
                            { "tag2", "value2" }
                        },
                        IsAutoInflateEnabled   = false,
                        MaximumThroughputUnits = 0,
                        ClusterArmId           = getClusterResponse.Id,
                        Identity = new Identity()
                        {
                            Type = ManagedServiceIdentityType.SystemAssigned
                        }
                    });

                    Assert.NotNull(createNamespaceResponse);
                    Assert.Equal(namespaceName, createNamespaceResponse.Name);
                    Assert.Equal(getClusterResponse.Id, createNamespaceResponse.ClusterArmId);
                    Assert.False(createNamespaceResponse.IsAutoInflateEnabled);
                    Assert.Equal(0, createNamespaceResponse.MaximumThroughputUnits);

                    TestUtilities.Wait(TimeSpan.FromSeconds(5));

                    // Create KeyVault
                    Microsoft.Azure.Management.KeyVault.Models.VaultCreateOrUpdateParameters vaultparams = new Microsoft.Azure.Management.KeyVault.Models.VaultCreateOrUpdateParameters();
                    var accesPolicies = new Microsoft.Azure.Management.KeyVault.Models.AccessPolicyEntry()
                    {
                        ObjectId    = createNamespaceResponse.Identity.PrincipalId,
                        TenantId    = Guid.Parse(createNamespaceResponse.Identity.TenantId),
                        Permissions = new Microsoft.Azure.Management.KeyVault.Models.Permissions()
                        {
                            Keys = new List <string> {
                                "get", "wrapKey", "unwrapKey"
                            }
                        }
                    };


                    Vault getVaultRsponse = KeyVaultManagementClient.Vaults.Get(resourceGroupCluster, keyVaultName);

                    vaultparams = new VaultCreateOrUpdateParameters(getVaultRsponse.Location, getVaultRsponse.Properties);

                    vaultparams.Properties.AccessPolicies.Add(accesPolicies);

                    var updateVault = KeyVaultManagementClient.Vaults.CreateOrUpdate(resourceGroupCluster, keyVaultName, vaultparams);

                    TestUtilities.Wait(TimeSpan.FromSeconds(5));

                    // Encrypt data in Event Hub namespace Customer managed key from keyvault

                    var getNamespaceResponse = EventHubManagementClient.Namespaces.Get(resourceGroupCluster, namespaceName);

                    getNamespaceResponse.Encryption = new Encryption()
                    {
                        KeySource          = KeySource.MicrosoftKeyVault,
                        KeyVaultProperties = new[] {
                            new KeyVaultProperties()
                            {
                                KeyName     = KeyName,
                                KeyVaultUri = updateVault.Properties.VaultUri,
                                KeyVersion  = ""
                            }
                        }
                    };

                    var updateNamespaceResponse = this.EventHubManagementClient.Namespaces.CreateOrUpdate(resourceGroupCluster, namespaceName, getNamespaceResponse);

                    Vault getVaultRsponse1 = KeyVaultManagementClient.Vaults.Get(resourceGroupCluster, keyVaultName);
                    vaultparams = new VaultCreateOrUpdateParameters(getVaultRsponse.Location, getVaultRsponse.Properties);
                    vaultparams.Properties.AccessPolicies.Remove(accesPolicies);
                    var updateVault1 = KeyVaultManagementClient.Vaults.CreateOrUpdate(resourceGroupCluster, keyVaultName, vaultparams);
                    TestUtilities.Wait(TimeSpan.FromSeconds(5));
                    //Delete the namesapce within the cluster
                }
                finally
                {
                    //Delete Resource Group
                    this.EventHubManagementClient.Namespaces.DeleteAsync(resourceGroupCluster, namespaceName, default(CancellationToken)).ConfigureAwait(false);
                    Console.WriteLine("End of EH2018 Namespace CRUD IPFilter Rules test");
                }
            }
        }
コード例 #2
0
        public void NamespaceBYOKCreateGetUpdateDelete()
        {
            using (MockContext context = MockContext.Start(this.GetType()))
            {
                InitializeClients(context);

                var location = "West US 2";

                var resourceGroup = string.Empty;

                var keyVaultName = "SDKTestingKey1";
                var KeyName      = "sdktestingkey11";
                var KeyName2     = "sdktestingkey12";
                var KeyName3     = "sdktestingkey13";

                var resourceGroupCluster = EventHubManagementHelper.ResourceGroupCluster;

                var identityName1 = TestUtilities.GenerateName(EventHubManagementHelper.IdentityPrefix);
                var identityName2 = TestUtilities.GenerateName(EventHubManagementHelper.IdentityPrefix);

                if (string.IsNullOrWhiteSpace(resourceGroup))
                {
                    resourceGroup = TestUtilities.GenerateName(EventHubManagementHelper.ResourceGroupPrefix);
                    this.ResourceManagementClient.TryRegisterResourceGroup(location, resourceGroup);
                }

                var namespaceName  = TestUtilities.GenerateName(EventHubManagementHelper.NamespacePrefix);
                var namespaceName2 = TestUtilities.GenerateName(EventHubManagementHelper.NamespacePrefix);

                try
                {
                    var checkNameAvailable = EventHubManagementClient.Namespaces.CheckNameAvailability(namespaceName);

                    //Create Namespace with System Assigned Identity
                    //----------------------------------------------------
                    var createNamespaceResponse = this.EventHubManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName,
                                                                                                          new EHNamespace()
                    {
                        Location = location,
                        Sku      = new Microsoft.Azure.Management.EventHub.Models.Sku
                        {
                            Name = Microsoft.Azure.Management.EventHub.Models.SkuName.Premium,
                            Tier = SkuTier.Premium
                        },
                        Tags = new Dictionary <string, string>()
                        {
                            { "tag1", "value1" },
                            { "tag2", "value2" }
                        },
                        IsAutoInflateEnabled   = false,
                        MaximumThroughputUnits = 0,
                        Identity = new Identity()
                        {
                            Type = ManagedServiceIdentityType.SystemAssigned
                        }
                    });

                    Assert.NotNull(createNamespaceResponse);
                    Assert.Equal(namespaceName, createNamespaceResponse.Name);
                    Assert.False(createNamespaceResponse.IsAutoInflateEnabled);
                    Assert.Equal(0, createNamespaceResponse.MaximumThroughputUnits);
                    Assert.Equal(ManagedServiceIdentityType.SystemAssigned, createNamespaceResponse.Identity.Type);
                    //----------------------------------------------------------------------

                    TestUtilities.Wait(TimeSpan.FromSeconds(5));

                    //Remove System Assigned Identity from namespace
                    //-----------------------------------------------
                    createNamespaceResponse.Identity = new Identity()
                    {
                        Type = ManagedServiceIdentityType.None
                    };

                    createNamespaceResponse = EventHubManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName, createNamespaceResponse);

                    Assert.NotNull(createNamespaceResponse);
                    Assert.Equal(namespaceName, createNamespaceResponse.Name);
                    Assert.False(createNamespaceResponse.IsAutoInflateEnabled);
                    Assert.Equal(0, createNamespaceResponse.MaximumThroughputUnits);
                    Assert.Null(createNamespaceResponse.Identity);
                    //------------------------------------------------

                    //ReEnable System assigned identity and later enable encryption
                    //--------------------------------------------------
                    createNamespaceResponse.Identity = new Identity()
                    {
                        Type = ManagedServiceIdentityType.SystemAssigned
                    };

                    createNamespaceResponse = EventHubManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName, createNamespaceResponse);

                    Assert.NotNull(createNamespaceResponse);
                    Assert.Equal(namespaceName, createNamespaceResponse.Name);
                    Assert.False(createNamespaceResponse.IsAutoInflateEnabled);
                    Assert.Equal(0, createNamespaceResponse.MaximumThroughputUnits);
                    Assert.Equal(ManagedServiceIdentityType.SystemAssigned, createNamespaceResponse.Identity.Type);
                    //--------------------------------------------------

                    //Give Key Vault Permissions to namespace to set system assigned encryption
                    //---------------------------------------------------
                    Microsoft.Azure.Management.KeyVault.Models.VaultCreateOrUpdateParameters vaultparams = new Microsoft.Azure.Management.KeyVault.Models.VaultCreateOrUpdateParameters();

                    var accesPolicies = new Microsoft.Azure.Management.KeyVault.Models.AccessPolicyEntry()
                    {
                        ObjectId    = createNamespaceResponse.Identity.PrincipalId,
                        TenantId    = Guid.Parse(createNamespaceResponse.Identity.TenantId),
                        Permissions = new Microsoft.Azure.Management.KeyVault.Models.Permissions()
                        {
                            Keys = new List <string> {
                                "get", "wrapKey", "unwrapKey"
                            }
                        }
                    };


                    Vault getVaultRsponse = KeyVaultManagementClient.Vaults.Get(resourceGroupCluster, keyVaultName);

                    vaultparams = new VaultCreateOrUpdateParameters(getVaultRsponse.Location, getVaultRsponse.Properties);

                    vaultparams.Properties.AccessPolicies.Add(accesPolicies);

                    var updateVault = KeyVaultManagementClient.Vaults.CreateOrUpdate(resourceGroupCluster, keyVaultName, vaultparams);

                    TestUtilities.Wait(TimeSpan.FromSeconds(5));

                    // Encrypt data in Event Hub namespace Customer managed key from keyvault

                    var getNamespaceResponse = EventHubManagementClient.Namespaces.Get(resourceGroup, namespaceName);

                    getNamespaceResponse.Encryption = new Encryption()
                    {
                        KeySource          = KeySource.MicrosoftKeyVault,
                        KeyVaultProperties = new[] {
                            new KeyVaultProperties()
                            {
                                KeyName     = KeyName,
                                KeyVaultUri = updateVault.Properties.VaultUri,
                                KeyVersion  = ""
                            }
                        }
                    };

                    var updateNamespaceResponse = this.EventHubManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName, getNamespaceResponse);

                    Assert.Equal(1, updateNamespaceResponse.Encryption.KeyVaultProperties.Count);
                    Assert.Equal(KeyName, updateNamespaceResponse.Encryption.KeyVaultProperties[0].KeyName);
                    Assert.Equal(updateVault.Properties.VaultUri, updateNamespaceResponse.Encryption.KeyVaultProperties[0].KeyVaultUri + "/");
                    //-------------------------------------------------------------

                    Vault getVaultRsponse1 = KeyVaultManagementClient.Vaults.Get(resourceGroupCluster, keyVaultName);
                    vaultparams = new VaultCreateOrUpdateParameters(getVaultRsponse.Location, getVaultRsponse.Properties);
                    vaultparams.Properties.AccessPolicies.Remove(accesPolicies);
                    var updateVault1 = KeyVaultManagementClient.Vaults.CreateOrUpdate(resourceGroupCluster, keyVaultName, vaultparams);
                    TestUtilities.Wait(TimeSpan.FromSeconds(5));


                    //Create User Assigned Identities and give permissions to access keyvault
                    //----------------------------------------------------------------
                    Microsoft.Azure.Management.ManagedServiceIdentity.Models.Identity identity1 = new Microsoft.Azure.Management.ManagedServiceIdentity.Models.Identity()
                    {
                        Location = "westus"
                    };

                    Microsoft.Azure.Management.ManagedServiceIdentity.Models.Identity identity2 = new Microsoft.Azure.Management.ManagedServiceIdentity.Models.Identity()
                    {
                        Location = "westus"
                    };

                    var userAssignedIdentity1 = IdentityManagementClient.UserAssignedIdentities.CreateOrUpdate(resourceGroup, identityName1, identity1);

                    var userAssignedIdentity2 = IdentityManagementClient.UserAssignedIdentities.CreateOrUpdate(resourceGroup, identityName2, identity2);

                    var accessPolicies = new Microsoft.Azure.Management.KeyVault.Models.AccessPolicyEntry()
                    {
                        ObjectId    = userAssignedIdentity1.PrincipalId.ToString(),
                        TenantId    = (Guid)userAssignedIdentity1.TenantId,
                        Permissions = new Microsoft.Azure.Management.KeyVault.Models.Permissions()
                        {
                            Keys = new List <string> {
                                "get", "wrapKey", "unwrapKey"
                            }
                        }
                    };

                    var accessPolicies2 = new Microsoft.Azure.Management.KeyVault.Models.AccessPolicyEntry()
                    {
                        ObjectId    = userAssignedIdentity2.PrincipalId.ToString(),
                        TenantId    = (Guid)userAssignedIdentity2.TenantId,
                        Permissions = new Microsoft.Azure.Management.KeyVault.Models.Permissions()
                        {
                            Keys = new List <string> {
                                "get", "wrapKey", "unwrapKey"
                            }
                        }
                    };

                    getVaultRsponse = KeyVaultManagementClient.Vaults.Get(resourceGroupCluster, keyVaultName);

                    vaultparams = new VaultCreateOrUpdateParameters(getVaultRsponse.Location, getVaultRsponse.Properties);

                    vaultparams.Properties.AccessPolicies.Add(accessPolicies);
                    vaultparams.Properties.AccessPolicies.Add(accessPolicies2);

                    updateVault = KeyVaultManagementClient.Vaults.CreateOrUpdate(resourceGroupCluster, keyVaultName, vaultparams);
                    //--------------------------------------------------------

                    TestUtilities.Wait(TimeSpan.FromSeconds(5));

                    //Enable User Assigned Identity Encryption
                    //---------------------------------------------
                    createNamespaceResponse = this.EventHubManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName2,
                                                                                                      new EHNamespace()
                    {
                        Location = location,
                        Sku      = new Microsoft.Azure.Management.EventHub.Models.Sku
                        {
                            Name = Microsoft.Azure.Management.EventHub.Models.SkuName.Premium,
                            Tier = SkuTier.Premium
                        },
                        Identity = new Identity()
                        {
                            Type = ManagedServiceIdentityType.UserAssigned,
                            UserAssignedIdentities = new Dictionary <string, UserAssignedIdentity>()
                            {
                                { userAssignedIdentity1.Id, new UserAssignedIdentity() },
                                { userAssignedIdentity2.Id, new UserAssignedIdentity() }
                            },
                        },
                        Encryption = new Encryption()
                        {
                            KeySource          = KeySource.MicrosoftKeyVault,
                            KeyVaultProperties = new List <KeyVaultProperties> {
                                new KeyVaultProperties()
                                {
                                    KeyName     = KeyName2,
                                    KeyVaultUri = updateVault.Properties.VaultUri,
                                    KeyVersion  = "",
                                    Identity    = new UserAssignedIdentityProperties()
                                    {
                                        UserAssignedIdentity = userAssignedIdentity1.Id
                                    }
                                },
                                new KeyVaultProperties()
                                {
                                    KeyName     = KeyName3,
                                    KeyVaultUri = updateVault.Properties.VaultUri,
                                    KeyVersion  = "",
                                    Identity    = new UserAssignedIdentityProperties()
                                    {
                                        UserAssignedIdentity = userAssignedIdentity1.Id
                                    }
                                }
                            }
                        }
                    }
                                                                                                      );

                    Assert.Equal(ManagedServiceIdentityType.UserAssigned, createNamespaceResponse.Identity.Type);
                    Assert.Equal(2, createNamespaceResponse.Encryption.KeyVaultProperties.Count);
                    Assert.Equal(KeyName2, createNamespaceResponse.Encryption.KeyVaultProperties[0].KeyName);
                    Assert.Equal(KeyName3, createNamespaceResponse.Encryption.KeyVaultProperties[1].KeyName);
                    Assert.Equal(updateVault.Properties.VaultUri, createNamespaceResponse.Encryption.KeyVaultProperties[0].KeyVaultUri + "/");
                    Assert.Equal(updateVault.Properties.VaultUri, createNamespaceResponse.Encryption.KeyVaultProperties[1].KeyVaultUri + "/");
                    Assert.Equal(userAssignedIdentity1.Id, createNamespaceResponse.Encryption.KeyVaultProperties[0].Identity.UserAssignedIdentity);
                    Assert.Equal(userAssignedIdentity1.Id, createNamespaceResponse.Encryption.KeyVaultProperties[1].Identity.UserAssignedIdentity);
                    Assert.Equal(2, createNamespaceResponse.Identity.UserAssignedIdentities.Count);
                    //-------------------------------------------------------------------------------------

                    //Test if identity can be set to System and User assigned.
                    //---------------------------------------------------------------------------------
                    createNamespaceResponse.Identity.Type = ManagedServiceIdentityType.SystemAssignedUserAssigned;

                    createNamespaceResponse = EventHubManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName2, createNamespaceResponse);

                    Assert.Equal(ManagedServiceIdentityType.SystemAssignedUserAssigned, createNamespaceResponse.Identity.Type);
                    Assert.Equal(2, createNamespaceResponse.Encryption.KeyVaultProperties.Count);
                    Assert.Equal(KeyName2, createNamespaceResponse.Encryption.KeyVaultProperties[0].KeyName);
                    Assert.Equal(KeyName3, createNamespaceResponse.Encryption.KeyVaultProperties[1].KeyName);
                    Assert.Equal(updateVault.Properties.VaultUri, createNamespaceResponse.Encryption.KeyVaultProperties[0].KeyVaultUri + "/");
                    Assert.Equal(updateVault.Properties.VaultUri, createNamespaceResponse.Encryption.KeyVaultProperties[1].KeyVaultUri + "/");
                    Assert.Equal(userAssignedIdentity1.Id, createNamespaceResponse.Encryption.KeyVaultProperties[0].Identity.UserAssignedIdentity);
                    Assert.Equal(userAssignedIdentity1.Id, createNamespaceResponse.Encryption.KeyVaultProperties[1].Identity.UserAssignedIdentity);
                    Assert.Equal(2, createNamespaceResponse.Identity.UserAssignedIdentities.Count);
                    //----------------------------------------------------------------------------------
                }
                finally
                {
                    this.EventHubManagementClient.Namespaces.DeleteAsync(resourceGroup, namespaceName, default(CancellationToken)).ConfigureAwait(false);
                    this.EventHubManagementClient.Namespaces.DeleteAsync(resourceGroup, namespaceName2, default(CancellationToken)).ConfigureAwait(false);
                    //Delete Resource Group
                    this.ResourceManagementClient.ResourceGroups.DeleteWithHttpMessagesAsync(resourceGroup, null, default(CancellationToken)).ConfigureAwait(false);
                    Console.WriteLine("End of EH2018 Namespace CRUD IPFilter Rules test");
                }
            }
        }
コード例 #3
0
        public void NamespaceBYOKCreateGetUpdateDelete()
        {
            using (MockContext context = MockContext.Start(this.GetType()))
            {
                InitializeClients(context);

                var location = this.ResourceManagementClient.GetLocationFromProvider();

                var resourceGroupCluster = ServiceBusManagementHelper.ResourceGroupCluster;

                //var resourceGroup = this.ResourceManagementClient.TryGetResourceGroup(location);
                //if (string.IsNullOrWhiteSpace(resourceGroup))
                //{
                //    resourceGroup = TestUtilities.GenerateName(ServiceBusManagementHelper.ResourceGroupPrefix);
                //    this.ResourceManagementClient.TryRegisterResourceGroup(location, resourceGroup);
                //}

                var keyVaultName = "SDKTestingKey1";
                var KeyName      = "sdktestingkey11";

                // Create Namespace
                var namespaceName = TestUtilities.GenerateName(ServiceBusManagementHelper.NamespacePrefix);

                //Check namespace name available
                var checknamespaceavailable = ServiceBusManagementClient.Namespaces.CheckNameAvailabilityMethod(new CheckNameAvailability()
                {
                    Name = namespaceName
                });

                var createNamespaceResponse = this.ServiceBusManagementClient.Namespaces.CreateOrUpdate(resourceGroupCluster, namespaceName,
                                                                                                        new SBNamespace()
                {
                    Location = location,
                    Sku      = new SBSku
                    {
                        Name = SkuName.Premium,
                        Tier = SkuTier.Premium
                    },
                    Tags = new Dictionary <string, string>()
                    {
                        { "tag1", "value1" },
                        { "tag2", "value2" }
                    },
                    Identity = new Identity()
                    {
                        Type = ManagedServiceIdentityType.SystemAssigned
                    }
                });

                Assert.NotNull(createNamespaceResponse);
                Assert.Equal(createNamespaceResponse.Name, namespaceName);

                TestUtilities.Wait(TimeSpan.FromSeconds(5));

                // Create KeyVault
                Microsoft.Azure.Management.KeyVault.Models.VaultCreateOrUpdateParameters vaultparams = new Microsoft.Azure.Management.KeyVault.Models.VaultCreateOrUpdateParameters();
                var accesPolicies = new Microsoft.Azure.Management.KeyVault.Models.AccessPolicyEntry()
                {
                    ObjectId    = createNamespaceResponse.Identity.PrincipalId,
                    TenantId    = Guid.Parse(createNamespaceResponse.Identity.TenantId),
                    Permissions = new Microsoft.Azure.Management.KeyVault.Models.Permissions()
                    {
                        Keys = new List <string> {
                            "get", "wrapKey", "unwrapKey"
                        }
                    }
                };

                Vault getVaultRsponse = KeyVaultManagementClient.Vaults.Get(resourceGroupCluster, keyVaultName);

                vaultparams = new VaultCreateOrUpdateParameters(getVaultRsponse.Location, getVaultRsponse.Properties);

                vaultparams.Properties.AccessPolicies.Add(accesPolicies);

                var updateVault = KeyVaultManagementClient.Vaults.CreateOrUpdate(resourceGroupCluster, keyVaultName, vaultparams);

                TestUtilities.Wait(TimeSpan.FromSeconds(5));

                // Encrypt data in Event Hub namespace Customer managed key from keyvault

                var getNamespaceResponse = ServiceBusManagementClient.Namespaces.Get(resourceGroupCluster, namespaceName);

                getNamespaceResponse.Encryption = new Encryption()
                {
                    KeySource          = KeySource.MicrosoftKeyVault,
                    KeyVaultProperties = new[] {
                        new KeyVaultProperties()
                        {
                            KeyName     = KeyName,
                            KeyVaultUri = updateVault.Properties.VaultUri,
                            KeyVersion  = ""
                        }
                    }
                };

                var updateNamespaceResponse = this.ServiceBusManagementClient.Namespaces.CreateOrUpdate(resourceGroupCluster, namespaceName, getNamespaceResponse);

                Vault getVaultRsponse1 = KeyVaultManagementClient.Vaults.Get(resourceGroupCluster, keyVaultName);
                vaultparams = new VaultCreateOrUpdateParameters(getVaultRsponse.Location, getVaultRsponse.Properties);
                vaultparams.Properties.AccessPolicies.Remove(accesPolicies);
                var updateVault1 = KeyVaultManagementClient.Vaults.CreateOrUpdate(resourceGroupCluster, keyVaultName, vaultparams);
                TestUtilities.Wait(TimeSpan.FromSeconds(5));
                //Delete the namesapce within the cluster

                // Delete namespace
                ServiceBusManagementClient.Namespaces.DeleteWithHttpMessagesAsync(resourceGroupCluster, namespaceName, null, new CancellationToken()).ConfigureAwait(false);
            }
        }