Gestire Azure Data Lake Analytics tramite Azure PowerShell

Informazioni su come gestire gli account, le origini dati, i processi e gli elementi del catalogo di Azure Data Lake Analytics usando Azure PowerShell.

Prerequisiti

Durante la creazione di un account di Data Lake Analytics, è necessario sapere:

  • ID sottoscrizione: l'ID di sottoscrizione di Azure in cui risiede l'account di Data Lake Analytics.
  • Gruppo di risorse: il nome del gruppo di risorse di Azure che contiene l'account di Data Lake Analytics.
  • Nome dell'account Data Lake Analytics: il nome dell'account deve contenere solo lettere minuscole e numeri.
  • Account Data Lake Store predefinito: ogni account Data Lake Analytics ha un account Data Lake Store predefinito. Questi account devono essere nello stesso percorso.
  • Posizione: la posizione dell'account di Data Lake Analytics, ad esempio "Stati Uniti orientali 2" o altre posizioni supportate. Le posizioni supportate possono essere visualizzate nella pagina dei prezzi.

I frammenti di codice di PowerShell in questa esercitazione usano le variabili seguenti per archiviare queste informazioni

$subId = "<SubscriptionId>"
$rg = "<ResourceGroupName>"
$adla = "<DataLakeAnalyticsAccountName>"
$adls = "<DataLakeStoreAccountName>"
$location = "<Location>"

Accesso

Accesso con un ID di sottoscrizione.

Login-AzureRmAccount -SubscriptionId $subId

Accesso con un nome di sottoscrizione.

Login-AzureRmAccount -SubscriptionName $subname 

Il cmdlet Login-AzureRmAccount richiede sempre le credenziali. È possibile evitare tale richiesta usando i cmdlet seguenti:

# Save login session information
Save-AzureRmProfile -Path D:\profile.json  

# Load login session information
Select-AzureRmProfile -Path D:\profile.json 

Gestione di account

Creare un account di Analisi Data Lake

Se non si ha già un gruppo di risorse da usare, crearne uno.

New-AzureRmResourceGroup -Name  $rg -Location $location

Per ogni account Data Lake Analytics deve essere configurato un account Data Lake Store che viene usato per l'archiviazione dei log. È possibile riusare un account esistente o creare un account.

New-AdlStore -ResourceGroupName $rg -Name $adls -Location $location

Quando sono disponibili un gruppo di risorse e un account Data Lake Store, creare un account Data Lake Analytics.

New-AdlAnalyticsAccount -ResourceGroupName $rg -Name $adla -Location $location -DefaultDataLake $adls

Ottenere informazioni su un account

Ottenere dettagli su un account.

Get-AdlAnalyticsAccount -Name $adla

Verificare l'esistenza di un account specifico di Data Lake Analytics. Il cmdlet restituisce True o False.

Test-AdlAnalyticsAccount -Name $adla

Verificare l'esistenza di un account specifico di Data Lake Store. Il cmdlet restituisce True o False.

Test-AdlStoreAccount -Name $adls

Elenco di account

Elencare gli account di Data Lake Analytics all'interno della sottoscrizione corrente.

Get-AdlAnalyticsAccount

Elencare gli account di Data Lake Analytics all'interno di un gruppo di risorse specifico.

Get-AdlAnalyticsAccount -ResourceGroupName $rg

Gestione delle regole del firewall

Elencare le regole del firewall.

Get-AdlAnalyticsFirewallRule -Account $adla

Aggiungere una regola del firewall.

$ruleName = "Allow access from on-prem server"
$startIpAddress = "<start IP address>"
$endIpAddress = "<end IP address>"

Add-AdlAnalyticsFirewallRule -Account $adla -Name $ruleName -StartIpAddress $startIpAddress -EndIpAddress $endIpAddress

Modificare una regola del firewall.

Set-AdlAnalyticsFirewallRule -Account $adla -Name $ruleName -StartIpAddress $startIpAddress -EndIpAddress $endIpAddress

Rimuovere una regola del firewall.

Remove-AdlAnalyticsFirewallRule -Account $adla -Name $ruleName

Consentire gli indirizzi IP di Azure.

Set-AdlAnalyticsAccount -Name $adla -AllowAzureIpState Enabled
Set-AdlAnalyticsAccount -Name $adla -FirewallState Enabled
Set-AdlAnalyticsAccount -Name $adla -FirewallState Disabled

Gestione delle origini dati

Azure Data Lake Analytics supporta attualmente le origini dati seguenti:

