I'm able to successfully run a .NET 5 Console Application with a BackgroundService in an Azure Kubernetes cluster on Ubuntu 18.04. In fact, the BackgroundService is all that really runs: just grabs messages from a queue, executes some actions, then terminates when Kubernetes tells it to stop, or the occasional exception.

It's this last scenario which is giving me problems. When the BackgroundService hits an unrecoverable exception, I'd like the container to stop (complete, or whatever state will cause Kubernetes to either restart or destroy/recreate the container).

Unfortunately, any time an exception is encountered, the BackgroundService appears to hit the StopAsync() function (from what I can see in the logs and console output), but the container stays in a running state and never restarts. My Main() is as appears below:

        public static async Task Main(string[] args)
        {
            // Build service host and execute.
            var host = CreateHostBuilder(args)
                .UseConsoleLifetime()
                .Build();

            // Attach application event handlers.
            AppDomain.CurrentDomain.ProcessExit += OnProcessExit;
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(OnUnhandledException);

            try
            {
                Console.WriteLine("Beginning WebSec.Scanner.");
                await host.StartAsync();
                await host.WaitForShutdownAsync();
                Console.WriteLine("WebSec.Scanner has completed.");
            }
            finally
            {
                Console.WriteLine("Cleaning up...");

                // Ensure host is properly disposed.
                if (host is IAsyncDisposable ad)
                {
                    await ad.DisposeAsync();
                }
                else if (host is IDisposable d)
                {
                    d.Dispose();
                }
            }
        }

If relevant, those event handlers for ProcessExit and UnhandledException exist to flush the AppInsights telemetry channel (maybe that's blocking it?):

        private static void OnProcessExit(object sender, EventArgs e)
        {
            // Ensure AppInsights logs are submitted upstream.
            Console.WriteLine("Flushing logs to AppInsights");
            TelemetryChannel.Flush();
        }

        private static void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            var thrownException = (Exception)e.ExceptionObject;
            Console.WriteLine("Unhandled exception thrown: {0}", thrownException.Message);

            // Ensure AppInsights logs are submitted upstream.
            Console.WriteLine("Flushing logs to AppInsights");
            TelemetryChannel.Flush();
        }

I am only overriding ExecuteAsync() in the BackgroundService:

        protected async override Task ExecuteAsync(CancellationToken stoppingToken)
        {
            this.logger.LogInformation(
                "Service started.");

            try
            {
                // Loop until the service is terminated.
                while (!stoppingToken.IsCancellationRequested)
                {
                    // Do some work...
                }
            }
            catch (Exception ex)
            {
                this.logger.LogWarning(
                    ex,
                    "Terminating due to exception.");
            }

            this.logger.LogInformation(
                "Service ending.",
        }

My Dockerfile is simple and has this line to run the service:

ENTRYPOINT ["dotnet", "MyService.dll"]

Am I missing something obvious? I feel like there's something about running this as a Linux container that I'm forgetting in order to make this run properly.

Thank you!