Merge branch 'release-aio-m3' of https://github.com/MicrosoftDocs/azure-docs-pr into patricka-doe-release-aio-m3

Author: PatAltimore

articles/iot-operations/connect-to-cloud/concept-dataflow-conversions.md

@@ -5,7 +5,7 @@ author: PatAltimore
 ms.author: patricka
 ms.subservice: azure-data-flows
 ms.topic: concept-article
-ms.date: 08/03/2024
+ms.date: 10/30/2024
 
 #CustomerIntent: As an operator, I want to understand how to use dataflow conversions to transform data.
 ms.service: azure-iot-operations
@@ -19,6 +19,19 @@ You can use dataflow conversions to transform data in Azure IoT Operations. The
 
 The dataflow conversion element is used to compute values for output fields:
 
+# [Bicep](#tab/bicep)
+
+```bicep
+inputs: [
+  '*.Max' // - $1
+  '*.Min' // - $2
+]
+output: 'ColorProperties.*'
+expression: '($1 + $2) / 2'
+```
+
+# [Kubernetes](#tab/kubernetes)
+
 ```yaml
 - inputs:
   - *.Max   # - $1
@@ -27,6 +40,8 @@ The dataflow conversion element is used to compute values for output fields:
   expression: ($1 + $2) / 2
 ```
 
+---
+
 There are several aspects to understand about conversions:
 
 * **Reference to input fields:** How to reference values from input fields in the conversion formula.
@@ -38,6 +53,21 @@ There are several aspects to understand about conversions:
 
 In conversions, formulas can operate on static values like a number such as *25* or parameters derived from input fields. A mapping defines these input fields that the formula can access. Each field is referenced according to its order in the input list:
 
+# [Bicep](#tab/bicep)
+
+```bicep
+inputs: [
+  '*.Max'      // - $1
+  '*.Min'      // - $2
+  '*.Mid.Avg'  // - $3
+  '*.Mid.Mean' // - $4
+]
+output: 'ColorProperties.*'
+expression: '($1, $2, $3, $4)'
+```
+
+# [Kubernetes](#tab/kubernetes)
+
 ```yaml
 - inputs:
   - *.Max        # - $1
@@ -48,6 +78,8 @@ In conversions, formulas can operate on static values like a number such as *25*
   expression: ($1, $2, $3, $4)
 ```
 
+---
+
 In this example, the conversion results in an array containing the values of `[Max, Min, Mid.Avg, Mid.Mean]`. The comments in the YAML file (`# - $1`, `# - $2`) are optional, but they help to clarify the connection between each field property and its role in the conversion formula.
 
 ## Data types
@@ -125,32 +157,75 @@ Arrays can be processed by using aggregation functions to compute a single value
 
 ```json
 {
-    "Measurements": [2.34, 12.3, 32.4]
+  "Measurements": [2.34, 12.3, 32.4]
 }
 ```
 
 With the mapping:
 
+# [Bicep](#tab/bicep)
+
+```bicep
+inputs: [
+  'Measurements' // - $1
+]
+output: 'Measurement'
+expression: 'min($1)'
+```
+
+# [Kubernetes](#tab/kubernetes)
+
 ```yaml
 - inputs:
   - Measurements # - $1
   output: Measurement
   expression: min($1)
 ```
 
+---
+
 This configuration selects the smallest value from the `Measurements` array for the output field.
 
 It's also possible to use functions that result in a new array:
 
+# [Bicep](#tab/bicep)
+
+```bicep
+inputs: [
+  'Measurements' // - $1
+]
+output: 'Measurements'
+expression: 'take($1, 10)'  // taking at max 10 items
+```
+
+# [Kubernetes](#tab/kubernetes)
+
 ```yaml
 - inputs:
   - Measurements # - $1
   output: Measurements
   expression: take($1, 10)  # taking at max 10 items
 ```
 
+---
+
 Arrays can also be created from multiple single values:
 
+# [Bicep](#tab/bicep)
+
+```bicep
+inputs: [
+  'minimum' // - - $1
+  'maximum' // - - $2
+  'average' // - - $3
+  'mean'    // - - $4
+]
+output: 'stats'
+expression: '($1, $2, $3, $4)'
+```
+
+# [Kubernetes](#tab/kubernetes)
+
 ```yaml
 - inputs:
   - minimum  # - - $1
@@ -161,6 +236,8 @@ Arrays can also be created from multiple single values:
   expression: ($1, $2, $3, $4)
 ```
 
+---
+
 This mapping creates an array that contains the minimum, maximum, average, and mean.
 
 ### Missing value
@@ -174,11 +251,11 @@ Example mapping that uses a missing value:
 
 ```json
 {
-    "Employment": {      
-      "Position": "Analyst",
-      "BaseSalary": 75000,
-      "WorkingHours": "Regular"
-    }
+  "Employment": {      
+    "Position": "Analyst",
+    "BaseSalary": 75000,
+    "WorkingHours": "Regular"
+  }
 }
 ```
 
@@ -194,14 +271,29 @@ The input record contains the `BaseSalary` field, but possibly that's optional.
 
 A mapping can check if the field is present in the input record. If the field is found, the output receives that existing value. Otherwise, the output receives the value from the context dataset. For example:
 
