Merge pull request #182651 from MicrosoftDocs/master

Merge master to live, 4 AM

Author: ttorble

articles/active-directory/develop/tutorial-v2-nodejs-console.md

@@ -9,7 +9,7 @@ manager: CelesteDG
 ms.service: active-directory
 ms.subservice: develop
 ms.topic: tutorial
-ms.date: 02/17/2021
+ms.date: 12/12/2021
 ms.author: marsma
 ---
 
@@ -45,63 +45,75 @@ Use the following settings for your app registration:
 
 ## Create the project
 
-Create a folder to host your application, for example *NodeConsoleApp*.
 
-1. First, change to your project directory in your terminal and then run the following NPM commands:
+1. Start by creating a directory for this Node.js tutorial project. For example, *NodeConsoleApp*.
 
-```console
+1. In your terminal, change into the directory you created (the project root), and then run the following commands:
+
+    ```console
     npm init -y
     npm install --save dotenv yargs axios @azure/msal-node
-```
+    ```
 
-2. Next, create a folder named *bin*. Then, inside this folder, create file named *index.js* and add the following code:
+1. Next, edit the *package.json* file in the project root and prefix the value of `main` with `bin/`, like this:
 
-```JavaScript
-#!/usr/bin/env node
+    ```json
+    "main": "bin/index.js",
+    ```
 
-// read in env settings
-require('dotenv').config();
+1. Now create the *bin* directory, and inside *bin*, add the following code to a new file named *index.js*:
 
-const yargs = require('yargs');
+    ```JavaScript
+    #!/usr/bin/env node
 
-const fetch = require('./fetch');
-const auth = require('./auth');
+    // read in env settings
+    require('dotenv').config();
 
-const options = yargs
-    .usage('Usage: --op <operation_name>')
-    .option('op', { alias: 'operation', describe: 'operation name', type: 'string', demandOption: true })
-    .argv;
+    const yargs = require('yargs');
 
