public async Task UpdateAvailabilitySet()
{
#region Snippet:Managing_Availability_Set_UpdateAnAvailabilitySet
// First, initialize the ArmClient and get the default subscription
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
// Now we get a ResourceGroupResource collection for that subscription
SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroupCollection rgCollection = subscription.GetResourceGroups();
// With the collection, we can create a new resource group with an specific name
string rgName = "myRgName";
ResourceGroupResource resourceGroup = await rgCollection.GetAsync(rgName);
AvailabilitySetCollection availabilitySetCollection = resourceGroup.GetAvailabilitySets();
string availabilitySetName = "myAvailabilitySet";
AvailabilitySetResource availabilitySet = await availabilitySetCollection.GetAsync(availabilitySetName);
// availabilitySet is an AvailabilitySetResource instance created above
AvailabilitySetPatch update = new AvailabilitySetPatch()
{
PlatformFaultDomainCount = 3
};
AvailabilitySetResource updatedAvailabilitySet = await availabilitySet.UpdateAsync(update);
#endregion Snippet:Managing_Availability_Set_UpdateAnAvailabilitySet
}
public async Task GetAllInSubscription()
{
var collection = await GetAvailabilitySetCollectionAsync();
var setName1 = Recording.GenerateAssetName("testAS-");
var setName2 = Recording.GenerateAssetName("testAS-");
var input = ResourceDataHelper.GetBasicAvailabilitySetData(DefaultLocation);
input.Tags.ReplaceWith(new Dictionary <string, string>
{
{ "key", "value" }
});
_ = await collection.CreateOrUpdateAsync(WaitUntil.Completed, setName1, input);
_ = await collection.CreateOrUpdateAsync(WaitUntil.Completed, setName2, input);
AvailabilitySetResource set1 = null, set2 = null;
await foreach (var availabilitySet in DefaultSubscription.GetAvailabilitySetsAsync())
{
if (availabilitySet.Data.Name == setName1)
{
set1 = availabilitySet;
}
if (availabilitySet.Data.Name == setName2)
{
set2 = availabilitySet;
}
}
Assert.NotNull(set1);
Assert.NotNull(set2);
}
public async Task CreateAvailabilitySet()
{
// First, initialize the ArmClient and get the default subscription
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
// Now we get a ResourceGroupResource collection for that subscription
SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroupCollection rgCollection = subscription.GetResourceGroups();
// With the collection, we can create a new resource group with an specific name
string rgName = "myRgName";
AzureLocation location = AzureLocation.WestUS2;
ArmOperation <ResourceGroupResource> rgLro = await rgCollection.CreateOrUpdateAsync(WaitUntil.Completed, rgName, new ResourceGroupData(location));
ResourceGroupResource resourceGroup = rgLro.Value;
#region Snippet:Managing_Availability_Set_CreateAnAvailabilitySet
AvailabilitySetCollection availabilitySetCollection = resourceGroup.GetAvailabilitySets();
string availabilitySetName = "myAvailabilitySet";
AvailabilitySetData input = new AvailabilitySetData(location);
ArmOperation <AvailabilitySetResource> lro = await availabilitySetCollection.CreateOrUpdateAsync(WaitUntil.Completed, availabilitySetName, input);
AvailabilitySetResource availabilitySet = lro.Value;
#endregion Snippet:Managing_Availability_Set_CreateAnAvailabilitySet
}
public async Task Get()
{
var setName = Recording.GenerateAssetName("testAS-");
var set1 = await CreateAvailabilitySetAsync(setName);
AvailabilitySetResource set2 = await set1.GetAsync();
ResourceDataHelper.AssertAvailabilitySet(set1.Data, set2.Data);
}
public async Task PlacementGroupId()
{
var asetName = Recording.GenerateAssetName("aset-");
AvailabilitySetResource aset = await CreateAvailabilitySetAsync(asetName);
var beforeAdd = aset.Data.ProximityPlacementGroupId;
ResourceGroupResource rg = Client.GetResourceGroupResource(ResourceGroupResource.CreateResourceIdentifier(aset.Id.SubscriptionId, aset.Id.ResourceGroupName));
var proxGrpName = Recording.GenerateAssetName("proxGrp-");
ProximityPlacementGroupResource proxGrp = (await rg.GetProximityPlacementGroups().CreateOrUpdateAsync(WaitUntil.Completed, proxGrpName, new ProximityPlacementGroupData(DefaultLocation))).Value;
AvailabilitySetPatch updateOptions = new AvailabilitySetPatch();
updateOptions.ProximityPlacementGroupId = proxGrp.Id;
aset = await aset.UpdateAsync(updateOptions);
var addIdResult = aset.Data.ProximityPlacementGroupId;
updateOptions.ProximityPlacementGroupId = null;
aset = await aset.UpdateAsync(updateOptions);
var removeIdResult = aset.Data.ProximityPlacementGroupId;
var asetName2 = Recording.GenerateAssetName("aset-");
AvailabilitySetResource aset2 = await CreateAvailabilitySetAsync(asetName2);
var newBeforeAdd = aset2.Data.ProximityPlacementGroup?.Id;
AvailabilitySetPatch updateOptions2 = new AvailabilitySetPatch();
updateOptions2.ProximityPlacementGroup = new Resources.Models.WritableSubResource();
updateOptions2.ProximityPlacementGroup.Id = proxGrp.Id;
aset2 = await aset2.UpdateAsync(updateOptions2);
var newAddIdResult = aset2.Data.ProximityPlacementGroup.Id;
updateOptions2.ProximityPlacementGroup.Id = null;
aset2 = await aset2.UpdateAsync(updateOptions2);
var newRemoveIdResult = aset2.Data.ProximityPlacementGroup?.Id;
updateOptions2.ProximityPlacementGroup.Id = proxGrp.Id;
aset2 = await aset2.UpdateAsync(updateOptions2);
Assert.NotNull(aset2.Data.ProximityPlacementGroup.Id);
updateOptions2.ProximityPlacementGroup = null;
aset2 = await aset2.UpdateAsync(updateOptions2);
var newRemoveOuterIdResult = aset2.Data.ProximityPlacementGroup?.Id;
Assert.AreEqual(beforeAdd, newBeforeAdd);
Assert.AreEqual(addIdResult, newAddIdResult);
Assert.AreEqual(removeIdResult, newRemoveIdResult);
Assert.AreEqual(removeIdResult, newRemoveOuterIdResult);
}
public async Task Update()
{
var setName = Recording.GenerateAssetName("testAS-");
var set = await CreateAvailabilitySetAsync(setName);
var updatedPlatformFaultDomainCount = 3;
var update = new AvailabilitySetPatch()
{
PlatformFaultDomainCount = updatedPlatformFaultDomainCount
};
AvailabilitySetResource updatedSet = await set.UpdateAsync(update);
Assert.AreEqual(updatedPlatformFaultDomainCount, updatedSet.Data.PlatformFaultDomainCount);
}
public async Task ManageAvailabilitySetNow()
{
#region Snippet:Readme_ManageAvailabilitySetNow
ResourceIdentifier resourceId = new ResourceIdentifier("/subscriptions/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/resourceGroups/workshop2021-rg/providers/Microsoft.Compute/availabilitySets/ws2021availSet");
// We construct a new client to work with
ArmClient client = new ArmClient(new DefaultAzureCredential());
// Next we get the AvailabilitySetResource resource client from the client
// The method takes in a ResourceIdentifier but we can use the implicit cast from string
AvailabilitySetResource availabilitySet = client.GetAvailabilitySetResource(resourceId);
// At this point availabilitySet.Data will be null and trying to access it will throw
// If we want to retrieve the objects data we can simply call get
availabilitySet = await availabilitySet.GetAsync();
// we now have the data representing the availabilitySet
Console.WriteLine(availabilitySet.Data.Name);
#endregion Snippet:Readme_ManageAvailabilitySetNow
}
public async Task Get()
{
var collection = await GetAvailabilitySetCollectionAsync();
var setName = Recording.GenerateAssetName("testAS-");
var input = ResourceDataHelper.GetBasicAvailabilitySetData(DefaultLocation);
input.Tags.ReplaceWith(new Dictionary <string, string>
{
{ "key", "value" }
});
var lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, setName, input);
AvailabilitySetResource set1 = lro.Value;
AvailabilitySetResource set2 = await collection.GetAsync(setName);
ResourceDataHelper.AssertAvailabilitySet(set1.Data, set2.Data);
}
public async Task AddTagToAvailabilitySet()
{
#region Snippet:Managing_Availability_Set_AddTagAvailabilitySet
// First, initialize the ArmClient and get the default subscription
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
// Now we get a ResourceGroupResource collection for that subscription
SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroupCollection rgCollection = subscription.GetResourceGroups();
string rgName = "myRgName";
ResourceGroupResource resourceGroup = await rgCollection.GetAsync(rgName);
AvailabilitySetCollection availabilitySetCollection = resourceGroup.GetAvailabilitySets();
string availabilitySetName = "myAvailabilitySet";
AvailabilitySetResource availabilitySet = await availabilitySetCollection.GetAsync(availabilitySetName);
// add a tag on this availabilitySet
AvailabilitySetResource updatedAvailabilitySet = await availabilitySet.AddTagAsync("key", "value");
#endregion Snippet:Managing_Availability_Set_AddTagAvailabilitySet
}
public async Task ManageAvailabilitySetPieces()
{
#region Snippet:Readme_ManageAvailabilitySetPieces
string subscriptionId = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
string resourceGroupName = "workshop2021-rg";
string availabilitySetName = "ws2021availSet";
ResourceIdentifier resourceId = AvailabilitySetResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, availabilitySetName);
// We construct a new client to work with
ArmClient client = new ArmClient(new DefaultAzureCredential());
// Next we get the AvailabilitySetResource resource client from the client
// The method takes in a ResourceIdentifier but we can use the implicit cast from string
AvailabilitySetResource availabilitySet = client.GetAvailabilitySetResource(resourceId);
// At this point availabilitySet.Data will be null and trying to access it will throw
// If we want to retrieve the objects data we can simply call get
availabilitySet = await availabilitySet.GetAsync();
// we now have the data representing the availabilitySet
Console.WriteLine(availabilitySet.Data.Name);
#endregion Snippet:Readme_ManageAvailabilitySetPieces
}
public async Task DeleteAvailabilitySet()
{
#region Snippet:Managing_Availability_Set_DeleteAnAvailabilitySet
// First, initialize the ArmClient and get the default subscription
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
// Now we get a ResourceGroupResource collection for that subscription
SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroupCollection rgCollection = subscription.GetResourceGroups();
// With the collection, we can create a new resource group with an specific name
string rgName = "myRgName";
ResourceGroupResource resourceGroup = await rgCollection.GetAsync(rgName);
AvailabilitySetCollection availabilitySetCollection = resourceGroup.GetAvailabilitySets();
string availabilitySetName = "myAvailabilitySet";
AvailabilitySetResource availabilitySet = await availabilitySetCollection.GetAsync(availabilitySetName);
// delete the availability set
await availabilitySet.DeleteAsync(WaitUntil.Completed);
#endregion Snippet:Managing_Availability_Set_DeleteAnAvailabilitySet
}
public async Task ManageAvailabilitySetOld()
{
#region Snippet:Readme_ManageAvailabilitySetOld
ResourceIdentifier id = new ResourceIdentifier("/subscriptions/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/resourceGroups/workshop2021-rg/providers/Microsoft.Compute/availabilitySets/ws2021availSet");
// We construct a new client to work with
ArmClient client = new ArmClient(new DefaultAzureCredential());
// Next we get the collection of subscriptions
SubscriptionCollection subscriptions = client.GetSubscriptions();
// Next we get the specific subscription this resource belongs to
SubscriptionResource subscription = await subscriptions.GetAsync(id.SubscriptionId);
// Next we get the collection of resource groups that belong to that subscription
ResourceGroupCollection resourceGroups = subscription.GetResourceGroups();
// Next we get the specific resource group this resource belongs to
ResourceGroupResource resourceGroup = await resourceGroups.GetAsync(id.ResourceGroupName);
// Next we get the collection of availability sets that belong to that resource group
AvailabilitySetCollection availabilitySets = resourceGroup.GetAvailabilitySets();
// Finally we get the resource itself
// Note: for this last step in this example, Azure.ResourceManager.Compute is needed
AvailabilitySetResource availabilitySet = await availabilitySets.GetAsync(id.Name);
#endregion Snippet:Readme_ManageAvailabilitySetOld
}
public async Task NewCode()
{
#endif
var armClient = new ArmClient(new DefaultAzureCredential());
var location = AzureLocation.WestUS;
// Create ResourceGroupResource
SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync();
ArmOperation<ResourceGroupResource> rgOperation = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, "myResourceGroup", new ResourceGroupData(location));
ResourceGroupResource resourceGroup = rgOperation.Value;
// Create AvailabilitySet
var availabilitySetData = new AvailabilitySetData(location)
{
PlatformUpdateDomainCount = 5,
PlatformFaultDomainCount = 2,
Sku = new ComputeSku() { Name = "Aligned" }
};
ArmOperation<AvailabilitySetResource> asetOperation = await resourceGroup.GetAvailabilitySets().CreateOrUpdateAsync(WaitUntil.Completed, "myAvailabilitySet", availabilitySetData);
AvailabilitySetResource availabilitySet = asetOperation.Value;
// Create VNet
var vnetData = new VirtualNetworkData()
{
Location = location,
Subnets =
{
new SubnetData()
{
Name = "mySubnet",
AddressPrefix = "10.0.0.0/24",
}
},
};
vnetData.AddressPrefixes.Add("10.0.0.0/16");
ArmOperation<VirtualNetworkResource> vnetOperation = await resourceGroup.GetVirtualNetworks().CreateOrUpdateAsync(WaitUntil.Completed, "myVirtualNetwork", vnetData);
VirtualNetworkResource vnet = vnetOperation.Value;
// Create Network interface
var nicData = new NetworkInterfaceData()
{
Location = location,
IPConfigurations =
{
new NetworkInterfaceIPConfigurationData()
{
Name = "Primary",
Primary = true,
Subnet = new SubnetData() { Id = vnet.Data.Subnets.First().Id },
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
}
}
};
ArmOperation<NetworkInterfaceResource> nicOperation = await resourceGroup.GetNetworkInterfaces().CreateOrUpdateAsync(WaitUntil.Completed, "myNetworkInterface", nicData);
NetworkInterfaceResource nic = nicOperation.Value;
var vmData = new VirtualMachineData(location)
{
AvailabilitySet = new WritableSubResource() { Id = availabilitySet.Id },
NetworkProfile = new Compute.Models.NetworkProfile { NetworkInterfaces = { new NetworkInterfaceReference() { Id = nic.Id } } },
OSProfile = new OSProfile
{
ComputerName = "testVM",
AdminUsername = "******",
AdminPassword = "******",
LinuxConfiguration = new LinuxConfiguration { DisablePasswordAuthentication = false, ProvisionVmAgent = true }
},
StorageProfile = new StorageProfile()
{
ImageReference = new ImageReference()
{
Offer = "UbuntuServer",
Publisher = "Canonical",
Sku = "18.04-LTS",
Version = "latest"
}
},
HardwareProfile = new HardwareProfile() { VmSize = VirtualMachineSizeTypes.StandardB1Ms },
};
ArmOperation<VirtualMachineResource> vmOperation = await resourceGroup.GetVirtualMachines().CreateOrUpdateAsync(WaitUntil.Completed, "myVirtualMachine", vmData);
VirtualMachineResource vm = vmOperation.Value;
#endregion
}
public async Task MigrationExample()
{
#region Snippet:Construct_Client
ArmClient client = new ArmClient(new DefaultAzureCredential());
#endregion
#region Snippet:Create_ResourceGroup
SubscriptionResource subscription = await client.GetDefaultSubscriptionAsync();
ResourceGroupCollection resourceGroups = subscription.GetResourceGroups();
AzureLocation location = AzureLocation.WestUS2;
string resourceGroupName = "QuickStartRG";
ResourceGroupData resourceGroupData = new ResourceGroupData(location);
ArmOperation <ResourceGroupResource> resourceGroupOperation = await resourceGroups.CreateOrUpdateAsync(WaitUntil.Completed, resourceGroupName, resourceGroupData);
ResourceGroupResource resourceGroup = resourceGroupOperation.Value;
#endregion
#region Snippet:Create_AvailabilitySet
string virtualMachineName = "quickstartvm";
AvailabilitySetData availabilitySetData = new AvailabilitySetData(location);
AvailabilitySetCollection availabilitySets = resourceGroup.GetAvailabilitySets();
ArmOperation <AvailabilitySetResource> availabilitySetOperation = await availabilitySets.CreateOrUpdateAsync(WaitUntil.Completed, virtualMachineName + "_aSet", availabilitySetData);
AvailabilitySetResource availabilitySet = availabilitySetOperation.Value;
#endregion
#region Snippet:Create_Vnet_and_Subnet
string virtualNetworkName = "MYVM" + "_vnet";
string subnetName = "mySubnet";
VirtualNetworkData virtualNetworkData = new VirtualNetworkData()
{
Subnets =
{
new SubnetData()
{
Name = subnetName,
AddressPrefix = "10.0.0.0/24"
}
}
};
VirtualNetworkCollection virtualNetworks = resourceGroup.GetVirtualNetworks();
virtualNetworkData.AddressPrefixes.Add("10.0.0.0/16");
ArmOperation <VirtualNetworkResource> virtualNetworkOperation = await virtualNetworks.CreateOrUpdateAsync(WaitUntil.Completed, virtualNetworkName, virtualNetworkData);
VirtualNetworkResource virtualNetwork = virtualNetworkOperation.Value;
#endregion
#region Snippet:Create_NetworkSecurityGroup
string networkSecurityGroupName = virtualMachineName + "_nsg";
NetworkSecurityGroupData networkSecurityGroupData = new NetworkSecurityGroupData()
{
Location = location
};
NetworkSecurityGroupCollection networkSecurityGroups = resourceGroup.GetNetworkSecurityGroups();
ArmOperation <NetworkSecurityGroupResource> networkSecurityGroupOperation = await networkSecurityGroups.CreateOrUpdateAsync(WaitUntil.Completed, networkSecurityGroupName, networkSecurityGroupData);
NetworkSecurityGroupResource networkSecurityGroup = networkSecurityGroupOperation.Value;
#endregion
#region Snippet:Create_NetworkInterface
string networkInterfaceName = virtualMachineName + "_nic";
NetworkInterfaceIPConfigurationData networkInterfaceIPConfiguration = new NetworkInterfaceIPConfigurationData()
{
Name = "Primary",
Primary = true,
Subnet = new SubnetData()
{
Id = virtualNetwork.Data.Subnets.First().Id
},
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
};
NetworkInterfaceData nicData = new NetworkInterfaceData();
nicData.Location = location;
nicData.IPConfigurations.Add(networkInterfaceIPConfiguration);
NetworkInterfaceCollection networkInterfaces = resourceGroup.GetNetworkInterfaces();
ArmOperation <NetworkInterfaceResource> networkInterfaceOperation = await networkInterfaces.CreateOrUpdateAsync(WaitUntil.Completed, networkInterfaceName, nicData);
NetworkInterfaceResource networkInterface = networkInterfaceOperation.Value;
#endregion
#region Snippet:Create_VirtualMachine
VirtualMachineData virutalMachineData = new VirtualMachineData(location);
virutalMachineData.OSProfile.AdminUsername = "******";
virutalMachineData.OSProfile.AdminPassword = "******";
virutalMachineData.OSProfile.ComputerName = "computer-name";
virutalMachineData.AvailabilitySetId = availabilitySet.Id;
NetworkInterfaceReference nicReference = new NetworkInterfaceReference();
nicReference.Id = networkInterface.Id;
virutalMachineData.NetworkProfile.NetworkInterfaces.Add(nicReference);
VirtualMachineCollection virtualMachines = resourceGroup.GetVirtualMachines();
ArmOperation <VirtualMachineResource> virtualMachineOperation = await virtualMachines.CreateOrUpdateAsync(WaitUntil.Completed, virtualMachineName, virutalMachineData);
VirtualMachineResource virtualMachine = virtualMachineOperation.Value;
Console.WriteLine("VM ID: " + virtualMachine.Id);
#endregion
}