+# [Bicep](#tab/bicep)
+
+```bicep
+inputs: [
+  'BaseSalary' // - - - - - - - - - - - $1
+  '$context(position).BaseSalary' //  - $2
+]
+output: 'BaseSalary'
+expression: 'if($1 == (), $2, $1)'
+```
+
+# [Kubernetes](#tab/kubernetes)
+
 ```yaml
 - inputs:
   - BaseSalary  # - - - - - - - - - - $1
-  - $context(position).BaseSalary #  - $2 
+  - $context(position).BaseSalary # - $2
   output: BaseSalary
   expression: if($1 == (), $2, $1)
 ```
 
+---
+
 The `conversion` uses the `if` function that has three parameters:
 
 * The first parameter is a condition. In the example, it checks if the `BaseSalary` field of the input field (aliased as `$1`) is the missing value.

articles/iot-operations/connect-to-cloud/concept-dataflow-enrich.md

@@ -5,7 +5,7 @@ author: PatAltimore
 ms.author: patricka
 ms.subservice: azure-data-flows
 ms.topic: concept-article
-ms.date: 08/13/2024
+ms.date: 10/30/2024
 
 #CustomerIntent: As an operator, I want to understand how to create a dataflow to enrich data sent to endpoints.
 ms.service: azure-iot-operations
@@ -34,20 +34,60 @@ For example, consider the following dataset with a few records, represented as J
 
 The mapper accesses the reference dataset stored in the Azure IoT Operations [distributed state store (DSS)](../create-edge-apps/concept-about-state-store-protocol.md) by using a key value based on a *condition* specified in the mapping configuration. Key names in the DSS correspond to a dataset in the dataflow configuration.
 
+# [Bicep](#tab/bicep)
+
+```bicep
+datasets: [
+  {
+    key: 'position',
+    inputs: [
+      '$source.Position' //  - $1
+      '$context.Position' // - $2
+    ],
+    expression: '$1 == $2'
+  }
+]
+```
+
+# [Kubernetes](#tab/kubernetes)
+
 ```yaml
 datasets:
 - key: position
   inputs:
-    - $source.Position # - $1
-    - $context.Position # -$2
+    - $source.Position #  - $1
+    - $context.Position # - $2
   expression: $1 == $2
 ```
 
+---
+
 When a new record is being processed, the mapper performs the following steps:
 
 * **Data request:** The mapper sends a request to the DSS to retrieve the dataset stored under the key `Position`.
 * **Record matching:** The mapper then queries this dataset to find the first record where the `Position` field in the dataset matches the `Position` field of the incoming record.
 
+# [Bicep](#tab/bicep)
+
+```bicep
+{
+  inputs: [
+    '$context(position).WorkingHours' //  - $1 
+  ]
+  output: 'WorkingHours'
+}
+{
+  inputs: [
+    'BaseSalary' // - - - - - - - - - - - - $1
+    '$context(position).BaseSalary' //  - - $2
+  ]
+  output: 'BaseSalary'
+  expression: 'if($1 == (), $2, $1)'
+}
+```
+
+# [Kubernetes](#tab/kubernetes)
+
 ```yaml
 - inputs:
   - $context(position).WorkingHours #  - $1 
@@ -60,10 +100,37 @@ When a new record is being processed, the mapper performs the following steps:
   expression: if($1 == (), $2, $1)
 ```
 
+---
+
 In this example, the `WorkingHours` field is added to the output record, while the `BaseSalary` is used conditionally only when the incoming record doesn't contain the `BaseSalary` field (or the value is `null` if it's a nullable field). The request for the contextualization data doesn't happen with every incoming record. The mapper requests the dataset and then it receives notifications from DSS about the changes, while it uses a cached version of the dataset.
 
 It's possible to use multiple datasets:
 
+# [Bicep](#tab/bicep)
+
+```bicep
+datasets: [
+  {
+    key: 'position'
+    inputs: [
+      '$source.Position'  // - $1
+      '$context.Position' // - $2
+    ],
+    expression: '$1 == $2'
+  }
+  {
+    key: 'permissions'
+    inputs: [
+      '$source.Position'  // - $1
+      '$context.Position' // - $2
+    ],
+    expression: '$1 == $2'
+  }
+]
+```
+
+# [Kubernetes](#tab/kubernetes)
+
 ```yaml
 datasets:
 - key: position
@@ -79,16 +146,48 @@ datasets:
   expression: $1 == $2
 ```
 
+---
+
 Then use the references mixed:
 
+# [Bicep](#tab/bicep)
+
+```bicep
+inputs: [
+  '$context(position).WorkingHours'  // - $1
+  '$context(permissions).NightShift' // - $2
+]
+```
+
+# [Kubernetes](#tab/kubernetes)
+
 ```yaml
 - inputs:
   - $context(position).WorkingHours  #    - - $1
   - $context(permission).NightShift  #    - - $2
 ```
 
+---
+
 The input references use the key of the dataset like `position` or `permission`. If the key in DSS is inconvenient to use, you can define an alias:
 
+# [Bicep](#tab/bicep)
+
+```bicep
+datasets: [
+  {
+    key: 'datasets.parag10.rule42 as position'
+    inputs: [
+      '$source.Position'  // - $1
+      '$context.Position' // - $2
+    ],
+    expression: '$1 == $2'
+  }
+]
+```
+
+# [Kubernetes](#tab/kubernetes)
+
 ```yaml
 datasets:
   - key: datasets.parag10.rule42 as position
@@ -98,4 +197,6 @@ datasets:
     expression: $1 == $2
 ```
 
+---
+
 The configuration renames the dataset with the key `datasets.parag10.rule42` to `position`.