Come configurare una pipeline di CI/CD per Azure Data Lake Analytics

Questo articolo illustra come configurare una pipeline di integrazione e distribuzione continua (CI/CD) per processi U-SQL e database U-SQL.

Usare CI/CD per i lavori U-SQL

Azure Data Lake Tools per Visual Studio fornisce il tipo di progetto U-SQL che consente di organizzare gli script U-SQL. L'uso del progetto U-SQL per gestire il codice U-SQL semplifica ulteriormente gli scenari CI/CD.

Compilare un progetto U-SQL

Un progetto U-SQL può essere compilato con Microsoft Build Engine (MSBuild) passando i parametri corrispondenti. Seguire la procedura descritta in questo articolo per configurare un processo di compilazione per un progetto U-SQL.

Migrazione del progetto

Prima di configurare un'attività di compilazione per un progetto U-SQL, assicurarsi di avere la versione più recente del progetto U-SQL. Aprire il file di progetto U-SQL nell'editor e verificare di disporre di questi elementi di importazione:

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

In caso contrario, sono disponibili due opzioni per eseguire la migrazione del progetto:

• Opzione 1: Modificare l'elemento di importazione precedente in quello precedente.
• Opzione 2: aprire il progetto precedente in Azure Data Lake Tools per Visual Studio. Usare una versione più recente della versione 2.3.3000.0. Il modello di progetto precedente verrà aggiornato automaticamente alla versione più recente. I nuovi progetti creati con versioni successive alla versione 2.3.3000.0 usano il nuovo modello.

Scarica NuGet

MSBuild non fornisce il supporto predefinito per i progetti U-SQL. Per ottenere questo supporto, è necessario aggiungere un riferimento per la soluzione al pacchetto NuGet Microsoft.Azure.DataLake.USQL.SDK che aggiunge il servizio linguistico richiesto.

Per aggiungere il riferimento al pacchetto NuGet, fare clic con il pulsante destro del mouse sulla soluzione in Esplora soluzioni di Visual Studio e scegliere Gestisci pacchetti NuGet. In alternativa, è possibile aggiungere un file denominato packages.config nella cartella della soluzione e inserirlo nel file seguente:

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

Gestire i riferimenti al database U-SQL

Gli script U-SQL in un progetto U-SQL potrebbero avere istruzioni di query per oggetti di database U-SQL. In tal caso, è necessario fare riferimento al progetto di database U-SQL corrispondente che include la definizione degli oggetti prima di compilare il progetto U-SQL. Un esempio è quando si esegue una query su una tabella U-SQL o si fa riferimento a un assembly.

Altre informazioni sul progetto di database U-SQL.

Compilare un progetto U-SQL con la riga di comando di MSBuild

Eseguire prima di tutto la migrazione del progetto e ottenere il pacchetto NuGet. Chiamare quindi la riga di comando MSBuild standard con gli argomenti seguenti per compilare il progetto U-SQL:

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

La definizione e i valori degli argomenti sono i seguenti:

• USQLSDKPath=<Pacchetto NuGet U-SQL>\build\rruntime. Questo parametro fa riferimento al percorso di installazione del pacchetto NuGet per il servizio di linguaggio U-SQL.

• USQLTargetType=Merge o SyntaxCheck:

  • Unisci. In modalità di fusione, si compilano i file code-behind. Esempi sono .cs, .py e file r . Inserisce la libreria di codice risultante definita dall'utente nel codice U-SQL. Esempi sono un codice dll binario, Python o R.

  • SyntaxCheck. La modalità SyntaxCheck unisce prima i file code-behind nello script U-SQL. Compila quindi lo script U-SQL per convalidare il codice.

• DataRoot=<DataRoot Percorso>. DataRoot è necessario solo per la modalità SyntaxCheck. Quando compila lo script con la modalità SyntaxCheck, MSBuild controlla i riferimenti agli oggetti di database nello script. Prima di compilare, configurare un ambiente locale corrispondente che contiene gli oggetti a cui si fa riferimento dal database U-SQL nella cartella DataRoot del computer di compilazione. È anche possibile gestire queste dipendenze del database facendo riferimento a un progetto di database U-SQL. MSBuild controlla solo i riferimenti agli oggetti di database, non i file.

• EnableDeployment=true o false. EnableDeployment indica se è consentito distribuire database U-SQL di riferimento durante il processo di compilazione. Se si fa riferimento a un progetto di database U-SQL e si usano gli oggetti di database nello script U-SQL, impostare questo parametro su true.

Integrazione continua tramite Azure Pipelines

