Gestire Azure Data Lake Analytics un'app .NET

Questo articolo descrive come gestire account, origini dati, utenti e processi di Azure Data Lake Analytics usando un'app scritta con Azure .NET SDK.

Prerequisiti

• Visual Studio 2015, Visual Studio 2013 update 4 o Visual Studio 2012 con Visual C++ installato.
• Microsoft Azure SDK per .NET versione 2.5 o successiva. Installarlo usando il programma di installazione della piattaforma Web.
• Pacchetti NuGet necessari

Installare i pacchetti NuGet

È possibile installare questi pacchetti tramite la riga di comando di NuGet con i comandi seguenti:

Install-Package -Id Microsoft.Rest.ClientRuntime.Azure.Authentication  -Version 2.3.1
Install-Package -Id Microsoft.Azure.Management.DataLake.Analytics  -Version 3.0.0
Install-Package -Id Microsoft.Azure.Management.DataLake.Store  -Version 2.2.0
Install-Package -Id Microsoft.Azure.Management.ResourceManager  -Version 1.6.0-preview
Install-Package -Id Microsoft.Azure.Graph.RBAC -Version 3.4.0-preview

Variabili comuni

string subid = "<Subscription ID>"; // Subscription ID (a GUID)
string tenantid = "<Tenant ID>"; // AAD tenant ID or domain. For example, "contoso.onmicrosoft.com"
string rg == "<value>"; // Resource  group name
string clientid = "abcdef01-2345-6789-0abc-def012345678"; // Sample client ID

Autenticazione

Sono disponibili più opzioni per l'accesso ad Azure Data Lake Analytics. Il frammento di codice seguente mostra un esempio di autenticazione con autenticazione utente interattiva con un popup.

Per ClientID è possibile usare l'ID di un utente o l'ID applicazione (client) di un'entità servizio.

using System;
using System.IO;
using System.Threading;
using System.Security.Cryptography.X509Certificates;

using Microsoft.Rest;
using Microsoft.Rest.Azure.Authentication;
using Microsoft.Azure.Management.DataLake.Analytics;
using Microsoft.Azure.Management.DataLake.Analytics.Models;
using Microsoft.Azure.Management.DataLake.Store;
using Microsoft.Azure.Management.DataLake.Store.Models;
using Microsoft.IdentityModel.Clients.ActiveDirectory;
using Microsoft.Azure.Graph.RBAC;

public static Program
{
   public static string TENANT = "microsoft.onmicrosoft.com";
   public static string CLIENTID = "abcdef01-2345-6789-0abc-def012345678";
   public static System.Uri ARM_TOKEN_AUDIENCE = new System.Uri( @"https://management.core.windows.net/");
   public static System.Uri ADL_TOKEN_AUDIENCE = new System.Uri( @"https://datalake.azure.net/" );
   public static System.Uri GRAPH_TOKEN_AUDIENCE = new System.Uri( @"https://graph.windows.net/" );

   static void Main(string[] args)
   {
      string MY_DOCUMENTS= System.Environment.GetFolderPath( System.Environment.SpecialFolder.MyDocuments);
      string TOKEN_CACHE_PATH = System.IO.Path.Combine(MY_DOCUMENTS, "my.tokencache");

      var tokenCache = GetTokenCache(TOKEN_CACHE_PATH);
      var armCreds = GetCreds_User_Popup(TENANT, ARM_TOKEN_AUDIENCE, CLIENTID, tokenCache);
      var adlCreds = GetCreds_User_Popup(TENANT, ADL_TOKEN_AUDIENCE, CLIENTID, tokenCache);
      var graphCreds = GetCreds_User_Popup(TENANT, GRAPH_TOKEN_AUDIENCE, CLIENTID, tokenCache);
   }
}

Il codice sorgente per GetCreds_User_Popup e il codice per altre opzioni per l'autenticazione sono trattati nelle opzioni di autenticazione .NET di Data Lake Analytics

Creare gli oggetti di gestione client

var resourceManagementClient = new ResourceManagementClient(armCreds) { SubscriptionId = subid };

var adlaAccountClient = new DataLakeAnalyticsAccountManagementClient(armCreds);
adlaAccountClient.SubscriptionId = subid;

var adlsAccountClient = new DataLakeStoreAccountManagementClient(armCreds);
adlsAccountClient.SubscriptionId = subid;

var adlaCatalogClient = new DataLakeAnalyticsCatalogManagementClient(adlCreds);
var adlaJobClient = new DataLakeAnalyticsJobManagementClient(adlCreds);

var adlsFileSystemClient = new DataLakeStoreFileSystemManagementClient(adlCreds);

var  graphClient = new GraphRbacManagementClient(graphCreds);
graphClient.TenantID = domain;

Gestire gli account

Creare un gruppo di risorse di Azure

Se non ne è già stato creato uno, è necessario avere un gruppo di risorse di Azure per creare i componenti di Data Lake Analytics. Sono necessarie le credenziali di autenticazione, l'ID sottoscrizione e una posizione. Il codice seguente illustra come creare un gruppo di risorse:

