private void SetEnvironmentVMResourceMocks() { var expectedAgent = new TaskAgent("environmentVMResourceName") { Id = 35 }; expectedAgent.Authorization = new TaskAgentAuthorization { ClientId = Guid.NewGuid(), AuthorizationUrl = new Uri("http://localhost:8080/tfs"), }; var environmentPool = new TaskAgentPoolReference { Id = 57 }; var expectedEnvironmentVMResource = new VirtualMachineResource { Agent = expectedAgent, Id = _expectedEnvironmentVMResourceId, Name = "environmentVMResourceName" }; _environmentsServer.Setup(x => x.ConnectAsync(It.IsAny <VssConnection>())).Returns(Task.FromResult <object>(null)); _environmentsServer.Setup(x => x.AddEnvironmentVMAsync(It.IsAny <Guid>(), It.IsAny <int>(), It.IsAny <VirtualMachineResource>())).Returns(Task.FromResult(expectedEnvironmentVMResource)); _environmentsServer.Setup(x => x.ReplaceEnvironmentVMAsync(It.IsAny <Guid>(), It.IsAny <int>(), It.IsAny <VirtualMachineResource>())).Returns(Task.FromResult(expectedEnvironmentVMResource)); _environmentsServer.Setup(x => x.GetEnvironmentVMsAsync(It.IsAny <Guid>(), It.IsAny <int>(), It.IsAny <string>())).Returns(Task.FromResult(new List <VirtualMachineResource>() { })); _environmentsServer.Setup(x => x.DeleteEnvironmentVMAsync(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult <object>(null)); _environmentsServer.Setup(x => x.GetEnvironmentPoolAsync(It.IsAny <Guid>(), It.IsAny <int>())).Returns(Task.FromResult(environmentPool)); }
public async Task CreateOrUpdate() { string vmName = Recording.GenerateAssetName("testVM-"); VirtualMachineResource virtualMachine = await CreateVirtualMachineAsync(vmName); Assert.AreEqual(vmName, virtualMachine.Data.Name); }
public async Task Exists() { var vmName = Recording.GenerateAssetName("testvm"); var _virtualMachineCollection = await GetVirtualMachineCollectionAsync(); var _extendedLocation = new ExtendedLocation() { Name = CustomLocationId, ExtendedLocationType = EXTENDED_LOCATION_TYPE }; var _placementProfile = new PlacementProfile() { ResourcePoolId = _resourcePoolId }; var virtualMachineBody = new VirtualMachineData(DefaultLocation); virtualMachineBody.VCenterId = VcenterId; virtualMachineBody.ExtendedLocation = _extendedLocation; virtualMachineBody.PlacementProfile = _placementProfile; virtualMachineBody.TemplateId = _vmTemplateId; // create virtual machine VirtualMachineResource vm1 = (await _virtualMachineCollection.CreateOrUpdateAsync(WaitUntil.Completed, vmName, virtualMachineBody)).Value; Assert.IsNotNull(vm1); Assert.AreEqual(vm1.Id.Name, vmName); // check for exists virtual machine bool exists = await _virtualMachineCollection.ExistsAsync(vmName); Assert.IsTrue(exists); }
public async Task GetAllInSubscription() { var collection = await GetVirtualMachineCollectionAsync(); var vmName1 = Recording.GenerateAssetName("testVM-"); var vmName2 = Recording.GenerateAssetName("testVM-"); var nic1 = await CreateBasicDependenciesOfVirtualMachineAsync(); var nic2 = await CreateBasicDependenciesOfVirtualMachineAsync(); var input1 = ResourceDataHelper.GetBasicLinuxVirtualMachineData(DefaultLocation, vmName1, nic1.Id); var input2 = ResourceDataHelper.GetBasicLinuxVirtualMachineData(DefaultLocation, vmName2, nic2.Id); _ = await collection.CreateOrUpdateAsync(WaitUntil.Completed, vmName1, input1); _ = await collection.CreateOrUpdateAsync(WaitUntil.Completed, vmName2, input2); VirtualMachineResource vm1 = null, vm2 = null; await foreach (var vm in DefaultSubscription.GetVirtualMachinesAsync()) { if (vm.Data.Name == vmName1) { vm1 = vm; } if (vm.Data.Name == vmName2) { vm2 = vm; } } Assert.NotNull(vm1); Assert.NotNull(vm2); }
public async Task Update() { var vmName = Recording.GenerateAssetName("testVM-"); var vm = await CreateVirtualMachineAsync(vmName); //// Create a PPG here and add this PPG to this virtual machine using Update //var ppgName = Recording.GenerateAssetName("testPPG-"); //var ppgData = new ProximityPlacementGroupData(DefaultLocation) { }; //var ppgLRO = await _resourceGroup.GetProximityPlacementGroups().CreateOrUpdateAsync(ppgName, ppgData); //var ppg = ppgLRO.Value; // update PPG requires the VM to be deallocated await vm.DeallocateAsync(WaitUntil.Completed); var update = new PatchableVirtualMachineData() { HardwareProfile = new HardwareProfile { VmSize = VirtualMachineSizeTypes.StandardF1 } }; var lro = await vm.UpdateAsync(WaitUntil.Completed, update); VirtualMachineResource updatedVM = lro.Value; Assert.AreEqual(VirtualMachineSizeTypes.StandardF1, updatedVM.Data.HardwareProfile.VmSize); }
public override async Task <TaskAgent> AddAgentAsync(AgentSettings agentSettings, TaskAgent agent, CommandSettings command) { ArgUtil.NotNull(agentSettings, nameof(agentSettings)); ArgUtil.NotNull(agent, nameof(agent)); ArgUtil.NotNull(command, nameof(command)); var virtualMachine = new VirtualMachineResource() { Name = agent.Name, Agent = agent }; var tags = GetVirtualMachineResourceTags(command); virtualMachine.Tags = tags; virtualMachine = await _environmentsServer.AddEnvironmentVMAsync(new Guid(agentSettings.ProjectId), agentSettings.EnvironmentId, virtualMachine); Trace.Info("Environment virtual machine resource with name: '{0}', id: '{1}' has been added successfully.", virtualMachine.Name, virtualMachine.Id); var pool = await _environmentsServer.GetEnvironmentPoolAsync(new Guid(agentSettings.ProjectId), agentSettings.EnvironmentId); Trace.Info("environment pool id: '{0}'", pool.Id); agentSettings.PoolId = pool.Id; agentSettings.AgentName = virtualMachine.Name; agentSettings.EnvironmentVMResourceId = virtualMachine.Id; return(virtualMachine.Agent); }
public async Task UpdateVmIdentityFromSystemUserToNone() { var collection = await GetVirtualMachineCollectionAsync(); var vmName = Recording.GenerateAssetName("testVM-"); var nic = await CreateBasicDependenciesOfVirtualMachineAsync(); var input = ResourceDataHelper.GetBasicLinuxVirtualMachineData(DefaultLocation, vmName, nic.Id); input.Identity = new ManagedServiceIdentity(ManagedServiceIdentityType.SystemAssignedUserAssigned); var userAssignedIdentity = await CreateUserAssignedIdentityAsync(); input.Identity.UserAssignedIdentities.Add(userAssignedIdentity.Id, new UserAssignedIdentity()); var lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, vmName, input); VirtualMachineResource virtualMachine = lro.Value; Assert.AreEqual(vmName, virtualMachine.Data.Name); Assert.AreEqual(ManagedServiceIdentityType.SystemAssignedUserAssigned, virtualMachine.Data.Identity.ManagedServiceIdentityType); Assert.AreEqual(virtualMachine.Data.Identity.UserAssignedIdentities.Count, 1); Assert.NotNull(virtualMachine.Data.Identity.PrincipalId); Assert.NotNull(virtualMachine.Data.Identity.UserAssignedIdentities[userAssignedIdentity.Id].PrincipalId); var identity = new ManagedServiceIdentity(ManagedServiceIdentityType.None); var updateOptions = new VirtualMachinePatch() { Identity = identity }; lro = await virtualMachine.UpdateAsync(WaitUntil.Completed, updateOptions); VirtualMachineResource updatedVM = lro.Value; Assert.Null(updatedVM.Data.Identity); }
public async Task Get() { var vmName = Recording.GenerateAssetName("testVM-"); var vm = await CreateVirtualMachineAsync(vmName); VirtualMachineResource vm2 = await vm.GetAsync(); ResourceDataHelper.AssertVirtualMachine(vm.Data, vm2.Data); }
public VirtualMachineResource Build() { var res = new VirtualMachineResource() { CPU = _cpu, HardDisk = _hardDiskSpace, RAM = _ram, OperatingSystem = _operatingSystem.Build() }; return(res); }
public async Task Get() { var collection = await GetVirtualMachineCollectionAsync(); var vmName = Recording.GenerateAssetName("testVM-"); var nic = await CreateBasicDependenciesOfVirtualMachineAsync(); var input = ResourceDataHelper.GetBasicLinuxVirtualMachineData(DefaultLocation, vmName, nic.Id); var lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, vmName, input); VirtualMachineResource vm1 = lro.Value; VirtualMachineResource vm2 = await collection.GetAsync(vmName); ResourceDataHelper.AssertVirtualMachine(vm1.Data, vm2.Data); }
public async Task BootDiagnostic() { string vmName = Recording.GenerateAssetName("testVM-"); VirtualMachineResource virtualMachine = await CreateVirtualMachineAsync(vmName); Assert.IsNull(virtualMachine.Data.BootDiagnostics); PatchableVirtualMachineData updateOptions = new PatchableVirtualMachineData(); updateOptions.BootDiagnostics = new BootDiagnostics(); updateOptions.BootDiagnostics.Enabled = true; virtualMachine = (await virtualMachine.UpdateAsync(WaitUntil.Completed, updateOptions)).Value; Assert.AreEqual(true, virtualMachine.Data.BootDiagnostics.Enabled); updateOptions.BootDiagnostics = null; virtualMachine = (await virtualMachine.UpdateAsync(WaitUntil.Completed, updateOptions)).Value; var originalBootDiag = virtualMachine.Data.BootDiagnostics; var originalEnabled = virtualMachine.Data.BootDiagnostics?.Enabled; string vmName2 = Recording.GenerateAssetName("testVM-"); VirtualMachineResource virtualMachine2 = await CreateVirtualMachineAsync(vmName2); Assert.IsNull(virtualMachine2.Data.DiagnosticsProfile?.BootDiagnostics); PatchableVirtualMachineData updateOptions2 = new PatchableVirtualMachineData(); updateOptions2.DiagnosticsProfile = new DiagnosticsProfile(); updateOptions2.DiagnosticsProfile.BootDiagnostics = new BootDiagnostics(); updateOptions2.DiagnosticsProfile.BootDiagnostics.Enabled = true; virtualMachine2 = (await virtualMachine2.UpdateAsync(WaitUntil.Completed, updateOptions2)).Value; Assert.AreEqual(true, virtualMachine2.Data.DiagnosticsProfile.BootDiagnostics.Enabled); updateOptions2.DiagnosticsProfile.BootDiagnostics = null; virtualMachine2 = (await virtualMachine2.UpdateAsync(WaitUntil.Completed, updateOptions2)).Value; var newBootDiag = virtualMachine2.Data.DiagnosticsProfile?.BootDiagnostics; var newEnabled = virtualMachine2.Data.DiagnosticsProfile?.BootDiagnostics?.Enabled; Assert.AreEqual(originalBootDiag is null, newBootDiag is null); Assert.AreEqual(originalEnabled, newEnabled); updateOptions2.DiagnosticsProfile = null; virtualMachine2 = (await virtualMachine2.UpdateAsync(WaitUntil.Completed, updateOptions2)).Value; newBootDiag = virtualMachine2.Data.DiagnosticsProfile?.BootDiagnostics; newEnabled = virtualMachine2.Data.DiagnosticsProfile?.BootDiagnostics?.Enabled; Assert.AreEqual(originalBootDiag is null, newBootDiag is null); Assert.AreEqual(originalEnabled, newEnabled); }
public async Task UpdateVmIdentityFromTwoUsersToOneUser() { var collection = await GetVirtualMachineCollectionAsync(); var vmName = Recording.GenerateAssetName("testVM-"); var nic = await CreateBasicDependenciesOfVirtualMachineAsync(); var input = ResourceDataHelper.GetBasicLinuxVirtualMachineData(DefaultLocation, vmName, nic.Id); input.Identity = new ManagedServiceIdentity(ManagedServiceIdentityType.UserAssigned); var userAssignedIdentity1 = await CreateUserAssignedIdentityAsync(); input.Identity.UserAssignedIdentities.Add(userAssignedIdentity1.Id, new UserAssignedIdentity()); var userAssignedIdentity2 = await CreateUserAssignedIdentityAsync(); input.Identity.UserAssignedIdentities.Add(userAssignedIdentity2.Id, new UserAssignedIdentity()); var lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, vmName, input); VirtualMachineResource virtualMachine = lro.Value; Assert.AreEqual(vmName, virtualMachine.Data.Name); Assert.AreEqual(ManagedServiceIdentityType.UserAssigned, virtualMachine.Data.Identity.ManagedServiceIdentityType); Assert.AreEqual(virtualMachine.Data.Identity.UserAssignedIdentities.Count, 2); Assert.Null(virtualMachine.Data.Identity.PrincipalId); Assert.NotNull(virtualMachine.Data.Identity.UserAssignedIdentities[userAssignedIdentity1.Id].PrincipalId); Assert.NotNull(virtualMachine.Data.Identity.UserAssignedIdentities[userAssignedIdentity2.Id].PrincipalId); // With JSON Merge Patch, we can use null to delete an identity from the dictionary. var identity = new ManagedServiceIdentity(ManagedServiceIdentityType.UserAssigned); identity.UserAssignedIdentities.Add(userAssignedIdentity1.Id, null); var updateOptions = new VirtualMachinePatch() { Identity = identity }; lro = await virtualMachine.UpdateAsync(WaitUntil.Completed, updateOptions); VirtualMachineResource updatedVM = lro.Value; Assert.AreEqual(ManagedServiceIdentityType.UserAssigned, updatedVM.Data.Identity.ManagedServiceIdentityType); Assert.AreEqual(updatedVM.Data.Identity.UserAssignedIdentities.Count, 1); Assert.Null(updatedVM.Data.Identity.PrincipalId); Assert.IsFalse(updatedVM.Data.Identity.UserAssignedIdentities.ContainsKey(userAssignedIdentity1.Id)); Assert.NotNull(updatedVM.Data.Identity.UserAssignedIdentities[userAssignedIdentity2.Id].PrincipalId); }
public async Task Exists() { var collection = await GetVirtualMachineCollectionAsync(); var vmName = Recording.GenerateAssetName("testVM-"); var nic = await CreateBasicDependenciesOfVirtualMachineAsync(); var input = ResourceDataHelper.GetBasicLinuxVirtualMachineData(DefaultLocation, vmName, nic.Id); var lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, vmName, input); VirtualMachineResource vm = lro.Value; Assert.IsTrue(await collection.ExistsAsync(vmName)); Assert.IsFalse(await collection.ExistsAsync(vmName + "1")); Assert.ThrowsAsync <ArgumentNullException>(async() => _ = await collection.ExistsAsync(null)); }
public async Task DeleteVirtualMachine() { #region Snippet:Managing_VirtualMachines_DeleteVirtualMachine ArmClient armClient = new ArmClient(new DefaultAzureCredential()); SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync(); // first we need to get the resource group string rgName = "myRgName"; ResourceGroupResource resourceGroup = await subscription.GetResourceGroups().GetAsync(rgName); // Now we get the virtual machine collection from the resource group VirtualMachineCollection vmCollection = resourceGroup.GetVirtualMachines(); string vmName = "myVM"; VirtualMachineResource vm = await vmCollection.GetAsync(vmName); await vm.DeleteAsync(WaitUntil.Completed); #endregion Snippet:Managing_VirtualMachines_DeleteVirtualMachine }
public async Task UpdateVmIdentityFromUserToTwoUsers() { var collection = await GetVirtualMachineCollectionAsync(); var vmName = Recording.GenerateAssetName("testVM-"); var nic = await CreateBasicDependenciesOfVirtualMachineAsync(); var input = ResourceDataHelper.GetBasicLinuxVirtualMachineData(DefaultLocation, vmName, nic.Id); input.Identity = new ManagedServiceIdentity(ManagedServiceIdentityType.UserAssigned); var userAssignedIdentity = await CreateUserAssignedIdentityAsync(); input.Identity.UserAssignedIdentities.Add(userAssignedIdentity.Id, new UserAssignedIdentity()); var lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, vmName, input); VirtualMachineResource virtualMachine = lro.Value; Assert.AreEqual(vmName, virtualMachine.Data.Name); Assert.AreEqual(ManagedServiceIdentityType.UserAssigned, virtualMachine.Data.Identity.ManagedServiceIdentityType); Assert.AreEqual(virtualMachine.Data.Identity.UserAssignedIdentities.Count, 1); Assert.Null(virtualMachine.Data.Identity.PrincipalId); Assert.NotNull(virtualMachine.Data.Identity.UserAssignedIdentities[userAssignedIdentity.Id].PrincipalId); // With JSON Merge Patch, we only need to put the identity to add in the dictionary for update operation. var identity2 = new ManagedServiceIdentity(ManagedServiceIdentityType.UserAssigned); var userAssignedIdentity2 = await CreateUserAssignedIdentityAsync(); identity2.UserAssignedIdentities.Add(userAssignedIdentity2.Id, new UserAssignedIdentity()); var updateOptions = new PatchableVirtualMachineData() { Identity = identity2 }; lro = await virtualMachine.UpdateAsync(WaitUntil.Completed, updateOptions); VirtualMachineResource updatedVM = lro.Value; Assert.AreEqual(ManagedServiceIdentityType.UserAssigned, updatedVM.Data.Identity.ManagedServiceIdentityType); Assert.AreEqual(updatedVM.Data.Identity.UserAssignedIdentities.Count, 2); Assert.Null(updatedVM.Data.Identity.PrincipalId); Assert.NotNull(updatedVM.Data.Identity.UserAssignedIdentities[userAssignedIdentity.Id].PrincipalId); Assert.NotNull(updatedVM.Data.Identity.UserAssignedIdentities[userAssignedIdentity2.Id].PrincipalId); }
public async Task CreateVmWithSystemAssignedIdentity() { var collection = await GetVirtualMachineCollectionAsync(); var vmName = Recording.GenerateAssetName("testVM-"); var nic = await CreateBasicDependenciesOfVirtualMachineAsync(); var input = ResourceDataHelper.GetBasicLinuxVirtualMachineData(DefaultLocation, vmName, nic.Id); input.Identity = new ManagedServiceIdentity(ManagedServiceIdentityType.SystemAssigned); var lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, vmName, input); VirtualMachineResource virtualMachine = lro.Value; Assert.AreEqual(vmName, virtualMachine.Data.Name); Assert.AreEqual(ManagedServiceIdentityType.SystemAssigned, virtualMachine.Data.Identity.ManagedServiceIdentityType); Assert.IsEmpty(virtualMachine.Data.Identity.UserAssignedIdentities); Assert.NotNull(virtualMachine.Data.Identity.PrincipalId); Assert.NotNull(virtualMachine.Data.Identity.TenantId); }
public void Provider_Should_Create_Linux_VirtualMachine_Infrastructure_Json_File() { //Arrang int cpu = 8; int ram = 4; int hdd = 40; LinuxDistribution linuxDistribution = LinuxDistribution.Suse; var expectedObject = new VirtualMachineResource { CPU = cpu, HardDisk = hdd, RAM = ram, OperatingSystem = linuxDistribution.ToString() }; var fileSystemMock = new Mock <IFileManager>(); fileSystemMock.Setup(w => w.WriteJsonFile(It.IsAny <object>(), It.IsAny <string>(), It.IsAny <string>())) .Verifiable(); //Act var provider = new Providers.Provider(_providerName, fileSystemMock.Object); var infra = provider.CreateInfrastructure("UAT"); infra.VirtualMachine(new Linux(linuxDistribution), hdd, ram, cpu); //Assert fileSystemMock.Verify(mock => mock.WriteJsonFile(It.IsAny <object>(), It.IsAny <string>(), It.IsAny <string>()), Times.Once()); fileSystemMock.Verify(mock => mock.WriteJsonFile(expectedObject, @"c:\test\UAT\VirtualMachine", "UAT_Server.json"), Times.Once()); }
public void Build_Windows_VirtualMachine_with_Right_Object() { //Arrange int cpu = 8; int ram = 4; int hdd = 40; WindowsVersion windowsVersion = WindowsVersion.WindowsServer2012; var vm = new VirtualMachine(new Windows(windowsVersion), hdd, ram, cpu); var excepted = new VirtualMachineResource { CPU = 8, HardDisk = 40, RAM = 4, OperatingSystem = "WindowsServer2012" }; //Act var action = vm.Build(); //Assert Assert.AreEqual(excepted, action); }
public void Build_Linux_VirtualMachine_with_Right_Object() { //Arrange int cpu = 8; int ram = 4; int hdd = 40; LinuxDistribution linuxDistribution = LinuxDistribution.Debian; var vm = new VirtualMachine(new Linux(linuxDistribution), hdd, ram, cpu); var excepted = new VirtualMachineResource { CPU = 8, HardDisk = 40, RAM = 4, OperatingSystem = "Debian" }; //Act var action = vm.Build(); //Assert Assert.AreEqual(excepted, action); }
public async Task CreateVirtualMachine() { #region Snippet:Managing_VirtualMachines_CreateAVirtualMachine ArmClient armClient = new ArmClient(new DefaultAzureCredential()); SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync(); // first we need to get the resource group string rgName = "myRgName"; ResourceGroupResource 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, SshPublicKeys = { new SshPublicKeyInfo() { Path = $"/home/adminUser/.ssh/authorized_keys", KeyData = "<value of the public ssh key>", } } } }, NetworkProfile = new NetworkProfile() { NetworkInterfaces = { new NetworkInterfaceReference() { Id = new ResourceIdentifier("/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", } } }; ArmOperation <VirtualMachineResource> lro = await vmCollection.CreateOrUpdateAsync(WaitUntil.Completed, vmName, input); VirtualMachineResource vm = lro.Value; #endregion Snippet:Managing_VirtualMachines_CreateAVirtualMachine }
public Task <VirtualMachineResource> ReplaceEnvironmentVMAsync(Guid projectId, int environmentId, VirtualMachineResource virtualMachineResource) { CheckConnection(); return(_environmentsHttpClient.ReplaceVirtualMachineResourceAsync(projectId, environmentId, virtualMachineResource)); }
public Task <VirtualMachineResource> AddEnvironmentVMAsync(Guid projectId, int environmentId, VirtualMachineResource virtualMachineResource) { CheckConnection(); var virtualMachineResourceCreateParameters = new VirtualMachineResourceCreateParameters(); virtualMachineResourceCreateParameters.virtualMachineResource = virtualMachineResource; return(_environmentsHttpClient.AddVirtualMachineResourceAsync(projectId.ToString(), environmentId, virtualMachineResourceCreateParameters)); }
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 }
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 }