+az webapp config appsettings set --name <app-name> --resource-group <resource-group-name> --settings WEBSITE_NODE_DEFAULT_VERSION="~16"

+> [!NOTE]

+> This example uses the recommended "tilde syntax" to target the latest available version of Node.js 16 runtime on App Service.

+>

+>Since the runtime is regularly patched and updated by the platform it's not recommended to target a specific minor version/patch as these are not guaranteed to be available due to potential security risks.

+az webapp config set --resource-group <resource-group-name> --name <app-name> --linux-fx-version "NODE|14-lts"

+App Service supports a variety of development frameworks, including ASP.NET, classic ASP, Node.js, PHP, and Python.

+In order to simplify and normalize security configuration, App Service apps typically run the various development frameworks with their default settings. The frameworks and runtime components provided by the platform are updated regularly to satisfy security and compliance requirements, for this reason we do not guarantee specific minor/patch versions and recommend customers target major version as needed.

+az webapp config appsettings set --settings WEBSITE_NODE_DEFAULT_VERSION=~14 --resource-group <groupname> --name <appname>

+> [!NOTE]

+> This example uses the recommended "tilde syntax" to target the latest available version of Node.js 16 runtime on Windows App Service.

+>

+Go to **Azure Active Directory**, and then select **Enterprise applications**. This pane displays all the service principals in your tenant. In **Managed Identities**, select the service principal for the managed identity.

+If you're following this tutorial, there are two service principals with the same display name (SecureWebApp2020094113531, for example). The service principal that has a **Homepage URL** represents the web app in your tenant. The service principal that appears in **Managed Identities** should *not* have a **Homepage URL** listed and the **Object ID** should match the object ID value of the managed identity in the [previous step](#enable-managed-identity-on-app).

+The [ChainedTokenCredential](/dotnet/api/azure.identity.chainedtokencredential), [ManagedIdentityCredential](/dotnet/api/azure.identity.managedidentitycredential), and [EnvironmentCredential](/dotnet/api/azure.identity.environmentcredential) classes are used to get a token credential for your code to authorize requests to Microsoft Graph. Create an instance of the [ChainedTokenCredential](/dotnet/api/azure.identity.chainedtokencredential) class, which uses the managed identity in the App Service environment or the development environment variables to fetch tokens and attach them to the service client. The following code example gets the authenticated token credential and uses it to create a service client object, which gets the users in the group.

+ // Create the Graph service client with a ChainedTokenCredential which gets an access

+ // token using the available Managed Identity or environment variables if running

+ // in development.

+ var credential = new ChainedTokenCredential(

+ new ManagedIdentityCredential(),

+ new EnvironmentCredential());

+> **File System Usage** is now available globally for apps hosted in multi-tenants and App Service Environment.

+## V1 SKUs

+Standard Application Gateway and WAF V1 SKUs are billed as a combination of:

+* Fixed Cost

+ Cost based on the time a particular type of Application Gateway/WAF is provisioned and running for processing requests.

+ The fixed cost component takes in consideration the following factors:

+ * Tier - Standard Application Gateway or WAF

+ * Size - Small, Medium & Large

+ * Instance Count - Number of instances to be deployed

+ For N instances, the costs associated will be N * cost of one Instance of a particular Tier(Standard & WAF) & Size(Small, Medium & Large) combination.

+* Variable Cost

+ Cost based on the amount of data processed by the Application Gateway/WAF. Both the request and response bytes processed by the Application Gateway would be considered for billing.

+Total Cost = Fixed Cost + Variable Cost

+### Standard Application Gateway

+Fixed Cost & Variable Cost will be calculated according to the Application Gateway type.

+The following table shows example prices based on a snapshot of East US pricing and are meant for illustration purposes only.

+#### Fixed Cost (East US region pricing)

+| Application Gateway Type | Costs ($/hr) |

+| - | |

+| Small | $0.025 |

+| Medium | $0.07 |

+| Large | $0.32 |

+Monthly price estimates are based on 730 hours of usage per month.

+#### Variable Cost (East US region pricing)

+| Data Processed | Small ($/GB) | Medium ($/GB) | Large ($/GB) |

