Usługи в ASP.NET Core - Part 1: Дослідження
Кожна сучасна веб-а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 коротко подумайте про " чому \ ." \ Навігаційні послуги дозволять вам
- Повільні операції відряду - Не змушуйте користувачів чекати, поки ви надсилаєте електронні листи чи генеруєте PDF
- Запланувати повторювані завдання - Зачистка старих записів щовечора в МSK1
- Кої processу - Передавати повідомлення від каналів або брокерів
- Бачити зовнішній стан - API для опитування або файлові системи для спостереження за змінами
- Координувати складні робочі потоки - Управляйте багатьма 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:
- Anulування сигналу - Використовуйте
CancellationTokenSourceі відкидати його - Завершити канали - Якщо ви
Writer.Complete() - Почекайте на завдання на фоні - Використовувати
Task.WhenAnyз символом anulації замкнутості - Рух operationCanceledException - Це очікувано і має бути виявлено
- Не викидати винятків - Винятки в
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);
}
}
}
Найпопулярніші варіанти черги повідомлень:
- RabbitMQ - НайпопулярнішіM SK1 функція-багато
- А Azure Service Bus - Якщо ви на Azure
- АWS SQS - Якщо ви на AWS
- Редіс Streams - ПростішийM SK1 хороший для меншого розміру
Опція 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
- Мова йде про більш гнучке планування, ніж у випадку з Hangfire.
- Obsługа виражень cron і календару-, що базується на розкладі
- Може залишатися на багатьох базах даних
- Складніший інтерфейс, але потужніший
Масове переміщення/NServiceBus:
- Полне-втілення автобусу повідомлень
- Краще для розподілених систем та мікрослужб
- Підтримка сага ( довгих -швидких операційних потоківM SK2
- Швидша кривая навчання
- Якщо ви - МСК0 - знаходитесь в хмарі, - МSK1 - маєте на увазі безсерверний
- платити за виконання, а не тримати службу на місці
- Автоматичне масштабування
- Невелика затримка для холодного старту
Підсумок
У частині "1," ми МSK1 застосували фундаментальні підходи до базових послуг в ASP
- Услуга IHosted - Основа МSK1 maksimalа гнучкість
- Обслуживание на тлі - Удобна базовий клас для довгих ланцюгів
- Координація запуску - Дозволяти службам чекати одне на одного
- Розповсюджена координація - Використовуючи Redis для багатьох сценаріїв МSK1
- Постріл - Коли вам потрібні тривалі роботи та складне планування
Найважливіші уроки
- Завершити канали і anulувати символи в StopAsync
- вирішити, чи StartAsync повинен блокувати або негайно повернутися
- Рух operationCanceledException граціозно
- Використовуйте задачу.WhenAny з символом вимкнений , щоб поважати вимкнення
В Частина 2, ми ' перевіримо реальні МSK2 світові втілення з виробничої блогової платформи
- Файлові системні спостерігачі, які синхронизують файли відмітки до бази даних
- Відправники електронної пошти з політиками повторного спробування та блокувальниками схеми
- Кільця подій, що вимагають пакету
- Семантичні пошукові індекси, які обробляють контент асинхронно
- Пошкоджені перевірники зв 'язків, які периодически підтверджують зовнішні URL
Ці приклади демонструють візерунки з частини 1 в дії ,, включаючи модель координації запуску і правильне подолання замкнутості .