Een CI/CD-pijplijn instellen voor Azure Data Lake Analytics

In dit artikel leert u hoe u een CI/CD-pijplijn (Continue integratie en implementatie) instelt voor U-SQL-taken en U-SQL-databases.

CI/CD gebruiken voor U-SQL-taken

Azure Data Lake Tools voor Visual Studio biedt het U-SQL-projecttype waarmee u U-SQL-scripts kunt ordenen. Door het U-SQL-project te gebruiken om uw U-SQL-code te beheren, zijn verdere CI/CD-scenario's eenvoudig.

Een U-SQL-project bouwen

Een U-SQL-project kan worden gebouwd met de Microsoft Build Engine (MSBuild) door de bijbehorende parameters door te geven. Volg de stappen in dit artikel om een buildproces in te stellen voor een U-SQL-project.

Projectmigratie

Voordat u een build-taak voor een U-SQL-project instelt, moet u ervoor zorgen dat u de nieuwste versie van het U-SQL-project hebt. Open het U-SQL-projectbestand in uw editor en controleer of u deze importitems hebt:

<!-- check for SDK Build target in current path then in USQLSDKPath-->
<Import Project="UsqlSDKBuild.targets" Condition="Exists('UsqlSDKBuild.targets')" />
<Import Project="$(USQLSDKPath)\UsqlSDKBuild.targets" Condition="!Exists('UsqlSDKBuild.targets') And '$(USQLSDKPath)' != '' And Exists('$(USQLSDKPath)\UsqlSDKBuild.targets')" />

Als dat niet het probleem is, hebt u twee opties om het project te migreren:

• Optie 1: Het oude importitem wijzigen in het voorgaande item.
• Optie 2: Open het oude project in Azure Data Lake Tools voor Visual Studio. Gebruik een nieuwere versie dan 2.3.3000.0. De oude projectsjabloon wordt automatisch bijgewerkt naar de nieuwste versie. Nieuwe projecten die zijn gemaakt met nieuwere versies dan 2.3.3000.0 gebruiken de nieuwe sjabloon.

NuGet ophalen

MSBuild biedt geen ingebouwde ondersteuning voor U-SQL-projecten. Voor deze ondersteuning moet u een verwijzing voor uw oplossing toevoegen aan het Microsoft.Azure.DataLake.USQL.SDK NuGet-pakket waarmee de vereiste taalservice wordt toegevoegd.

Als u de NuGet-pakketverwijzing wilt toevoegen, klikt u met de rechtermuisknop op de oplossing in Visual Studio Solution Explorer en kiest u NuGet-pakketten beheren. U kunt ook een bestand met de naam packages.config toevoegen in de oplossingsmap en de volgende inhoud erin plaatsen:

<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Microsoft.Azure.DataLake.USQL.SDK" version="1.3.180620" targetFramework="net452" />
</packages>

U-SQL-databaseverwijzingen beheren

U-SQL-scripts in een U-SQL-project bevatten mogelijk queryinstructies voor U-SQL-databaseobjecten. In dat geval moet u verwijzen naar het bijbehorende U-SQL-databaseproject dat de definitie van de objecten bevat voordat u het U-SQL-project bouwt. Een voorbeeld is wanneer u een query uitvoert op een U-SQL-tabel of naar een assembly verwijst.

Meer informatie over U-SQL-databaseproject.

Een U-SQL-project bouwen met de MSBuild-opdrachtregel

Migreer eerst het project en haal het NuGet-pakket op. Roep vervolgens de standaard-MSBuild-opdrachtregel aan met de volgende argumenten om uw U-SQL-project te bouwen:

msbuild USQLBuild.usqlproj /p:USQLSDKPath=packages\Microsoft.Azure.DataLake.USQL.SDK.1.3.180615\build\runtime;USQLTargetType=SyntaxCheck;DataRoot=datarootfolder;/p:EnableDeployment=true

De definitie en waarden van de argumenten zijn als volgt:

• USQLSDKPath=<U-SQL NuGet-pakket>\build\runtime. Deze parameter verwijst naar het installatiepad van het NuGet-pakket voor de U-SQL-taalservice.