var resourceGroup = new ResourceGroup { Location = location };
resourceManagementClient.ResourceGroups.CreateOrUpdate(groupName, rg);

Per altre informazioni, vedere Gruppi di risorse di Azure e Data Lake Analytics.

Creare un account Data Lake Store

L'account ADLA richiede un account ADLS. Se non è già disponibile uno da usare, è possibile crearne uno con il codice seguente:

var new_adls_params = new DataLakeStoreAccount(location: _location);
adlsAccountClient.Account.Create(rg, adls, new_adls_params);

Creare un account Data Lake Analytics

Il codice seguente crea un account ADLS

var new_adla_params = new DataLakeAnalyticsAccount()
{
   DefaultDataLakeStoreAccount = adls,
   Location = location
};

adlaClient.Account.Create(rg, adla, new_adla_params);

Elenca gli account di Data Lake Store

var adlsAccounts = adlsAccountClient.Account.List().ToList();
foreach (var adls in adlsAccounts)
{
   Console.WriteLine($"ADLS: {0}", adls.Name);
}

Elencare gli account di Data Lake Analytics

var adlaAccounts = adlaClient.Account.List().ToList();

for (var adla in AdlaAccounts)
{
   Console.WriteLine($"ADLA: {0}, adla.Name");
}

Verifica dell'esistenza di un account

bool exists = adlaClient.Account.Exists(rg, adla));

Ottenere informazioni su un account

bool exists = adlaClient.Account.Exists(rg, adla));
if (exists)
{
   var adla_accnt = adlaClient.Account.Get(rg, adla);
}

Eliminare un account

if (adlaClient.Account.Exists(rg, adla))
{
   adlaClient.Account.Delete(rg, adla);
}

Ottieni l'account predefinito di Data Lake Store

Ogni account Data Lake Analytics richiede un account Data Lake Store predefinito. Usare questo codice per determinare l'account predefinito dello Store per un account Analytics.

if (adlaClient.Account.Exists(rg, adla))
{
  var adla_accnt = adlaClient.Account.Get(rg, adla);
  string def_adls_account = adla_accnt.DefaultDataLakeStoreAccount;
}

Gestisci le origini dati

Data Lake Analytics supporta attualmente le origini dati seguenti:

• Azure Data Lake Store
• Account di archiviazione di Azure

Collegamento a un account di archiviazione di Azure

È possibile creare collegamenti ad account di archiviazione di Azure.

string storage_key = "xxxxxxxxxxxxxxxxxxxx";
string storage_account = "mystorageaccount";
var addParams = new AddStorageAccountParameters(storage_key);            
adlaClient.StorageAccounts.Add(rg, adla, storage_account, addParams);

Elencare le origini dati di Archiviazione di Azure

var stg_accounts = adlaAccountClient.StorageAccounts.ListByAccount(rg, adla);

if (stg_accounts != null)
{
  foreach (var stg_account in stg_accounts)
  {
      Console.WriteLine($"Storage account: {0}", stg_account.Name);
  }
}

Elencare le origini dati di Data Lake Store

var adls_accounts = adlsClient.Account.List();

if (adls_accounts != null)
{
  foreach (var adls_accnt in adls_accounts)
  {
      Console.WriteLine($"ADLS account: {0}", adls_accnt.Name);
  }
}

Caricare e scaricare cartelle e file

È possibile usare l'oggetto di gestione client del file system di Data Lake Store per caricare e scaricare singoli file o cartelle da Azure al computer locale, usando i metodi seguenti:

• UploadFolder
• UploadFile
• DownloadFolder
• DownloadFile

Il primo parametro per questi metodi è il nome dell'account Data Lake Store, seguito dai parametri per il percorso di origine e il percorso di destinazione.

L'esempio seguente illustra come scaricare una cartella in Data Lake Store.

adlsFileSystemClient.FileSystem.DownloadFolder(adls, sourcePath, destinationPath);

Creare un file in un account Data Lake Store

using (var memstream = new MemoryStream())
{
   using (var sw = new StreamWriter(memstream, UTF8Encoding.UTF8))
   {
      sw.WriteLine("Hello World");
      sw.Flush();
      
      memstream.Position = 0;

      adlsFileSystemClient.FileSystem.Create(adls, "/Samples/Output/randombytes.csv", memstream);
   }
}

Verificare i percorsi dell'account di archiviazione di Azure

Il codice seguente verifica se esiste un account di archiviazione di Azure (storageAccntName) in un account Data Lake Analytics (analyticsAccountName) e se esiste un contenitore (containerName) nell'account di archiviazione di Azure.

string storage_account = "mystorageaccount";
string storage_container = "mycontainer";
bool accountExists = adlaClient.Account.StorageAccountExists(rg, adla, storage_account));
bool containerExists = adlaClient.Account.StorageContainerExists(rg, adla, storage_account, storage_container));

Gestire catalogo e processi

L'oggetto DataLakeAnalyticsCatalogManagementClient fornisce metodi per la gestione del database SQL fornito per ogni account di Azure Data Lake Analytics. DataLakeAnalyticsJobManagementClient fornisce metodi per inviare e gestire i processi eseguiti nel database con script U-SQL.

