Merge pull request #50364 from lootle1/MR102

Stacyrch140 · web-flow · commit 61f5c0681804 · 2025-05-19T12:15:59.000-04:00
Technical Review 1044280: Implement resiliency in a cloud-native .NET…
diff --git a/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/1-introduction.yml b/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/1-introduction.yml
@@ -5,7 +5,7 @@ metadata:
   description: Learn how to add fault tolerance to your cloud-native ASP.NET Core microservice app, with minimal impact on the user.
   author: codemillmatt
   ms.author: masoucou
-  ms.date: 11/06/2023
+  ms.date: 05/09/2025
   ms.topic: unit
 title: Introduction
 durationInMinutes: 1
diff --git a/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/2-application-infrastructure-resiliency.yml b/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/2-application-infrastructure-resiliency.yml
@@ -5,7 +5,7 @@ metadata:
   description: Learn about approaches to resiliency for cloud-native microservices apps.
   author: codemillmatt
   ms.author: masoucou
-  ms.date: 11/06/2023
+  ms.date: 05/09/2025
   ms.topic: unit
 title: Application and infrastructure resiliency
 durationInMinutes: 5
diff --git a/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/3-implement-application-resiliency.yml b/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/3-implement-application-resiliency.yml
@@ -5,7 +5,7 @@ metadata:
   description: Learn how to use .NET resiliency with cloud-native microservices apps.
   author: codemillmatt
   ms.author: masoucou
-  ms.date: 11/06/2023
+  ms.date: 05/09/2025
   ms.topic: unit
   ms.custom: devx-track-dotnet
 title: Implement application resiliency
diff --git a/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/4-exercise-implement-resiliency.yml b/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/4-exercise-implement-resiliency.yml
@@ -5,7 +5,7 @@ metadata:
   description: Write code to add resiliency to an existing cloud-native microservices app.
   author: codemillmatt
   ms.author: masoucou
-  ms.date: 11/06/2023
+  ms.date: 05/09/2025
   ms.topic: unit
 title: Exercise - Implement application resiliency
 durationInMinutes: 9
diff --git a/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/5-implement-infrastructure-resiliency.yml b/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/5-implement-infrastructure-resiliency.yml
@@ -5,7 +5,7 @@ metadata:
   description: Learn how to use Linkerd to configure infrastructure-based resiliency in your microservices app.
   author: codemillmatt
   ms.author: masoucou
-  ms.date: 11/06/2023
+  ms.date: 05/09/2025
   ms.topic: unit
   ms.custom:
     - devx-track-dotnet
diff --git a/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/6-exercise-implement-infrastructure-resiliency.yml b/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/6-exercise-implement-infrastructure-resiliency.yml
@@ -5,7 +5,7 @@ metadata:
   description: Use Linkerd to configure infrastructure-based resiliency in your microservices app.
   author: codemillmatt
   ms.author: masoucou
-  ms.date: 11/06/2023
+  ms.date: 05/09/2025
   ms.topic: unit
 title: Exercise - Implement infrastructure resiliency with Kubernetes
 durationInMinutes: 11
diff --git a/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/7-knowledge-check.yml b/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/7-knowledge-check.yml
@@ -5,7 +5,7 @@ metadata:
   description: Test your knowledge of what you learned in this tutorial about resiliency.
   author: codemillmatt
   ms.author: masoucou
-  ms.date: 11/06/2023
+  ms.date: 05/09/2025
   ms.topic: unit
 title: Module assessment
 durationInMinutes: 7
diff --git a/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/8-summary.yml b/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/8-summary.yml
@@ -5,7 +5,7 @@ metadata:
   description: Review what you learned in the tutorial, and deprovision the Azure resources that you used.
   author: codemillmatt
   ms.author: masoucou
-  ms.date: 11/06/2023
+  ms.date: 05/09/2025
   ms.topic: unit
   ms.custom:
     - devx-track-dotnet
