BackgroundService & Hosted Service di ASP.NET Core: Proses Latar Belakang

Foto oleh Ann Hannes via Pexels

BackgroundService dan Hosted Service di ASP.NET Core: Menjalankan Tugas Latar Belakang Secara Elegan

Pernahkah Anda menghadapi situasi di mana aplikasi web ASP.NET Core Anda perlu melakukan tugas yang tidak terkait langsung dengan respons HTTP? Mungkin Anda perlu mengirim email selamat datang setelah pendaftaran, menghasilkan laporan kompleks secara berkala, atau melakukan sinkronisasi data dengan sistem eksternal setiap beberapa menit.

Jika tugas-tugas ini dieksekusi langsung dalam konteks permintaan HTTP, ada beberapa masalah serius yang bisa timbul:

  • Blocking Request: Permintaan pengguna akan tertunda sampai tugas selesai, menyebabkan pengalaman pengguna yang buruk atau bahkan timeout.
  • Resiko Kehilangan Data: Jika aplikasi berhenti atau me-restart di tengah jalan, tugas yang sedang berlangsung bisa terhenti tanpa penyelesaian, berpotensi meninggalkan data dalam keadaan inkonsisten.
  • Skalabilitas Terbatas: Setiap worker thread untuk HTTP request akan terpakai untuk tugas latar belakang, membatasi kemampuan server untuk melayani permintaan lain.

Di sinilah konsep BackgroundService dan IHostedService hadir sebagai solusi elegan di ASP.NET Core. Mereka memungkinkan aplikasi Anda menjalankan tugas-tugas non-interaktif di latar belakang, terpisah dari siklus hidup permintaan HTTP, namun tetap terkelola oleh host aplikasi.

Mengenal IHostedService: Pondasi Tugas Latar Belakang

IHostedService adalah interface yang sangat sederhana namun fundamental di ASP.NET Core. Interface ini menyediakan dua metode utama:

  • StartAsync(CancellationToken cancellationToken): Dipanggil saat host aplikasi mulai. Di sinilah Anda menginisialisasi dan memulai tugas latar belakang Anda.
  • StopAsync(CancellationToken cancellationToken): Dipanggil saat host aplikasi berhenti. Ini adalah kesempatan Anda untuk membersihkan sumber daya dan menghentikan tugas secara graceful.

Dengan mengimplementasikan IHostedService, Anda memberi tahu runtime ASP.NET Core bahwa ada layanan yang perlu dikelola sepanjang siklus hidup aplikasi, bukan hanya sebagai respons terhadap permintaan web.

Membuat BackgroundService Kustom Pertama Anda

Meskipun Anda bisa langsung mengimplementasikan IHostedService, Microsoft menyediakan kelas abstrak BackgroundService yang lebih nyaman untuk sebagian besar kasus penggunaan. Kelas ini sudah mengimplementasikan IHostedService dan menyediakan metode abstrak ExecuteAsync(CancellationToken stoppingToken) yang harus Anda override.

Metode ExecuteAsync adalah tempat di mana logika utama tugas latar belakang Anda berjalan. CancellationToken stoppingToken yang diberikan akan memberi tahu Anda kapan host meminta layanan untuk berhenti, yang krusial untuk graceful shutdown.

Mari kita buat contoh sederhana: sebuah layanan yang mencatat waktu ke konsol setiap beberapa detik.

Contoh 1: PeriodicLoggerService

Pertama, definisikan kelas PeriodicLoggerService yang mewarisi BackgroundService:

Implementasi PeriodicLoggerService

