Azure Functions körs i en serverlös miljö och skalas automatiskt om de ingår i en konsumtionsplan (värdplan). En konsumtionsplan innebär att resurser allokeras när de behövs och att du bara betalar för resurser när dina funktioner körs.
Azure Functions är mikrotjänster, oberoende mikrotjänster är ett utmärkt sätt att skala din webbplats och att förbättra modulariteten i ditt projekt. En http-utlöst Azure funktion körs när någon anropar webbadressen, du kan anropa en funktion från din kod, från en Azure Logic App eller från Postman till exempel.
Azure funktioner är offentligt tillgängliga (AuthorizationLevel.Anonymous) som standard, du kan begränsa åtkomsten till en funktion genom att välja en annan behörighetsnivå. Sätt auktoriseringsnivån till Function (AuthorizationLevel.Function) för att kräva en funktionsnyckel som en kodparameter i varje begäran. Du kan skapa funktionsnycklar i Azure Portal för varje funktion.
Projektmallar och NuGet-paket
Installera Azure Functions and Web Jobs Tools under Tools/Extensions and Updates i Visual Studio för att få mallar och verktyg för Azure Functions. Skapa ett nytt projekt och använd Azure Functions som mall. Du måste också installera Microsoft.NET.Sdk.Functions och Microsoft.Azure.Functions.Extensions för att kunna använda beroendeinjektion (DI) i projektet.
Inställningar
Ditt projekt har en host.json-fil och en local.settings.json-fil. Du behöver alltid en anslutningssträng till ett lagringskonto för AzureWebJobsStorage i dina programinställningar. Innehållet i filen host.json visas nedan, funktionstiden är inställd på 10 minuter. En vanlig azurefunktion kan inte köras längre än 10 minuter, skapa en hållbar funktion (Durable Function) om du har tidskrävande uppgifter.
{
"version": "2.0",
"functionTimeout": "00:10:00",
"logging": {
"logLevel": {
"default": "Information"
}
}
}Startup
Vårt Startup-klass används för att registrera inställningar och arkivklasser så att vi kan använda beroendeinjektion (DI) i vårt projekt.
using System;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Azure.Functions.Extensions.DependencyInjection;
[assembly: FunctionsStartup(typeof(Fotbollstabeller.Functions.Startup))]
namespace Fotbollstabeller.Functions
{
public class Startup : FunctionsStartup
{
public override void Configure(IFunctionsHostBuilder builder)
{
// Create options
builder.Services.Configure<DatabaseOptions>(options =>
{
options.connection_string = Environment.GetEnvironmentVariable("SqlConnectionString");
options.sql_retry_count = 3;
});
// Add repositories
builder.Services.AddSingleton<IDatabaseRepository, MsSqlRepository>();
builder.Services.AddSingleton<IGroupRepository, GroupRepository>();
builder.Services.AddSingleton<IFinalRepository, FinalRepository>();
builder.Services.AddSingleton<IXslTemplateRepository, XslTemplateRepository>();
builder.Services.AddSingleton<IXslProcessorRepository, XslProcessorRepository>();
} // End of the Configure method
} // End of the class
} // End of the namespaceFunktion
Denna klass innehåller endast en funktion, du kan lägga till flera funktioner i en klass. Du behöver en funktionsnyckel för att anropa denna funktion i produktion, url:en ser ut på följande vis: https://myfunction.com/api/updategroupsandfinals?Code=XXXXXXXXXXX. Ingen funktionsnyckel behövs under utveckling.
using System;
using System.IO;
using Microsoft.Extensions.Logging;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Http;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
namespace Fotbollstabeller.Functions
{
public class UpdateGroupsAndFinals
{
#region Variables
private readonly ILogger logger;
private readonly IXslProcessorRepository xsl_processor;
#endregion
#region Constructors
public UpdateGroupsAndFinals(ILogger<UpdateGroupsAndFinals> logger, IXslProcessorRepository xsl_processor)
{
// Set values for instance variables
this.logger = logger;
this.xsl_processor = xsl_processor;
} // End of the constructor
#endregion
#region Function
[FunctionName("UpdateGroupsAndFinals")]
public IActionResult Update([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest request)
{
// Log the start of the function
this.logger.LogInformation($"Application started at: {DateTime.UtcNow}");
// Get header values
string header = request.Headers["Host"];
// Get query paramter
string query = request.Query["Key1"];
// Get form value
string form_value = request.Form["FormKey1"];
// Get the entire body
string body = "";
using (StreamReader reader = new StreamReader(request.Body))
{
body = reader.ReadToEnd();
}
// Do the work
this.xsl_processor.UpdateGroups();
this.xsl_processor.UpdateFinals();
// Log the end of the function
this.logger.LogInformation($"Application ended at: {DateTime.UtcNow}");
return new OkObjectResult("Done");
} // End of the run method
#endregion
} // End of the class
} // End of the namespaceHållbar funktion
Du behöver en hållbar funktion om du har en tidskrävande uppgift. För att lägga till en hållbar funktion: Högerklicka på din projektfil i Visual Studio, välj Add/New Azure Function… och välj mallen Durable Functions Orchestration. Url:en till metoden kommer att se ut på följande sätt: https://myfunction.com/api/DurableFunction_HttpStart.
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Extensions.Logging;
namespace Fotbollstabeller.Functions
{
public class DurableFunction
{
#region Variables
private readonly ILogger logger;
private readonly IXslProcessorRepository xsl_processor;
#endregion
#region Constructors
public DurableFunction(ILogger<DurableFunction> logger, IXslProcessorRepository xsl_processor)
{
// Set values for instance variables
this.logger = logger;
this.xsl_processor = xsl_processor;
} // End of the constructor
#endregion
#region Functions
[FunctionName("DurableFunction")]
public async Task<List<string>> RunOrchestrator([OrchestrationTrigger] DurableOrchestrationContext context)
{
// Create a list with outputs
List<string> outputs = new List<string>();
// Log the start of the function
this.logger.LogInformation($"Application started at: {DateTime.UtcNow}");
// Call activities
outputs.Add(await context.CallActivityAsync<string>("DurableFunction_Update", "Groups"));
outputs.Add(await context.CallActivityAsync<string>("DurableFunction_Update", "Finals"));
// Log the end of the function
this.logger.LogInformation($"Application ended at: {DateTime.UtcNow}");
// Return a list
return outputs;
} // End of the RunOrchestrator method
[FunctionName("DurableFunction_Update")]
public string Update([ActivityTrigger] string name)
{
// Do the work
if(name == "Groups")
{
this.xsl_processor.UpdateGroups();
}
else if (name == "Finals")
{
this.xsl_processor.UpdateFinals();
}
return $"Done {name}";
} // End of the Update method
[FunctionName("DurableFunction_HttpStart")]
public async Task<HttpResponseMessage> HttpStart([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")]HttpRequestMessage req,
[OrchestrationClient]DurableOrchestrationClient starter)
{
// Function input comes from the request content.
string instanceId = await starter.StartNewAsync("DurableFunction", null);
this.logger.LogInformation($"Started orchestration with ID = '{instanceId}'.");
return starter.CreateCheckStatusResponse(req, instanceId);
}
#endregion
} // End of the class
} // End of the namespacePublicera applikationen
Högerklicka på din projektfil och klicka på Publish… för att skapa Azure-resurser och en mall för att publicera din applikation. Skapa eller välj en befintlig värdplan för din applikation, du kan ha många applikationer i samma värdplan. Välj en konsumtionsplan om du vill ha automatisk skalning.