• USQLTargetType=Merge of SyntaxCheck:

  • Samenvoegen. Met de samenvoegmodus worden code-behind-bestanden gecompileerd. Voorbeelden zijn .cs, .pyen .r bestanden. Het integreert de resulterende codebibliotheek die door de gebruiker is gedefinieerd in het U-SQL-script. Voorbeelden zijn een binaire DLL-code, Python of R-code.

  • SyntaxControle. SyntaxCheck-modus voegt eerst code-behind-bestanden samen in het U-SQL-script. Vervolgens wordt het U-SQL-script gecompileerd om uw code te valideren.

• DataRoot=<DataRoot path>. DataRoot is alleen nodig voor de syntaxiscontrolemodus. Wanneer het script wordt gebouwd met de syntaxiscontrolemodus, controleert MSBuild de verwijzingen naar databaseobjecten in het script. Voordat u gaat bouwen, stelt u een overeenkomende lokale omgeving in die de objecten bevat waarnaar wordt verwezen uit de U-SQL-database in de dataroot-map van de buildcomputer. U kunt deze databaseafhankelijkheden ook beheren door te verwijzen naar een U-SQL-databaseproject. MSBuild controleert alleen databaseobjectverwijzingen, geen bestanden.

• EnableDeployment=true of false. EnableDeployment geeft aan of het is toegestaan om tijdens het buildproces verwijzingen naar U-SQL-databases te implementeren. Als u naar een U-SQL-databaseproject verwijst en de databaseobjecten in uw U-SQL-script gebruikt, stelt u deze parameter in op true.

Continue integratie via Azure Pipelines

Naast de opdrachtregel kunt u ook de Visual Studio Build- of MSBuild-taak gebruiken om U-SQL-projecten te bouwen in Azure Pipelines. Als u een build-pijplijn wilt instellen, moet u twee taken toevoegen in de build-pijplijn: een NuGet-hersteltaak en een MSBuild-taak.

1. Voeg een NuGet-restore-taak toe om het NuGet-pakket dat door de oplossing wordt verwezen, op te halen met Azure.DataLake.USQL.SDK, zodat MSBuild de doelen voor de U-SQL-taal kan vinden. Stel Advanced>Destination directory in op $(Build.SourcesDirectory)/packages als u het msBuild-argumentenvoorbeeld rechtstreeks in stap 2 wilt gebruiken.

   

2. Stel MSBuild-argumenten in Visual Studio-buildhulpprogramma's of in een MSBuild-taak in, zoals wordt weergegeven in het volgende voorbeeld. U kunt ook variabelen definiëren voor deze argumenten in de build-pijplijn van Azure Pipelines.

   

   /p:USQLSDKPath=$(Build.SourcesDirectory)/packages/Microsoft.Azure.DataLake.USQL.SDK.1.3.180615/build/runtime /p:USQLTargetType=SyntaxCheck /p:DataRoot=$(Build.SourcesDirectory) /p:EnableDeployment=true
   

De buildoutput van een U-SQL-project

Nadat u een build hebt uitgevoerd, worden alle scripts in het U-SQL-project gebouwd en uitgevoerd naar een zip-bestand met de naam USQLProjectName.usqlpack. De mapstructuur in uw project wordt bewaard in de gezipte build-uitvoer.

U-SQL-scripts testen

Azure Data Lake biedt testprojecten voor U-SQL-scripts en C# UDO/UDAG/UDF:

• Leer hoe je test-cases toevoegt voor U-SQL-scripts en uitgebreide C#-code

• Meer informatie over het uitvoeren van testcases in Azure Pipelines.

Een U-SQL-taak implementeren

Nadat u code hebt gecontroleerd via het build- en testproces, kunt u U-SQL-taken rechtstreeks vanuit Azure Pipelines verzenden via een Azure PowerShell-taak. U kunt het script ook implementeren in Azure Data Lake Store of Azure Blob Storage en de geplande taken uitvoeren via Azure Data Factory.

U-SQL-opdrachten verzenden via Azure Pipelines