diff --git a/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/includes/1-introduction.md b/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/includes/1-introduction.md
@@ -13,7 +13,7 @@ You'll modify the app to include some code-based resiliency handling policies in
 
 ## Learning objectives
 
-In this module, you will:
+In this module, you'll:
 
 * Understand foundational resiliency concepts.
 * Observe the behavior of a microservice that has no resiliency strategy.
@@ -25,4 +25,4 @@ In this module, you will:
 * Familiarity with C# and .NET development at the beginner level.
 * Familiarity with RESTful service concepts.
 * Conceptual knowledge of containers and AKS at the intermediate level.
-* Ability to run development containers GitHub Codespaces or in Visual Studio Code.
+* Ability to run development containers GitHub Codespaces or in Visual Studio Code.
diff --git a/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/includes/2-application-infrastructure-resiliency.md b/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/includes/2-application-infrastructure-resiliency.md
@@ -6,7 +6,7 @@ Because microservice environments can be volatile, design your apps to expect an
 
 In designing resilient applications, you often have to choose between failing fast and graceful degradation. Failing fast means the application will immediately throw an error or exception when something goes wrong, rather than try to recover or work around the problem. This allows issues to be identified and fixed quickly. Graceful degradation means the application will try to keep operating in a limited capacity even when some component fails.
 
-In cloud-native applications it's important for services to handle failures gracefully rather than fail fast. Since microservices are decentralized and independently deployable, partial failures are expected. Failing fast would allow a failure in one service to quickly take down dependent services, which reduce overall system resiliency. Instead, microservices should be coded to anticipate and tolerate both internal and external service failures. This graceful degradation allows the overall system to continue operating even if some services are disrupted. Critical user-facing functions can be sustained, avoiding a complete outage. Graceful failure also allows disturbed services time to recover or self-heal before impacting the rest of the system. So for microservices-based applications, graceful degradation better aligns with resiliency best practices like fault isolation and rapid recovery. It prevents local incidents from cascading across the system.
+In cloud-native applications, it's important for services to handle failures gracefully rather than fail fast. Since microservices are decentralized and independently deployable, partial failures are expected. Failing fast would allow a failure in one service to quickly take down dependent services, which reduce overall system resiliency. Instead, microservices should be coded to anticipate and tolerate both internal and external service failures. This graceful degradation allows the overall system to continue operating even if some services are disrupted. Critical user-facing functions can be sustained, avoiding a complete outage. Graceful failure also allows disturbed services time to recover or self-heal before impacting the rest of the system. So for microservices-based applications, graceful degradation better aligns with resiliency best practices like fault isolation and rapid recovery. It prevents local incidents from cascading across the system.
 
 There are two fundamental approaches to support a graceful degradation with resiliency: application and infrastructure. Each approach has benefits and drawbacks. Both approaches can be appropriate depending on the situation. This module explains how to implement both *code-based* and *infrastructure-based* resiliency.
 
@@ -28,11 +28,11 @@ A *Circuit Breaker* strategy gives a target service a break after a repeated num
 
 ### Infrastructure-based resiliency
 
-To implement infrastructure-based resiliency, you can use a *service mesh*. Aside from resiliency without changing code, a service mesh provides traffic management, policy, security, strong identity, and observability. Your app is decoupled from these operational capabilities, which are moved to the infrastructure layer. 
+To implement infrastructure-based resiliency, you can use a *service mesh*. Aside from resiliency without changing code, a service mesh provides traffic management, policy, security, strong identity, and observability. Your app is decoupled from these operational capabilities, which are moved to the infrastructure layer.
 
 #### Comparison to code-based approaches
 
-An infrastructure-based resiliency approach can use a metrics-based view that allows it to adapt dynamically to cluster conditions in real time. This approach adds another dimension to managing the cluster, but doesn't add any code.
+An infrastructure-based resiliency approach can use a metrics-based view that allows it to adapt dynamically to cluster conditions in real time. This approach adds another dimension to managing the cluster but doesn't add any code.
 
 With a code-based approach you:
 
