Pola Pemutus Sirkuit

handel kesalahan yang mungkin memerlukan waktu yang bervariasi untuk pulih, saat terhubung ke layanan atau sumber daya jarak jauh. Hal ini dapat meningkatkan stabilitas dan ketahanan suatu aplikasi.

Konteks dan masalah

Dalam lingkungan terdistribusi, panggilan ke sumber daya dan layanan jarak jauh bisa gagal karena kesalahan sementara, seperti koneksi jaringan yang lambat, batas waktu, atau sumber daya yang terlalu berkomitmen atau sementara tidak tersedia. Kesalahan ini biasanya memperbaiki diri setelah waktu yang singkat, dan aplikasi cloud yang kuat harus siap untuk menanganinya dengan menggunakan strategi seperti pola Retry.

Namun, mungkin ada juga situasi di mana kesalahan disebabkan oleh peristiwa yang tidak terduga, dan itu mungkin memakan waktu lebih lama untuk diperbaiki. Keparahan kesalahan ini dapat berkisar mulai dari hilangnya sebagian konektivitas hingga kegagalan total layanan. Dalam situasi ini mungkin tidak ada gunanya bagi aplikasi untuk terus mencoba kembali operasi yang tidak mungkin berhasil, dan sebaliknya aplikasi harus dengan cepat menerima bahwa operasi telah gagal dan menangani kegagalan ini sesuai dengan itu.

Selain itu, jika layanan sangat sibuk, kegagalan di satu bagian sistem dapat menyebabkan kegagalan berjenjang. Misalnya, operasi yang memanggil layanan dapat dikonfigurasi untuk menerapkan batas waktu, dan membalas dengan pesan kegagalan jika layanan gagal merespons dalam periode ini. Namun, strategi ini dapat menyebabkan banyak permintaan bersamaan ke operasi yang sama menjadi diblokir sampai periode batas waktu berakhir. Permintaan yang diblokir ini mungkin menyimpan sumber daya sistem penting seperti memori, utas, koneksi database, dan sebagainya, yang dapat menyebabkan kegagalan berjenjang. Akibatnya, sumber daya ini bisa habis, menyebabkan kegagalan bagian lain yang mungkin tidak terkait dari sistem yang perlu menggunakan sumber daya yang sama. Dalam situasi ini, akan lebih baik operasi segera gagal, dan hanya berusaha untuk memanggil layanan jika ada kemungkinan akan berhasil. Perhatikan bahwa menetapkan batas waktu yang lebih pendek dapat membantu menyelesaikan masalah ini, tetapi batas waktu seharusnya tidak begitu singkat sehingga operasi gagal pada waktu tersebut, bahkan jika permintaan ke layanan pada akhirnya akan berhasil.

Solusi

Pola Circuit Breaker, yang dipopulerkan oleh Michael Nygard dalam bukunya, Release It!, Dapat mencegah aplikasi berulang kali mencoba untuk menjalankan operasi yang kemungkinan akan gagal. Membiarkannya berlanjut tanpa menunggu kesalahan diperbaiki atau membuang-buang siklus CPU sementara itu menentukan bahwa kesalahan itu bertahan lama. Pola Circuit Breaker juga memungkinkan aplikasi untuk mendeteksi apakah kesalahan telah diselesaikan. Jika masalah tampaknya telah diperbaiki, aplikasi dapat mencoba untuk memanggil operasi.

Tujuan dari pola Circuit Breaker berbeda dari pola Retry. Pola Retry memungkinkan aplikasi untuk mencoba kembali operasi dengan harapan bahwa itu akan berhasil. Pola Circuit Breaker mencegah aplikasi melakukan operasi yang kemungkinan akan gagal. Sebuah aplikasi dapat menggabungkan kedua pola ini dengan menggunakan pola Retry untuk memanggil operasi melalui pemutus sirkuit. Namun, percobaan ulang logika harus peka terhadap pengecualian yang dikembalikan oleh pemutus sirkuit dan meninggalkan upaya coba ulang jika pemutus sirkuit menunjukkan bahwa kesalahan tidak bersifat sementara.

Pemutus sirkuit bertindak sebagai proxy untuk operasi yang mungkin gagal. Proxy harus memantau jumlah kegagalan yang telah terjadi baru-baru ini, dan menggunakan informasi ini untuk memutuskan apakah akan mengizinkan operasi untuk melanjutkan, atau hanya mengembalikan pengecualian segera.

