Konfigurera en CI/CD-pipeline för Azure Data Lake Analytics

I den här artikeln får du lära dig att konfigurera en pipeline för kontinuerlig integrering och distribution (CI/CD) för U-SQL-jobb och U-SQL-databaser.

Använda CI/CD för U-SQL-jobb

Azure Data Lake Tools for Visual Studio tillhandahåller U-SQL-projekttypen som hjälper dig att organisera U-SQL-skript. Genom att använda U-SQL-projektet för att hantera din U-SQL-kod blir det enkelt att använda fler CI/CD-scenarier.

Skapa ett U-SQL-projekt

Ett U-SQL-projekt kan byggas med Microsoft Build Engine (MSBuild) genom att skicka motsvarande parametrar. Följ stegen i den här artikeln för att konfigurera en byggprocess för ett U-SQL-projekt.

Projektmigrering

Innan du ställer in en versionsuppgift för ett U-SQL-projekt kontrollerar du att du har den senaste versionen av U-SQL-projektet. Öppna U-SQL-projektfilen i redigeraren och kontrollera att du har följande importobjekt:

<!-- 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')" />

Om inte, har du två alternativ för att migrera projektet:

• Alternativ 1: Ändra det gamla importobjektet till det föregående.
• Alternativ 2: Öppna det gamla projektet i Azure Data Lake Tools för Visual Studio. Använd en nyare version än 2.3.3000.0. Den gamla projektmallen uppgraderas automatiskt till den senaste versionen. Nya projekt som skapats med nyare versioner än 2.3.3000.0 använder den nya mallen.

Hämta NuGet

MSBuild har inte inbyggt stöd för U-SQL-projekt. För att få det här stödet måste du lägga till en referens för din lösning i Microsoft.Azure.DataLake.USQL.SDK NuGet-paketet som lägger till den språktjänst som krävs.

Om du vill lägga till NuGet-paketreferensen högerklickar du på lösningen i Visual Studio Solution Explorer väljer Hantera NuGet-paket. Eller så kan du lägga till en fil packages.config med namnet i lösningsmappen och lägga till följande innehåll i den:

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

Hantera U-SQL-databasreferenser

U-SQL-skript i ett U-SQL-projekt kan ha frågeutdrag för U-SQL-databasobjekt. I så fall måste du referera till motsvarande U-SQL-databasprojekt som innehåller objektdefinitionen innan du skapar U-SQL-projektet. Ett exempel är när du frågar en U-SQL-tabell eller refererar till en sammansättning.

Läs mer om U-SQL-databasprojektet.

Skapa ett U-SQL-projekt med MSBuild-kommandoraden

Migrera först projektet och hämta NuGet-paketet. Anropa sedan standardkommandoraden MSBuild med följande ytterligare argument för att skapa ditt U-SQL-projekt:

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

Argumentdefinitionen och -värdena är följande:

• USQLSDKPath= <U-SQL Nuget package> \build\runtime. Den här parametern refererar till installationssökvägen för NuGet-paketet för U-SQL-språktjänsten.

• USQLTargetType=Merge eller SyntaxCheck:

  • Sammanfoga. Sammanfogningsläget kompilerar kod bakom filer. Exempel är .cs-, .py- och .r-filer. Det inlines det resulterande användardefinierade kodbiblioteket i U-SQL-skriptet. Exempel är en dll-binär fil, Python eller R-kod.

  • SyntaxCheck. SyntaxCheck-läget sammanfogar först kod bakom-filer i U-SQL-skriptet. Sedan kompileras U-SQL-skriptet för att verifiera din kod.

• DataRoot= <DataRoot path>. DataRoot behövs bara för SyntaxCheck-läge. När skriptet skapas med SyntaxCheck-läge kontrollerar MSBuild referenserna till databasobjekten i skriptet. Innan du skapar ska du konfigurera en matchande lokal miljö som innehåller de refererade objekten från U-SQL-databasen i byggdatorns DataRoot-mapp. Du kan också hantera dessa databasberoenden genom att referera till ett U-SQL-databasprojekt. MSBuild kontrollerar endast databasobjektreferenser, inte filer.

• EnableDeployment=true eller false. EnableDeployment anger om det är tillåtet att distribuera refererade U-SQL-databaser under byggprocessen. Om du refererar till ett U-SQL-databasprojekt och använder databasobjekten i U-SQL-skriptet anger du den här parametern till true.

