How have you worked with transactions on shards? How did you ensure consistency?

Working with transactions on sharded databases requires a special approach, as data is distributed across different nodes, making it difficult to ensure atomicity and consistency.

Main approaches:

1. Local transactions on each shard — a transaction is executed only on one shard, which is simple but limits operations.

2. Two-phase commit (2PC) — coordinates transactions across multiple shards, ensuring atomicity but increasing delays and complexity.

3. Compensating transactions — instead of atomicity, operations are performed with the possibility of rollback through compensating actions.

4. Eventual Consistency and CQRS — allows temporary inconsistency with subsequent synchronization.

To ensure consistency, often use:

• Coordination via a distributed transaction manager.
• Local transactions with a minimal number of cross-shard operations.
• Identification and handling of conflicts at the application level.

Example: when transferring money between accounts on different shards, resources on both shards are first locked, then a two-phase commit is performed to either confirm or rollback both operations simultaneously.

In Go, you can use libraries for working with distributed transactions or implement your own protocol using gRPC and contexts for managing time and cancellation.