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
}