Kontinuerlig integrering via Azure Pipelines

Förutom kommandoraden kan du även använda Visual Studio Build eller en MSBuild-uppgift för att skapa U-SQL-projekt i Azure Pipelines. Om du vill konfigurera en bygg-pipeline måste du lägga till två uppgifter i bygg-pipelinen: en NuGet-återställningsaktivitet och en MSBuild-uppgift.

1. Lägg till en NuGet-återställningsuppgift för att hämta det lösningsreferenserade NuGet-paketet som innehåller , så att MSBuild kan hitta Azure.DataLake.USQL.SDK U-SQL-språkmålen. Ange Avancerad > målkatalog till $(Build.SourcesDirectory)/packages om du vill använda MSBuild-argumentexempel direkt i steg 2.

   

2. Ange MSBuild-argument Visual Studio skapa verktyg eller i en MSBuild-uppgift som du ser i följande exempel. Eller så kan du definiera variabler för dessa argument i Azure Pipelines-bygg-pipelinen.

   

   /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
   

Utdata från U-SQL-projekt

När du har kört en version byggs alla skript i U-SQL-projektet och matas ut till en zip-fil med namnet USQLProjectName.usqlpack . Mappstrukturen i projektet sparas i zippade build-utdata.

Testa U-SQL-skript

Azure Data Lake tillhandahåller testprojekt för U-SQL-skript och C# UDO/UDAG/UDF:

• Lär dig hur du lägger till testfall för U-SQL-skript och utökad C#-kod

• Lär dig hur du kör testfall i Azure Pipelines.

Distribuera ett U-SQL-jobb

När du har verifierat koden via bygg- och testprocessen kan du skicka U-SQL-jobb direkt från Azure Pipelines via en Azure PowerShell uppgift. Du kan också distribuera skriptet till Azure Data Lake Store eller Azure Blob Storage och köra de schemalagda jobben via Azure Data Factory.

Skicka U-SQL-jobb via Azure Pipelines

U-SQL-projektets build-utdata är en zip-fil med namnet USQLProjectName.usqlpack. ZIP-filen innehåller alla U-SQL-skript i projektet. Du kan använda Azure PowerShell i Pipelines med följande PowerShell-exempelskript för att skicka U-SQL-jobb direkt från Azure Pipelines.

<#
   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

Distribuera U-SQL-jobb via Azure Data Factory

Du kan skicka U-SQL-jobb direkt från Azure Pipelines. Eller så kan du ladda upp de skapade skripten till Azure Data Lake Store eller Azure Blob Storage och köra de schemalagda jobben via Azure Data Factory.

Använd Azure PowerShell i Azure Pipelines med följande PowerShell-exempelskript för att ladda upp U-SQL-skripten till ett Azure Data Lake Store konto:

<#
   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 för en U-SQL-databas

Azure Data Lake Tools for Visual Studio innehåller U-SQL-databasprojektmallar som hjälper dig att utveckla, hantera och distribuera U-SQL-databaser. Läs mer om U-SQL-databasprojektet.

Skapa U-SQL-databasprojekt

Hämta NuGet-paketet

MSBuild har inte inbyggt stöd för U-SQL-databasprojekt. För att få den här möjligheten måste du lägga till en referens för din lösning i Microsoft.Azure.DataLake.USQL.SDK NuGet-paketet som lägger till den språktjänst som krävs.

Om du vill lägga till NuGet-paketreferensen högerklickar du på lösningen i Visual Studio Solution Explorer. Välj Hantera NuGet-paket. Sök sedan efter och installera NuGet-paketet. Du kan också lägga till en filpackages.config i lösningsmappen och placera följande innehåll i den:

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

Skapa ett U-SQL-databasprojekt med MSBuild-kommandoraden

Skapa U-SQL-databasprojektet genom att anropa standardkommandoraden MSBuild och skicka U-SQL SDK NuGet-paketreferensen som ett ytterligare argument. Se följande exempel:

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

Argumentet USQLSDKPath=<U-SQL Nuget package>\build\runtime refererar till installationssökvägen för NuGet-paketet för U-SQL-språktjänsten.

Kontinuerlig integrering med Azure Pipelines

Förutom kommandoraden kan du använda Visual Studio Build eller en MSBuild-uppgift för att skapa U-SQL-databasprojekt i Azure Pipelines. Om du vill konfigurera en bygguppgift måste du lägga till två uppgifter i bygg-pipelinen: en NuGet-återställningsaktivitet och en MSBuild-uppgift.