Proxy dapat diimplementasikan sebagai mesin status dengan kondisi berikut yang meniru kegunaan pemutus sirkuit listrik:

• Ditutup: Permintaan dari aplikasi dirutekan ke operasi. Proxy mempertahankan hitungan jumlah kegagalan baru-baru ini, dan jika panggilan ke operasi tidak berhasil, proxy meningkatkan jumlah ini. Jika jumlah kegagalan baru-baru ini melebihi ambang batas yang ditentukan dalam jangka waktu tertentu, proxy ditempatkan dalam kondisi Terbuka. Pada titik ini proxy memulai timer batas waktu, dan ketika timer ini berakhir proxy ditempatkan ke dalam status Half-Open.

  Tujuan dari timeout timer adalah untuk memberikan waktu kepada sistem untuk memperbaiki masalah yang menyebabkan kegagalan sebelum memungkinkan aplikasi untuk mencoba melakukan operasi lagi.

• Terbuka: Permintaan dari aplikasi segera gagal dan pengecualian dikembalikan ke aplikasi.

• Setengah Terbuka: Sejumlah permintaan terbatas dari aplikasi diizinkan untuk melewati dan memanggil operasi. Jika permintaan ini berhasil, ini diasumsikan bahwa kesalahan yang sebelumnya menyebabkan kegagalan telah diperbaiki dan pemutus sirkuit beralih ke keadaan Tertutup (penghitung kegagalan diatur ulang). Jika ada permintaan yang gagal, pemutus sirkuit mengasumsikan bahwa kesalahan masih ada sehingga kembali ke status Terbuka dan memulai ulang timer waktu habis untuk memberi sistem jangka waktu lebih lanjut untuk pulih dari kegagalan.

  Status Setengah Terbuka berguna untuk mencegah layanan pemulihan tiba-tiba dibanjiri permintaan. Ketika layanan pulih, mungkin dapat mendukung volume permintaan yang terbatas sampai pemulihan selesai, tetapi sementara pemulihan sedang berlangsung, banjir pekerjaan dapat menyebabkan layanan keluar atau gagal lagi.

Dalam gambar, penghitung kegagalan yang digunakan oleh status Tertutup berbasis waktu. Ini secara otomatis diatur ulang pada interval periodik. Ini membantu mencegah pemutus sirkuit memasuki status Terbuka jika mengalami kegagalan sesekali. Ambang kegagalan yang berjarak sebagai pemutus sirkuit ke dalam keadaan Terbuka hanya tercapai ketika sejumlah kegagalan tertentu terjadi selama interval tertentu. Penghitung yang digunakan oleh statusSetengah Terbuka mencatat jumlah upaya yang berhasil untuk memanggil operasi. Pemutus sirkuit kembali ke status Tertutup setelah sejumlah permohonan operasi berturut-turut telah berhasil. Jika ada permohonan yang gagal, pemutus sirkuit segera memasuki keadaan Terbuka dan penghitung keberhasilan akan diatur ulang saat berikutnya memasuki status Setengah Terbuka.

Bagaimana sistem pemulihan ditangani secara eksternal, mungkin dengan memulihkan atau memulai ulang komponen yang gagal atau memperbaiki koneksi jaringan.

Pola Pemutus Sirkuit memberikan stabilitas saat sistem pulih dari kegagalan dan meminimalkan dampak pada performa. Ini dapat membantu mempertahankan waktu respons sistem dengan menolak permintaan dengan cepat untuk operasi yang cenderung gagal, bukan menunggu batas waktu operasi, atau tidak pernah kembali. Jika pemutus sirkuit menimbulkan peristiwa setiap kali berubah status, informasi ini dapat digunakan untuk memantau kesehatan bagian dari sistem yang dilindungi oleh pemutus sirkuit, atau untuk mengingatkan administrator ketika pemutus sirkuit melakukan perjalanan ke statusTerbuka.

Pola ini dapat disesuaikan dan dapat diadaptasi sesuai dengan jenis kemungkinan kegagalan. Misalnya, Anda dapat menerapkan timer batas waktu yang meningkat ke pemutus sirkuit. Anda dapat menempatkan pemutus sirkuit di status Terbuka selama beberapa detik pada awalnya, dan kemudian jika kegagalan belum diselesaikan, tingkatkan batas waktu menjadi beberapa menit, dan seterusnya. Dalam beberapa kasus, daripada status Terbukakembali gagal dan menaikkan pengecualian, mungkin lebih berguna untuk mengembalikan nilai default yang berarti bagi aplikasi.