@@ -43,4 +43,4 @@ There's no reasonable way to respond to an infrastructure failure in your app's
 
 In contrast, infrastructure-based approaches are unaware of app internals. For example, complex database transactions are invisible to service meshes. Such transactions can only be protected from failure with a code based approach.
 
-In upcoming units, you'll implement resilience for a microservice based app  using .NET HTTP resiliency in code and a Linkerd service mesh.
+In upcoming units, you'll implement resilience for a microservice based app using .NET HTTP resiliency in code and a Linkerd service mesh.
diff --git a/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/includes/3-implement-application-resiliency.md b/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/includes/3-implement-application-resiliency.md
@@ -18,7 +18,7 @@ dotnet add package Microsoft.Extensions.Http.Resilience
 
 Running this command from the terminal in the apps project folder will add the package reference to the project file.
 
-In your application's startup class then add the following using statement:
+Then add the following using statement in your application's startup class :
 
 ```csharp
 using Microsoft.Extensions.Http.Resilience;
@@ -30,20 +30,20 @@ You can now add a standard resilience strategy to your HttpClient service. .NET
 
 :::image type="content" source="../media/3-standard-reslience-strategies.png" alt-text="A diagram showing the strategies included in the Standard Resilience Handler. From overall timeout, retry, bulkhead, circuit breaker, and attempt timeout." border="false":::
 
-The request handler goes through each of the above strategies in order form left to right:
+The request handler goes through each of these strategies in order form left to right:
 
 - **Total request timeout strategy**: This sets a total amount of time that the request can take. You can think of this as setting the upper time limit for all the other strategies.
 - **Retry strategy**: This strategy controls the options on number of retries, backoff, and jitter. These options can't exceed the total timeout set in the previous strategy.
 - **Circuit breaker strategy**: This strategy opens the circuit if the failure ratio exceeds the threshold.
-- **Attempt timeout strategy**: This strategy sets a timeout for each individual request. If the request takes longer than this time then an exception is thrown.
+- **Attempt timeout strategy**: This strategy sets a timeout for each individual request. If the request takes longer than this time, then an exception is thrown.
 
 You can add this standard strategy, with all the default values by adding this extension method:
 
 ```csharp
 .AddStandardResilienceHandler();
 ```
 
-For example if you have declared a `WebApplication`, and you want to add a resilience strategy to the HttpClient service use this code: 
+For example if you have declared a `WebApplication`, and you want to add a resilience strategy to the HttpClient service use this code:
 
 ```csharp
 builder.Services.AddHttpClient<ServiceBeingCalled>(httpClient =>
@@ -52,7 +52,7 @@ builder.Services.AddHttpClient<ServiceBeingCalled>(httpClient =>
 }).AddStandardResilienceHandler();
 ```
 
-The first line of the above code adds a standard resilience handler to the HTTPClient. This will use all the default settings for the retry and circuit breaker strategies.
+The first line of the preceding code adds a standard resilience handler to the HTTPClient. This will use all the default settings for the retry and circuit breaker strategies.
 
 ### Configure the resilience strategy
 
@@ -68,7 +68,7 @@ You can change the default values of any of the strategies by specifying new opt
 
 This code changes the retry strategy defaults to have a maximum number of retires of 10, to use a linear back off, and use a base delay of 1 second.
 
-The options you choose have to be compatible with each other. For example, if the total time remains as its default of 30 seconds, then the retry options above will cause an exception. This is an error because the exponential backoff setting would cause the total time to complete the 10 retries to be 2046 seconds. This is a runtime exception, not a compile time error.
+The options you choose have to be compatible with each other. For example, if the total time remains as its default of 30 seconds, then the retry options will cause an exception. This is an error because the exponential backoff setting would cause the total time to complete the 10 retries to be 2,046 seconds. This is a runtime exception, not a compile time error.
 
 The following table lists the options available for each of the strategies.
 
@@ -108,4 +108,4 @@ The following table lists the options available for each of the strategies.
 
 :::image type="content" source="../media/3-calling-pattern-with-resiliency.png" alt-text="A sequence diagram showing the flow of events in an application using a resiliency strategy." border="false":::
 
-The sequence diagram above shows how each of the strategies work together in a standard resiliency strategy. To begin with the limiting factor of how long a request can take is controlled by the total timeout strategy. The retry strategy must then be set to have a maximum number of retries that will complete within the total timeout. The circuit breaker strategy will open the circuit if the failure ratio exceeds the threshold set for it. The attempt timeout strategy sets a timeout for each individual request. If the request takes longer than this time then an exception is thrown.
+The sequence diagram shows how each of the strategies work together in a standard resiliency strategy. To begin with, the total timeout strategy controls the limiting factor of how long a request can take. The retry strategy must then be set to have a maximum number of retries that will complete within the total timeout. The circuit breaker strategy will open the circuit if the failure ratio exceeds the threshold set for it. The attempt timeout strategy sets a timeout for each individual request. If the request takes longer than this time, then an exception is thrown.
diff --git a/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/includes/5-implement-infrastructure-resiliency.md b/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/includes/5-implement-infrastructure-resiliency.md
@@ -9,7 +9,7 @@ The *control plane* component has many components that support managing the serv
 * Security management for things like strong identity and certificates for mTLS.
 * Metrics or observability to collect and aggregate metrics and telemetry from the apps.
 
-The *data plane* component consists of proxies that are transparently injected alongside each service; this is known as the Sidecar pattern. Each proxy is configured to control the network traffic in and out of the pod that contains your service. This configuration allows each proxy to be configured to:
+The *data plane* component consists of proxies that are transparently injected alongside each service, which is known as the Sidecar pattern. Each proxy is configured to control the network traffic in and out of the pod that contains your service. This configuration allows each proxy to be configured to:
 
 * Secure traffic via mTLS.
 * Dynamically route traffic.
diff --git a/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/includes/6-exercise-implement-infrastructure-resiliency.md b/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/includes/6-exercise-implement-infrastructure-resiliency.md
@@ -1,6 +1,6 @@
 In the previous unit, you implemented resiliency by adding failure-handling code using .NET native resilience extension. However, this change only applies to the service that you changed. Updating a large app with many services would be nontrivial.
 
-Instead of using *code-based* resiliency, this unit uses an approach called *infrastructure-based* resiliency that spans the entire app. You will:
+Instead of using *code-based* resiliency, this unit uses an approach called *infrastructure-based* resiliency that spans the entire app. You'll:
 
 * Redeploy the app without any resiliency into Kubernetes.
 * Deploy Linkerd in your Kubernetes cluster.
diff --git a/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/index.yml b/learn-pr/aspnetcore/microservices-resiliency-aspnet-core/index.yml
@@ -1,17 +1,17 @@
 ### YamlMime:Module
 uid: learn.microservices-resiliency-aspnet-core
 metadata:
-  title: Implement resiliency in a cloud-native microservice
+  title: Implement Resiliency in a Cloud-Native Microservice
   description: This module guides you through implementing resiliency in an .NET microservices app in a Kubernetes Service.
   author: codemillmatt
   ms.author: masoucou
-  ms.date: 11/06/2023
+  ms.date: 05/09/2025
   ms.service: aspnet-core
   ms.topic: module-standard-task-based
 title: Implement resiliency in a cloud-native .NET microservice
 summary: Learn how to make your cloud-native .NET Core microservices app fault-tolerant with minimal impact on the user.
 abstract: |
-  In this module, you will:
+  In this module, you'll:
   - Understand foundational resiliency concepts.
   - Observe the behavior of a microservice with no resiliency strategy.
   - Implement failure handling code for HTTP requests in one microservice.