Quando si crea un account di Analytics, è necessario impostare un account di Data Lake Store come origine dati predefinita. L'account di Data Lake Store predefinito viene usato per archiviare i metadati e i log di controllo dei processi. Dopo aver creato un account di Data Lake Analytics, è possibile aggiungere altri account di Data Lake Store e/o account di archiviazione.

Trovare l'account di Data Lake Store predefinito

$adla_acct = Get-AdlAnalyticsAccount -Name $adla
$dataLakeStoreName = $adla_acct.DefaultDataLakeAccount

È possibile trovare l'account Data Lake Store predefinito filtrando l'elenco di origine dati secondo il criterio di proprietà IsDefault:

Get-AdlAnalyticsDataSource -Account $adla  | ? { $_.IsDefault } 

Aggiungere un'origine dati


# Add an additional Storage (Blob) account.
$AzureStorageAccountName = "<AzureStorageAccountName>"
$AzureStorageAccountKey = "<AzureStorageAccountKey>"
Add-AdlAnalyticsDataSource -Account $adla -Blob $AzureStorageAccountName -AccessKey $AzureStorageAccountKey

# Add an additional Data Lake Store account.
$AzureDataLakeStoreName = "<AzureDataLakeStoreAccountName"
Add-AdlAnalyticsDataSource -Account $adla -DataLakeStore $AzureDataLakeStoreName 

Elencare le origini dati

# List all the data sources
Get-AdlAnalyticsDataSource -Name $adla

# List attached Data Lake Store accounts
Get-AdlAnalyticsDataSource -Name $adla | where -Property Type -EQ "DataLakeStore"

# List attached Storage accounts
Get-AdlAnalyticsDataSource -Name $adla | where -Property Type -EQ "Blob"

Inviare processi U-SQL

Inviare una stringa come script U-SQL

$script = @"
@a  = 
    SELECT * FROM 
        (VALUES
            ("Contoso", 1500.0),
            ("Woodgrove", 2700.0)
        ) AS D( customer, amount );
OUTPUT @a
    TO "/data.csv"
    USING Outputters.Csv();
"@

$scriptpath = "d:\test.usql"
$script | Out-File $scriptpath 

Submit-AdlJob -AccountName $adla -Script $script -Name "Demo"

Inviare un file come script U-SQL

$scriptpath = "d:\test.usql"
$script | Out-File $scriptpath 
Submit-AdlJob -AccountName $adla –ScriptPath $scriptpath -Name "Demo"

Elencare i processi in un account

Elencare tutti i processi nell'account.

L'output include i processi attualmente in esecuzione e quelli completati di recente.

Get-AdlJob -Account $adla

Elencare un numero specifico di processi

Per impostazione predefinita, l'elenco dei processi viene ordinato in base all'ora di invio. Pertanto, i processi inviati di recente vengono visualizzati per primi. Per impostazione predefinita, l’account di ADLA memorizza i processi per 180 giorni, ma il cmdlet Ge AdlJob ne restituisce solo i primi 500. Utilizzare i parametri superiori per elencare un numero specifico di processi.

$jobs = Get-AdlJob -Account $adla -Top 10

Elencare i processi in base al valore della proprietà processo

Uso del parametro -State. È possibile combinare questi valori:

  • Accepted
  • Compiling
  • Ended
  • New
  • Paused
  • Queued
  • Running
  • Scheduling
  • Start
# List the running jobs
Get-AdlJob -Account $adla -State Running

# List the jobs that have completed
Get-AdlJob -Account $adla -State Ended

# List the jobs that have not started yet
Get-AdlJob -Account $adla -State Accepted,Compiling,New,Paused,Scheduling,Start

Usare il parametro -Result per rilevare se i processi finiti sono stati completati correttamente. Dispone di questi valori:

  • Operazione annullata
  • Operazione non riuscita
  • Nessuna
  • Operazione completata
# List Successful jobs.
Get-AdlJob -Account $adla -State Ended -Result Succeeded

# List Failed jobs.
Get-AdlJob -Account $adla -State Ended -Result Failed

Il parametro -Submitter consente di identificare chi ha inviato un processo.

Get-AdlJob -Account $adla -Submitter "joe@contoso.com"

Il -SubmittedAfter è utile per un filtraggio in base a un intervallo di tempo.

# List  jobs submitted in the last day.
$d = [DateTime]::Now.AddDays(-1)
Get-AdlJob -Account $adla -SubmittedAfter $d

# List  jobs submitted in the last seven day.
$d = [DateTime]::Now.AddDays(-7)
Get-AdlJob -Account $adla -SubmittedAfter $d

Scenari comuni per elencare i processi

# List jobs submitted in the last five days and that successfully completed.
$d = (Get-Date).AddDays(-5)
Get-AdlJob -Account $adla -SubmittedAfter $d -State Ended -Result Succeeded