Masalah dan pertimbangan

Anda harus mempertimbangkan poin berikut saat memutuskan cara menerapkan pola ini:

Penanganan pengecualian. Aplikasi yang meminta operasi melalui pemutus sirkuit harus siap untuk menangani pengecualian yang diajukan jika operasi tidak tersedia. Cara pengecualian ditangani akan jadi spesifik aplikasi. Misalnya, aplikasi dapat menurunkan fungsinya sementara, meminta operasi alternatif untuk mencoba melakukan tugas yang sama atau mendapatkan data yang sama, atau melaporkan pengecualian kepada pengguna dan meminta mereka untuk mencoba lagi nanti.

Jenis pengecualian. Permintaan mungkin gagal karena berbagai alasan, beberapa di antaranya mungkin menunjukkan jenis kegagalan yang lebih parah daripada yang lain. Misalnya, permintaan mungkin gagal karena layanan jarak jauh telah macet dan akan memakan waktu beberapa menit untuk pulih, atau karena batas waktu yang disebabkan oleh layanan yang kelebihan beban sementara. Pemutus sirkuit mungkin dapat memeriksa jenis pengecualian yang terjadi dan menyesuaikan strateginya tergantung pada sifat pengecualian ini. Misalnya, mungkin memerlukan sejumlah besar pengecualian batas waktu untuk perjalanan pemutus sirkuit ke status Buka dibandingkan dengan jumlah kegagalan karena layanan yang benar-benar tidak tersedia.

Pengelogan. Pemutus sirkuit harus mencatat semua permintaan yang gagal (dan mungkin permintaan yang berhasil) untuk memungkinkan administrator memantau kesehatan operasi.

Pemulihan. Anda harus mengkonfigurasi pemutus sirkuit agar sesuai dengan pola pemulihan operasi yang mungkin dilindunginya. Misalnya, jika pemutus sirkuit tetap dalam status Terbuka untuk waktu yang lama, itu bisa menimbulkan pengecualian bahkan jika alasan kegagalan telah diselesaikan. Demikian pula, pemutus sirkuit dapat berfluktuasi dan mengurangi waktu respons aplikasi jika beralih dari status Terbuka ke keadaan Setengah Terbuka terlalu cepat.

Pengujian Operasi gagal. Dalam keadaan Buka, daripada menggunakan timer untuk menentukan kapan harus beralih ke status Setengah Terbuka, pemutus sirkuit dapat secara berkala melakukan ping ke layanan jarak jauh atau sumber daya untuk menentukan apakah itu tersedia lagi. Ping ini dapat berupa upaya untuk memanggil operasi yang sebelumnya gagal, atau dapat menggunakan operasi khusus yang disediakan oleh layanan jarak jauh khusus untuk menguji kesehatan layanan, seperti yang dijelaskan oleh pola Pemantauan Titik Akhir Kesehatan.

Penggantian Manual. Dalam sistem di mana waktu pemulihan untuk operasi yang gagal sangat bervariasi, bermanfaat untuk menyediakan opsi reset manual yang memungkinkan administrator untuk menutup pemutus sirkuit (dan mengatur ulang penghitung kegagalan). Demikian pula, administrator dapat memaksa pemutus sirkuit ke dalam status Buka (dan memulai ulang timer batas waktu) jika operasi yang dilindungi oleh pemutus sirkuit untuk sementara tidak tersedia.

Konkurensi. Pemutus sirkuit yang sama dapat diakses oleh sejumlah besar instans aplikasi pada waktu yang bersamaan. Implementasi tidak boleh memblokir permintaan yang bersamaan atau menambahkan overhead yang berlebihan untuk setiap panggilan ke operasi.

Diferensiasi Sumber Daya. Berhati-hatilah saat menggunakan pemutus sirkuit tunggal untuk satu jenis sumber daya jika mungkin ada beberapa penyedia independen yang mendasarinya. Misalnya, di penyimpanan data yang berisi beberapa pecahan, satu pecahan mungkin dapat diakses sepenuhnya sementara yang lain mengalami masalah sementara. Jika respons kesalahan dalam skenario ini digabungkan, aplikasi mungkin mencoba mengakses beberapa pecahan bahkan ketika kegagalan sangat mungkin, sementara akses ke pecahan lain mungkin diblokir meskipun kemungkinan akan berhasil.

