Adding content to 114-microservices

src/roadmaps/aspnet-core/content/114-microservices/100-message-brokers/100-active-mq.md

@@ -1 +1,11 @@
-# Active mq
+# ActiveMQ
+
+ActiveMQ is an open-source message broker written in Java that implements the Java Message Service (JMS) API. It can be used to send and receive messages between different applications in a loosely coupled, asynchronous manner. ActiveMQ supports a variety of messaging protocols, including JMS, AMQP, STOMP, MQTT, and OpenWire.
+
+In the context of an ASP.NET application, ActiveMQ can be used to send and receive messages to and from other systems. For example, it can be used to send messages from a web application to a background service, or to send messages between different microservices.
+
+To learn more, visit the following links:
+
+- [What Is ActiveMQ And How Can You Use It?](https://www.c-sharpcorner.com/article/what-is-activemq-and-how-can-you-use-it/)
+- [Messaging with .NET and ActiveMQ](https://remark.wordpress.com/articles/messaging-with-net-and-activemq/)
+- [Messaging with ActiveMQ and ASP.NET](https://havret.io/activemq-artemis-net-core)

src/roadmaps/aspnet-core/content/114-microservices/100-message-brokers/101-apache-kafka.md

@@ -1 +1,10 @@
-# Apache kafka
+# Apache Kafka
+
+Apache Kafka is an open-source, distributed event streaming platform that is used for building real-time data pipelines and streaming applications. It is designed to handle high volumes of data and to support real-time data processing.
+
+Kafka is based on a publish-subscribe model, where producers write data to topics, and consumers read data from those topics. Data is stored in topics in a log-based format, which allows for efficient storage and retrieval of data.
+
+To learn more, visit the following links:
+
+- [Working with Apache Kafka in ASP.NET](https://www.codemag.com/Article/2201061/Working-with-Apache-Kafka-in-ASP.NET-6-Core)
+- [Kafka and .NET](https://docs.confluent.io/kafka-clients/dotnet/current/overview.html)

src/roadmaps/aspnet-core/content/114-microservices/100-message-brokers/102-rabbit-mq.md

@@ -1 +1,11 @@
-# Rabbit mq
+# RabbitMQ
+
+RabbitMQ is an open-source message broker software that implements the Advanced Message Queuing Protocol (AMQP). It is written in Erlang and can be used to send and receive messages between different applications in a loosely coupled, asynchronous manner. RabbitMQ supports a variety of messaging patterns, including point-to-point, publish-subscribe, and request-response.
+
+In the context of an ASP.NET application, RabbitMQ can be used to send and receive messages to and from other systems. For example, it can be used to send messages from a web application to a background service, or to send messages between different microservices.
+
+To learn more, visit the following links:
+
+- [How to Use RabbitMQ in ASP NET?](https://www.freecodespot.com/blog/use-rabbitmq-in-asp-net-core/)
+- [Introduction of RabbitMQ](https://www.rabbitmq.com/tutorials/tutorial-one-dotnet.html)
+- [ASP.NET and RabbitMQ](https://referbruv.com/blog/integrating-rabbitmq-with-aspnet-core-quickstart-with-an-example/)

src/roadmaps/aspnet-core/content/114-microservices/100-message-brokers/103-net-mq.md

@@ -1 +1,10 @@
-# Net mq
+# NetMQ
+
+NetMQ is a lightweight, open-source messaging library for building distributed systems and real-time applications in .NET. It provides an API for sending and receiving messages using a variety of messaging patterns and protocols, including request-response, publish-subscribe, and push-pull.
+
+NetMQ is built on top of ZeroMQ, a high-performance, asynchronous messaging library that provides a minimalistic socket-based API for building distributed systems. NetMQ is designed to be easy to use and to abstract away the complexities of ZeroMQ, making it a good choice for developers who want to add messaging capabilities to their ASP.NET applications without having to learn a complex API.
+
+Visit the following links to learn more:
+
+- [Documentation of NetMQ](https://netmq.readthedocs.io/en/latest/introduction/)
+- [NetMQ and creating a Dynamic Worker in .NET](https://mikaelkoskinen.net/post/netmq-and-creating-a-dynamic-worker-per-task)

src/roadmaps/aspnet-core/content/114-microservices/100-message-brokers/104-azure-service-bus.md

@@ -1 +1,9 @@
-# Azure service bus
+# Azure Service Bus
+
+Azure Service Bus is a scalable and reliable messaging platform that can handle a high volume of messages, it's also easy to use, has a lot of features like subscription, Topics, Dead Letter, and easy to integrate with other Azure services, and it's a managed service which means Microsoft takes care of the infrastructure and scaling. However, it's worth noting that Azure Service Bus is a paid service and the cost will depend on the number of messages and the size of the data that you are sending and receiving.
+
+To learn more, visit the following links:
+
+- [Getting Started With Azure Service Bus and ASP.NET Core](https://www.c-sharpcorner.com/article/get-started-with-azure-service-bus-queues-asp-net-core-part-1/)
+- [How to Send & receive messages from Azure Service Bus queue (.NET)?](https://learn.microsoft.com/en-us/azure/service-bus-messaging/service-bus-dotnet-get-started-with-queues?tabs=passwordless)
+- [What is Azure Service Bus?](https://learn.microsoft.com/en-us/azure/service-bus-messaging/service-bus-messaging-overview)

src/roadmaps/aspnet-core/content/114-microservices/100-message-brokers/index.md

@@ -1 +1,10 @@
-# Message brokers
+# Message Brokers
+
+Message Brokers are systems that provide a messaging infrastructure for applications and services to communicate with each other in a reliable, secure and scalable way. They act as a central hub for sending and receiving messages between different applications, services and devices.
+
+In the context of ASP.NET, message brokers can be used to send and receive messages between different parts of an application or between different applications or services, enabling them to communicate with each other in a decoupled and asynchronous manner.
+
+Visit the following links to learn more:
+
+- [What are message brokers?](https://www.ibm.com/topics/message-brokers)
+- [Building a messaging solution with .Net Core?](https://medium.com/c-sharp-progarmming/quick-start-how-could-you-build-a-messaging-solution-with-net-core-b5f8253f31ea)

src/roadmaps/aspnet-core/content/114-microservices/101-message-bus/100-mass-transit.md

@@ -1 +1,10 @@
-# Mass transit
+# MassTransit
+
+MassTransit is an open-source, highly configurable service bus framework for building distributed systems using the .NET framework. It allows developers to easily create message-based, loosely-coupled applications by providing a simple and fluent API for defining message contracts, handling messages, and managing message routing.
+
+It supports multiple messaging transports such as RabbitMQ, Azure Service Bus, Amazon SQS and others, automatic serialization and deserialization of messages, automatic retries and exception handling for failed message deliveries, and support for advanced messaging patterns like publish-subscribe, request-response, and event-driven architectures.
+
+To learn more, visit the following links:
+
+- [Using MassTransit with RabbitMQ in ASP.NET Core](https://code-maze.com/masstransit-rabbitmq-aspnetcore/)
+- [Complete guide to MassTransit](https://github.com/MassTransit/MassTransit)

src/roadmaps/aspnet-core/content/114-microservices/101-message-bus/101-nservice-bus.md

@@ -1 +1,10 @@
-# Nservice bus
+# NServiceBus
+
+NServiceBus (NSB) is a service bus framework for building distributed systems using the .NET framework. It provides a set of features for building message-based, loosely-coupled applications, including support for message routing, message handling, and message persistence.
+
+NSB supports multiple messaging transports, including MSMQ, RabbitMQ, and Azure Service Bus, and provides support for advanced messaging patterns such as publish-subscribe, request-response, and message-based sagas.
+
+To learn more, visit the following links:
+
+- [Using NServiceBus in an ASP.NET](https://docs.particular.net/samples/web/send-from-aspnetcore-webapi/)
+- [Learn NServiceBus from .NET Core](https://www.codeproject.com/Articles/1224839/Learn-NServiceBus-from-NET-Core-WebAPI)

src/roadmaps/aspnet-core/content/114-microservices/101-message-bus/102-easy-net-q.md

@@ -1 +1,10 @@
-# Easy net q
+# EasyNetQ
+
+EasyNetQ is a simple and easy-to-use .NET client for RabbitMQ, a popular open-source message broker. It provides a simple and fluent API for connecting to RabbitMQ, publishing and consuming messages, and managing message queues.
+
+EasyNetQ supports a wide range of messaging patterns, such as publish-subscribe, request-response, and message-based sagas, and makes it easy to work with RabbitMQ's advanced features, such as message routing, message persistence, and message acknowledgements.
+
+To learn more, visit the following links:
+
+- [Overview of EasyNetQ](https://easynetq.com/)
+- [RabbitMQ with EasyNetQ Tutorials](https://www.youtube.com/watch?v=CqxV_Xn4PlI)

src/roadmaps/aspnet-core/content/114-microservices/101-message-bus/index.md

@@ -1 +1,10 @@
-# Message bus
+# Message Bus
+
+A message bus is a software architecture pattern that enables different parts of an application, or different systems, to communicate with each other asynchronously using a message-based protocol. The message bus acts as a central intermediary, routing messages from senders to receivers and providing features such as message persistence, message routing, and message acknowledgements.
+
+There are different types of message buses, such as event-driven message buses, command-driven message buses, and publish-subscribe message buses. Each type of message bus is designed to handle specific messaging patterns and use cases.
+
+Visit the following links to learn more:
+
+- [Implementation of Message Bus C# microservices](https://stackoverflow.com/questions/51330229/implementation-of-message-bus-c-sharp-microservices)
+- [Building a Message Bus with .NET Core](https://fatihdumanli.medium.com/build-a-message-bus-implementation-with-net-core-and-rabbitmq-9ba350b777f4)

src/roadmaps/aspnet-core/content/114-microservices/102-kubernetes.md

@@ -1,6 +1,6 @@
 # Kubernetes
 
-Kubernetes is an [open source](https://github.com/kubernetes/kubernetes) container management platform, and the dominant product in this space.  Using Kubernetes, teams can deploy images across multiple underlying hosts, defining their desired availability, deployment logic, and scaling logic in YAML.  Kubernetes evolved from Borg, an internal Google platform used to provision and allocate compute resources.  (similar to the Autopilot and Aquaman systems of Microsoft Azure)
+Kubernetes is an [open source](https://github.com/kubernetes/kubernetes) container management platform, and the dominant product in this space.  Using Kubernetes, teams can deploy images across multiple underlying hosts, defining their desired availability, deployment logic, and scaling logic in YAML.  Kubernetes evolved from Borg, an internal Google platform used to provision and allocate compute resources (similar to the Autopilot and Aquaman systems of Microsoft Azure).
 
 The popularity of Kubernetes has made it an increasingly important skill for the DevOps Engineer and has triggered the creation of Platform teams across the industry.  These Platform engineering teams often exist with the sole purpose of making Kubernetes approachable and usable for their product development colleagues.
 

src/roadmaps/aspnet-core/content/114-microservices/103-docker-swarm.md

@@ -1 +1,11 @@
-# Docker swarm
+# Docker Swarm
+
+Docker Swarm is a container orchestration platform for managing and scheduling Docker containers across a cluster of servers. It is a native clustering solution for Docker and provides the ability to create and manage a swarm of Docker nodes as a single virtual host.
+
+With Docker Swarm, you can easily deploy and scale your applications across multiple servers, ensuring high availability and fault tolerance. It provides features such as load balancing, service discovery, and rolling updates, making it easy to manage and maintain your containerized applications.
+
+To learn more, visit the following links:
+
+- [Introduction to Docker Swarm](https://www.section.io/engineering-education/introduction-to-docker-swarm-in-container-orchestration/)
+- [Scale ASP.NET Core Apps with Docker Swarm](https://www.pluralsight.com/guides/scale-asp-net-core-apps-with-docker-swarm-mode)
+- [How - Deploy to Swarm?](https://docs.docker.com/get-started/swarm-deploy/)

src/roadmaps/aspnet-core/content/114-microservices/104-ocelot.md

@@ -1 +1,11 @@
-# Ocelot
+# Ocelot
+
+Ocelot is an open-source API gateway for ASP.NET Core. It is designed to work as a reverse proxy, routing incoming requests to the appropriate service and aggregating the responses to return to the client. Ocelot allows you to define routing rules, handle requests and responses, and perform other common API gateway tasks such as rate limiting, caching, and authentication.
+
+One of the key features of Ocelot is its flexibility, it can route incoming requests to multiple services, aggregate the responses, and return them as a single response to the client. It also allows you to define dynamic routes, based on the request's content, perform request and response transformations, and handle errors.
+
+To learn more, visit the following links:
+
+- [Implement API Gateways with Ocelot](https://learn.microsoft.com/en-us/dotnet/architecture/microservices/multi-container-microservice-net-applications/implement-api-gateways-with-ocelot)
+- [Getting Started with Ocelot](https://ocelot.readthedocs.io/en/latest/introduction/gettingstarted.html)
+- [Building an API Gateway in ASP.NET using Ocelotss](https://www.youtube.com/watch?v=hlUGZ6Hmv6s)

src/roadmaps/aspnet-core/content/114-microservices/105-docker.md

@@ -1 +1,11 @@
-# Docker
+# Docker
+
+Docker is a platform for developing, shipping, and running applications in containers. A container is a lightweight, standalone, and executable package of software that includes everything needed to run a piece of software, including the code, a runtime, system tools, libraries, and settings.
+
+Docker allows developers to package their applications and dependencies into a container, which can then be easily deployed and run on any host machine with Docker installed. This makes it easy to run the same software on different environments, such as development, staging, and production, without worrying about compatibility issues.s
+
+To learn more, visit the following links:
+
+- [ASP.NET and Docker](https://www.tatvasoft.com/blog/asp-net-core-and-docker/)
+- [Introduction to .NET and Docker](https://learn.microsoft.com/en-us/dotnet/core/docker/introduction)
+- [What is Docker, Why use it?](https://www.youtube.com/watch?v=vmnvOITMoIg)

src/roadmaps/aspnet-core/content/114-microservices/106-yarp.md

@@ -1 +1,8 @@
-# Yarp
+# YARP
+
+YARP (Yet Another Robot Platform) is an open-source software framework for robotics and computer vision, focused on providing a simple and efficient way to create and manage multi-modal robotic systems. It provides a set of libraries and tools to handle the low-level communication and control of robotic devices, such as cameras, motors, and sensors, as well as high-level functionalities such as image processing, object recognition, and control algorithms.
+
+To learn more, visit the following links:
+
+- [Getting Started with YARP](https://microsoft.github.io/reverse-proxy/articles/getting-started.html)
+- [YARP: The .NET Reverse proxy](https://www.youtube.com/watch?v=1IqQkNcsqWE)

src/roadmaps/aspnet-core/content/114-microservices/107-orleans.md

@@ -1 +1,11 @@
-# Orleans
+# Orleans
+
+Orleans is an open-source virtual actor model framework for building distributed, high-scale, and low-latency applications in .NET. It is designed to make it easy to build and operate large-scale, distributed systems, such as cloud services, IoT applications, and gaming servers.
+
+One of the key features of Orleans is its use of the virtual actor model, which is a programming model that allows developers to write concurrent and parallel code in a way that is similar to writing single-threaded code. Orleans provides a set of abstractions for building stateful actors, which are similar to objects in object-oriented programming, that can be distributed across multiple machines. These actors can communicate with each other using message passing, and can be accessed remotely using a transparent proxy
+
+To learn more, visit the following links:
+
+- [Microsoft Orleans](https://learn.microsoft.com/en-us/dotnet/orleans/overview)
+- [Building real applications with Orleans](https://www.youtube.com/watch?v=8duFuggnj8o)
+- [Introduction to Orleans](https://dev.to/willvelida/introduction-to-microsoft-orleans-796)

src/roadmaps/aspnet-core/content/114-microservices/108-steel-toe.md

@@ -1 +1,9 @@
-# Steel toe
+# Steeltoe
+
+Steeltoe is an open-source project that provides a set of libraries for building cloud-native applications on the .NET platform. The libraries are designed to work with the .NET Core runtime and provide a set of abstractions for common cloud-native patterns, such as service discovery, configuration management, and circuit breaking. The goal of Steeltoe is to make it easy for developers to take advantage of the cloud-native capabilities of the .NET platform and build resilient and scalable applications.
+
+To learn more, visit the following links:
+
+- [.NET Microservices with Steeltoe](https://learn.microsoft.com/en-us/shows/on-net/net-microservices-with-steeltoe)
+- [Steeltoe Documentation](https://docs.steeltoe.io/api/v3/welcome/index.html)
+- [.NET Microservices with Steeltoe](https://www.youtube.com/watch?v=QLRi6iPapVg)

src/roadmaps/aspnet-core/content/114-microservices/109-dapr.md

@@ -1 +1,8 @@
-# Dapr
+# Dapr
+
+Dapr (Distributed Application Runtime) is an open-source, portable runtime that makes it easy to build microservices-based applications that run on the cloud and edge. It provides a set of building blocks for building microservices, including service discovery, state management, pub-sub messaging, and more. It is designed to be language-agnostic, so it can be used with any programming language, including .NET.
+
+To learn more, visit the following links:
+
+- [Get started with Dapr](https://learn.microsoft.com/en-us/dotnet/architecture/dapr-for-net-developers/getting-started)
+- [Building an event-driven .NET Core app with Dapr](https://medium.com/polarsquad/building-an-event-driven-net-core-app-with-dapr-58cc83ab120b)

src/roadmaps/aspnet-core/content/114-microservices/110-tye.md

@@ -1 +1,9 @@
-# Tye
+# Tye
+
+Tye (short for "Try Everything") is a developer tool for .NET that makes it easy to develop, test, and deploy microservices and distributed applications. It is built on top of the .NET Core CLI and Docker and provides a simple and consistent way to run multiple services and components locally, making it easy to test and debug distributed applications.
+
+Tye allows you to define the components of your application in a single YAML file, and then automatically starts, stops and configures all the required services and dependencies. It also provides a set of features to make it easy to manage the application, such as automatic service discovery and configuration, and automatic binding of services to the right ports.
+
+To learn more, visit the following links:
+
+- [Getting Started with Tye](https://github.com/dotnet/tye)

src/roadmaps/aspnet-core/content/114-microservices/index.md

@@ -1 +1,11 @@
-# Microservices
+# Microservices
+
+Microservices are a software architectural style in which a large application is built as a set of small, independent services that communicate with each other through APIs. These services are typically built using different technologies and run in their own processes, and can be deployed, scaled, and updated independently.
+
+In ASP.NET, microservices can be built using the .NET Core framework, which is a cross-platform, open-source version of the .NET framework that can run on Windows, Linux, and macOS. Each microservice can be built as a self-contained, small web application that handles a specific set of functionality, such as user management, product catalog, or order processing.
+
+To learn more, visit the following links:
+
+- [Overview of ASP.NET Microservices](https://www.pluralsight.com/paths/net-microservices)
+- [Intro to Microservices Using ASP.NET Core](https://www.c-sharpcorner.com/article/microservice-using-asp-net-core/)
+- [Advantages and Disadvantages of Microservices Architecture](https://www.dotnettricks.com/learn/microservices/architecture-example-advantages)