Oltre alla riga di comando, è anche possibile usare la compilazione di Visual Studio o un'attività MSBuild per compilare progetti U-SQL in Azure Pipelines. Per configurare una pipeline di compilazione, assicurarsi di aggiungere due attività nella pipeline di compilazione: un'attività di ripristino NuGet e un'attività MSBuild.

1. Aggiungere un'attività di ripristino di NuGet per ottenere il pacchetto NuGet referenziato della soluzione che include Azure.DataLake.USQL.SDK, in modo che MSBuild possa trovare le destinazioni del linguaggio U-SQL. Impostare Avanzate>directory di destinazione su $(Build.SourcesDirectory)/packages se si vuole usare l'esempio di argomenti MSBuild direttamente nel passaggio 2.

   

2. Imposta gli argomenti di MSBuild negli strumenti di compilazione di Visual Studio o in un'attività MSBuild, come mostrato nell'esempio seguente. In alternativa, è possibile definire le variabili per questi argomenti nella pipeline di compilazione di 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
   

Output della compilazione del progetto U-SQL

Dopo aver eseguito una compilazione, tutti gli script nel progetto U-SQL vengono compilati e restituiti in un file ZIP denominato USQLProjectName.usqlpack. La struttura di cartelle nel progetto viene mantenuta nell'output di compilazione compresso.

Testare gli script U-SQL

Azure Data Lake fornisce progetti di test per script U-SQL e C# UDO/UDAG/UDF:

• Informazioni su come aggiungere test case per script U-SQL e codice C# esteso

• Scopri come eseguire test case in Azure Pipelines.

Distribuire un processo U-SQL

Dopo aver verificato il codice tramite il processo di compilazione e test, è possibile inviare processi U-SQL direttamente da Azure Pipelines tramite un'attività di Azure PowerShell. È anche possibile distribuire lo script in Azure Data Lake Store o nell'archivio BLOB di Azure ed eseguire i processi pianificati tramite Azure Data Factory.

Inviare processi U-SQL tramite Azure Pipelines

L'output di compilazione del progetto U-SQL è un file ZIP denominato USQLProjectName.usqlpack. Il file ZIP include tutti gli script U-SQL nel progetto. È possibile usare l'attività di Azure PowerShell in Pipelines con lo script di PowerShell di esempio seguente per inviare processi U-SQL direttamente da 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

Distribuire processi U-SQL tramite Azure Data Factory

È possibile inviare processi U-SQL direttamente da Azure Pipelines. In alternativa, è possibile caricare gli script compilati in Azure Data Lake Store o nell'archivio BLOB di Azure ed eseguire i processi pianificati tramite Azure Data Factory.

Usare l'attività Azure PowerShell in Azure Pipelines con lo script di PowerShell di esempio seguente per caricare gli script U-SQL in un account Azure Data Lake Store:

<#
   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 per un database U-SQL

Azure Data Lake Tools per Visual Studio offre modelli di progetto di database U-SQL che consentono di sviluppare, gestire e distribuire database U-SQL. Altre informazioni su un progetto di database U-SQL.

Compilare un progetto di database U-SQL

Ottenere il pacchetto NuGet

MSBuild non fornisce il supporto predefinito per i progetti di database U-SQL. Per ottenere questa possibilità, è necessario aggiungere un riferimento per la soluzione al pacchetto NuGet Microsoft.Azure.DataLake.USQL.SDK che aggiunge il servizio linguistico richiesto.

Per aggiungere il riferimento al pacchetto NuGet, fare clic con il pulsante destro del mouse sulla soluzione in Esplora soluzioni di Visual Studio. Scegliere Gestisci pacchetti NuGet. Cercare e installare quindi il pacchetto NuGet. In alternativa, è possibile aggiungere un file denominato packages.config nella cartella della soluzione e inserirlo nel file seguente:

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

Compilare un progetto di database U-SQL con la riga di comando di MSBuild

Per compilare il progetto di database U-SQL, usa la riga di comando standard MSBuild e passa il riferimento al pacchetto NuGet dell'SDK U-SQL come altro argomento. Vedere l'esempio seguente:

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

L'argomento USQLSDKPath=<U-SQL Nuget package>\build\runtime fa riferimento al percorso di installazione del pacchetto NuGet per il servizio di linguaggio U-SQL.

Integrazione continua con Azure Pipelines

Oltre alla riga di comando, è possibile usare Visual Studio Build o un'attività MSBuild per compilare progetti di database U-SQL in Azure Pipelines. Per configurare un'attività di compilazione, assicurarsi di aggiungere due attività nella pipeline di compilazione: un'attività di ripristino NuGet e un'attività MSBuild.