Akselerasi Sirkuit terputus. Kadang-kadang respon kegagalan dapat berisi informasi yang cukup untuk pemutus sirkuit untuk perjalanan segera dan tetap tersandung untuk jumlah minimum waktu. Misalnya, respons kesalahan dari sumber daya bersama yang kelebihan beban dapat menunjukkan bahwa segera mencoba ulang tidak dianjurkan dan bahwa aplikasi harus mencoba lagi dalam beberapa menit.

Memutar ulang permintaan yang gagal. Dalam status Terbuka, alih-alih hanya gagal dengan cepat, pemutus sirkuit juga dapat merekam rincian setiap permintaan ke jurnal dan mengatur agar permintaan ini diputar ulang ketika sumber daya atau layanan jarak jauh tersedia.

Batas Waktu yang Tidak Tepat pada Layanan Eksternal. Pemutus sirkuit mungkin tidak dapat sepenuhnya melindungi aplikasi dari operasi yang gagal dalam layanan eksternal yang dikonfigurasi dengan periode batas waktu yang lama. Jika batas waktu terlalu lama, benang yang menjalankan pemutus sirkuit mungkin diblokir untuk waktu yang lama sebelum pemutus sirkuit menunjukkan bahwa operasi telah gagal. Pada saat ini, banyak instans aplikasi lain mungkin juga mencoba untuk memanggil layanan melalui pemutus sirkuit dan mengikat sejumlah besar utas sebelum semuanya gagal.

Kapan menggunakan pola ini

Gunakan pola ini:

• Untuk mencegah aplikasi mencoba memanggil layanan jarak jauh atau mengakses sumber daya bersama jika operasi ini sangat mungkin gagal.

Pola ini tidak direkomendasikan:

• Untuk menangani akses ke sumber daya privat lokal dalam aplikasi, seperti struktur data dalam memori. Dalam lingkungan ini, menggunakan pemutus sirkuit akan menambah overhead ke sistem Anda.
• Sebagai pengganti untuk menangani pengecualian dalam logika bisnis aplikasi Anda.

Desain beban kerja

Arsitek harus mengevaluasi bagaimana pola Circuit Breaker dapat digunakan dalam desain beban kerja mereka untuk mengatasi tujuan dan prinsip yang tercakup dalam pilar Azure Well-Architected Framework. Contohnya:

Seperti halnya keputusan desain apa pun, pertimbangkan tradeoff terhadap tujuan pilar lain yang mungkin diperkenalkan dengan pola ini.

Contoh

Dalam aplikasi web, beberapa halaman diisi dengan data yang diambil dari layanan eksternal. Jika sistem menerapkan penembolokan minimal, terlalu banyak klik ke halaman-halaman ini akan menyebabkan perjalanan pulang pergi ke layanan. Koneksi dari aplikasi web ke layanan dapat dikonfigurasi dengan periode batas waktu (biasanya 60 detik), dan jika layanan tidak merespons saat ini logika di setiap halaman web akan menganggap bahwa layanan tidak tersedia dan memberikan pengecualian.

Namun, jika layanan gagal dan sistem sangat sibuk, pengguna dapat dipaksa untuk menunggu hingga 60 detik sebelum pengecualian terjadi. Akhirnya sumber daya seperti memori, koneksi, dan utas dapat habis, mencegah pengguna lain terhubung ke sistem, bahkan jika mereka tidak mengakses halaman yang mengambil data dari layanan.

Penskalaan sistem dengan menambahkan server web lebih lanjut dan menerapkan penyeimbangan beban yang mungkin tertunda ketika sumber daya menjadi habis, tetapi itu tidak akan menyelesaikan masalah karena permintaan pengguna masih tidak responsif dan semua server web pada akhirnya bisa kehabisan sumber daya.

Membungkus logika yang terhubung ke layanan dan mengambil data dalam pemutus sirkuit dapat membantu memecahkan masalah ini dan menangani kegagalan layanan dengan lebih elegan. Permintaan pengguna masih akan gagal, tetapi mereka akan gagal lebih cepat dan sumber daya tidak akan diblokir.

