public async virtual Task <VirtualMachineCreateOrUpdateOperation> CreateOrUpdateAsync(string vmName, VirtualMachineData parameters, bool waitForCompletion = true, CancellationToken cancellationToken = default)
{
if (vmName == null)
{
throw new ArgumentNullException(nameof(vmName));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
using var scope = _clientDiagnostics.CreateScope("VirtualMachineContainer.CreateOrUpdate");
scope.Start();
try
{
var response = await _restClient.CreateOrUpdateAsync(Id.ResourceGroupName, vmName, parameters, cancellationToken).ConfigureAwait(false);
var operation = new VirtualMachineCreateOrUpdateOperation(Parent, _clientDiagnostics, Pipeline, _restClient.CreateCreateOrUpdateRequest(Id.ResourceGroupName, vmName, parameters).Request, response);
if (waitForCompletion)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual VirtualMachineCreateOrUpdateOperation CreateOrUpdate(bool waitForCompletion, string vmName, VirtualMachineData parameters, CancellationToken cancellationToken = default)
{
if (vmName == null)
{
throw new ArgumentNullException(nameof(vmName));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
using var scope = _clientDiagnostics.CreateScope("VirtualMachineCollection.CreateOrUpdate");
scope.Start();
try
{
var response = _virtualMachinesRestClient.CreateOrUpdate(Id.SubscriptionId, Id.ResourceGroupName, vmName, parameters, cancellationToken);
var operation = new VirtualMachineCreateOrUpdateOperation(this, _clientDiagnostics, Pipeline, _virtualMachinesRestClient.CreateCreateOrUpdateRequest(Id.SubscriptionId, Id.ResourceGroupName, vmName, parameters).Request, response);
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual VirtualMachineCreateOrUpdateOperation CreateOrUpdate(bool waitForCompletion, string virtualMachineName, VirtualMachineData body = null, CancellationToken cancellationToken = default)
{
Argument.AssertNotNullOrEmpty(virtualMachineName, nameof(virtualMachineName));
using var scope = _virtualMachineClientDiagnostics.CreateScope("VirtualMachineCollection.CreateOrUpdate");
scope.Start();
try
{
var response = _virtualMachineRestClient.Create(Id.SubscriptionId, Id.ResourceGroupName, virtualMachineName, body, cancellationToken);
var operation = new VirtualMachineCreateOrUpdateOperation(ArmClient, _virtualMachineClientDiagnostics, Pipeline, _virtualMachineRestClient.CreateCreateRequest(Id.SubscriptionId, Id.ResourceGroupName, virtualMachineName, body).Request, response);
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async Task NewCode()
{
#endif
var armClient = new ArmClient(new DefaultAzureCredential());
var location = AzureLocation.WestUS;
// Create ResourceGroup
Subscription subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroupCreateOrUpdateOperation rgOperation = await subscription.GetResourceGroups().CreateOrUpdateAsync(true, "myResourceGroup", new ResourceGroupData(location));
ResourceGroup resourceGroup = rgOperation.Value;
// Create AvailabilitySet
var availabilitySetData = new AvailabilitySetData(location)
{
PlatformUpdateDomainCount = 5,
PlatformFaultDomainCount = 2,
Sku = new Compute.Models.Sku() { Name = "Aligned" }
};
AvailabilitySetCreateOrUpdateOperation asetOperation = await resourceGroup.GetAvailabilitySets().CreateOrUpdateAsync(true, "myAvailabilitySet", availabilitySetData);
AvailabilitySet availabilitySet = asetOperation.Value;
// Create VNet
var vnetData = new VirtualNetworkData()
{
Location = location,
AddressSpace = new AddressSpace() { AddressPrefixes = { "10.0.0.0/16" } },
Subnets =
{
new SubnetData()
{
Name = "mySubnet",
AddressPrefix = "10.0.0.0/24",
}
},
};
VirtualNetworkCreateOrUpdateOperation vnetOperation = await resourceGroup.GetVirtualNetworks().CreateOrUpdateAsync(true, "myVirtualNetwork", vnetData);
VirtualNetwork 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,
}
}
};
NetworkInterfaceCreateOrUpdateOperation nicOperation = await resourceGroup.GetNetworkInterfaces().CreateOrUpdateAsync(true, "myNetworkInterface", nicData);
NetworkInterface 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 },
};
VirtualMachineCreateOrUpdateOperation vmOperation = await resourceGroup.GetVirtualMachines().CreateOrUpdateAsync(true, "myVirtualMachine", vmData);
VirtualMachine vm = vmOperation.Value;
#endregion
}
public async Task CreateVirtualMachine()
{
#region Snippet:Managing_VirtualMachines_CreateAVirtualMachine
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
Subscription subscription = await armClient.GetDefaultSubscriptionAsync();
// first we need to get the resource group
string rgName = "myRgName";
ResourceGroup resourceGroup = await subscription.GetResourceGroups().GetAsync(rgName);
// Now we get the virtual machine collection from the resource group
VirtualMachineCollection vmCollection = resourceGroup.GetVirtualMachines();
// Use the same location as the resource group
string vmName = "myVM";
var input = new VirtualMachineData(resourceGroup.Data.Location)
{
HardwareProfile = new HardwareProfile()
{
VmSize = VirtualMachineSizeTypes.StandardF2
},
OsProfile = new OSProfile()
{
AdminUsername = "******",
ComputerName = "myVM",
LinuxConfiguration = new LinuxConfiguration()
{
DisablePasswordAuthentication = true,
Ssh = new SshConfiguration()
{
PublicKeys =
{
new SshPublicKeyInfo()
{
Path = $"/home/adminUser/.ssh/authorized_keys",
KeyData = "<value of the public ssh key>",
}
}
}
}
},
NetworkProfile = new NetworkProfile()
{
NetworkInterfaces =
{
new NetworkInterfaceReference()
{
Id = "/subscriptions/<subscriptionId>/resourceGroups/<rgName>/providers/Microsoft.Network/networkInterfaces/<nicName>",
Primary = true,
}
}
},
StorageProfile = new StorageProfile()
{
OsDisk = new OSDisk(DiskCreateOptionTypes.FromImage)
{
OsType = OperatingSystemTypes.Linux,
Caching = CachingTypes.ReadWrite,
ManagedDisk = new ManagedDiskParameters()
{
StorageAccountType = StorageAccountTypes.StandardLRS
}
},
ImageReference = new ImageReference()
{
Publisher = "Canonical",
Offer = "UbuntuServer",
Sku = "16.04-LTS",
Version = "latest",
}
}
};
VirtualMachineCreateOrUpdateOperation lro = await vmCollection.CreateOrUpdateAsync(true, vmName, input);
VirtualMachine vm = lro.Value;
#endregion Snippet:Managing_VirtualMachines_CreateAVirtualMachine
}
