Back to "Usługи в ASP.NET Core - Part 1: Дослідження"

This is a viewer only at the moment see the article on how this works.

To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk

This is a preview from the server running through my markdig pipeline

ASP.NET Core BackgroundService Hangfire IHostedService

Usługи в ASP.NET Core - Part 1: Дослідження

Thursday, 27 November 2025

Кожна сучасна веб-аplikaція має роботу, яка повинна:' не блокувати HTTP-запросу — відправляти електронні листи M SK2 обробляти файли МSK3 синхронізувати з зовнішними службами IHostedService implements to sophisticated frameworks like Hangfire. В цій першій частині ми , дослідимо фундаментальні шаблони і коли використовувати кожен з них

Введение

Confession; Мені подобаються Background Services a LOTM SK1 цей сайт (a BLOG site МSK3 має більше половини M SK4 дюжину з них займаються серйозними фоновими завданнями , але, як і все, у них є певні ODDITIES та практики, які зрозуміють вам їх набагато приємніше використовувати Бюро背景ів - невідомі герої сучасних веб-пристосувань. Podczas, як ваші контролери виконують HTTP-запити на передньому плані , Бюro背景ів спокійно обробляє загасовані електронні листи МSK2 індикаторний контент для пошуку MSC3 перевіряє зовнішні API M SK4 прибирає тимчасові файли , і виконує безліч інших завдань, які інакше заблокували б pipeline ваших запитів MRK6

В цих двох серіях, МСК0, МSK1 і МСК2, ми дослідимо різні підходи до введення базових послуг у ASP, ., NET Core та , збудованих IHostedService і BackgroundService абстракції до більш складних рішень, як-от Hangfire. У частині M SK1 ми ' проаналізуємо фундаментальні підходи та їхні характеристики. В Частина 2, ми ' зануримося у реальні МSK2 інтерфейси світу з кодової бази виробництва

Важливо: Ми звернемо особливу увагу на управління життєвим циклом, зокрема, часто занедбаних StopAsync метод,, де багато розробників стикаються з криптичними винятками, коли їх застосування закриваються

Навіщо базові послуги?

Перед тим, як зануритися в " як МSK1 дозволити МSK2s коротко подумайте про " чому \ ." \ Навігаційні послуги дозволять вам

  1. Повільні операції відряду - Не змушуйте користувачів чекати, поки ви надсилаєте електронні листи чи генеруєте PDF
  2. Запланувати повторювані завдання - Зачистка старих записів щовечора в МSK1
  3. Кої processу - Передавати повідомлення від каналів або брокерів
  4. Бачити зовнішній стан - API для опитування або файлові системи для спостереження за змінами
  5. Координувати складні робочі потоки - Управляйте багатьма proceduraми, що тривають хвилини або години

ASP.NET Core надає кілька підходів для втілення цих послуг

Історічний контекст: Чому тепер дають доступ до базових послуг

У давні часи running background work в веб-приложениї зазвичай вважався поганою ідеєю.

Це не просто вантаж - це була чудернацька мудрість - це було засновано на реальних технічних обмеженнях

Епоха Кора

Ранні веб-сервери ( і, чесно кажучи, зараз МSK1 МSK2 дешеві ' А Azure-сервіси pojedyncze-core або подвійні-core процесори. Якщо ви запустили CPU- інтенсивний фоновий задачіM SK2 він безпосередньо конкурував з веб-запитими для того ж ядра :

Single Core (2005):
┌─────────────────────┐
│  Background Task    │  ← Uses 80% CPU
│  (80% of core)      │
├─────────────────────┤
│  Web Requests       │  ← Only 20% left!
│  (20% of core)      │  ← Slow responses
└─────────────────────┘

Результат: Ваша веб-сторінка стала повільнею, коли запустили роботу на фоніM SK1

Стридж-pool голодування

Класичний ASP.NET thread-per-request. Коллекция потоків була відносно маленькою

// Classic ASP.NET (2008)
ThreadPool.QueueUserWorkItem(_ =>
{
    // This steals a thread from the pool!
    ProcessLongRunningTask();
});

// Meanwhile, web requests are queued waiting for threads
// HTTP 503 Service Unavailable

Переробка Pool Application IIS

IIS агрессивно перероблятиме додатки. (заново запустити вашу програму) на основі обмежень пам 'ятіM SK2 підрахунки запитів , або वेळापत ’ रकMSC4 оперативна робота буде знищена всередині

00:00 - Background import starts (2 hour task)
02:00 - IIS recycles app pool (scheduled)
      - Background task killed
      - Work lost, must start again

Ограничений Async/Отримаємо підтримку

До того, як .NET 4.5 МSK2 асинхове програмування було МSK3 відносно M) боляче МСК5 Задачи на фоні часто непотрібно блокували потоки МК6

// Pre-async (2008)
void ProcessEmails()
{
    foreach (var email in GetEmails())
    {
        smtp.Send(email);  // Blocks thread for 500ms per email
    }
}
// 100 emails = 50 seconds of blocked thread time

Що змінило епоху сучасності?

На сьогодні

1. МультиM SK1 Кора доступна

Економіка змінилася. ХлобаловіVM з багатьма ядрами reasonably priced , and bare metal servers are surprisingly cheapM SK2 This blog runs on a dedicated 8- core server that costs less than a comparable Azure VMMSC4and I get all those cores to myselfMska5 no noisy neighboursM Ska6 A background task on one core doesn’ t significantly impact web requests on other coreMSKA8

8-Core Server (2024):
Core 1: ████████████████████ Web Requests
Core 2: ████████████████████ Web Requests
Core 3: ████████████████████ Web Requests
Core 4: ████████████████████ Web Requests
Core 5: ████████████████████ Background Task ← Isolated
Core 6: ████████████████████ Background Task
Core 7: ████████████████████ Background Task
Core 8: ████████████████████ Background Task

2. Асинк / Будь-де чекати

.NET робить асинк-програмування банальним . Задачі на фоні можуть чекати на I/O без блокування потоківM SK3

// Modern async (2024)
async Task ProcessEmailsAsync(CancellationToken ct)
{
    await foreach (var email in GetEmailsAsync(ct))
    {
        await smtp.SendAsync(email, ct);  // Doesn't block thread!
    }
}
// 100 emails processed efficiently, thread returns to pool during I/O

3. Кращий процес хостингу

  • Докер - Посередні послуги у контейнерах не переробляються
  • Кубернеті - Правильний гнучкий підключення з SIGTERM
  • систематично - Linux-сервіси, які можуть відпочати роботу надійно
  • Услуги Windows - Правильний довгий МSK1модель процесу

4. Канали та сучасні примітиви

.NET тепер має першу підтримку klasy - для синхронного програмування з System.Threading.Channels:

// System.Threading.Channels
var channel = Channel.CreateBounded<Email>(100);

// Producer (web request)
await channel.Writer.WriteAsync(email);  // Fast, non-blocking

// Consumer (background service)
await foreach (var email in channel.Reader.ReadAllAsync())
{
    await ProcessAsync(email);  // Efficient, async
}

5. Ограничення ресурсів та класи

Сучасні оркеструвальники контейнерів дозволяють вам обмеження використання ресурсів:

# Kubernetes resource limits
resources:
  limits:
    cpu: "500m"        # Background task can't use more than 0.5 CPU
    memory: "512Mi"    # Or more than 512 MB RAM

Це означає, що завдання на фоні може не голодувати вашого веб-ґатунку

Питання більше не """, а "" МSK2 "".Чи варто намМСК0 МиМSK1 розглянемо це рішення в розділі " Коли не використовувати базові послугиММК3 пізнішеММСК4

Вбудовані параметри

IHostedService: Фонд

У своєму ядре - МСК0 - кожен фоновий сервіс ASP - МSK1 - NET Core IHostedService. Цей інтерфейс дуже простий

public interface IHostedService
{
    Task StartAsync(CancellationToken cancellationToken);
    Task StopAsync(CancellationToken cancellationToken);
}

Це – МСК0, це – МSK1. Два способи: МСК2 StartAsync з 'являється, коли запущена ваша програма, і StopAsync коли він закривається

Зарегистрируйтесь в Program.cs:

builder.Services.AddHostedService<MyBackgroundService>();

Ось візуалізація життєвого циклу

graph LR
    A[Application Starts] --> B[StartAsync Called]
    B --> C[Service Running]
    C --> D[Application Shutting Down]
    D --> E[StopAsync Called]
    E --> F[Application Stopped]

    style A stroke:#059669,stroke-width:3px,color:#10b981
    style C stroke:#2563eb,stroke-width:3px,color:#3b82f6
    style F stroke:#dc2626,stroke-width:3px,color:#ef4444

StartAsync: Синхронний проти асинхронного старту

Критична рішення при втіленні IHostedService чи ваша StartAsync метод повинен блокувати або повернутися негайно.

Синхронний (блокуванняM SK1 запуск:

public class BlockingStartService : IHostedService
{
    public async Task StartAsync(CancellationToken cancellationToken)
    {
        // This blocks application startup until complete
        await InitializeDatabaseAsync(cancellationToken);
        await LoadConfigurationAsync(cancellationToken);

        // Only now will the application continue starting
    }

    public Task StopAsync(CancellationToken cancellationToken)
        => Task.CompletedTask;
}

Асинхронний (неможливий-блокуванняM SK2початокMSC3

public class NonBlockingStartService : IHostedService
{
    private Task _backgroundTask;
    private readonly CancellationTokenSource _cts = new();

    public Task StartAsync(CancellationToken cancellationToken)
    {
        // Start background work but return immediately
        _backgroundTask = Task.Run(async () =>
        {
            // Give other services time to initialise
            await Task.Delay(TimeSpan.FromSeconds(5), _cts.Token);
            await DoLongRunningWorkAsync(_cts.Token);
        }, _cts.Token);

        return Task.CompletedTask;
    }

    public async Task StopAsync(CancellationToken cancellationToken)
    {
        _cts.Cancel();
        await _backgroundTask; // Wait for completion
    }
}

Коли використовувати кожен підхід:

  • Блокування: Коли служба повинна завершити інisiaлізацію перед тим, як програма зможе виконувати завдання. (eM SK1g., завантаження критичної конфігурації
  • Неможливе-блокуванняM SK1 Коли служба може inicialізуватися в фоні, тоді як інші сервіси запускаються (eM SK1g., indeksуючи наявний контент , синхронізація з зовнішніми службамиMSC4

StopAsync: Зазвичайний провал

Тут' це місце, де все стає цікавішим — і де багато розробників зіштовхуються з проблемами МSK2 Коли ваша програма закривається StopAsync на всіх об 'єднаних службах. У вас є обмежене вікно M SK1по замовчуванню МSK2секунди МSK3 для гарного прибирання. Ви можете розширити це в Program.cs:

builder.Services.Configure<HostOptions>(options =>
{
    options.ShutdownTimeout = TimeSpan.FromSeconds(30);
});

Найчастіша помилка:

public class BrokenService : IHostedService
{
    private readonly Channel<string> _channel = Channel.CreateUnbounded<string>();
    private Task _processingTask;

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _processingTask = ProcessMessagesAsync();
        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        // WRONG: The channel is still open, ProcessMessagesAsync
        // will hang on WaitToReadAsync forever!
        return Task.CompletedTask;
    }

    private async Task ProcessMessagesAsync()
    {
        // This will never exit because the channel is never completed
        await foreach (var message in _channel.Reader.ReadAllAsync())
        {
            await ProcessAsync(message);
        }
    }
}

Коли ви запускаєте цю службу і зупиняєте свою програму, ви побачите такі помилки як:

Unable to cast object of type 'TaskCompletionSource`1[System.Threading.Tasks.VoidTaskResult]' to type 'System.Threading.Tasks.Task'

Або програма просто зачепиться на час відключення, перш ніж forcefully terminating.

Правильний підхід:

public class CorrectService : IHostedService
{
    private readonly Channel<string> _channel = Channel.CreateUnbounded<string>();
    private readonly CancellationTokenSource _cts = new();
    private Task _processingTask;

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _processingTask = ProcessMessagesAsync(_cts.Token);
        return Task.CompletedTask;
    }

    public async Task StopAsync(CancellationToken cancellationToken)
    {
        // CORRECT: Signal cancellation and complete the channel
        await _cts.CancelAsync();
        _channel.Writer.Complete();

        try
        {
            // Wait for processing to finish or for the shutdown timeout
            await Task.WhenAny(_processingTask,
                Task.Delay(Timeout.Infinite, cancellationToken));
        }
        catch (OperationCanceledException)
        {
            // Expected when shutdown timeout is reached
        }
    }

    private async Task ProcessMessagesAsync(CancellationToken token)
    {
        await foreach (var message in _channel.Reader.ReadAllAsync(token))
        {
            try
            {
                await ProcessAsync(message);
            }
            catch (OperationCanceledException)
            {
                // Shutdown requested, exit gracefully
                break;
            }
        }
    }
}

Ключові моменти для правильного втілення StopAsync:

  1. Anulування сигналу - Використовуйте CancellationTokenSource і відкидати його
  2. Завершити канали - Якщо ви Writer.Complete()
  3. Почекайте на завдання на фоні - Використовувати Task.WhenAny з символом anulації замкнутості
  4. Рух operationCanceledException - Це очікувано і має бути виявлено
  5. Не викидати винятків - Винятки в StopAsync може призвести до непередбачуваного поведінки

Базова послуга: Удобна базова клас

Письмо IHostedService інсталяції можуть бути повторюваними. Вам завжди потрібна фонова задача BackgroundService керує цим котлярним панелем для вас:

public abstract class BackgroundService : IHostedService, IDisposable
{
    private Task _executeTask;
    private CancellationTokenSource _stoppingCts;

    protected abstract Task ExecuteAsync(CancellationToken stoppingToken);

    public virtual Task StartAsync(CancellationToken cancellationToken)
    {
        _stoppingCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
        _executeTask = ExecuteAsync(_stoppingCts.Token);
        return Task.CompletedTask;
    }

    public virtual async Task StopAsync(CancellationToken cancellationToken)
    {
        if (_executeTask == null) return;

        try
        {
            _stoppingCts.Cancel();
        }
        finally
        {
            await Task.WhenAny(_executeTask, Task.Delay(Timeout.Infinite, cancellationToken));
        }
    }

    public virtual void Dispose()
    {
        _stoppingCts?.Cancel();
    }
}

Ви просто реалізуєте ExecuteAsync і дозволити базовому класу керувати водопроводом:

public class SimpleBackgroundService : BackgroundService
{
    private readonly ILogger<SimpleBackgroundService> _logger;

    public SimpleBackgroundService(ILogger<SimpleBackgroundService> logger)
    {
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Service starting");

        // Wait for app to finish starting
        await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);

        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                await DoWorkAsync(stoppingToken);
                await Task.Delay(TimeSpan.FromMinutes(5), stoppingToken);
            }
            catch (OperationCanceledException)
            {
                // Shutdown requested
                break;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error in background service");
            }
        }

        _logger.LogInformation("Service stopping");
    }

    private async Task DoWorkAsync(CancellationToken token)
    {
        _logger.LogInformation("Doing work...");
        // Your actual work here
        await Task.Delay(1000, token);
    }
}

Коли використовувати BackgroundService проти IHostedService

Використовувати BackgroundService коли:

  • Вам потрібен довгий -забігаючий фоновий цикл
  • Ви хочете прості періодичні виконання
  • Вам не потрібно контролювати StartAsync/StopAsync набір часу

Використовувати IHostedService коли:

  • Потрібно контролювати саме те, що відбувається StartAsync проти роботи на фоні
  • Ви' створюєте обладначі подій або спостерігачі, а не постійному циклу
  • Вам потрібно координувати роботу з іншими службами під час запуску

Розвинена: Координація запуску

Інколи вам потрібні послуги, щоб чекати одне на одного.. Наприклад,

Ось pattern для координації запуску сервісу

public interface IStartupCoordinator
{
    void RegisterService(string serviceName);
    void SignalReady(string serviceName);
    bool IsServiceReady(string serviceName);
    Task WaitForServiceAsync(string serviceName, CancellationToken cancellationToken = default);
    Task WaitForAllServicesAsync(CancellationToken cancellationToken = default);
}

public class StartupCoordinator : IStartupCoordinator
{
    private readonly ConcurrentDictionary<string, TaskCompletionSource> _services = new();
    private readonly ILogger<StartupCoordinator> _logger;

    public void RegisterService(string serviceName)
    {
        _services.TryAdd(serviceName, new TaskCompletionSource());
    }

    public void SignalReady(string serviceName)
    {
        if (_services.TryGetValue(serviceName, out var tcs))
        {
            tcs.TrySetResult();
            _logger.LogInformation("{Service} is ready", serviceName);
        }
    }

    public async Task WaitForServiceAsync(string serviceName, CancellationToken ct = default)
    {
        if (_services.TryGetValue(serviceName, out var tcs))
        {
            await tcs.Task.WaitAsync(ct);
        }
    }

    public async Task WaitForAllServicesAsync(CancellationToken ct = default)
    {
        await Task.WhenAll(_services.Values.Select(tcs => tcs.Task)).WaitAsync(ct);
    }
}

Використовування в службі:

public class DependentService : IHostedService
{
    private readonly IStartupCoordinator _coordinator;
    private readonly ILogger<DependentService> _logger;

    public DependentService(
        IStartupCoordinator coordinator,
        ILogger<DependentService> logger)
    {
        _coordinator = coordinator;
        _logger = logger;
    }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        // Wait for another service to be ready
        await _coordinator.WaitForServiceAsync("MarkdownProcessor", cancellationToken);

        _logger.LogInformation("Dependencies ready, starting work");

        // Do your work...

        // Signal you're ready for services that depend on you
        _coordinator.SignalReady("DependentService");
    }

    public Task StopAsync(CancellationToken cancellationToken)
        => Task.CompletedTask;
}

Ця модель стає особливо корисною, коли ви маєте багато базових послуг з взаємозалежністю.

Розповсюджена координація з Redis

Координатор запуску працює в рамках одного прикладного випадку. Але що трапляється, коли ви масштабуєте один до кількох instanційM SK1 Ви не хочете ' хочете, щоб три instanції працювали одночасно з тим же запланованим завданням

Рідіс надає просте рішення: використовувати флаги M SK1 ключі) для координації того, хто робить що

Прості вибори лідера

public class DistributedBackgroundService : BackgroundService
{
    private readonly IConnectionMultiplexer _redis;
    private readonly ILogger<DistributedBackgroundService> _logger;
    private readonly string _instanceId = Guid.NewGuid().ToString();
    private const string LeaderKey = "background:newsletter:leader";

    public DistributedBackgroundService(
        IConnectionMultiplexer redis,
        ILogger<DistributedBackgroundService> logger)
    {
        _redis = redis;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var db = _redis.GetDatabase();

        while (!stoppingToken.IsCancellationRequested)
        {
            // Try to become the leader (SET NX with expiry)
            var acquired = await db.StringSetAsync(
                LeaderKey,
                _instanceId,
                TimeSpan.FromMinutes(5),
                When.NotExists);

            if (acquired)
            {
                _logger.LogInformation("This instance is the leader, running task");

                try
                {
                    await DoScheduledWorkAsync(stoppingToken);
                }
                finally
                {
                    // Release leadership
                    await db.KeyDeleteAsync(LeaderKey);
                }
            }
            else
            {
                var leader = await db.StringGetAsync(LeaderKey);
                _logger.LogDebug("Another instance ({Leader}) is the leader", leader);
            }

            await Task.Delay(TimeSpan.FromMinutes(5), stoppingToken);
        }
    }
}

Розділений замок для критичних секцій

Для завдань, які не повинні працювати одночасно між instancjami:

public async Task ProcessWithLockAsync(CancellationToken cancellationToken)
{
    var db = _redis.GetDatabase();
    var lockKey = "locks:critical-task";
    var lockValue = _instanceId;

    // Try to acquire lock
    if (await db.LockTakeAsync(lockKey, lockValue, TimeSpan.FromMinutes(10)))
    {
        try
        {
            _logger.LogInformation("Lock acquired, processing...");
            await DoCriticalWorkAsync(cancellationToken);
        }
        finally
        {
            await db.LockReleaseAsync(lockKey, lockValue);
        }
    }
    else
    {
        _logger.LogDebug("Could not acquire lock, another instance is processing");
    }
}

Коли використовувати розподілену координацію

  • Заплановані завдання - Лише один випадок повинен надіслати щоденний бюллетень
  • Обробка черги з замовленням - Упевнитись, що повідомлення обробляються в порядку
  • Ресурс- інтенсивні операції - Захищати multiple instances from overwhelming an external API
  • Міграції в бази даних - Лише один випадок повинен запускати міграції при запускі

Для більш складних сценаріїв (multiM SK1step jobs, надійний розклад по всіх рестартах ), візьміть до уваги Hangfire, який обробляє розподілене заблокування автоматично з його базою даних

Коли НЕ використовувати базові послуги

До того, як ми зануримося в більш складні інструменти, такі як Hangfire, дозвольте' говорити про те, коли ви shouldn't використати базові послуги у головній веб-аplikaції.

Потрібно розділити проект

Інформаційні служби, що запускаються в вашій веб-прикладі, поширюють ресурси з вашими HTTP-запросами.. Це може призвести до проблем:

1. Обговорення ресурсів

Проблема: Ваша база даних споживає значний CPU, пам 'ять, або зв' язки з базами данихM SK2

// This will starve your web application
public class VideoTranscodingService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var video = await _queue.DequeueAsync();
            // This uses 100% of 4 CPU cores for 5 minutes
            await TranscodeVideoAsync(video);
        }
    }
}

Коли веб-запити приходять під час транскодування, вони повільні, бо CPU зайняті

Рішення: Переход до окремої робітничої служби:

# Your solution structure
/YourApp.Web          # ASP.NET Core web app - no background services
/YourApp.Worker       # .NET Worker Service - handles background work
/YourApp.Shared       # Shared models, interfaces

2. Різні вимоги до масштабування

Проблема: Ваші попередні роботи потребують різного масштабування, ніж ваш веб рівень.

  • Веб рівень: Шкала для HTTP-траficу (можливо потребувати МSK1 інстанцій протягом дняM SK2 2 вночі)
  • Базова рівність: Скала для глибини черги (можливо потребувати МSK1 інстанція зазвичай МSK2 20 при обробці пакету

Якщо вони в тому ж процесі, ви можете масштабувати їх неzależnie.

Прикладний сценарій:

09:00 - High web traffic, low background work → Need 10 web instances, 1 worker
14:00 - Newsletter time! Low web traffic, high background work → Need 2 web instances, 20 workers

Поміщання фонових послуг у веб-апцію означає, що вам ' потрібно запускати 20 веб інстанції тільки для того, щоб задовольнити newsletter

3. Незалежність від використання

Проблема: Ви хочете застосувати зміни в вебі без перезапускання базових послуг ( або навпакиM SK1

// If this is in your web app, deploying a CSS change restarts the service
public class LongRunningImportService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        // This import takes 2 hours
        await ImportMillionsOfRecordsAsync(stoppingToken);
    }
}

Кожне застосування зупиняє введення. Переміщаємо його до окремої робітничої служби, яку ви застосовуєте самостійно.

4. Різні домена невдачі

Проблема: Баг у вашій фоновій службі скасує всю веб-програму.

// This null reference exception crashes your web app
public class BuggyBackgroundService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        string value = null;
        // Unhandled exception - takes down the whole app
        await ProcessAsync(value.Length);
    }
}

Якщо фонова робота знаходиться в іншому процесі, вона може скасуватися і розпочати роботу, не впливаючи на веб-запити.

Як спричинити фонові послуги

Коли ви вирішуєте розділити

Опція 1: . NET Worker Service

Створити новий проект, використовуючи шаблон Служби робітників:

dotnet new worker -n YourApp.Worker

Структура:

/YourApp.Worker
  /Services
    VideoTranscodingService.cs
    EmailSenderService.cs
  /Program.cs
  /appsettings.json

Програму.csM SK1

var builder = Host.CreateApplicationBuilder(args);

// Register your background services
builder.Services.AddHostedService<VideoTranscodingService>();
builder.Services.AddHostedService<EmailSenderService>();

// Share configuration with web app
builder.Services.Configure<VideoConfig>(
    builder.Configuration.GetSection("Video"));

// Share database context
builder.Services.AddDbContext<YourDbContext>(options =>
    options.UseNpgsql(builder.Configuration.GetConnectionString("Default")));

var host = builder.Build();
host.Run();

Розміщувати окремо:

# Web app on ports 80/443
/YourApp.Web → web-server-1, web-server-2, web-server-3

# Worker service doesn't listen on any port
/YourApp.Worker → worker-server-1, worker-server-2

Опція 2: розділити проект з спільним чергою

Використовуйте чергу повідомлень, щоб відокремити веб і працівників:

graph LR
    A[Web App] --> B[Message Queue]
    B --> C[Worker 1]
    B --> D[Worker 2]
    B --> E[Worker N]

    style A stroke:#059669,stroke-width:3px,color:#10b981
    style B stroke:#2563eb,stroke-width:3px,color:#3b82f6
    style C stroke:#7c3aed,stroke-width:3px,color:#8b5cf6
    style D stroke:#7c3aed,stroke-width:3px,color:#8b5cf6
    style E stroke:#7c3aed,stroke-width:3px,color:#8b5cf6

Рабочие черги веб-приложений:

// In your web controller
public class VideoController : ControllerBase
{
    private readonly IMessageQueue _queue;

    [HttpPost("upload")]
    public async Task<IActionResult> Upload(IFormFile video)
    {
        await _storage.SaveAsync(video);

        // Queue for processing - don't process in web app
        await _queue.PublishAsync(new VideoTranscodeJob
        {
            VideoId = video.Id,
            Priority = Priority.Normal
        });

        return Accepted(); // Return immediately
    }
}

Працівник споживає з черги:

// In your worker service
public class VideoWorker : BackgroundService
{
    private readonly IMessageQueue _queue;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await foreach (var job in _queue.SubscribeAsync<VideoTranscodeJob>(stoppingToken))
        {
            await TranscodeAsync(job);
        }
    }
}

Найпопулярніші варіанти черги повідомлень:

Опція 3: Множество спеціалізованих робітників

Для складних систем

/YourApp.Web              # HTTP requests only
/YourApp.EmailWorker      # Sends emails
/YourApp.VideoWorker      # Transcodes videos
/YourApp.ReportWorker     # Generates reports
/YourApp.Scheduler        # Runs scheduled jobs (Hangfire)

Кожен працівник може

  • Скала незалежно
  • Працювати незалежно
  • Використовуйте різні ресурси (email workers needs SMTPM SK1 video worker needs GPU)
  • Подібне стеження і попередження

Коли зберігати подібні послуги в вашій веб-апці

Незважаючи на це, деякі сценарії абсолютно непогані для

Легкі періодичні завдання

// Fine to keep in web app
public class CacheWarmingService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            await _cache.WarmupAsync(); // Quick operation
            await Task.Delay(TimeSpan.FromMinutes(5), stoppingToken);
        }
    }
}

Слухачі подій

// Fine to keep in web app
public class FileWatcherService : IHostedService
{
    // Reacts to events, doesn't consume significant resources
    private FileSystemWatcher _watcher;

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _watcher = new FileSystemWatcher("/config");
        _watcher.Changed += OnConfigChanged;
        _watcher.EnableRaisingEvents = true;
        return Task.CompletedTask;
    }
}

Канал-Посадкова черга M SK1для неможливих-критичну роботуMSC3

// Fine to keep in web app if work is quick and not critical
public class EmailQueueService : BackgroundService
{
    // Sends emails in background, but each email takes < 1 second
    // If the app restarts, losing a few queued emails is acceptable
}

Координація запуску

// Fine to keep in web app
public class WarmupService : IHostedService
{
    // Runs once at startup, then does nothing
    public async Task StartAsync(CancellationToken cancellationToken)
    {
        await _database.WarmupConnectionPoolAsync();
        await _cache.LoadCriticalDataAsync();
    }
}

Матрица прийняття рішень

Характеристика МSK1 Утримка в веб-апліці МSK2 Перехід до робітничої служби
Використовування процесора на одну операцію
Пам 'ять на одну операцію
МSK0 Частота Периодічна МSK2 хвилини МСК3 години М СК4 M СК5 Неперервна або висока ССК6 частота \ М С К7
Критичний Некритичний МSK2критичний
МSK0 Продолжительность Стори МSK2 Миті до годин
Скала з МSK1 Веб-траfic МSK2 Глубина черги праці
До прикладу Отопування таємниці МSK2 перезавантаження конфігурації МSK3 Обробка відеозаписів

Реальність- Світовий приклад : Блог-платформа

В блоговій платформі, код якої ми вивчаємо у частині 2:

Залишена в веб-прикладі:

  • MarkdownDirectoryWatcherService - Легкий файловий годинник
  • UmamiBackgroundSender - Краткий аналіз подій
  • EmailSenderHostedService - Невеликий об 'єм , не МSK2 критичний
  • MarkdownReAddPostsService - Начальник - ТількиM SK2 конфігурація МSK3 задіяна

Чи варто переїхати на службу працівників, якщо масштаб зростає:

  • BrokenLinkCheckerBackgroundService - Зробляє багато HTTP запитів
  • SemanticIndexingBackgroundService - Викликає зовнішній API для вмонтування

Уже в окремому обслуживанні:

  • Mostlylucid.SchedulerService - Панель навігацій Hangfire і відправлення bulletinів

Це прагматичний підхід.

Поза базовими принципами: Hangfire

В той час IHostedService і BackgroundService є чудовими для послуг, які ви маєте і контролюєте. Постріл прийти

Хангфайр надає:

  • Неперервні черги робіт - Роботи, які виживають після запуску програми
  • Рекурентні роботи - CronM SK1програмування
  • Панель інтерфейсу - Подивіться, що running
  • Розповсюджене виконання - Багато серверів можуть обробляти одну і ту ж чергу робіт
  • Автоматічні повторення - Неисправні завдання автоматично відслідковуються з експоненційним відхиленням

Ось простий приклад:

// In Program.cs
builder.Services.AddHangfire(config => config
    .UsePostgreSqlStorage(connectionString)
    .UseRecommendedSerializerSettings());

builder.Services.AddHangfireServer();

var app = builder.Build();

// Schedule recurring jobs
app.UseHangfireDashboard();
app.Services.GetRequiredService<IRecurringJobManager>()
    .AddOrUpdate<NewsletterService>(
        "send-daily-newsletter",
        x => x.SendDailyNewsletter(),
        Cron.Daily(17)); // 5 PM every day

Ваша послуга - це лише нормальна клас.

public class NewsletterService
{
    private readonly IEmailService _emailService;
    private readonly ISubscriberRepository _subscribers;

    public NewsletterService(
        IEmailService emailService,
        ISubscriberRepository subscribers)
    {
        _emailService = emailService;
        _subscribers = subscribers;
    }

    public async Task SendDailyNewsletter()
    {
        var subscribers = await _subscribers.GetDailySubscribersAsync();

        foreach (var subscriber in subscribers)
        {
            await _emailService.SendNewsletterAsync(subscriber);
        }
    }
}

Ручки вогню:

  • Упевнитись, що робота відбуватиметься в запланованому часі
  • Знову спробувати, якщо це не вдасться
  • Сохранени історії страти
  • Дозволяти налагодити панель для перевірки всього
graph TD
    A[Hangfire Server] --> B{Check Schedule}
    B -->|Job Due| C[Dequeue Job]
    C --> D[Execute Job Method]
    D -->|Success| E[Mark Complete]
    D -->|Failure| F[Retry with Backoff]
    F --> G{Max Retries?}
    G -->|No| C
    G -->|Yes| H[Mark Failed]
    E --> I[Update Dashboard]
    H --> I
    I --> B

    style A stroke:#059669,stroke-width:3px,color:#10b981
    style D stroke:#2563eb,stroke-width:3px,color:#3b82f6
    style E stroke:#059669,stroke-width:3px,color:#10b981
    style H stroke:#dc2626,stroke-width:3px,color:#ef4444

Коли використовувати Hangfire:

  • Вам потрібні тривалі черги робіт, які переживуть рестарт
  • Ви хочете, щоб панель з настроями моніторувала і ручно запускала завдання
  • Потрібно розповсюджувати роботу на багатьох серверах
  • Ви хочете зробити збудовану - логіку повторного спроби і подолання проблем
  • Вам потрібне cron-stil планування повторюваних завдань

Коли користуватись IHostedService/BackgroundService :

  • Потрібно добре контролювати життєвий цикл служби
  • Ваша служба повинна реагувати на події в реальному часі-
  • Ви хочете мінімізувати залежності
  • Ви створюєте просту періодичну задачу, яка не потребує тривалості

Інші варіанти

У той час, як Hangfire популярний, існують інші бібліотеки, які варто взяти до увагиM SK1

Кварц.NET:

  • Мова йде про більш гнучке планування, ніж у випадку з Hangfire.
  • Obsługа виражень cron і календару-, що базується на розкладі
  • Може залишатися на багатьох базах даних
  • Складніший інтерфейс, але потужніший

Масове переміщення/NServiceBus:

  • Полне-втілення автобусу повідомлень
  • Краще для розподілених систем та мікрослужб
  • Підтримка сага ( довгих -швидких операційних потоківM SK2
  • Швидша кривая навчання

Функції Azure/АWS Ламбда:

  • Якщо ви - МСК0 - знаходитесь в хмарі, - МSK1 - маєте на увазі безсерверний
  • платити за виконання, а не тримати службу на місці
  • Автоматичне масштабування
  • Невелика затримка для холодного старту

Підсумок

У частині "1," ми МSK1 застосували фундаментальні підходи до базових послуг в ASP

  1. Услуга IHosted - Основа МSK1 maksimalа гнучкість
  2. Обслуживание на тлі - Удобна базовий клас для довгих ланцюгів
  3. Координація запуску - Дозволяти службам чекати одне на одного
  4. Розповсюджена координація - Використовуючи Redis для багатьох сценаріїв МSK1
  5. Постріл - Коли вам потрібні тривалі роботи та складне планування

Найважливіші уроки

  • Завершити канали і anulувати символи в StopAsync
  • вирішити, чи StartAsync повинен блокувати або негайно повернутися
  • Рух operationCanceledException граціозно
  • Використовуйте задачу.WhenAny з символом вимкнений , щоб поважати вимкнення

В Частина 2, ми ' перевіримо реальні МSK2 світові втілення з виробничої блогової платформи

  • Файлові системні спостерігачі, які синхронизують файли відмітки до бази даних
  • Відправники електронної пошти з політиками повторного спробування та блокувальниками схеми
  • Кільця подій, що вимагають пакету
  • Семантичні пошукові індекси, які обробляють контент асинхронно
  • Пошкоджені перевірники зв 'язків, які периодически підтверджують зовнішні URL

Ці приклади демонструють візерунки з частини 1 в дії ,, включаючи модель координації запуску і правильне подолання замкнутості .

Дальне читання

logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.