In un sistema distribuito, come impedire ai servizi duplicati di agire più volte su un'origine dati comune?

Al momento stiamo riscrivendo la nostra infrastruttura da un monolite a un sistema distribuito perché il vecchio sistema non si adattava più al carico di lavoro.

In una parte del nostro sistema distribuito, abbiamo un'entità (dal punto di vista del database) che ha N ... eventi associati. Abbiamo un servizio S che gestisce l'accesso a tutti N s e agli eventi. Gli eventi vengono spinti da altri servizi. Se nessun evento è stato inviato a uno specifico N per un tempo specifico, S aggiunge un altro evento a N .

Vogliamo essere in grado di ridimensionare S in orizzontale (quando ne abbiamo bisogno - È più una sorta di prova del futuro). Ma c'è un problema: se eseguiamo più istanze di S sullo stesso database, due o più istanze potrebbero rilevare che non c'è stata una voce a un N per alcuni secondi e aggiungere un evento, entrambi al stessa ora.

Abbiamo trovato diversi approcci per risolvere questo problema:

• Blocca il database, controlla se è necessario aggiungere un nuovo evento, aggiungilo e sblocca il database. Potrebbe non scalare bene, perché dobbiamo interrompere tutte le interazioni con il tavolo?
• Implementa S come master e slave e lascia che solo il master esegua questi aggiornamenti. Potrebbe non essere scalabile - E scegliere un nuovo master quando il vecchio master non è più disponibile è molto lavoro.
• Shard S . Dì un'istanza, S1 , si prende cura di N1 to N500 , S2 si prende cura di N501 to N1000 ecc. Ma dobbiamo aggiungere la logica per occuparci dello sharding e del resharding, se un'istanza si interrompe.

Queste opzioni sono difficili da implementare o potrebbero non essere scalabili correttamente (?). Esiste una soluzione generale a tale problema? Dove più servizi guardano sullo stesso set di dati, ma devono impedire a vicenda di agire sulle stesse cose?