Kelas CircuitBreaker menyimpan informasi status tentang pemutus sirkuit dalam objek yang mengimplementasikan antarmuka yang ICircuitBreakerStateStore ditunjukkan dalam kode berikut.

interface ICircuitBreakerStateStore
{
  CircuitBreakerStateEnum State { get; }

  Exception LastException { get; }

  DateTime LastStateChangedDateUtc { get; }

  void Trip(Exception ex);

  void Reset();

  void HalfOpen();

  bool IsClosed { get; }
}

Properti State menunjukkan keadaan pemutus sirkuit saat ini, dan akan Terbuka, Setengah Terbuka, atau Tertutup seperti yang didefinisikan oleh CircuitBreakerStateEnum enumeration. Properti IsClosed harus benar jika pemutus sirkuit ditutup, tetapi salah jika terbuka atau setengah terbuka. Metode ini Trip mengalihkan keadaan pemutus sirkuit ke keadaan terbuka dan mencatat pengecualian yang menyebabkan perubahan keadaan, bersama dengan tanggal dan waktu pengecualian terjadi. LastException dan LastStateChangedDateUtc properti mengembalikan informasi ini. Metode ini Reset menutup pemutus sirkuit, dan metode ini HalfOpen mengatur pemutus sirkuit menjadi setengah terbuka.

Kelas InMemoryCircuitBreakerStateStore pada contoh berisi implementasi ICircuitBreakerStateStore antarmuka. Kelas CircuitBreaker membuat contoh instans kelas ini untuk menahan keadaan pemutus sirkuit.

Metode ExecuteAction di CircuitBreaker kelas membungkus operasi, yang ditentukan sebagai Action delegasi. Jika pemutus sirkuit ditutup, ExecuteAction panggil Action delegasi. Jika operasi gagal, penangan pengecualian memanggil TrackException, yang mengatur keadaan pemutus sirkuit untuk dibuka. Contoh kode berikut menyoroti alur ini.

public class CircuitBreaker
{
  private readonly ICircuitBreakerStateStore stateStore =
    CircuitBreakerStateStoreFactory.GetCircuitBreakerStateStore();

  private readonly object halfOpenSyncObject = new object ();
  ...
  public bool IsClosed { get { return stateStore.IsClosed; } }

  public bool IsOpen { get { return !IsClosed; } }

  public void ExecuteAction(Action action)
  {
    ...
    if (IsOpen)
    {
      // The circuit breaker is Open.
      ... (see code sample below for details)
    }

    // The circuit breaker is Closed, execute the action.
    try
    {
      action();
    }
    catch (Exception ex)
    {
      // If an exception still occurs here, simply
      // retrip the breaker immediately.
      this.TrackException(ex);

      // Throw the exception so that the caller can tell
      // the type of exception that was thrown.
      throw;
    }
  }

  private void TrackException(Exception ex)
  {
    // For simplicity in this example, open the circuit breaker on the first exception.
    // In reality this would be more complex. A certain type of exception, such as one
    // that indicates a service is offline, might trip the circuit breaker immediately.
    // Alternatively it might count exceptions locally or across multiple instances and
    // use this value over time, or the exception/success ratio based on the exception
    // types, to open the circuit breaker.
    this.stateStore.Trip(ex);
  }
}

Contoh berikut menunjukkan kode (dihilangkan dari contoh sebelumnya) yang dijalankan jika pemutus sirkuit tidak ditutup. Ini pertama kali memeriksa apakah pemutus sirkuit telah terbuka untuk jangka waktu yang lebih lama dari waktu yang ditentukan oleh bidang lokal OpenToHalfOpenWaitTime di CircuitBreaker kelas. Jika ini masalahnya, metode ini ExecuteAction mengatur pemutus sirkuit menjadi setengah terbuka, lalu mencoba melakukan operasi yang ditentukan oleh Action delegasi.

Jika operasi berhasil, pemutus sirkuit diatur ulang ke keadaan tertutup. Jika operasi gagal, itu berjalan kembali ke keadaan terbuka dan waktu pengecualian terjadi diperbarui sehingga pemutus sirkuit akan menunggu periode lebih lanjut sebelum mencoba melakukan operasi lagi.

