Membangun Klien HTTP yang Robust: HttpClient dan IHttpClientFactory di ASP.NET Core

Dalam pengembangan aplikasi web modern, sangat umum bagi aplikasi kita untuk berinteraksi dengan API eksternal. Baik itu memanggil layanan microservice lain, API pihak ketiga untuk pembayaran, atau sumber data eksternal lainnya, kita akan selalu berhadapan dengan panggilan HTTP. Di ekosistem .NET, kelas HttpClient adalah alat utama untuk melakukan tugas ini.

Namun, penggunaan HttpClient secara langsung dan tidak tepat dapat menyebabkan masalah serius, terutama pada aplikasi ASP.NET Core yang berjalan di bawah beban tinggi. Kita akan membahas mengapa demikian, dan bagaimana IHttpClientFactory hadir sebagai solusi standar yang direkomendasikan.

Risiko Menggunakan HttpClient Secara Langsung

Sebagian besar developer pemula sering tergoda untuk membuat instansi HttpClient baru setiap kali mereka perlu melakukan panggilan HTTP. Meskipun tampaknya sederhana dan berfungsi pada skala kecil, pendekatan ini memiliki dua masalah utama yang seringkali baru muncul pada kondisi produksi:

  1. Socket Exhaustion: Setiap instansi HttpClient akan membuka koneksi soket baru. Jika Anda sering membuat instansi HttpClient dan tidak membuangnya dengan benar (atau bahkan membuangnya terlalu cepat), sistem operasi akan kehabisan jumlah soket yang tersedia. Ini karena soket tidak langsung ditutup dan akan masuk ke status TIME_WAIT untuk beberapa saat, mencegah soket baru dibuka. Akibatnya, aplikasi tidak dapat lagi melakukan panggilan HTTP dan akan mengalami timeout atau error koneksi.
  2. DNS Changes Not Respected: Instansi HttpClient dimaksudkan untuk berumur panjang. Jika Anda membuat instansi baru terlalu sering, Anda mungkin mengalami masalah dengan pembaruan DNS. HttpClient akan melakukan resolusi DNS sekali saat instansi dibuat dan menyimpan hasilnya. Jika alamat IP dari layanan eksternal berubah (misalnya, karena auto-scaling atau pembaruan infrastruktur), instansi HttpClient yang sudah ada tidak akan mengambil pembaruan DNS tersebut dan akan terus mencoba menghubungi alamat IP lama yang mungkin sudah tidak valid.

Contoh Penggunaan HttpClient yang Kurang Tepat

Berikut adalah contoh kode yang menunjukkan pola umum yang harus dihindari di aplikasi ASP.NET Core:

Contoh penggunaan HttpClient yang berisiko

public class MyBadController : ControllerBase { [HttpGet("external-data")] public async Task<IActionResult> GetExternalData() { // Anti-pattern: Membuat HttpClient baru setiap kali using var client = new HttpClient(); client.BaseAddress = new Uri("https://api.example.com/"); var response = await client.GetStringAsync("data"); return Ok(response); } }

Pada contoh di atas, setiap kali method GetExternalData dipanggil, instansi HttpClient baru dibuat. Jika ini terjadi berkali-kali dalam waktu singkat, terutama di aplikasi web yang menerima banyak request, maka akan sangat rentan terhadap masalah socket exhaustion.

Solusi: Mengenal IHttpClientFactory

Untuk mengatasi masalah-masalah di atas, ASP.NET Core memperkenalkan IHttpClientFactory. Ini adalah *factory pattern* yang terintegrasi dengan Dependency Injection (DI) di ASP.NET Core. IHttpClientFactory dirancang untuk:

