public void NewAzureVMProcess() { AzureSubscription currentSubscription = Profile.Context.Subscription; CloudStorageAccount currentStorage = null; try { currentStorage = currentSubscription.GetCloudStorageAccount(Profile); } catch (Exception ex) // couldn't access { throw new ArgumentException(Resources.CurrentStorageAccountIsNotAccessible, ex); } if (currentStorage == null) // not set { throw new ArgumentException(Resources.CurrentStorageAccountIsNotSet); } bool serviceExists = DoesCloudServiceExist(this.ServiceName); if (!string.IsNullOrEmpty(this.Location)) { if (serviceExists) { HostedServiceGetResponse existingSvc = null; try { existingSvc = ComputeClient.HostedServices.Get(this.ServiceName); } catch { throw new ApplicationException(Resources.ServiceExistsLocationCanNotBeSpecified); } if (existingSvc == null || existingSvc.Properties == null || !this.Location.Equals(existingSvc.Properties.Location)) { throw new ApplicationException(Resources.ServiceExistsLocationCanNotBeSpecified); } } } if (!string.IsNullOrEmpty(this.AffinityGroup)) { if (serviceExists) { HostedServiceGetResponse existingSvc = null; try { existingSvc = ComputeClient.HostedServices.Get(this.ServiceName); } catch { throw new ApplicationException(Resources.ServiceExistsAffinityGroupCanNotBeSpecified); } if (existingSvc == null || existingSvc.Properties == null || !this.AffinityGroup.Equals(existingSvc.Properties.AffinityGroup)) { throw new ApplicationException(Resources.ServiceExistsAffinityGroupCanNotBeSpecified); } } } if (!string.IsNullOrEmpty(this.ReverseDnsFqdn)) { if (serviceExists) { throw new ApplicationException(Resources.ServiceExistsReverseDnsFqdnCanNotBeSpecified); } } if (!serviceExists) { try { //Implicitly created hosted service2012-05-07 23:12 // Create the Cloud Service when // Location or Affinity Group is Specified // or VNET is specified and the service doesn't exist var parameter = new HostedServiceCreateParameters { AffinityGroup = this.AffinityGroup, Location = this.Location, ServiceName = this.ServiceName, Description = String.Format("Implicitly created hosted service{0}", DateTime.Now.ToUniversalTime().ToString("yyyy-MM-dd HH:mm")), Label = this.ServiceName, ReverseDnsFqdn = this.ReverseDnsFqdn }; ExecuteClientActionNewSM( parameter, CommandRuntime + Resources.QuickVMCreateCloudService, () => this.ComputeClient.HostedServices.Create(parameter)); } catch (CloudException ex) { WriteExceptionError(ex); return; } } if (ParameterSetName.Equals(WindowsParamSet, StringComparison.OrdinalIgnoreCase)) { if (WinRMCertificate != null) { if (!CertUtilsNewSM.HasExportablePrivateKey(WinRMCertificate)) { throw new ArgumentException(Resources.WinRMCertificateDoesNotHaveExportablePrivateKey); } var operationDescription = string.Format(Resources.QuickVMUploadingWinRMCertificate, CommandRuntime, WinRMCertificate.Thumbprint); var parameters = CertUtilsNewSM.Create(WinRMCertificate); ExecuteClientActionNewSM( null, operationDescription, () => this.ComputeClient.ServiceCertificates.Create(this.ServiceName, parameters), (s, r) => ContextFactory<OperationStatusResponse, ManagementOperationContext>(r, s)); } if (X509Certificates != null) { var certificateFilesWithThumbprint = from c in X509Certificates select new { c.Thumbprint, CertificateFile = CertUtilsNewSM.Create(c, this.NoExportPrivateKey.IsPresent) }; foreach (var current in certificateFilesWithThumbprint.ToList()) { var operationDescription = string.Format(Resources.QuickVMUploadingCertificate, CommandRuntime, current.Thumbprint); ExecuteClientActionNewSM( null, operationDescription, () => this.ComputeClient.ServiceCertificates.Create(this.ServiceName, current.CertificateFile), (s, r) => ContextFactory<OperationStatusResponse, ManagementOperationContext>(r, s)); } } } var vm = CreatePersistenVMRole(currentStorage); try { if (CurrentDeploymentNewSM == null) { // If the current deployment doesn't exist set it create it var parameters = new VirtualMachineCreateDeploymentParameters { DeploymentSlot = DeploymentSlot.Production, Name = this.ServiceName, Label = this.ServiceName, VirtualNetworkName = this.VNetName, Roles = { vm }, ReservedIPName = this.ReservedIPName, DnsSettings = this.DnsSettings == null ? null : new Microsoft.WindowsAzure.Management.Compute.Models.DnsSettings { DnsServers = (from dns in this.DnsSettings select new Management.Compute.Models.DnsServer { Name = dns.Name, Address = dns.Address }).ToList() } }; ExecuteClientActionNewSM( parameters, string.Format(Resources.QuickVMCreateDeploymentWithVM, CommandRuntime, vm.RoleName), () => this.ComputeClient.VirtualMachines.CreateDeployment(this.ServiceName, parameters)); } else { if (!string.IsNullOrEmpty(VNetName) || DnsSettings != null) { WriteWarning(Resources.VNetNameOrDnsSettingsCanOnlyBeSpecifiedOnNewDeployments); } // Only create the VM when a new VM was added and it was not created during the deployment phase. ExecuteClientActionNewSM( vm, string.Format(Resources.QuickVMCreateVM, CommandRuntime, vm.RoleName), () => this.ComputeClient.VirtualMachines.Create( this.ServiceName, this.ServiceName, new VirtualMachineCreateParameters { AvailabilitySetName = vm.AvailabilitySetName, OSVirtualHardDisk = vm.OSVirtualHardDisk, DataVirtualHardDisks = vm.DataVirtualHardDisks, RoleName = vm.RoleName, RoleSize = vm.RoleSize, VMImageName = vm.VMImageName, MediaLocation = vm.MediaLocation, ProvisionGuestAgent = vm.ProvisionGuestAgent, ResourceExtensionReferences = vm.ResourceExtensionReferences, ConfigurationSets = vm.ConfigurationSets })); } if (WaitForBoot.IsPresent) { WaitForRoleToBoot(vm.RoleName); } } catch (CloudException ex) { if (ex.Response.StatusCode == HttpStatusCode.NotFound) { throw new Exception(Resources.ServiceDoesNotExistSpecifyLocationOrAffinityGroup); } WriteExceptionError(ex); } }
public void NewAzureVMProcess() { AzureSubscription currentSubscription = Profile.Context.Subscription; CloudStorageAccount currentStorage = null; try { currentStorage = currentSubscription.GetCloudStorageAccount(Profile); } catch (Exception ex) // couldn't access { throw new ArgumentException(Resources.CurrentStorageAccountIsNotAccessible, ex); } if (currentStorage == null) // not set { throw new ArgumentException(Resources.CurrentStorageAccountIsNotSet); } if (this.ParameterSetName.Equals("CreateService", StringComparison.OrdinalIgnoreCase)) { var parameter = new HostedServiceCreateParameters { AffinityGroup = this.AffinityGroup, Location = this.Location, ServiceName = this.ServiceName, Description = this.ServiceDescription ?? String.Format( "Implicitly created hosted service{0}", DateTime.Now.ToUniversalTime().ToString("yyyy-MM-dd HH:mm")), Label = this.ServiceLabel ?? this.ServiceName, ReverseDnsFqdn = this.ReverseDnsFqdn }; try { this.ComputeClient.HostedServices.Create(parameter); } catch (CloudException ex) { if (string.Equals(ex.Error.Code, "ConflictError")) { HostedServiceGetResponse existingService = this.ComputeClient.HostedServices.Get(this.ServiceName); if (existingService == null || existingService.Properties == null) { // The same service name is already used by another subscription. WriteExceptionError(ex); return; } else if ((string.IsNullOrEmpty(existingService.Properties.Location) && string.Compare(existingService.Properties.AffinityGroup, this.AffinityGroup, StringComparison.InvariantCultureIgnoreCase) == 0) || (string.IsNullOrEmpty(existingService.Properties.AffinityGroup) && string.Compare(existingService.Properties.Location, this.Location, StringComparison.InvariantCultureIgnoreCase) == 0)) { // The same service name is already created under the same subscription, // and its affinity group or location is matched with the given parameter. this.WriteWarning(ex.Error.Message); } else { // The same service name is already created under the same subscription, // but its affinity group or location is not matched with the given parameter. this.WriteWarning("Location or AffinityGroup name is not matched with the existing service"); WriteExceptionError(ex); return; } } else { WriteExceptionError(ex); return; } } } foreach (var vm in from v in VMs let configuration = v.ConfigurationSets.OfType<Model.WindowsProvisioningConfigurationSet>().FirstOrDefault() where configuration != null select v) { if (vm.WinRMCertificate != null) { if(!CertUtilsNewSM.HasExportablePrivateKey(vm.WinRMCertificate)) { throw new ArgumentException(Resources.WinRMCertificateDoesNotHaveExportablePrivateKey); } var operationDescription = string.Format(Resources.AzureVMUploadingWinRMCertificate, CommandRuntime, vm.WinRMCertificate.Thumbprint); var parameters = CertUtilsNewSM.Create(vm.WinRMCertificate); ExecuteClientActionNewSM( null, operationDescription, () => this.ComputeClient.ServiceCertificates.Create(this.ServiceName, parameters), (s, r) => ContextFactory<OperationStatusResponse, ManagementOperationContext>(r, s)); } var certificateFilesWithThumbprint = from c in vm.X509Certificates select new { c.Thumbprint, CertificateFile = CertUtilsNewSM.Create(c, vm.NoExportPrivateKey) }; foreach (var current in certificateFilesWithThumbprint.ToList()) { var operationDescription = string.Format(Resources.AzureVMCommandUploadingCertificate, CommandRuntime, current.Thumbprint); ExecuteClientActionNewSM( null, operationDescription, () => this.ComputeClient.ServiceCertificates.Create(this.ServiceName, current.CertificateFile), (s, r) => ContextFactory<OperationStatusResponse, ManagementOperationContext>(r, s)); } } var persistentVMs = this.VMs.Select((vm, index) => CreatePersistentVMRole(VMTuples[index], currentStorage)).ToList(); // If the current deployment doesn't exist set it create it if (CurrentDeploymentNewSM == null) { try { var parameters = new VirtualMachineCreateDeploymentParameters { DeploymentSlot = DeploymentSlot.Production, Name = this.DeploymentName ?? this.ServiceName, Label = this.DeploymentLabel ?? this.ServiceName, VirtualNetworkName = this.VNetName, Roles = { persistentVMs[0] }, ReservedIPName = ReservedIPName }; if (this.DnsSettings != null) { parameters.DnsSettings = new Management.Compute.Models.DnsSettings(); foreach (var dns in this.DnsSettings) { parameters.DnsSettings.DnsServers.Add( new Microsoft.WindowsAzure.Management.Compute.Models.DnsServer { Name = dns.Name, Address = dns.Address }); } } if (this.InternalLoadBalancerConfig != null) { parameters.LoadBalancers = new LoadBalancer[1] { new LoadBalancer { Name = this.InternalLoadBalancerConfig.InternalLoadBalancerName, FrontendIPConfiguration = new FrontendIPConfiguration { Type = FrontendIPConfigurationType.Private, SubnetName = this.InternalLoadBalancerConfig.SubnetName, StaticVirtualNetworkIPAddress = this.InternalLoadBalancerConfig.IPAddress } } }; } var operationDescription = string.Format(Resources.AzureVMCommandCreateDeploymentWithVM, CommandRuntime, persistentVMs[0].RoleName); ExecuteClientActionNewSM( parameters, operationDescription, () => this.ComputeClient.VirtualMachines.CreateDeployment(this.ServiceName, parameters)); if(this.WaitForBoot.IsPresent) { WaitForRoleToBoot(persistentVMs[0].RoleName); } } catch (CloudException ex) { if (ex.Response.StatusCode == HttpStatusCode.NotFound) { throw new Exception(Resources.ServiceDoesNotExistSpecifyLocationOrAffinityGroup); } else { WriteExceptionError(ex); } return; } this.createdDeployment = true; } else { if (this.VNetName != null || this.DnsSettings != null || !string.IsNullOrEmpty(this.DeploymentLabel) || !string.IsNullOrEmpty(this.DeploymentName)) { WriteWarning(Resources.VNetNameDnsSettingsDeploymentLabelDeploymentNameCanBeSpecifiedOnNewDeployments); } } if (this.createdDeployment == false && CurrentDeploymentNewSM != null) { this.DeploymentName = CurrentDeploymentNewSM.Name; } int startingVM = this.createdDeployment ? 1 : 0; for (int i = startingVM; i < persistentVMs.Count; i++) { var operationDescription = string.Format(Resources.AzureVMCommandCreateVM, CommandRuntime, persistentVMs[i].RoleName); var parameter = new VirtualMachineCreateParameters { AvailabilitySetName = persistentVMs[i].AvailabilitySetName, OSVirtualHardDisk = VMTuples[i].Item3 ? null : persistentVMs[i].OSVirtualHardDisk, RoleName = persistentVMs[i].RoleName, RoleSize = persistentVMs[i].RoleSize, ProvisionGuestAgent = persistentVMs[i].ProvisionGuestAgent, ResourceExtensionReferences = persistentVMs[i].ProvisionGuestAgent != null && persistentVMs[i].ProvisionGuestAgent.Value ? persistentVMs[i].ResourceExtensionReferences : null, VMImageName = VMTuples[i].Item3 ? persistentVMs[i].VMImageName : null, MediaLocation = VMTuples[i].Item3 ? persistentVMs[i].MediaLocation : null }; if (parameter.OSVirtualHardDisk != null) { parameter.OSVirtualHardDisk.IOType = null; } if (persistentVMs[i].DataVirtualHardDisks != null && persistentVMs[i].DataVirtualHardDisks.Any()) { persistentVMs[i].DataVirtualHardDisks.ForEach(c => parameter.DataVirtualHardDisks.Add(c)); parameter.DataVirtualHardDisks.ForEach(d => d.IOType = null); } persistentVMs[i].ConfigurationSets.ForEach(c => parameter.ConfigurationSets.Add(c)); ExecuteClientActionNewSM( persistentVMs[i], operationDescription, () => this.ComputeClient.VirtualMachines.Create(this.ServiceName, this.DeploymentName ?? this.ServiceName, parameter)); } if(this.WaitForBoot.IsPresent) { for (int i = startingVM; i < persistentVMs.Count; i++) { WaitForRoleToBoot(persistentVMs[i].RoleName); } } }
protected PSArgument[] CreateVirtualMachineCreateDeploymentParameters() { string serviceName = string.Empty; VirtualMachineCreateDeploymentParameters parameters = new VirtualMachineCreateDeploymentParameters(); return ConvertFromObjectsToArguments(new string[] { "ServiceName", "Parameters" }, new object[] { serviceName, parameters }); }
/// <summary> /// The Create Virtual Machine Deployment operation provisions a /// virtual machine based on the supplied configuration. When you /// create a deployment of a virtual machine, you should make sure /// that the cloud service and the disk or image that you use are /// located in the same region. For example, if the cloud service was /// created in the West US region, the disk or image that you use /// should also be located in a stor4age account in the West US /// region. (see /// http://msdn.microsoft.com/en-us/library/windowsazure/jj157194.aspx /// for more information) /// </summary> /// <param name='operations'> /// Reference to the /// Microsoft.WindowsAzure.Management.Compute.IVirtualMachineOperations. /// </param> /// <param name='serviceName'> /// The name of your service. /// </param> /// <param name='parameters'> /// Parameters supplied to the Create Virtual Machine Deployment /// operation. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public static Task<OperationResponse> BeginCreatingDeploymentAsync(this IVirtualMachineOperations operations, string serviceName, VirtualMachineCreateDeploymentParameters parameters) { return operations.BeginCreatingDeploymentAsync(serviceName, parameters, CancellationToken.None); }
public static VirtualMachineCreateDeploymentParameters CreateVMParameters(VirtualMachineOSImageGetResponse image, string deploymentName, string storageAccount, string deploymentLabel, string blobUri) { var blobUrl = GetUriForVMVhd(deploymentName, storageAccount, blobUri); string roleName = AZT.TestUtilities.GenerateName("role"); VirtualMachineCreateDeploymentParameters parameters = new VirtualMachineCreateDeploymentParameters { DeploymentSlot = DeploymentSlot.Production, Label = deploymentLabel, Name = deploymentName }; parameters.Roles.Add(new Role { OSVirtualHardDisk = new OSVirtualHardDisk { HostCaching = VirtualHardDiskHostCaching.ReadWrite, MediaLink = blobUrl, SourceImageName = image.Name }, ProvisionGuestAgent = true, RoleName = roleName, RoleType = VirtualMachineRoleType.PersistentVMRole.ToString(), RoleSize = VirtualMachineRoleSize.Large.ToString(), }); return parameters; }
/// <summary> /// The Begin Creating Virtual Machine Deployment operation provisions /// a virtual machine based on the supplied configuration. When you /// create a deployment of a virtual machine, you should make sure /// that the cloud service and the disk or image that you use are /// located in the same region. For example, if the cloud service was /// created in the West US region, the disk or image that you use /// should also be located in a storage account in the West US region. /// (see /// http://msdn.microsoft.com/en-us/library/windowsazure/jj157194.aspx /// for more information) /// </summary> /// <param name='operations'> /// Reference to the /// Microsoft.WindowsAzure.Management.Compute.IVirtualMachineOperations. /// </param> /// <param name='serviceName'> /// Required. The name of your service. /// </param> /// <param name='parameters'> /// Required. Parameters supplied to the Begin Creating Virtual Machine /// Deployment operation. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public static OperationResponse BeginCreatingDeployment(this IVirtualMachineOperations operations, string serviceName, VirtualMachineCreateDeploymentParameters parameters) { return Task.Factory.StartNew((object s) => { return ((IVirtualMachineOperations)s).BeginCreatingDeploymentAsync(serviceName, parameters); } , operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult(); }
/// <summary> /// The Create Virtual Machine Deployment operation provisions a /// virtual machine based on the supplied configuration. When you /// create a deployment of a virtual machine, you should make sure /// that the cloud service and the disk or image that you use are /// located in the same region. For example, if the cloud service was /// created in the West US region, the disk or image that you use /// should also be located in a stor4age account in the West US /// region. (see /// http://msdn.microsoft.com/en-us/library/windowsazure/jj157194.aspx /// for more information) /// </summary> /// <param name='operations'> /// Reference to the /// Microsoft.WindowsAzure.Management.Compute.IVirtualMachineOperations. /// </param> /// <param name='serviceName'> /// The name of your service. /// </param> /// <param name='parameters'> /// Parameters supplied to the Create Virtual Machine Deployment /// operation. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public static OperationResponse BeginCreatingDeployment(this IVirtualMachineOperations operations, string serviceName, VirtualMachineCreateDeploymentParameters parameters) { try { return operations.BeginCreatingDeploymentAsync(serviceName, parameters).Result; } catch (AggregateException ex) { if (ex.InnerExceptions.Count > 1) { throw; } else { throw ex.InnerException; } } }
/// <author>Bart</author> /// <summary> /// Deze methode is om een nieuwe Virtual Machine aan te maken op Azure. /// </summary> /// <param name="virtualMachine">Is het model van de Virtual Machine</param> /// <returns>Een true of false respectiefelijk aan of de actie geslaagt is of niet.</returns> private Boolean WithDeployment(VirtualMachine virtualMachine) { try { ComputeManagementClient client = new ComputeManagementClient(cloudCredentials); //Stap 1 : Het klaarzetten van de meeste data uit het VirtualMachine model. string vmName = virtualMachine.Naam; string uName = virtualMachine.VMuser; string uPassword = virtualMachine.VMpass; string cloudServiceName = virtualMachine.IP; int port = virtualMachine.PoortNr; string imageName = null; switch (virtualMachine.Type) { case VirtualMachineTypes.Sharepoint: imageName = sc.GetValue("sharepointImg"); break; case VirtualMachineTypes.SQLServer: imageName = sc.GetValue("sqlImg"); break; } //Stap 2 : Het maken van de configuratie van de VM. var vmRole = new Role() { RoleType = VirtualMachineRoleType.PersistentVMRole.ToString(), RoleName = vmName, Label = vmName, RoleSize = VirtualMachineRoleSize.Small, ProvisionGuestAgent = true, ConfigurationSets = new List<ConfigurationSet>(), ResourceExtensionReferences = new List<ResourceExtensionReference>(), OSVirtualHardDisk = new OSVirtualHardDisk() { MediaLink = GetVhdUri(string.Format("{0}.blob.core.windows.net/vhds", relatedStorageAccountName)), SourceImageName = GetSourceImageNameByFamilyName(imageName) } }; ResourceExtensionReference resourceExtensionReference = new ResourceExtensionReference() { ReferenceName = "VMAccessAgent", Name = "VMAccessAgent", Publisher = "Microsoft.Compute", Version = "2.0" }; ConfigurationSet configSet = new ConfigurationSet() { ConfigurationSetType = ConfigurationSetTypes.WindowsProvisioningConfiguration, EnableAutomaticUpdates = false, ComputerName = vmName, AdminUserName = uName, AdminPassword = uPassword, }; ConfigurationSet networkConfigSet = new ConfigurationSet() { ConfigurationSetType = ConfigurationSetTypes.NetworkConfiguration, InputEndpoints = new List<InputEndpoint> { new InputEndpoint() { LocalPort = int.Parse(sc.GetValue("rdpPort")), Name = "Remote Desktop", Port = port, Protocol = InputEndpointTransportProtocol.Tcp, EnableDirectServerReturn = false } } }; vmRole.ResourceExtensionReferences.Add(resourceExtensionReference); vmRole.ConfigurationSets.Add(configSet); vmRole.ConfigurationSets.Add(networkConfigSet); //Stap 3 : Het zetten van alle gegevens in één CreateParameters object. List<Role> roleList = new List<Role>() { vmRole }; VirtualMachineCreateDeploymentParameters createDeploymentParams = new VirtualMachineCreateDeploymentParameters() { Name = "VMs", Label = vmName, Roles = roleList, DeploymentSlot = DeploymentSlot.Production }; //Stap 4 : Het werkelijke creëren van de VM. client.VirtualMachines.CreateDeployment(cloudServiceName, createDeploymentParams); System.Diagnostics.Debug.Write("Create VM Succes"); return true; } catch (CloudException e) { throw e; //return false; } catch (Exception ex) { throw ex; //return false; } }
/// <summary> /// Create the Virtual Machine /// </summary> /// <param name="imageName">The OS image name to use</param> /// <returns></returns> internal async Task CreateVirtualMachine(string imageName) { // Get the details of the selected OS image var image = await _computeManagementClient.VirtualMachineOSImages.GetAsync(imageName); // The Deployment where the Virtual Machine will be hosted var parameters = new VirtualMachineCreateDeploymentParameters { DeploymentSlot = DeploymentSlot.Production, Name = _parameters.CloudServiceName, Label = String.Format("CloudService{0}", _parameters.CloudServiceName), }; // The Role defines the details of the VM parameters parameters.Roles.Add(new Role { OSVirtualHardDisk = new OSVirtualHardDisk { HostCaching = VirtualHardDiskHostCaching.ReadWrite, MediaLink = new Uri(string.Format("https://{0}.blob.core.windows.net/vhds/{1}", _parameters.StorageAccountName, _parameters.VMName)), SourceImageName = image.Name }, // You could use DataVirtualHardDisks here to add additional persistent data disks RoleName = _parameters.VMName, RoleType = VirtualMachineRoleType.PersistentVMRole.ToString(), RoleSize = VirtualMachineRoleSize.Small, ProvisionGuestAgent = true }); // Add a ConfigurationSet for the Windows specific configuration parameters.Roles[0].ConfigurationSets.Add(new ConfigurationSet { ConfigurationSetType = ConfigurationSetTypes.WindowsProvisioningConfiguration, ComputerName = _parameters.VMName, // TODO: HostName for Linux AdminUserName = _parameters.AdminUsername, AdminPassword = _parameters.AdminPassword, EnableAutomaticUpdates = false, TimeZone = "Pacific Standard Time" }); // Add a ConfigurationSet describing the ports to open to the outside parameters.Roles[0].ConfigurationSets.Add(new ConfigurationSet { ConfigurationSetType = ConfigurationSetTypes.NetworkConfiguration, InputEndpoints = new List<InputEndpoint>() { // Open the RDP port using a non-standard external port new InputEndpoint() { Name = "RDP", Protocol = InputEndpointTransportProtocol.Tcp, LocalPort = 3389, Port = _parameters.RDPPort } } }); // Create the Virtual Machine var response = await _computeManagementClient.VirtualMachines.CreateDeploymentAsync(_parameters.CloudServiceName, parameters); }
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; }
public async Task<string> CreateVirtualMachine(string virtualMachineName, string cloudServiceName, string storageAccountName, string username, string password, string imageFilter, string virtualMachineSize, int rdpPort, bool isCloudServiceAlreadyCreated) { using (var computeClient = new ComputeManagementClient(_credentials)) { // get the list of images from the api var operatingSystemImageListResult = await computeClient.VirtualMachineOSImages.ListAsync(); // find the one i want var virtualMachineOsImage = operatingSystemImageListResult .Images .FirstOrDefault(x => x.Name.Contains(imageFilter)); if (virtualMachineOsImage == null) { throw new Exception("OS Image Name Not Foud"); } var imageName = virtualMachineOsImage.Name; // set up the configuration set for the windows image var windowsConfigSet = new ConfigurationSet { ConfigurationSetType = ConfigurationSetTypes.WindowsProvisioningConfiguration, AdminPassword = password, AdminUserName = username, ComputerName = virtualMachineName, HostName = string.Format("{0}.cloudapp.net", cloudServiceName) }; // make sure i enable powershell & rdp access var endpoints = 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 = rdpPort, } } }; // set up the hard disk with the os var vhd = SetOsVirtualHardDisk(virtualMachineName, storageAccountName, imageName); // create the role for the vm in the cloud service var role = new Role { RoleName = virtualMachineName, RoleSize = virtualMachineSize, RoleType = VirtualMachineRoleType.PersistentVMRole.ToString(), OSVirtualHardDisk = vhd, ProvisionGuestAgent = true, ConfigurationSets = new List<ConfigurationSet> { windowsConfigSet, endpoints } }; var isDeploymentCreated = false; if (isCloudServiceAlreadyCreated) { var vm = await computeClient.HostedServices.GetDetailedAsync(cloudServiceName); isDeploymentCreated = vm.Deployments.ToList().Any(x => x.Name == cloudServiceName); } if (isDeploymentCreated) { AddRole(cloudServiceName, cloudServiceName, role, DeploymentSlot.Production); } else { // create the deployment parameters var createDeploymentParameters = new VirtualMachineCreateDeploymentParameters { Name = cloudServiceName, Label = cloudServiceName, DeploymentSlot = DeploymentSlot.Production, Roles = new List<Role> {role} }; // deploy the virtual machine var deploymentResult = await computeClient.VirtualMachines.CreateDeploymentAsync( cloudServiceName, createDeploymentParameters); } // return the name of the virtual machine return virtualMachineName; } }
public static void CreateVMDeployment(this IVirtualMachineOperations operations, string cloudServiceName, string deploymentName, List<Role> roleList, DeploymentSlot slot = DeploymentSlot.Production) { try { VirtualMachineCreateDeploymentParameters createDeploymentParams = new VirtualMachineCreateDeploymentParameters { Name = deploymentName, Label = cloudServiceName, Roles = roleList, DeploymentSlot = slot }; operations.CreateDeployment(cloudServiceName, createDeploymentParams); } catch (CloudException e) { throw e; } }
/// <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(); }