1. Aggiungere un'attività di ripristino NuGet per ottenere il pacchetto NuGet a cui fa riferimento la soluzione, che include Azure.DataLake.USQL.SDK, in modo che MSBuild possa trovare i target del linguaggio U-SQL. Impostare Avanzata>directory di destinazione su $(Build.SourcesDirectory)/packages se si vuole usare l'esempio di argomenti MSBuild direttamente nel passaggio 2.

   

2. Imposta gli argomenti di MSBuild negli strumenti di compilazione di Visual Studio o in un'attività MSBuild, come illustrato nel seguente esempio. In alternativa, è possibile definire le variabili per questi argomenti nella pipeline di compilazione di Azure Pipelines.

   

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

Output della compilazione del progetto di database U-SQL

L'output di compilazione per un progetto di database U-SQL è un pacchetto di distribuzione del database U-SQL denominato con il suffisso .usqldbpack. Il .usqldbpack pacchetto è un file ZIP che include tutte le istruzioni DDL in un singolo script U-SQL in una cartella DDL. Include tutti i file DLL e altri file per l'assembly in una cartella temporanea.

Testare le funzioni con valori di tabella e le stored procedure

L'aggiunta diretta di test case per funzioni con valori di tabella e stored procedure non è attualmente supportata. Come soluzione alternativa, è possibile creare un progetto U-SQL con script U-SQL che chiamano tali funzioni e scrivono test case per tali funzioni. Per configurare i test case per le funzioni con valori di tabella e le stored procedure definite nel progetto di database U-SQL, seguire questa procedura:

1. Creare un progetto U-SQL a scopo di test e scrivere script U-SQL che chiamano le funzioni con valori di tabella e le stored procedure.

2. Aggiungere un riferimento al database al progetto U-SQL. Per ottenere la funzione con valori di tabella e la definizione di stored procedure, è necessario fare riferimento al progetto di database contenente l'istruzione DDL. Altre informazioni sui riferimenti al database.

3. Aggiungere casi di test per gli script U-SQL che chiamano funzioni con valori di tabella e procedure memorizzate. Informazioni su come aggiungere test case per gli script U-SQL.

Distribuire il database U-SQL tramite Azure Pipelines

PackageDeploymentTool.exe fornisce le interfacce della programmazione e della riga di comando che consentono di distribuire pacchetti di distribuzione di database U-SQL, .usqldbpack. L'SDK è incluso nel pacchetto NuGet U-SQL SDK, disponibile in build/runtime/PackageDeploymentTool.exe. Usando PackageDeploymentTool.exe, è possibile distribuire database U-SQL sia in Azure Data Lake Analytics che in account locali.

Per configurare un'attività di distribuzione del database in Azure Pipelines, seguire questa procedura:

1. Aggiungere un'attività script PowerShell in una pipeline di build o rilascio ed eseguire il seguente script PowerShell. Questa attività consente di ottenere le dipendenze di Azure SDK per PackageDeploymentTool.exe e PackageDeploymentTool.exe. È possibile impostare i parametri -AzureSDK e -DBDeploymentTool per caricare le dipendenze e lo strumento di distribuzione in cartelle specifiche. Passare il percorso -AzureSDK a PackageDeploymentTool.exe come parametro -AzureSDKPath nel passaggio 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. Aggiungere un'attivitàCommand-Line in una pipeline di compilazione o rilascio e completare lo script chiamando PackageDeploymentTool.exe. PackageDeploymentTool.exe si trova nella cartella di $DBDeploymentTool definita. Lo script di esempio è il seguente:

   • Implementare un database U-SQL localmente.

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

   • Usare la modalità di autenticazione interattiva per distribuire un database U-SQL in un account di Azure Data Lake Analytics:

     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
     

   • Usare l'autenticazione privata per distribuire un database U-SQL in un account di Azure Data Lake Analytics:

     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>
     

   • Usare l'autenticazione certFile per distribuire un database U-SQL in un account azure Data Lake Analytics:

     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>
     

descrizioni dei parametri PackageDeploymentTool.exe

Parametri comuni

Parametro per la distribuzione locale

Parametri per la distribuzione di Azure Data Lake Analytics

Passaggi successivi

• Come testare il codice di Azure Data Lake Analytics.
• Eseguire lo script U-SQL nel computer locale.
• Usare il progetto di database U-SQL per sviluppare un database U-SQL.