Merge pull request #250930 from mattchenderson/coldstart

adding 64-bit requirement notes

Author: prmerger-automator[bot]

articles/azure-functions/dotnet-isolated-process-guide.md

@@ -229,6 +229,7 @@ Placeholders are a platform capability that improves cold start. Normally, you d
 
 - Set the `WEBSITE_USE_PLACEHOLDER_DOTNETISOLATED` application setting to "1"
 - Ensure that the `netFrameworkVersion` property of the function app matches your project's target framework, which must be .NET 6 or later.
+- Ensure that the function app is configured to use a 64-bit process.
 - Update your project file:
     - Upgrade [Microsoft.Azure.Functions.Worker] to version 1.19.0 or later
     - Upgrade [Microsoft.Azure.Functions.Worker.Sdk] to version 1.14.1 or later
@@ -239,11 +240,12 @@ Placeholders are a platform capability that improves cold start. Normally, you d
 > [!NOTE]
 > Setting `FunctionsEnableWorkerIndexing` to "True" may cause an issue when debugging locally using version 4.0.5274 or earlier of the [Azure Functions Core Tools](./functions-run-local.md). The issue manifests with the debugger not being able to attach. If you encounter this issue, remove the `FunctionsEnableWorkerIndexing` property during local testing.
 
-The following CLI commands will set the application setting and update the `netFrameworkVersion` property. Replace `<groupName>` with the name of the resource group, and replace `<appName>` with the name of your function app. Replace `<framework>` with the appropriate version string, such as "v6.0" or "v7.0", according to your target .NET version.
+The following CLI commands will set the application setting, update the `netFrameworkVersion` property, and make the app run as 64-bit. Replace `<groupName>` with the name of the resource group, and replace `<appName>` with the name of your function app. Replace `<framework>` with the appropriate version string, such as "v6.0" or "v7.0", according to your target .NET version.
 
 ```azurecli
 az functionapp config appsettings set -g <groupName> -n <appName> --settings 'WEBSITE_USE_PLACEHOLDER_DOTNETISOLATED=1'
 az functionapp config set -g <groupName> -n <appName> --net-framework-version <framework>
+az functionapp config set -g <groupName> -n <appName> --use-32bit-worker-process false
 ```
 
 The following example shows a project file with the appropriate changes in place:
@@ -326,34 +328,42 @@ You can compile your function app as [ReadyToRun binaries](/dotnet/core/deployin
 
 ReadyToRun requires you to build the project against the runtime architecture of the hosting app. **If these are not aligned, your app will encounter an error at startup.** Select your runtime identifier from the table below:
 
-|Operating System | App is 32-bit | Runtime identifier |
+|Operating System | App is 32-bit<sup>1</sup> | Runtime identifier |
 |-|-|-|
 | Windows | True | `win-x86` |
 | Windows | False | `win-x64` |
 | Linux | True | N/A (not supported) |
 | Linux | False | `linux-x64` | 
 
+<sup>1</sup> Only 64-bit apps are eligible for some other performance optimizations such as [placeholders](#placeholders-preview).
+
 To check if your Windows app is 32-bit or 64-bit, you can run the following CLI command, substituting `<group_name>` with the name of your resource group and `<app_name>` with the name of your application. An output of "true" indicates that the app is 32-bit, and "false" indicates 64-bit.
 
 ```azurecli
  az functionapp config show -g <group_name> -n <app_name> --query "use32BitWorkerProcess"
 ```
 
-To compile your project as ReadyToRun, update your project file by adding the `<PublishReadyToRun>` and `<RuntimeIdentifier>` elements. The following examples shows a configuration for publishing to a Windows 32-bit function app.
+You can change your application to 64-bit with the following command, using the same substitutions:
+
+```azurecli
+az functionapp config set -g <group_name> -n <app_name> --use-32bit-worker-process false`
+```
+
+To compile your project as ReadyToRun, update your project file by adding the `<PublishReadyToRun>` and `<RuntimeIdentifier>` elements. The following examples shows a configuration for publishing to a Windows 64-bit function app.
 
 ```xml
 <PropertyGroup>
   <TargetFramework>net6.0</TargetFramework>
   <AzureFunctionsVersion>v4</AzureFunctionsVersion>
-  <RuntimeIdentifier>win-x86</RuntimeIdentifier>
+  <RuntimeIdentifier>win-x64</RuntimeIdentifier>
   <PublishReadyToRun>true</PublishReadyToRun>
 </PropertyGroup>
 ```
 
-If you don't want to set the `<RuntimeIdentifier>` as part of the project file, you can also configure this as part of the publish gesture itself. For example, with a Windows 32-bit function app, the .NET CLI command would be:
+If you don't want to set the `<RuntimeIdentifier>` as part of the project file, you can also configure this as part of the publish gesture itself. For example, with a Windows 64-bit function app, the .NET CLI command would be:
 
 ```dotnetcli
-dotnet publish --runtime win-x86
+dotnet publish --runtime win-x64
 ```
 
 In Visual Studio, the "Target Runtime" option in the publish profile should be set to the correct runtime identifier. If it is set to the default value "Portable", ReadyToRun will not be used.