Pola lapisan anti-korupsi

Niat

Pola anti-korupsi lapisan (ACL) bertindak sebagai lapisan mediasi yang menerjemahkan semantik model domain dari satu sistem ke sistem lain. Ini menerjemahkan model konteks hulu dibatasi (monolit) ke dalam model yang sesuai dengan konteks hilir dibatasi (microservice) sebelum mengkonsumsi kontrak komunikasi yang ditetapkan oleh tim hulu. Pola ini mungkin berlaku ketika konteks hilir dibatasi berisi subdomain inti, atau model hulu adalah sistem warisan yang tidak dapat dimodifikasi. Ini juga mengurangi risiko transformasi dan gangguan bisnis dengan mencegah perubahan pada penelepon ketika panggilan mereka harus diarahkan secara transparan ke sistem target.

Motivasi

Selama proses migrasi, ketika aplikasi monolitik dimigrasi ke layanan mikro, mungkin ada perubahan dalam semantik model domain dari layanan yang baru dimigrasi. Ketika fitur dalam monolit diperlukan untuk memanggil layanan mikro ini, panggilan harus dialihkan ke layanan yang dimigrasi tanpa memerlukan perubahan apa pun pada layanan panggilan. Pola ACL memungkinkan monolit untuk memanggil layanan mikro secara transparan dengan bertindak sebagai adaptor atau lapisan fasad yang menerjemahkan panggilan ke semantik yang lebih baru.

Penerapan

Pertimbangkan untuk menggunakan pola ini saat:

• Aplikasi monolitik Anda yang ada harus berkomunikasi dengan fungsi yang telah dimigrasi ke layanan mikro, dan model domain layanan migrasi serta semantik berbeda dari fitur aslinya.

• Dua sistem memiliki semantik yang berbeda dan perlu bertukar data, tetapi tidak praktis untuk memodifikasi satu sistem agar kompatibel dengan sistem lainnya.

• Anda ingin menggunakan pendekatan yang cepat dan disederhanakan untuk menyesuaikan satu sistem ke sistem lain dengan dampak minimal.

• Aplikasi Anda berkomunikasi dengan sistem eksternal.

Masalah dan pertimbangan

• Dependensi tim:Ketika layanan yang berbeda dalam sistem dimiliki oleh tim yang berbeda, semantik model domain baru dalam layanan yang dimigrasi dapat menyebabkan perubahan dalam sistem panggilan. Namun, tim mungkin tidak dapat membuat perubahan ini dengan cara yang terkoordinasi, karena mereka mungkin memiliki prioritas lain. ACL memisahkan panggilan dan menerjemahkan panggilan untuk mencocokkan semantik layanan baru, sehingga menghindari kebutuhan penelepon untuk membuat perubahan dalam sistem saat ini.

• Overhead operasional:Pola ACL membutuhkan upaya tambahan untuk mengoperasikan dan memelihara. Pekerjaan ini termasuk mengintegrasikan ACL dengan alat pemantauan dan peringatan, proses rilis, dan proses integrasi berkelanjutan dan pengiriman berkelanjutan (CI/CD).

• Titik kegagalan tunggal:Setiap kegagalan dalam ACL dapat membuat layanan target tidak terjangkau, menyebabkan masalah aplikasi. Untuk mengurangi masalah ini, Anda harus membangun kemampuan coba ulang dan pemutus sirkuit. Lihatcoba lagi dengan backoffdanpemutus sirkuitpola untuk memahami lebih lanjut tentang pilihan ini. Menyiapkan peringatan dan logging yang sesuai akan meningkatkan waktu rata-rata untuk resolusi (MTTR).

• Utang teknis:Sebagai bagian dari strategi migrasi atau modernisasi Anda, pertimbangkan apakah ACL akan menjadi solusi sementara atau sementara, atau solusi jangka panjang. Jika ini adalah solusi sementara, Anda harus mencatat ACL sebagai utang teknis dan menonaktifkannya setelah semua penelepon yang bergantung telah dimigrasi.

• Latensi:Lapisan tambahan dapat memperkenalkan latensi karena konversi permintaan dari satu antarmuka ke antarmuka lainnya. Kami menyarankan Anda menentukan dan menguji toleransi kinerja dalam aplikasi yang sensitif terhadap waktu respons sebelum Anda menerapkan ACL ke lingkungan produksi.

• Penskalaan bottleneck:Dalam aplikasi beban tinggi di mana layanan dapat menskalakan ke beban puncak, ACL dapat menjadi hambatan dan dapat menyebabkan masalah penskalaan. Jika layanan target skala sesuai permintaan, Anda harus merancang ACL untuk skala yang sesuai.

• Implementasi khusus layanan atau bersama:Anda dapat merancang ACL sebagai objek bersama untuk mengonversi dan mengarahkan panggilan ke beberapa layanan atau kelas khusus layanan. Memperhitungkan latensi, penskalaan, dan toleransi kegagalan saat Anda menentukan jenis implementasi untuk ACL.

Implementasi

Anda dapat menerapkan ACL di dalam aplikasi monolitik Anda sebagai kelas yang khusus untuk layanan yang sedang dimigrasi, atau sebagai layanan independen. ACL harus dinonaktifkan setelah semua layanan dependen telah bermigrasi ke arsitektur layanan mikro.

Arsitektur tingkat tinggi

Dalam contoh arsitektur berikut, aplikasi monolitik memiliki tiga layanan: layanan pengguna, layanan keranjang, dan layanan akun. Layanan keranjang tergantung pada layanan pengguna, dan aplikasi menggunakan database relasional monolitik.