De build-uitvoer van het U-SQL-project is een zip-bestand met de naam USQLProjectName.usqlpack. Het zip-bestand bevat alle U-SQL-scripts in het project. U kunt de Azure PowerShell-taak in Pijplijnen gebruiken met het volgende PowerShell-voorbeeldscript om U-SQL-taken rechtstreeks vanuit Azure Pipelines te verzenden.

<#
   This script can be used to submit U-SQL Jobs with given U-SQL project build output(.usqlpack file).
   This will unzip the U-SQL project build output, and submit all scripts one-by-one.

   Note: the code behind file for each U-SQL script will be merged into the built U-SQL script in build output.

   Example :
      USQLJobSubmission.ps1 -ADLAAccountName "myadlaaccount" -ArtifactsRoot "C:\USQLProject\bin\debug\" -DegreeOfParallelism 2
#>

param(
   [Parameter(Mandatory=$true)][string]$ADLAAccountName, # ADLA account name to submit U-SQL jobs
   [Parameter(Mandatory=$true)][string]$ArtifactsRoot, # Root folder of U-SQL project build output
   [Parameter(Mandatory=$false)][string]$DegreeOfParallelism = 1
)

function Unzip($USQLPackfile, $UnzipOutput)
{
   $USQLPackfileZip = Rename-Item -Path $USQLPackfile -NewName $([System.IO.Path]::ChangeExtension($USQLPackfile, ".zip")) -Force -PassThru
   Expand-Archive -Path $USQLPackfileZip -DestinationPath $UnzipOutput -Force
   Rename-Item -Path $USQLPackfileZip -NewName $([System.IO.Path]::ChangeExtension($USQLPackfileZip, ".usqlpack")) -Force
}

## Get U-SQL scripts in U-SQL project build output(.usqlpack file)
Function GetUsqlFiles()
{

   $USQLPackfiles = Get-ChildItem -Path $ArtifactsRoot -Include *.usqlpack -File -Recurse -ErrorAction SilentlyContinue

   $UnzipOutput = Join-Path $ArtifactsRoot -ChildPath "UnzipUSQLScripts"

   foreach ($USQLPackfile in $USQLPackfiles)
   {
      Unzip $USQLPackfile $UnzipOutput
   }

   $USQLFiles = Get-ChildItem -Path $UnzipOutput -Include *.usql -File -Recurse -ErrorAction SilentlyContinue

   return $USQLFiles
}

## Submit U-SQL scripts to ADLA account one-by-one
Function SubmitAnalyticsJob()
{
   $usqlFiles = GetUsqlFiles

   Write-Output "$($usqlFiles.Count) jobs to be submitted..."

   # Submit each usql script and wait for completion before moving ahead.
   foreach ($usqlFile in $usqlFiles)
   {
      $scriptName = "[Release].[$([System.IO.Path]::GetFileNameWithoutExtension($usqlFile.fullname))]"

      Write-Output "Submitting job for '{$usqlFile}'"

      $jobToSubmit = Submit-AzDataLakeAnalyticsJob -Account $ADLAAccountName -Name $scriptName -ScriptPath $usqlFile -DegreeOfParallelism $DegreeOfParallelism

      LogJobInformation $jobToSubmit

      Write-Output "Waiting for job to complete. Job ID:'{$($jobToSubmit.JobId)}', Name: '$($jobToSubmit.Name)' "
      $jobResult = Wait-AzDataLakeAnalyticsJob -Account $ADLAAccountName -JobId $jobToSubmit.JobId  
      LogJobInformation $jobResult
   }
}

Function LogJobInformation($jobInfo)
{
   Write-Output "************************************************************************"
   Write-Output ([string]::Format("Job Id: {0}", $(DefaultIfNull $jobInfo.JobId)))
   Write-Output ([string]::Format("Job Name: {0}", $(DefaultIfNull $jobInfo.Name)))
   Write-Output ([string]::Format("Job State: {0}", $(DefaultIfNull $jobInfo.State)))
   Write-Output ([string]::Format("Job Started at: {0}", $(DefaultIfNull  $jobInfo.StartTime)))
   Write-Output ([string]::Format("Job Ended at: {0}", $(DefaultIfNull  $jobInfo.EndTime)))
   Write-Output ([string]::Format("Job Result: {0}", $(DefaultIfNull $jobInfo.Result)))
   Write-Output "************************************************************************"
}

