public void CreateModel()
{
#region Snippet:Changelog_CreateModel
VaultProperties properties = new VaultProperties(Guid.NewGuid(), new KeyVaultSku(KeyVaultSkuFamily.A, KeyVaultSkuName.Standard));
VaultCreateOrUpdateContent parameters = new VaultCreateOrUpdateContent(AzureLocation.WestUS2, properties);
#endregion
}
private async Task <ArmOperation <VaultResource> > CreateVault()
{
// Create a Vault first
VaultCreateOrUpdateContent parameters = new VaultCreateOrUpdateContent(Location, VaultProperties);
parameters.Tags.InitializeFrom(Tags);
return(await VaultCollection.CreateOrUpdateAsync(WaitUntil.Completed, VaultName, parameters).ConfigureAwait(false));
}
public async Task KeyVaultManagementVaultTestCompoundIdentityAccessControlPolicy()
{
IgnoreTestInLiveMode();
AccessPolicy.ApplicationId = Guid.Parse(TestEnvironment.ClientId);
VaultProperties.EnableSoftDelete = null;
VaultCreateOrUpdateContent parameters = new VaultCreateOrUpdateContent(Location, VaultProperties);
parameters.Tags.InitializeFrom(Tags);
ArmOperation <VaultResource> createVault = await VaultCollection.CreateOrUpdateAsync(WaitUntil.Completed, VaultName, parameters).ConfigureAwait(false);
VaultResource vaultResponse = createVault.Value;
ValidateVault(vaultResponse.Data,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
"A",
KeyVaultSkuName.Standard,
true,
true,
true,
true,
new[] { AccessPolicy },
Tags);
// Get
Response <VaultResource> retrievedVault = await VaultCollection.GetAsync(VaultName);
ValidateVault(retrievedVault.Value.Data,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
"A",
KeyVaultSkuName.Standard,
true,
true,
true,
true,
new[] { AccessPolicy },
Tags);
// Delete
await retrievedVault.Value.DeleteAsync(WaitUntil.Completed);
Assert.ThrowsAsync <RequestFailedException>(async() =>
{
await VaultCollection.GetAsync(VaultName);
});
}
public async Task KeyVaultManagementVaultCreateWithoutAccessPolicies()
{
IgnoreTestInLiveMode();
VaultProperties vaultProperties = new VaultProperties(TenantIdGuid, new KeyVaultSku(KeyVaultSkuFamily.A, KeyVaultSkuName.Standard));
VaultCreateOrUpdateContent content = new VaultCreateOrUpdateContent(Location, vaultProperties);
ArmOperation <VaultResource> rawVault = await VaultCollection.CreateOrUpdateAsync(WaitUntil.Completed, VaultName, content);
VaultData createdVault = rawVault.Value.Data;
Assert.IsNotNull(createdVault);
Assert.AreEqual(VaultName, createdVault.Name);
}
public async Task KeyVaultManagementRecoverDeletedVault()
{
IgnoreTestInLiveMode();
VaultCreateOrUpdateContent parameters = new VaultCreateOrUpdateContent(Location, VaultProperties);
parameters.Tags.InitializeFrom(Tags);
ArmOperation <VaultResource> createdVault = await VaultCollection.CreateOrUpdateAsync(WaitUntil.Completed, VaultName, parameters).ConfigureAwait(false);
VaultResource vaultValue = createdVault.Value;
// Delete
await vaultValue.DeleteAsync(WaitUntil.Completed);
// Get deleted vault
Assert.ThrowsAsync <RequestFailedException>(async() =>
{
await VaultCollection.GetAsync(VaultName);
});
parameters = new VaultCreateOrUpdateContent(Location, VaultProperties);
parameters.Tags.InitializeFrom(Tags);
// Recover in default mode
ArmOperation <VaultResource> recoveredRawVault = await VaultCollection.CreateOrUpdateAsync(WaitUntil.Completed, VaultName, parameters).ConfigureAwait(false);
VaultResource recoveredVault = recoveredRawVault.Value;
Assert.True(recoveredVault.Data.IsEqual(vaultValue.Data));
// Get recovered vault
Response <VaultResource> getResult = await VaultCollection.GetAsync(VaultName);
// Delete
await getResult.Value.DeleteAsync(WaitUntil.Completed);
VaultProperties.CreateMode = VaultCreateMode.Recover;
parameters = new VaultCreateOrUpdateContent(Location, VaultProperties);
// Recover in recover mode
ArmOperation <VaultResource> recoveredRawVault2 = await VaultCollection.CreateOrUpdateAsync(WaitUntil.Completed, VaultName, parameters).ConfigureAwait(false);
VaultResource recoveredVault2 = recoveredRawVault.Value;
Assert.True(recoveredVault2.Data.IsEqual(vaultValue.Data));
// Get recovered vault
getResult = await VaultCollection.GetAsync(VaultName);
// Delete
await getResult.Value.DeleteAsync(WaitUntil.Completed);
}
public async Task NewCode()
{
#region Snippet:Changelog_NewCode
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroupResource resourceGroup = await subscription.GetResourceGroups().GetAsync("myRgName");
VaultCollection vaultCollection = resourceGroup.GetVaults();
VaultCreateOrUpdateContent parameters = new VaultCreateOrUpdateContent(AzureLocation.WestUS2, new VaultProperties(Guid.NewGuid(), new KeyVaultSku(KeyVaultSkuFamily.A, KeyVaultSkuName.Standard)));
ArmOperation <VaultResource> lro = await vaultCollection.CreateOrUpdateAsync(WaitUntil.Completed, "myVaultName", parameters);
VaultResource vault = lro.Value;
#endregion
}
public async Task KeyVaultManagementListVaults()
{
IgnoreTestInLiveMode();
int n = 3;
int top = 2;
VaultProperties.EnableSoftDelete = null;
List <string> resourceIds = new List <string>();
List <VaultResource> vaultList = new List <VaultResource>();
for (int i = 0; i < n; i++)
{
string vaultName = Recording.GenerateAssetName("sdktest-vault-");
VaultCreateOrUpdateContent parameters = new VaultCreateOrUpdateContent(Location, VaultProperties);
parameters.Tags.InitializeFrom(Tags);
ArmOperation <VaultResource> createdVault = await VaultCollection.CreateOrUpdateAsync(WaitUntil.Completed, vaultName, parameters).ConfigureAwait(false);
VaultResource vaultValue = createdVault.Value;
Assert.NotNull(vaultValue);
Assert.NotNull(vaultValue.Id);
resourceIds.Add(vaultValue.Id);
vaultList.Add(vaultValue);
}
AsyncPageable <VaultResource> vaults = VaultCollection.GetAllAsync(top);
await foreach (var v in vaults)
{
Assert.True(resourceIds.Remove(v.Id));
}
Assert.True(resourceIds.Count == 0);
AsyncPageable <VaultResource> allVaults = VaultCollection.GetAllAsync(top);
Assert.NotNull(vaults);
// Delete
foreach (var item in vaultList)
{
await item.DeleteAsync(WaitUntil.Completed);
}
}
public async Task CreateOrUpdate()
{
#region Snippet:Managing_KeyVaults_CreateAVault
VaultCollection vaultCollection = resourceGroup.GetVaults();
string vaultName = "myVault";
Guid tenantIdGuid = new Guid("Your tenantId");
string objectId = "Your Object Id";
IdentityAccessPermissions permissions = new IdentityAccessPermissions
{
Keys = { new KeyPermission("all") },
Secrets = { new SecretPermission("all") },
Certificates = { new CertificatePermission("all") },
Storage = { new StoragePermission("all") },
};
AccessPolicyEntry AccessPolicy = new AccessPolicyEntry(tenantIdGuid, objectId, permissions);
VaultProperties VaultProperties = new VaultProperties(tenantIdGuid, new KeyVaultSku(KeyVaultSkuFamily.A, KeyVaultSkuName.Standard));
VaultProperties.EnabledForDeployment = true;
VaultProperties.EnabledForDiskEncryption = true;
VaultProperties.EnabledForTemplateDeployment = true;
VaultProperties.EnableSoftDelete = true;
VaultProperties.VaultUri = new Uri("http://vaulturi.com");
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);
VaultCreateOrUpdateContent parameters = new VaultCreateOrUpdateContent(AzureLocation.WestUS, VaultProperties);
var rawVault = await vaultCollection.CreateOrUpdateAsync(WaitUntil.Started, vaultName, parameters).ConfigureAwait(false);
VaultResource vault = await rawVault.WaitForCompletionAsync();
#endregion
}
public async Task KeyVaultManagementListDeletedVaults()
{
IgnoreTestInLiveMode();
int n = 3;
List <string> resourceIds = new List <string>();
List <VaultResource> vaultList = new List <VaultResource>();
VaultCreateOrUpdateContent parameters = new VaultCreateOrUpdateContent(Location, VaultProperties);
parameters.Tags.InitializeFrom(Tags);
for (int i = 0; i < n; i++)
{
string vaultName = Recording.GenerateAssetName("sdktest-vault-");
ArmOperation <VaultResource> createdRawVault = await VaultCollection.CreateOrUpdateAsync(WaitUntil.Completed, vaultName, parameters).ConfigureAwait(false);
VaultResource createdVault = createdRawVault.Value;
Assert.NotNull(createdVault.Data);
Assert.NotNull(createdVault.Data.Id);
resourceIds.Add(createdVault.Data.Id);
vaultList.Add(createdVault);
await createdVault.DeleteAsync(WaitUntil.Completed).ConfigureAwait(false);
Response <DeletedVaultResource> deletedVault = await DeletedVaultCollection.GetAsync(Location, vaultName).ConfigureAwait(false);
Assert.IsTrue(deletedVault.Value.Data.Name.Equals(createdVault.Data.Name));
}
List <DeletedVaultResource> deletedVaults = Subscription.GetDeletedVaultsAsync().ToEnumerableAsync().Result;
Assert.NotNull(deletedVaults);
foreach (var v in deletedVaults)
{
bool exists = resourceIds.Remove(v.Data.Properties.VaultId);
if (resourceIds.Count == 0)
{
break;
}
}
Assert.True(resourceIds.Count == 0);
}
public virtual async Task <ArmOperation <VaultResource> > CreateOrUpdateAsync(WaitUntil waitUntil, string vaultName, VaultCreateOrUpdateContent content, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(vaultName, nameof(vaultName));
Argument.AssertNotNull(content, nameof(content));
using var scope = _vaultClientDiagnostics.CreateScope("VaultCollection.CreateOrUpdate");
scope.Start();
try
{
var response = await _vaultRestClient.CreateOrUpdateAsync(Id.SubscriptionId, Id.ResourceGroupName, vaultName, content, cancellationToken).ConfigureAwait(false);
var operation = new KeyVaultArmOperation <VaultResource>(new VaultOperationSource(Client), _vaultClientDiagnostics, Pipeline, _vaultRestClient.CreateCreateOrUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, vaultName, content).Request, response, OperationFinalStateVia.Location);
if (waitUntil == WaitUntil.Completed)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async Task KeyVaultManagementVaultCreateUpdateDelete()
{
VaultProperties.EnableSoftDelete = null;
VaultCreateOrUpdateContent parameters = new VaultCreateOrUpdateContent(Location, VaultProperties);
parameters.Tags.InitializeFrom(Tags);
ArmOperation <VaultResource> rawVault = await VaultCollection.CreateOrUpdateAsync(WaitUntil.Completed, VaultName, parameters).ConfigureAwait(false);
VaultData createdVault = rawVault.Value.Data;
ValidateVault(createdVault,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
"A",
KeyVaultSkuName.Standard,
true,
true,
true,
true, // enableSoftDelete defaults to true
new[] { AccessPolicy },
VaultProperties.NetworkAcls,
Tags);
//Update
AccessPolicy.Permissions.Secrets.Clear();
AccessPolicy.Permissions.Secrets.Add(SecretPermission.Get);
AccessPolicy.Permissions.Secrets.Add(SecretPermission.Set);
(AccessPolicy.Permissions.Keys as ChangeTrackingList <KeyPermission>).Reset();
AccessPolicy.Permissions.Storage.Clear();
AccessPolicy.Permissions.Storage.Add(StoragePermission.Get);
AccessPolicy.Permissions.Storage.Add(StoragePermission.Regeneratekey);
createdVault.Properties.AccessPolicies.Clear();
createdVault.Properties.AccessPolicies.Add(AccessPolicy);
createdVault.Properties.Sku.Name = KeyVaultSkuName.Premium;
parameters = new VaultCreateOrUpdateContent(Location, createdVault.Properties);
parameters.Tags.InitializeFrom(Tags);
ArmOperation <VaultResource> rawUpdateVault = await VaultCollection.CreateOrUpdateAsync(WaitUntil.Completed, VaultName, parameters).ConfigureAwait(false);
VaultData updateVault = rawUpdateVault.Value.Data;
ValidateVault(updateVault,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
"A",
KeyVaultSkuName.Premium,
true,
true,
true,
true,
new[] { AccessPolicy },
VaultProperties.NetworkAcls,
Tags);
Response <VaultResource> rawRetrievedVault = await VaultCollection.GetAsync(VaultName);
VaultData retrievedVault = rawRetrievedVault.Value.Data;
ValidateVault(retrievedVault,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
"A",
KeyVaultSkuName.Premium,
true,
true,
true,
true,
new[] { AccessPolicy },
VaultProperties.NetworkAcls,
Tags);
// Delete
ArmOperation deleteVault = await rawRetrievedVault.Value.DeleteAsync(WaitUntil.Completed);
Assert.ThrowsAsync <RequestFailedException>(async() =>
{
await VaultCollection.GetAsync(VaultName);
});
}
