Membina microservices yang berdaya tahan dengan PHP dan Rabbitmq

Untuk membina microservice PHP yang fleksibel, anda perlu menggunakan RabbitMQ untuk mencapai komunikasi tak segerak. 1. Decouple perkhidmatan melalui beratur mesej untuk mengelakkan kegagalan cascade; 2. Konfigurasi beratur berterusan, mesej berterusan, penerbitan pengesahan dan ACK manual untuk memastikan kebolehpercayaan; 3. Menggunakan Backoff Exponential Backoff, TTL dan Kegagalan Pemprosesan Keselamatan Gilir Surat Dead; 4. Gunakan alat seperti penyelia untuk melindungi proses pengguna dan membolehkan mekanisme degupan jantung untuk memastikan kesihatan perkhidmatan; dan akhirnya menyedari keupayaan sistem untuk terus beroperasi dalam kegagalan.

Membina microservices yang berdaya tahan bukan sekadar menulis kod bersih - ia mengenai merancang sistem yang dapat menahan kegagalan, skala secara bebas, dan berkomunikasi dipercayai. Apabila menggunakan PHP dalam seni bina microservices, salah satu cabaran terbesar ialah menguruskan komunikasi antara perkhidmatan tanpa memperkenalkan gandingan yang ketat atau downtime. Di situlah Rabbitmq masuk.

RabbitMQ, broker mesej yang mantap, membolehkan komunikasi tak segerak antara perkhidmatan, decoupling pengeluar dari pengguna dan membenarkan sistem untuk mengendalikan pancang beban, gangguan sementara, dan penangguhan pemprosesan. Digabungkan dengan PHP-bahasa yang digunakan secara meluas untuk perkhidmatan web walaupun sifatnya yang tidak berkesudahan-RabbitMQ membantu membina microservices yang bukan sahaja berskala tetapi juga toleran kesalahan.

Berikut adalah cara menggunakan PHP dan Rabbitmq dengan berkesan untuk membina microservices yang benar -benar berdaya tahan.

1. Perkhidmatan decouple dengan pemesejan tak segerak

Dalam persediaan segerak biasa (contohnya, panggilan API REST), perkhidmatan A mesti menunggu perkhidmatan B untuk bertindak balas. Sekiranya Perkhidmatan B turun atau perlahan, perkhidmatan A boleh keluar atau merendahkan prestasi - mewujudkan kegagalan kegagalan.

Dengan memperkenalkan RabbitMQ, anda mengganti panggilan HTTP langsung dengan beratur mesej:

• Perkhidmatan A menerbitkan mesej (misalnya, "userregistered") ke barisan.
• Perkhidmatan B menggunakan mesej apabila sudah siap - walaupun ia berada di luar talian semasa penerbitan.

Pendekatan ini memastikan bahawa:

• Perkhidmatan tidak bergantung pada ketersediaan masing -masing.
• Kegagalan sementara dalam satu perkhidmatan tidak menghalang orang lain.
• Kerja boleh bersara atau ditangguhkan tanpa kehilangan data.