# List all failed jobs submitted by "joe@contoso.com" within the past seven days.
Get-AdlJob -Account $adla `
    -Submitter "joe@contoso.com" `
    -SubmittedAfter (Get-Date).AddDays(-7) `
    -Result Failed

Filtrare un elenco di processi

Dopo aver creato un elenco dei processi nella sessione corrente di PowerShell. È possibile utilizzare i cmdlet normali di PowerShell per filtrare l'elenco.

Filtrare un elenco di processi per i processi inviati nelle ultime 24 ore

$upperdate = Get-Date
$lowerdate = $upperdate.AddHours(-24)
$jobs | Where-Object { $_.EndTime -ge $lowerdate }

Filtrare un elenco di processi per i processi terminati nelle ultime 24 ore

$upperdate = Get-Date
$lowerdate = $upperdate.AddHours(-24)
$jobs | Where-Object { $_.SubmitTime -ge $lowerdate }

Filtrare un elenco di processi per i processi con esecuzione avviata. Un processo potrebbe non riuscire in fase di compilazione, e pertanto non essere mai avviato. Esaminiamo i processi non riusciti, in cui l’esecuzione è stata avviata ma non è riuscita.

$jobs | Where-Object { $_.StartTime -ne $null }

Analizzare un elenco di processi

Utilizzare il cmdlet Group-Object per analizzare un elenco di processi.

# Count the number of jobs by Submitter
$jobs | Group-Object Submitter | Select -Property Count,Name

# Count the number of jobs by Result
$jobs | Group-Object Result | Select -Property Count,Name

# Count the number of jobs by State
$jobs | Group-Object State | Select -Property Count,Name

#  Count the number of jobs by DegreeOfParallelism
$jobs | Group-Object DegreeOfParallelism | Select -Property Count,Name

Quando si esegue un'analisi, può essere utile aggiungere proprietà agli oggetti di processo per rendere più semplice il filtraggio e il raggruppamento. Il frammento di codice seguente mostra come annotare un JobInfo con proprietà calcolate.

function annotate_job( $j )
{
    $dic1 = @{
        Label='AUHours';
        Expression={ ($_.DegreeOfParallelism * ($_.EndTime-$_.StartTime).TotalHours)}}
    $dic2 = @{
        Label='DurationSeconds';
        Expression={ ($_.EndTime-$_.StartTime).TotalSeconds}}
    $dic3 = @{
        Label='DidRun';
        Expression={ ($_.StartTime -ne $null)}}

    $j2 = $j | select *, $dic1, $dic2, $dic3
    $j2
}

$jobs = Get-AdlJob -Account $adla -Top 10
$jobs = $jobs | %{ annotate_job( $_ ) }

Ottenere informazioni sulle pipeline e l'intervallo di esecuzione

Utilizzare il cmdlet Get-AdlJobPipeline per visualizzare le informazioni di pipeline dei processi inviati in precedenza.

$pipelines = Get-AdlJobPipeline -Account $adla

$pipeline = Get-AdlJobPipeline -Account $adla -PipelineId "<pipeline ID>"

Utilizzare il cmdlet Get-AdlJobRecurrence per visualizzare le informazioni relative all'intervallo di esecuzione dei processi inviati in precedenza.

$recurrences = Get-AdlJobRecurrence -Account $adla

$recurrence = Get-AdlJobRecurrence -Account $adla -RecurrenceId "<recurrence ID>"

Ottenere informazioni su un processo

Ottenere lo stato di processo

Ottenere lo stato di un processo specifico.

Get-AdlJob -AccountName $adla -JobId $job.JobId

Esaminare gli output di processo

Al termine del processo, controllare se il file di output esiste elencando i file in una cartella.

Get-AdlStoreChildItem -Account $adls -Path "/"

Gestire i processi in esecuzione

Annullare un processo

Stop-AdlJob -Account $adls -JobID $jobID

Attendere il completamento di un processo

Anziché ripetere Get-AdlAnalyticsJob finché non termina un processo, è possibile usare il cmdlet Wait-AdlJob per attendere la fine del processo.

Wait-AdlJob -Account $adla -JobId $job.JobId

Gestire i criteri di calcolo

Elenco di criteri di calcolo esistenti

Il cmdlet Get-AdlAnalyticsComputePolicy recupera informazioni sui criteri di calcolo per un account Data Lake Analytics.

$policies = Get-AdlAnalyticsComputePolicy -Account $adla

Creare un criterio di calcolo

Il cmdlet New-AdlAnalyticsComputePolicy crea un nuovo criterio di calcolo per un account Data Lake Analytics. In questo esempio le unità di analisi massime disponibili per l'utente specificato sono 50 e la priorità minima del processo è pari a 250.

$userObjectId = (Get-AzureRmAdUser -SearchString "garymcdaniel@contoso.com").Id

New-AdlAnalyticsComputePolicy -Account $adla -Name "GaryMcDaniel" -ObjectId $objectId -ObjectType User -MaxDegreeOfParallelismPerJob 50 -MinPriorityPerJob 250

Verificare l'esistenza di un file.

Test-AdlStoreItem -Account $adls -Path "/data.csv"

Caricamento e download

Caricare un file.

Import-AdlStoreItem -AccountName $adls -Path "c:\data.tsv" -Destination "/data_copy.csv" 

Caricare in modo ricorsivo un'intera cartella.

Import-AdlStoreItem -AccountName $adls -Path "c:\myData\" -Destination "/myData/" -Recurse

Scaricare un file.

Export-AdlStoreItem -AccountName $adls -Path "/data.csv" -Destination "c:\data.csv"

Scaricare in modo ricorsivo un'intera cartella.

Export-AdlStoreItem -AccountName $adls -Path "/" -Destination "c:\myData\" -Recurse
Nota

Se il processo di caricamento o download viene interrotto, è possibile tentare di riprendere il processo eseguendo nuovamente il cmdlet con il flag -Resume.

Gestire gli elementi del catalogo

Il catalogo di U-SQL viene usato per definire la struttura dei dati e del codice in modo da poterli condividere mediante U-SQL. Il catalogo consente di ottenere le migliori prestazioni possibili con i dati in Azure Data Lake. Per altre informazioni, vedere la pagina di Usare il catalogo di U-SQL.

Elencare elementi nel catalogo U-SQL

# List U-SQL databases
Get-AdlCatalogItem -Account $adla -ItemType Database 

# List tables within a database
Get-AdlCatalogItem -Account $adla -ItemType Table -Path "database"

# List tables within a schema.
Get-AdlCatalogItem -Account $adla -ItemType Table -Path "database.schema"

Elencare tutti gli assembly in tutti i database in un account ADLA.

$dbs = Get-AdlCatalogItem -Account $adla -ItemType Database

foreach ($db in $dbs)
{
    $asms = Get-AdlCatalogItem -Account $adla -ItemType Assembly -Path $db.Name

    foreach ($asm in $asms)
    {
        $asmname = "[" + $db.Name + "].[" + $asm.Name + "]"
        Write-Host $asmname
    }
}

Ottenere informazioni dettagliate su un elemento del catalogo

# Get details of a table
Get-AdlCatalogItem  -Account $adla -ItemType Table -Path "master.dbo.mytable"

# Test existence of a U-SQL database.
Test-AdlCatalogItem  -Account $adla -ItemType Database -Path "master"

Creare le credenziali in un catalogo

All'interno di un database U-SQL creare un oggetto credenziali per un database ospitato in Azure. Attualmente le credenziali di U-SQL sono l'unico tipo di elemento del catalogo che è possibile creare tramite PowerShell.

$dbName = "master"
$credentialName = "ContosoDbCreds"
$dbUri = "https://contoso.database.windows.net:8080"

New-AdlCatalogCredential -AccountName $adla `
          -DatabaseName $db `
          -CredentialName $credentialName `
          -Credential (Get-Credential) `
          -Uri $dbUri

Ottenere le informazioni di base relative all'account ADLA

Dato un nome di account, il codice seguente cerca le informazioni di base sull'account

$adla_acct = Get-AdlAnalyticsAccount -Name "saveenrdemoadla"
$adla_name = $adla_acct.Name
$adla_subid = $adla_acct.Id.Split("/")[2]
$adla_sub = Get-AzureRmSubscription -SubscriptionId $adla_subid
$adla_subname = $adla_sub.Name
$adla_defadls_datasource = Get-AdlAnalyticsDataSource -Account $adla_name  | ? { $_.IsDefault } 
$adla_defadlsname = $adla_defadls_datasource.Name

Write-Host "ADLA Account Name" $adla_name
Write-Host "Subscription Id" $adla_subid
Write-Host "Subscription Name" $adla_subname
Write-Host "Defautl ADLS Store" $adla_defadlsname
Write-Host 

Write-Host '$subname' " = ""$adla_subname"" "
Write-Host '$subid' " = ""$adla_subid"" "
Write-Host '$adla' " = ""$adla_name"" "
Write-Host '$adls' " = ""$adla_defadlsname"" "

Utilizzo di Azure

Ottenere i dettagli di errore di AzureRm

Resolve-AzureRmError -Last

Verificare che il processo sia in esecuzione in modalità amministratore

function Test-Administrator  
{  
    $user = [Security.Principal.WindowsIdentity]::GetCurrent();
    $p = New-Object Security.Principal.WindowsPrincipal $user
    $p.IsInRole([Security.Principal.WindowsBuiltinRole]::Administrator)  
}

Trovare un ID tenant

Da un nome di sottoscrizione:

function Get-TenantIdFromSubcriptionName( [string] $subname )
{
    $sub = (Get-AzureRmSubscription -SubscriptionName $subname)
    $sub.TenantId
}

Get-TenantIdFromSubcriptionName "ADLTrainingMS"

Da un ID di sottoscrizione:

function Get-TenantIdFromSubcriptionId( [string] $subid )
{
    $sub = (Get-AzureRmSubscription -SubscriptionId $subid)
    $sub.TenantId
}

$subid = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
Get-TenantIdFromSubcriptionId $subid

Da un indirizzo di dominio, ad esempio "contoso.com"

function Get-TenantIdFromDomain( $domain )
{
    $url = "https://login.windows.net/" + $domain + "/.well-known/openid-configuration"
    return (Invoke-WebRequest $url|ConvertFrom-Json).token_endpoint.Split('/')[3]
}

$domain = "contoso.com"
Get-TenantIdFromDomain $domain

Elencare tutte le sottoscrizioni e i relativi ID tenant

$subs = Get-AzureRmSubscription
foreach ($sub in $subs)
{
    Write-Host $sub.Name "("  $sub.Id ")"
    Write-Host "`tTenant Id" $sub.TenantId
}