Function DefaultIfNull($item)
{
   if ($item -ne $null)
   {
      return $item
   }
   return ""
}

Function Main()
{
   Write-Output ([string]::Format("ADLA account: {0}", $ADLAAccountName))
   Write-Output ([string]::Format("Root folde for usqlpack: {0}", $ArtifactsRoot))
   Write-Output ([string]::Format("AU count: {0}", $DegreeOfParallelism))

   Write-Output "Starting USQL script deployment..."

   SubmitAnalyticsJob

   Write-Output "Finished deployment..."
}

Main

U-SQL-taken uitvoeren via Azure Data Factory

U kunt U-SQL-taken rechtstreeks verzenden vanuit Azure Pipelines. Of u kunt de ingebouwde scripts uploaden naar Azure Data Lake Store of Azure Blob Storage en de geplande taken uitvoeren via Azure Data Factory.

Gebruik de Azure PowerShell-taak in Azure Pipelines met het volgende PowerShell-voorbeeldscript om de U-SQL-scripts te uploaden naar een Azure Data Lake Store-account:

<#
   This script can be used to upload U-SQL files to ADLS with given U-SQL project build output(.usqlpack file).
   This will unzip the U-SQL project build output, and upload all scripts to ADLS one-by-one.

   Example :
      FileUpload.ps1 -ADLSName "myadlsaccount" -ArtifactsRoot "C:\USQLProject\bin\debug\"
#>

param(
   [Parameter(Mandatory=$true)][string]$ADLSName, # ADLS account name to upload U-SQL scripts
   [Parameter(Mandatory=$true)][string]$ArtifactsRoot, # Root folder of U-SQL project build output
   [Parameter(Mandatory=$false)][string]$DestinationFolder = "USQLScriptSource" # Destination folder in ADLS
)

Function UploadResources()
{
   Write-Host "************************************************************************"
   Write-Host "Uploading files to $ADLSName"
   Write-Host "***********************************************************************"

   $usqlScripts = GetUsqlFiles

   $files = @(get-childitem $usqlScripts -recurse)
   foreach($file in $files)
   {
      Write-Host "Uploading file: $($file.Name)"
      Import-AzDataLakeStoreItem -AccountName $ADLSName -Path $file.FullName -Destination "/$(Join-Path $DestinationFolder $file)" -Force
   }
}

function Unzip($USQLPackfile, $UnzipOutput)
{
   $USQLPackfileZip = Rename-Item -Path $USQLPackfile -NewName $([System.IO.Path]::ChangeExtension($USQLPackfile, ".zip")) -Force -PassThru
   Expand-Archive -Path $USQLPackfileZip -DestinationPath $UnzipOutput -Force
   Rename-Item -Path $USQLPackfileZip -NewName $([System.IO.Path]::ChangeExtension($USQLPackfileZip, ".usqlpack")) -Force
}

Function GetUsqlFiles()
{

   $USQLPackfiles = Get-ChildItem -Path $ArtifactsRoot -Include *.usqlpack -File -Recurse -ErrorAction SilentlyContinue

   $UnzipOutput = Join-Path $ArtifactsRoot -ChildPath "UnzipUSQLScripts"

   foreach ($USQLPackfile in $USQLPackfiles)
   {
      Unzip $USQLPackfile $UnzipOutput
   }

   return Get-ChildItem -Path $UnzipOutput -Include *.usql -File -Recurse -ErrorAction SilentlyContinue
}

UploadResources

CI/CD voor een U-SQL-database

Azure Data Lake Tools voor Visual Studio biedt U-SQL-databaseprojectsjablonen waarmee u U-SQL-databases kunt ontwikkelen, beheren en implementeren. Meer informatie over een U-SQL-databaseproject.

U-SQL-databaseproject bouwen

Het NuGet-pakket ophalen

MSBuild biedt geen ingebouwde ondersteuning voor U-SQL-databaseprojecten. Om deze mogelijkheid te verkrijgen, moet u een verwijzing voor uw oplossing toevoegen aan het Microsoft.Azure.DataLake.USQL.SDK NuGet-pakket waarmee de vereiste taalservice wordt toegevoegd.

