Fixes

Author: alexbuckgit

articles/data-factory/v1/data-factory-build-your-first-pipeline-using-arm.md

@@ -300,24 +300,30 @@ Create a JSON file named **ADFTutorialARM-Parameters.json** that contains parame
 ```
 
 > [!IMPORTANT]
-> You may have separate parameter JSON files for development, testing, and production environments that you can use with the same Data Factory JSON template. By using a Power Shell script, you can automate deploying Data Factory entities in these environments. 
-> 
-> 
+> You may have separate parameter JSON files for development, testing, and production environments that you can use with the same Data Factory JSON template. By using a Power Shell script, you can automate deploying Data Factory entities in these environments.
 
 ## Create data factory
-1. Start **Azure PowerShell** and run the following command: 
+
+1. Start **Azure PowerShell** and run the following command:
+
    * Run the following command and enter the user name and password that you use to sign in to the Azure portal.
-     ```PowerShell
+
+     ```powershell
      Connect-AzAccount
-     ```  
+     ```
+
    * Run the following command to view all the subscriptions for this account.
-     ```PowerShell
+
+     ```powershell
      Get-AzSubscription
-     ``` 
-   * Run the following command to select the subscription that you want to work with. This subscription should be the same as the one you used in the Azure portal.
      ```
+
+   * Run the following command to select the subscription that you want to work with. This subscription should be the same as the one you used in the Azure portal.
+
+     ```powershell
      Get-AzSubscription -SubscriptionName <SUBSCRIPTION NAME> | Set-AzContext
-     ```   
+     ```
+
 2. Run the following command to deploy Data Factory entities using the Resource Manager template you created in Step 1. 
 
    ```powershell
@@ -560,17 +566,18 @@ You define a pipeline that transform data by running Hive script on an on-demand
 ```
 
 ## Reuse the template
-In the tutorial, you created a template for defining Data Factory entities and a template for passing values for parameters. To use the same template to deploy Data Factory entities to different environments, you create a parameter file for each environment and use it when deploying to that environment.     
+In the tutorial, you created a template for defining Data Factory entities and a template for passing values for parameters. To use the same template to deploy Data Factory entities to different environments, you create a parameter file for each environment and use it when deploying to that environment.
 
-Example:  
+Example:
 
-```PowerShell
+```powershell
 New-AzResourceGroupDeployment -Name MyARMDeployment -ResourceGroupName ADFTutorialResourceGroup -TemplateFile ADFTutorialARM.json -TemplateParameterFile ADFTutorialARM-Parameters-Dev.json
 
 New-AzResourceGroupDeployment -Name MyARMDeployment -ResourceGroupName ADFTutorialResourceGroup -TemplateFile ADFTutorialARM.json -TemplateParameterFile ADFTutorialARM-Parameters-Test.json
 
 New-AzResourceGroupDeployment -Name MyARMDeployment -ResourceGroupName ADFTutorialResourceGroup -TemplateFile ADFTutorialARM.json -TemplateParameterFile ADFTutorialARM-Parameters-Production.json
 ```
+
 Notice that the first command uses parameter file for the development environment, second one for the test environment, and the third one for the production environment.  
 
 You can also reuse the template to perform repeated tasks. For example, you need to create many data factories with one or more pipelines that implement the same logic but each data factory uses different Azure storage and Azure SQL Database accounts. In this scenario, you use the same template in the same environment (dev, test, or production) with different parameter files to create data factories. 

articles/data-factory/v1/data-factory-build-your-first-pipeline-using-powershell.md

@@ -43,27 +43,36 @@ The pipeline in this tutorial has one activity: **HDInsight Hive activity**. Thi
 In this step, you use Azure PowerShell to create an Azure Data Factory named **FirstDataFactoryPSH**. A data factory can have one or more pipelines. A pipeline can have one or more activities in it. For example, a Copy Activity to copy data from a source to a destination data store and a HDInsight Hive activity to run a Hive script to transform input data. Let's start with creating the data factory in this step.
 
 1. Start Azure PowerShell and run the following command. Keep Azure PowerShell open until the end of this tutorial. If you close and reopen, you need to run these commands again.
+
    * Run the following command and enter the user name and password that you use to sign in to the Azure portal.
-     ```PowerShell
+
+     ```powershell
      Connect-AzAccount
-     ```    
+     ```
+
    * Run the following command to view all the subscriptions for this account.
-     ```PowerShell
+
+     ```powershell
      Get-AzSubscription  
      ```
