Merge branch 'main' into release-microsoft-discovery

Author: v-alje

articles/azure-functions/consumption-plan.md

@@ -10,12 +10,10 @@ ms.custom:
 
 # Azure Functions Consumption plan hosting (legacy)
 
-[!INCLUDE [functions-consumption-legacy-banner](../../includes/functions-consumption-legacy-banner.md)]
+[!INCLUDE [functions-linux-consumption-retirement](../../includes/functions-linux-consumption-retirement.md)]
 
 When you use the Consumption plan, the Azure Functions host dynamically adds and removes instances based on the number of incoming events. 
 
-[!INCLUDE [functions-linux-consumption-retirement](../../includes/functions-linux-consumption-retirement.md)]
-
 The Consumption plan automatically scales, even during periods of high load. When you run functions in a Consumption plan, you pay for compute resources only when your functions are running. On a Consumption plan, a function execution times out after a configurable period of time. The Consumption plan is currently the only serverless hosting option that supports Windows.
 
 ## Billing

articles/azure-functions/functions-versions.md

@@ -26,6 +26,8 @@ Azure Functions currently supports only version 4.x of the runtime host.
 > [!IMPORTANT]
 > Versions 2.x and 3.x of the Azure Functions runtime are no longer supported. For more information, see [Retired versions](#retired-versions).
 
+[!INCLUDE [functions-linux-consumption-retirement](../../includes/functions-linux-consumption-retirement.md)]
+
 [Migrate apps from Azure Functions version 3.x to version 4.x](migrate-version-3-version-4.md).
 
 ## Levels of support
@@ -120,9 +122,7 @@ These versions of the Functions runtime reached end of extended support on Decem
 
 Migrate your apps to version 4.x as soon as possible to get full support. For a complete set of language-specific migration instructions, see [Migrate apps to Azure Functions version 4.x](migrate-version-3-version-4.md).
 
-Apps using versions 2.x and 3.x can still be created and deployed from your CI/CD DevOps pipeline, and all existing apps continue to run without breaking changes. But your apps aren't eligible for new features, security patches, and performance optimizations. You can only get related service support after you upgrade your apps to version 4.x.
-
-Versions 2.x and 3.x are no longer supported because .NET Core 3.1, a core dependency, reached end of support. This requirement affects all [languages supported by Azure Functions](supported-languages.md).
+Apps using versions 2.x and 3.x can still be created and deployed from your CI/CD DevOps pipeline, and existing apps continue to run without breaking changes, except for v3 apps on Linux Consumption, which [will stop running after September 30, 2026](#retired-versions). Your apps aren't eligible for new features, security patches, and performance optimizations. You can only get related service support after you upgrade your apps to version 4.x.
 ::: zone pivot="programming-language-csharp"
 ## Locally developed application versions
 

articles/azure-functions/migrate-version-3-version-4.md

@@ -19,11 +19,13 @@ ms.custom:
 
 # Migrate apps from Azure Functions version 3.x to version 4.x 
 
-Azure Functions version 4.x is highly backwards compatible to version 3.x. Most apps should safely migrate to 4.x without requiring significant code changes. For more information about Functions runtime versions, see [Azure Functions runtime versions overview](./functions-versions.md).
-
 > [!IMPORTANT]
 > As of December 13, 2022, function apps running on versions 2.x and 3.x of the Azure Functions runtime have reached the end of extended support. For more information, see [Retired versions](functions-versions.md#retired-versions).
 
+Azure Functions version 4.x is highly backwards compatible to version 3.x. Most apps should safely migrate to 4.x without requiring significant code changes. For more information about Functions runtime versions, see [Azure Functions runtime versions overview](./functions-versions.md).
+
+[!INCLUDE [functions-linux-consumption-retirement](../../includes/functions-linux-consumption-retirement.md)]
+
 This article walks you through the process of safely migrating your function app to run on version 4.x of the Functions runtime. Because project migration instructions are language dependent, make sure to choose your development language from the selector at the top of the article.
 
 ## Identify function apps to migrate

articles/azure-functions/migration/migrate-aws-lambda-to-azure-functions.md

@@ -32,25 +32,59 @@ This article doesn't address:
 - Hosting AWS Lambda containers in Azure.
 - Fundamental Azure adoption approaches by your organization, such as [Azure landing zones](/azure/cloud-adoption-framework/ready/landing-zone/) or other topics addressed in the Cloud Adoption Framework [migrate methodology](/azure/cloud-adoption-framework/migrate/).
 
-## Migration custom chat mode
+## Migrate with GitHub Copilot and Azure Skills
 
-To make it easier to migrate your AWS Lambda apps to Azure using Visual Studio Code, Azure Functions provides a [custom chat mode](https://code.visualstudio.com/docs/copilot/customization/custom-chat-modes) in GitHub Copilot. Use these steps to add the `LambdaToFunctionMigration` custom chat mode to your project in Visual Studio Code:
+GitHub Copilot with Azure Skills has built-in support to guide migration from AWS Lambda to Azure Functions.
 
-1. If you don't already have the [GitHub Copilot for Azure](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azure-github-copilot) Visual Studio Code extension, install it now.
+You can use Copilot to automate most migration steps interactively, while using this article as your reference for architecture decisions, validation, and production readiness.
 
-1. Open your Lambda project as a workspace in Visual Studio Code.
+To use Azure Skills in GitHub Copilot (in VS Code or Copilot CLI), follow these steps:
 
-1. Run this prompt in **Agent** mode in GitHub Copilot:
+### Prerequisites
 
-   ```copilot-prompt
-   Help me migrate my Lambda app to Azure
+- **Node.js 18+** - required for MCP servers ([Download Node.js](https://nodejs.org/en/download/))
+- Access to an **Azure subscription** for creating and testing your migrated function app.
+- **Azure CLI (`az`)** installed and authenticated ([Install Azure CLI](/cli/azure/install-azure-cli)) (`az login`)
+- **Azure Developer CLI (`azd`)** installed and authenticated ([Install Azure Developer CLI](/azure/developer/azure-developer-cli/install-azd)) (`azd auth login`)
+
+### For GitHub Copilot CLI
+
+1. [Install Copilot CLI](https://github.com/github/copilot-cli)
+2. Add the marketplace source (first time only):
+   ```
+   /plugin marketplace add microsoft/azure-skills
+   ```
+3. Install the plugin:
+   ```
+   /plugin install azure@azure-skills
+   ```
+4. After install, reload MCP servers:
    ```
+   /mcp reload
+   ```
+5. Verify installation:
+   ```
+   /mcp status
+   ```
+   You should see the azure MCP server listed and running.
 
-1. When prompted in the notification area, select **Install** to add the `LambdaToFunctionMigration` custom chat mode to your project.
-   
-You can now use guided prompts defined in this custom chat for each stage of your migration. Start typing `/LambdaMigration` in chat to see the complete list of available commands.
+### For Visual Studio Code
 
-### Compare functionality
+1. [Install the Azure MCP extension](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azure-mcp-server) from the VS Code Marketplace (Extension ID: `ms-azuretools.vscode-azure-mcp-server`).
+2. The extension auto-installs a companion extension, GitHub Copilot for Azure, which contains the Azure skills.
+3. Open Copilot Chat (Ctrl+Shift+I / Cmd+Shift+I).
+4. Make sure you're in Agent mode (not Ask or Edit mode).
+5. Open the Command Palette (Ctrl+Shift+P) -> search "MCP" -> verify servers are listed and running.
+
+Use this prompt to start and continue the migration workflow in Copilot:
+
+```copilot-prompt
+Help me migrate my Lambda app to Azure Functions
+```
+
+This prompt guides the migration in phases: first generating a detailed assessment report, then migrating code and configuration, and finally building the required infrastructure-as-code (IaC) assets for deployment to Azure.
+
+## Compare functionality
 
 This article maps AWS Lambda features to Azure Functions equivalents to help ensure compatibility.
 
@@ -77,13 +111,6 @@ The first step is to conduct a detailed discovery process to evaluate your exist
 - Cost of ownership
 - Performance targets and current performance
 
-> [!TIP]
-> Use this custom chat mode prompt to generate an assessment report for your AWS Lambda setup:
-> 
-> ```copilot-prompt
-> /LambdaMigration-Phase1-AssessLambdaProject
-> ```
-
 ## Perform premigration planning
 
 Before you start migrating your workload, you must map AWS Lambda features to Azure Functions to ensure compatibility and develop a migration plan. Then you can select key workloads for a proof of concept.
@@ -262,26 +289,13 @@ The following tables compare AWS Lambda concepts, resources, and properties with
 
 1. Test iteratively and gather feedback.
 
-   > [!TIP]
-   > Use this custom chat mode prompt to check the current status of the migration process at any time:
-   > 
-   > ```copilot-prompt
-   > /LambdaMigration-GetStatus
-   > ```
-
    Use the proof of concept to gather feedback, identify gaps, and fine-tune the process before you scale to larger workloads. This iterative approach ensures that by the time you move to full-scale migration, you address potential challenges and refine the process.
 
 ## Build the migration assets
 
 This step is a transitional development phase. During this phase, you build source code, infrastructure as code (IaC) templates, and deployment pipelines to represent the workload in Azure. You must adapt function code for compatibility and best practices before you can perform the migration.
 
 - [Adapt function code, configuration files, and infrastructure as code files](#adapt-function-code-configuration-files-and-infrastructure-as-code-files)
-   > [!TIP]
-   > Use this custom chat mode prompt to start the code migration process:
-   > 
-   > ```copilot-prompt
-   > /LambdaMigration-Phase2-MigrateLambdaCode
-   > ```
 - [Adjust configuration settings](#adjust-configuration-settings)
 - [Generate IaC files](#generate-iac-files)
 - [Use tools for refactoring](#use-tools-for-refactoring)
@@ -614,13 +628,6 @@ Deployments follow a single path. After you build your project code and zip it i
 
 - Use tools like Bicep, Azure Resource Manager templates, or Terraform to create IaC files to deploy Azure resources.
 
-   > [!TIP]
-   > Use this custom chat mode prompt to generate infrastructure as code (IaC) files for Azure Functions:
-   > 
-   > ```copilot-prompt
-   > /LambdaMigration-Phase3-GenerateFunctionsInfra
-   > ```
-
 - Define resources such as Azure Functions, storage accounts, and networking components in your IaC files.
 
 - Use this [IaC samples repository](https://github.com/Azure-Samples/azure-functions-flex-consumption-samples/tree/main/IaC) for samples that use Azure Functions recommendations and best practices.
@@ -629,9 +636,6 @@ Deployments follow a single path. After you build your project code and zip it i
 
 Use tools like GitHub Copilot in VS Code for help with code refactoring, manual refactoring for specific changes, or other migration aids.
 
-> [!NOTE]
-> Use *Agent mode* in GitHub Copilot in VS Code.
-
 The following articles provide specific examples and detailed steps to facilitate the migration process:
 
 - [Azure for AWS professionals](/azure/architecture/aws-professional)
@@ -647,13 +651,6 @@ Develop failover and failback strategies for your migration and thoroughly test
 
    - Test each function thoroughly to ensure that it works as expected. These tests should include input/output, event triggers, and bindings verification.
 
-      > [!TIP]
-      > Use this custom chat mode prompt to validate the migrated Azure Functions code:
-      > 
-      > ```copilot-prompt
-      > /LambdaMigration-Phase4-ValidateCode
-      > ```
-
    - Use tools like curl or [REST Client](https://marketplace.visualstudio.com/items?itemName=humao.rest-client) extensions on VS Code to send HTTP requests for HTTP-triggered functions.
 
    - For other triggers, such as timers or queues, ensure that the triggers fire correctly and the functions run as expected.
@@ -663,13 +660,6 @@ Develop failover and failback strategies for your migration and thoroughly test
    - Conduct performance testing to compare the new Azure Functions deployment with the previous AWS Lambda deployment.
 
    - Monitor metrics like response time, run time, and resource consumption.
- 
-      > [!TIP]
-      > Use this custom chat mode prompt to validate the infrastructure configuration:
-      > 
-      > ```copilot-prompt
-      > /LambdaMigration-Phase5-ValidateInfra
-      > ```
 
    - Use Application Insights for [monitoring, log analysis, and troubleshooting](/azure/azure-functions/functions-monitoring) during the testing phase.
 
@@ -685,13 +675,6 @@ Deploy and test functions to validate their performance and correctness.
 
 ### Deploy to Azure
 
-> [!TIP]
-> Use this custom chat mode prompt to deploy the validated project to Azure:
-> 
-> ```copilot-prompt
-> /LambdaMigration-Phase6-DeployToAzure
-> ```
-
 Deploy workloads by using the [VS Code](/azure/azure-functions/functions-develop-vs-code#publish-to-azure) publish feature. You can also deploy workloads from the command line by using [Azure Functions Core Tools](/azure/azure-functions/functions-run-local#project-file-deployment) or the [Azure CLI](/cli/azure/functionapp/deployment/source#az-functionapp-deployment-source-config-zip). [Azure DevOps](/azure/azure-functions/functions-how-to-azure-devops#deploy-your-app) and [GitHub Actions](/azure/azure-functions/functions-how-to-github-actions) also use One Deploy.
 
 - Azure Functions Core Tools: [Deploy your function app](/azure/azure-functions/flex-consumption-how-to#deploy-your-code-project) by using [Azure Functions Core Tools](/azure/azure-functions/functions-run-local) with the `func azure functionapp publish <FunctionAppName>` command.

articles/azure-resource-manager/bicep/toc.yml

@@ -627,7 +627,7 @@ items:
   - name: Resource reference
     href: /azure/templates/
   - name: Bicep CLI
-    displayName: build,decompile,decompile-params, format,generate-params,install,jsonrpc,lint,list-versions,list versions,publish,restore,upgrade,version,module,registry
+    displayName: build,console,decompile,decompile-params, format,generate-params,install,jsonrpc,lint,list-versions,list versions,publish,restore,upgrade,version,module,registry
     href: bicep-cli.md
   - name: Azure CLI
     href: /cli/azure/resource

articles/cost-management-billing/reservations/reservation-renew.md

@@ -13,7 +13,7 @@ ms.author: primittal
 
 # Automatically renew reservations
 
-You can renew reservations to automatically purchase a replacement when an existing reservation expires. Automatic renewal provides an easy way to continue getting reservation discounts. It also saves you from having to closely monitor a reservation's expiration. With automatic renewal, you prevent savings benefits loss by not having to manually renew. *The renewal setting is turned on by default* when you make a purchase. You can manually turn off the renewal setting at the time of purchase. After purchase, you can enable or disable the renewal setting anytime by selecting your reservation at Azure portal>Reservations, up to the expiration of the existing reservation. *When auto-renew is enabled, you have to manually turn it off to stop automatic renewal*.
+You can renew reservations to automatically purchase a replacement when an existing reservation expires. Automatic renewal provides an easy way to continue getting reservation discounts. It also saves you from having to closely monitor a reservation's expiration. With automatic renewal, you prevent savings benefits loss by not having to manually renew. *The renewal setting is turned on by default* when you make a purchase. You can manually turn off the renewal setting at the time of purchase. After purchase, you can enable or disable the renewal setting 48 hours before the expiry date time by selecting your reservation at Azure portal>Reservations, up to the expiration of the existing reservation. *When auto-renew is enabled, you have to manually turn it off to stop automatic renewal*.
 
 The renewal price is available 30 days before the expiry of existing reservation. You can view the current rates and discounts by selecting your reservation at Azure portal>Reservations. When you enable renewal more than 30 days before the reservation expiration, you're sent an email detailing renewal costs before expiration. The reservation price might change between the time that you lock the renewal price and the renewal time. If so, your renewal will not be processed and you can purchase a new reservation in order to continue getting the benefit.
 

articles/governance/policy/concepts/definition-structure-policy-rule.md

@@ -665,10 +665,15 @@ The following functions are only available in policy rules:
     ```
 
   - `http: //schemas.microsoft.com/identity/claims/objectidentifier`: returns the user (or object) ID associated with the request.
-  ```json
-   "value": "[tryGet(requestContext().identity, 'http: //schemas.microsoft.com/identity/claims/objectidentifier')]",
-   "in": ['userId']
-```
+    ```json
+       "value": "[tryGet(requestContext().identity, 'http: //schemas.microsoft.com/identity/claims/objectidentifier')]",
+       "in": ['userId']
+    ```
+    
+> [!WARNING]
+> When you use the `requestContext().identity` function, the policy engine marks the policy as `NotApplicable` for compliance evaluation/scans. As a result, compliance results for that policy show as `NotApplicable`, but enforcement of effects such as `Deny`, `DeployIfNotExists`, and `Modify` still occurs at request time.
+
+
 - `policy()`
   - Returns the following information about the policy that is being evaluated. Properties can be accessed from the returned object (example: `[policy().assignmentId]`).