This is a code series that shows practical, real-world scenarios involving distributed applications and Project Tye. In general, each example builds upon the ideas and code of the previous one, but each is also designed to run on its own. My goal is to provide an example that evolves over time rather than just the "end result" so you can see what changes from scenario to scenario.

The first four parts of the series are there to set up common scenarios you will encounter when developing distributed apps. If you want to skip right to the good stuff, hop into the 5th in the series where we actually start using Tye.

I'm a relative newcomer to the world of Tye, so if anyone has any feedback about anything, please let me know! Also, if you wanna keep track of what's going on in the Tye codebase, the Tye team claims that they'll post here every two weeks-ish (YMMV).

This series started life as the demo code for a dev talk. Each piece in the series builds upon the ideas of the previous. We start with a simple little Blazor app. Over time, we add in co-dependent microservices, distributed monitoring and logging, local databases, local load balancing, and more! After the 4th in the series, we start to use Tye to make our lives easier when it comes to inner-loop development of this distributed app.

The basics:

• Install .NET 5.0
  • Tye does not need .NET 5.0, but all of the examples are running on .NET 5.0 so you'll need it
• Install Project Tye
  • The main tooling for Tye

For examples that use containers:

• Install Docker Desktop for your OS

For examples that use Kubernetes:

• A Kubernetes cluster, such as Azure Kubernetes Service
• The Azure CLI utility
• kubectl

Here are some places to go that delve a bit deeper into the various technologies used it this series.

• Introducing Project Tye
• Building Microservices with Tye - March 2021 Update
• Tye and Kubernetes
• How Dell Botched Their Initial Microservice Implementation
• Basic Info on Kubernetes
• Docker Hub
• Overview of Microservices
• Pluralsight .NET Microservices Path
• Intro to Zipkin
• Intro to Elastic Search Series
• Debugging Tye with VS Code

• tye-talk-01-simple
  • A basic monolithic application, which is essentially just the standard Blazor WASM Weather App
• tye-talk-02-microservice
  • We add in our first microservice
• tye-talk-03-more-microservices
  • We add in a couple more microservices
• tye-talk-04-intertwined
  • We spaghettify our microservices
• tye-talk-05-tye-ahoy
  • We see how Tye can help simplify our spaghetti
• tye-talk-06-tye-plus-plus
  • We use Tye to quickly add in Zipkin and Elastic Stack to take our local debugging and dependency monitoring experience to the next level
• tye-talk-07-sql-server
  • We add in a SQL Server container, run some database migrations against it, and have our own freshly initialized local development database
• tye-talk-08-replication
  • We dive into local load balancing to test distributed locking and distributed caching with Redis
• tye-talk-09-diverse-databases
  • Microservices are supposed to have their own isolated data stores. In this episode, we look at how to spool up a whole bunch of popular data storage platforms (SQL Server, MySQL, PostgreSQL, MariaDB, and MongoDB)
• tye-talk-10-deploy-to-aks
  • We take a peek at Tye's Kubernetes deployment capabilities by sending a slimmed down version of our app to Azure Kubernetes Service
• tye-talk-11-multi-repo
  • We look at a more complicated, real-world scenario where the dependencies of a project may not always lay within that project's solution