Als u de NuGet-pakketverwijzing wilt toevoegen, klikt u met de rechtermuisknop op de oplossing in Visual Studio Solution Explorer. Kies NuGet-pakketten beheren. Zoek en installeer vervolgens het NuGet-pakket. U kunt ook een bestand met de naam packages.config toevoegen in de oplossingsmap en de volgende inhoud erin plaatsen:

<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Microsoft.Azure.DataLake.USQL.SDK" version="1.3.180615" targetFramework="net452" />
</packages>

Met de MSBuild-opdrachtregel een U-SQL-databaseproject bouwen

Als u uw U-SQL-databaseproject wilt bouwen, roept u de standaard MSBuild-opdrachtregel aan en geeft u de U-SQL SDK NuGet-pakketverwijzing door als een ander argument. Zie het volgende voorbeeld:

msbuild DatabaseProject.usqldbproj /p:USQLSDKPath=packages\Microsoft.Azure.DataLake.USQL.SDK.1.3.180615\build\runtime

Het argument USQLSDKPath=<U-SQL Nuget package>\build\runtime verwijst naar het installatiepad van het NuGet-pakket voor de U-SQL-taalservice.

Continue integratie met Azure Pipelines

Naast de opdrachtregel kunt u Visual Studio Build of een MSBuild-taak gebruiken om U-SQL-databaseprojecten te bouwen in Azure Pipelines. Als u een build-taak wilt instellen, moet u twee taken toevoegen in de build-pijplijn: een NuGet-hersteltaak en een MSBuild-taak.

1. Voeg een NuGet-hersteltaak toe om het NuGet-pakket waarnaar wordt verwezen met de oplossing op te halen, inclusief Azure.DataLake.USQL.SDK, zodat MSBuild de U-SQL-taaldoelen kan vinden. Stel Advanced>Destination directory in op $(Build.SourcesDirectory)/packages als u het msBuild-argumentenvoorbeeld rechtstreeks in stap 2 wilt gebruiken.

   

2. Stel MSBuild-argumenten in Visual Studio-buildhulpprogramma's of in een MSBuild-taak in, zoals wordt weergegeven in het volgende voorbeeld. U kunt ook variabelen definiëren voor deze argumenten in de build-pijplijn van Azure Pipelines.

   

   /p:USQLSDKPath=$(Build.SourcesDirectory)/packages/Microsoft.Azure.DataLake.USQL.SDK.1.3.180615/build/runtime
   

Uitvoer van build voor U-SQL-databaseproject

De build-uitvoer voor een U-SQL-databaseproject is een U-SQL-database-implementatiepakket genaamd met het achtervoegsel .usqldbpack. Het .usqldbpack-pakket is een zip-bestand met alle DDL-instructies in één U-SQL-script in een DDL-map. Het bevat alle DLL-bestanden en andere bestanden voor assemblage in een tijdelijke map.

Tabelwaardefuncties en opgeslagen procedures testen

Het toevoegen van testgevallen voor tabelwaardefuncties en opgeslagen procedures wordt momenteel niet ondersteund. Als tijdelijke oplossing kunt u een U-SQL-project maken met U-SQL-scripts die deze functies aanroepen en testcases schrijven. Voer de volgende stappen uit om testcases in te stellen voor tabelwaardefuncties en opgeslagen procedures die zijn gedefinieerd in het U-SQL-databaseproject:

1. Maak een U-SQL-project voor testdoeleinden en schrijf U-SQL-scripts die de tabelwaardefuncties en opgeslagen procedures aanroepen.

2. Voeg een databaseverwijzing toe aan het U-SQL-project. Als u de tabelwaardefunctie en de definitie van de opgeslagen procedure wilt ophalen, moet u verwijzen naar het databaseproject dat de DDL-instructie bevat. Meer informatie over databaseverwijzingen.

3. Voeg testcases toe voor U-SQL-scripts die functies met tabelwaarden en opgeslagen procedures aanroepen. Meer informatie over het toevoegen van testcases voor U-SQL-scripts.

U-SQL-database implementeren via Azure Pipelines