  • Menyediakan instansi HttpClient yang di-pool dan diatur umurnya secara tepat, menghindari socket exhaustion.
  • Mengelola lifetime dari handler HttpClient, memastikan pembaruan DNS dihormati setelah periode tertentu.
  • Memudahkan konfigurasi HttpClient (seperti base address, headers, dan timeout).
  • Mempermudah integrasi dengan kebijakan resiliensi eksternal seperti Polly.
  • Mendukung Typed Clients, yang menyederhanakan kode dan meningkatkan testability.

Secara internal, IHttpClientFactory akan me-manage kumpulan HttpClientHandler yang dapat digunakan kembali, bukan instansi HttpClient itu sendiri. Instansi HttpClient yang Anda dapatkan dari IHttpClientFactory adalah objek transient yang aman untuk digunakan dalam blok using, namun handler-nya akan dikelola oleh factory untuk penggunaan kembali.

Registrasi IHttpClientFactory

Untuk menggunakan IHttpClientFactory, Anda perlu mendaftarkannya di layanan DI aplikasi Anda. Ini biasanya dilakukan di file Program.cs (atau Startup.cs pada versi lama):

Registrasi IHttpClientFactory di Program.cs

// Program.cs var builder = WebApplication.CreateBuilder(args); // Add services to the container. builder.Services.AddControllers(); // Mendaftarkan IHttpClientFactory ke DI container builder.Services.AddHttpClient(); var app = builder.Build(); // Configure the HTTP request pipeline. app.UseHttpsRedirection(); app.UseAuthorization(); app.MapControllers(); app.Run();

Menggunakan IHttpClientFactory dengan Named Clients

Salah satu cara menggunakan IHttpClientFactory adalah dengan mendaftarkan named clients. Ini berguna ketika aplikasi Anda perlu berkomunikasi dengan beberapa API eksternal yang berbeda, masing-masing dengan konfigurasi spesifiknya sendiri (misalnya, base address, default headers).

Anda bisa mendaftarkan named client seperti ini:

Mendaftarkan Named Client

// Program.cs (lanjutan dari di atas) builder.Services.AddHttpClient("MyApiClient", client => { client.BaseAddress = new Uri("https://api.example.com/"); client.DefaultRequestHeaders.Add("Accept", "application/json"); client.DefaultRequestHeaders.Add("User-Agent", "MalamNgodingApp"); });

Kemudian, Anda bisa menginject IHttpClientFactory ke dalam kelas Anda (misalnya, controller atau service) dan meminta HttpClient dengan nama yang sesuai:

Menggunakan Named Client di Controller

public class MyGoodController : ControllerBase { private readonly IHttpClientFactory _httpClientFactory; public MyGoodController(IHttpClientFactory httpClientFactory) { _httpClientFactory = httpClientFactory; } [HttpGet("external-data-named")] public async Task<IActionResult> GetExternalDataNamed() { // Mengambil HttpClient dari factory dengan nama "MyApiClient" var client = _httpClientFactory.CreateClient("MyApiClient"); var response = await client.GetStringAsync("data"); return Ok(response); } }

Kelebihan dari named clients adalah kemampuan untuk mengisolasi konfigurasi untuk setiap API eksternal. Jika Anda perlu mengubah base address atau default headers untuk satu layanan, Anda hanya perlu mengubahnya di satu tempat saat registrasi.

Menggunakan IHttpClientFactory dengan Typed Clients (Disarankan)

Meskipun named clients sudah lebih baik, pola yang paling disarankan dan sering digunakan adalah Typed Clients. Typed Clients mengintegrasikan HttpClient dengan kelas Anda sendiri yang mengencapsulasi semua logika panggilan API eksternal. Ini meningkatkan testability dan memisahkan tanggung jawab dengan lebih baik.

Membuat Typed Client

Pertama, Anda membuat kelas yang akan bertindak sebagai klien untuk API eksternal tertentu. Kelas ini akan menerima HttpClient melalui konstruktornya.

Contoh kelas Typed Client

public class GitHubService { private readonly HttpClient _httpClient; // HttpClient diinject oleh IHttpClientFactory public GitHubService(HttpClient httpClient) { _httpClient = httpClient; } public async Task<string> GetUserProfile(string username) { var response = await _httpClient.GetStringAsync($"users/{username}"); return response; } // Anda bisa menambahkan method lain untuk API GitHub }

Registrasi Typed Client

Kemudian, Anda mendaftarkan typed client ini ke DI container. Saat mendaftar, Anda juga bisa menambahkan konfigurasi spesifik untuk HttpClient yang akan diinject ke dalamnya.

Mendaftarkan Typed Client

// Program.cs (lanjutan) // Mendaftarkan Typed Client builder.Services.AddHttpClient<GitHubService>(client => { client.BaseAddress = new Uri("https://api.github.com/"); client.DefaultRequestHeaders.Add("Accept", "application/vnd.github.v3+json"); client.DefaultRequestHeaders.Add("User-Agent", "MalamNgodingApp"); });

Secara default, typed client didaftarkan sebagai transient service ke dalam DI container, yang berarti instansi baru akan dibuat setiap kali diminta. Namun, jangan khawatir tentang masalah socket exhaustion; HttpClient yang diinject ke typed client masih dikelola oleh IHttpClientFactory.

Menggunakan Typed Client

Setelah terdaftar, Anda bisa menginject typed client langsung ke dalam kelas yang membutuhkannya, sama seperti layanan DI lainnya:

Menggunakan Typed Client di Controller

public class GitHubController : ControllerBase { private readonly GitHubService _gitHubService; // Typed client langsung diinject ke controller public GitHubController(GitHubService gitHubService) { _gitHubService = gitHubService; } [HttpGet("github-user/{username}")] public async Task<IActionResult> GetGitHubUser(string username) { var userProfile = await _gitHubService.GetUserProfile(username); return Ok(userProfile); } }

Keuntungan utama dari typed clients adalah abstraksi yang jelas. Kelas seperti GitHubService hanya perlu fokus pada logika bisnis untuk berinteraksi dengan GitHub API, tanpa perlu tahu detail implementasi HttpClient. Ini membuat kode lebih bersih, mudah diuji (karena GitHubService bisa di-mock), dan mempermudah perubahan di masa mendatang.

Integrasi dengan Kebijakan Resiliensi (Polly)

Salah satu fitur unggulan dari IHttpClientFactory adalah kemudahan integrasinya dengan pustaka resiliensi seperti Polly. Polly memungkinkan Anda menambahkan kebijakan seperti retries (mencoba kembali jika gagal), circuit breakers (menghentikan panggilan ke layanan yang sedang bermasalah), dan timeout pada panggilan HTTP Anda.

Anda dapat mengaitkan kebijakan Polly langsung saat mendaftarkan klien HTTP Anda:

Mendaftarkan Typed Client dengan Kebijakan Resiliensi Polly

// Pastikan Anda sudah menginstal paket NuGet seperti Microsoft.Extensions.Http.Polly // dan Polly jika belum. builder.Services.AddHttpClient<GitHubService>(client => { client.BaseAddress = new Uri("https://api.github.com/"); client.DefaultRequestHeaders.Add("Accept", "application/vnd.github.v3+json"); client.DefaultRequestHeaders.Add("User-Agent", "MalamNgodingApp"); }) .AddTransientHttpErrorPolicy(policyBuilder => policyBuilder.RetryAsync(3)) // Coba lagi 3 kali jika ada error HTTP sementara .AddTransientHttpErrorPolicy(policyBuilder => policyBuilder.CircuitBreakerAsync( handledEventsAllowedBeforeBreaking: 5, // Izinkan 5 kegagalan sebelum membuka circuit durationOfBreak: TimeSpan.FromSeconds(30) // Buka circuit selama 30 detik ));

Dengan konfigurasi ini, setiap kali GitHubService membuat panggilan HTTP, kebijakan retry dan circuit breaker dari Polly akan diterapkan secara otomatis. Ini adalah cara yang sangat efektif untuk membuat aplikasi Anda lebih resilien terhadap kegagalan layanan eksternal tanpa mengotori logika bisnis Anda dengan detail penanganan kesalahan.

Kesalahan Umum dan Cara Menghindarinya