Jika pemutus sirkuit hanya terbuka untuk waktu yang singkat, kurang dari OpenToHalfOpenWaitTime nilainya, metode ini ExecuteAction hanya melemparkan CircuitBreakerOpenException pengecualian dan mengembalikan kesalahan yang menyebabkan pemutus sirkuit beralih ke keadaan terbuka.

Selain itu, ia menggunakan kunci untuk mencegah pemutus sirkuit mencoba melakukan panggilan bersamaan ke operasi saat setengah terbuka. Upaya bersamaan untuk memanggil operasi akan ditangani seolah-olah pemutus sirkuit terbuka, dan itu akan gagal dengan pengecualian seperti yang dijelaskan kemudian.

    ...
    if (IsOpen)
    {
      // The circuit breaker is Open. Check if the Open timeout has expired.
      // If it has, set the state to HalfOpen. Another approach might be to
      // check for the HalfOpen state that had be set by some other operation.
      if (stateStore.LastStateChangedDateUtc + OpenToHalfOpenWaitTime < DateTime.UtcNow)
      {
        // The Open timeout has expired. Allow one operation to execute. Note that, in
        // this example, the circuit breaker is set to HalfOpen after being
        // in the Open state for some period of time. An alternative would be to set
        // this using some other approach such as a timer, test method, manually, and
        // so on, and check the state here to determine how to handle execution
        // of the action.
        // Limit the number of threads to be executed when the breaker is HalfOpen.
        // An alternative would be to use a more complex approach to determine which
        // threads or how many are allowed to execute, or to execute a simple test
        // method instead.
        bool lockTaken = false;
        try
        {
          Monitor.TryEnter(halfOpenSyncObject, ref lockTaken);
          if (lockTaken)
          {
            // Set the circuit breaker state to HalfOpen.
            stateStore.HalfOpen();

            // Attempt the operation.
            action();

            // If this action succeeds, reset the state and allow other operations.
            // In reality, instead of immediately returning to the Closed state, a counter
            // here would record the number of successful operations and return the
            // circuit breaker to the Closed state only after a specified number succeed.
            this.stateStore.Reset();
            return;
          }
        }
        catch (Exception ex)
        {
          // If there's still an exception, trip the breaker again immediately.
          this.stateStore.Trip(ex);

          // Throw the exception so that the caller knows which exception occurred.
          throw;
        }
        finally
        {
          if (lockTaken)
          {
            Monitor.Exit(halfOpenSyncObject);
          }
        }
      }
      // The Open timeout hasn't yet expired. Throw a CircuitBreakerOpen exception to
      // inform the caller that the call was not actually attempted,
      // and return the most recent exception received.
      throw new CircuitBreakerOpenException(stateStore.LastException);
    }
    ...

Untuk menggunakan CircuitBreaker objek untuk melindungi operasi, aplikasi membuat instans CircuitBreaker kelas dan memanggil ExecuteAction metode, menentukan operasi yang akan dilakukan sebagai parameter. Aplikasi harus siap untuk menangkap CircuitBreakerOpenException pengecualian jika operasi gagal karena pemutus sirkuit terbuka. Kode berikut menunjukkan contoh:

var breaker = new CircuitBreaker();

try
{
  breaker.ExecuteAction(() =>
  {
    // Operation protected by the circuit breaker.
    ...
  });
}
catch (CircuitBreakerOpenException ex)
{
  // Perform some different action when the breaker is open.
  // Last exception details are in the inner exception.
  ...
}
catch (Exception ex)
{
  ...
}

Sumber daya terkait

Beberapa pola berikut mungkin juga berguna saat menerapkan pola ini:

• Pola aplikasi web yang andal menunjukkan kepada Anda cara menerapkan pola pemutus sirkuit ke aplikasi web yang berkonvergsi di cloud.

• Pola percobaan ulang. Menjelaskan bagaimana aplikasi dapat menangani kegagalan sementara yang diantisipasi ketika mencoba terhubung ke layanan atau sumber daya jaringan dengan secara transparan mencoba kembali operasi yang sebelumnya gagal.

• Pola Pemantauan Titik Akhir Kesehatan. Pemutus sirkuit mungkin dapat menguji kesehatan layanan dengan mengirimkan permintaan ke titik akhir yang diekspos oleh layanan. Layanan harus mengembalikan informasi yang menunjukkan statusnya.