Skapa http-utlöst Azure Funktion i ASP.NET Core

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 namespace

Funktion

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 namespace

Hå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 namespace

Publicera 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.

Lämna ett svar

E-postadressen publiceras inte. Obligatoriska fält är märkta *