using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Logging; namespace MalamNgoding.HostedServices; public class PeriodicLoggerService : BackgroundService { private readonly ILogger<PeriodicLoggerService> _logger; public PeriodicLoggerService(ILogger<PeriodicLoggerService> logger) { _logger = logger; } protected override async Task ExecuteAsync(CancellationToken stoppingToken) { _logger.LogInformation( "PeriodicLoggerService is starting."); stoppingToken.Register(() => _logger.LogInformation("PeriodicLoggerService is stopping.")); while (!stoppingToken.IsCancellationRequested) { _logger.LogInformation( "PeriodicLoggerService running at: {time}", DateTimeOffset.Now); try { await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken); } catch (OperationCanceledException) { // Ketika stoppingToken dibatalkan, Task.Delay akan melempar OperationCanceledException. // Kita tangani ini untuk keluar dari loop secara graceful. break; } } _logger.LogInformation("PeriodicLoggerService has stopped."); } }

Selanjutnya, daftarkan PeriodicLoggerService ke dalam dependency injection container di file Program.cs atau Startup.cs (tergantung versi .NET Core yang Anda gunakan). Untuk .NET 6 ke atas (Minimal API):

Mendaftarkan PeriodicLoggerService di Program.cs

var builder = WebApplication.CreateBuilder(args); // Add services to the container. builder.Services.AddControllers(); builder.Services.AddEndpointsApiExplorer(); builder.Services.AddSwaggerGen(); // Daftarkan BackgroundService Anda builder.Services.AddHostedService<PeriodicLoggerService>(); var app = builder.Build(); // Configure the HTTP request pipeline. if (app.Environment.IsDevelopment()) { app.UseSwagger(); app.UseSwaggerUI(); } app.UseHttpsRedirection(); app.UseAuthorization(); app.MapControllers(); app.Run();

Saat aplikasi dijalankan, Anda akan melihat output di konsol yang menunjukkan bahwa layanan latar belakang sedang berjalan dan mencatat waktu secara berkala. Ini menunjukkan bagaimana BackgroundService bekerja secara independen dari web request.

Contoh Output Konsol dari PeriodicLoggerService

info: PeriodicLoggerService[0] PeriodicLoggerService is starting. info: PeriodicLoggerService[0] PeriodicLoggerService running at: 2023-10-26T10:00:00.123+07:00 info: PeriodicLoggerService[0] PeriodicLoggerService running at: 2023-10-26T10:00:05.123+07:00 info: PeriodicLoggerService[0] PeriodicLoggerService running at: 2023-10-26T10:00:10.123+07:00 ... info: PeriodicLoggerService[0] PeriodicLoggerService is stopping. info: PeriodicLoggerService[0] PeriodicLoggerService has stopped.

Studi Kasus: Polling API Eksternal dengan IHttpClientFactory

Artikel sebelumnya membahas tentang HttpClient dan IHttpClientFactory. Ini adalah contoh sempurna di mana BackgroundService dapat berkolaborasi dengan layanan lain yang telah terdaftar di DI. Bayangkan Anda perlu secara berkala mengambil data dari API eksternal, misalnya untuk memperbarui cache lokal atau memicu proses lainnya.

Kita akan membuat ApiPollingService yang menggunakan IHttpClientFactory untuk melakukan polling ke API dummy setiap interval tertentu.

Contoh 2: ApiPollingService

Pertama, buat kelas ApiPollingService. Dalam contoh ini, kita akan mengasumsikan ada HttpClient bernama "MyApiClient" yang sudah dikonfigurasi menggunakan IHttpClientFactory.

Implementasi ApiPollingService menggunakan IHttpClientFactory

using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Logging; using System.Net.Http; using System.Text.Json; namespace MalamNgoding.HostedServices; public class ApiPollingService : BackgroundService { private readonly ILogger<ApiPollingService> _logger; private readonly IHttpClientFactory _httpClientFactory; public ApiPollingService( ILogger<ApiPollingService> logger, IHttpClientFactory httpClientFactory) { _logger = logger; _httpClientFactory = httpClientFactory; } protected override async Task ExecuteAsync(CancellationToken stoppingToken) { _logger.LogInformation("ApiPollingService starting."); while (!stoppingToken.IsCancellationRequested) { _logger.LogInformation("Fetching data from API..."); try { // Dapatkan HttpClient dari factory var httpClient = _httpClientFactory.CreateClient("MyApiClient"); var response = await httpClient.GetAsync("posts/1", stoppingToken); // Contoh dummy API response.EnsureSuccessStatusCode(); var content = await response.Content.ReadAsStringAsync(stoppingToken); _logger.LogInformation("API Response: {content}", content.Substring(0, Math.Min(content.Length, 100)) + "..."); // Log sebagian kecil response } catch (OperationCanceledException) { // Operasi dibatalkan oleh token, keluar dari loop. break; } catch (HttpRequestException ex) { _logger.LogError(ex, "Error fetching data from API."); } catch (Exception ex) { _logger.LogError(ex, "An unexpected error occurred."); } // Tunggu sebelum polling berikutnya, sambil memonitor cancellation token try { await Task.Delay(TimeSpan.FromSeconds(10), stoppingToken); } catch (OperationCanceledException) { break; } } _logger.LogInformation("ApiPollingService stopping."); } }

Pastikan Anda telah mendaftarkan HttpClient bernama "MyApiClient" di Program.cs, misalnya:

Konfigurasi IHttpClientFactory di Program.cs

var builder = WebApplication.CreateBuilder(args); // Konfigurasi HttpClient untuk MyApiClient builder.Services.AddHttpClient("MyApiClient", client => { client.BaseAddress = new Uri("https://jsonplaceholder.typicode.com/"); client.Timeout = TimeSpan.FromSeconds(30); client.DefaultRequestHeaders.Add("Accept", "application/json"); }); // ... layanan lain builder.Services.AddControllers(); builder.Services.AddEndpointsApiExplorer(); builder.Services.AddSwaggerGen(); // ...

Kemudian, daftarkan ApiPollingService juga:

Mendaftarkan ApiPollingService di Program.cs

var builder = WebApplication.CreateBuilder(args); // Konfigurasi HttpClient untuk MyApiClient builder.Services.AddHttpClient("MyApiClient", client => { client.BaseAddress = new Uri("https://jsonplaceholder.typicode.com/"); client.Timeout = TimeSpan.FromSeconds(30); client.DefaultRequestHeaders.Add("Accept", "application/json"); }); // Add services to the container. builder.Services.AddControllers(); builder.Services.AddEndpointsApiExplorer(); builder.Services.AddSwaggerGen(); // Daftarkan BackgroundService Anda builder.Services.AddHostedService<ApiPollingService>(); var app = builder.Build(); // Configure the HTTP request pipeline. if (app.Environment.IsDevelopment()) { app.UseSwagger(); app.UseSwaggerUI(); } app.UseHttpsRedirection(); app.UseAuthorization(); app.MapControllers(); app.Run();

Ketika aplikasi berjalan, ApiPollingService akan secara otomatis memulai polling ke API yang ditentukan. Anda akan melihat log "Fetching data from API..." dan hasil respons di konsol secara berkala.

Contoh Output Konsol dari ApiPollingService

info: ApiPollingService[0] ApiPollingService starting. info: ApiPollingService[0] Fetching data from API... info: ApiPollingService[0] API Response: {"userId": 1, "id": 1, "title": "sunt aut facere repellat provident occaecati excepturi optio repreh... info: ApiPollingService[0] Fetching data from API... info: ApiPollingService[0] API Response: {"userId": 1, "id": 1, "title": "sunt aut facere repellat provident occaecati excepturi optio repreh... ... info: ApiPollingService[0] ApiPollingService stopping.

Contoh ini menunjukkan bagaimana BackgroundService bisa memanfaatkan kekuatan Dependency Injection untuk berinteraksi dengan layanan lain, termasuk yang memiliki siklus hidup yang kompleks seperti HttpClient yang dikelola oleh IHttpClientFactory.

Penanganan Graceful Shutdown dengan CancellationToken

Salah satu aspek terpenting dari BackgroundService adalah kemampuannya untuk berhenti secara graceful. Ketika aplikasi ASP.NET Core Anda dimatikan (misalnya, karena deployment baru, restart server, atau perintah stop), host akan memberi sinyal kepada semua IHostedService (termasuk BackgroundService Anda) untuk berhenti.

Sinyal ini disampaikan melalui CancellationToken stoppingToken yang diterima oleh metode ExecuteAsync. Sangat penting bagi kode Anda untuk secara rutin memeriksa status CancellationToken dan meresponsnya dengan menghentikan operasi yang sedang berjalan.

Dalam contoh PeriodicLoggerService, perhatikan baris await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);. Ini adalah cara yang benar untuk menunggu sambil tetap memonitor CancellationToken. Jika stoppingToken dibatalkan saat Task.Delay sedang menunggu, ia akan segera keluar dari penundaan tersebut dengan melempar OperationCanceledException.

Jika Anda memiliki operasi yang lebih kompleks atau perulangan yang panjang, pastikan untuk memeriksa stoppingToken.IsCancellationRequested secara manual dan keluar dari perulangan jika sinyal pembatalan diterima. Ini memastikan bahwa aplikasi Anda dapat dimatikan dengan cepat dan bersih tanpa meninggalkan tugas yang menggantung.

Kapan Menggunakan BackgroundService dan IHostedService? (Trade-off)

Meskipun BackgroundService sangat berguna, ia bukanlah solusi untuk semua masalah tugas latar belakang. Penting untuk memahami kapan ia layak dipakai dan kapan Anda perlu mempertimbangkan alternatif lain.

Kapan Sebaiknya Menggunakan:

  • Tugas Periodik: Cocok untuk polling API, membersihkan data lama, atau mengirim laporan harian/mingguan.
  • Pemrosesan Antrean Internal: Jika Anda memiliki antrean pesan atau tugas yang hanya perlu diproses oleh satu instans aplikasi dan tidak membutuhkan ketahanan tingkat tinggi (misalnya, antrean di-memory).
  • Tugas yang Terikat Siklus Hidup Aplikasi: Ketika tugas harus dimulai saat aplikasi start dan berhenti saat aplikasi shutdown.
  • Monitor atau Log: Untuk memantau status sistem atau menghasilkan log secara berkala.

Kapan Perlu Mempertimbangkan Alternatif:

  • Tugas Berkapasitas Tinggi dan Terdistribusi: Untuk skenario yang membutuhkan pemrosesan ribuan atau jutaan pesan, ketahanan data yang kuat, dan kemampuan skala horizontal (misalnya, lebih dari satu instans aplikasi), Anda harus mempertimbangkan message broker eksternal seperti RabbitMQ, Apache Kafka, atau Azure Service Bus.
  • Tugas yang Membutuhkan Jaminan Eksekusi: Jika tugas harus benar-benar selesai meskipun aplikasi crash atau di-restart, BackgroundService saja tidak cukup. Anda memerlukan mekanisme antrean dengan persistensi.
  • Penjadwalan Kompleks: Untuk penjadwalan yang sangat kompleks (misalnya, tugas yang berjalan pada tanggal tertentu setiap bulan, atau dengan dependensi antar-tugas), Anda mungkin memerlukan pustaka penjadwalan tugas yang lebih canggih seperti Quartz.NET atau Hangfire.
  • Tugas yang Tidak Perlu Bersama Aplikasi: Jika tugas bisa berjalan secara independen di server terpisah, maka BackgroundService di aplikasi web mungkin bukan tempat terbaik.

Intinya, BackgroundService sangat baik untuk tugas latar belakang yang sifatnya "lokal" pada satu instans aplikasi dan dapat mentoleransi potensial kehilangan proses jika aplikasi mendadak mati (tanpa graceful shutdown) atau di-restart.

Kesalahan Umum dalam Penggunaan BackgroundService

  • Memblokir ExecuteAsync secara Sinkron: Ini adalah kesalahan fatal. Metode ExecuteAsync harus selalu bersifat async dan tidak boleh mengandung operasi pemblokiran yang panjang tanpa menggunakan await. Memblokir berarti host tidak bisa memberi sinyal untuk berhenti, dan aplikasi tidak bisa di-shutdown secara graceful.
  • Mengabaikan CancellationToken: Tidak memeriksa atau merespons CancellationToken akan membuat aplikasi Anda lambat saat di-shutdown, karena layanan Anda tidak akan berhenti sampai operasi yang memblokir selesai atau sampai timeout paksa terjadi.
  • Melakukan Terlalu Banyak Pekerjaan dalam Satu Layanan: Seperti halnya kelas lain, BackgroundService juga harus mengikuti prinsip Single Responsibility Principle. Pisahkan tugas-tugas yang berbeda ke dalam kelas BackgroundService yang berbeda untuk menjaga kode tetap rapi dan mudah di-maintain.
  • Menggunakan untuk Tugas yang Membutuhkan Persistensi dan Ketahanan: Seperti yang sudah dibahas, BackgroundService di-memory tidak akan menjamin eksekusi tugas jika aplikasi crash. Jangan gunakan ini untuk tugas-tugas kritikal yang membutuhkan jaminan penyelesaian.

Ringkasan: Membangun Aplikasi Responsif dengan Proses Latar Belakang

BackgroundService dan IHostedService adalah bagian integral dari arsitektur ASP.NET Core yang modern, memungkinkan Anda untuk membangun aplikasi yang lebih responsif dan efisien. Dengan memisahkan tugas latar belakang dari siklus hidup permintaan HTTP, Anda dapat meningkatkan kinerja, keandalan, dan pengalaman pengguna aplikasi Anda.

Penting untuk selalu merancang layanan latar belakang Anda dengan mempertimbangkan graceful shutdown menggunakan CancellationToken dan memahami batasan-batasan BackgroundService agar Anda bisa memilih solusi yang tepat untuk setiap kebutuhan tugas latar belakang Anda.

Seri Belajar .NET Core:

← Sebelumnya: HttpClient dan IHttpClientFactory di ASP.NET Core

→ Selanjutnya: Memory Cache dengan IMemoryCache di ASP.NET Core (segera terbit)