Elenca database e schemi

Tra le diverse cose che è possibile elencare, i database più comuni sono i database e il relativo schema. Il codice seguente ottiene una raccolta di database e quindi enumera lo schema per ogni database.

var databases = adlaCatalogClient.Catalog.ListDatabases(adla);
foreach (var db in databases)
{
  Console.WriteLine($"Database: {db.Name}");
  Console.WriteLine(" - Schemas:");
  var schemas = adlaCatalogClient.Catalog.ListSchemas(adla, db.Name);
  foreach (var schm in schemas)
  {
      Console.WriteLine($"\t{schm.Name}");
  }
}

Elencare le colonne della tabella

Il codice seguente illustra come accedere al database con un client di gestione di Data Lake Analytics Catalog per elencare le colonne in una tabella specificata.

var tbl = adlaCatalogClient.Catalog.GetTable(adla, "master", "dbo", "MyTableName");
IEnumerable<USqlTableColumn> columns = tbl.ColumnList;

foreach (USqlTableColumn utc in columns)
{
  Console.WriteLine($"\t{utc.Name}");
}

Inviare un job U-SQL

Il codice seguente illustra come usare un client di gestione dei processi di Data Lake Analytics per inviare un processo.

string scriptPath = "/Samples/Scripts/SearchResults_Wikipedia_Script.txt";
Stream scriptStrm = adlsFileSystemClient.FileSystem.Open(_adlsAccountName, scriptPath);
string scriptTxt = string.Empty;
using (StreamReader sr = new StreamReader(scriptStrm))
{
    scriptTxt = sr.ReadToEnd();
}

var jobName = "SR_Wikipedia";
var jobId = Guid.NewGuid();
var properties = new USqlJobProperties(scriptTxt);
var parameters = new JobInformation(jobName, JobType.USql, properties, priority: 1, degreeOfParallelism: 1, jobId: jobId);
var jobInfo = adlaJobClient.Job.Create(adla, jobId, parameters);
Console.WriteLine($"Job {jobName} submitted.");

Elenco dei lavori non riusciti

Nel codice seguente sono elencate le informazioni sui processi non riusciti.

var odq = new ODataQuery<JobInformation> { Filter = "result eq 'Failed'" };
var jobs = adlaJobClient.Job.List(adla, odq);
foreach (var j in jobs)
{
   Console.WriteLine($"{j.Name}\t{j.JobId}\t{j.Type}\t{j.StartTime}\t{j.EndTime}");
}

Elenco delle pipeline

Il codice seguente elenca le informazioni su ogni pipeline di compiti inviati all'account utente.

var pipelines = adlaJobClient.Pipeline.List(adla);
foreach (var p in pipelines)
{
   Console.WriteLine($"Pipeline: {p.Name}\t{p.PipelineId}\t{p.LastSubmitTime}");
}

Elencare le ricorrenze

Il codice seguente elenca le informazioni su ogni ricorrenza dei lavori inviati all'account.

var recurrences = adlaJobClient.Recurrence.List(adla);
foreach (var r in recurrences)
{
   Console.WriteLine($"Recurrence: {r.Name}\t{r.RecurrenceId}\t{r.LastSubmitTime}");
}

Scenari comuni del grafico

Cerca l'utente nella directory Microsoft Entra ID

var userinfo = graphClient.Users.Get( "[email protected]" );

Ottenere l'ObjectId di un utente nella directory MICROSOFT Entra ID

var userinfo = graphClient.Users.Get( "[email protected]" );
Console.WriteLine( userinfo.ObjectId )

Gestire i criteri di calcolo

L'oggetto DataLakeAnalyticsAccountManagementClient fornisce metodi per la gestione dei criteri di calcolo per un account Data Lake Analytics.

Elencare i criteri di calcolo

Il codice seguente recupera un elenco di criteri di calcolo per un account Data Lake Analytics.

var policies = adlaAccountClient.ComputePolicies.ListByAccount(rg, adla);
foreach (var p in policies)
{
   Console.WriteLine($"Name: {p.Name}\tType: {p.ObjectType}\tMax AUs / job: {p.MaxDegreeOfParallelismPerJob}\tMin priority / job: {p.MinPriorityPerJob}");
}

Creare un nuovo criterio di calcolo

Il codice seguente crea un nuovo criterio di elaborazione per un account Data Lake Analytics, impostando il numero massimo di unità di elaborazione disponibili per l'utente specificato su 50 e la priorità minima del processo su 250.

var userAadObjectId = "3b097601-4912-4d41-b9d2-78672fc2acde";
var newPolicyParams = new ComputePolicyCreateOrUpdateParameters(userAadObjectId, "User", 50, 250);
adlaAccountClient.ComputePolicies.CreateOrUpdate(rg, adla, "GaryMcDaniel", newPolicyParams);

Passaggi successivi

• Panoramica di Microsoft Azure Data Lake Analytics
• Gestire Azure Data Lake Analytics tramite il portale di Azure
• Monitorare e risolvere i problemi dei processi di Azure Data Lake Analytics tramite il portale di Azure