Dalam arsitektur berikut, layanan pengguna telah dimigrasi ke layanan mikro baru. Layanan keranjang memanggil layanan pengguna, tetapi implementasinya tidak lagi tersedia dalam monolit.  Kemungkinan juga antarmuka layanan yang baru dimigrasi tidak akan cocok dengan antarmuka sebelumnya, ketika berada di dalam aplikasi monolitik.

Jika layanan keranjang harus memanggil layanan pengguna yang baru dimigrasi secara langsung, ini akan memerlukan perubahan pada layanan keranjang dan pengujian menyeluruh terhadap aplikasi monolitik. Hal ini dapat meningkatkan risiko transformasi dan gangguan bisnis. Tujuannya adalah untuk meminimalkan perubahan pada fungsi aplikasi monolitik yang ada.

Dalam hal ini, kami menyarankan Anda memperkenalkan ACL antara layanan pengguna lama dan layanan pengguna yang baru dimigrasi. ACL berfungsi sebagai adaptor atau fasad yang mengubah panggilan ke antarmuka yang lebih baru. ACL dapat diimplementasikan di dalam aplikasi monolitik sebagai kelas (misalnya,UserServiceFacadeatauUserServiceAdapter) yang khusus untuk layanan yang dimigrasi. Lapisan anti-korupsi harus dinonaktifkan setelah semua layanan dependen telah bermigrasi ke arsitektur layanan mikro.

Implementasi menggunakanAWSjasa

Diagram berikut menunjukkan bagaimana Anda dapat menerapkan contoh ACL ini dengan menggunakanAWSlayanan.

Pengguna microservice dimigrasi keluar dari aplikasi monolitik ASP.NET dan digunakan sebagaiAWS Lambdafungsi pada AWS. Panggilan ke fungsi Lambda dialihkan melaluiGerbang API Amazon. ACL dikerahkan dalam monolit untuk menerjemahkan panggilan untuk beradaptasi dengan semantik microservice pengguna.

KapanProgram.csmemanggil layanan pengguna (UserInMonolith.cs) di dalam monolit, panggilan dialihkan ke ACL (UserServiceACL.cs). ACL menerjemahkan panggilan ke semantik dan antarmuka baru, dan memanggil microservice melalui endpoint API Gateway. Penelepon (Program.cs) tidak menyadari terjemahan dan routing yang terjadi di layanan pengguna dan ACL. Karena penelepon tidak menyadari perubahan kode, ada sedikit gangguan bisnis dan mengurangi risiko transformasi.

Kode sampel

Cuplikan kode berikut memberikan perubahan pada layanan asli dan implementasiUserServiceACL.cs. Ketika permintaan diterima, layanan pengguna asli memanggil ACL. ACL mengubah objek sumber agar sesuai dengan antarmuka layanan yang baru dimigrasi, memanggil layanan, dan mengembalikan respons ke pemanggil.

public class UserInMonolith: IUserInMonolith
{
    private readonly IACL _userServiceACL;
    public UserInMonolith(IACL userServiceACL) => (_userServiceACL) = (userServiceACL);
    public async Task<HttpStatusCode> UpdateAddress(UserDetails userDetails)
    {
        //Wrap the original object in the derived class 
        var destUserDetails = new UserDetailsWrapped("user", userDetails);
        //Logic for updating address has been moved to a microservice
        return await _userServiceACL.CallMicroservice(destUserDetails);
    }
}

public class UserServiceACL: IACL
{
    static HttpClient _client = new HttpClient();
    private static string _apiGatewayDev = string.Empty;

    public UserServiceACL()
    {
        IConfiguration config = new ConfigurationBuilder().AddJsonFile(AppContext.BaseDirectory + "../../../config.json").Build();
        _apiGatewayDev = config["APIGatewayURL:Dev"];
        _client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
    }
    public async Task<HttpStatusCode> CallMicroservice(ISourceObject details)
    {
        _apiGatewayDev +=  "/" + details.ServiceName;
        Console.WriteLine(_apiGatewayDev);

        var userDetails = details as UserDetails;
        var userMicroserviceModel = new UserMicroserviceModel();
        userMicroserviceModel.UserId = userDetails.UserId;
        userMicroserviceModel.Address = userDetails.AddressLine1 + ", " + userDetails.AddressLine2;
        userMicroserviceModel.City = userDetails.City;
        userMicroserviceModel.State = userDetails.State;
        userMicroserviceModel.Country = userDetails.Country;

        if (Int32.TryParse(userDetails.ZipCode, out int zipCode))
        {
            userMicroserviceModel.ZipCode = zipCode;
            Console.WriteLine("Updated zip code");
        }
        else
        {
            Console.WriteLine("String could not be parsed.");
            return HttpStatusCode.BadRequest;
        }

        var jsonString = JsonSerializer.Serialize<UserMicroserviceModel>(userMicroserviceModel);
        var payload = JsonSerializer.Serialize(userMicroserviceModel);
        var content = new StringContent(payload, Encoding.UTF8, "application/json");

        var response = await _client.PostAsync(_apiGatewayDev, content);
        return response.StatusCode;
    }  
}

GitHubrepositori

Untuk implementasi lengkap arsitektur sampel untuk pola ini, lihatGitHubrepositori dihttps://github.com/aws-samples/anti-corruption-layer-pattern.

Konten terkait

• Pola ara pencekik

• Pola pemutus sirkuit

• Coba lagi dengan pola backoff