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()));
}
}
