Wade Waldron
Staff Software Practice Lead
Apache Kafka for .Net Developers
About This Course
The best applications provide users with nearly instantaneous feedback. However, that doesn’t necessarily mean those applications are performing the work in a synchronous manner. Instead, the most responsive applications often have a significant component that is asynchronous. User actions trigger events that are then distributed as messages by a streaming platform such as Apache Kafka.
The streaming nature of these applications allows them to be more robust. The system can be scaled up or down by adding additional message consumers. Portions of the system can even be taken offline without an immediate impact on the users. And new features can be added quickly by stitching together data from a variety of events already flowing through the system.
But before you can take advantage of these benefits, you need to know where to start. In this course, we will show you how to build a simple streaming system using C# and ASP.NET. We will walk you through how to connect your application to a Kafka Cluster hosted by Confluent Cloud. You’ll see how to produce and consume messages from the cluster, how to scale your application, and how to achieve different message delivery guarantees. By the end of the course, you will have a small working set of services using Apache Kafka as their communication layer.
Intended Audience
- You have experience with C# and .Net, ideally including:
- ASP.NET
- Asynchronous Programming
- You are familiar with the basic concepts of a publish/subscribe system such as:
- Topics
- Producers
- Consumers
- You may have never used Kafka.
Course Outline
- This course will cover:
- What is Event Streaming?
- Kafka Messages
- Producing Messages
- Serialization and Deserialization (SerDes)
- Schemas and the Schema Registry
- Consuming Messages
- Message Delivery Guarantees & Transactions
- Kafka Topic Management with the Admin Client
Prerequisites
- Required Knowledge
- C# .Net development experience
- Required Setup
- A local development environment including:
- .Net
- A local development environment including:
Length
- Approximately 2-3 hours
Staff
Wade Waldron (Course Author)
Wade has been a Software Developer since 2005. He has worked on video games, backend microservices, ETL Pipelines, IoT systems, and more. He is an advocate for Test-Driven Development, Domain-Driven Design, Microservice Architecture, and Event-Driven Systems. Today, Wade works as a Staff Software Practice Lead at Confluent where he shows people how to build modern data streaming applications.
- Previous
- Next
Use the promo codes DOTNETKAFKA101 & CONFLUENTDEV1 to get $25 of free Confluent Cloud usage and skip credit card entry.
Be the first to get updates and new content
We will only share developer content and updates, including notifications when new content is added. We will never send you sales emails. 🙂 By subscribing, you understand we will process your personal information in accordance with our Privacy Statement.
Overview
Hi, I'm Wade from Confluent. In this course, I'm going to show you how to create a simple set of microservices using the C# .NET client for Kafka. Each Kafka client potentially behaves a little differently from the others. If we try to build an application using the .NET client, but we base it on an example from Java, the end result may not be what we expect. We could end up with some severe problems such as message loss. It's important that we take the time to understand how to use the language-specific client so we can avoid these problems. But don't worry, by the end of this course, you will know how to build a fully-functioning set of microservices with strong messaging guarantees. We'll start the course by talking about event streaming. What is it and why should we care? From there, we move on to producing some messages from a simple ASP.NET microservice into Kafka. We'll also implement a second microservice that will consume those messages as they arrive. Along the way, we'll be looking at how to serialize messages and tie them to a schema. Critically, we'll be taking a deeper look at message delivery guarantees and transactions so that you can be confident that your messages behave the way you expect. The course will introduce you to the Kafka .NET client through a series of hands-on exercises. These exercises will allow you to produce and consume data through Confluent Cloud. If you haven't already signed up for Confluent Cloud, sign up now, so when your first exercise asks you to log in, you're ready. Be sure to use the promo code when signing up to get the free usage that it provides. If you aren't already on Confluent Developer, head there now using the link in the video description to access the rest of this course and its hands-on exercises.