Creare un account Data Lake Analytics usando un modello

È inoltre possibile usare un modello di gruppo di risorse di Azure tramite lo script di PowerShell seguente:

$subId = "<Your Azure Subscription ID>"

$rg = "<New Azure Resource Group Name>"
$location = "<Location (such as East US 2)>"
$adls = "<New Data Lake Store Account Name>"
$adla = "<New Data Lake Analytics Account Name>"

$deploymentName = "MyDataLakeAnalyticsDeployment"
$armTemplateFile = "<LocalFolderPath>\azuredeploy.json"  # update the JSON template path 

# Log in to Azure
Login-AzureRmAccount -SubscriptionId $subId

# Create the resource group
New-AzureRmResourceGroup -Name $rg -Location $location

# Create the Data Lake Analytics account with the default Data Lake Store account.
$parameters = @{"adlAnalyticsName"=$adla; "adlStoreName"=$adls}
New-AzureRmResourceGroupDeployment -Name $deploymentName -ResourceGroupName $rg -TemplateFile $armTemplateFile -TemplateParameterObject $parameters 

Per altre informazioni, vedere Distribuire un'applicazione con un modello di Gestione risorse di Azure e Creazione di modelli di Azure Resource Manager.

Modello di esempio

Salvare il testo seguente come un file .json e usare lo script di PowerShell precedente per usare il modello.

