Some fix

Author: zackliu

articles/azure-web-pubsub/socketio-serverless-protocol.md

@@ -45,17 +45,17 @@ Explanations of the previous sample:
 
 When a client attempts to connect to the service, the process is divided into two distinct steps: establishing an Engine.IO (physical) connection and connecting to a namespace, which is referred to as a socket in Socket.IO terminology. The authentication process differs between these two steps:
 
-1. **Engine.IO connection**: During this step, the service authenticates the client using an access token to determine whether to accept the connection. If the corresponding hub is configured to allow anonymous mode, the Engine.IO connection can proceed without validating the access token. However, for security reasons, it's recommended to disable anonymous mode in production environments.
+1. **Engine.IO connection**: During this step, the service authenticates the client using an access token to determine whether to accept the connection. If the corresponding hub is configured to allow anonymous mode, the Engine.IO connection can proceed without validating the access token. However, for security reasons, we recommend to disable anonymous mode in production environments.
 
-    - The Engine.IO connection url follow the format as shown below. But in most cases, it should be handled by Socket.IO client library.
+    - The Engine.IO connection url follows the format. But in most cases, it should be handled by Socket.IO client library.
 
       ```
       http://<service-endpoint>/clients/socketio/hubs/<hub-name>/?access_token=<access-token>
       ```
 
     - The details of access token can be found in [here](#authentication-details)
 
-2. **Socket**: After the Engine.IO connection is successfully established, the client SDK sends a payload to connect to a namespace. Upon receiving the socket connect request, the service triggers a connect call to the event handler. The outcome of this step depends on the status code returned by the connect response: a 200 status code indicates that the socket is approved, while a 4xx or 5xx status code results in the socket being rejected.
+2. **Socket**: After the Engine.IO connection is successfully established, the client SDK sends a payload to connect to a namespace. Once the service receives the socket connect request, the service triggers a connect call to the event handler. The outcome of this step depends on the status code returned by the connect response: a 200 status code indicates that the socket is approved, while a 4xx or 5xx status code results in the socket being rejected.
 
 3. Once a socket is connected, the service triggers a connected call to the event handler. It's an asynchronized call to notify the event handler a socket is successfully connected.
 
@@ -85,7 +85,7 @@ Client disconnects from a namespace or the corresponding Engine.IO connection cl
 
 ## Authentication Details
 
-The service uses bearer token to authenticate. There're two main scenario to use the token. 
+The service uses bearer token to authenticate. There are two main scenarios to use the token. 
 
 - Connect of Engine.IO connection. The following request is an example.
 
@@ -102,7 +102,7 @@ The service uses bearer token to authenticate. There're two main scenario to use
   Authorization: Bearer <token>
   ```
 
-The generation of token can also be devided into two categories: key based authenitcation or identity based authentication.
+The generation of token can also be divided into two categories: key based authentication or identity based authentication.
 
 ### **Key based authentication**
 
@@ -139,7 +139,7 @@ The generation of token can also be devided into two categories: key based authe
   HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), <AccessKey>)
   ```
 
-  The `AccessKey` can be get from the service Azure Portal or from the Azure Cli:
+  The `AccessKey` can be obtained from the service Azure portal or from the Azure CLI:
 
   ```azcli
   az webpubsub key show -g <resource-group> -n <resource-name>

articles/azure-web-pubsub/socketio-serverless-quickstart.md

@@ -1,44 +1,39 @@
 ---
 title: 'Quickstart: Build chat app with Azure Function in Socket.IO Serverless Mode'
-description: In this artical, you will familiar with the samples of using Web PubSub for Socket.IO with Azure Function in Serverless Mode.
+description: In this article, you will familiar with the samples of using Web PubSub for Socket.IO with Azure Function in Serverless Mode.
 keywords: Socket.IO, serverless, azure function, Socket.IO on Azure, multi-node Socket.IO, scaling Socket.IO, socketio, azure socketio
 author: zackliu
 ms.author: chenyl
 ms.date: 09/01/2024
 ms.service: azure-web-pubsub
 ms.topic: tutorial
-zone_pivot_groups: programming-languages-set-functions
 ---
 
 # Quickstart: Build chat app with Azure Function in Socket.IO Serverless Mode (Preview)
 
-In this artical, you will use samples to familiar with how to build a chat app using Web PubSub for Socket.IO in Serverless Mode with Azure Function online and use Identity based authentication to secure your app.
+In this article, you'll learn how to build a chat app using Web PubSub for Socket.IO in Serverless Mode with Azure Functions. The tutorial will guide you through securing your app with identity-based authentication, while working online.
 
-The project source uses the Bicep to deploy the infrastructure in Azure and Azure Function Core Tools to deploy the code to the Function App.
+The project source uses Bicep to deploy the infrastructure on Azure, and Azure Functions Core Tools to deploy the code to the Function App.
 
 ## Prerequest
 
 + An Azure account with an active subscription. [Create an account for free](https://azure.microsoft.com/free/?ref=microsoft.com&utm_source=microsoft.com&utm_medium=docs&utm_campaign=visualstudio).
 
-+ [Azure Functions Core Tools](functions-run-local.md#install-the-azure-functions-core-tools).
++ [Azure Functions Core Tools](../azure-functions/functions-run-local.md).
 
 + [.NET 8.0 SDK](https://dotnet.microsoft.com/download)
 
-::: zone pivot="programming-language-typescript"  
 + [Node.js 18](https://nodejs.org/)  
-::: zone-end
 
 
 ## Get the sample code
 
-::: zone pivot="programming-language-typescript"  
 Find the sample code: [Socket.IO Serverless Sample (TS)](https://github.com/Azure/azure-webpubsub/tree/main/sdk/webpubsub-socketio-extension/examples/chat-serverless-typescript)
 
 ```bash
 git clone https://github.com/Azure/azure-webpubsub.git
 cd ./sdk/webpubsub-socketio-extension/examples/chat-serverless-typescript
 ```
-::: zone-end
 
 ## Deploy infrastructure
 
@@ -56,14 +51,14 @@ az deployment sub create -n "<deployment-name>" -l "<deployment-location>" --tem
 
 - `<deployment-name>`: The name of the deployment.
 - `<deployment-location>`: The location of the deployment metadata. Note it's not the location where resources deploy to.
-- `<env-name>`: The name will be a part of the resource group name and resource name.
+- `<env-name>`: The name is a part of the resource group name and resource name.
 - `<location>`: The location of the resources.
 
 ### Review of the infrastructure
 
-In the infrastructure release, we deploy an Azure Function App in consumption plan as well as the Monitor and Storage Account that required by the Function App. We also deploy a Web PubSub for Socket.IO resource in Serverless Mode.
+In the infrastructure release, we deploy an Azure Function App in consumption plan and the Monitor and Storage Account that required by the Function App. We also deploy a Web PubSub for Socket.IO resource in Serverless Mode.
 
-For the identity based authentication purpose, we deploye a user-assigned managed identity, assign it to both Function App and Socket.IO resource and grant it with some permissions:
+For the identity based authentication purpose, we deploy a user-assigned managed identity, assign it to both Function App and Socket.IO resource and grant it with some permissions:
 
 - **Storage Blob Data Owner role**: Access storage for Function App
 - **Monitoring Metrics Publisher role**: Access monitor for Function App
@@ -102,7 +97,7 @@ We need to do two steps to deploy the sample app.
 
 ### Run Sample App
 
-After the code is deployed, visit the website to try the sample: 
+After the code is deployd, visit the website to try the sample: 
 
 ```bash
 https://<function-endpoint>/api/index

articles/azure-web-pubsub/socketio-serverless-tutorial.md

@@ -297,19 +297,19 @@ func settings add WebPubSubForSocketIOConnectionString "<connection string>"
 az webpubsub hub create -n <resource name> -g <resource group> --hub-name hub --event-handler url-template="tunnel:///runtime/webhooks/socketio" user-event-pattern="*"
 ```
 
-The connection string can be get by the azure cli command
+The connection string can be obtained by the Azure CLI command
 
 ```azcli
 az webpubsub key show -g <resource group> -n <resource name>
 ```
 
-The output will contains `primaryConnectionString` and `secondaryConnectionString`, and either is available.
+The output contains `primaryConnectionString` and `secondaryConnectionString`, and either is available.
 
 ### Setup tunnel 
 
-In serverless mode, the service uses webhooks to trigger the function. When running the app locally, a crucial problem is let the service be able to access your local function endpoint.
+In serverless mode, the service uses webhooks to trigger the function. When you try to run the app locally, a crucial problem is let the service be able to access your local function endpoint.
 
-An easiest way to achieve it is to use [Tunnel Tool](../azure-web-pubsub/howto-web-pubsub-tunnel-tool.md)
+An easiest way to achieve it's to use [Tunnel Tool](../azure-web-pubsub/howto-web-pubsub-tunnel-tool.md)
 
 1. Install Tunnel Tool:
 
@@ -338,7 +338,7 @@ And visit the webpage at `http://localhost:7071/api/index`.
 :::image type="content" source="./media/socketio-serverless-tutorial/chatsample.png" alt-text="Screenshot of the serverless chat app.":::
 
 ## Next steps
-Next, you can try to leverage Bicep to deploy the app online with identity-based authentication:
+Next, you can try to use Bicep to deploy the app online with identity-based authentication:
 
 > [!div class="nextstepaction"]
 > [Quickstart: Build chat app with Azure Function in Socket.IO Serverless Mode](./socketio-serverless-quickstart.md)