Gestire Azure Data Lake Analytics tramite .NET SDK di Azure

Informazioni su come gestire gli account, le origini dati, gli utenti e i processi di Azure Data Lake Analytics tramite .NET SDK di Azure.

Prerequisiti

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

Installare i pacchetti NuGet

Pacchetto Versione
Microsoft.Rest.ClientRuntime.Azure.Authentication 2.3.1
Microsoft.Azure.Management.DataLake.Analytics 3.0.0
Microsoft.Azure.Management.DataLake.Store 2.2.0
Microsoft.Azure.Management.ResourceManager 1.6.0-anteprima
Microsoft.Azure.Graph.RBAC 3.4.0-anteprima

È 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 = "1950a258-227b-4e31-a9cf-717495945fc2"; // Sample client ID (this will work, but you should pick your own)

Autenticazione

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

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 = "1950a258-227b-4e31-a9cf-717495945fc2";
   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 le altre opzioni per l'autenticazione vengono trattati in Data Lake Analytics .NET authentication options (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;

Gestisci account

Creare un gruppo di risorse di Azure

Se non ne è già stato creato uno, è necessario creare un gruppo di risorse di Azure per creare i componenti di Data Lake Analytics. Sono necessari l'ID sottoscrizione, le credenziali di autenticazione e un percorso. Il codice seguente mostra come creare il 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 Archivio Data Lake

L'account ADLA richiede sempre un account ADLS. Se non si è già in possesso di un account, è 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 di Analisi Data Lake

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);

Elencare 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 riguardante l'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);
}

Ottenere l'account di Data Lake Store predefinito

Per ogni account di Data Lake Analytics deve essere configurato un account di Data Lake Store. Usare questo codice per determinare l'account di archiviazione predefinito per Data Lake Store.

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

Gestire le origini dati

Analisi Data Lake supporta attualmente le seguenti origini dati:

È possibile creare collegamenti agli 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 Data Lake Store per caricare e scaricare file o cartelle individuali da Azure nel computer locale, usando i metodi seguenti:

  • UploadFolder
  • UploadFile
  • DownloadFolder
  • DownloadFile

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

L'esempio seguente mostra 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();

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

Verificare i percorsi degli account di Archiviazione di Azure

Il codice seguente controlla se l'account di Archiviazione di Azure (storageAccntName) esiste in un account di 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 cataloghi e processi

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

Elencare database e schemi

Tra le diverse operazioni che è possibile elencare le più comuni sono i database e i relativi schemi. 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 colonne di tabella

Il codice seguente mostra come accedere al database con un client di gestione del catalogo di Data Lake Analytics per elencare le colonne di una tabella specificata.

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

foreach (USqlTableColumn utc in columns)
{
  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.");

}

Elencare i processi non riusciti

Il codice seguente elenca 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 dei processi inviati all'account.

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

Elenco delle ricorrenze

Il codice seguente elenca le informazioni su ogni ricorrenza dei processi 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 di Graph

Cercare l'utente nella directory AAD

var userinfo = graphClient.Users.Get( "bill@contoso.com" );

Ottenere l'ID dell'oggetto di un utente nella directory AAD

var userinfo = graphClient.Users.Get( "bill@contoso.com" );
Console.WriteLine( userinfo.ObjectId )

Gestire i criteri di calcolo

L'oggetto DataLakeAnalyticsAccountManagementClient offre metodi per gestire i 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 calcolo per un account Data Lake Analytics, impostando il massimo di unità di analisi disponibile 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