/// <summary>
/// Instantiate a new VM Role
/// </summary>
public static Role CreateVMRole(this IVirtualMachineOperations client, string cloudServiceName, string roleName, string image, string size, string userName, string password, OSVirtualHardDisk osVHD)
{
Role vmRole = new Role
{
RoleType = VirtualMachineRoleType.PersistentVMRole.ToString(),
RoleName = roleName,
Label = roleName,
RoleSize = size,
ConfigurationSets = new List<ConfigurationSet>(),
//OSVirtualHardDisk = osVHD,
ProvisionGuestAgent = true,
ResourceExtensionReferences = null,
VMImageName = image,
//OSVersion = "Windows Server 2012 R2 Datacenter"
};
ConfigurationSet configSet = new ConfigurationSet
{
ConfigurationSetType = ConfigurationSetTypes.WindowsProvisioningConfiguration,
EnableAutomaticUpdates = true,
ResetPasswordOnFirstLogon = false,
ComputerName = roleName,
AdminUserName = userName,
AdminPassword = password,
InputEndpoints = new BindingList<InputEndpoint>
{
new InputEndpoint { LocalPort = 3389, Name = "RDP", Protocol = "tcp" },
new InputEndpoint { LocalPort = 80, Port = 80, Name = "web", Protocol = "tcp" }
}
};
vmRole.ConfigurationSets.Add(configSet);
return vmRole;
}
/// <summary>
/// Initializes a new instance of the VirtualMachineUpdateParameters
/// class with required arguments.
/// </summary>
public VirtualMachineUpdateParameters(string roleName, OSVirtualHardDisk oSVirtualHardDisk)
: this()
{
if (roleName == null)
{
throw new ArgumentNullException("roleName");
}
if (oSVirtualHardDisk == null)
{
throw new ArgumentNullException("oSVirtualHardDisk");
}
this.RoleName = roleName;
this.OSVirtualHardDisk = oSVirtualHardDisk;
}
/// <summary>
/// Initializes a new instance of the VirtualMachineUpdateParameters
/// class with required arguments.
/// </summary>
public VirtualMachineUpdateParameters(string roleName, OSVirtualHardDisk oSVirtualHardDisk)
: this()
{
if (roleName == null)
{
throw new ArgumentNullException("roleName");
}
if (oSVirtualHardDisk == null)
{
throw new ArgumentNullException("oSVirtualHardDisk");
}
this.RoleName = roleName;
this.OSVirtualHardDisk = oSVirtualHardDisk;
}
public static OSVirtualHardDisk CreateOSVHD(this IVirtualMachineVMImageOperations operation, string cloudserviceName, string vmName, string storageAccount, string imageFamiliyName)
{
try
{
var osVHD = new OSVirtualHardDisk
{
MediaLink = GetVhdUri(string.Format("{0}.blob.core.windows.net/vhds", storageAccount), cloudserviceName, vmName),
SourceImageName = GetSourceImageNameByFamliyName(operation, imageFamiliyName)
};
//osVHD.OperatingSystem = "Windows";
return osVHD;
}
catch (CloudException e)
{
throw e;
}
}
/// <summary>
/// Create virtual machine
/// </summary>
/// <param name="hostedServiceName"></param>
/// <param name="osVirtualHardDisk"></param>
/// <param name="configurationSets"></param>
/// <param name="dataVirtualHardDisks"></param>
/// <param name="virtualMachineName"></param>
/// <param name="deploymentName"></param>
/// <returns></returns>
public string CreateVirtualMachine(
string hostedServiceName,
OSVirtualHardDisk osVirtualHardDisk,
IList<ConfigurationSet> configurationSets,
IList<DataVirtualHardDisk> dataVirtualHardDisks = null,
string virtualMachineName = "",
string deploymentName = "")
{
if (string.IsNullOrEmpty(deploymentName))
{
deploymentName = Dependencies.TestResourcesCollector.GetUniqueDeploymentName();
}
if (string.IsNullOrEmpty(virtualMachineName))
{
virtualMachineName = Dependencies.TestResourcesCollector.GetUniqueVirtualMachineName();
}
var csm = new AzureCloudServiceManager();
csm.CreateOrUpdateDeployment(hostedServiceName, new DeploymentCreateParameters { Name = deploymentName });
var vmDeployment = csm.CreateOrUpdateDeployment(hostedServiceName, new DeploymentCreateParameters {
Name = deploymentName,
Label = Base64EncodingHelper.EncodeToBase64String(AzureServiceConstants.DefaultLabel)
});
var vmRole = new Role
{
RoleName = virtualMachineName,
RoleType = "PersistentVMRole",
OSVirtualHardDisk = osVirtualHardDisk,
ConfigurationSets = configurationSets,
DataVirtualHardDisks = dataVirtualHardDisks
};
vmDeployment.Roles.Add(vmRole);
return CreateVirtualMachine(hostedServiceName, vmDeployment, virtualMachineName);
}
private void GenerateVM(string serviceName, VMConfigModel vmConfig, string virtualMachineName,
int rdpPort, VMUserModel user, bool firstVMInDeployment)
{
var windowsConfigurationSet = new ConfigurationSet
{
//TODO: depends on the OS type??
ConfigurationSetType = ConfigurationSetTypes.WindowsProvisioningConfiguration,
AdminPassword = user.Password,
AdminUserName = user.Username,
ComputerName = virtualMachineName,
HostName = string.Format("{0}.cloudapp.net", serviceName),
};
var endpoints = new ConfigurationSet
{
ConfigurationSetType = "NetworkConfiguration",
InputEndpoints = new List<InputEndpoint>
{
new InputEndpoint
{
Name = "RDP",
Port = rdpPort,
Protocol = "TCP",
LocalPort = InternalRdpPort
}
}
};
string newVhdName = string.Format("{0}.vhd", virtualMachineName);
Uri mediaUri = new Uri(GetVHDStorageUrl(vmConfig.Region) + newVhdName);
var vhd = new OSVirtualHardDisk
{
SourceImageName = vmConfig.ImageName,
HostCaching = VirtualHardDiskHostCaching.ReadWrite,
MediaLink = mediaUri,
};
OperationStatusResponse deploymentResult;
if (firstVMInDeployment)
{
deploymentResult = CreateDeployment(serviceName, virtualMachineName, windowsConfigurationSet, endpoints, vhd, vmConfig);
}
else
{
deploymentResult = AddVm(serviceName, virtualMachineName, windowsConfigurationSet, endpoints, vhd, vmConfig);
}
//TODO: handle the deploymentResult
}
private OperationStatusResponse CreateDeployment(string serviceName, string virtualMachineName, ConfigurationSet windowsConfigurationSet, ConfigurationSet endpoints, OSVirtualHardDisk vhd, VMConfigModel vmConfig)
{
OperationStatusResponse deploymentResult;
var role = new Role
{
RoleName = virtualMachineName,
RoleSize = MapToAzureVmSize(vmConfig.VmSize),
RoleType = VirtualMachineRoleType.PersistentVMRole.ToString(),
OSVirtualHardDisk = vhd,
ProvisionGuestAgent = true,
ConfigurationSets = new List<ConfigurationSet>
{
windowsConfigurationSet,
endpoints,
}
};
if (vmConfig.InsertCaptureScript)
{
role.ResourceExtensionReferences =
CreateCaptureScript(vmConfig.CaptureKey, vmConfig.ChocoPackageList);
}
var createDeploymentParameters = new VirtualMachineCreateDeploymentParameters
{
Name = serviceName,
Label = serviceName,
DeploymentSlot = DeploymentSlot.Production,
Roles = new List<Role> { role },
};
deploymentResult = _compute.VirtualMachines.CreateDeployment(
serviceName,
createDeploymentParameters);
return deploymentResult;
}
private OperationStatusResponse AddVm(string serviceName, string virtualMachineName, ConfigurationSet windowsConfigurationSet, ConfigurationSet endpoints, OSVirtualHardDisk vhd, VMConfigModel vmConfig)
{
OperationStatusResponse deploymentResult;
var createVMParameters = new VirtualMachineCreateParameters
{
RoleName = virtualMachineName,
RoleSize = MapToAzureVmSize(vmConfig.VmSize),
OSVirtualHardDisk = vhd,
ProvisionGuestAgent = true,
ConfigurationSets = new List<ConfigurationSet>
{
windowsConfigurationSet,
endpoints,
},
};
if (vmConfig.InsertCaptureScript)
{
createVMParameters.ResourceExtensionReferences =
CreateCaptureScript(vmConfig.CaptureKey, vmConfig.ChocoPackageList);
}
deploymentResult = _compute.VirtualMachines.Create(serviceName, serviceName, createVMParameters);
return deploymentResult;
}
private static OSVirtualHardDisk SetOsVirtualHardDisk(string virtualMachineName, string storageAccountName,
string imageName)
{
var vhd = new OSVirtualHardDisk
{
SourceImageName = imageName,
HostCaching = VirtualHardDiskHostCaching.ReadWrite,
MediaLink = new Uri(string.Format(CultureInfo.InvariantCulture,
"https://{0}.blob.core.windows.net/vhds/{1}.vhd", storageAccountName, virtualMachineName),
UriKind.Absolute)
};
return vhd;
}
/// <summary>
/// Creates deployment and virtual machines in destination subscription.
/// </summary>
/// <param name="deploymentDetails">Deployment details</param>
/// <param name="serviceName">Cloud service name</param>
private void CreateDeployment(Deployment deploymentDetails, string serviceName)
{
string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Logger.Info(methodName, ProgressResources.ExecutionStarted, ResourceType.Deployment.ToString(), deploymentDetails.Name);
Stopwatch swTotalDeploymentWithVMs = new Stopwatch();
swTotalDeploymentWithVMs.Start();
if (!deploymentDetails.IsImported)
{
//List<Uri> disks = null;
string containerName;
using (var client = new ComputeManagementClient(importParameters.SourceSubscriptionSettings.Credentials,
importParameters.SourceSubscriptionSettings.ServiceUrl))
{
try
{
using (var computeClient = new ComputeManagementClient(importParameters.DestinationSubscriptionSettings.Credentials))
{
for (int virtualMachineNumber = 0; virtualMachineNumber < deploymentDetails.VirtualMachines.Count(); virtualMachineNumber++)
{
VirtualMachine virtualMachine = deploymentDetails.VirtualMachines[virtualMachineNumber];
// Check if virtual machine is already imported, if not create new virtual machine
if (!virtualMachine.IsImported)
{
string sourceStorageAccountName = virtualMachine.VirtualMachineDetails.OSVirtualHardDisk.MediaLink.Host.Substring(
0, virtualMachine.VirtualMachineDetails.OSVirtualHardDisk.MediaLink.Host.IndexOf('.'));
string accountName = GetDestinationResourceName(ResourceType.StorageAccount, sourceStorageAccountName);
Stopwatch swDeployment = new Stopwatch();
swDeployment.Start();
containerName = virtualMachine.VirtualMachineDetails.OSVirtualHardDisk.MediaLink.Segments[1].Substring(0,
virtualMachine.VirtualMachineDetails.OSVirtualHardDisk.MediaLink.Segments[1].IndexOf('/')); ;
// Set up the Virtual Hard Disk with the OS Disk
var vhd = new OSVirtualHardDisk
{
HostCaching = virtualMachine.VirtualMachineDetails.OSVirtualHardDisk.HostCaching,
//IOType is implicitly determined from the MediaLink. This should not be explicitly specified in the request.
Label = virtualMachine.VirtualMachineDetails.OSVirtualHardDisk.Label,
MediaLink = new Uri(string.Format(CultureInfo.InvariantCulture,
Constants.StorageAccountMediaLink,
accountName, containerName,
virtualMachine.VirtualMachineDetails.OSVirtualHardDisk.MediaLink.Segments.Last()), UriKind.Absolute),
Name = string.Format("{0}{1}", importParameters.DestinationPrefixName,
GetDestinationResourceName(ResourceType.OSDisk, virtualMachine.VirtualMachineDetails.OSVirtualHardDisk.Name,
ResourceType.CloudService, serviceName)),
OperatingSystem = virtualMachine.VirtualMachineDetails.OSVirtualHardDisk.OperatingSystem,
//SourceImageName should be set only when creating the virtual machine from an image. Here we create it from a disk.
};
// Set up the Data Disk
List<DataVirtualHardDisk> dataDisks = new List<DataVirtualHardDisk>();
foreach (var disk in virtualMachine.VirtualMachineDetails.DataVirtualHardDisks)
{
dataDisks.Add(new DataVirtualHardDisk
{
HostCaching = disk.HostCaching,
//IOType is implicitly determined from the MediaLink. This should not be explicitly specified in the request.
Label = disk.Label,
LogicalDiskSizeInGB = disk.LogicalDiskSizeInGB,
LogicalUnitNumber = disk.LogicalUnitNumber,
MediaLink = new Uri(string.Format(CultureInfo.InvariantCulture,
Constants.StorageAccountMediaLink, accountName, containerName,
disk.MediaLink.Segments.Last()), UriKind.Absolute),
Name = string.Format("{0}{1}", importParameters.DestinationPrefixName,
GetDestinationResourceName(ResourceType.HardDisk, disk.Name, ResourceType.CloudService, serviceName)),
SourceMediaLink = new Uri(string.Format(CultureInfo.InvariantCulture,
Constants.StorageAccountMediaLink, accountName, containerName,
disk.MediaLink.Segments.Last()), UriKind.Absolute)
});
};
// Deploy the Virtual Machine
Logger.Info(methodName, string.Format(ProgressResources.ImportVirtualMachineStarted,
virtualMachine.VirtualMachineDetails.RoleName, deploymentDetails.Name),
ResourceType.VirtualMachine.ToString(), virtualMachine.VirtualMachineDetails.RoleName);
// For first virtual machine create new deployment
if (virtualMachineNumber == 0)
{
List<Role> roles = new List<Role>();
roles.Add(new Role
{
AvailabilitySetName = virtualMachine.VirtualMachineDetails.AvailabilitySetName,
ConfigurationSets = virtualMachine.VirtualMachineDetails.ConfigurationSets,
DataVirtualHardDisks = dataDisks,
DefaultWinRmCertificateThumbprint = virtualMachine.VirtualMachineDetails.DefaultWinRmCertificateThumbprint,
Label = null, // Label is set automatically.
MediaLocation = virtualMachine.VirtualMachineDetails.MediaLocation,
OSVersion = virtualMachine.VirtualMachineDetails.OSVersion,
OSVirtualHardDisk = vhd,
ProvisionGuestAgent = true,
ResourceExtensionReferences = virtualMachine.VirtualMachineDetails.ResourceExtensionReferences,
RoleName = virtualMachine.VirtualMachineDetails.RoleName,
RoleSize = virtualMachine.VirtualMachineDetails.RoleSize,
RoleType = virtualMachine.VirtualMachineDetails.RoleType,
VMImageName = virtualMachine.VirtualMachineDetails.VMImageName
});
// Create the deployment parameters
var createDeploymentParameters = new VirtualMachineCreateDeploymentParameters
{
DeploymentSlot = DeploymentSlot.Production,
DnsSettings = deploymentDetails.DnsSettings,
Label = deploymentDetails.Name, // Set it to new name instead of old deployment label.
LoadBalancers = deploymentDetails.LoadBalancers,
Name = deploymentDetails.Name,
ReservedIPName = deploymentDetails.ReservedIPName,
Roles = roles,
VirtualNetworkName = deploymentDetails.VirtualNetworkName
};
var deploymentResult = Retry.RetryOperation(() => computeClient.VirtualMachines.CreateDeployment(
serviceName, createDeploymentParameters), (BaseParameters)importParameters, ResourceType.VirtualMachine,
virtualMachine.VirtualMachineDetails.RoleName);
UpdateMedatadaFile(ResourceType.VirtualMachine, virtualMachine.VirtualMachineDetails.RoleName,
parentResourceName: serviceName);
}
// Add virtual machine in existing deployment
else
{
VirtualMachineCreateParameters parameters = new VirtualMachineCreateParameters
{
AvailabilitySetName = virtualMachine.VirtualMachineDetails.AvailabilitySetName,
ConfigurationSets = virtualMachine.VirtualMachineDetails.ConfigurationSets,
DataVirtualHardDisks = dataDisks,
MediaLocation = virtualMachine.VirtualMachineDetails.MediaLocation,
OSVirtualHardDisk = vhd,
ProvisionGuestAgent = true,
ResourceExtensionReferences = virtualMachine.VirtualMachineDetails.ResourceExtensionReferences,
RoleName = virtualMachine.VirtualMachineDetails.RoleName,
RoleSize = virtualMachine.VirtualMachineDetails.RoleSize,
VMImageName = virtualMachine.VirtualMachineDetails.VMImageName
};
Retry.RetryOperation(() => computeClient.VirtualMachines.Create(serviceName, deploymentDetails.Name, parameters),
(BaseParameters)importParameters, ResourceType.VirtualMachine, virtualMachine.VirtualMachineDetails.RoleName,
() => DeleteVirtualMachineIfTaskCancelled(ResourceType.VirtualMachine, serviceName, deploymentDetails.Name, virtualMachine.VirtualMachineDetails.RoleName));
UpdateMedatadaFile(ResourceType.VirtualMachine, virtualMachine.VirtualMachineDetails.RoleName, parentResourceName: serviceName);
}
swDeployment.Stop();
Logger.Info(methodName, string.Format(ProgressResources.ImportVirtualMachineCompleted,
virtualMachine.VirtualMachineDetails.RoleName, deploymentDetails.Name, swDeployment.Elapsed.Days, swDeployment.Elapsed.Hours,
swDeployment.Elapsed.Minutes, swDeployment.Elapsed.Seconds),
ResourceType.VirtualMachine.ToString(), virtualMachine.VirtualMachineDetails.RoleName);
// ShutDown created virtual machine.
computeClient.VirtualMachines.Shutdown(serviceName, deploymentDetails.Name,
virtualMachine.VirtualMachineDetails.RoleName,
new VirtualMachineShutdownParameters { PostShutdownAction = PostShutdownAction.StoppedDeallocated });
}
}
UpdateMedatadaFile(ResourceType.Deployment, deploymentDetails.Name, parentResourceName: serviceName);
}
}
catch (Exception ex)
{
Logger.Error(methodName, ex, ResourceType.Deployment.ToString(), deploymentDetails.Name);
throw;
}
}
}
swTotalDeploymentWithVMs.Stop();
Logger.Info(methodName, string.Format(ProgressResources.ExecutionCompletedWithTime, swTotalDeploymentWithVMs.Elapsed.Days, swTotalDeploymentWithVMs.Elapsed.Hours,
swTotalDeploymentWithVMs.Elapsed.Minutes, swTotalDeploymentWithVMs.Elapsed.Seconds), ResourceType.Deployment.ToString(), deploymentDetails.Name);
}
static void Main(string[] args)
{
//var token = GetAuthorizationHeader();
//var credential = new TokenCloudCredentials(
// "ed0caab7-c6d4-45e9-9289-c7e5997c9241", token);
// CreateVM(credential);
#region
var x509Certificate2 = new X509Certificate2(@"D:/aktest.cer");
CertificateCloudCredentials cer = new CertificateCloudCredentials("ed0caab7-c6d4-45e9-9289-c7e5997c9241", x509Certificate2);
// CreateResources(credential);
//var storageClient=CloudContext.Clients.CreateStorageManagementClient(cer);
//storageClient.StorageAccounts.Create(new StorageAccountCreateParameters
//{
// AccountType= "Standard_LRS",
// // GeoReplicationEnabled = false,
// Label = "Sample Storage Account",
// Location = "East US",
// Name = "mbjastorage"
//});
var windowsConfigSet = new ConfigurationSet
{
ConfigurationSetType =
ConfigurationSetTypes.WindowsProvisioningConfiguration,
AdminPassword =
"******",
AdminUserName = "******",
ComputerName = "libraryvm01",
HostName = string.Format("{0}.cloudapp.net",
"libraryvm01")
};
var vmClient = CloudContext.Clients.CreateComputeManagementClient(cer);
var operatingSystemImageListResult = vmClient.VirtualMachineOSImages.List();
var imageName =
operatingSystemImageListResult.Images.FirstOrDefault(
x => x.Label.Contains(
"SQL Server 2014 RTM Standard on Windows Server 2012 R2")).Name;
var networkConfigSet = new ConfigurationSet
{
ConfigurationSetType = "NetworkConfiguration",
InputEndpoints = new List<InputEndpoint>
{
new InputEndpoint
{
Name = "PowerShell",
LocalPort = 5986,
Protocol = "tcp",
Port = 5986,
},
new InputEndpoint
{
Name = "Remote Desktop",
LocalPort = 3389,
Protocol = "tcp",
Port = 3389,
}
}
};
var vhd = new OSVirtualHardDisk
{
SourceImageName = imageName,
HostCaching = VirtualHardDiskHostCaching.ReadWrite,
MediaLink = new Uri(string.Format(
"https://{0}.blob.core.windows.net/vhds/{1}.vhd",
"willshao", imageName))
};
var deploymentAttributes = new Role
{
RoleName = "libraryvm01",
RoleSize = VirtualMachineRoleSize.Small,
RoleType = VirtualMachineRoleType.PersistentVMRole.ToString(),
OSVirtualHardDisk = vhd,
ConfigurationSets = new List<ConfigurationSet>
{
windowsConfigSet,
networkConfigSet
},
ProvisionGuestAgent = true
};
var createDeploymentParameters =
new VirtualMachineCreateDeploymentParameters
{
Name = "libraryvm01",
Label = "libraryvm01",
DeploymentSlot = DeploymentSlot.Production,
Roles = new List<Role> { deploymentAttributes }
};
try
{
var mymachine= vmClient.VirtualMachines.Get("javmtest", "javmtest", "javmtest");
vmClient.VirtualMachines.CreateDeploymentAsync(
"libraryvm01",
createDeploymentParameters);
}
catch (Exception e)
{ }
#endregion
Console.ReadLine();
}
