dotnet · IEvangelist · Apr 13, 2022 · Apr 13, 2022
@@ -9,6 +9,8 @@ ms.contributors: jeliknes-07302021
 ---
 # Telemetry with Application Insights
 
+[!INCLUDE [download-alert](includes/download-alert.md)]
+
 [Application Insights](/azure/application-insights) is a serverless diagnostics platform that enables developers to detect, triage, and diagnose issues in web apps, mobile apps, desktop apps, and microservices. You can turn on Application Insights for function apps simply by flipping a switch in the portal. Application Insights provides all of these capabilities without you having to configure a server or set up your own database. All of Application Insights' capabilities are provided as a service that automatically integrates with your apps.
 
 ![Application Insights logo](./media/application-insights-logo.png)

@@ -9,6 +9,8 @@ ms.contributors: jeliknes-10172019
 ---
 # Architecture approaches
 
+[!INCLUDE [download-alert](includes/download-alert.md)]
+
 Understanding existing approaches to architecting enterprise apps helps clarify the role played by serverless. There are many approaches and patterns that evolved over decades of software development, and all have their own pros and cons. In many cases, the ultimate solution may not involve deciding on a single approach but may integrate several approaches. Migration scenarios often involve shifting from one architecture approach to another through a hybrid approach.
 
 This chapter provides an overview of both logical and physical architecture patterns for enterprise applications.

@@ -9,6 +9,8 @@ ms.contributors: jeliknes-03262021
 ---
 # Architecture deployment approaches
 
+[!INCLUDE [download-alert](includes/download-alert.md)]
+
 Regardless of the architecture approach used to design a business application, the implementation, or deployment of those applications may vary. Businesses host applications on everything from physical hardware to serverless functions.
 
 ## N-Tier applications

@@ -9,6 +9,8 @@ ms.contributors: jeliknes-01302020
 ---
 # Azure Functions
 
+[!INCLUDE [download-alert](includes/download-alert.md)]
+
 Azure Functions provide a serverless compute experience. A function is invoked by a *trigger* (such as access to an HTTP endpoint or a timer) and executes a block of code or business logic. Functions also support specialized *bindings* that connect to resources like storage and queues.
 
 ![Azure functions logo](./media/azure-functions-logo.png)

@@ -7,6 +7,8 @@ ms.date: 06/26/2018
 ---
 # Azure serverless platform
 
+[!INCLUDE [download-alert](includes/download-alert.md)]
+
 The Azure serverless platform includes Azure Functions, Logic Apps, and Event Grid. These services work together and connect with myriad other resources. The serverless platform works with everything from databases and storage to analytics and machine learning/artificial intelligence.
 
 You can also use Application Insights, a serverless platform for capturing diagnostic traces and telemetry. Application Insights are available to applications of all types (desktop, mobile, or web) as well as serverless implementations. The platform is visualized in the following diagram:

@@ -6,6 +6,8 @@ ms.date: 06/26/2018
 ---
 # Durable Azure Functions
 
+[!INCLUDE [download-alert](includes/download-alert.md)]
+
 When creating serverless applications with Azure Functions, your operations will typically be designed to run in a stateless manner. The reason for this design choice is because as the platform scales, it becomes difficult to know what servers the code is running on. It also becomes difficult to know how many instances are active at any given point. However, there are classes of applications that require the current state of a process to be known. Consider the process of submitting an order to an online store. The checkout operation might be a workflow that is composed of multiple operations that need to know the state of the process. Such information may include the product inventory, if the customer has any credits on their account, and also the results of processing the credit card. These operations could easily be their own internal workflows or even services from third-party systems.
 
 Various patterns exist today that assist with the coordination of application state between internal and external systems. It's common to come across solutions that rely on centralized queuing systems, distributed key-value stores, or shared databases to manage that state. However, these are all additional resources that now need to be provisioned and managed. In a serverless environment, your code could become cumbersome trying to coordinate with these resources manually. Azure Functions offers an alternative for creating stateful functions called Durable Functions.

@@ -9,6 +9,8 @@ ms.contributors: jeliknes-11262021
 ---
 # Event Grid
 
+[!INCLUDE [download-alert](includes/download-alert.md)]
+
 [Azure Event Grid](/azure/event-grid/overview) provides serverless infrastructure for event-based applications. You can publish to Event Grid from any source and consume messages from any platform. Event Grid also has built-in support for events from Azure resources to streamline integration with your applications. For example, you can subscribe to blob storage events to notify your app when a file is uploaded. Your application can then publish a custom event grid message that is consumed by other cloud or on-premises applications. Event Grid was built to reliably handle massive scale. You get the benefits of publishing and subscribing to messages without the overhead of setting up the necessary infrastructure.
 
 ![Event Grid logo](./media/event-grid-logo.png)