+| | -- | -- | - |

+| First 10 TB/month | $0.008 | Free | Free |

+| Next 30 TB (10ΓÇô40 TB)/month | $0.008 | $0.007 | Free |

+| Over 40 TB/month | $0.008 | $0.007 | $0.0035 |

+For more pricing information according to your region, see the [pricing page](https://azure.microsoft.com/pricing/details/application-gateway/).

+### WAF V1

+Fixed Cost & Variable Costs will be calculated according to the provisioned Application Gateway type.

+The following table shows example prices based on a snapshot of East US pricing and are for illustration purposes only.

+#### Fixed Cost (East US region pricing)

+| Application Gateway Type | Costs ($/hr) |

+| - | |

+| Small | NA |

+| Medium | $0.126 |

+| Large | $0.448 |

+Monthly price estimates are based on 730 hours of usage per month.

+#### Variable Cost (East US region pricing)

+| Data Processed | Small ($/GB) | Medium ($/GB) | Large ($/GB) |

+| | -- | -- | - |

+| First 10 TB/month | $0.008 | Free | Free |

+| Next 30 TB (10ΓÇô40 TB)/month | $0.008 | $0.007 | Free |

+| Over 40 TB/month | $0.008 | $0.007 | $0.0035 |

+For more pricing information according to your region, see the [pricing page](https://azure.microsoft.com/pricing/details/application-gateway/).

+> [!NOTE]

+> Outbound data transfers - data going out of Azure data centers from application gateways will be charged at standard [data transfer rates](https://azure.microsoft.com/pricing/details/bandwidth/).

+### Example 1 (a) ΓÇô Standard Application Gateway with 1 instance count

+LetΓÇÖs assume youΓÇÖve provisioned a standard Application Gateway of medium type with 1 instance and it processes 500 GB in a month.

+Your Application Gateway costs using the pricing mentioned above would be calculated as follows:

+Fixed Price = $0.07 * 730 (Hours) = $51.1

+Monthly price estimates are based on 730 hours of usage per month.

+Variable Costs = Free (Medium tier has no costs for the first 10 TB processed per month)

+Total Costs = $51.1 + 0 = $51.1

+> [!NOTE]

+> To support high availability scenarios, it is required to setup a minimum of 2 instances for V1 SKUs. See [SLA for Application Gateway](https://azure.microsoft.com/support/legal/sla/application-gateway/v1_2/)

+### Example 1 (b) ΓÇô Standard Application Gateway with > 1 instance count

+LetΓÇÖs assume youΓÇÖve provisioned a standard Application Gateway of medium type with five instances and it processes 500 GB in a month.

+Your Application Gateway costs using the pricing mentioned above would be calculated as follows:

+Fixed Price = 5 (Instance count) * $0.07 * 730 (Hours) = $255.5

+Monthly price estimates are based on 730 hours of usage per month.

+Variable Costs = Free (Medium tier has no costs for the first 10 TB processed per month)

+Total Costs = $255.5 + 0 = $255.5

+### Example 2 ΓÇô WAF Application Gateway

+LetΓÇÖs assume youΓÇÖve provisioned a small type standard Application Gateway and a large type WAF Application Gateway for the first 15 days of the month. The small application gateway processes 15 TB in the duration that it is active and the large WAF application gateway processes 100 TB in the duration that it is active.

+Your Application Gateway costs using the pricing mentioned above would be calculated as follows:

+###### Small instance Standard Application Gateway

+24 Hours * 15 Days = 360 Hours

+Fixed Price = $0.025 * 360 (Hours) = $9

+Variable Costs = 10 * 1000 * $0.008/GB + 5 * 1000 * $0.008/GB = $120

+Total Costs = $9 + $120 = $129

+###### Large instance WAF Application Gateway

+24 Hours * 15 Days = 360 Hours

+Fixed Price = $0.448 * 360 (Hours) = $161.28

+Variable Costs = 60 * 1000 * $0.0035/GB = $210 (Large tier has no costs for the first 40 TB processed per month)

+Total Costs = $161.28 + $210 = $371.28

+## Compare complete files

+The [Bicep Playground](https://aka.ms/bicepdemo) lets you view Bicep and equivalent JSON side by side. You can compare the implementations of the same infrastructure.

+For example, you can view the file to deploy a [SQL server and database](https://aka.ms/bicepdemo#eJx1kctqwzAQRff+Ci0KsqF+JIvSGgohBLppS8FfMLUnQdSW5JGcLIL/vfJDaRrinebq3tGckQaChhmkI9InNMiMJSEP7JV1UrQdFmMZctPW/JERGtVRiW+kOh1GiaiiQE8d2nq3/d+AF9DoGndbPntqVYIVSv5Zbvt5xxyAqhFSODdYRe/qIHw0CDYGy44wjBatX2DMSVF1ifjHZlrGP0RJyqi9TYq2TifVbNbZ6iXOnuJsFWvCo8ATd5OeA8akw8uvduUkP3B+OTlRk9JIVqDJxxy7M11+R1uwepB7EX/non3QXzMO/7GAmFZg4RsMDrDrLM6eF2H5w3kKJUPdp670H93zJX7z03nwuUthQVZAFR9Ftxm6EYfhfwGNyOE5). The Bicep is about half the size of the ARM template.

+## Benefits of Bicep

+Bicep provides the following advantages:

+- **Repeatable results**: Repeatedly deploy your infrastructure throughout the development lifecycle and have confidence your resources are deployed in a consistent manner. Bicep files are idempotent, which means you can deploy the same file many times and get the same resource types in the same state. You can develop one file that represents the desired state, rather than developing lots of separate files to represent updates.

+- **Orchestration**: You don't have to worry about the complexities of ordering operations. Resource Manager orchestrates the deployment of interdependent resources so they're created in the correct order. When possible, Resource Manager deploys resources in parallel so your deployments finish faster than serial deployments. You deploy the file through one command, rather than through multiple imperative commands.

+ :::image type="content" source="./media/overview/bicep-processing.png" alt-text="Bicep deployment comparison" border="false":::

+- **Preview changes**: You can use the [what-if operation](./deploy-what-if.md) to get a preview of changes before deploying the Bicep file. With what-if, you see which resources will be created, updated, or deleted, and any resource properties that will be changed. The what-if operation checks the current state of your environment and eliminates the need to manage state.

+- **No state or state files to manage**: All state is stored in Azure. Users can collaborate and have confidence their updates are handled as expected.

+You can use [Speech-to-text REST API v3.0](rest-speech-to-text.md#speech-to-text-rest-api-v30) to automate any operations related to your custom models. In particular, you can use the REST API to upload a dataset.

+## Speech - Speaker Recognition

+* [Transparency note and use cases](/legal/cognitive-services/speech-service/speaker-recognition/transparency-note-speaker-recognition?context=/azure/cognitive-services/speech-service/context/context)

+* [Characteristics and limitations](/legal/cognitive-services/speech-service/speaker-recognition/characteristics-and-limitations-speaker-recognition?context=/azure/cognitive-services/speech-service/context/context)

+* [Data, privacy, and security](/legal/cognitive-services/speech-service/speaker-recognition/data-privacy-speaker-recognition?context=/azure/cognitive-services/speech-service/context/context)

+* [Data, privacy, and security](/legal/cognitive-services/luis/data-privacy-security?context=/azure/cognitive-services/LUIS/context/context)

+* [Develop locally with the Azure Cosmos DB Emulator](../local-emulator.md)

+<tr><td>Native change data capture (CDC) now natively supported</td><td>CDC is now natively supported in Azure Data Factory for CosmosDB, Blob Store, Azure Data Lake Storage Gen1 and Gen2, and common data model (CDM).<br><a href="https://techcommunity.microsoft.com/t5/azure-data-factory-blog/cosmosdb-change-feed-is-supported-in-adf-now/ba-p/3037011">Learn more</a></td></tr>

+- ['Active Alerts' workbook](#use-the-active-alerts-workbook) - view active alerts by severity, type, tag, MITRE ATT&CK tactics, and location.

+The new recommendation, **Running container images should have vulnerability findings resolved** groups running images that have vulnerabilities and provides details about the issues discovered and how to remediate them.

+ > Learn more about tags in [Use tags to organize your Azure resources and management hierarchy](/azure/azure-resource-manager/management/tag-resources).

+- Explore the [Microsoft Defender for Storage ΓÇô Price Estimation Dashboard](https://techcommunity.microsoft.com/t5/microsoft-defender-for-cloud/microsoft-defender-for-storage-price-estimation-dashboard/ba-p/2429724)

+- [Save Storage telemetry for investigation](/azure/azure-monitor/essentials/diagnostic-settings)

+| [AWS recommendations to GA](#aws-recommendations-to-ga) | March 2022 |

+| [Relocation of custom recommendations](#relocation-of-custom-recommendations) | March 2022 |

+### AWS recommendations to GA

+**Estimated date for change:** March 2022

+There are currently AWS recommendations in the preview stage. These recommendations come from the AWS Foundational Security Best Practices standard which is assigned by default. All of the recommendations will become Generally Available (GA) in March 2022.

+When these recommendations go live, their impact will be included in the calculations of your secure score. Expect changes to your secure score.

+**To find these recommendations**:

+1. Navigate to **Environment settings** > **`AWS connector`** > **Standards (preview)**.

+1. Right click on **AWS Foundational Security Best Practices (preview)**, and select **view assessments**.

+### Relocation of custom recommendations

+**Estimated date for change:** March 2022

+Custom recommendation are those created by a user, and have no impact on the secure score. Therefore, the custom recommendations are being relocated from the Secure score recommendations tab to the All recommendations tab.

+When the move occurs, the custom recommendations will be found via a new "recommendation type" filter.

+Learn more:

+- [Create custom security initiatives and policies](custom-security-policies.md).

+## Creating key using ARM template is different from creating key via data plane

+### Creating a key via ARM

+- It is only possible to create *new* keys. It is not possible to update existing keys, and it is not possible to create new versions of existing keys. If the key already exists, then the existing key is retrieved from storage and used (no write operations will occur).

+- To be authorized to use this API, the caller needs to have the **"Microsoft.KeyVault/vaults/keys/write"** RBAC Action. The built-in "Key Vault Contributor" role is sufficient, since it authorizes all RBAC Actions which match the pattern "Microsoft.KeyVault/*". See the below screenshots for more information.

+### Existing API (creating key via data plane)

+- It is possible to create new keys, update existing keys, and create new versions of existing keys.

+- To be authorized to use this API, the caller either needs to have the "create" key permission (if the vault uses access policies) or the "Microsoft.KeyVault/vaults/keys/create/action" RBAC DataAction (if the vault is enabled for RBAC).

+- Review the [Key Vault security overview](../general/security-features.md)

+To grant GitHub Actions access to your Azure Load Testing resource, perform the following steps:

+1. Create a service principal that has the permissions to access Azure Load Testing.

+1. Configure a GitHub secret with the service principal information.

+1. Authenticate with Azure using [Azure Login](https://github.com/Azure/login).

+### Create a service principal

+First, you'll create an Azure Active Directory [service principal](/azure/active-directory/develop/app-objects-and-service-principals#service-principal-object) and grant it the permissions to access your Azure Load Testing resource.

+1. Run the following Azure CLI command to create a service principal and assign the *Contributor* role:

+ > [!NOTE]

+ > Azure Login supports multiple ways to authenticate with Azure. For other authentication options, see the [Azure and GitHub integration site](/azure/developer/github).

+ The output is the role assignment credentials that provide access to your resource. The command should output a JSON object similar to this.

+ "clientId": "<GUID>",

+ "clientSecret": "<GUID>",

+ "subscriptionId": "<GUID>",

+ "tenantId": "<GUID>",

+1. Copy this JSON object, which you can use to authenticate from GitHub.

+1. Grant permissions to the service principal to create and run tests with Azure Load Testing. The Load Test Contributor role grants permissions to create, manage and run tests in an Azure Load Testing resource.

+ Next, run the following Azure CLI command to assign the *Load Test Contributor* role to the service principal.

+ --subscription "<subscription-id>"

+

+ In the previous command, replace the placeholder text `<sp-object-id>` with the `ObjectId` value from the previous Azure CLI command. Also, replace `<subscription-id>` with your Azure subscription ID.

+### Configure the GitHub secret

+You'll add a GitHub secret to your repository for the service principal you created in the previous step. The Azure Login action uses this secret to authenticate with Azure.

+1. In [GitHub](https://github.com), browse to your forked repository, select **Settings** > **Secrets** > **New repository secret**.

+ :::image type="content" source="./media/tutorial-cicd-github-actions/github-new-secret.png" alt-text="Screenshot that shows selections for adding a new repository secret to your GitHub repo.":::

+1. Paste the JSON role assignment credentials that you copied previously, as the value of secret variable *AZURE_CREDENTIALS*.

+ :::image type="content" source="./media/tutorial-cicd-github-actions/github-new-secret-details.png" alt-text="Screenshot that shows the details of the new GitHub repository secret.":::

+### Authenticate with Azure

+You can now use the `AZURE_CREDENTIALS` secret with the Azure Login action in your CI/CD workflow. The *workflow.yml* file in the sample application already has the necessary configuration:

+You've now authenticated with Azure from the GitHub. You'll now configure the CI/CD workflow to run a load test by using Azure Load Testing.

+>[!NOTE]

+> Support for computer vision tasks: image classification (multi-class and multi-label), object detection, and instance segmentation is available in public preview. [Learn more about computer vision tasks in automated ML](concept-automated-ml.md#when-to-use-automl-classification-regression-forecasting--computer-vision).<br><br> This preview version is provided without a service-level agreement. Certain features might not be supported or might have constrained capabilities. For more information, see [Supplemental Terms of Use for Microsoft Azure Previews](https://azure.microsoft.com/support/legal/preview-supplemental-terms/).

+See the [SupportedModels reference documentation](/python/api/azureml-train-automl-client/azureml.train.automl.constants.supportedmodels) for a summarization of the supported models by task type.

+> [!Note]

+> [!NOTE]

+> Automated machine learning featurization steps (feature normalization, handling missing data, converting text to numeric, etc.) become part of the underlying model. When using the model for predictions, the same featurization steps applied during training are applied to your input data automatically.

+You can view the hyperparameters, the scaling and normalization techniques, and algorithm applied to a specific automated ML run with the [custom code solution, `print_model()`](how-to-configure-auto-features.md#scaling-and-normalization).

+| **RegionCodes-GetRegionCodesAsync**<br/>Service Bus/EventHub/Relay Get Namespace<br/>```GET https://management.core.windows.net/{subscription ID}/services/ServiceBus/Namespaces/{namespace name}``` | &nbsp; | &nbsp; | &nbsp; |

+| **EventHubsCrud-ListEventHubsAsync**<br/>[List Event Hubs](/rest/api/eventhub/list-event-hubs)<br/>```GET https://management.core.windows.net/{subscription ID}/services/ServiceBus/Namespaces/{namespace name}/eventhubs?$skip={skip}&$top={top}``` | &nbsp; | [list](/rest/api/eventhub/preview/event-hubs/list-by-namespace) | &nbsp; |

+ Title: Capture heap dump and thread dump manually and use Java Flight Recorder in Azure Spring Cloud

+description: Learn how to manually capture a heap dump, a thread dump, or start Java Flight Recorder.

+# Capture heap dump and thread dump manually and use Java Flight Recorder in Azure Spring Cloud

+This article describes how to manually generate a heap dump or thread dump, and how to start Java Flight Recorder (JFR).

+Effective troubleshooting is critical to ensure you can fix issues in production environments and keep your business online. Azure Spring Cloud provides application log streaming and query, rich metrics emitting, alerts, distributed tracing, and so forth. However, when you get alerts about requests with high latency, JVM heap leak, or high CPU usage, there's no last-mile solution. For this reason, we've enabled you to manually generate a heap dump, generate a thread dump, and start JFR.

+* A deployed Azure Spring Cloud service instance. To get started, see [Quickstart: Deploy your first application to Azure Spring Cloud](quickstart.md).

+* Your own persistent storage as described in [How to enable your own persistent storage in Azure Spring Cloud](how-to-custom-persistent-storage.md). This storage is used to save generated diagnostic files. The paths you provide in the parameter values below should be under the mount path of the persistent storage bound to your app. If you want to use a path under the mount path, be sure to create the subpath beforehand.

+Use the following command to generate a heap dump of your app in Azure Spring Cloud.

+```azurecli

+az spring-cloud app deployment generate-heap-dump \

+ --resource-group <resource-group-name> \

+ --service <Azure-Spring-Cloud-instance-name> \

+ --app <app-name> \

+ --deployment <deployment-name> \

+ --app-instance <app-instance name> \

+ --file-path <your-target-file-path-in-your-persistent-storage-mount-path>

+Use the following command to generate a thread dump of your app in Azure Spring Cloud.

+```azurecli

+az spring-cloud app deployment generate-thread-dump \

+ --resource-group <resource-group-name> \

+ --service <Azure-Spring-Cloud-instance-name> \

+ --app <app-name> \

+ --deployment <deployment-name> \

+ --app-instance <app-instance name> \

+ --file-path <your-target-file-path-in-your-persistent-storage-mount-path>

+Use the following command to start JFR for your app in Azure Spring Cloud.

+```azurecli

+az spring-cloud app deployment start-jfr \

+ --resource-group <resource-group-name> \

+ --service <Azure-Spring-Cloud-instance-name> \

+ --app <app-name> \

+ --deployment <deployment-name> \

+ --app-instance <app-instance name> \

+ --file-path <your-target-file-path-in-your-persistent-storage-mount-path> \

+ --duration <duration-of-JFR>

+The default value for `duration` is 60 seconds.

+Navigate to the target file path in your persistent storage and find your dump/JFR. From there, you can download them to your local machine. The name of the generated file will be similar to *`<app-instance>_heapdump_<time-stamp>.hprof`* for the heap dump, *`<app-instance>_threaddump_<time-stamp>.txt`* for the thread dump, and *`<app-instance>_JFR_<time-stamp>.jfr`* for the JFR file.

+## Next steps

+- [Use the diagnostic settings of JVM options for advanced troubleshooting in Azure Spring Cloud](how-to-dump-jvm-options.md)

+ Title: Use the diagnostic settings of JVM options for advanced troubleshooting in Azure Spring Cloud

+description: Describes several best practices with JVM configuration to set heap dump, JFR, and GC logs.

+# Use the diagnostic settings of JVM options for advanced troubleshooting in Azure Spring Cloud

+**This article applies to:** ✔️ Java ❌ C#

+This article describes how to use diagnostic settings through JVM options to conduct advanced troubleshooting in Azure Spring Cloud.

+There are several JVM-based application startup parameters related to heap dump, Java Flight Recorder (JFR), and garbage collection (GC) logs. In Azure Spring Cloud, we support JVM configuration using JVM options.

+For more information on configuring JVM-based application startup parameters, see [az spring-cloud app deployment](/cli/azure/spring-cloud/app/deployment) in the Azure CLI reference documentation. The following sections provide several examples of useful values for the `--jvm-options` parameter.

+## Prerequisites

+* A deployed Azure Spring Cloud service instance. Follow our [quickstart on deploying an app via the Azure CLI](./quickstart.md) to get started.

+* At least one application already created in your service instance.

+* Your own persistent storage as described in [How to enable your own persistent storage in Azure Spring Cloud](how-to-custom-persistent-storage.md). This storage is used to save generated diagnostic files. The paths you provide in the parameter values below should be under the mount path of the persistent storage bound to your app. If you want to use a path under the mount path, be sure to create the subpath beforehand.

+## Generate a heap dump when out of memory

+Use the following `--jvm-options` parameter to generate a heap dump when you encounter an out-of-memory error.

+```azurecli

+--jvm-options="-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=<path-to-heap-dump-folder>"

+```

+As alternative to specifying the path to the heap dump folder, you can provide a specific file name. However, we highly recommend that you provide a folder path instead. If you provide a file name, the command will generate a heap dump for the first out-of-memory error only, due to the limitations of the HPROF file format. If you provide a folder path, you'll get a heap dump in a file with an autogenerated name for each out-of-memory error.

+## Generate GC logs

+Use the following `--jvm-options` parameter to generate GC logs. For more information, see the official JVM documentation.

+```azurecli

+--jvm-options="-XX:+PrintGCDetails -Xloggc:<path-to-GC-log-file>"

+```

+## Generate a JFR file on exit

+Use the following `--jvm-options` parameter to generate a JFR file. For more information, see the official JVM documentation.

+```azurecli

+--jvm-options="-XX:StartFlightRecording=dumponexit=true,dumponexitpath=<path-to-JFR-file>"

+```

+## Configure the path for generated files

+To ensure that you can access your files, be sure that the target path of your generated file is in the persistent storage bound to your app. For example, you can use JSON similar to the following example when you create your persistent storage in Azure Spring Cloud.

+```json

+ {

+ "customPersistentDisks": [

+ {

+ "storageName": "<storage-resource-name>",

+ "customPersistentDiskProperties": {

+ "type": "AzureFileVolume",

+ "shareName": "<azure-file-share-name>",

+ "mountPath": "<unique-mount-path>",

+ "mountOptions": [

+ "uid=0",

+ "gid=0"

+ ],

+ "readOnly": false

+ }

+ },

+ {

+ "storageName": "<storage-resource-name>",

+ "customPersistentDiskProperties": {

+ "type": "AzureFileVolume",

+ "shareName": "<azure-file-share-name>",

+ "mountPath": "<unique-mount-path>",

+ "readOnly": true

+ }

+ }

+ ]

+ }

+```

+Alternately, you can use the following command to append to persistent storage.

+```azurecli

+az spring-cloud app append-persistent-storage \

+ --resource-group <resource-group-name> \

+ --service <Azure-Spring-Cloud-instance-name> \

+ --name <app-name> \

+ --persistent-storage-type AzureFileVolume \

+ --storage-name <storage-resource-name> \

+ --share-name <azure-file-share-name> \

+ --mount-path <unique-mount-path>

+```

+## Next steps

+- [Capture heap dump and thread dump manually and use Java Flight Recorder in Azure Spring Cloud](how-to-capture-dumps.md)

+- You can assign a `Synapse SQL Administrator` workspace role or `sysadmin` server-level role in the serverless SQL pool. This role has a full control on all databases (note that the shared databases are still read-only even for the administrator role).

+Trusted launch are Gen2 Azure VMs with enhanced security features aimed to protect against ΓÇ£bottom of the stackΓÇ¥ threats through attack vectors such as rootkits, boot kits, and kernel-level malware. The following are the enhanced security features of trusted launch, all of which are supported in Azure Virtual Desktop. To learn more about trusted launch, visit [Trusted launch for Azure virtual machines](../virtual-machines/trusted-launch.md).

+[Nested Virtualization](/virtualization/hyper-v-on-windows/user-guide/nested-virtualization): Supported <br>

+Learn more about how [Azure compute units (ACU)](acu.md) can help you compare compute performance across Azure SKUs.

+Learn more about how [Azure compute units (ACU)](acu.md) can help you compare compute performance across Azure SKUs.

+Learn more about how [Azure compute units (ACU)](acu.md) can help you compare compute performance across Azure SKUs.

+Learn more about how [Azure compute units (ACU)](acu.md) can help you compare compute performance across Azure SKUs.

+Learn more about how [Azure compute units (ACU)](acu.md) can help you compare compute performance across Azure SKUs.

+export storageaccount="<storageaccount>"

+export keyvault="<keyvault>"

+ --tenant_id "${tenant_id}" \

+ --keyvault "${keyvault}" \

+ --storageaccountname "${storageaccount}"

+> [!TIP]

+> If the scripts fail to run, it can sometimes help to clear the local cache files by removing `~/.sap_deployment_automation/` and `~/.terraform.d/` directories before running the scripts again.