스키마 관리의 중요성

In an event-driven system, services communicate by sending and receiving events. An event is a record of something that happened, like "UserSignedUp" or "OrderPlaced".

But what exactly is an event? It's just data! An event schema defines the structure and type of this data, acting like a blueprint or a contract.

Imagine a producer service sends an event {"username": "coddy"}. A consumer service reads this and updates a dashboard.

What happens if the producer changes the event to {"userId": "123", "name": "Coddy"}? The old consumer might break! This is where schemas become crucial.

An event schema is a formal description of an event's data format. It specifies:

• Field names: What are the data points?
• Data types: Is it a string, number, boolean, or another object?
• Required/Optional: Which fields must always be present?

Think of it as an API contract for your events.

As applications grow, event structures often need to change. New features might require new data, or old data might become obsolete.

The challenge is to evolve these schemas without breaking existing services that depend on them. This is where backward and forward compatibility come into play.

Backward compatibility means that newer versions of an event schema can still be understood and processed by older versions of consumer services.

If a producer sends a new event format, an old consumer should still be able to read and process the parts it understands without crashing. It's about protecting existing consumers.

Forward compatibility means that older versions of an event schema can be understood by newer versions of consumer services.

If an old producer sends an old event format, a new consumer should still be able to read and process it, even if it expects additional fields. It's about protecting new consumers from old producers.

Without proper schema management, changing event structures can lead to:

• Data corruption: Misinterpretation of data types.
• Service outages: Consumers crashing due to unexpected fields or missing required fields.
• Maintenance nightmares: Difficulty in updating services in a coordinated manner.
• Lost data: Events being dropped because they can't be parsed.

Consider an "OrderPlaced" event. Initially, it had orderId and amount. A new version adds currency.

An old consumer expecting only orderId and amount might ignore currency (if designed to be flexible) or fail if it strictly validates known fields. This is a backward compatibility challenge.

Now, imagine an "UserProfileUpdated" event. It used to have email and phone. Later, phone is removed.

A new consumer might be built expecting only email. If an old producer sends an event with email and phone, the new consumer must gracefully ignore the unexpected phone field. This is a forward compatibility challenge.

You've learned about the importance of event schemas and compatibility.

We've learned that event schemas are crucial contracts for data in event-driven systems. They define the structure and types of event data.

Managing schemas ensures backward compatibility (old consumers handle new events) and forward compatibility (new consumers handle old events), preventing service disruptions and data loss as your system evolves.

Next, we'll dive into Apache Avro as a tool for defining these schemas effectively.