public static async Task <IAuthenticated> GetAzureClient(TrialResource resource, ILogger log) { if (_azureClient == null || DateTime.UtcNow >= _tokenExpiry) { if (DateTime.UtcNow >= _tokenExpiry) { log.LogInformation($"Renewing token at {DateTime.UtcNow.ToLongDateString()}"); } else { log.LogInformation($"Creating new azureclient at {DateTime.UtcNow.ToLongDateString()}"); } var tenantId = resource.TenantId; var tokenCredentials = new TokenCredentials(await _azureServiceTokenProvider.GetAccessTokenAsync("https://management.azure.com/")); var azureCredentials = new AzureCredentials( tokenCredentials, tokenCredentials, tenantId, AzureEnvironment.FromName(resource.Template.AzureEnvironment)); var client = RestClient .Configure() .WithEnvironment(AzureEnvironment.FromName(resource.Template.AzureEnvironment)) .WithLogLevel(resource.Template.DeploymentLoggingLevel.ToEnum <HttpLoggingDelegatingHandler.Level>()) .WithCredentials(azureCredentials) .Build(); _tokenExpiry = DateTime.UtcNow.AddMinutes(30); _azureClient = Azure .Authenticate(client, tenantId); } return((IAuthenticated)_azureClient); }
public TransferClient( AzureEnvironmentConfiguration azureEnvironmentConfiguration, IdentityConfiguration identityConfiguration, RegistryConfiguration registryConfiguration) { _registryConfiguration = registryConfiguration ?? throw new ArgumentNullException(nameof(registryConfiguration)); var env = AzureEnvironment.FromName(azureEnvironmentConfiguration.Name); if (env == null) { env = new AzureEnvironment { Name = azureEnvironmentConfiguration.Name, AuthenticationEndpoint = azureEnvironmentConfiguration.AuthenticationEndpoint, ManagementEndpoint = azureEnvironmentConfiguration.ManagementEndpoint, ResourceManagerEndpoint = azureEnvironmentConfiguration.ResourceManagerEndpoint, GraphEndpoint = azureEnvironmentConfiguration.GraphEndpoint, KeyVaultSuffix = azureEnvironmentConfiguration.KeyVaultSuffix, StorageEndpointSuffix = azureEnvironmentConfiguration.StorageEndpointSuffix }; } var credential = new AzureCredentials( new ServicePrincipalLoginInformation { ClientId = identityConfiguration.ClientId, ClientSecret = identityConfiguration.ClientSecret }, registryConfiguration.TenantId, env); _registryClient = new ContainerRegistryManagementClient(credential.WithDefaultSubscription(registryConfiguration.SubscriptionId)); _registryClient.SubscriptionId = registryConfiguration.SubscriptionId; }
public async System.Threading.Tasks.Task <ActionResult> ListStorageAccountAsync() { // var credentials = SdkContext.AzureCredentialsFactory.FromFile(Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION")); // AzureEnvironment env = new AzureEnvironment(); //var credentias = SdkContext.AzureCredentialsFactory.FromServicePrincipal("bc472b9f-bfd3-4a23-b99a-fbc1e1d35a24", "OaOM_qlh7V17reE_6w0tn_JFr2u82z_6gq","3882b70d-a91e-468c-9928-820358bfbd73",env); DefaultAzureCredential credential = new DefaultAzureCredential(); await ListSubscriptions.Models.ListSubscriptions.GetSubscriptions(credential); AzureEnvironment env = AzureEnvironment.FromName("AzureGlobalCloud"); Debug.WriteLine("environment-->" + env); var credentials = SdkContext.AzureCredentialsFactory.FromServicePrincipal("bc472b9f-bfd3-4a23-b99a-fbc1e1d35a24", "OaOM_qlh7V17reE_6w0tn_JFr2u82z_6gq", "3882b70d-a91e-468c-9928-820358bfbd73", env); //DefaultAzureCredential credential = new DefaultAzureCredential(); //await ListSubscriptions.Models.ListSubscriptions.GetSubscriptions(credential); //var credentiall = SdkContext.AzureCredentialsFactory. var azure = Microsoft.Azure.Management.Fluent.Azure.Configure() .WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic) .Authenticate(credentials) .WithDefaultSubscription(); string subscriptionId = ListSubscriptions.Models.ListSubscriptions.SubscriptionID; GetStorageAccount(azure, credential, subscriptionId); return(View()); }
public void FromName() { Assert.Equal(AzureEnvironment.AzureGlobalCloud, AzureEnvironment.FromName("AzureGlobalCloud")); Assert.Equal(AzureEnvironment.AzureChinaCloud, AzureEnvironment.FromName("AzureChinaCloud")); Assert.Equal(AzureEnvironment.AzureGlobalCloud, AzureEnvironment.FromName("AzuregLobalCloud")); Assert.Equal(AzureEnvironment.AzureGlobalCloud, AzureEnvironment.FromName("azureglobalcloud")); }
protected async Task <IContainerInstanceManager> Authenticate() { var env = AzureEnvironment.FromName(this.attribute.AzureEnvironment); string accessToken = await _tokenProvider.GetAccessTokenAsync(env.ResourceManagerEndpoint).ConfigureAwait(false); var creds = new AzureCredentials(new TokenCredentials(accessToken), new TokenCredentials(accessToken), _tokenProvider.PrincipalUsed.TenantId, env); return(ContainerInstanceManager.Authenticate(creds, this.attribute.SubscriptionId)); }
public AzureClient(Subscription subscription) { Subscription = subscription ?? throw new ArgumentNullException(nameof(subscription)); Environment = AzureEnvironment.FromName(Subscription.Environment); _identity = new Lazy <AzureIdentity>(GetIdentity, true); _billing = new Lazy <Client>(GetBilling, true); _management = new Lazy <IAzure>(GetAzure, true); }
public static AzureEnvironment ParseAzureEnvironment(string environmentName) { if (string.IsNullOrEmpty(environmentName)) { return(AzureEnvironment.AzureGlobalCloud); } return(AzureEnvironment.FromName(environmentName) ?? throw new Exception("Unknown environment: " + environmentName)); }
/// <param name="environment">The environment name exactly matching the names defined in Azure SDK (see here https://github.com/Azure/azure-libraries-for-net/blob/master/src/ResourceManagement/ResourceManager/AzureEnvironment.cs) /// Other names are allowed in case this list is ever expanded/changed, but will likely result in an error at deployment time. /// </param> public AzureKnownEnvironment(string environment) { Value = environment; if (string.IsNullOrEmpty(environment) || environment == "AzureCloud") // This environment name is defined in Sashimi.Azure.Accounts.AzureEnvironmentsListAction { Value = Global.Value; // We interpret it as the normal Azure environment for historical reasons) } azureSdkEnvironment = AzureEnvironment.FromName(Value) ?? throw new InvalidOperationException($"Unknown environment name {Value}"); }
private static async System.Threading.Tasks.Task DeleteImageAsync( ContainerRegistryImageDeletedEventData deleteEvent, AppConfiguration configuration, ILogger log) { // Create the resourceId from the target ACR resourceId string var targetACRResourceId = ResourceId.FromString(configuration.TargetACRResourceId); // Create Azure credentials to talk to target Cloud using the Active directory application var credential = new AzureCredentials( new ServicePrincipalLoginInformation { ClientId = configuration.TargetAzureServicePrincipalClientId, ClientSecret = configuration.TargetAzureServicePrincipalClientKey }, configuration.TargetAzureServicePrincipalTenantId, AzureEnvironment.FromName(configuration.TargetAzureEnvironmentName)) .WithDefaultSubscription(targetACRResourceId.SubscriptionId); var builder = RestClient .Configure() .WithEnvironment(AzureEnvironment.FromName(configuration.TargetAzureEnvironmentName)) .WithCredentials(credential) .Build(); // Create ACR management client using the Azure credentials var _registryClient = new ContainerRegistryManagementClient(builder); _registryClient.SubscriptionId = targetACRResourceId.SubscriptionId; // Fetch the target ACR properties to identify its login server. var targetRegistry = await _registryClient.Registries.GetAsync( resourceGroupName : targetACRResourceId.ResourceGroupName, registryName : targetACRResourceId.Name) ?? throw new InvalidOperationException($"'{configuration.TargetACRResourceId}' is not found"); // Create ACR data plane client using the Azure credentials var registryCredentials = new ContainerRegistryCredentials( ContainerRegistryCredentials.LoginMode.TokenAuth, targetRegistry.LoginServer, configuration.TargetAzureServicePrincipalClientId, configuration.TargetAzureServicePrincipalClientKey); var client = new AzureContainerRegistryClient(registryCredentials); // Invoke Delete of the image that is part of the delete event on the target ACR. await client.Manifests.DeleteAsync( name : deleteEvent.Target.Repository, reference : deleteEvent.Target.Digest); log.LogInformation($"Image '{deleteEvent.Target.Repository}:@{deleteEvent.Target.Digest}' deleted from registry '{configuration.TargetACRResourceId}'"); }
public AzureEnvironmentHelper(string azureEnvironmentName) { if (AzureEnvironment.FromName(azureEnvironmentName) == null) { var region = Environment.GetEnvironmentVariable("REGION_NAME"); if (!string.IsNullOrWhiteSpace(region) && RegionToEnvironmentNameMapping.TryGetValue(region, out var cloudEnvironment)) { azureEnvironmentName = cloudEnvironment; } else { azureEnvironmentName = "AzureGlobalCloud"; } } var azureEnvironment = AzureEnvironment.FromName(azureEnvironmentName); this.AzureEnvironmentName = azureEnvironment.Name; this.AuthenticationEndpoint = azureEnvironment.AuthenticationEndpoint; this.ResourceManagerEndpoint = azureEnvironment.ResourceManagerEndpoint; this.StorageEndpointSuffix = azureEnvironment.StorageEndpointSuffix; }
public async Task <IActionResult> DeleteVmFromDedicatedHost( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log, ExecutionContext context) { var parameters = req.GetQueryParameterDictionary(); if (!parameters.ContainsKey(Constants.CloudName) || string.IsNullOrEmpty(parameters[Constants.CloudName])) { return(new BadRequestObjectResult("CloudName was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.TenantId) || string.IsNullOrEmpty(parameters[Constants.TenantId])) { return(new BadRequestObjectResult("TenantId was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.Token) || string.IsNullOrEmpty(parameters[Constants.Token])) { return(new BadRequestObjectResult("Token was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.SubscriptionId) || string.IsNullOrEmpty(parameters[Constants.SubscriptionId])) { return(new BadRequestObjectResult("Subscription ID was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.ResourceGroup) || string.IsNullOrEmpty(parameters[Constants.ResourceGroup])) { return(new BadRequestObjectResult("Resource group was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.DedicatedHostGroupName) || string.IsNullOrEmpty(parameters[Constants.DedicatedHostGroupName])) { return(new BadRequestObjectResult("Dedicated host group was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.VmName) || string.IsNullOrEmpty(parameters[Constants.VmName])) { return(new BadRequestObjectResult("VmName was missing in the query parameters.")); } var sw = Stopwatch.StartNew(); try { var cloudName = parameters[Constants.CloudName]; AzureEnvironment azureEnvironment = null; if (cloudName.Equals("AzureGlobalCloud", StringComparison.InvariantCultureIgnoreCase) || cloudName.Equals("AzureCloud", StringComparison.InvariantCultureIgnoreCase)) { azureEnvironment = AzureEnvironment.AzureGlobalCloud; } else { azureEnvironment = AzureEnvironment.FromName(cloudName); } await _dedicatedHostEngine.DeleteVmOnDedicatedHost( parameters[Constants.Token], azureEnvironment, parameters[Constants.TenantId], parameters[Constants.SubscriptionId], parameters[Constants.ResourceGroup], parameters[Constants.DedicatedHostGroupName], parameters[Constants.VmName]); log.LogInformation( $"DeleteVm: Took {sw.Elapsed.TotalSeconds}s to delete {parameters[Constants.VmName]}"); log.LogMetric("VmDeletionTimeSecondsMetric", sw.Elapsed.TotalSeconds); log.LogMetric("VmDeletionSuccessCountMetric", 1); return(new OkObjectResult($"Deleted {parameters[Constants.VmName]}.")); } catch (Exception exception) { log.LogError( $"DeleteVm: Error deleting {parameters[Constants.VmName]}, time spent: {sw.Elapsed.TotalSeconds}s, Exception: {exception}"); log.LogMetric("VmDeletionFailureCountMetric", 1); return(new BadRequestObjectResult(exception.ToString())); } }
public static async Task Run([QueueTrigger("create-items")] TrialResource myQueueItem, ILogger log) { log.LogInformation("CreateResource QueueTrigger function processed a request."); var subscriptionId = myQueueItem.SubscriptionId;; AzureServiceTokenProvider azureServiceTokenProvider = new AzureServiceTokenProvider(); var tenantId = myQueueItem.TenantId; var tokenCredentials = new TokenCredentials(await azureServiceTokenProvider.GetAccessTokenAsync("https://management.azure.com/").ConfigureAwait(false)); var azureCredentials = new AzureCredentials( tokenCredentials, tokenCredentials, tenantId, AzureEnvironment.FromName(myQueueItem.AzureEnvironment)); var client = RestClient .Configure() .WithEnvironment(AzureEnvironment.FromName(myQueueItem.AzureEnvironment)) .WithLogLevel(myQueueItem.DeploymentLoggingLevel.ToEnum <HttpLoggingDelegatingHandler.Level>()) .WithCredentials(azureCredentials) .Build(); var azure = Azure .Authenticate(client, tenantId) .WithSubscription(subscriptionId); // var resourceManagementClient = new ResourceManagementClient(client); string rgName = myQueueItem.ResourceGroupName; //SdkContext.RandomResourceName(myQueueItem.ResourceGroupName, 24); string deploymentName = myQueueItem.AppServiceName; try { //var templateJson = File.ReadAllText(System.IO.Path.Combine(context.FunctionDirectory, "..\\FreeFunctionARMTemplate.json")); //============================================================= // Create resource group. Console.WriteLine("Creating a resource group with name: " + rgName); await azure.ResourceGroups.Define(rgName) .WithRegion(myQueueItem.Region.ToEnum <Region>()) .CreateAsync(); Console.WriteLine("Created a resource group with name: " + rgName); //============================================================= // Create a deployment for an Azure App Service via an ARM template. Console.WriteLine("Starting a deployment for an Azure App Service: " + deploymentName); await azure.Deployments.Define(deploymentName) .WithExistingResourceGroup(rgName) .WithTemplateLink("", null) //.WithParameters(new Dictionary<string, Dictionary<string, object>>{ // { "hostingPlanName", new Dictionary<string, object>{{"value",deploymentName}}}, // { "skuName", new Dictionary<string, object>{{"value", "B1" }}}, // { "skuCapacity", new Dictionary<string, object>{{"value",1}}}, // { "webSiteName", new Dictionary<string, object>{{"value", deploymentName } }} // }) //.WithParameters(new Dictionary<string, Dictionary<string, object>>{ // { "msdeployPackageUrl", new Dictionary<string, object>{{"value", "https://tryappservicetemplates.blob.core.windows.net/zipped/Default/Express.zip" } }}, // { "appServiceName", new Dictionary<string, object>{{"value", deploymentName } }} // }) .WithParametersLink("", null) .WithMode(myQueueItem.DeploymentMode.ToEnum <DeploymentMode>()) .CreateAsync(); Console.WriteLine("Started a deployment for an Azure App Service: " + deploymentName); var deployment = await azure.Deployments.GetByResourceGroupAsync(rgName, deploymentName); Console.WriteLine("Current deployment status : " + deployment.ProvisioningState); var tries = 180; while (!(StringComparer.OrdinalIgnoreCase.Equals(deployment.ProvisioningState, "Succeeded") || StringComparer.OrdinalIgnoreCase.Equals(deployment.ProvisioningState, "Failed") || StringComparer.OrdinalIgnoreCase.Equals(deployment.ProvisioningState, "Cancelled")) && tries-- > 0) { SdkContext.DelayProvider.Delay(10000); deployment = await azure.Deployments.GetByResourceGroupAsync(rgName, deploymentName); Console.WriteLine("Current deployment status : " + deployment.ProvisioningState); } if (StringComparer.OrdinalIgnoreCase.Equals(deployment.ProvisioningState, "Succeeded")) { var res = deployment.Outputs; var sitesDeployed = deployment.Dependencies.Where(a => StringComparer.OrdinalIgnoreCase.Equals(a.ResourceType, "Microsoft.Web/sites")); if (sitesDeployed != null) { var siteList = new List <IWebApp>(); foreach (var site in sitesDeployed) { siteList.Add(await azure.WebApps.GetByIdAsync(site.Id)); } } } } catch (Exception ex) { Console.WriteLine(ex); } finally { try { Console.WriteLine("Deleting Resource Group: " + rgName); azure.ResourceGroups.DeleteByName(rgName); Console.WriteLine("Deleted Resource Group: " + rgName); } catch (NullReferenceException) { Console.WriteLine("Did not create any resources in Azure. No clean up is necessary"); } catch (Exception ex) { Console.WriteLine(ex); } } string name = myQueueItem.AppServiceName; }
public async Task <IActionResult> TestDhmConcurrentVmCreation( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log) { var parameters = req.GetQueryParameterDictionary(); if (!parameters.ContainsKey(ResourceGroupName) || string.IsNullOrEmpty(parameters[ResourceGroupName])) { return(new BadRequestObjectResult("Resource group name was missing in the query parameters.")); } if (!parameters.ContainsKey(HostGroupName) || string.IsNullOrEmpty(parameters[HostGroupName])) { return(new BadRequestObjectResult("Host group name was missing in the query parameters.")); } if (!parameters.ContainsKey(VmCount) || string.IsNullOrEmpty(parameters[VmCount])) { return(new BadRequestObjectResult("VmCount was missing in the query parameters.")); } if (!parameters.ContainsKey(VmSku) || string.IsNullOrEmpty(parameters[VmSku])) { return(new BadRequestObjectResult("VM SKU was missing in the query parameters.")); } var authEndpoint = _configuration["AuthEndpoint"]; var azureRmEndpoint = _configuration["AzureRmEndpoint"]; var location = _configuration["Location"]; var virtualMachineSize = parameters[VmSku]; var numVirtualMachines = int.Parse(parameters[VmCount]); var tenantId = _configuration["TenantId"]; var clientId = _configuration["ClientId"]; var clientSecret = _configuration["FairfaxClientSecret"]; var subscriptionId = _configuration["SubscriptionId"]; var resourceGroupName = parameters[ResourceGroupName]; var hostGroupName = parameters[HostGroupName]; log.LogInformation($"Generating auth token..."); var token = await TokenHelper.GetToken( authEndpoint, azureRmEndpoint, tenantId, clientId, clientSecret); var customTokenProvider = new AzureCredentials( new TokenCredentials(token), new TokenCredentials(token), tenantId, AzureEnvironment.FromName(_configuration["CloudName"])); var client = RestClient .Configure() .WithEnvironment(AzureEnvironment.FromName(_configuration["CloudName"])) .WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic) .WithCredentials(customTokenProvider) .Build(); var azure = Azure.Authenticate(client, tenantId).WithSubscription(subscriptionId); var computeManagementClient = new ComputeManagementClient(customTokenProvider) { SubscriptionId = subscriptionId, BaseUri = new Uri(_configuration["ResourceManagerUri"]), LongRunningOperationRetryTimeout = 5 }; log.LogInformation($"Creating resource group ({resourceGroupName}), if needed"); var resourceGroup = azure.ResourceGroups.Define(resourceGroupName) .WithRegion(location) .Create(); log.LogInformation($"Creating host group ({hostGroupName}), if needed"); var newDedicatedHostGroup = new DedicatedHostGroup() { Location = location, PlatformFaultDomainCount = 1 }; await computeManagementClient.DedicatedHostGroups.CreateOrUpdateAsync( resourceGroupName, hostGroupName, newDedicatedHostGroup); var taskList = new List <Task <HttpResponseMessage> >(); var inputDictionary = new Dictionary <string, StringContent>(); for (var i = 0; i < numVirtualMachines; i++) { var vmName = $"vm{i}-{new Random().Next(1, 10000)}"; log.LogInformation($"Configuring (not provisioning) VM: {vmName}"); var virtualMachine = CreateVmHelper.CreateVirtualMachine( computeManagementClient, azure, Region.Create(location), resourceGroupName, vmName, virtualMachineSize, null, "pip-" + Guid.NewGuid(), "adh-poc-vnet", "nic-" + Guid.NewGuid()); #if DEBUG var createVmUri = $"http://localhost:7071/api/CreateVm" + $"?token={token}" + $"&cloudName={_configuration["CloudName"]}" + $"&tenantId={tenantId}" + $"&subscriptionId={subscriptionId}" + $"&resourceGroup={resourceGroupName}" + $"&location={location}" + $"&vmSku={virtualMachineSize}" + $"&vmName={vmName}" + $"&dedicatedHostGroupName={hostGroupName}" + $"&platformFaultDomainCount=1"; #else var createVmUri = _configuration["DhmCreateVmnUri"] + $"&token={token}" + $"&cloudName={_configuration["CloudName"]}" + $"&tenantId={tenantId}" + $"&subscriptionId={subscriptionId}" + $"&resourceGroup={resourceGroupName}" + $"&location={location}" + $"&vmSku={virtualMachineSize}" + $"&vmName={vmName}" + $"&dedicatedHostGroupName={hostGroupName}" + $"&platformFaultDomainCount=1"; #endif var httpContent = new StringContent(JsonConvert.SerializeObject(virtualMachine), Encoding.UTF8, "application/json"); inputDictionary[createVmUri] = httpContent; } foreach (var item in inputDictionary) { taskList.Add(_httpClient.PostAsync(item.Key, item.Value)); } await Task.WhenAll(taskList); return(new OkObjectResult($"VM provisioning kicked off successfully for {numVirtualMachines} VMs - exiting.")); }
public async Task <IActionResult> TestPrepareDedicatedHostGroup( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log) { var parameters = req.GetQueryParameterDictionary(); if (!parameters.ContainsKey(ResourceGroupName) || string.IsNullOrEmpty(parameters[ResourceGroupName])) { return(new BadRequestObjectResult("Resource group name was missing in the query parameters.")); } if (!parameters.ContainsKey(HostGroupName) || string.IsNullOrEmpty(parameters[HostGroupName])) { return(new BadRequestObjectResult("Host group name was missing in the query parameters.")); } if (!parameters.ContainsKey(VmCount) || !Int32.TryParse(parameters[VmCount], out int numVirtualMachines)) { return(new BadRequestObjectResult("VmCount was missing in the query parameters.")); } if (!parameters.ContainsKey(VmSku) || string.IsNullOrEmpty(parameters[VmSku])) { return(new BadRequestObjectResult("VM SKU was missing in the query parameters.")); } var authEndpoint = _configuration["AuthEndpoint"]; var azureRmEndpoint = _configuration["AzureRmEndpoint"]; var location = _configuration["Location"]; var virtualMachineSize = parameters[VmSku]; var tenantId = _configuration["TenantId"]; var clientId = _configuration["ClientId"]; var clientSecret = _configuration["FairfaxClientSecret"]; var subscriptionId = _configuration["SubscriptionId"]; var resourceGroupName = parameters[ResourceGroupName]; var hostGroupName = parameters[HostGroupName]; log.LogInformation($"Generating auth token..."); var token = await TokenHelper.GetToken( authEndpoint, azureRmEndpoint, tenantId, clientId, clientSecret); var customTokenProvider = new AzureCredentials( new TokenCredentials(token), new TokenCredentials(token), tenantId, AzureEnvironment.FromName(_configuration["CloudName"])); var client = RestClient .Configure() .WithEnvironment(AzureEnvironment.FromName(_configuration["CloudName"])) .WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic) .WithCredentials(customTokenProvider) .Build(); var azure = Azure.Authenticate(client, tenantId).WithSubscription(subscriptionId); var computeManagementClient = new ComputeManagementClient(customTokenProvider) { SubscriptionId = subscriptionId, BaseUri = new Uri(_configuration["ResourceManagerUri"]), LongRunningOperationRetryTimeout = 5 }; log.LogInformation($"Creating resource group ({resourceGroupName}), if needed"); var resourceGroup = azure.ResourceGroups.Define(resourceGroupName) .WithRegion(location) .Create(); log.LogInformation($"Creating host group ({hostGroupName}), if needed"); var newDedicatedHostGroup = new DedicatedHostGroup() { Location = location, PlatformFaultDomainCount = 1 }; await computeManagementClient.DedicatedHostGroups.CreateOrUpdateAsync( resourceGroupName, hostGroupName, newDedicatedHostGroup); #if DEBUG var prepareDHGroup = $"http://localhost:7071/api/PrepareDedicatedHostGroup" + $"?token={token}" + $"&cloudName={_configuration["CloudName"]}" + $"&tenantId={tenantId}" + $"&subscriptionId={subscriptionId}" + $"&resourceGroup={resourceGroupName}" + $"&vmSku={virtualMachineSize}" + $"&dedicatedHostGroupName={hostGroupName}" + $"&vmCount={numVirtualMachines}" + $"&platformFaultDomain=0"; #else var prepareDHGroup = _configuration["PrepareDHGroupUri"] + $"&token={token}" + $"&cloudName={_configuration["CloudName"]}" + $"&tenantId={tenantId}" + $"&subscriptionId={subscriptionId}" + $"&resourceGroup={resourceGroupName}" + $"&vmSku={virtualMachineSize}" + $"&dedicatedHostGroupName={hostGroupName}" + $"&vmCount={numVirtualMachines}" + $"&platformFaultDomain=0"; #endif var response = await _httpClient.GetAsync(prepareDHGroup); if (response.StatusCode != HttpStatusCode.OK) { return(new ObjectResult(new { error = $"Exception thrown by {await response.Content.ReadAsStringAsync()}" }) { StatusCode = (int)response.StatusCode }); } var dhCreated = await response.Content.ReadAsAsync <List <DedicatedHost> >(); return(new OkObjectResult($"Prepared Dedicated Host Group completed successfully {string.Join(",", dhCreated.Select(c => c.Name))} VM.")); }
public async Task <IActionResult> TestDhmConcurrentVmDeletion( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log) { var parameters = req.GetQueryParameterDictionary(); if (!parameters.ContainsKey(ResourceGroupName) || string.IsNullOrEmpty(parameters[ResourceGroupName])) { return(new BadRequestObjectResult("ResourceGroupName was missing in the query parameters.")); } if (!parameters.ContainsKey(HostGroupName) || string.IsNullOrEmpty(parameters[HostGroupName])) { return(new BadRequestObjectResult("HostGroupName was missing in the query parameters.")); } if (!parameters.ContainsKey(VmName) || string.IsNullOrEmpty(parameters[VmName])) { return(new BadRequestObjectResult("VmName was missing in the query parameters.")); } var authEndpoint = _configuration["AuthEndpoint"]; var azureRmEndpoint = _configuration["AzureRmEndpoint"]; var location = _configuration["Location"]; var vmName = parameters[VmName]; var tenantId = _configuration["TenantId"]; var clientId = _configuration["ClientId"]; var clientSecret = _configuration["FairfaxClientSecret"]; var subscriptionId = _configuration["SubscriptionId"]; var resourceGroupName = parameters[ResourceGroupName]; var hostGroupName = parameters[HostGroupName]; log.LogInformation($"Generating auth token..."); var token = await TokenHelper.GetToken( authEndpoint, azureRmEndpoint, tenantId, clientId, clientSecret); var customTokenProvider = new AzureCredentials( new TokenCredentials(token), new TokenCredentials(token), tenantId, AzureEnvironment.FromName(_configuration["CloudName"])); var client = RestClient .Configure() .WithEnvironment(AzureEnvironment.FromName(_configuration["CloudName"])) .WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic) .WithCredentials(customTokenProvider) .Build(); var azure = Azure.Authenticate(client, tenantId).WithSubscription(subscriptionId); var computeManagementClient = new ComputeManagementClient(customTokenProvider) { SubscriptionId = subscriptionId, BaseUri = new Uri(_configuration["ResourceManagerUri"]), LongRunningOperationRetryTimeout = 5 }; #if DEBUG var deleteVmUri = $"http://localhost:7071/api/DeleteVm" + $"?token={token}" + $"&cloudName={_configuration["CloudName"]}" + $"&tenantId={tenantId}" + $"&subscriptionId={subscriptionId}" + $"&resourceGroup={resourceGroupName}" + $"&dedicatedHostGroupName={hostGroupName}" + $"&vmName={vmName}"; #else var deleteVmUri = _configuration["DhmDeleteVmnUri"] + $"&token={token}" + $"&cloudName={_configuration["CloudName"]}" + $"&tenantId={tenantId}" + $"&subscriptionId={subscriptionId}" + $"&resourceGroup={resourceGroupName}" + $"&dedicatedHostGroupName={hostGroupName}" + $"&vmName={vmName}"; #endif await _httpClient.GetAsync(deleteVmUri); return(new OkObjectResult($"Deleted {vmName} VM.")); }
public static async Task Main(string[] args) { var config = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddUserSecrets <DedicatedHostsManagerConsoleClient>() .Build(); var resourceGroupName = config["ResourceGroupName"]; var authEndpoint = config["AuthEndpoint"]; var azureRmEndpoint = config["AzureRmEndpoint"]; var location = config["Location"]; var virtualMachineSize = config["VirtualMachineSize"]; var numVirtualMachines = int.Parse(config["NumVirtualMachines"]); var tenantId = config["TenantId"]; var clientId = config["ClientId"]; var clientSecret = config["FairfaxClientSecret"]; var subscriptionId = config["SubscriptionId"]; var hostGroupName = config["HostGroupName"]; var token = await TokenHelper.GetToken( authEndpoint, azureRmEndpoint, tenantId, clientId, clientSecret); var customTokenProvider = new AzureCredentials( new TokenCredentials(token), new TokenCredentials(token), tenantId, AzureEnvironment.FromName(config["CloudName"])); var client = RestClient .Configure() .WithEnvironment(AzureEnvironment.FromName(config["CloudName"])) .WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic) .WithCredentials(customTokenProvider) .Build(); var azure = Azure.Authenticate(client, tenantId).WithSubscription(subscriptionId); var computeManagementClient = new ComputeManagementClient(customTokenProvider) { SubscriptionId = subscriptionId, BaseUri = new Uri(config["ResourceManagerUri"]), LongRunningOperationRetryTimeout = 5 }; var resourceGroup = azure.ResourceGroups.Define(resourceGroupName) .WithRegion(location) .Create(); var newDedicatedHostGroup = new DedicatedHostGroup() { Location = location, PlatformFaultDomainCount = 1 }; await computeManagementClient.DedicatedHostGroups.CreateOrUpdateAsync( resourceGroupName, hostGroupName, newDedicatedHostGroup); var taskList = new List <Task <HttpResponseMessage> >(); var inputDictionary = new Dictionary <string, StringContent>(); for (var i = 0; i < numVirtualMachines; i++) { var vmName = $"vm{i}-{new Random().Next(1,10000)}"; var virtualMachine = CreateVmHelper.CreateVirtualMachine( computeManagementClient, azure, Region.Create(location), resourceGroupName, vmName, virtualMachineSize, null, "pip-" + Guid.NewGuid(), "adh-poc-vnet", "nic-" + Guid.NewGuid()); #if DEBUG var createVmUri = $"http://localhost:7071/api/CreateVm" + $"?token={token}" + $"&cloudName={config["CloudName"]}" + $"&tenantId={tenantId}" + $"&subscriptionId={subscriptionId}" + $"&resourceGroup={resourceGroupName}" + $"&location={location}" + $"&vmSku={virtualMachineSize}" + $"&vmName={vmName}" + $"&dedicatedHostGroupName={hostGroupName}" + $"&platformFaultDomainCount=1"; #else var createVmUri = config["DhmCreateVmnUri"] + $"&token={token}" + $"&cloudName={config["CloudName"]}" + $"&tenantId={tenantId}" + $"&subscriptionId={subscriptionId}" + $"&resourceGroup={resourceGroupName}" + $"&location={location}" + $"&vmSku={virtualMachineSize}" + $"&vmName={vmName}" + $"&dedicatedHostGroupName={hostGroupName}" + $"&platformFaultDomainCount=1"; #endif var httpContent = new StringContent(JsonConvert.SerializeObject(virtualMachine), Encoding.UTF8, "application/json"); inputDictionary[createVmUri] = httpContent; } foreach (var item in inputDictionary) { taskList.Add(HttpClient.PostAsync(item.Key, item.Value)); } var results = await Task.WhenAll(taskList); }
public void FromNameWithNonexistingName(string name) { Assert.Null(AzureEnvironment.FromName(name)); }
public async Task <IActionResult> PrepareDedicatedHostGroup( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log, ExecutionContext context) { var parameters = req.GetQueryParameterDictionary(); if (!parameters.ContainsKey(Constants.CloudName) || string.IsNullOrEmpty(parameters[Constants.CloudName])) { return(new BadRequestObjectResult("CloudName was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.TenantId) || string.IsNullOrEmpty(parameters[Constants.TenantId])) { return(new BadRequestObjectResult("TenantId was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.Token) || string.IsNullOrEmpty(parameters[Constants.Token])) { return(new BadRequestObjectResult("Token was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.SubscriptionId) || string.IsNullOrEmpty(parameters[Constants.SubscriptionId])) { return(new BadRequestObjectResult("Subscription ID was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.ResourceGroup) || string.IsNullOrEmpty(parameters[Constants.ResourceGroup])) { return(new BadRequestObjectResult("Resource group was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.DedicatedHostGroupName) || string.IsNullOrEmpty(parameters[Constants.DedicatedHostGroupName])) { return(new BadRequestObjectResult("Dedicated host group was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.VmSku) || string.IsNullOrEmpty(parameters[Constants.VmSku])) { return(new BadRequestObjectResult("VmSku was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.VmCount) || !int.TryParse(parameters[Constants.VmCount], out int vmCount)) { return(new BadRequestObjectResult("VmCount was missing in the query parameters or not numeric value")); } int?platformFaultDomain; if (!parameters.ContainsKey(Constants.PlatformFaultDomain)) { platformFaultDomain = null; } else if (int.TryParse(parameters[Constants.PlatformFaultDomain], out int parsedFD) && parsedFD >= 0 && parsedFD <= 2) { platformFaultDomain = parsedFD; } else { return(new BadRequestObjectResult("PlatformFaultDomain if specificed must be a value between 0-2")); } var sw = Stopwatch.StartNew(); try { var requestBody = await req.ReadAsStringAsync(); var virtualMachine = JsonConvert.DeserializeObject <VirtualMachine>(requestBody); var cloudName = parameters[Constants.CloudName]; AzureEnvironment azureEnvironment = null; if (cloudName.Equals("AzureGlobalCloud", StringComparison.InvariantCultureIgnoreCase) || cloudName.Equals("AzureCloud", StringComparison.InvariantCultureIgnoreCase)) { azureEnvironment = AzureEnvironment.AzureGlobalCloud; } else { azureEnvironment = AzureEnvironment.FromName(cloudName); } var prepareDedicatedHostGroupResponse = await _dedicatedHostEngine.PrepareDedicatedHostGroup( parameters[Constants.Token], azureEnvironment, parameters[Constants.TenantId], parameters[Constants.SubscriptionId], parameters[Constants.ResourceGroup], parameters[Constants.DedicatedHostGroupName], parameters[Constants.VmSku], vmCount, platformFaultDomain); log.LogInformation( $"PrepareDedicatedHostGroup: Took {sw.Elapsed.TotalSeconds}s"); log.LogMetric("PrepareDedicatedHostGroupTimeSecondsMetric", sw.Elapsed.TotalSeconds); log.LogMetric("PrepareDedicatedHostGroupSuccessCountMetric", 1); return(new OkObjectResult(prepareDedicatedHostGroupResponse)); } catch (ArgumentException exception) { log.LogError( $"PrepareDedicatedHostGroup: Validation Error creating {parameters[Constants.DedicatedHostGroupName]}, time spent: {sw.Elapsed.TotalSeconds}s, Exception: {exception}"); log.LogMetric("PrepareDedicatedHostGroupFailureCountMetric", 1); return(new BadRequestObjectResult(exception.ToString())); } catch (Exception exception) { log.LogError( $"PrepareDedicatedHostGroup: Error creating {parameters[Constants.DedicatedHostGroupName]}, time spent: {sw.Elapsed.TotalSeconds}s, Exception: {exception}"); log.LogMetric("PrepareDedicatedHostGroupFailureCountMetric", 1); return(new ObjectResult(exception.ToString()) { StatusCode = (int)HttpStatusCode.InternalServerError }); } }
private static async System.Threading.Tasks.Task ImportImageAsync( ContainerRegistryImagePushedEventData pushEvent, AppConfiguration configuration, ILogger log) { // Create the resourceId from the target ACR resourceId string var targetACRResourceId = ResourceId.FromString(configuration.TargetACRResourceId); // Create Azure credentials to talk to target Cloud using the Active directory application var credential = new AzureCredentials( new ServicePrincipalLoginInformation { ClientId = configuration.TargetAzureServicePrincipalClientId, ClientSecret = configuration.TargetAzureServicePrincipalClientKey }, configuration.TargetAzureServicePrincipalTenantId, AzureEnvironment.FromName(configuration.TargetAzureEnvironmentName)) .WithDefaultSubscription(targetACRResourceId.SubscriptionId); var builder = RestClient .Configure() .WithEnvironment(AzureEnvironment.FromName(configuration.TargetAzureEnvironmentName)) .WithCredentials(credential) .Build(); // Create ACR management client using the Azure credentials var _registryClient = new ContainerRegistryManagementClient(builder); _registryClient.SubscriptionId = targetACRResourceId.SubscriptionId; // Initiate import of the image that is part of the push event into target ACR // Configure the pull of image from source ACR using the token var imageTag = $"{pushEvent.Target.Repository}:{pushEvent.Target.Tag}"; var importSource = new ImportSource { SourceImage = imageTag, RegistryUri = pushEvent.Request.Host, Credentials = new ImportSourceCredentials { Username = configuration.SourceACRPullTokenName, Password = configuration.SourceACRPullTokenPassword, } }; await _registryClient.Registries.ImportImageAsync( resourceGroupName : targetACRResourceId.ResourceGroupName, registryName : targetACRResourceId.Name, parameters : new ImportImageParametersInner { // Existing Tag will be overwritten with Force option, // If the desired behavior is to fail the operation instead of overwriting, use ImportMode.NoForce Mode = ImportMode.Force, Source = importSource, TargetTags = new List <string>() { imageTag } }); log.LogInformation($"Import of '{imageTag}' success to '{configuration.TargetACRResourceId}'"); }
public async Task <IActionResult> CreateVmOnDedicatedHost( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log, ExecutionContext context) { var parameters = req.GetQueryParameterDictionary(); if (!parameters.ContainsKey(Constants.CloudName) || string.IsNullOrEmpty(parameters[Constants.CloudName])) { return(new BadRequestObjectResult("CloudName was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.TenantId) || string.IsNullOrEmpty(parameters[Constants.TenantId])) { return(new BadRequestObjectResult("TenantId was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.Token) || string.IsNullOrEmpty(parameters[Constants.Token])) { return(new BadRequestObjectResult("Token was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.SubscriptionId) || string.IsNullOrEmpty(parameters[Constants.SubscriptionId])) { return(new BadRequestObjectResult("Subscription ID was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.ResourceGroup) || string.IsNullOrEmpty(parameters[Constants.ResourceGroup])) { return(new BadRequestObjectResult("Resource group was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.DedicatedHostGroupName) || string.IsNullOrEmpty(parameters[Constants.DedicatedHostGroupName])) { return(new BadRequestObjectResult("Dedicated host group was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.Location) || string.IsNullOrEmpty(parameters[Constants.Location])) { return(new BadRequestObjectResult("Location was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.VmSku) || string.IsNullOrEmpty(parameters[Constants.VmSku])) { return(new BadRequestObjectResult("VmSku was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.VmName) || string.IsNullOrEmpty(parameters[Constants.VmName])) { return(new BadRequestObjectResult("VmName was missing in the query parameters.")); } if (!parameters.ContainsKey(Constants.PlatformFaultDomainCount) || string.IsNullOrEmpty(parameters[Constants.PlatformFaultDomainCount]) || !int.TryParse(parameters[Constants.PlatformFaultDomainCount], out var platformFaultDomainCount)) { return(new BadRequestObjectResult("PlatformFaultDomainCount was missing in the query parameters.")); } var sw = Stopwatch.StartNew(); try { var requestBody = await req.ReadAsStringAsync(); var virtualMachine = JsonConvert.DeserializeObject <VirtualMachine>(requestBody); var cloudName = parameters[Constants.CloudName]; AzureEnvironment azureEnvironment = null; if (cloudName.Equals("AzureGlobalCloud", StringComparison.InvariantCultureIgnoreCase) || cloudName.Equals("AzureCloud", StringComparison.InvariantCultureIgnoreCase)) { azureEnvironment = AzureEnvironment.AzureGlobalCloud; } else { azureEnvironment = AzureEnvironment.FromName(cloudName); } var createVmResponse = await _dedicatedHostEngine.CreateVmOnDedicatedHost( parameters[Constants.Token], azureEnvironment, parameters[Constants.TenantId], parameters[Constants.SubscriptionId], parameters[Constants.ResourceGroup], parameters[Constants.DedicatedHostGroupName], parameters[Constants.VmSku], parameters[Constants.VmName], Region.Create(parameters[Constants.Location]), virtualMachine); log.LogInformation( $"CreateVm: Took {sw.Elapsed.TotalSeconds}s to create {parameters[Constants.VmName]}"); log.LogMetric("VmCreationTimeSecondsMetric", sw.Elapsed.TotalSeconds); log.LogMetric("VmCreationSuccessCountMetric", 1); return(new OkObjectResult(createVmResponse)); } catch (Exception exception) { log.LogError( $"CreateVm: Error creating {parameters[Constants.VmName]}, time spent: {sw.Elapsed.TotalSeconds}s, Exception: {exception}"); log.LogMetric("VmCreationFailureCountMetric", 1); return(new BadRequestObjectResult(exception.ToString())); } }