You have the following options:

1. IHostedService classes can be long running methods that run in the background for the lifetime of your app. In order to make them to handle some sort of background task, you need to implement some sort of “global” queue system in your app for the controllers to store the data/events. This queue system can be as simple as a Singleton class with a ConcurrentQueue that you pass in to your controller, or something like an IDistributedCache or more complex external pub/sub systems. Then you can just poll the queue in your IHostedService and run certain operations based on it. Here is a microsoft example of IHostedService implementation for handling queues https://learn.microsoft.com/en-us/aspnet/core/fundamentals/host/hosted-services?view=aspnetcore-3.1&tabs=visual-studio#queued-background-tasks
   Note that the Singleton class approach can cause issues in multi-server environments.
   Example implementation of the Singleton approach can be like:

// Needs to be registered as a Singleton in your Startup.cs
public class BackgroundJobs
{
    public ConcurrentQueue<string> BackgroundTasks { get; set; } = new ConcurrentQueue<string>();
}

public class MyController : ControllerBase
{
    private readonly BackgroundJobs _backgroundJobs;
    public MyController(BackgroundJobs backgroundJobs)
    {
        _backgroundJobs = backgroundJobs;
    }

    public async Task<ActionResult> FireAndForgetEndPoint()
    {
        _backgroundJobs.BackgroundTasks.Enqueue("SomeJobIdentifier");
    }
}

public class MyBackgroundService : IHostedService
{
    private readonly BackgroundJobs _backgroundJobs;
    public MyBackgroundService(BackgroundJobs backgroundJobs)
    {
        _backgroundJobs = backgroundJobs;
    }

    public void StartAsync(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            if (_backgroundJobs.BackgroundTasks.TryDequeue(out var jobId))
            {
                // Code to do long running operation
            }
            Task.Delay(TimeSpan.FromSeconds(1)); // You really don't want an infinite loop here without having any sort of delays.
        }
    }
}

2. Create a method that returns a Task, pass in a IServiceProvider to that method and create a new Scope in there to make sure ASP.NET would not kill the task when the controller Action completes. Something like

IServiceProvider _serviceProvider;

public async Task<ActionResult> FireAndForgetEndPoint()
{
  // Do stuff
  _ = FireAndForgetOperation(_serviceProvider);
  Return Ok();
}

public async Task FireAndForgetOperation(IServiceProvider serviceProvider)
{
  using (var scope = _serviceProvider.CreateScope()){
    await Task.Delay(1000);
    //... Long running tasks
  }
}

Update: Here is the Microsoft example of doing something similar: https://learn.microsoft.com/en-us/aspnet/core/performance/performance-best-practices?view=aspnetcore-3.1#do-not-capture-services-injected-into-the-controllers-on-background-threads

As I understand from your question you want to create a fire and forget task like logging to database. In this scenario you don’t have to wait for log to be inserted database. It also took much of my time to discover an easily implementable solution. Here is what I have found:

In your controller parameters, add IServiceScopeFactory. This will not effect the request body or header. After that create a scope and call your service over it.

[HttpPost]
public IActionResult MoveRecordingToStorage([FromBody] StreamingRequestModel req, [FromServices] IServiceScopeFactory serviceScopeFactory)
{
    // Move record to Azure storage in the background
    Task.Run(async () => 
    {
        try
        {
            using var scope = serviceScopeFactory.CreateScope();
            var repository = scope.ServiceProvider.GetRequiredService<ICloudStorage>();
            await repository.UploadFileToAzure(req.RecordedPath, key, req.Id, req.RecordCode);
        }
        catch(Exception e)
        {
            Console.WriteLine(e);
        }
    });
    return Ok("In progress..");
}

After posting your request, you will immediately receive In Progress.. text but your task will run in the background.

One more thing, If you don’t create your task in this way and try to call database operations you will receive an error like this which means your database object is already dead and you are trying to access it;

Cannot access a disposed object. A common cause of this error is disposing a context that was resolved from dependency injection and then later trying to use the same context instance elsewhere in your application. This may occur if you are calling Dispose() on the context, or wrapping the context in a using statement. If you are using dependency injection, you should let the dependency injection container take care of disposing context instances.rnObject name: ‘DBContext’.

My code is based on Repository pattern. You should not forget to inject service class in your Startup.cs

services.AddScoped<ICloudStorage, AzureCloudStorage>();

Find the detailed documentation here.

What is the simplest way to run a single background task from a controller in .NET Core?

I don’t want the consumers of the service to have to wait for this job to finish.

Ultimately, everything I have seen has been a huge, convoluted mess of code for something that seems like it should be such a simple thing to do. What am I missing?

The problem is that ASP.NET is a framework for writing web services, which are applications that respond to requests. But as soon as your code says “I don’t want the consumers of the service to have to wait”, then you’re talking about running code outside of a request (i.e., request-extrinsic code). This is why all solutions are complex: your code has to bypass/extend the framework itself in an attempt to force it to do something it wasn’t designed to do.

The only proper solution for request-extrinsic code is to have a durable queue with a separate background process. Anything in-process (e.g., ConcurrentQueue with an IHostedService) will have reliability problems; in particular, those solutions will occasionally lose work.

For the long-running background tasks i.e., “Fire and Forget” jobs, .NET Own’s IHostedServices can be used, but there is another useful third-party tool that is very easy to configure called Hangfire.
All you need is a little configuration and you are good to go.