Merge branch 'main' of https://github.com/MicrosoftDocs/azure-docs-pr into 2009248

Author: ktoliver

articles/active-directory/develop/media/workload-identity-federation-create-trust/add-credential.png

@@ -298,7 +298,6 @@ kubectl get services --namespace ingress-basic -o wide -w ingress-nginx-controll
 When the Kubernetes load balancer service is created for the NGINX ingress controller, an IP address is assigned under *EXTERNAL-IP*, as shown in the following example output:
 
 ```
-NAME                                     TYPE           CLUSTER-IP    EXTERNAL-IP     PORT(S)                      AGE   SELECTOR
 NAME                       TYPE           CLUSTER-IP    EXTERNAL-IP     PORT(S)                      AGE   SELECTOR
 ingress-nginx-controller   LoadBalancer   10.0.65.205   EXTERNAL-IP     80:30957/TCP,443:32414/TCP   1m   app.kubernetes.io/component=controller,app.kubernetes.io/instance=ingress-nginx,app.kubernetes.io/name=ingress-nginx
 ```

articles/aks/ingress-basic.md

@@ -176,7 +176,8 @@ The following image shows the first flow:
         |Video URL|Select **Web Url** from the dynamic content of **Create SAS URI by path** action.|
         | Body| Can be left as default.|
         
-        ![Screenshot of the upload and index action.](./media/logic-apps-connector-arm-accounts/upload-and-index.png)
+        > [!div class="mx-imgBorder"]
+        > :::image type="content" source="./media/logic-apps-connector-arm-accounts/upload-and-index-expression.png" alt-text="Screenshot of the upload and index action." lightbox="./media/logic-apps-connector-arm-accounts/upload-and-index-expression.png":::
 
         Select **Save**.
 

articles/aks/supported-kubernetes-versions.md

@@ -29,6 +29,7 @@ The following extensions can currently be installed when creating a Batch pool:
 - [Azure Diagnostics extension for Windows VMs](../virtual-machines/windows/extensions-diagnostics.md)
 - [HPC GPU driver extension for Windows on AMD](../virtual-machines/extensions/hpccompute-amd-gpu-windows.md)
 - [HPC GPU driver extension for Windows on NVIDIA](../virtual-machines/extensions/hpccompute-gpu-windows.md)
+- [HPC GPU driver extension for Linux on NVIDIA](../virtual-machines/extensions/hpccompute-gpu-linux.md)
 - [Microsoft Antimalware extension for Windows](../virtual-machines/extensions/iaas-antimalware-windows.md)
 
 You can request support for additional publishers and/or extension types by opening a support request.

articles/azure-video-indexer/logic-apps-connector-arm-accounts.md

@@ -6,6 +6,23 @@ ms.date: 11/01/2022
 ms.author: eur
 ---
 
+### Speech SDK 1.24.2: November 2022 release
+
+#### New features
+- No new features, just an embedded engine fix to support new model files.
+
+#### Bug fixes
+
+- **All programing languages**
+    - Fixed an issue with encryption of embedded speech recognition models.
+- **JavaScript SDK**
+    - not included in this release
+
+- **Java**
+    - none
+- **Python**
+    - none
+
 ### Speech SDK 1.24.1: November 2022 release
 
 #### New features

articles/azure-video-indexer/media/logic-apps-connector-arm-accounts/upload-and-index-expression.png

