/// <author>Bart</author> /// <summary> /// Deze methode wordt gebruikt om nieuwe CloudServices aan te maken in Azure. Location of Affinitygroup mag null zijn. /// </summary> /// <param name="cloudServiceName">Is de naam die de CloudService gaat hebben.</param> /// <param name="location">Is de geografische lokatie die de CloudService zal hebben.</param> /// <param name="affinityGroupName">Is de groep waar deze CloudService bij hoort.</param> /// <returns>Een true of false respectiefelijk aan of de actie geslaagt is of niet.</returns> public Boolean CreateCloudService(string cloudServiceName, string location, string affinityGroupName = null) { ComputeManagementClient client = new ComputeManagementClient(cloudCredentials); HostedServiceCreateParameters hostedServiceCreateParams = new HostedServiceCreateParameters(); if (location != null) { hostedServiceCreateParams = new HostedServiceCreateParameters { ServiceName = cloudServiceName, Location = location, Label = EncodeToBase64(cloudServiceName), }; } else if (affinityGroupName != null) { hostedServiceCreateParams = new HostedServiceCreateParameters { ServiceName = cloudServiceName, AffinityGroup = affinityGroupName, Label = EncodeToBase64(cloudServiceName), }; } try { client.HostedServices.Create(hostedServiceCreateParams); return true; } catch (CloudException) { return false; } }
public static void CreateCloudService() { ComputeManagementClient client = Util.getComputeManagementClient(); HostedServiceCreateParameters param = new HostedServiceCreateParameters(); param.ServiceName = "rd-TestService"; param.Location = "East Asia"; OperationResponse response = client.HostedServices.Create(param); Console.WriteLine("Status Code : " + response.StatusCode); }
/// <summary> /// Creates a service specification (configuration?) entry in Azure's database. /// This reserves the (Azure-unique) DNS prefix name used to access the service. /// </summary> /// <remarks> /// Note that this does not deploy and start the service. /// </remarks> /// <param name="serviceName">Name of the cloud service.</param> /// <param name="location">Geographical region where the service should be hosted.</param> public void CreateServiceSpecification(string serviceName, string location) { // Required: Label, ServiceName. // One Required (but not both): AffinityGroup, Location. // Optional: Description, ExtendedProperties, HostedServiceCreateParameters parameters = new HostedServiceCreateParameters(); parameters.Label = serviceName; parameters.ServiceName = serviceName; parameters.Location = location; this.computeManager.HostedServices.Create(parameters); }
/// <summary> /// Create hosted service /// </summary> /// <param name="input"></param> /// <returns></returns> public string CreateHostedService(HostedServiceCreateParameters input) { if (input == null) { throw new ArgumentNullException("input"); } if (HostedServiceExists(input.ServiceName)) return input.ServiceName; var affinityGroupManager = new AzureAffinityGroupManager(); affinityGroupManager.EnsureAffinityGroupExists(input.AffinityGroup); ComputeManagementClient.HostedServices.CreateAsync(input, new CancellationToken()).Wait(); Dependencies.TestResourcesCollector.Remember(AzureResourceType.HostedService, input.ServiceName, input.ServiceName); return input.ServiceName; }
public static void createCloudServiceByAffinityGroup(string cloudServiceName, string affinityGroupName) { ComputeManagementClient client = new ComputeManagementClient(getCredentials()); HostedServiceCreateParameters hostedServiceCreateParams = new HostedServiceCreateParameters { ServiceName = cloudServiceName, AffinityGroup = affinityGroupName, Label = EncodeToBase64(cloudServiceName), }; try { client.HostedServices.Create(hostedServiceCreateParams); } catch (CloudException e) { throw e; } }
public void ExecuteCommand() { var parameter = new HostedServiceCreateParameters() { ServiceName = this.ServiceName, Label = string.IsNullOrEmpty(this.Label) ? this.ServiceName : this.Label, ReverseDnsFqdn = this.ReverseDnsFqdn, Description = this.Description, AffinityGroup = this.AffinityGroup, Location = this.Location }; ExecuteClientActionNewSM(null, CommandRuntime.ToString(), () => this.ComputeClient.HostedServices.Create(parameter)); }
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); } }
/// <summary> /// The Create Hosted Service operation creates a new cloud service in /// Azure. (see /// http://msdn.microsoft.com/en-us/library/windowsazure/gg441304.aspx /// for more information) /// </summary> /// <param name='operations'> /// Reference to the /// Microsoft.WindowsAzure.Management.Compute.IHostedServiceOperations. /// </param> /// <param name='parameters'> /// Required. Parameters supplied to the Create Hosted Service /// operation. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public static Task<AzureOperationResponse> CreateAsync(this IHostedServiceOperations operations, HostedServiceCreateParameters parameters) { return operations.CreateAsync(parameters, CancellationToken.None); }
/// <summary> /// The Create Hosted Service operation creates a new cloud service in /// Azure. (see /// http://msdn.microsoft.com/en-us/library/windowsazure/gg441304.aspx /// for more information) /// </summary> /// <param name='operations'> /// Reference to the /// Microsoft.WindowsAzure.Management.Compute.IHostedServiceOperations. /// </param> /// <param name='parameters'> /// Required. Parameters supplied to the Create Hosted Service /// operation. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public static AzureOperationResponse Create(this IHostedServiceOperations operations, HostedServiceCreateParameters parameters) { return Task.Factory.StartNew((object s) => { return ((IHostedServiceOperations)s).CreateAsync(parameters); } , operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult(); }
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); } } }
/// <summary> /// Checks for the existence of a specific Cloud Service, if it doesn't exist it will create it. /// </summary> /// <param name="client">The <see cref="ComputeManagementClient"/> that is performing the operation.</param> /// <param name="parameters">The <see cref="HostedServiceCreateParameters"/> that define the service we want to create.</param> /// <returns>The async <see cref="Task"/> wrapper.</returns> public static async Task CreateServiceIfNotExistsAsync(this ComputeManagementClient client, HostedServiceCreateParameters parameters) { Contract.Requires(client != null); Contract.Requires(parameters != null); HostedServiceGetResponse service = null; FlexStreams.BuildEventsObserver.OnNext(new CheckIfExistsEvent(AzureResource.CloudService, parameters.ServiceName)); try { service = await client.HostedServices.GetAsync(parameters.ServiceName); } catch (CloudException cex) { if (cex.Error.Code != "ResourceNotFound") throw; } if (service != null) { FlexStreams.BuildEventsObserver.OnNext(new FoundExistingEvent(AzureResource.CloudService, parameters.ServiceName)); return; } await client.HostedServices.CreateAsync(parameters); FlexStreams.BuildEventsObserver.OnNext(new ProvisionEvent(AzureResource.CloudService, parameters.ServiceName)); }
/// <summary> /// Creates cloud service if it does not exist. /// </summary> /// <param name="name">The cloud service name</param> /// <param name="label">The cloud service label</param> /// <param name="location">The location to create the cloud service in.</param> /// <param name="affinityGroup">Affinity group name for cloud service</param> public void CreateCloudServiceIfNotExist( string name, string label = null, string location = null, string affinityGroup = null) { if (!CloudServiceExists(name)) { WriteVerboseWithTimestamp(Resources.PublishCreatingServiceMessage); var createParameters = new HostedServiceCreateParameters { ServiceName = name, Label = label }; if (!string.IsNullOrEmpty(affinityGroup)) { createParameters.AffinityGroup = affinityGroup; } else { location = string.IsNullOrEmpty(location) ? GetDefaultLocation() : location; createParameters.Location = location; } ComputeClient.HostedServices.Create(createParameters); WriteVerboseWithTimestamp(Resources.PublishCreatedServiceMessage, name); } }
protected PSArgument[] CreateHostedServiceCreateParameters() { HostedServiceCreateParameters parameters = new HostedServiceCreateParameters(); return ConvertFromObjectsToArguments(new string[] { "Parameters" }, new object[] { parameters }); }
/// <summary> /// The Create Hosted Service operation creates a new cloud service in /// Windows Azure. (see /// http://msdn.microsoft.com/en-us/library/windowsazure/gg441304.aspx /// for more information) /// </summary> /// <param name='operations'> /// Reference to the /// Microsoft.WindowsAzure.Management.Compute.IHostedServiceOperations. /// </param> /// <param name='parameters'> /// Parameters supplied to the Create Hosted Service operation. /// </param> /// <returns> /// A standard service response including an HTTP status code and /// request ID. /// </returns> public static OperationResponse Create(this IHostedServiceOperations operations, HostedServiceCreateParameters parameters) { try { return operations.CreateAsync(parameters).Result; } catch (AggregateException ex) { if (ex.InnerExceptions.Count > 1) { throw; } else { throw ex.InnerException; } } }
public async Task Test_CheckCreateCloudService_WithNewService() { using (var client = ManagementClient.CreateComputeClient()) { var parameters = new HostedServiceCreateParameters { Label = "Integration Test", Location = LocationNames.NorthEurope, ServiceName = "fct-" + Guid.NewGuid().ToString().Split('-').Last() }; try { await client.CreateServiceIfNotExistsAsync(parameters); var service = await client.HostedServices.GetAsync(parameters.ServiceName); Assert.IsNotNull(service); } finally { client.HostedServices.Delete(parameters.ServiceName); } } }