How to graceful shutdown web app when it exceeds start time limit in Azure App Service?

In Azure App Service I have a ASP.NET Core web app that can need to do a long running initialization before it starts receiving requests. The initialization can take more time than set in WEBSITES_CONTAINER_START_TIME_LIMIT. When it happens AAS kills the app.

I want AAS try to gracefully stop the app via sending SIGTERM signal.

I've extracted all long running initialization to an implementation of IHostedService and use CancellationTokens. I tested it on a local machine via sending SIGTERM while this initialization was running and it gracefully shutdowned, but AAS stills kill the app.

It looks like AAS doesn't try to SIGTERM the app and just sends SIGKILL.

>Azure App Service does not send a SIGTERM signal to gracefully shut down a web app when it exceeds the start time limit. It terminates the process by sending a SIGKILL signal.

In Azure, by changing the App configuration it can be done.

You can implement a workaround to handle graceful shutdowns when the start time limit is exceeded.

Update the Program.cs file in your ASP.NET Core web app project.
Create a static variable to track whether the application is shutting down gracefully.

public static class Program
{
    public static bool IsShuttingDown { get; private set; }

    public static void Main(string[] args)
    {
        
    }
}

Modify the Main method to SetUp a SIGTERM handler.

public static void Main(string[] args)
{
      AppDomain.CurrentDomain.ProcessExit += (sender, eventArgs) =>
    {
        Program.IsShuttingDown = true;
    };

}

Check the IsShuttingDown flag to perform a graceful shutdown in IHostedService.

public class LongRunningInitializationService : IHostedService
{
    private readonly ILogger<LongRunningInitializationService> _logger;
    private readonly CancellationTokenSource _cancellationTokenSource;

    public LongRunningInitializationService(ILogger<LongRunningInitializationService> logger)
    {
        _logger = logger;
        _cancellationTokenSource = new CancellationTokenSource();
    }

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _cancellationTokenSource.Token to check for cancellation requests
        Task.Run(() => DoInitialization(), _cancellationTokenSource.Token);
        return Task.CompletedTask;
    }

    private async Task DoInitialization()
    {
        try
        {
            while (!Program.IsShuttingDown)
            {
                await Task.Delay(1000);
                _cancellationTokenSource.Token.ThrowIfCancellationRequested();
            }

           _logger.LogInformation("Initialization completed.");
        }
        catch (OperationCanceledException)
        {
          _logger.LogWarning("Initialization canceled.");
        }
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        _cancellationTokenSource.Cancel();
        return Task.CompletedTask;
    }
}

If the Azure App Service exceeds the start time limit then it sends a SIGKILL signal to terminate the process.

And the SIGTERM handler in the Main method will set the IsShuttingDown flag, allowing the LongRunningInitializationService to perform a graceful shutdown by cancelling the initialization process.

>Azure App Service has a timeout mechanism, and if the shutdown process takes longer than the timeout period, it still result in a forced termination.

For more information, refer to MS Doc.