After following the above article and making the required changes the warning should be gone.

Configure App Configuration

Normally as per my understanding Azure function doesn’t comes up with by default integration with AppConfiguration. As App Configuration help us centralize storage and management of all your application settings separate from your code which is indeed needed in Enterprise level of application. We are gonna use AppSettings in order to centralize our management of application settings and some of them we will keep in key vault.

We will be using Azure App Configuration in order to maintain all our App configuration in appsettings.json files have our configs based on env i.e. (Dev, Test, Prod)

Install Microsoft.Azure.Functions.Extensions version 1.1.0

Add a new Startup.cs and file with the following code:

using Microsoft.Azure.Functions.Extensions.DependencyInjection;
using Microsoft.Extensions.Configuration;
using System;
using System.IO;
using TimerTrigger.StartupExtensions;

[assembly: FunctionsStartup(typeof(TimerTrigger.Startup))]

namespace TimerTrigger
{
    class Startup : FunctionsStartup
    {
        public IConfigurationRoot _configurationRoot; 


        public override void ConfigureAppConfiguration(IFunctionsConfigurationBuilder builder)
        {
            FunctionsHostBuilderContext context = builder.GetContext();
            string environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
            _configurationRoot = builder.ConfigurationBuilder
                                    .AddJsonFile(Path.Combine(context.ApplicationRootPath, "appsettings.json"), optional: true, reloadOnChange: false)
                                    .AddJsonFile(Path.Combine(context.ApplicationRootPath, $"appsettings.{environment}.json"), optional: true, reloadOnChange: false)
                                    .AddEnvironmentVariables()
                                    .Build();


        }



        public override void Configure(IFunctionsHostBuilder builder)
        {
            
        }
    }
}

Add one new file launchSettings.json inside Properties folder and add the following content on it.