PackageDeploymentTool.exe biedt de programmeer- en opdrachtregelinterfaces waarmee u U-SQL Database-implementatiepakketten kunt implementeren, .usqldbpack. De SDK is opgenomen in het U-SQL SDK NuGet-pakket, dat zich bevindt in build/runtime/PackageDeploymentTool.exe. Met behulp van PackageDeploymentTool.exekunt u U-SQL-databases implementeren in zowel Azure Data Lake Analytics als lokale accounts.

Voer de volgende stappen uit om een database-implementatietaak in Azure Pipelines in te stellen:

1. Voeg een PowerShell-scripttaak toe aan een build- of release-pijplijn en voer het volgende PowerShell-script uit. Deze taak helpt bij het ophalen van Azure SDK-afhankelijkheden voor PackageDeploymentTool.exe en PackageDeploymentTool.exe. U kunt de parameters -AzureSDK en -DBDeploymentTool instellen om de afhankelijkheden en het implementatieprogramma te laden in specifieke mappen. Geef het -AzureSDK- pad door naar PackageDeploymentTool.exe als de parameter -AzureSDKPath in stap 2.

   <#
      This script is used for getting dependencies and SDKs for U-SQL database deployment.
      PowerShell command line support for deploying U-SQL database package(.usqldbpack file) will come soon.
   
      Example :
          GetUSQLDBDeploymentSDK.ps1 -AzureSDK "AzureSDKFolderPath" -DBDeploymentTool "DBDeploymentToolFolderPath"
   #>
   
   param (
      [string]$AzureSDK = "AzureSDK", # Folder to cache Azure SDK dependencies
      [string]$DBDeploymentTool = "DBDeploymentTool", # Folder to cache U-SQL database deployment tool
      [string]$workingfolder = "" # Folder to execute these command lines
   )
   
   if ([string]::IsNullOrEmpty($workingfolder))
   {
      $scriptpath = $MyInvocation.MyCommand.Path
      $workingfolder = Split-Path $scriptpath
   }
   cd $workingfolder
   
   echo "workingfolder=$workingfolder, outputfolder=$outputfolder"
   echo "Downloading required packages..."
   
   iwr https://www.nuget.org/api/v2/package/Microsoft.Azure.Management.DataLake.Analytics/3.5.1-preview -outf Microsoft.Azure.Management.DataLake.Analytics.3.5.1-preview.zip
   iwr https://www.nuget.org/api/v2/package/Microsoft.Azure.Management.DataLake.Store/2.4.1-preview -outf Microsoft.Azure.Management.DataLake.Store.2.4.1-preview.zip
   iwr https://www.nuget.org/api/v2/package/Microsoft.IdentityModel.Clients.ActiveDirectory/2.28.3 -outf Microsoft.IdentityModel.Clients.ActiveDirectory.2.28.3.zip
   iwr https://www.nuget.org/api/v2/package/Microsoft.Rest.ClientRuntime/2.3.11 -outf Microsoft.Rest.ClientRuntime.2.3.11.zip
   iwr https://www.nuget.org/api/v2/package/Microsoft.Rest.ClientRuntime.Azure/3.3.7 -outf Microsoft.Rest.ClientRuntime.Azure.3.3.7.zip
   iwr https://www.nuget.org/api/v2/package/Microsoft.Rest.ClientRuntime.Azure.Authentication/2.3.3 -outf Microsoft.Rest.ClientRuntime.Azure.Authentication.2.3.3.zip
   iwr https://www.nuget.org/api/v2/package/Newtonsoft.Json/6.0.8 -outf Newtonsoft.Json.6.0.8.zip
   iwr https://www.nuget.org/api/v2/package/Microsoft.Azure.DataLake.USQL.SDK/ -outf USQLSDK.zip
   
   echo "Extracting packages..."
   
   Expand-Archive Microsoft.Azure.Management.DataLake.Analytics.3.5.1-preview.zip -DestinationPath Microsoft.Azure.Management.DataLake.Analytics.3.5.1-preview -Force
   Expand-Archive Microsoft.Azure.Management.DataLake.Store.2.4.1-preview.zip -DestinationPath Microsoft.Azure.Management.DataLake.Store.2.4.1-preview -Force
   Expand-Archive Microsoft.IdentityModel.Clients.ActiveDirectory.2.28.3.zip -DestinationPath Microsoft.IdentityModel.Clients.ActiveDirectory.2.28.3 -Force
   Expand-Archive Microsoft.Rest.ClientRuntime.2.3.11.zip -DestinationPath Microsoft.Rest.ClientRuntime.2.3.11 -Force
   Expand-Archive Microsoft.Rest.ClientRuntime.Azure.3.3.7.zip -DestinationPath Microsoft.Rest.ClientRuntime.Azure.3.3.7 -Force
   Expand-Archive Microsoft.Rest.ClientRuntime.Azure.Authentication.2.3.3.zip -DestinationPath Microsoft.Rest.ClientRuntime.Azure.Authentication.2.3.3 -Force
   Expand-Archive Newtonsoft.Json.6.0.8.zip -DestinationPath Newtonsoft.Json.6.0.8 -Force
   Expand-Archive USQLSDK.zip -DestinationPath USQLSDK -Force
   
   echo "Copy required DLLs to output folder..."
   
   mkdir $AzureSDK -Force
   mkdir $DBDeploymentTool -Force
   copy Microsoft.Azure.Management.DataLake.Analytics.3.5.1-preview\lib\net452\*.dll $AzureSDK
   copy Microsoft.Azure.Management.DataLake.Store.2.4.1-preview\lib\net452\*.dll $AzureSDK
   copy Microsoft.IdentityModel.Clients.ActiveDirectory.2.28.3\lib\net45\*.dll $AzureSDK
   copy Microsoft.Rest.ClientRuntime.2.3.11\lib\net452\*.dll $AzureSDK
   copy Microsoft.Rest.ClientRuntime.Azure.3.3.7\lib\net452\*.dll $AzureSDK
   copy Microsoft.Rest.ClientRuntime.Azure.Authentication.2.3.3\lib\net452\*.dll $AzureSDK
   copy Newtonsoft.Json.6.0.8\lib\net45\*.dll $AzureSDK
   copy USQLSDK\build\runtime\*.* $DBDeploymentTool
   

