public async Task KeyVaultManagementVaultTestCompoundIdentityAccessControlPolicy()
{
AccessPolicy.ApplicationId = Guid.Parse(TestEnvironment.ClientId);
VaultProperties.EnableSoftDelete = null;
var parameters = new VaultCreateOrUpdateParameters(Location, VaultProperties);
parameters.Tags.InitializeFrom(Tags);
var createVault = await VaultContainer.CreateOrUpdateAsync(
vaultName : VaultName,
parameters : parameters
).ConfigureAwait(false);
var vaultResponse = createVault.Value;
ValidateVault(vaultResponse.Data,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
"A",
SkuName.Standard,
true,
true,
true,
true,
new[] { AccessPolicy },
Tags);
// Get
var retrievedVault = await VaultContainer.GetAsync(VaultName);
ValidateVault(retrievedVault.Value.Data,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
"A",
SkuName.Standard,
true,
true,
true,
true,
new[] { AccessPolicy },
Tags);
// Delete
await retrievedVault.Value.DeleteAsync();
Assert.ThrowsAsync <RequestFailedException>(async() =>
{
await VaultContainer.GetAsync(VaultName);
});
}
public async Task Get()
{
#region Snippet:Managing_KeyVaults_GetAVault
VaultContainer vaultContainer = resourceGroup.GetVaults();
Vault vault = await vaultContainer.GetAsync("myVault");
Console.WriteLine(vault.Data.Name);
#endregion
}
public async Task Delete()
{
#region Snippet:Managing_KeyVaults_DeleteAVault
VaultContainer vaultContainer = resourceGroup.GetVaults();
Vault vault = await vaultContainer.GetAsync("myVault");
await vault.DeleteAsync();
#endregion
}
public async Task List()
{
#region Snippet:Managing_KeyVaults_ListAllVaults
VaultContainer vaultContainer = resourceGroup.GetVaults();
AsyncPageable <Vault> response = vaultContainer.GetAllAsync();
await foreach (Vault vault in response)
{
Console.WriteLine(vault.Data.Name);
}
#endregion
}
public async Task KeyVaultManagementListDeletedVaults()
{
int n = 3;
List <string> resourceIds = new List <string>();
List <Vault> vaultList = new List <Vault>();
var parameters = new VaultCreateOrUpdateParameters(Location, VaultProperties);
parameters.Tags.InitializeFrom(Tags);
for (int i = 0; i < n; i++)
{
string vaultName = Recording.GenerateAssetName("sdktestvault");
var createdRawVault = await VaultContainer.CreateOrUpdateAsync(vaultName, parameters).ConfigureAwait(false);
var createdVault = createdRawVault.Value;
Assert.NotNull(createdVault.Data);
Assert.NotNull(createdVault.Data.Id);
resourceIds.Add(createdVault.Data.Id);
vaultList.Add(createdVault);
await createdVault.DeleteAsync().ConfigureAwait(false);
var deletedVault = await DeletedVaultContainer.GetAsync(Location).ConfigureAwait(false);
Assert.IsTrue(deletedVault.Value.Data.Name.Equals(createdVault.Data.Name));
}
var deletedVaults = DeletedVaultContainer.GetAllAsync().ToEnumerableAsync().Result;
Assert.NotNull(deletedVaults);
foreach (var v in deletedVaults)
{
var exists = resourceIds.Remove(v.Data.Properties.VaultId);
if (exists)
{
// Purge vault
await v.PurgeAsync().ConfigureAwait(false);
Assert.ThrowsAsync <RequestFailedException>(async() => await DeletedVaultContainer.GetAsync(Location));
}
if (resourceIds.Count == 0)
{
break;
}
}
Assert.True(resourceIds.Count == 0);
}
public async Task KeyVaultManagementRecoverDeletedVault()
{
var parameters = new VaultCreateOrUpdateParameters(Location, VaultProperties);
parameters.Tags.InitializeFrom(Tags);
var createdVault = await VaultContainer.CreateOrUpdateAsync(VaultName, parameters).ConfigureAwait(false);
var vaultValue = createdVault.Value;
// Delete
await vaultValue.DeleteAsync();
// Get deleted vault
Assert.ThrowsAsync <RequestFailedException>(async() =>
{
await VaultContainer.GetAsync(VaultName);
});
parameters = new VaultCreateOrUpdateParameters(Location, VaultProperties);
parameters.Tags.InitializeFrom(Tags);
// Recover in default mode
var recoveredRawVault = await VaultContainer.CreateOrUpdateAsync(VaultName, parameters).ConfigureAwait(false);
var recoveredVault = recoveredRawVault.Value;
Assert.True(recoveredVault.Data.IsEqual(vaultValue.Data));
// Get recovered vault
var getResult = await VaultContainer.GetAsync(VaultName);
// Delete
await getResult.Value.DeleteAsync();
VaultProperties.CreateMode = CreateMode.Recover;
parameters = new VaultCreateOrUpdateParameters(Location, VaultProperties);
// Recover in recover mode
var recoveredRawVault2 = await VaultContainer.CreateOrUpdateAsync(VaultName, parameters).ConfigureAwait(false);
var recoveredVault2 = recoveredRawVault.Value;
Assert.True(recoveredVault2.Data.IsEqual(vaultValue.Data));
// Get recovered vault
getResult = await VaultContainer.GetAsync(VaultName);
// Delete
await getResult.Value.DeleteAsync();
}
public async Task CreateKeyVaultDisableSoftDelete()
{
this.AccessPolicy.ApplicationId = Guid.Parse(TestEnvironment.ClientId);
this.VaultProperties.EnableSoftDelete = false;
var parameters = new VaultCreateOrUpdateParameters("westeurope", VaultProperties);
parameters.Tags.InitializeFrom(Tags);
var vault = await VaultContainer.CreateOrUpdateAsync(VaultName, parameters).ConfigureAwait(false);
var vaultValue = vault.Value;
Assert.False(vaultValue.Data.Properties.EnableSoftDelete);
await vaultValue.DeleteAsync();
}
public async Task GetIfExists()
{
#region Snippet:Managing_KeyVaults_GetAVaultIfExists
VaultContainer vaultContainer = resourceGroup.GetVaults();
Vault vault = await vaultContainer.GetIfExistsAsync("foo");
if (vault != null)
{
Console.WriteLine(vault.Data.Name);
}
if (await vaultContainer.CheckIfExistsAsync("bar"))
{
Console.WriteLine("KeyVault 'bar' exists.");
}
#endregion
}
public async Task KeyVaultManagementListVaults()
{
int n = 3;
int top = 2;
VaultProperties.EnableSoftDelete = null;
List <string> resourceIds = new List <string>();
List <Vault> vaultList = new List <Vault>();
for (int i = 0; i < n; i++)
{
string vaultName = Recording.GenerateAssetName("sdktestvault");
var parameters = new VaultCreateOrUpdateParameters(Location, VaultProperties);
parameters.Tags.InitializeFrom(Tags);
var createdVault = await VaultContainer.CreateOrUpdateAsync(vaultName, parameters).ConfigureAwait(false);
var vaultValue = createdVault.Value;
Assert.NotNull(vaultValue);
Assert.NotNull(vaultValue.Id);
resourceIds.Add(vaultValue.Id);
vaultList.Add(vaultValue);
}
var vaults = VaultContainer.GetAllAsync(top);
await foreach (var v in vaults)
{
Assert.True(resourceIds.Remove(v.Id));
}
Assert.True(resourceIds.Count == 0);
var allVaults = VaultContainer.GetAllAsync(top);
Assert.NotNull(vaults);
// Delete
foreach (var item in vaultList)
{
await item.DeleteAsync();
}
}
public async Task CreateOrUpdate()
{
#region Snippet:Managing_KeyVaults_CreateAVault
VaultContainer vaultContainer = resourceGroup.GetVaults();
string vaultName = "myVault";
Guid tenantIdGuid = new Guid("Your tenantId");
string objectId = "Your Object Id";
Permissions permissions = new Permissions
{
Keys = { new KeyPermissions("all") },
Secrets = { new SecretPermissions("all") },
Certificates = { new CertificatePermissions("all") },
Storage = { new StoragePermissions("all") },
};
AccessPolicyEntry AccessPolicy = new AccessPolicyEntry(tenantIdGuid, objectId, permissions);
VaultProperties VaultProperties = new VaultProperties(tenantIdGuid, new Sku(SkuFamily.A, SkuName.Standard));
VaultProperties.EnabledForDeployment = true;
VaultProperties.EnabledForDiskEncryption = true;
VaultProperties.EnabledForTemplateDeployment = true;
VaultProperties.EnableSoftDelete = true;
VaultProperties.VaultUri = "";
VaultProperties.NetworkAcls = new NetworkRuleSet()
{
Bypass = "******",
DefaultAction = "Allow",
IpRules =
{
new IPRule("1.2.3.4/32"),
new IPRule("1.0.0.0/25")
}
};
VaultProperties.AccessPolicies.Add(AccessPolicy);
VaultCreateOrUpdateParameters parameters = new VaultCreateOrUpdateParameters(Location.WestUS, VaultProperties);
var rawVault = await vaultContainer.CreateOrUpdateAsync(vaultName, parameters).ConfigureAwait(false);
Vault vault = await rawVault.WaitForCompletionAsync();
#endregion
}
public async Task KeyVaultManagementVaultCreateUpdateDelete()
{
VaultProperties.EnableSoftDelete = null;
var parameters = new VaultCreateOrUpdateParameters(Location, VaultProperties);
parameters.Tags.InitializeFrom(Tags);
var rawVault = await VaultContainer.CreateOrUpdateAsync(VaultName, parameters).ConfigureAwait(false);
var createdVault = rawVault.Value.Data;
ValidateVault(createdVault,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
"A",
SkuName.Standard,
true,
true,
true,
true, // enableSoftDelete defaults to true
new[] { AccessPolicy },
VaultProperties.NetworkAcls,
Tags);
//Update
AccessPolicy.Permissions.Secrets.Clear();
AccessPolicy.Permissions.Secrets.Add(SecretPermissions.Get);
AccessPolicy.Permissions.Secrets.Add(SecretPermissions.Set);
(AccessPolicy.Permissions.Keys as ChangeTrackingList <KeyPermissions>).Reset();
AccessPolicy.Permissions.Storage.Clear();
AccessPolicy.Permissions.Storage.Add(StoragePermissions.Get);
AccessPolicy.Permissions.Storage.Add(StoragePermissions.Regeneratekey);
createdVault.Properties.AccessPolicies.Clear();
createdVault.Properties.AccessPolicies.Add(AccessPolicy);
createdVault.Properties.Sku.Name = SkuName.Premium;
parameters = new VaultCreateOrUpdateParameters(Location, createdVault.Properties);
parameters.Tags.InitializeFrom(Tags);
var rawUpdateVault = await VaultContainer.CreateOrUpdateAsync(VaultName, parameters).ConfigureAwait(false);
var updateVault = rawUpdateVault.Value.Data;
ValidateVault(updateVault,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
"A",
SkuName.Premium,
true,
true,
true,
true,
new[] { AccessPolicy },
VaultProperties.NetworkAcls,
Tags);
var rawRetrievedVault = await VaultContainer.GetAsync(VaultName);
var retrievedVault = rawRetrievedVault.Value.Data;
ValidateVault(retrievedVault,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
"A",
SkuName.Premium,
true,
true,
true,
true,
new[] { AccessPolicy },
VaultProperties.NetworkAcls,
Tags);
// Delete
await rawRetrievedVault.Value.DeleteAsync();
Assert.ThrowsAsync <RequestFailedException>(async() =>
{
await VaultContainer.GetAsync(VaultName);
});
}