{
  "profiles": {
    "TimerTrigger": {
      "commandName": "Project",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

Run the application just to check whether the timer trigger function is getting triggered or not?

💡 Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"); _configurationRoot = builder.ConfigurationBuilder

You might confused around why I am using Environment Variable named ASPNETCORE_ENVIRONMENT. If you are using ASP.NET Core and deploying the web app to different environment, you would be aware that we keep all the configuration in appSettings file with env name as Development, Test, PreProduction and Production. It might differ as per different teams. 🙂

So In order to have the same deployment strategy, I am using this Environment Variable which you can change as per your requirement. For this demo I will only maintain two env Dev and Test env to demonstrate e2e CI/CD with Azure function.

We will adding ASPNETCORE_ENVIRONMENT in azure function configuration when we will deploy the Azure Function.

This is how it will look:

💡 Best Practice
As a best practice the timer schedule should not be hardcoded and should come from configuration or key vault.

For this function app I am gonna create one key in local.settings.json and add one key and value as shown below:

{
    "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "dotnet",
    "Schedule": "0 */5 * * * *"
  }
}

You can see my Schedule for the Azure Function is every 5 mins.

This is how my Function code looks like:

using CronExpressionDescriptor;
using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;
using System;

namespace TimerTrigger
{
    public static class Function1
    {
        [FunctionName("Function1")]
        public static void Run([TimerTrigger("%Schedule%")]TimerInfo myTimer, ILogger log)
        {

            log.LogInformation(ExpressionDescriptor.GetDescription("0 */5 * * * *"));
            log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
        }
    }
}

Integrating with Azure Application Insight

Every application that is running on cloud requires a good monitoring and tracing. Azure Application Insight help us to achieve that. I am not gonna go deep on Application Insight as that is out of scope of this article.

In order to integrate the Application Insight with Azure function I will go my devApplication insight instance and copy the APPINSIGHTS_INSTRUMENTATIONKEY as shown below:

Add appsettings.Develoment and appsettings.json for now and enable copy to output Directory as Copy if newer.

We will be using appsettings.json for the configuration where keys and values will be same in all the environments.

Copy paste your Instrumentation key

{
  "APPINSIGHTS_INSTRUMENTATIONKEY": "Instrumentation Key Value",
  "KeyVaultName": "devkeyvaultfunc"
}

Install ApplicationInsights dependency from nuget

💡 Dependencies
      Microsoft.Azure.WebJobs.Logging.ApplicationInsights v 3.0.18
      Microsoft.Extensions.Logging.AzureAppServices v 3.1.3

Create one folder in solution with name StartupExtensions and add class file with name StartupExtensions.

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace TimerTrigger.StartupExtensions
{
    public static class StartupExtensions
    {
      public  static void AddApplicationInsightLogging(this IServiceCollection services, IConfiguration configuration)
        {
            services.AddLogging(logging =>
            {
                string instrumentationKey = configuration["APPINSIGHTS_INSTRUMENTATIONKEY"];
                if (!string.IsNullOrEmpty(instrumentationKey))
                {
                    logging.AddApplicationInsights(instrumentationKey).SetMinimumLevel(LogLevel.Information);
                    logging.AddApplicationInsightsWebJobs(o => o.InstrumentationKey = instrumentationKey);
                }

                logging.AddAzureWebAppDiagnostics();
            });
        }
    }
}

As you can see we are retrieving the APPINSIGHTS_INSTRUMENTATIONKEY from configuration and setting up the minimum level as Information. So that we can track down the logs and create a tree of dependency in Application Insight.

Run the Function app to check whether we are able to see any logs in application insights or not?
Inject ILogger in your function class and you Function class should look like this now:

using CronExpressionDescriptor;
using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;
using System;
using System.Threading.Tasks;

namespace TimerTrigger
{
    public class Function1
    {
        private readonly ILogger<Function1> _logger;
        /// <summary>
        /// 
        /// </summary>
        /// <param name="logger"></param>
        public Function1(ILogger<Function1> logger)
        {
            _logger = logger ?? throw new Exception(nameof(logger));
        }

        [FunctionName("Function1")]
        public async Task Run([TimerTrigger("%Schedule%")]TimerInfo myTimer)
        {

            _logger.LogInformation(ExpressionDescriptor.GetDescription("0 */5 * * * *"));
            _logger.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
        }
    }
}

Integrating Dependency Injection in C#

We need to inject our Function as a dependency now. In order to enable DI in Azure function install which is compatible with Azure function

💡 Microsoft.Extensions.DependencyInjection V 3.1.8

Inject the dependency in Startup class.

using Microsoft.Azure.Functions.Extensions.DependencyInjection;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.IO;
using TimerTrigger.StartupExtensions;

[assembly: FunctionsStartup(typeof(TimerTrigger.Startup))]

namespace TimerTrigger
{
    class Startup : FunctionsStartup
    {
        public IConfigurationRoot _configurationRoot; 

        public override void ConfigureAppConfiguration(IFunctionsConfigurationBuilder builder)
        {
            FunctionsHostBuilderContext context = builder.GetContext();
            string environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");

            _configurationRoot = builder.ConfigurationBuilder
                                    .AddJsonFile(Path.Combine(context.ApplicationRootPath, "appsettings.json"), optional: true, reloadOnChange: false)
                                    .AddJsonFile(Path.Combine(context.ApplicationRootPath, $"appsettings.{environment}.json"), optional: true, reloadOnChange: false)
                                    .AddEnvironmentVariables()
                                    .Build();
        }

        public override void Configure(IFunctionsHostBuilder builder)
        {
            builder.Services.AddScoped<Function1>();
            builder.Services.AddApplicationInsightLogging(_configurationRoot);
        }
    }
}

Run your Function App:

Code snippet to access Key Vault secret

using CronExpressionDescriptor;
using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using System;
using System.Threading.Tasks;

namespace TimerTrigger
{
    public class Function1
    {

        private readonly ILogger<Function1> _logger;
        private readonly IConfiguration _configuartion;


        /// <summary>
        /// 
        /// </summary>
        /// <param name="logger"></param>
        public Function1(ILogger<Function1> logger, IConfiguration configuartion)
        {
            _logger = logger ?? throw new Exception(nameof(logger));
            _configuartion = configuartion ?? throw new Exception(nameof(logger));
        }

        [FunctionName("Function1")]
        public async Task Run([TimerTrigger("%Schedule%")]TimerInfo myTimer)
        {

            _logger.LogInformation(ExpressionDescriptor.GetDescription("0 */5 * * * *"));
            _logger.LogInformation($"Key vault value for secret secret-func-name is {_configuartion["secret-func-name"]}");
            _logger.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
        }
    }
}

If you want to learn Azure from start, my suggestion will be to watch this Learn Azure Step by Step video.

I hope you enjoyed the article as I did writing this up. It’s so cool to know Function Filters and how they help us share common logic across Azure Functions.
If you did, leave your thoughts in the comments below.
Also, I will love it if you share the article on your preferred social media.