2. Voeg een Command-Line taak toe in een build- of release-pijplijn en vul het script in door PackageDeploymentTool.exeaan te roepen. PackageDeploymentTool.exe bevindt zich onder de gedefinieerde map $DBDeploymentTool. Het voorbeeldscript is als volgt:

   • Een U-SQL-database lokaal implementeren:

     PackageDeploymentTool.exe deploylocal -Package <package path> -Database <database name> -DataRoot <data root path>
     

   • Gebruik de interactieve verificatiemodus om een U-SQL-database te implementeren in een Azure Data Lake Analytics-account:

     PackageDeploymentTool.exe deploycluster -Package <package path> -Database <database name> -Account <account name> -ResourceGroup <resource group name> -SubscriptionId <subscript id> -Tenant <tenant name> -AzureSDKPath <azure sdk path> -Interactive
     

   • Gebruik secrete verificatie om een U-SQL-database te implementeren in een Azure Data Lake Analytics-account:

     PackageDeploymentTool.exe deploycluster -Package <package path> -Database <database name> -Account <account name> -ResourceGroup <resource group name> -SubscriptionId <subscript id> -Tenant <tenant name> -ClientId <client id> -Secrete <secrete>
     

   • Gebruik certFile-verificatie om een U-SQL-database te implementeren in een Azure Data Lake Analytics-account:

     PackageDeploymentTool.exe deploycluster -Package <package path> -Database <database name> -Account <account name> -ResourceGroup <resource group name> -SubscriptionId <subscript id> -Tenant <tenant name> -ClientId <client id> -Secrete <secrete> -CertFile <certFile>
     

PackageDeploymentTool.exe parameterbeschrijvingen

Algemene parameters

Parameter voor lokale implementatie

Parameters voor Azure Data Lake Analytics-implementatie

Volgende stappen

• Uw Azure Data Lake Analytics-code testen.
• U-SQL-script uitvoeren op uw lokale computer.
• U-SQL-databaseproject gebruiken om U-SQL-database te ontwikkelen.