{
  "$schema": "http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "adlAnalyticsName": {
      "type": "string",
      "metadata": {
        "description": "The name of the Data Lake Analytics account to create."
      }
    },
    "adlStoreName": {
      "type": "string",
      "metadata": {
        "description": "The name of the Data Lake Store account to create."
      }
    }
  },
  "resources": [
    {
      "name": "[parameters('adlStoreName')]",
      "type": "Microsoft.DataLakeStore/accounts",
      "location": "East US 2",
      "apiVersion": "2015-10-01-preview",
      "dependsOn": [ ],
      "tags": { }
    },
    {
      "name": "[parameters('adlAnalyticsName')]",
      "type": "Microsoft.DataLakeAnalytics/accounts",
      "location": "East US 2",
      "apiVersion": "2015-10-01-preview",
      "dependsOn": [ "[concat('Microsoft.DataLakeStore/accounts/',parameters('adlStoreName'))]" ],
      "tags": { },
      "properties": {
        "defaultDataLakeStoreAccount": "[parameters('adlStoreName')]",
        "dataLakeStoreAccounts": [
          { "name": "[parameters('adlStoreName')]" }
        ]
      }
    }
  ],
  "outputs": {
    "adlAnalyticsAccount": {
      "type": "object",
      "value": "[reference(resourceId('Microsoft.DataLakeAnalytics/accounts',parameters('adlAnalyticsName')))]"
    },
    "adlStoreAccount": {
      "type": "object",
      "value": "[reference(resourceId('Microsoft.DataLakeStore/accounts',parameters('adlStoreName')))]"
    }
  }
}

Passaggi successivi