Contoh Gunakan Kes : Selepas pengguna menandatangani, bukannya memanggil perkhidmatan e -mel secara langsung, perkhidmatan auth anda menerbitkan acara seperti:

 $ channel-> Basic_publish (
    AmqpMessage baru (json_encode ([[
        'event' => 'user_registered',
        'user_id' => 123,
        'e -mel' => 'user@example.com'
    )),,
    '', 'user_events'
);

Perkhidmatan e -mel memilih ini kemudian dan menghantar e -mel selamat datang - walaupun ia dimulakan semula pada masa itu.

2. Pastikan ketahanan dan kebolehpercayaan mesej

Untuk menjadikan sistem anda berdaya tahan, anda perlu menjamin bahawa mesej tidak hilang, walaupun RabbitMQ dimulakan semula atau kemalangan.

Inilah yang perlu anda konfigurasikan:

• Beratur yang berterusan : Mengisytiharkan beratur sebagai tahan lama sehingga mereka bertahan dengan mulakan semula broker.
• Mesej berterusan : Tandakan mesej sebagai berterusan sehingga mereka ditulis ke cakera.
• Penerbit Mengesahkan : Dayakan Mod Sahkan untuk memastikan mesej sebenarnya diterima oleh RabbitMQ.
• Pengakuan Pengguna : Gunakan ACKS manual supaya mesej hanya dikeluarkan selepas pemprosesan yang berjaya.

Contoh Persediaan PHP :

 // mengisytiharkan barisan tahan lama
$ channel-> queue_declare ('user_events', false, true, false, false);

// menerbitkan mesej yang berterusan
$ message = baru amqpmessage ($ muatan, ['delivery_mode' => 2]); // 2 = berterusan
$ channel-> basic_publish ($ mesej, '', 'user_events');

// Dayakan penerbit mengesahkan
$ channel-> confirm_select ();

// pengguna dengan ack manual
$ channel-> basic_consume ('user_events', '', false, false, false, function, function ($ msg) use ($ channel) {
    Cuba {
        ProcessMessage ($ msg-> body);
        $ channel-> basic_ack ($ msg-> getDeliveryTag ()); // ack hanya setelah berjaya
    } tangkapan (\ excepe $ e) {
        // menolak dan permintaan pilihan
        $ channel-> basic_nack ($ msg-> getDeliveryTag (), false, true);
    }
});

Tanpa tetapan ini, broker yang terhempas boleh menghapuskan mesej yang belum selesai - memecahkan daya tahan.

3. Mengendalikan kegagalan dengan anggun dengan mekanisme semula dan beratur surat mati

Walaupun dengan pemesejan tahan lama, beberapa mesej akan gagal - disebabkan oleh pepijat, isu rangkaian, atau kesilapan sementara. Mendapatkan semula secara membabi buta selama -lamanya tidak selamat.

Gunakan strategi ini:

• Cuba semula dengan backoff eksponen : Requeue gagal mesej dengan peningkatan kelewatan.
• Hadkan percubaan semula : Mencegah gelung tak terhingga.
• Pertukaran Surat Mati (DLX) : Pindahkan mesej yang gagal berulang kali ke barisan berasingan untuk pemeriksaan.

Idea Pelaksanaan :

Sediakan barisan dengan TTL (masa-ke-hidup) dan pertukaran mati:

 $ args = Amqptable baru ([
    'X-Dead-Letter-Exchange' => 'Dlx',
    'x-message-ttl' => 60000, // cuba semula selama 60 saat
]);

$ channel-> queue_declare ('user_events', false, true, false, false, false, $ args);

Apabila mesej gagal diproses dan ditolak dengan permintaan, anda boleh melambatkannya menggunakan giliran semula berasaskan TTL, kemudian akhirnya hantar ke DLX untuk campur tangan atau campur tangan manual.

Ini menghalang mesej yang hilang dan memberi anda penglihatan ke dalam kegagalan yang berterusan.

4. Memantau dan mengekalkan kesihatan dengan degupan jantung dan pengawasan

Proses PHP biasanya berpanjangan (skrip CLI atau pekerja), sehingga pengguna yang lama dapat merempuh dengan senyap.

Amalan Terbaik:

• Jalankan pengguna sebagai daemon CLI yang lama (menggunakan supervisord atau systemd ).
• Dayakan degupan jantung dalam sambungan Rabbitmq untuk mengesan pengguna mati.
• Pemprosesan mesej log dan memantau panjang giliran.

Contoh Config Penyelia ( supervisord.conf ):

 [Program: email_consumer]
COMMAND = PHP MASUSE_EMAILS.PHP
NumProcs = 1
Autostart = Benar
Autorestart = Benar
stderr_logfile =/var/log/e-mel-consumer.err.log
stdout_logfile =/var/log/e-mel-consumer.out.log

Ini memastikan pengguna anda dimulakan semula secara automatik jika ia terhempas - sebahagian daripada daya tahan yang kecil tetapi kritikal.

Pemikiran terakhir

Ketahanan dalam microservices tidak dicapai dalam satu langkah. Dengan PHP dan RabbitMQ, anda mendapat kombinasi yang kuat - PHP untuk pembangunan pesat dan rabbitmq untuk pemesejan yang boleh dipercayai.

Takeaways Kunci:

• Gunakan RabbitMQ untuk merumuskan perkhidmatan dan elakkan kegagalan cascading.
• Buat beratur dan mesej tahan lama untuk terus hidup.
• Melaksanakan logik semula dan DLX untuk mengendalikan kesilapan dengan selamat.
• Mengawasi pengguna untuk menjaga mereka hidup dan responsif.

Dengan corak ini, microservices berasaskan PHP anda boleh mengendalikan kekacauan dunia nyata-dari cegukan penyebaran untuk tiba-tiba melonjak lalu lintas-tanpa melanggar peluh.

Pada asasnya, ia bukan tentang menghalang semua kegagalan (itu mustahil), tetapi tentang merancang sistem yang terus berfungsi walaupun mereka.

Atas ialah kandungan terperinci Membina microservices yang berdaya tahan dengan PHP dan Rabbitmq. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!