+
    * Run the following command to select the subscription that you want to work with. This subscription should be the same as the one you used in the Azure portal.
-     ```PowerShell
+
+     ```powershell
      Get-AzSubscription -SubscriptionName <SUBSCRIPTION NAME> | Set-AzContext
-     ```     
+     ```
+
 2. Create an Azure resource group named **ADFTutorialResourceGroup** by running the following command:
 	
-	```PowerShell
+    ```powershell
     New-AzResourceGroup -Name ADFTutorialResourceGroup  -Location "West US"
     ```
+
     Some of the steps in this tutorial assume that you use the resource group named ADFTutorialResourceGroup. If you use a different resource group, you need to use it in place of ADFTutorialResourceGroup in this tutorial.
+
 3. Run the **New-AzDataFactory** cmdlet that creates a data factory named **FirstDataFactoryPSH**.
 
-    ```PowerShell
+    ```powershell
     New-AzDataFactory -ResourceGroupName ADFTutorialResourceGroup -Name FirstDataFactoryPSH –Location "West US"
     ```
 
@@ -76,14 +85,16 @@ Note the following:
 
   * In Azure PowerShell, run the following command to register the Data Factory provider:
 
-	```PowerShell
-	Register-AzResourceProvider -ProviderNamespace Microsoft.DataFactory
+    ```powershell
+    Register-AzResourceProvider -ProviderNamespace Microsoft.DataFactory
     ```
-      You can run the following command to confirm that the Data Factory provider is registered:
 
-	```PowerShell
-	Get-AzResourceProvider
+    You can run the following command to confirm that the Data Factory provider is registered:
+
+    ```powershell
+    Get-AzResourceProvider
     ```