@@ -0,0 +1,19 @@
+---
+author: IEvangelist
+ms.author: dapine
+ms.date: 04/06/2022
+ms.topic: include
+---
+
+> [!TIP]
+> :::row:::
+> :::column span="3":::
+> This content is an excerpt from the eBook, Serverless apps: Architecture, patterns, and Azure implementation, available on [.NET Docs](/dotnet/architecture/serverless) or as a free downloadable PDF that can be read offline.
+>
+> > [!div class="nextstepaction"]
+> > [Download PDF](https://dotnet.microsoft.com/en-us/download/e-book/serverless-apps-architecture/pdf)
+> :::column-end:::
+> :::column:::
+> :::image type="content" source="../media/cover-thumbnail.png" alt-text="Serverless apps: Architecture, patterns, and Azure implementation eBook cover thumbnail.":::
+> :::column-end:::
+> :::row-end:::
@@ -9,6 +9,8 @@ ms.contributors: jeliknes-09232020
 ---
 # Azure Logic Apps
 
+[!INCLUDE [download-alert](includes/download-alert.md)]
+
 [Azure Logic Apps](/azure/logic-apps) provides a serverless engine to build automated workflows to integrate apps and data between cloud services and on-premises systems. You build workflows using a visual designer. You can trigger workflows based on events or timers and leverage connectors to integration applications and facilitate business-to-business (B2B) communication. Logic Apps integrates seamlessly with Azure Functions.
 
 ![Azure Logic Apps logo](./media/logic-apps-logo.png)

@@ -6,6 +6,8 @@ ms.date: 06/26/2018
 ---
 # Orchestration patterns
 
+[!INCLUDE [download-alert](includes/download-alert.md)]
+
 Durable Functions makes it easier to create stateful workflows that are composed of discrete, long running activities in a serverless environment. Since Durable Functions can track the progress of your workflows and periodically checkpoints the execution history, it lends itself to implementing some interesting patterns.
 
 ## Function chaining

@@ -9,6 +9,8 @@ ms.contributors: jeliknes-10172019
 ---
 # Serverless architecture considerations
 
+[!INCLUDE [download-alert](includes/download-alert.md)]
+
 Adopting a serverless architecture does come with certain challenges. This section explores some of the more common considerations to be aware of. All of these challenges have solutions. As with all architecture choices, the decision to go serverless should be made only after carefully considering the pros and cons. Depending on the needs of your application, you may decide a serverless implementation isn't the right solution for certain components.
 
 ## Managing state

@@ -9,6 +9,8 @@ ms.contributors: jeliknes-11262021
 ---
 # Serverless architecture
 
+[!INCLUDE [download-alert](includes/download-alert.md)]
+
 There are many approaches to using [serverless](https://azure.com/serverless) architectures. This chapter explores examples of common architectures that integrate serverless. It also covers concerns that may pose additional challenges or require extra consideration when implementing serverless. Finally, several design examples are provided that illustrate various serverless use cases.
 
 Serverless hosts often use an existing container-based or PaaS layer to manage the serverless instances. For example, Azure Functions is based on [Azure App Service](/azure/app-service/). The App Service is used to scale out instances and manage the runtime that executes Azure Functions code. For Windows-based functions, the host runs as PaaS and scales out the .NET runtime. For Linux-based functions, the host leverages containers.

@@ -9,6 +9,8 @@ ms.contributors: jeliknes-01282020
 ---
 # Serverless business scenarios and use cases
 
+[!INCLUDE [download-alert](includes/download-alert.md)]
+
 There are many use cases and scenarios for serverless applications. This chapter includes samples that illustrate the different scenarios. The scenarios include links to related documentation and public source code repositories. The samples in this chapter enable you to get started on your own building and implementing serverless solutions.
 
 ## Big data processing

@@ -7,6 +7,8 @@ ms.date: 06/26/2018
 ---
 # Conclusion
 
+[!INCLUDE [download-alert](includes/download-alert.md)]
+
 The following key takeaways are the most important conclusions from this guide.
 
 **Benefits of using serverless.** Serverless solutions provide the important benefit of cost savings because serverless is implemented in a pay-per-use model. Serverless makes it possible to independently scale, test, and deploy individual components of your application. Serverless is uniquely suited to implement microservices architectures and integrates fully into a DevOps pipeline.

@@ -9,6 +9,8 @@ ms.contributors: jeliknes-10172019
 ---
 # Serverless design examples
 
+[!INCLUDE [download-alert](includes/download-alert.md)]
+
 There are many design patterns that exist for serverless. This section captures some common scenarios that use serverless. What all of the examples have in common is the fundamental combination of an event trigger and business logic.
 
 ## Scheduling