  • Membuat new HttpClient() terus-menerus: Ini adalah kesalahan terbesar yang harus dihindari. Selalu gunakan IHttpClientFactory di aplikasi ASP.NET Core Anda.
  • Membuang instansi HttpClient yang didapat dari IHttpClientFactory: Instansi HttpClient yang diberikan oleh IHttpClientFactory adalah objek transient, tetapi handler-nya dikelola oleh factory. Menggunakan using (var client = _httpClientFactory.CreateClient()) atau using (var client = _gitHubService._httpClient) umumnya tidak diperlukan dan bahkan bisa membingungkan, meskipun tidak akan menyebabkan socket exhaustion karena factory tetap mengelola handler-nya. Sebaiknya biarkan IHttpClientFactory atau DI container mengelola lifetime-nya.
  • Mengabaikan penanganan error: Meskipun IHttpClientFactory dan Polly membantu dalam hal resiliensi, Anda tetap perlu menangani error spesifik dari API (misalnya, status code 4xx, 5xx) di dalam logika klien Anda.

Kapan Menggunakan HttpClient Langsung vs. IHttpClientFactory?

Untuk aplikasi ASP.NET Core, hampir selalu disarankan untuk menggunakan IHttpClientFactory. Manfaat yang ditawarkannya dalam hal manajemen koneksi, resiliensi, dan kemudahan pengujian jauh melebihi upaya awal untuk mengkonfigurasinya.

Penggunaan HttpClient secara langsung mungkin masih dapat diterima di skenario yang sangat spesifik dan berumur pendek, seperti:

  • Aplikasi konsol sederhana yang hanya membuat beberapa panggilan HTTP dan kemudian berakhir.
  • Script satu kali atau utilitas internal yang tidak berjalan secara terus-menerus atau di bawah beban tinggi.

Namun, jika aplikasi Anda adalah layanan yang berjalan terus-menerus dan melakukan banyak panggilan HTTP, terutama dalam konteks server web, IHttpClientFactory adalah pilihan yang wajib.

Ringkasan

Memahami dan mengimplementasikan IHttpClientFactory adalah keterampilan esensial bagi setiap developer ASP.NET Core. Ini bukan hanya tentang menghindari socket exhaustion, tetapi juga tentang membangun klien HTTP yang lebih terstruktur, resilien, dan mudah diuji. Dengan memanfaatkan named clients atau typed clients, Anda dapat secara signifikan meningkatkan kualitas dan keandalan interaksi aplikasi Anda dengan layanan eksternal. Jangan lupa bahwa IHttpClientFactory juga menjadi fondasi yang kuat untuk menambahkan kebijakan resiliensi seperti retries dan circuit breakers dengan Polly, memastikan aplikasi Anda tetap stabil bahkan saat menghadapi kendala jaringan atau kegagalan layanan.