1. Lägg till en NuGet-återställningsuppgift för att hämta det lösningsreferenserade NuGet-paketet, som innehåller , så att MSBuild kan hitta Azure.DataLake.USQL.SDK U-SQL-språkmålen. Ange Avancerad > målkatalog till $(Build.SourcesDirectory)/packages om du vill använda MSBuild-argumentexempel direkt i steg 2.

   

2. Ange MSBuild-argument Visual Studio skapa verktyg eller i en MSBuild-uppgift som du ser i följande exempel. Eller så kan du definiera variabler för dessa argument i Azure Pipelines-bygg-pipelinen.

   

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

Build-utdata för U-SQL-databasprojekt

Byggutdata för ett U-SQL-databasprojekt är ett U-SQL-databasdistributionspaket med namnet med suffixet .usqldbpack . Paketet .usqldbpack är en zip-fil som innehåller alla DDL-instruktioner i ett enda U-SQL-skript i en DDL-mapp. Den innehåller alla DLL-filer och ytterligare filer för sammansättning i en temporär mapp.

Testa tabellvärdesfunktioner och lagrade procedurer

Att lägga till testfall för tabellvärdesfunktioner och lagrade procedurer direkt stöds inte för närvarande. Som en tillfällig lösning kan du skapa ett U-SQL-projekt som har U-SQL-skript som anropar dessa funktioner och skriver testfall åt dem. Vidta följande steg för att konfigurera testfall för tabellvärdesfunktioner och lagrade procedurer som definierats i U-SQL-databasprojektet:

1. Skapa ett U-SQL-projekt i testsyfte och skriv U-SQL-skript som anropar tabellvärdesfunktionerna och lagrade procedurer.

2. Lägg till en databasreferens till U-SQL-projektet. För att få tabellvärdesfunktionen och definitionen av den lagrade proceduren måste du referera till databasprojektet som innehåller DDL-instruktionen. Läs mer om databasreferenser.

3. Lägg till testfall för U-SQL-skript som anropar tabellvärdesfunktioner och lagrade procedurer. Lär dig hur du lägger till testfall för U-SQL-skript.

Distribuera U-SQL-databas via Azure Pipelines

PackageDeploymentTool.exe innehåller programmerings- och kommandoradsgränssnitt som hjälper dig att distribuera U-SQL-databasdistributionspaket, .usqldbpack. SDK ingår i U-SQL SDK NuGet-paketetsom finns i build/runtime/PackageDeploymentTool.exe. Med hjälp PackageDeploymentTool.exe av kan du distribuera U-SQL-databaser till både Azure Data Lake Analytics och lokala konton.

Konfigurera en databasdistributionsuppgift i Azure Pipelines genom att utföra följande steg:

1. Lägg till en PowerShell-skriptuppgift i en bygg- eller lanseringspipeline och kör följande PowerShell-skript. Den här uppgiften hjälper till att hämta Azure SDK-beroenden för PackageDeploymentTool.exe och PackageDeploymentTool.exe . Du kan ange parametrarna -AzureSDK och -DBDeploymentTool för att läsa in beroenden och distributionsverktyget till specifika mappar. Skicka -AzureSDK-sökvägen PackageDeploymentTool.exe till som parametern -AzureSDKPath i steg 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. Lägg till en kommandoradsaktivitet i en bygg- eller lanseringspipeline och fyll i skriptet genom att anropa PackageDeploymentTool.exe . PackageDeploymentTool.exefinns under den definierade $DBDeploymentTool mappen. Exempelskriptet är följande:

   • Distribuera en U-SQL-databas lokalt:

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

   • Använd interaktivt autentiseringsläge för att distribuera en U-SQL-databas till ett Azure Data Lake Analytics konto:

     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
     

   • Använd hemlig autentisering för att distribuera en U-SQL-databas till ett Azure Data Lake Analytics konto:

     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>
     

   • Använd certFile-autentisering för att distribuera en U-SQL-databas till ett Azure Data Lake Analytics konto:

     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 parameterbeskrivningar

Vanliga parametrar

Parameter för lokal distribution

Parametrar för Azure Data Lake Analytics distribution

Nästa steg

• Så här testar du Azure Data Lake Analytics kod.
• Kör U-SQL-skript på den lokala datorn.
• Använd U-SQL-databasprojektet för att utveckla U-SQL-databasen.