Azure.ResourceManager Create VM with new nic example.cs

CreateVm.cs

using Azure;
using Azure.Core;
using Azure.ResourceManager;
using Azure.ResourceManager.Compute;
using Azure.ResourceManager.Compute.Models;
using Azure.ResourceManager.Network;
using Azure.ResourceManager.Network.Models;
using Azure.ResourceManager.Resources;

namespace AutoManageTest
{
    public static class Extensions
    {
        public static async Task<VirtualMachineResource> CreateVM(this SubscriptionResource sub, string resourceGroup, string computerName)
        {
            var rgCollection = sub.GetResourceGroups();
            ResourceGroupResource targetGroup;

            try
            {
                targetGroup = await rgCollection.GetAsync(resourceGroup);
                Console.WriteLine($"Found previous RG, {resourceGroup}");
            }
            catch (Exception ex)
            {
                AzureLocation location = AzureLocation.WestUS2;
                var l = rgCollection.CreateOrUpdate(WaitUntil.Completed, resourceGroup, new ResourceGroupData(location));
                Console.WriteLine("Need to create ResourceGroup");

            }
            finally
            {
                targetGroup = await rgCollection.GetAsync(resourceGroup);
            }

            var vmCollection = targetGroup.GetVirtualMachines();

            try
            {
                var vm2 = await vmCollection.GetAsync(computerName);
                Console.WriteLine("VM Already existed, exiting early");
                return vm2;
            }
            catch (Exception ex)
            {
                Console.WriteLine("Need to create VM");
            }

            var nic = await targetGroup.CreateNicIfNotExistsAsync(computerName);

            // Use the same location as the resource group
            VirtualMachineData input = new VirtualMachineData(targetGroup.Data.Location)
            {
                HardwareProfile = new VirtualMachineHardwareProfile()
                {
                    VmSize = VirtualMachineSizeType.StandardF2
                },
                OSProfile = new VirtualMachineOSProfile()
                {
                    AdminUsername = "adminUser",
                    AdminPassword = "@pPAaaW@220rd!",
                    ComputerName = computerName,
                    LinuxConfiguration = new LinuxConfiguration()
                    {
                        DisablePasswordAuthentication = false,
                    }
                },
                NetworkProfile = new VirtualMachineNetworkProfile()
                {
                    NetworkInterfaces = 
                    {
                      nic
                    }
                },
                StorageProfile = new VirtualMachineStorageProfile()
                {
                    OSDisk = new VirtualMachineOSDisk(DiskCreateOptionType.FromImage)
                    {
                        OSType = SupportedOperatingSystemType.Linux,
                        Caching = CachingType.ReadWrite,
                        ManagedDisk = new VirtualMachineManagedDisk()
                        {
                            StorageAccountType = StorageAccountType.StandardLrs
                        }
                    },
                    ImageReference = new ImageReference()
                    {
                        Publisher = "Canonical",
                        Offer = "UbuntuServer",
                        Sku = "16.04-LTS",
                        Version = "latest",
                    }
                }
            };
            ArmOperation<VirtualMachineResource> lro = await vmCollection.CreateOrUpdateAsync(WaitUntil.Completed, computerName, input);
            VirtualMachineResource vm = lro.Value;

            return vm;
        }

        public static async Task<VirtualMachineNetworkInterfaceReference> CreateNicIfNotExistsAsync(this ResourceGroupResource resourceGroup, string virtualMachineName)
        {
            var networkInterfaceName = virtualMachineName + "_nic";

            NetworkInterfaceCollection networkInterfaces = resourceGroup.GetNetworkInterfaces();

            try
            {
                var l = await networkInterfaces.GetAsync(networkInterfaceName);
                Console.WriteLine("Found previous NIC, reusing");
                return l.Value.ToVmNicReference(); ;
            }
            catch
            {
                Console.WriteLine("Need to create NIC, continuing");
            }
            
            var networkGroup = await resourceGroup.CreateVirtualNetworksIfNotExistsAsync(virtualMachineName);
            var subnet = networkGroup.GetSubnets().FirstOrDefault().Id;

            NetworkInterfaceIPConfigurationData networkInterfaceIPConfiguration = new NetworkInterfaceIPConfigurationData()
            {
                Name = "Primary",
                Primary = true,
                Subnet = new SubnetData() { Id = subnet },
                PrivateIPAllocationMethod = NetworkIPAllocationMethod.Dynamic,
            };

            NetworkInterfaceData nicData = new NetworkInterfaceData();
            nicData.Location = AzureLocation.WestUS2;
            nicData.IPConfigurations.Add(networkInterfaceIPConfiguration);
            var networkInterfaceOperation = await networkInterfaces.CreateOrUpdateAsync(WaitUntil.Completed, networkInterfaceName, nicData);
            
            return networkInterfaceOperation.Value.ToVmNicReference();
        }

        public static async Task<VirtualNetworkResource> CreateVirtualNetworksIfNotExistsAsync(this ResourceGroupResource resourceGroup, string virtualMachineName)
        {

            var networkGroups = resourceGroup.GetVirtualNetworks();
            var targetName = $"{virtualMachineName}_netwrk";

            if (networkGroups.Count() != 0)
            {
                Console.Write("Network groups exist, using the first one");
                return networkGroups.FirstOrDefault();
            }

            Console.WriteLine("Need to create a virtual network");
            VirtualNetworkData virtualNetworkData = new VirtualNetworkData()
            {
                Location= AzureLocation.WestUS2,
                Subnets =
            {
                new SubnetData()
                {
                    Name = targetName,
                    AddressPrefix = "10.0.0.0/24"
                }
            }
            };

            virtualNetworkData.AddressPrefixes.Add("10.0.0.0/16");
            var virtualNetworkOperation = await networkGroups.CreateOrUpdateAsync(WaitUntil.Completed, targetName, virtualNetworkData);
            var virtualNetwork = virtualNetworkOperation.Value;

            return virtualNetwork;
        }

        public static VirtualMachineNetworkInterfaceReference ToVmNicReference(this NetworkInterfaceResource networkInterfaceResource)
        {
            var vmNicReference = new VirtualMachineNetworkInterfaceReference()
            {
                Id = networkInterfaceResource.Id
            };

            return vmNicReference;
        }
    }
}