+
   * Login using the Azure subscription into the [Azure portal](https://portal.azure.com) and navigate to a Data Factory blade (or) create a data factory in the Azure portal. This action automatically registers the provider for you.
 
 Before creating a pipeline, you need to create a few Data Factory entities first. You first create linked services to link data stores/computes to your data store, define input and output datasets to represent input/output data in linked data stores, and then create the pipeline with an activity that uses these datasets.
@@ -112,19 +123,21 @@ In this step, you link your Azure Storage account to your data factory. You use
 2. In Azure PowerShell, switch to the ADFGetStarted folder.
 3. You can use the **New-AzDataFactoryLinkedService** cmdlet that creates a linked service. This cmdlet and other Data Factory cmdlets you use in this tutorial requires you to pass values for the *ResourceGroupName* and *DataFactoryName* parameters. Alternatively, you can use **Get-AzDataFactory** to get a **DataFactory** object and pass the object without typing *ResourceGroupName* and *DataFactoryName* each time you run a cmdlet. Run the following command to assign the output of the **Get-AzDataFactory** cmdlet to a **$df** variable.
 
-	```PowerShell
-	$df=Get-AzDataFactory -ResourceGroupName ADFTutorialResourceGroup -Name FirstDataFactoryPSH
+    ```powershell
+    $df = Get-AzDataFactory -ResourceGroupName ADFTutorialResourceGroup -Name FirstDataFactoryPSH
     ```
 4. Now, run the **New-AzDataFactoryLinkedService** cmdlet that creates the linked **StorageLinkedService** service.
 
-	```PowerShell
-	New-AzDataFactoryLinkedService $df -File .\StorageLinkedService.json
+    ```powershell
+    New-AzDataFactoryLinkedService $df -File .\StorageLinkedService.json
     ```
+
     If you hadn't run the **Get-AzDataFactory** cmdlet and assigned the output to the **$df** variable, you would have to specify values for the *ResourceGroupName* and *DataFactoryName* parameters as follows.
 
-	```PowerShell
-	New-AzDataFactoryLinkedService -ResourceGroupName ADFTutorialResourceGroup -DataFactoryName FirstDataFactoryPSH -File .\StorageLinkedService.json
+    ```powershell
+    New-AzDataFactoryLinkedService -ResourceGroupName ADFTutorialResourceGroup -DataFactoryName FirstDataFactoryPSH -File .\StorageLinkedService.json
     ```
+
     If you close Azure PowerShell in the middle of the tutorial, you have to run the **Get-AzDataFactory** cmdlet next time you start Azure PowerShell to complete the tutorial.
 
 ### Create Azure HDInsight linked service
@@ -165,9 +178,9 @@ In this step, you link an on-demand HDInsight cluster to your data factory. The
 
      See [On-demand HDInsight Linked Service](data-factory-compute-linked-services.md#azure-hdinsight-on-demand-linked-service) for details.
 2. Run the **New-AzDataFactoryLinkedService** cmdlet that creates the linked service called HDInsightOnDemandLinkedService.
-	
-	```PowerShell
-	New-AzDataFactoryLinkedService $df -File .\HDInsightOnDemandLinkedService.json
+
+    ```powershell
+    New-AzDataFactoryLinkedService $df -File .\HDInsightOnDemandLinkedService.json
     ```
 
 ## Create datasets
@@ -214,16 +227,16 @@ In this step, you create datasets to represent the input and output data for Hiv
    | external |this property is set to true if the input data is not generated by the Data Factory service. |
 2. Run the following command in Azure PowerShell to create the Data Factory dataset:
 
-	```PowerShell
-	New-AzDataFactoryDataset $df -File .\InputTable.json
+    ```powershell
+    New-AzDataFactoryDataset $df -File .\InputTable.json
     ```
 
 ### Create output dataset
 Now, you create the output dataset to represent the output data stored in the Azure Blob storage.
 
 1. Create a JSON file named **OutputTable.json** in the **C:\ADFGetStarted** folder with the following content:
 
-	```json
+    ```json
     {
       "name": "AzureBlobOutput",
       "properties": {
@@ -243,11 +256,13 @@ Now, you create the output dataset to represent the output data stored in the Az
       }
     }
     ```
+
     The JSON defines a dataset named **AzureBlobOutput**, which represents output data for an activity in the pipeline. In addition, it specifies that the results are stored in the blob container called **adfgetstarted** and the folder called **partitioneddata**. The **availability** section specifies that the output dataset is produced on a monthly basis.
+
 2. Run the following command in Azure PowerShell to create the Data Factory dataset:
 
-	```PowerShell
-	New-AzDataFactoryDataset $df -File .\OutputTable.json
+    ```powershell
+    New-AzDataFactoryDataset $df -File .\OutputTable.json
     ```
 
 ## Create pipeline
@@ -319,27 +334,30 @@ In this step, you create your first pipeline with a **HDInsightHive** activity.
 
 2. Confirm that you see the **input.log** file in the **adfgetstarted/inputdata** folder in the Azure blob storage, and run the following command to deploy the pipeline. Since the **start** and **end** times are set in the past and **isPaused** is set to false, the pipeline (activity in the pipeline) runs immediately after you deploy.
 
-	```PowerShell
-	New-AzDataFactoryPipeline $df -File .\MyFirstPipelinePSH.json
+    ```powershell
+    New-AzDataFactoryPipeline $df -File .\MyFirstPipelinePSH.json
     ```
+
 3. Congratulations, you have successfully created your first pipeline using Azure PowerShell!
 
 ## Monitor pipeline
 In this step, you use Azure PowerShell to monitor what’s going on in an Azure data factory.
 
 1. Run **Get-AzDataFactory** and assign the output to a **$df** variable.
 
-	```PowerShell
-	$df=Get-AzDataFactory -ResourceGroupName ADFTutorialResourceGroup -Name FirstDataFactoryPSH
+    ```powershell
+    $df = Get-AzDataFactory -ResourceGroupName ADFTutorialResourceGroup -Name FirstDataFactoryPSH
     ```
+
 2. Run **Get-AzDataFactorySlice** to get details about all slices of the **EmpSQLTable**, which is the output table of the pipeline.
 
-	```PowerShell
-	Get-AzDataFactorySlice $df -DatasetName AzureBlobOutput -StartDateTime 2017-07-01
+    ```powershell
+    Get-AzDataFactorySlice $df -DatasetName AzureBlobOutput -StartDateTime 2017-07-01
     ```
+
     Notice that the StartDateTime you specify here is the same start time specified in the pipeline JSON. Here is the sample output:
 
-	```PowerShell
+    ```output
     ResourceGroupName : ADFTutorialResourceGroup
     DataFactoryName   : FirstDataFactoryPSH
     DatasetName       : AzureBlobOutput
@@ -351,15 +369,16 @@ In this step, you use Azure PowerShell to monitor what’s going on in an Azure
     LatencyStatus     :
     LongRetryCount    : 0
     ```
+
 3. Run **Get-AzDataFactoryRun** to get the details of activity runs for a specific slice.
 
-	```PowerShell
-	Get-AzDataFactoryRun $df -DatasetName AzureBlobOutput -StartDateTime 2017-07-01
+    ```powershell
+    Get-AzDataFactoryRun $df -DatasetName AzureBlobOutput -StartDateTime 2017-07-01
     ```
 
     Here is the sample output: 
 
-	```PowerShell
+    ```output
     Id                  : 0f6334f2-d56c-4d48-b427-d4f0fb4ef883_635268096000000000_635292288000000000_AzureBlobOutput
     ResourceGroupName   : ADFTutorialResourceGroup
     DataFactoryName     : FirstDataFactoryPSH
@@ -378,6 +397,7 @@ In this step, you use Azure PowerShell to monitor what’s going on in an Azure
     PipelineName        : MyFirstPipeline
     Type                : Script
     ```
+
     You can keep running this cmdlet until you see the slice in **Ready** state or **Failed** state. When the slice is in Ready state, check the **partitioneddata** folder in the **adfgetstarted** container in your blob storage for the output data.  Creation of an on-demand HDInsight cluster usually takes some time.
 
     :::image type="content" source="./media/data-factory-build-your-first-pipeline-using-powershell/three-ouptut-files.png" alt-text="output data":::

articles/data-factory/v1/data-factory-copy-activity-tutorial-using-azure-resource-manager-template.md

@@ -580,17 +580,19 @@ You define a pipeline that copies data from the Azure blob dataset to the Azure
 ```
 
 ## Reuse the template
-In the tutorial, you created a template for defining Data Factory entities and a template for passing values for parameters. The pipeline copies data from an Azure Storage account to Azure SQL Database specified via parameters. To use the same template to deploy Data Factory entities to different environments, you create a parameter file for each environment and use it when deploying to that environment.     
+In the tutorial, you created a template for defining Data Factory entities and a template for passing values for parameters. The pipeline copies data from an Azure Storage account to Azure SQL Database specified via parameters. To use the same template to deploy Data Factory entities to different environments, you create a parameter file for each environment and use it when deploying to that environment.
 
-Example:  
+Example:
 
-```PowerShell
+```powershell
 New-AzResourceGroupDeployment -Name MyARMDeployment -ResourceGroupName ADFTutorialResourceGroup -TemplateFile ADFCopyTutorialARM.json -TemplateParameterFile ADFCopyTutorialARM-Parameters-Dev.json
 ```
-```PowerShell
+
+```powershell
 New-AzResourceGroupDeployment -Name MyARMDeployment -ResourceGroupName ADFTutorialResourceGroup -TemplateFile ADFCopyTutorialARM.json -TemplateParameterFile ADFCopyTutorialARM-Parameters-Test.json
 ```
-```PowerShell
+
+```powershell
 New-AzResourceGroupDeployment -Name MyARMDeployment -ResourceGroupName ADFTutorialResourceGroup -TemplateFile ADFCopyTutorialARM.json -TemplateParameterFile ADFCopyTutorialARM-Parameters-Production.json
 ```
 

articles/data-factory/v1/data-factory-data-management-gateway.md

@@ -456,7 +456,7 @@ To encrypt credentials in the Data Factory Editor, do the following steps:
    4. Click **OK** to encrypt credentials and close the dialog box.
 8. You should see a **encryptedCredential** property in the **connectionString** now.
 
-    ```json`
+    ```json
     {
         "name": "SqlServerLinkedService",
         "properties": {