Verwalten von Azure Data Lake Analytics einer .NET-App

In diesem Artikel wird beschrieben, wie Sie Azure Data Lake Analytics-Konten, Datenquellen, Benutzer und Aufträge mithilfe einer App verwalten, die mit dem Azure .NET SDK geschrieben wurde.

Voraussetzungen

• Visual Studio 2015, Visual Studio 2013 Update 4 oder Visual Studio 2012 mit Visual C++ installiert.
• Microsoft Azure SDK für .NET Version 2.5 oder höher. Installieren Sie sie mit dem Webplattform-Installationsprogramm.
• Erforderliche NuGet-Pakete

Installieren von NuGet-Paketen

Sie können diese Pakete über die NuGet-Befehlszeile mit den folgenden Befehlen installieren:

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

Allgemeine Variablen

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

Authentifizierung

Sie haben mehrere Optionen für die Anmeldung bei Azure Data Lake Analytics. Der folgende Codeausschnitt zeigt ein Beispiel für die Authentifizierung mit interaktiver Benutzerauthentifizierung mit einem Popup.

Für ClientID können Sie entweder die ID eines Benutzers oder die Anwendungs-ID (Client-ID) eines Dienstprinzipals verwenden.

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

Der Quellcode für GetCreds_User_Popup und der Code für andere Authentifizierungsoptionen werden in den Data Lake Analytics .NET-Authentifizierungsoptionen behandelt.

Erstellen der Clientverwaltungsobjekte

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;

Konten verwalten

Erstellen einer Azure-Ressourcengruppe

Wenn Sie noch keins erstellt haben, müssen Sie über eine Azure-Ressourcengruppe verfügen, um Ihre Data Lake Analytics-Komponenten zu erstellen. Sie benötigen Ihre Authentifizierungsanmeldeinformationen, Abonnement-ID und einen Speicherort. Der folgende Code zeigt, wie sie eine Ressourcengruppe erstellen:

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

Weitere Informationen finden Sie unter Azure Resource Groups and Data Lake Analytics.

Erstellen eines Data Lake Store-Kontos

Für ein ADLA-Konto ist ein ADLS-Konto erforderlich. Wenn Sie noch keins zur Verfügung haben, können Sie eines mit dem folgenden Code erstellen:

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

Erstellen eines Data Lake Analytics-Kontos

Der folgende Code erstellt ein ADLS-Konto.

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

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

Data Lake Store-Konten auflisten

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

Data Lake Analytics-Konten auflisten

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

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

Überprüfen, ob ein Konto vorhanden ist

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

Abrufen von Informationen zu einem Konto

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

Löschen eines Kontos

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

Abrufen des standardmäßigen Data Lake Store Kontos

Jedes Data Lake Analytics-Konto erfordert ein Standardmäßiges Data Lake Store-Konto. Verwenden Sie diesen Code, um das Standardmäßige Store-Konto für ein Analytics-Konto zu ermitteln.

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

Datenquellen verwalten

Data Lake Analytics unterstützt derzeit die folgenden Datenquellen:

• Azure Data Lake Store
• Azure Storage-Konto

Verknüpfen mit einem Azure Storage-Konto

Sie können Links zu Azure Storage-Konten erstellen.

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

Azure Storage-Datenquellen auflisten

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

Datenquellen im Data Lake Store auflisten

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

Hochladen und Herunterladen von Ordnern und Dateien

Sie können das Data Lake Store-Dateisystem-Clientverwaltungsobjekt verwenden, um einzelne Dateien oder Ordner von Azure auf Ihren lokalen Computer hochzuladen und herunterzuladen, indem Sie die folgenden Methoden verwenden:

• UploadFolder
• Datei hochladen
• DownloadFolder
• Datei herunterladen

Der erste Parameter für diese Methoden ist der Name des Data Lake Store-Kontos, gefolgt von Parametern für den Quellpfad und dem Zielpfad.

Das folgende Beispiel zeigt, wie Sie einen Ordner im Data Lake Store herunterladen.

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

Erstellen einer Datei in einem Data Lake Store-Konto

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

Überprüfen Sie Azure Storage-Kontopfad

Der folgende Code überprüft, ob ein Azure Storage-Konto (storageAccntName) in einem Data Lake Analytics-Konto (analyticsAccountName) vorhanden ist und ob ein Container (containerName) im Azure Storage-Konto vorhanden ist.

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

Verwalten von Katalogen und Aufträgen

Das DataLakeAnalyticsCatalogManagementClient -Objekt stellt Methoden zum Verwalten der SQL-Datenbank bereit, die für jedes Azure Data Lake Analytics-Konto bereitgestellt wird. Der DataLakeAnalyticsJobManagementClient stellt Methoden zum Übermitteln und Verwalten von Aufträgen bereit, die in der Datenbank mit U-SQL-Skripts ausgeführt werden.

Datenbanken und Schemas auflisten

Unter den verschiedenen Elementen, die Sie auflisten können, sind die am häufigsten verwendeten Datenbanken und deren Schema. Der folgende Code ruft eine Sammlung von Datenbanken ab und listet dann das Schema für jede Datenbank auf.

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

Tabellenspalten auflisten

Der folgende Code zeigt, wie Sie mit einem Data Lake Analytics-Katalogverwaltungsclient auf die Datenbank zugreifen, um die Spalten in einer angegebenen Tabelle auflisten zu können.

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

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

Übermitteln eines U-SQL-Auftrags

Der folgende Code zeigt, wie Sie einen Data Lake Analytics Job Management-Client verwenden, um einen Auftrag zu übermitteln.

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

Fehlgeschlagene Aufträge auflisten

Der folgende Code listet Informationen zu fehlgeschlagenen Aufträgen auf.

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

Pipelines auflisten

Der folgende Code listet Informationen zu jeder Pipeline von Aufträgen auf, die an das Konto übermittelt wurden.

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

Wiederholungen auflisten

Der folgende Code listet Informationen zu jeder Wiederholung von Aufträgen auf, die an das Konto übermittelt wurden.

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

Allgemeine Diagrammszenarien

Nachschlagen des Benutzers im Microsoft Entra ID-Verzeichnis

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

Abrufen der ObjectId eines Benutzers im Microsoft Entra ID-Verzeichnis

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

Rechenrichtlinien verwalten

Das DataLakeAnalyticsAccountManagementClient-Objekt stellt Methoden zum Verwalten der Computerichtlinien für ein Data Lake Analytics-Konto bereit.

Auflisten von Berechnungsrichtlinien

Der folgende Code ruft eine Liste der Bereitstellungsrichtlinien für ein Konto in Data Lake Analytics ab.

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

Erstellen einer neuen Richtlinie für die Berechnung

Mit dem folgenden Code werden eine neue Computerrichtlinie für ein Data Lake Analytics-Konto erstellt, wobei die für den angegebenen Benutzer maximal verfügbaren AUs auf 50 und die Mindest-Job-Priorität auf 250 festgelegt werden.

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

Nächste Schritte

• Übersicht über microsoft Azure Data Lake Analytics
• Verwalten von Azure Data Lake Analytics mithilfe des Azure-Portals
• Überwachen und Behandeln von Problemen mit Azure Data Lake Analytics-Aufträgen mithilfe des Azure-Portals