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:
- Socket Exhaustion: Setiap instansi
HttpClientakan membuka koneksi soket baru. Jika Anda sering membuat instansiHttpClientdan 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 statusTIME_WAITuntuk beberapa saat, mencegah soket baru dibuka. Akibatnya, aplikasi tidak dapat lagi melakukan panggilan HTTP dan akan mengalami timeout atau error koneksi. - DNS Changes Not Respected: Instansi
HttpClientdimaksudkan untuk berumur panjang. Jika Anda membuat instansi baru terlalu sering, Anda mungkin mengalami masalah dengan pembaruan DNS.HttpClientakan melakukan resolusi DNS sekali saat instansi dibuat dan menyimpan hasilnya. Jika alamat IP dari layanan eksternal berubah (misalnya, karena auto-scaling atau pembaruan infrastruktur), instansiHttpClientyang 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
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
HttpClientyang 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
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
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
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
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
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
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
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 gunakanIHttpClientFactorydi aplikasi ASP.NET Core Anda. - Membuang instansi
HttpClientyang didapat dariIHttpClientFactory: InstansiHttpClientyang diberikan olehIHttpClientFactoryadalah objek transient, tetapi handler-nya dikelola oleh factory. Menggunakanusing (var client = _httpClientFactory.CreateClient())atauusing (var client = _gitHubService._httpClient)umumnya tidak diperlukan dan bahkan bisa membingungkan, meskipun tidak akan menyebabkan socket exhaustion karena factory tetap mengelola handler-nya. Sebaiknya biarkanIHttpClientFactoryatau DI container mengelola lifetime-nya. - Mengabaikan penanganan error: Meskipun
IHttpClientFactorydan 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.
Seri Belajar .NET Core:
← Sebelumnya: Dependency Injection Lifetime: Transient Scoped Singleton
→ Selanjutnya: BackgroundService dan Hosted Service di ASP.NET Core