internal async Task <string> StartVirtualMachineAsync(string name) { string returnMessage; IVirtualMachine machine = await GetVmByNameAsync(name); if (machine == null) { returnMessage = $"No machine named {name} was found"; } else if (machine.PowerState == PowerState.Deallocated || machine.PowerState == PowerState.Stopped) { #pragma warning disable CS4014 //This will take a while, let it run async and continue no need to await it machine.StartAsync(); #pragma warning restore CS4014 returnMessage = $"{name} is starting, original state was {VmHtmlMaker.FormatPowerState(machine.PowerState)}"; } else if (machine.PowerState == PowerState.Running) { IPublicIPAddress ipAddress = machine.GetPrimaryPublicIPAddress(); returnMessage = $"Machine is already running, IP address is {ipAddress.IPAddress}"; } else { returnMessage = $"No action taken, machine state is: {VmHtmlMaker.FormatPowerState(machine.PowerState)}"; } //_helper.LogMessage("Finished"); return(returnMessage); }
/** * It creates a new Azure virtual machine and it instantiate a Java Docker client. * @param azure - instance of Azure * @param rgName - name of the Azure resource group to be used when creating a virtual machine * @param region - region to be used when creating a virtual machine * @return an instance of DockerClient */ public static DockerClient FromNewDockerVM(IAzure azure, String rgName, Region region) { string dockerVMName = SdkContext.RandomResourceName("dockervm", 15); string publicIPDnsLabel = SdkContext.RandomResourceName("pip", 10); string vmUserName = "******"; string vmPassword = Utilities.CreatePassword(); // Could not find a Docker environment; presume that there is no local Docker engine running and // attempt to configure a Docker engine running inside a new Azure virtual machine Utilities.Log("Creating an Azure virtual machine running Docker"); IVirtualMachine dockerVM = azure.VirtualMachines.Define(dockerVMName) .WithRegion(region) .WithExistingResourceGroup(rgName) .WithNewPrimaryNetwork("10.0.0.0/28") .WithPrimaryPrivateIPAddressDynamic() .WithNewPrimaryPublicIPAddress(publicIPDnsLabel) .WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts) .WithRootUsername(vmUserName) .WithRootPassword(vmPassword) .WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4")) .Create(); Utilities.Log("Created Azure Virtual Machine: " + dockerVM.Id); // Get the IP of the Docker host INicIPConfiguration nicIPConfiguration = dockerVM.GetPrimaryNetworkInterface().PrimaryIPConfiguration; IPublicIPAddress publicIp = nicIPConfiguration.GetPublicIPAddress(); string dockerHostIP = publicIp.IPAddress; DockerClient dockerClient = InstallDocker(dockerHostIP, vmUserName, vmPassword); return(dockerClient); }
public override ILoadBalancer UpdateResource(ILoadBalancer resource) { String backendName = resource.Backends.Values.First().Name; String frontendName = resource.Frontends.Values.First().Name; var nics = new List <INetworkInterface>(); foreach (string nicId in resource.Backends[backendName].BackendNicIPConfigurationNames.Keys) { nics.Add(networks.Manager.NetworkInterfaces.GetById(nicId)); } INetworkInterface nic1 = nics[0]; INetworkInterface nic2 = nics[1]; // Remove the NIC associations nic1.Update() .WithoutLoadBalancerBackends() .WithoutLoadBalancerInboundNatRules() .Apply(); Assert.Empty(nic1.PrimaryIPConfiguration.ListAssociatedLoadBalancerBackends()); nic2.Update() .WithoutLoadBalancerBackends() .WithoutLoadBalancerInboundNatRules() .Apply(); Assert.Empty(nic2.PrimaryIPConfiguration.ListAssociatedLoadBalancerBackends()); // Update the load balancer var existingPips = loadBalancerHelper.EnsurePIPs(pips); IPublicIPAddress pip = resource.Manager.PublicIPAddresses.GetByResourceGroup( loadBalancerHelper.GroupName, loadBalancerHelper.PipNames[1]); resource = resource.Update() .UpdatePublicFrontend(frontendName) .WithExistingPublicIPAddress(pip) .Parent() .WithoutLoadBalancingRule("rule1") .WithoutInboundNatRule("natrule1") .WithTag("tag1", "value1") .WithTag("tag2", "value2") .Apply(); Assert.True(resource.Tags.ContainsKey("tag1")); Assert.Empty(resource.InboundNatRules.Values); // Verify frontends Assert.Single(resource.PublicFrontends.Values); Assert.Empty(resource.PrivateFrontends.Values); Assert.True(resource.Frontends.ContainsKey(frontendName)); var frontend = resource.Frontends[frontendName]; Assert.True(frontend.IsPublic); var publicFrontend = (ILoadBalancerPublicFrontend)frontend; Assert.Equal(pip.Id, publicFrontend.PublicIPAddressId, ignoreCase: true); return(resource); }
public Task <INetworkInterface> CreateNetworkInterfaceAsync(string nicBase, Region location, string groupName, string subNet, INetwork network, IPublicIPAddress publicIPAddress, INetworkSecurityGroup nsg, int i = 0) { Console.WriteLine($"Creating {i}th network interface in resource group {groupName}"); var j = 0; var maxRetry = 5; // 5 times retry is enough while (j < maxRetry) { try { if (publicIPAddress != null && nsg != null) { var newNic = _azure.NetworkInterfaces.Define(nicBase + Convert.ToString(i)) .WithRegion(location) .WithExistingResourceGroup(groupName) .WithExistingPrimaryNetwork(network) .WithSubnet(subNet) .WithPrimaryPrivateIPAddressDynamic() .WithExistingPrimaryPublicIPAddress(publicIPAddress) .WithExistingNetworkSecurityGroup(nsg) .CreateAsync(); return(newNic); } else { var newNic = _azure.NetworkInterfaces.Define(nicBase + Convert.ToString(i)) .WithRegion(location) .WithExistingResourceGroup(groupName) .WithExistingPrimaryNetwork(network) .WithSubnet(subNet) .WithPrimaryPrivateIPAddressDynamic() .CreateAsync(); return(newNic); } } catch (Exception e) { // clear the uncompleted data var allNICs = _azure.NetworkInterfaces.ListByResourceGroup(groupName); var ids = new List <string>(); var enumerator = allNICs.GetEnumerator(); while (enumerator.MoveNext()) { ids.Add(enumerator.Current.Id); } _azure.NetworkInterfaces.DeleteByIds(ids); Task.Delay(2000); Util.Log($"error: {e.Message} retry create {i}th nic"); } j++; } return(null); }
public override ILoadBalancer UpdateResource(ILoadBalancer resource) { ILoadBalancerBackend backend = resource.Backends.Values.First(); ILoadBalancerInboundNatRule natRule = resource.InboundNatRules.Values.First(); ILoadBalancerPublicFrontend publicFrontend = (ILoadBalancerPublicFrontend)natRule.Frontend; IPublicIPAddress pip = resource.Manager.PublicIPAddresses.Define(loadBalancerHelper.PipNames[1]) .WithRegion(loadBalancerHelper.Region) .WithExistingResourceGroup(loadBalancerHelper.GroupName) .WithLeafDomainLabel(loadBalancerHelper.PipNames[1]) .Create(); resource = resource.Update() .UpdatePublicFrontend(publicFrontend.Name) .WithExistingPublicIPAddress(pip) .Parent() .DefineBackend("backend2") .Attach() .WithoutBackend(backend.Name) .WithoutInboundNatRule("natrule1") .WithTag("tag1", "value1") .WithTag("tag2", "value2") .Apply(); Assert.True(resource.Tags.ContainsKey("tag1")); // Verify frontends Assert.Equal(1, resource.Frontends.Count); Assert.Equal(1, resource.PublicFrontends.Count); Assert.Equal(0, resource.PrivateFrontends.Count); Assert.True(resource.Frontends.ContainsKey(publicFrontend.Name)); var frontend = resource.Frontends[publicFrontend.Name]; Assert.True(frontend.IsPublic); publicFrontend = (ILoadBalancerPublicFrontend)frontend; Assert.Equal(pip.Id, publicFrontend.PublicIPAddressId, ignoreCase: true); Assert.Equal(0, publicFrontend.LoadBalancingRules.Count); // Verify probes Assert.Equal(0, resource.TcpProbes.Count); Assert.Equal(0, resource.HttpProbes.Count); // Verify backends Assert.True(resource.Backends.ContainsKey("backend2")); Assert.True(!resource.Backends.ContainsKey(backend.Name)); // Verify NAT rules Assert.Equal(0, resource.InboundNatRules.Count); // Verify load balancing rules Assert.Equal(0, resource.LoadBalancingRules.Count); return(resource); }
///GENMHASH:DAC7C95BFBE152B599EE795AE6AFEF02:B63A71AAE81F86EEB4A9F4709EF1253D internal ILoadBalancerPublicFrontend FindFrontendByPublicIPAddress(IPublicIPAddress publicIPAddress) { if (publicIPAddress == null) { return(null); } else { return(FindFrontendByPublicIPAddress(publicIPAddress.Id)); } }
public override IApplicationGateway CreateResource(IApplicationGateways resources) { // Create an application gateway try { string appPublicIp = TestUtilities.GenerateName("pip"); IPublicIPAddress pip = resources.Manager.PublicIPAddresses .Define(appPublicIp) .WithRegion(applicationGatewayHelper.Region) .WithNewResourceGroup(applicationGatewayHelper.GroupName) .WithSku(PublicIPSkuType.Standard) .WithStaticIP() .Create(); Assert.NotNull(pip); resources.Define(applicationGatewayHelper.AppGatewayName) .WithRegion(applicationGatewayHelper.Region) .WithExistingResourceGroup(applicationGatewayHelper.GroupName) // Request routing rules // Request routing rules .DefineRequestRoutingRule("rule1") .FromPublicFrontend() .FromFrontendHttpsPort(443) .WithSslCertificateFromPfxFile(new FileInfo(Path.Combine("Assets", "myTest._pfx"))) .WithSslCertificatePassword("Abc123") .ToBackendHttpPort(8080) .ToBackendIPAddress("11.1.1.1") .ToBackendIPAddress("11.1.1.2") .Attach() .WithExistingPublicIPAddress(pip) .WithTier(ApplicationGatewayTier.WAFV2) .WithSize(ApplicationGatewaySkuName.WAFV2) .WithAutoscale(2, 5) .WithWebApplicationFirewall(true, ApplicationGatewayFirewallMode.Prevention) .Create(); } catch { } // Get the resource as created so far string resourceId = applicationGatewayHelper.CreateResourceId(resources.Manager.SubscriptionId); IApplicationGateway appGateway = resources.GetById(resourceId); Assert.NotNull(appGateway); Assert.Equal(ApplicationGatewayTier.WAFV2, appGateway.Tier); Assert.Equal(ApplicationGatewaySkuName.WAFV2, appGateway.Size); Assert.Equal <int>(2, appGateway.AutoscaleConfiguration.MinCapacity); Assert.Equal <int>(5, appGateway.AutoscaleConfiguration.MaxCapacity.Value); return(appGateway); }
IPublicIPAddress GetOrCreatePublicIPAddress(IAzure azure, string name, Region location, string groupName) { IPublicIPAddress publicIPAddress = FindInCollectionOrNull(azure.PublicIPAddresses, "a public IP address", name); if (publicIPAddress == null) { Console.WriteLine("Creating a public IP address..."); publicIPAddress = azure.PublicIPAddresses.Define(name) .WithRegion(location) .WithExistingResourceGroup(groupName) .WithDynamicIP() .Create(); } return(publicIPAddress); }
public IPublicIPAddress createPublicIpAddress() { Microsoft.Azure.Management.Fluent.IAzure azureCredentials = new AzureCredentialProvider().LoginAzure(); Console.WriteLine("Creating public IP address..."); IPublicIPAddress publicIpAddress = azureCredentials.PublicIPAddresses.Define("myPublicIP") .WithRegion(Region.EuropeNorth) .WithExistingResourceGroup("sdk-netcore-practices") .WithDynamicIP() .Create(); return(publicIpAddress); }
internal void Print(IPublicIPAddress resource) { TestHelper.WriteLine(new StringBuilder().Append("Public IP Address: ").Append(resource.Id) .Append("Name: ").Append(resource.Name) .Append("\n\tResource group: ").Append(resource.ResourceGroupName) .Append("\n\tRegion: ").Append(resource.Region) .Append("\n\tTags: ").Append(resource.Tags) .Append("\n\tIP Address: ").Append(resource.IPAddress) .Append("\n\tLeaf domain label: ").Append(resource.LeafDomainLabel) .Append("\n\tFQDN: ").Append(resource.Fqdn) .Append("\n\tReverse FQDN: ").Append(resource.ReverseFqdn) .Append("\n\tIdle timeout (minutes): ").Append(resource.IdleTimeoutInMinutes) .Append("\n\tIP allocation method: ").Append(resource.IPAllocationMethod.ToString()) .ToString()); }
public static void PrintPIP(IPublicIPAddress resource) { var info = new StringBuilder().Append("Public IP Address: ").Append(resource.Id) .Append("\n\tName: ").Append(resource.Name) .Append("\n\tResource group: ").Append(resource.ResourceGroupName) .Append("\n\tRegion: ").Append(resource.Region) .Append("\n\tTags: ").Append(resource.Tags) .Append("\n\tIP Address: ").Append(resource.IPAddress) .Append("\n\tLeaf domain label: ").Append(resource.LeafDomainLabel) .Append("\n\tFQDN: ").Append(resource.Fqdn) .Append("\n\tReverse FQDN: ").Append(resource.ReverseFqdn) .Append("\n\tIdle timeout (minutes): ").Append(resource.IdleTimeoutInMinutes) .Append("\n\tIP allocation method: ").Append(resource.IPAllocationMethod) .Append("\n\tIP version: ").Append(resource.Version); // Show the associated load balancer if any info.Append("\n\tLoad balancer association: "); if (resource.HasAssignedLoadBalancer) { var frontend = resource.GetAssignedLoadBalancerFrontend(); var lb = frontend.Parent; info.Append("\n\t\tLoad balancer ID: ").Append(lb.Id) .Append("\n\t\tFrontend name: ").Append(frontend.Name); } else { info.Append("(None)"); } // Show the associated NIC if any info.Append("\n\tNetwork interface association: "); if (resource.HasAssignedNetworkInterface) { var nicIP = resource.GetAssignedNetworkInterfaceIPConfiguration(); var nic = nicIP.Parent; info.Append("\n\t\tNetwork interface ID: ").Append(nic.Id) .Append("\n\t\tIP config name: ").Append(nicIP.Name); } else { info.Append("(None)"); } TestHelper.WriteLine(info.ToString()); }
public INetworkInterface createNetworkInterface(INetwork newNetwork, IPublicIPAddress publicIPAddress) { Microsoft.Azure.Management.Fluent.IAzure azureCredentials = new AzureCredentialProvider().LoginAzure(); Console.WriteLine("Creating Network Interface..."); INetworkInterface networkInterface = azureCredentials.NetworkInterfaces.Define("myNIC") .WithRegion(Region.EuropeNorth) .WithExistingResourceGroup("sdk-netcore-practices") .WithExistingPrimaryNetwork(newNetwork) .WithSubnet("mySubnet") .WithPrimaryPrivateIPAddressDynamic() .WithExistingPrimaryPublicIPAddress(publicIPAddress) .Create(); return(networkInterface); }
INetworkInterface GetOrCreateNetworkInterface(IAzure azure, string name, Region location, string groupName, IPublicIPAddress publicIPAddress, INetwork network) { INetworkInterface networkInterface = FindInCollectionOrNull(azure.NetworkInterfaces, "a network interface", name); if (networkInterface == null) { Console.WriteLine("Creating a network interface..."); networkInterface = azure.NetworkInterfaces.Define(name) .WithRegion(location) .WithExistingResourceGroup(groupName) .WithExistingPrimaryNetwork(network) .WithSubnet("mySubnet") .WithPrimaryPrivateIPAddressDynamic() .WithExistingPrimaryPublicIPAddress(publicIPAddress) .Create(); } return(networkInterface); }
public async Task GetVmVn() { var allvms = await azure.VirtualMachines.ListAsync(); IVirtualMachine targetvm = allvms .Where(vm => vm.Name == "Annvm") .SingleOrDefault(); Console.WriteLine(targetvm?.Id); INetworkInterface targetnic = targetvm.GetPrimaryNetworkInterface(); INicIPConfiguration targetipconfig = targetnic.PrimaryIPConfiguration; IPublicIPAddress targetipaddress = targetipconfig.GetPublicIPAddress(); Console.WriteLine($"IP Address:\t{targetipaddress.IPAddress}"); Console.WriteLine("Press any key to exit."); Console.ReadLine(); }
string GetVmControlContent(IVirtualMachine machine) { string contents = GetWebContentFile(ChangeStateFormFile); string powerState = FormatPowerState(machine.PowerState); IPublicIPAddress ipAddress = machine.GetPrimaryPublicIPAddress(); string action; string buttonText; string formVisibility = "visible"; string qualifiedDnsName = string.Empty; string displayIp = string.Empty; string dnsCopyDisplayClass = "hidden"; string ipCopyDisplayClass = "hidden"; if (machine.PowerState == PowerState.Running) { action = nameof(StopVm); buttonText = "Deallocate"; qualifiedDnsName = ipAddress.Inner.DnsSettings != null ? ipAddress.Inner.DnsSettings.Fqdn : string.Empty; dnsCopyDisplayClass = !string.IsNullOrEmpty(qualifiedDnsName) ? "visible" : dnsCopyDisplayClass; displayIp = ipAddress.IPAddress; ipCopyDisplayClass = !string.IsNullOrEmpty(displayIp) ? "visible" : ipCopyDisplayClass; } else if (machine.PowerState == PowerState.Stopped || machine.PowerState == PowerState.Deallocated) { action = nameof(StartVm); buttonText = "Start"; } else { action = string.Empty; buttonText = string.Empty; formVisibility = "collapse"; } if (!string.IsNullOrEmpty(_functionAccessCode)) { action = $"{action}?code={_functionAccessCode}"; } string finalForm = string.Format(contents, machine.Name, powerState, qualifiedDnsName, displayIp, action, formVisibility, buttonText, dnsCopyDisplayClass, ipCopyDisplayClass); return(finalForm); }
public void CreateVM() { String region = AzureConnectionUtility.Region; String resourceGroup = AzureConnectionUtility.ResourceGroup; IAvailabilitySet availabilitySet = CreateAvailabilitySetIfNotExists(); IPublicIPAddress publicIPAddress = CreateIPIfNotExists(); INetwork network = CreateNetworkIfNotExists(); INetworkInterface networkInterface = CreateNetworkInterfaceIfNotExists(network, publicIPAddress); messageContainer.AddInformationMessage("Configuring virtual machine..."); String machineName = "azureAutoEngine_VM"; virtualMachine = azureConnection.AzureLink.VirtualMachines.GetByResourceGroup(AzureConnectionUtility.ResourceGroup, machineName); if (virtualMachine == null) { messageContainer.AddInformationMessage("Creating virtual machine..."); virtualMachine = azureConnection.AzureLink.VirtualMachines.Define(machineName) .WithRegion(AzureConnectionUtility.Region) .WithExistingResourceGroup(AzureConnectionUtility.ResourceGroup) .WithExistingPrimaryNetworkInterface(networkInterface) .WithLatestLinuxImage("credativ", "Debian", "8") .WithRootUsername("azureUser") .WithRootPassword("Azure12345678") .WithComputerName("azureAutoEngineVM") .WithExistingAvailabilitySet(availabilitySet) .WithSize(VirtualMachineSizeTypes.BasicA1) .Create(); messageContainer.AddInformationMessage("Virtual machine created..."); } if (virtualMachine.PowerState != PowerState.Running) { SwitchOnVM(); } messageContainer.AddInformationMessage("Virtual machine configured... feel free to inspect it on the portal..."); }
private IPublicIPAddress CreateIPIfNotExists() { messageContainer.AddInformationMessage("Configuring IP..."); String ipName = "azureAutoEngine_IPAddress"; IPublicIPAddress publicIPAddress = azureConnection.AzureLink.PublicIPAddresses.GetByResourceGroup(AzureConnectionUtility.ResourceGroup, ipName); if (publicIPAddress == null) { messageContainer.AddInformationMessage("Creating public IP..."); publicIPAddress = azureConnection.AzureLink.PublicIPAddresses.Define(ipName) .WithRegion(AzureConnectionUtility.Region) .WithExistingResourceGroup(AzureConnectionUtility.ResourceGroup) .WithDynamicIP() .Create(); messageContainer.AddInformationMessage("Public IP created..."); } messageContainer.AddInformationMessage("IP configured..."); return(publicIPAddress); }
internal async Task <string> GetVmStatusAsync(string name) { _helper.LogMessage($"Starting"); string returnMessage; IVirtualMachine machine = await GetVmByNameAsync(name); PowerState powerState = machine.PowerState; if (powerState == PowerState.Running) { IPublicIPAddress ipAddress = machine.GetPrimaryPublicIPAddress(); returnMessage = $"{powerState}, IP Address: {ipAddress.IPAddress}"; } else { returnMessage = $"Machine status: {powerState}"; } _helper.LogMessage($"Finished"); return(returnMessage); }
/// <summary> /// Associates an existing public IP address with the network interface's primary IP configuration. /// </summary> /// <param name="publicIPAddress">An existing public IP address.</param> /// <return>The next stage of the definition.</return> NetworkInterface.Definition.IWithCreate NetworkInterface.Definition.IWithPrimaryPublicIPAddress.WithExistingPrimaryPublicIPAddress(IPublicIPAddress publicIPAddress) { return this.WithExistingPrimaryPublicIPAddress(publicIPAddress) as NetworkInterface.Definition.IWithCreate; }
///GENMHASH:BE684C4F4845D0C09A9399569DFB7A42:05B694DF2AF4DFEC5D2DC7534C0AD459 public VirtualNetworkGatewayImpl WithExistingPublicIPAddress(IPublicIPAddress publicIPAddress) { EnsureDefaultIPConfig().WithExistingPublicIPAddress(publicIPAddress); return(this); }
///GENMHASH:AC21A10EE2E745A89E94E447800452C1:5EB77CF275BEAA2D6C9B6E198BAA8385 override protected void BeforeCreating() { // Account for the newly created public IPs if (creatablePIPKeys != null) { foreach (var pipFrontendAssociation in creatablePIPKeys) { IPublicIPAddress pip = (IPublicIPAddress)CreatedResource(pipFrontendAssociation.Key); if (pip != null) { WithExistingPublicIPAddress(pip.Id, pipFrontendAssociation.Value); } } creatablePIPKeys.Clear(); } // Reset and update probes var innerProbes = InnersFromWrappers <ProbeInner, ILoadBalancerHttpProbe>(httpProbes.Values); innerProbes = InnersFromWrappers(httpsProbes.Values, innerProbes); Inner.Probes = InnersFromWrappers(tcpProbes.Values, innerProbes) ?? new List <ProbeInner>(); // Reset and update backends Inner.BackendAddressPools = InnersFromWrappers <BackendAddressPoolInner, ILoadBalancerBackend>(backends.Values) ?? new List <BackendAddressPoolInner>(); // Reset and update frontends Inner.FrontendIPConfigurations = InnersFromWrappers <FrontendIPConfigurationInner, ILoadBalancerFrontend>(frontends.Values) ?? new List <FrontendIPConfigurationInner>(); // Reset and update inbound NAT rules Inner.InboundNatRules = InnersFromWrappers <InboundNatRuleInner, ILoadBalancerInboundNatRule>(inboundNatRules.Values) ?? new List <InboundNatRuleInner>(); foreach (var natRule in inboundNatRules.Values) { // Clear deleted frontend references var frontendRef = natRule.Inner.FrontendIPConfiguration; if (frontendRef != null && !Frontends().ContainsKey(ResourceUtils.NameFromResourceId(frontendRef.Id))) { natRule.Inner.FrontendIPConfiguration = null; } } // Reset and update inbound NAT pools Inner.InboundNatPools = InnersFromWrappers <InboundNatPoolInner, ILoadBalancerInboundNatPool>(inboundNatPools.Values) ?? new List <InboundNatPoolInner>(); foreach (var natPool in inboundNatPools.Values) { // Clear deleted frontend references var frontendRef = natPool.Inner.FrontendIPConfiguration; if (frontendRef != null && !Frontends().ContainsKey(ResourceUtils.NameFromResourceId(frontendRef.Id))) { natPool.Inner.FrontendIPConfiguration = null; } } // Reset and update load balancing rules Inner.LoadBalancingRules = InnersFromWrappers <LoadBalancingRuleInner, ILoadBalancingRule>(loadBalancingRules.Values) ?? new List <LoadBalancingRuleInner>(); foreach (var lbRule in loadBalancingRules.Values) { // Clear deleted frontend references var frontendRef = lbRule.Inner.FrontendIPConfiguration; if (frontendRef != null && !Frontends().ContainsKey(ResourceUtils.NameFromResourceId(frontendRef.Id))) { lbRule.Inner.FrontendIPConfiguration = null; } // Clear deleted backend references var backendRef = lbRule.Inner.BackendAddressPool; if (backendRef != null && !Backends().ContainsKey(ResourceUtils.NameFromResourceId(backendRef.Id))) { lbRule.Inner.BackendAddressPool = null; } // Clear deleted probe references var probeRef = lbRule.Inner.Probe; if (probeRef != null && !HttpProbes().ContainsKey(ResourceUtils.NameFromResourceId(probeRef.Id)) && !HttpsProbes().ContainsKey(ResourceUtils.NameFromResourceId(probeRef.Id)) && !TcpProbes().ContainsKey(ResourceUtils.NameFromResourceId(probeRef.Id))) { lbRule.Inner.Probe = null; } } }
/// <summary> /// Associates an existing public IP address with the resource. /// </summary> /// <param name="publicIPAddress">An existing public IP address.</param> /// <return>The next stage of the update.</return> ApplicationGatewayFrontend.Update.IUpdate HasPublicIPAddress.Update.IWithExistingPublicIPAddress <ApplicationGatewayFrontend.Update.IUpdate> .WithExistingPublicIPAddress(IPublicIPAddress publicIPAddress) { return(this.WithExistingPublicIPAddress(publicIPAddress) as ApplicationGatewayFrontend.Update.IUpdate); }
/// <summary> /// Associates an existing public IP address with the resource. /// </summary> /// <param name="publicIPAddress">An existing public IP address.</param> /// <return>The next stage of the definition.</return> ApplicationGatewayFrontend.Definition.IWithAttach <ApplicationGateway.Definition.IWithListener> HasPublicIPAddress.Definition.IWithExistingPublicIPAddress <ApplicationGatewayFrontend.Definition.IWithAttach <ApplicationGateway.Definition.IWithListener> > .WithExistingPublicIPAddress(IPublicIPAddress publicIPAddress) { return(this.WithExistingPublicIPAddress(publicIPAddress) as ApplicationGatewayFrontend.Definition.IWithAttach <ApplicationGateway.Definition.IWithListener>); }
/// <summary> /// Associates an existing public IP address with the resource. /// </summary> /// <param name="publicIPAddress">An existing public IP address.</param> /// <return>The next stage of the definition.</return> ApplicationGatewayFrontend.UpdateDefinition.IWithAttach <ApplicationGateway.Update.IUpdate> HasPublicIPAddress.UpdateDefinition.IWithExistingPublicIPAddress <ApplicationGatewayFrontend.UpdateDefinition.IWithAttach <ApplicationGateway.Update.IUpdate> > .WithExistingPublicIPAddress(IPublicIPAddress publicIPAddress) { return(this.WithExistingPublicIPAddress(publicIPAddress) as ApplicationGatewayFrontend.UpdateDefinition.IWithAttach <ApplicationGateway.Update.IUpdate>); }
///GENMHASH:8FC05031058012246BAA83A815D4D8FB:37FCC8D93CF67DD30C6ADCDA2115A8F2 internal NetworkInterfaceImpl WithExistingPrimaryPublicIPAddress(IPublicIPAddress publicIPAddress) { PrimaryIPConfiguration().WithExistingPublicIPAddress(publicIPAddress); return(this); }
static async Task <INetworkInterface> CreateNIC(IResourceGroup resourceGroup, INetwork network, string subnetName, IPublicIPAddress publicIPAddress, string name = "CSNIC") { Console.WriteLine("Creating network interface..."); return(await Subscription.NetworkInterfaces.Define("myNIC") .WithRegion(resourceGroup.Region) .WithExistingResourceGroup(resourceGroup) .WithExistingPrimaryNetwork(network) .WithSubnet(subnetName) .WithPrimaryPrivateIPAddressDynamic() .WithExistingPrimaryPublicIPAddress(publicIPAddress) .CreateAsync()); }
/// <summary> /// Associates an existing public IP address with the network interface's primary IP configuration. /// if there is an existing public IP association then that will be removed in favour of this. /// </summary> /// <param name="publicIPAddress">An existing public IP address.</param> /// <return>The next stage of the network interface update.</return> NetworkInterface.Update.IUpdate NetworkInterface.Update.IWithPrimaryPublicIPAddress.WithExistingPrimaryPublicIPAddress(IPublicIPAddress publicIPAddress) { return this.WithExistingPrimaryPublicIPAddress(publicIPAddress) as NetworkInterface.Update.IUpdate; }
/// <summary> /// Associates an existing public IP address with the resource. /// </summary> /// <param name="publicIPAddress">An existing public IP address.</param> /// <return>The next stage of the update.</return> LoadBalancerPublicFrontend.Update.IUpdate HasPublicIPAddress.Update.IWithExistingPublicIPAddress <LoadBalancerPublicFrontend.Update.IUpdate> .WithExistingPublicIPAddress(IPublicIPAddress publicIPAddress) { return(this.WithExistingPublicIPAddress(publicIPAddress)); }
/// <summary> /// Associates an existing public IP address with the resource. /// </summary> /// <param name="publicIPAddress">An existing public IP address.</param> /// <return>The next stage of the definition.</return> LoadBalancerPublicFrontend.UpdateDefinition.IWithAttach <LoadBalancer.Update.IUpdate> HasPublicIPAddress.UpdateDefinition.IWithExistingPublicIPAddress <LoadBalancerPublicFrontend.UpdateDefinition.IWithAttach <LoadBalancer.Update.IUpdate> > .WithExistingPublicIPAddress(IPublicIPAddress publicIPAddress) { return(this.WithExistingPublicIPAddress(publicIPAddress)); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log) { log.LogInformation($"{DateAndTime()} | C# HTTP trigger function processed a request."); string requestBody = await new StreamReader(req.Body).ReadToEndAsync(); ProvisioningModel provisioningModel = JsonConvert.DeserializeObject <ProvisioningModel>(requestBody); if (string.IsNullOrEmpty(provisioningModel.ClientId) || string.IsNullOrEmpty(provisioningModel.ClientSecret) || string.IsNullOrEmpty(provisioningModel.TenantId) || string.IsNullOrEmpty(provisioningModel.SubscriptionId) || string.IsNullOrEmpty(provisioningModel.ClustrerName) || string.IsNullOrEmpty(provisioningModel.ResourceGroupName) || string.IsNullOrEmpty(provisioningModel.MainVhdURL) || string.IsNullOrEmpty(provisioningModel.SmtpServer) || string.IsNullOrEmpty(provisioningModel.SmtpPort.ToString()) || string.IsNullOrEmpty(provisioningModel.SmtpEmail) || string.IsNullOrEmpty(provisioningModel.SmtpPassword)) { log.LogInformation($"{DateAndTime()} | Error | Missing parameter | \n{requestBody}"); return(new BadRequestObjectResult(false)); } else { bool isSingleInstance; switch (provisioningModel.InstanceCount) { case "1": { isSingleInstance = true; break; } case "3": { isSingleInstance = false; if ( string.IsNullOrEmpty(provisioningModel.MysqlVhdURL) || string.IsNullOrEmpty(provisioningModel.MongoVhdURL)) { log.LogInformation($"{DateAndTime()} | Error | Missing parameter for 3 instance (MysqlVhdURL/MongoVhdURL) | \n{requestBody}"); return(new BadRequestObjectResult(false)); } break; } default: { log.LogInformation($"{DateAndTime()} | Error | Please set valid instance count (1 or 3) | \n{requestBody}"); return(new BadRequestObjectResult(false)); } } SmtpClient smtpClient = new SmtpClient() { Host = provisioningModel.SmtpServer, Port = provisioningModel.SmtpPort, EnableSsl = true, UseDefaultCredentials = false, Credentials = new NetworkCredential(provisioningModel.SmtpEmail, provisioningModel.SmtpPassword) }; MailMessage mailMessage = new MailMessage(); mailMessage.From = new MailAddress(provisioningModel.SmtpEmail); mailMessage.To.Add(new MailAddress(provisioningModel.SmtpEmail)); mailMessage.Subject = "Branch Academy Installation"; try { string resourceGroupName = provisioningModel.ResourceGroupName; string clusterName = provisioningModel.ClustrerName; string MainVhdURL = provisioningModel.MainVhdURL; string MysqlVhdURL = provisioningModel.MysqlVhdURL; string MongoVhdURL = provisioningModel.MongoVhdURL; string subnet = "default"; string username = provisioningModel.Username; string password = provisioningModel.Password; string contactPerson = provisioningModel.SmtpEmail; log.LogInformation("deploying Main instance"); Utils.Email(smtpClient, "Main Instance Deployed Successfully", log, mailMessage); ServicePrincipalLoginInformation principalLogIn = new ServicePrincipalLoginInformation(); principalLogIn.ClientId = provisioningModel.ClientId; principalLogIn.ClientSecret = provisioningModel.ClientSecret; AzureEnvironment environment = AzureEnvironment.AzureGlobalCloud; AzureCredentials credentials = new AzureCredentials(principalLogIn, provisioningModel.TenantId, environment); IAzure _azureProd = Azure.Configure() .WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic) .Authenticate(credentials) .WithSubscription(provisioningModel.SubscriptionId); IResourceGroup resourceGroup = _azureProd.ResourceGroups.GetByName(resourceGroupName); Region region = resourceGroup.Region; #region comment #region Create Virtual Network INetwork virtualNetwork = _azureProd.Networks.Define($"{clusterName}-vnet") .WithRegion(region) .WithExistingResourceGroup(resourceGroupName) .WithAddressSpace("10.0.0.0/16") .DefineSubnet(subnet) .WithAddressPrefix("10.0.0.0/24") .Attach() .WithTag("_contact_person", contactPerson) .Create(); #endregion log.LogInformation($"{DateAndTime()} | Created | VNET"); #region Create VM IP IPublicIPAddress publicIpAddress = _azureProd.PublicIPAddresses.Define($"{clusterName}-vm-ip") .WithRegion(region) .WithExistingResourceGroup(resourceGroupName) .WithDynamicIP() .WithLeafDomainLabel(clusterName) .WithTag("_contact_person", contactPerson) .Create(); #endregion log.LogInformation($"{DateAndTime()} | Created | VM IP Address"); #region NSG INetworkSecurityGroup networkSecurityGroup = _azureProd.NetworkSecurityGroups.Define($"{clusterName}-nsg") .WithRegion(region) .WithExistingResourceGroup(resourceGroupName) .DefineRule("ALLOW-SSH") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(22) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(100) .WithDescription("Allow SSH") .Attach() .DefineRule("LMS") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(80) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(101) .WithDescription("LMS") .Attach() .DefineRule("CMS") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(18010) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(102) .WithDescription("CMS") .Attach() .DefineRule("CMSSSLPort") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(48010) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(112) .WithDescription("CMSSSLPort") .Attach() .DefineRule("LMSSSLPort") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(443) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(122) .WithDescription("LMSSSLPort") .Attach() .DefineRule("Certs") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(18090) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(132) .WithDescription("Certs") .Attach() .DefineRule("Discovery") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(18381) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(142) .WithDescription("Discovery") .Attach() .DefineRule("Ecommerce") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(18130) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(152) .WithDescription("Ecommerce") .Attach() .DefineRule("edx-release") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(8099) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(162) .WithDescription("edx-release") .Attach() .DefineRule("Forum") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(18080) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(172) .WithDescription("Forum") .Attach() .WithTag("_contact_person", contactPerson) .DefineRule("Xqueue") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(18040) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(182) .WithDescription("Xqueue") .Attach() .WithTag("_contact_person", contactPerson) .Create(); #endregion log.LogInformation($"{DateAndTime()} | Created | Network Security Group"); #region nic INetworkInterface networkInterface = _azureProd.NetworkInterfaces.Define($"{clusterName}-nic") .WithRegion(region) .WithExistingResourceGroup(resourceGroupName) .WithExistingPrimaryNetwork(virtualNetwork) .WithSubnet(subnet) .WithPrimaryPrivateIPAddressDynamic() .WithExistingPrimaryPublicIPAddress(publicIpAddress) .WithExistingNetworkSecurityGroup(networkSecurityGroup) .WithTag("_contact_person", contactPerson) .Create(); #endregion log.LogInformation($"{DateAndTime()} | Created | Network Interface"); IStorageAccount storageAccount = _azureProd.StorageAccounts.GetByResourceGroup(resourceGroupName, $"{clusterName}vhdsa"); #region vm IVirtualMachine createVm = _azureProd.VirtualMachines.Define($"{clusterName}-jb") .WithRegion(region) .WithExistingResourceGroup(resourceGroupName) .WithExistingPrimaryNetworkInterface(networkInterface) .WithStoredLinuxImage(MainVhdURL) .WithRootUsername(username) .WithRootPassword(password) .WithComputerName(username) .WithBootDiagnostics(storageAccount) .WithSize(VirtualMachineSizeTypes.StandardD2sV3) .WithTag("_contact_person", contactPerson) .Create(); #endregion log.LogInformation($"{DateAndTime()} | Created | Main Virtual Machine"); #region LMS IP IPublicIPAddress publicIPAddressLMS = _azureProd.PublicIPAddresses.Define($"{clusterName}-lms-ip") .WithRegion(region) .WithExistingResourceGroup(resourceGroupName) .WithDynamicIP() .WithLeafDomainLabel($"{clusterName}-lms-ip") .WithTag("_contact_person", contactPerson) .Create(); #endregion log.LogInformation($"{DateAndTime()} | Created | LMS Public IP Address"); #region CMS IP IPublicIPAddress publicIPAddressCMS = _azureProd.PublicIPAddresses.Define($"{clusterName}-cms-ip") .WithRegion(region) .WithExistingResourceGroup(resourceGroupName) .WithDynamicIP() .WithLeafDomainLabel($"{clusterName}-cms-ip") .WithTag("_contact_person", contactPerson) .Create(); #endregion log.LogInformation($"{DateAndTime()} | Created | CMS Public IP Address"); #region LoadBalancer ILoadBalancer loadBalancer = _azureProd.LoadBalancers.Define($"{clusterName}-lb") .WithRegion(region) .WithExistingResourceGroup(resourceGroupName) .DefineLoadBalancingRule("LBRuleCMS") .WithProtocol(TransportProtocol.Tcp) .FromFrontend("CMS") .FromFrontendPort(80) .ToBackend($"{clusterName}-bepool") .ToBackendPort(18010) .WithProbe("tcpProbeCMS") .WithFloatingIPDisabled() .Attach() .DefineLoadBalancingRule("LBRuleCMS_SSL") .WithProtocol(TransportProtocol.Tcp) .FromFrontend("CMS") .FromFrontendPort(443) .ToBackend($"{clusterName}-bepool") .ToBackendPort(48010) .WithProbe("tcpProbeCMSSSL") .WithFloatingIPDisabled() .Attach() .DefineLoadBalancingRule("LBRuleLMS") .WithProtocol(TransportProtocol.Tcp) .FromFrontend("LMS") .FromFrontendPort(80) .ToBackend($"{clusterName}-bepool") .ToBackendPort(80) .WithProbe("tcpProbeLMS") .WithFloatingIPDisabled() .Attach() .DefineLoadBalancingRule("LBRuleLMS_SSL") .WithProtocol(TransportProtocol.Tcp) .FromFrontend("LMS") .FromFrontendPort(443) .ToBackend($"{clusterName}-bepool") .ToBackendPort(443) .WithProbe("tcpProbeLMSSSL") .WithFloatingIPDisabled() .Attach() .DefineBackend($"{clusterName}-bepool") .WithExistingVirtualMachines(createVm) .Attach() .DefinePublicFrontend("LMS") .WithExistingPublicIPAddress(publicIPAddressLMS) .Attach() .DefinePublicFrontend("CMS") .WithExistingPublicIPAddress(publicIPAddressCMS) .Attach() .DefineHttpProbe("tcpProbeCMS") .WithRequestPath("/heartbeat") .WithPort(18010) .WithIntervalInSeconds(5) .WithNumberOfProbes(6) .Attach() .DefineTcpProbe("tcpProbeCMSSSL") .WithPort(48010) .WithIntervalInSeconds(5) .WithNumberOfProbes(6) .Attach() .DefineHttpProbe("tcpProbeLMS") .WithRequestPath("/heartbeat") .WithPort(80) .WithIntervalInSeconds(5) .WithNumberOfProbes(6) .Attach() .DefineTcpProbe("tcpProbeLMSSSL") .WithPort(443) .WithIntervalInSeconds(5) .WithNumberOfProbes(6) .Attach() .WithTag("_contact_person", contactPerson) .Create(); #endregion log.LogInformation($"{DateAndTime()} | Created | Load Balancer"); #region tm IWithEndpoint tmDefinitionLMS = _azureProd.TrafficManagerProfiles .Define($"{clusterName}-lms-tm") .WithExistingResourceGroup(resourceGroupName) .WithLeafDomainLabel($"{clusterName}-lms-tm") .WithPriorityBasedRouting(); ICreatable <ITrafficManagerProfile> tmCreatableLMS = null; tmCreatableLMS = tmDefinitionLMS .DefineExternalTargetEndpoint($"{clusterName}-lms-tm") .ToFqdn(publicIPAddressLMS.Fqdn) .FromRegion(region) .WithRoutingPriority(1) .Attach() .WithTag("_contact_person", contactPerson); ITrafficManagerProfile trafficManagerProfileLMS = tmCreatableLMS.Create(); log.LogInformation($"{DateAndTime()} | Created | LMS Traffic Manager"); IWithEndpoint tmDefinitionCMS = _azureProd.TrafficManagerProfiles .Define($"{clusterName}-cms-tm") .WithExistingResourceGroup(resourceGroupName) .WithLeafDomainLabel($"{clusterName}-cms-tm") .WithPriorityBasedRouting(); ICreatable <ITrafficManagerProfile> tmCreatableCMS = null; tmCreatableCMS = tmDefinitionCMS .DefineExternalTargetEndpoint($"{clusterName}-cms-tm") .ToFqdn(publicIPAddressCMS.Fqdn) .FromRegion(region) .WithRoutingPriority(1) .Attach() .WithTag("_contact_person", contactPerson); ITrafficManagerProfile trafficManagerProfileCMS = tmCreatableCMS.Create(); log.LogInformation($"{DateAndTime()} | Created | CMS Traffic Manager"); #endregion #endregion if (!isSingleInstance) { #region mysql INetworkSecurityGroup networkSecurityGroupmysql = _azureProd.NetworkSecurityGroups.Define($"{clusterName}-mysql-nsg") .WithRegion(region) .WithExistingResourceGroup(resourceGroup) .DefineRule("ALLOW-SSH") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(22) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(100) .WithDescription("Allow SSH") .Attach() .DefineRule("mysql") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(3306) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(101) .WithDescription("mysql") .Attach() .WithTag("_contact_person", contactPerson) .Create(); log.LogInformation($"{DateAndTime()} | Created | MySQL Network Security Group"); INetworkInterface networkInterfacemysql = _azureProd.NetworkInterfaces.Define($"{clusterName}-mysql-nic") .WithRegion(region) .WithExistingResourceGroup(resourceGroup) .WithExistingPrimaryNetwork(virtualNetwork) .WithSubnet(subnet) .WithPrimaryPrivateIPAddressDynamic() .WithExistingNetworkSecurityGroup(networkSecurityGroupmysql) .WithTag("_contact_person", contactPerson) .Create(); log.LogInformation($"{DateAndTime()} | Created | MySQL Network Interface"); IVirtualMachine createVmmysql = _azureProd.VirtualMachines.Define($"{clusterName}-mysql") .WithRegion(region) .WithExistingResourceGroup(resourceGroup) .WithExistingPrimaryNetworkInterface(networkInterfacemysql) .WithStoredLinuxImage(MysqlVhdURL) .WithRootUsername(username) .WithRootPassword(password) .WithComputerName("mysql") .WithBootDiagnostics(storageAccount) .WithSize(VirtualMachineSizeTypes.StandardD2V2) .WithTag("_contact_person", contactPerson) .Create(); log.LogInformation($"{DateAndTime()} | Created | MySQL Virtual Machine"); #endregion #region mongodb INetworkSecurityGroup networkSecurityGroupmongo = _azureProd.NetworkSecurityGroups.Define($"{clusterName}-mongo-nsg") .WithRegion(region) .WithExistingResourceGroup(resourceGroup) .DefineRule("ALLOW-SSH") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(22) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(100) .WithDescription("Allow SSH") .Attach() .DefineRule("mongodb") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(27017) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(101) .WithDescription("mongodb") .Attach() .WithTag("_contact_person", contactPerson) .Create(); log.LogInformation($"{DateAndTime()} | Created | MongoDB Network Security Group"); INetworkInterface networkInterfacemongo = _azureProd.NetworkInterfaces.Define($"{clusterName}-mongo-nic") .WithRegion(region) .WithExistingResourceGroup(resourceGroup) .WithExistingPrimaryNetwork(virtualNetwork) .WithSubnet(subnet) .WithPrimaryPrivateIPAddressDynamic() .WithExistingNetworkSecurityGroup(networkSecurityGroupmongo) .WithTag("_contact_person", contactPerson) .Create(); log.LogInformation($"{DateAndTime()} | Created | MongoDB Network Interface"); IVirtualMachine createVmmongo = _azureProd.VirtualMachines.Define($"{clusterName}-mongo") .WithRegion(region) .WithExistingResourceGroup(resourceGroup) .WithExistingPrimaryNetworkInterface(networkInterfacemongo) .WithStoredLinuxImage(MongoVhdURL) .WithRootUsername(username) .WithRootPassword(password) .WithComputerName("mongo") .WithBootDiagnostics(storageAccount) .WithSize(VirtualMachineSizeTypes.StandardD2V2) .WithTag("_contact_person", contactPerson) .Create(); log.LogInformation($"{DateAndTime()} | Created | MongoDB Virtual Machine"); #endregion log.LogInformation("deploying 3 instance"); Utils.Email(smtpClient, "MySQL Instance Deployed Successfully", log, mailMessage); } string cmsUrl = trafficManagerProfileCMS.DnsLabel; string lmsUrl = trafficManagerProfileLMS.DnsLabel; Utils.Email(smtpClient, "Your Learning Platform is Ready to use." + "<br/>" + $"<a href=\"{lmsUrl}\">LMS</a>" + "<br/>" + $"<a href=\"{cmsUrl}\">CMS</a>" , log, mailMessage); log.LogInformation($"Done"); } catch (Exception e) { log.LogInformation($"{DateAndTime()} | Error | {e.Message}"); return(new BadRequestObjectResult(false)); } log.LogInformation($"{DateAndTime()} | Done"); return(new OkObjectResult(true)); } }