-async function main() {
-    console.log(`You have selected: ${options.op}`);
+    const fetch = require('./fetch');
+    const auth = require('./auth');
 
-    switch (yargs.argv['op']) {
-        case 'getUsers':
+    const options = yargs
+        .usage('Usage: --op <operation_name>')
+        .option('op', { alias: 'operation', describe: 'operation name', type: 'string', demandOption: true })
+        .argv;
 
-            try {
-                // here we get an access token
-                const authResponse = await auth.getToken(auth.tokenRequest);
+    async function main() {
+        console.log(`You have selected: ${options.op}`);
 
-                // call the web API with the access token
-                const users = await fetch.callApi(auth.apiConfig.uri, authResponse.accessToken);
+        switch (yargs.argv['op']) {
+            case 'getUsers':
 
-                // display result
-                console.log(users);
-            } catch (error) {
-                console.log(error);
-            }
+                try {
+                    // here we get an access token
+                    const authResponse = await auth.getToken(auth.tokenRequest);
 
-            break;
-        default:
-            console.log('Select a Graph operation first');
-            break;
-    }
-};
+                    // call the web API with the access token
+                    const users = await fetch.callApi(auth.apiConfig.uri, authResponse.accessToken);
 
-main();
-```
+                    // display result
+                    console.log(users);
+                } catch (error) {
+                    console.log(error);
+                }
+
+                break;
+            default:
+                console.log('Select a Graph operation first');
+                break;
+        }
+    };
+
+    main();
+    ```
+
+The *index.js* file you just created references two other node modules that you'll create next:
+
+- *auth.js* - Uses MSAL Node for acquiring access tokens from the Microsoft identity platform.
+- *fetch.js* - Requests data from the Microsoft Graph API by including access tokens (acquired in *auth.js*) in HTTP requests to the API.
 
-This file references two other node modules: *auth.js* which contains an implementation of MSAL Node for acquiring access tokens, and *fetch.js* which contains a method for making an HTTP request to Microsoft Graph API with an access token. After completing the rest of the tutorial, the file and folder structure of your project should look similar to the following:
+At the end of the tutorial, your project's file and directory structure should look similar to this:
 
 ```
 NodeConsoleApp/
@@ -115,7 +127,7 @@ NodeConsoleApp/
 
 ## Add authentication logic
 
-Inside the *bin* folder, create another file named *auth.js* and add the following code for acquiring an access token to present when calling the Microsoft Graph API.
+Inside the *bin* directory, add the following code to a new file named *auth.js*. The code in *auth.js* acquires an access token from the Microsoft identity platform for including in Microsoft Graph API requests.
 
 ```JavaScript
 const msal = require('@azure/msal-node');
@@ -128,7 +140,7 @@ const msal = require('@azure/msal-node');
 const msalConfig = {
     auth: {
         clientId: process.env.CLIENT_ID,
-        authority: process.env.AAD_ENDPOINT + process.env.TENANT_ID,
+        authority: process.env.AAD_ENDPOINT + '/' + process.env.TENANT_ID,
         clientSecret: process.env.CLIENT_SECRET,
     }
 };

articles/azure-monitor/logs/private-link-configure.md

@@ -93,9 +93,6 @@ So far we covered the configuration of your network, but you should also conside
 Go to the Azure portal. In your resource's menu, there's a menu item called **Network Isolation** on the left-hand side. This page controls both which networks can reach the resource through a Private Link, and whether other networks can reach it or not.
 
 
-> [!NOTE]
-> Starting September 2021, Network Isolation will be strictly enforced. Resources set to block queries from public networks, and that aren't connected to any private network (through an AMPLS) will stop accepting queries from any network.
-
 ![LA Network Isolation](./media/private-link-security/ampls-network-isolation.png)
 
 ### Connected Azure Monitor Private Link scopes

articles/azure-monitor/logs/private-link-design.md

@@ -11,7 +11,7 @@ ms.date: 08/01/2021
 
 Before you set up your Azure Monitor Private Link, consider your network topology, and specifically your DNS routing topology.
 
-As discussed in [How it works](./private-link-security.md#how-it-works), setting up a Private Link affects traffic to all Azure Monitor resources. That's especially true for Application Insights resources. Additionally, it affects not only the network connected to the Private Endpoint but also all other networks sharing the same DNS.
+As discussed in the [Azure Monitor Private Link overview article](private-link-security.md), setting up a Private Link affects traffic to all Azure Monitor resources. That's especially true for Application Insights resources. Additionally, it affects not only the network connected to the Private Endpoint but also all other networks sharing the same DNS.
 
 The simplest and most secure approach would be:
 1. Create a single Private Link connection, with a single Private Endpoint and a single AMPLS. If your networks are peered, create the Private Link connection on the shared (or hub) VNet.

articles/azure-monitor/logs/private-link-security.md

@@ -24,9 +24,7 @@ With Private Link you can:
 
 For more information, see  [Key Benefits of Private Link](../../private-link/private-link-overview.md#key-benefits).
 
-## How it works
-
-### Overview
+## How it works: main principles
 An Azure Monitor Private Link connects a Private Endpoint to a set of Azure Monitor resources - Log Analytics workspaces and Application Insights resources. That set is called an Azure Monitor Private Link Scope (AMPLS).
 
 ![Diagram of basic resource topology](./media/private-link-security/private-link-basic-topology.png)
@@ -37,7 +35,7 @@ An Azure Monitor Private Link connects a Private Endpoint to a set of Azure Moni
 * Control networks access to your Azure Monitor resources - configure each of your workspaces or components to accept or block traffic from public networks. You can apply different settings for ingestion and query requests.
 
 
-### Azure Monitor Private Links rely on your DNS
+## Azure Monitor Private Links rely on your DNS
 When you set up a Private Link connection, your DNS zones map Azure Monitor endpoints to private IPs in order to send traffic through the Private Link. Azure Monitor uses both resource-specific endpoints and shared global / regional endpoints to reach the workspaces and components in your AMPLS. 
 
 > [!WARNING]
@@ -46,7 +44,7 @@ When you set up a Private Link connection, your DNS zones map Azure Monitor endp
 The use of shared endpoints also means you should use a single AMPLS for all networks that share the same DNS. Creating multiple AMPLS resources will cause Azure Monitor DNS zones to override each other, and break existing environments. See [Plan by network topology](./private-link-design.md#plan-by-network-topology) to learn more.
 
 
-#### Shared global and regional endpoints
+### Shared global and regional endpoints
 When configuring Private Link even for a single resource, traffic to the below endpoints will be sent through the allocated Private IPs.
 
 * All Application Insights endpoints - endpoints handling ingestion, live metrics, profiler, debugger etc. to Application Insights endpoints are global.
@@ -57,14 +55,14 @@ When configuring Private Link even for a single resource, traffic to the below e
 > Creating a Private Link affects traffic to **all** monitoring resources, not only resources in your AMPLS. Effectively, it will cause all query requests as well as ingestion to Application Insights components to go through private IPs. However, it does not mean the Private Link validation applies to all these requests.</br>
 > Resources not added to the AMPLS can only be reached if the AMPLS access mode is 'Open' and the target resource accepts traffic from public networks. While using the private IP, **Private Link validations don't apply to resources not in the AMPLS**. See [Private Link access modes](#private-link-access-modes-private-only-vs-open) to learn more.
 
-#### Resource-specific endpoints
+### Resource-specific endpoints
 Log Analytics endpoints are workspace-specific, except for the query endpoint discussed earlier. As a result, adding a specific Log Analytics workspace to the AMPLS will send ingestion requests to this workspace over the Private Link, while ingestion to other workspaces will continue to use the public endpoints.
 
 > [!IMPORTANT]
 > Starting December 1, 2021, the Private Endpoints DNS configuration will use the Endpoint Compression mechanism, which allocates a single private IP address for all workspaces in the same region. This improves the supported scale (up to 300 workspaces and 1000 components per AMPLS) and  reduces the total number of IPs taken from the network's IP pool.  
 
 
-### Private Link access modes: Private Only vs Open
+## Private Link access modes: Private Only vs Open
 As discussed in [Azure Monitor Private Link relies on your DNS](#azure-monitor-private-links-rely-on-your-dns), only a single AMPLS resource should be created for all networks that share the same DNS. As a result, organizations that use a single global or regional DNS in fact have a single Private Link to manage traffic to all Azure Monitor resources, across all global, or regional networks.
 
 For Private Links created before September 2021, that means - 

articles/data-factory/concepts-data-flow-expression-builder.md

@@ -83,7 +83,17 @@ A cached lookup allows you to do an inline lookup of the output of a cached sink
 
 ### Locals
 
-If you are sharing logic across multiple columns or want to compartmentalize your logic, you can create a local within a derived column\. To reference a local, either click on the local from the **Expression elements** view or reference it with a colon in front of its name. For example, a local called local1 would be referenced by `:local1`. Learn more about locals in the [derived column documentation](data-flow-derived-column.md#locals).
+If you are sharing logic across multiple columns or want to compartmentalize your logic, you can create a local variable. A local is a set of logic that doesn't get propagated downstream to the following transformation. Locals can be created within the expression builder by going to **Expression elements** and selecting **Locals**. Create a new one by selecting **Create new**.
+
+:::image type="content" source="media/data-flow/create-local.png" alt-text="Create local":::
+
+Locals can reference any expression element including functions, input schema, parameters, and other locals. When referencing other locals, order does matter as the referenced local needs to be "above" the current one.
+
+:::image type="content" source="media/data-flow/create-local-2.png" alt-text="Create local 2":::
+
+To reference a local in a transformation, either click on the local from the **Expression elements** view or reference it with a colon in front of its name. For example, a local called local1 would be referenced by `:local1`. To edit a local definition, hover over it in the expression elements view and click on the pencil icon.
+
+:::image type="content" source="media/data-flow/using-locals.png" alt-text="Using locals":::
 
 ## Preview expression results
 

articles/data-factory/concepts-data-flow-flowlet.md

@@ -22,6 +22,8 @@ ms.date: 11/11/2021
 > [!NOTE] 
 > The Flowlet feature in mapping data flow is currently in public preview
 
+> [!VIDEO https://www.microsoft.com/en-us/videoplayer/embed/RWQK3m]
+
 ## Getting started
 To create a flowlet, click the new flowlet action from the mapping data flow menu options.
 
@@ -72,4 +74,4 @@ If you have mulit-select turned on, you can also select multiple mapping data fl
 ## Running a flowlet inside of a mapping data flow
 Once the flowlet is created, you can run the flowlet from your mapping data flow activity with the flowlet transformation. 
 
-For more information, see [Flowlet transformation in mapping data flow | Microsoft Docs](data-flow-flowlet.md)
+For more information, see [Flowlet transformation in mapping data flow | Microsoft Docs](data-flow-flowlet.md)

articles/data-factory/control-flow-power-query-activity.md

@@ -6,7 +6,7 @@ ms.author: makromer
 ms.service: data-factory
 ms.subservice: data-flows
 ms.topic: conceptual
-ms.date: 08/12/2021
+ms.date: 12/12/2021
 ---
 
 # Power Query activity in Azure Data Factory
@@ -61,6 +61,10 @@ To achieve scale with your Power Query activity, Azure Data Factory translates y
 
 Choose the dataset you wish to use for landing your transformed data once the Power Query M script has been executed on Spark. For more details on configuring sinks, visit the documentation for [data flow sinks](data-flow-sink.md).
 
+You have the option to sink your output to multiple destinations. Click on the plus (+) button to add more sinks to your query. You can also direct each individual query output from your wrangling Power Query activity to different destinations.
+
+![Screenshot that shows Power Query multiple sinks.](media/data-flow/pq-multi-output.png)
+
 ## Mapping
 
 In the Mapping tab, you can configure column mapping from the output of your Power Query activity to the target schema of your chosen sink. Read more about column mapping from the [data flow sink mapping documentation](data-flow-sink.md#field-mapping).

articles/data-factory/data-flow-derived-column.md

@@ -8,7 +8,7 @@ ms.service: data-factory
 ms.subservice: data-flows
 ms.topic: conceptual
 ms.custom: synapse
-ms.date: 09/09/2021
+ms.date: 12/10/2021
 ---
 
 # Derived column transformation in mapping data flow
@@ -49,20 +49,6 @@ For more information on handling complex types in data flow, see [JSON handling
 
 :::image type="content" source="media/data-flow/derive-complex-column.png" alt-text="Add complex column":::
 
-### Locals
-
-If you are sharing logic across multiple columns or want to compartmentalize your logic, you can create a local within a derived column transformation. A local is a set of logic that doesn't get propagated downstream to the following transformation. Locals can be created within the expression builder by going to **Expression elements** and selecting **Locals**. Create a new one by selecting **Create new**.
-
-:::image type="content" source="media/data-flow/create-local.png" alt-text="Create local":::
-
-Locals can reference any expression element a derived column including functions, input schema, parameters, and other locals. When referencing other locals, order does matter as the referenced local needs to be "above" the current one.
-
-:::image type="content" source="media/data-flow/create-local-2.png" alt-text="Create local 2":::
-
-To reference a local in a derived column, either click on the local from the **Expression elements** view or reference it with a colon in front of its name. For example, a local called local1 would be referenced by `:local1`. To edit a local definition, hover over it in the expression elements view and click on the pencil icon.
-
-:::image type="content" source="media/data-flow/using-locals.png" alt-text="Using locals":::
-
 ## Data flow script
 
 ### Syntax

articles/data-factory/data-flow-flowlet.md

@@ -22,6 +22,7 @@ Use the flowlet transformation to run a previously create mapping data flow flow
 > [!NOTE] 
 > The flowlet transformation in Azure Data Factory and Synapse Analytics pipelines is currently in public preview
 
+> [!VIDEO https://www.microsoft.com/en-us/videoplayer/embed/RWQK3m]
 
 ## Configuration