@@ -77,10 +77,25 @@ To import the library into your project using the [Maven](https://maven.apache.o
 </dependency>
 ```
 
+### Set up Azure Function
+Please check out [Azure Function integration](../../../tutorials/integrate-azure-function.md) for details. We highly recommend integrating with Azure Function to avoid hard-coding application parameters.
+
+### Set up application constants:
+Create a class `ApplicationConstants` which stores all application constants:
+```java
+public class ApplicationConstants {
+    public static final String SDK_VERSION = "<your_version>";
+    public final static String SDK_NAME = "azure-communication-com.azure.android.communication.chat";
+    public final static String APPLICATION_ID = "Chat_Test_App";
+    public final static String TAG = "[Chat Test App]";
+    public static CommunicationTokenCredential COMMUNICATION_TOKEN_CREDENTIAL;
+}
+```
 
 ### Set up the placeholders
 
-Open and edit the file `MainActivity.java`. In this Quickstart, we'll add our code to `MainActivity`, and view the output in the console. This quickstart does not address building a UI. At the top of file, import the `Communication common`, `Communication chat`, and other system libraries:
+Open and edit the file `MainActivity.java`. In this quick-start, we'll add our code to `MainActivity`, and view the output in the console. This quick-start does not address building a UI. At the top of the file, import the `Azure Communication Common`, `Azure 
+ Communication Chat`, and other system libraries:
 
 ```
 import com.azure.android.communication.chat.*;
@@ -100,16 +115,6 @@ import java.util.List;
 Copy the following code into class `MainActivity` in file `MainActivity.java`:
 
 ```java
-    private String endpoint = "<replace with your resource endpoint>'";
-    private String firstUserId = "<first_user_id>";
-    private String secondUserId = "<second_user_id>";
-    private String firstUserAccessToken = "<first_user_access_token>";
-    private String threadId = "<thread_id>";
-    private String chatMessageId = "<chat_message_id>";
-    private final String sdkVersion = "<chat_sdk_version>";
-    private static final String APPLICATION_ID = "Chat Quickstart App";
-    private static final String SDK_NAME = "azure-communication-com.azure.android.communication.chat";
-    private static final String TAG = "Chat Quickstart App";
     private ChatAsyncClient chatAsyncClient;
 
     private void log(String msg) {
@@ -123,6 +128,8 @@ Copy the following code into class `MainActivity` in file `MainActivity.java`:
         try {
             AndroidThreeTen.init(this);
 
+            // Initialize application parameters if one of the conditions in '### Initialize Application Parameters' are met.
+
             // <CREATE A CHAT CLIENT>
 
             // <CREATE A CHAT THREAD>
@@ -150,13 +157,33 @@ Copy the following code into class `MainActivity` in file `MainActivity.java`:
     }
 ```
 
-1. Replace `<resource>` with your Communication Services resource.
-2. Replace `<first_user_id>` and `<second_user_id>` with valid Communication Services user IDs that were generated as part of prerequisite steps.
-3. Replace `<first_user_access_token>` with the Communication Services access token for `<first_user_id>` that was generated as part of prerequisite steps.
-4. Replace `<chat_sdk_version>` with the version of Azure Communication Chat SDK.
+### Initialize Application Parameters
+> [!NOTE]
+> Initializing `ApplicationConstants` needs to be added to `MainActivity.java` if EITHER of the following conditions is met: 1. The push notification feature is NOT enabled. 2. The version for the Azure Communication Chat library for Android is < '2.0.0'. Otherwise, please refer to step 11 in [Android push notifications](../../../tutorials/chat-android-push-notification.md). Please refer to the sample APP of the SDK version that you are consuming for reference.
 
-In following steps, we'll replace the placeholders with sample code using the Azure Communication Services Chat library.
+`ACS_ENDPOINT`, `FIRST_USER_ID` and `FIRST_USER_ACCESS_TOKEN` are returned from calling Azure Function. Please check out [Azure Function integration](../../../tutorials/integrate-azure-function.md) for details. We use the response from calling Azure Function to initialize the list of parameters:
+* `ACS_ENDPOINT`: the endpoint of your Communication Services resource.
+* `FIRST_USER_ID` and `SECOND_USER_ID`: valid Communication Services user IDs generated by your Communication Services resource.
+* `FIRST_USER_ACCESS_TOKEN`: the communication Services access token for `<FIRST_USER_ID>`.
 
+Code block for initialing application parameters by calling Azure Function: 
+```java
+try {
+        UserTokenClient userTokenClient = new UserTokenClient(AZURE_FUNCTION_URL);
+        //First user context
+        userTokenClient.getNewUserContext();
+        ACS_ENDPOINT = userTokenClient.getACSEndpoint();
+        FIRST_USER_ID = userTokenClient.getUserId();
+        FIRST_USER_ACCESS_TOKEN = userTokenClient.getUserToken();
+        COMMUNICATION_TOKEN_CREDENTIAL = new CommunicationTokenCredential(FIRST_USER_ACCESS_TOKEN);
+        //Second user context
+        userTokenClient.getNewUserContext();
+        SECOND_USER_ID = userTokenClient.getUserId();
+    } catch (Throwable throwable) {
+        //Your handling code
+        logger.logThrowableAsError(throwable);
+    }
+```
 
 ### Create a chat client
 

articles/batch/create-pool-extensions.md

@@ -195,26 +195,32 @@ Push notifications let clients be notified for incoming messages and other opera
 11. Add a custom `WorkManager` initializer by creating a class implementing `Configuration.Provider`:
 
 ```java
-public class MyAppConfiguration extends Application implements Configuration.Provider {
-    Consumer<Throwable> exceptionHandler = new Consumer<Throwable>() {
+    public class MyAppConfiguration extends Application implements Configuration.Provider {
+        Consumer<Throwable> exceptionHandler = new Consumer<Throwable>() {
+            @Override
+            public void accept(Throwable throwable) {
+                Log.i("YOUR_TAG", "Registration failed for push notifications!" + throwable.getMessage());
+            }
+        };
+    
         @Override
-        public void accept(Throwable throwable) {
-            Log.i("YOUR_TAG", "Registration failed for push notifications!" + throwable.getMessage());
+        public void onCreate() {
+            super.onCreate();
+            // Initialize application parameters here
+            WorkManager.initialize(getApplicationContext(), getWorkManagerConfiguration());
+        }
+    
+        @NonNull
+        @Override
+        public Configuration getWorkManagerConfiguration() {
+            return new Configuration.Builder().
+                setWorkerFactory(new RegistrationRenewalWorkerFactory(COMMUNICATION_TOKEN_CREDENTIAL, exceptionHandler)).build();
         }
-    };
-    @Override
-    public void onCreate() {
-        super.onCreate();
-        WorkManager.initialize(getApplicationContext(), getWorkManagerConfiguration());
-    }
-    @NonNull
-    @Override
-    public Configuration getWorkManagerConfiguration() {
-        return new Configuration.Builder().
-            setWorkerFactory(new RegistrationRenewalWorkerFactory(COMMUNICATION_TOKEN_CREDENTIAL, exceptionHandler)).build();
     }
-}
 ```
+**Explanation to code above:** The default initializer of `WorkManager` has been disabled in step 9. This step implements `Configuration.Provider` to provide a customized 'WorkFactory', which is responsible to create `WorkerManager` during runtime. 
+
+If the app is integrated with Azure Function, initialization of application parameters should be added in method 'onCreate()'. Method 'getWorkManagerConfiguration()' is called when the application is starting, before any activity, service, or receiver objects (excluding content providers) have been created, so that application parameters could be initialized before being used. More details can be found in the sample chat app.
 
 12. Add the `android:name=.MyAppConfiguration` field, which uses the class name from step 11, into `AndroidManifest.xml`:
 

articles/cognitive-services/Speech-Service/includes/release-notes/release-notes-sdk.md

@@ -0,0 +1,92 @@
+---
+title: Enable Azure Function in chat app
+titleSuffix: An Azure Communication Services tutorial
+description: Learn how to enable Azure Function 
+author: jiminwen
+services: azure-communication-services
+ms.author: jiminwen
+ms.date: 11/03/2022
+ms.topic: tutorial
+ms.service: azure-communication-services
+---
+
+# Integrate Azure Function
+## Introduction
+This tutorial provides detailed guidance on how to set up an Azure Function to receive user-related information. Setting up an Azure Function is highly recommended. It helps to avoid hard-coding application parameters in the Contoso app (such as user ID and user token). This information is highly confidential. More importantly, we refresh user tokens periodically on the backend. Hard-coding the user ID and token combination requires editing the value after every refresh.
+
+## Prerequisites
+
+Before you get started, make sure to:
+
+- Create an Azure account with an active subscription. For details, see [Create an account for free](https://azure.microsoft.com/free/?WT.mc_id=A261C142F).
+- Install Visual Studio Code. 
+
+## Setting up functions
+1. Install the Azure Function extension in Visual Studio Code. You can install it from Visual Studio Code's plugin browser or by following [this link](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azurefunctions)
+2. Set up a local Azure Function app by following [this link](../../azure-functions/functions-develop-vs-code.md?tabs=csharp#create-an-azure-functions-project). We need to create a local function using the HTTP trigger template in JavaScript. 
+3. Install Azure Communication Services libraries. We'll use the Identity library to generate User Access Tokens. Run the npm install command in your local Azure Function app directory, to install the Azure Communication Services Identity SDK for JavaScript.
+
+```
+    npm install @azure/communication-identity --save
+```
+4. Modify the `index.js` file so it looks like the code below:
+```JavaScript
+    const { CommunicationIdentityClient } = require('@azure/communication-identity');
+    const connectionString = '<your_connection_string>'
+    const acsEndpoint = "<your_ACS_endpoint>"
+    
+    module.exports = async function (context, req) {
+        let tokenClient = new CommunicationIdentityClient(connectionString);
+    
+        const userIDHolder = await tokenClient.createUser();
+        const userId = userIDHolder.communicationUserId
+    
+        const userToken = await (await tokenClient.getToken(userIDHolder, ["chat"])).token;
+    
+        context.res = {
+            body: {
+                acsEndpoint,
+                userId,
+                userToken
+            }
+        };
+    }
+```
+**Explanation to code above**: The first line import the interface for the `CommunicationIdentityClient`. The connection string in the second line can be found in your ACS resource in the Azure portal. The `ACSEndpoint` is the URL of the ACS resource that was created. 
+
+5. Open the local Azure Function folder in Visual Studio Code. Open the `index.js` and run the local Azure Function. A local Azure Function endpoint will be created and printed in the terminal. The printed message looks similar to:
+
+```
+Functions:
+HttpTrigger1: [GET,POST] http://localhost:7071/api/HttpTrigger1
+```
+
+Open the link in a browser. The result will be similar to this example:
+```
+    {
+      "acsEndpoint": "<Azure Function endpoint>",
+      "userId": "8:acs:a636364c-c565-435d-9818-95247f8a1471_00000014-f43f-b90f-9f3b-8e3a0d00c5d9",
+      "userToken": "eyJhbGciOiJSUzI1NiIsImtpZCI6IjEwNiIsIng1dCI6Im9QMWFxQnlfR3hZU3pSaXhuQ25zdE5PU2p2cyIsInR5cCI6IkpXVCJ9.eyJza3lwZWlkIjoiYWNzOmE2MzYzNjRjLWM1NjUtNDM1ZC05ODE4LTk1MjQ3ZjhhMTQ3MV8wMDAwMDAxNC1mNDNmLWI5MGYtOWYzYi04ZTNhMGQwMGM1ZDkiLCJzY3AiOjE3OTIsImNzaSI6IjE2Njc4NjI3NjIiLCJleHAiOjE2Njc5NDkxNjIsImFjc1Njb3BlIjoiY2hhdCIsInJlc291cmNlSWQiOiJhNjM2MzY0Yy1jNTY1LTQzNWQtOTgxOC05NTI0N2Y4YTE0NzEiLCJyZXNvdXJjZUxvY2F0aW9uIjoidW5pdGVkc3RhdGVzIiwiaWF0IjoxNjY3ODYyNzYyfQ.t-WpaUUmLJaD0V2vgn3M5EKdJUQ_JnR2jnBUZq3J0zMADTnFss6TNHMIQ-Zvsumwy14T1rpw-1FMjR-zz2icxo_mcTEM6hG77gHzEgMR4ClGuE1uRN7O4-326ql5MDixczFeIvIG8s9kAeJQl8N9YjulvRkGS_JZaqMs2T8Mu7qzdIOiXxxlmcl0HeplxLaW59ICF_M4VPgUYFb4PWMRqLXWjKyQ_WhiaDC3FvhpE_Bdb5U1eQXDw793V1_CRyx9jMuOB8Ao7DzqLBQEhgNN3A9jfEvIE3gdwafpBWlQEdw-Uuf2p1_xzvr0Akf3ziWUsVXb9pxNlQQCc19ztl3MIQ"
+    }
+```
+
+6. Deploy the local function to the cloud. More details can be found in [this documentation](../../azure-functions/functions-develop-vs-code.md).
+
+7. **Test the deployed Azure Function.** First, find your Azure Function in the Azure portal. Then, use the "Get Function URL" button to get the Azure Function endpoint. The result you see should be similar to what was shown in step 5. The Azure Function endpoint will be used in the app for initializing application parameters.
+
+8. Implement `UserTokenClient`, which is used to call the target Azure Function resource and obtain the ACS endpoint, user ID and user token from the returned JSON object. Refer to the sample app for usage.
+
+## Troubleshooting guide
+1. If the Azure Function extension failed to deploy the local function to the Azure cloud, it's likely due to the version of Visual Studio Code and the Azure Function extension being used having a bug. This version combination has been tested to work: Visual Studio Code version `1.68.1` and Azure Function extension version `1.2.1`.
+2. The place to initialize application constants is tricky but important. Double check the [chat Android quick-start](https://learn.microsoft.com/azure/communication-services/quickstarts/chat/get-started). More specifically, the highlight note in the section "Set up application constants", and compare with the sample app of the version you are consuming.
+
+## (Optional) secure the Azure Function endpoint
+For demonstration purposes, this sample uses a publicly accessible endpoint by default to fetch an Azure Communication Services token. For production scenarios, one option is to use your own secured endpoint to provision your own tokens.
+
+With extra configuration, this sample supports connecting to an Azure Active Directory (Azure AD) protected endpoint so that user log is required for the app to fetch an Azure Communication Services token. The user will be required to sign in with Microsoft account to access the app. This setup increases the security level while users are required to log in. Decide whether to enable it based on the use cases.
+
+Note that we currently don't support Azure AD in sample code. Follow the links below to enable it in your app and Azure Function:
+
+[Register your app under Azure Active Directory (using Android platform settings)](../../active-directory/develop/tutorial-v2-android.md).
+
+[Configure your App Service or Azure Functions app to use Azure AD log in](../../app-service/configure-authentication-provider-aad.md).