Vývoj C# topologií pro Apache Storm pomocí nástrojů Data Lake pro Visual StudioDevelop C# topologies for Apache Storm by using the Data Lake tools for Visual Studio

Naučte se vytvářet C# Apache Storm topologii pomocí nástrojů Azure Data Lake (Apache Hadoop) pro Visual Studio.Learn how to create a C# Apache Storm topology by using the Azure Data Lake (Apache Hadoop) tools for Visual Studio. Tento dokument vás provede procesem vytvoření projektu zaplavení v aplikaci Visual Studio, jeho otestováním lokálně a nasazením do Apache Storm v clusteru Azure HDInsight.This document walks through the process of creating a Storm project in Visual Studio, testing it locally, and deploying it to an Apache Storm on Azure HDInsight cluster.

Naučíte se také, jak vytvořit hybridní topologie, C# které používají komponenty a součásti Java.You also learn how to create hybrid topologies that use C# and Java components.

Poznámka

I když postup v tomto dokumentu spoléhá na vývojové prostředí Windows se sadou Visual Studio, zkompilovaný projekt lze odeslat do clusteru HDInsight se systémem Linux nebo Windows.While the steps in this document rely on a Windows development environment with Visual Studio, the compiled project can be submitted to either a Linux or Windows-based HDInsight cluster. Pouze clustery se systémem Linux vytvořené po 28. říjnu 2016 podporují topologie SCP.NET.Only Linux-based clusters created after October 28, 2016, support SCP.NET topologies.

Pokud chcete použít C# topologii s clusterem se systémem Linux, musíte aktualizovat balíček NuGet Microsoft. SCP. NET. SDK, který používá váš projekt, na verzi 0.10.0.6 nebo novější.To use a C# topology with a Linux-based cluster, you must update the Microsoft.SCP.Net.SDK NuGet package used by your project to version 0.10.0.6 or later. Verze balíčku se zároveň musí shodovat s hlavní verzí Stormu nainstalovanou ve službě HDInsight.The version of the package must also match the major version of Storm installed on HDInsight.

Verze HDInsightHDInsight version Verze Apache StormApache Storm version Verze SCP.NETSCP.NET version Výchozí verze monoDefault Mono version
3.33.3 0.10.x0.10.x 0.10.x.x0.10.x.x
(pouze v HDInsight se systémem Windows)(only on Windows-based HDInsight)
Není k dispoziciNA
3.43.4 0.10.0.x0.10.0.x 0.10.0.x0.10.0.x 3.2.83.2.8
3,53.5 1.0.2.x1.0.2.x 1.0.0.x1.0.0.x 4.2.14.2.1
3.63.6 1.1.0.x1.1.0.x 1.0.0.x1.0.0.x 4.2.84.2.8

Důležité

Topologie jazyka C# v clusterech založených na Linuxu musí používat technologii .NET 4.5. a pro spuštění v clusteru HDInsight musí používat Mono.C# topologies on Linux-based clusters must use .NET 4.5, and use Mono to run on the HDInsight cluster. Ověřte kompatibilitu mono pro potenciální nekompatibility.Check Mono compatibility for potential incompatibilities.

Instalace sady Visual StudioInstall Visual Studio

Můžete vyvíjet C# topologie pomocí SCP.NET pomocí jedné z následujících verzí sady Visual Studio:You can develop C# topologies with SCP.NET by using one of the following versions of Visual Studio:

Nainstalovat Data Lake nástroje pro Visual StudioInstall Data Lake tools for Visual Studio

Chcete-li nainstalovat nástroje Data Lake Tools for Visual Studio, postupujte podle kroků v části Začínáme používat data Lake Tools for Visual Studio.To install Data Lake tools for Visual Studio, follow the steps in Get started using Data Lake tools for Visual Studio.

Nainstalovat JavaInstall Java

Při odeslání topologie negenerovaného toku ze sady Visual Studio vygeneruje SCP.NET soubor zip, který obsahuje topologii a závislosti.When you submit a Storm topology from Visual Studio, SCP.NET generates a zip file that contains the topology and dependencies. Jazyk Java slouží k vytvoření těchto souborů zip, protože používá formát, který je více kompatibilní s clustery se systémem Linux.Java is used to create these zip files, because it uses a format that is more compatible with Linux-based clusters.

  1. Do vývojového prostředí nainstalujte sadu Java Developer Kit (JDK) 7 nebo novější.Install the Java Developer Kit (JDK) 7 or later on your development environment. Oracle JDK můžete získat od Oracle.You can get the Oracle JDK from Oracle. Můžete také použít jiné distribuce Java.You can also use other Java distributions.

  2. Proměnná JAVA_HOME prostředí musí odkazovat na adresář, který obsahuje Java.The JAVA_HOME environment variable must point to the directory that contains Java.

  3. Proměnná prostředí musí %JAVA_HOME%\binzahrnovatadresář. PATHThe PATH environment variable must include the %JAVA_HOME%\bin directory.

K ověření, že jsou C# správně nainstalované jazyky Java a JDK, můžete použít tuto konzolovou aplikaci:You can use the following C# console application to verify that Java and the JDK are correctly installed:

using System;
using System.IO;
namespace ConsoleApplication2
{
   class Program
   {
       static void Main(string[] args)
       {
           string javaHome = Environment.GetEnvironmentVariable("JAVA_HOME");
           if (!string.IsNullOrEmpty(javaHome))
           {
               string jarExe = Path.Combine(javaHome + @"\bin", "jar.exe");
               if (File.Exists(jarExe))
               {
                   Console.WriteLine("JAVA Is Installed properly");
                    return;
               }
               else
               {
                   Console.WriteLine("A valid JAVA JDK is not found. Looks like JRE is installed instead of JDK.");
               }
           }
           else
           {
             Console.WriteLine("A valid JAVA JDK is not found. JAVA_HOME environment variable is not set.");
           }
       }  
   }
}

Šablony Apache StormApache Storm templates

Nástroje pro Data Lake pro Visual Studio poskytují následující šablony:The Data Lake tools for Visual Studio provide the following templates:

Typ projektuProject type DemonstrujeDemonstrates
Aplikace s více aplikacemiStorm Application Prázdný projekt topologie naplnění.An empty Storm topology project.
Ukázka funkce pro vyplavení Azure SQL WriterStorm Azure SQL Writer Sample Jak zapisovat do Azure SQL Database.How to write to Azure SQL Database.
Ukázka Azure Cosmos DBho čtecího modulu pro čteníStorm Azure Cosmos DB Reader Sample Jak číst z Azure Cosmos DB.How to read from Azure Cosmos DB.
Ukázka funkce pro zápis Azure Cosmos DBho zápisuStorm Azure Cosmos DB Writer Sample Jak zapisovat do Azure Cosmos DB.How to write to Azure Cosmos DB.
Ukázka čtečky EventHub pro EventHubStorm EventHub Reader Sample Jak číst z Azure Event Hubs.How to read from Azure Event Hubs.
Ukázka zapisovače nástroje pro vyplavení EventHubStorm EventHub Writer Sample Jak zapisovat do Azure Event Hubs.How to write to Azure Event Hubs.
Ukázka čtecího modulu pro vyplavování HBAStorm HBase Reader Sample Jak číst z adaptérů HBA v clusterech HDInsight.How to read from HBase on HDInsight clusters.
Ukázka zapisovače pro vyplavování HBAStorm HBase Writer Sample Jak zapisovat do adaptérů HBA v clusterech HDInsight.How to write to HBase on HDInsight clusters.
Hybridní ukázka s více podprocesyStorm Hybrid Sample Jak používat komponentu Java.How to use a Java component.
Ukázka obplaveníStorm Sample Základní topologie počtu slov.A basic word count topology.

Varování

Ne všechny šablony pracují se systémem Linux HDInsight.Not all templates work with Linux-based HDInsight. Balíčky NuGet používané šablonami nemusí být kompatibilní s mono.NuGet packages used by the templates may not be compatible with Mono. Ověřte v dokumentu o kompatibilitě mono a použijte analyzátor přenositelnosti .NET k identifikaci potenciálních problémů.Check the Mono compatibility document and use the .NET Portability Analyzer to identify potential problems.

V krocích v tomto dokumentu použijete k vytvoření topologie typ projektu základní aplikace pro zaplavení.In the steps in this document, you use the basic Storm Application project type to create a topology.

Poznámky k šablonám Apache HBAApache HBase templates notes

Šablony pro čtečku a zapisovače HBA používají adaptéry HBA REST API, ne adaptéry Java API pro komunikaci s HBA v clusteru HDInsight.The HBase reader and writer templates use the HBase REST API, not the HBase Java API, to communicate with an HBase on HDInsight cluster.

Poznámky k šablonám EventHubEventHub templates notes

Důležité

Komponenta EventHub Spout na bázi Java, která je součástí šablony čtečky EventHub, nemusí fungovat se zaplavou ve službě HDInsight verze 3,5 nebo novější.The Java-based EventHub spout component included with the EventHub Reader template may not work with Storm on HDInsight version 3.5 or later. Aktualizovaná verze této součásti je k dispozici na GitHubu.An updated version of this component is available at GitHub.

Příklad topologie, která používá tuto součást a pracuje se zachováním v HDInsight 3,5, najdete v tématu GitHub.For an example topology that uses this component and works with Storm on HDInsight 3.5, see GitHub.

Vytvoření C# topologieCreate a C# topology

  1. Otevřete Visual Studio, vyberte soubor > Novýa pak vyberte projekt.Open Visual Studio, select File > New, and then select Project.

  2. V okně Nový projekt rozbalte položku nainstalované > šablonya vyberte možnost Azure Data Lake.From the New Project window, expand Installed > Templates, and select Azure Data Lake. V seznamu šablon vyberte možnost zaplavit aplikaci.From the list of templates, select Storm Application. V dolní části obrazovky jako název aplikace zadejte WORDCOUNT .At the bottom of the screen, enter WordCount as the name of the application.

    Snímek obrazovky okna s novým projektem

  3. Po vytvoření projektu byste měli mít následující soubory:After you have created the project, you should have the following files:

    • Program.cs: Tento soubor definuje topologii pro váš projekt.Program.cs: This file defines the topology for your project. Ve výchozím nastavení se vytvoří výchozí topologie, která se skládá z jednoho Spout a jednoho šroubu.A default topology that consists of one spout and one bolt is created by default.

    • Spout.cs: Příklad Spout, který generuje náhodná čísla.Spout.cs: An example spout that emits random numbers.

    • Bolt.cs: Příklad, který udržuje počet čísel emitovaných Spout.Bolt.cs: An example bolt that keeps a count of numbers emitted by the spout.

      Při vytváření projektu NuGet stáhne nejnovější balíček SCP.NET.When you create the project, NuGet downloads the latest SCP.NET package.

      Důležité

      SCP.NET verze použitá v projektu musí odpovídat verzi Storm na clusteru HDInsight.The SCP.NET version used in your project must match the Storm version present on your HDInsight cluster. Použijte následující tabulku k určení verze, které byste měli použít:Use the following table to determine which version you should use:

      Verze HDInsightHDInsight version Apache Storm verzeApache Storm version Verze SCP.NETSCP.NET version Výchozí verze MonoDefault Mono version
      3.33.3 0.10.0.x0.10.0.x 0.10.0.x (Windows clusterů se systémem jenom)0.10.0.x (Windows-based clusters only) Není k dispoziciNA
      3.43.4 0.10.0.x0.10.0.x 0.10.0.x0.10.0.x 3.2.83.2.8
      3,53.5 1.0.2.x1.0.2.x 1.0.0.x1.0.0.x 4.2.14.2.1
      3.63.6 1.1.0.#1.1.0.# 1.0.0.x1.0.0.x 4.2.84.2.8

      Další informace o součásti s HDInsight, naleznete v tématu verzí komponenty HDInsight.For more information on components provided with HDInsight, see HDInsight component versions.

Implementace rozhraní SpoutImplement the spout

  1. Otevřete Spout.cs.Open Spout.cs. Spoutů se používají ke čtení dat z topologie z externího zdroje.Spouts are used to read data in a topology from an external source. Hlavní součásti pro Spout jsou:The main components for a spout are:

    • NextTuple: Volá se se zavoláním, když je povolený Spout k vygenerování nových řazených kolekcí členů.NextTuple: Called by Storm when the spout is allowed to emit new tuples.

    • Potvrzení (pouze transakční topologie): Zpracovává potvrzení iniciovaná jinými součástmi v topologii pro řazené kolekce členů odeslané z Spout.Ack (transactional topology only): Handles acknowledgments initiated by other components in the topology for tuples sent from the spout. Potvrzením řazené kolekce členů umožní Spout zjistit, že byl úspěšně zpracován pomocí součástí podřízené součásti.Acknowledging a tuple lets the spout know that it was processed successfully by downstream components.

    • Selhání (pouze transakční topologie): Zpracovává řazené kolekce členů, které zpracovávají selhání jiných komponent v topologii.Fail (transactional topology only): Handles tuples that are fail-processing other components in the topology. Implementace metody selhání umožňuje znovu vygenerovat řazenou kolekci členů, aby ji bylo možné znovu zpracovat.Implementing a Fail method allows you to re-emit the tuple so that it can be processed again.

  2. Nahraďte obsah třídy Spout následujícím textem: Tento Spout náhodně generuje větu do topologie.Replace the contents of the Spout class with the following text: This spout randomly emits a sentence into the topology.

    private Context ctx;
    private Random r = new Random();
    string[] sentences = new string[] {
        "the cow jumped over the moon",
        "an apple a day keeps the doctor away",
        "four score and seven years ago",
        "snow white and the seven dwarfs",
        "i am at two with nature"
    };
    
    public Spout(Context ctx)
    {
        // Set the instance context
        this.ctx = ctx;
    
        Context.Logger.Info("Generator constructor called");
    
        // Declare Output schema
        Dictionary<string, List<Type>> outputSchema = new Dictionary<string, List<Type>>();
        // The schema for the default output stream is
        // a tuple that contains a string field
        outputSchema.Add("default", new List<Type>() { typeof(string) });
        this.ctx.DeclareComponentSchema(new ComponentStreamSchema(null, outputSchema));
    }
    
    // Get an instance of the spout
    public static Spout Get(Context ctx, Dictionary<string, Object> parms)
    {
        return new Spout(ctx);
    }
    
    public void NextTuple(Dictionary<string, Object> parms)
    {
        Context.Logger.Info("NextTuple enter");
        // The sentence to be emitted
        string sentence;
    
        // Get a random sentence
        sentence = sentences[r.Next(0, sentences.Length - 1)];
        Context.Logger.Info("Emit: {0}", sentence);
        // Emit it
        this.ctx.Emit(new Values(sentence));
    
        Context.Logger.Info("NextTuple exit");
    }
    
    public void Ack(long seqId, Dictionary<string, Object> parms)
    {
        // Only used for transactional topologies
    }
    
    public void Fail(long seqId, Dictionary<string, Object> parms)
    {
        // Only used for transactional topologies
    }
    

Implementace šroubyImplement the bolts

  1. Odstraňte existující soubor Bolt.cs z projektu.Delete the existing Bolt.cs file from the project.

  2. V Průzkumník řešeníklikněte pravým tlačítkem myši na projekt a vyberte možnost Přidat > novou položku.In Solution Explorer, right-click the project, and select Add > New item. V seznamu vyberte možnost přešroubovánía jako název zadejte Splitter.cs .From the list, select Storm Bolt, and enter Splitter.cs as the name. Zopakováním tohoto postupu vytvořte druhý šroub s názvem Counter.cs.Repeat this process to create a second bolt named Counter.cs.

    • Splitter.cs: Implementuje šroub, který rozdělí věty na jednotlivá slova a emituje nový proud slov.Splitter.cs: Implements a bolt that splits sentences into individual words, and emits a new stream of words.

    • Counter.cs: Implementuje šroub, který počítá každé slovo, a vygeneruje nový proud slov a počet pro každé slovo.Counter.cs: Implements a bolt that counts each word, and emits a new stream of words and the count for each word.

      Poznámka

      Tyto šrouby čtou a zapisují do datových proudů, ale můžete také použít šroub ke komunikaci se zdroji, jako je databáze nebo služba.These bolts read and write to streams, but you can also use a bolt to communicate with sources such as a database or service.

  3. Otevřete Splitter.cs.Open Splitter.cs. Ve výchozím nastavení má pouze jednu metodu: Provést.It has only one method by default: Execute. Metoda Execute je volána, když šroub obdrží řazenou kolekci členů ke zpracování.The Execute method is called when the bolt receives a tuple for processing. Tady můžete číst a zpracovávat příchozí řazené kolekce členů a generovat odchozí řazené kolekce členů.Here, you can read and process incoming tuples, and emit outbound tuples.

  4. Obsah třídy rozdělovače nahraďte následujícím kódem:Replace the contents of the Splitter class with the following code:

    private Context ctx;
    
    // Constructor
    public Splitter(Context ctx)
    {
        Context.Logger.Info("Splitter constructor called");
        this.ctx = ctx;
    
        // Declare Input and Output schemas
        Dictionary<string, List<Type>> inputSchema = new Dictionary<string, List<Type>>();
        // Input contains a tuple with a string field (the sentence)
        inputSchema.Add("default", new List<Type>() { typeof(string) });
        Dictionary<string, List<Type>> outputSchema = new Dictionary<string, List<Type>>();
        // Outbound contains a tuple with a string field (the word)
        outputSchema.Add("default", new List<Type>() { typeof(string) });
        this.ctx.DeclareComponentSchema(new ComponentStreamSchema(inputSchema, outputSchema));
    }
    
    // Get a new instance of the bolt
    public static Splitter Get(Context ctx, Dictionary<string, Object> parms)
    {
        return new Splitter(ctx);
    }
    
    // Called when a new tuple is available
    public void Execute(SCPTuple tuple)
    {
        Context.Logger.Info("Execute enter");
    
        // Get the sentence from the tuple
        string sentence = tuple.GetString(0);
        // Split at space characters
        foreach (string word in sentence.Split(' '))
        {
            Context.Logger.Info("Emit: {0}", word);
            //Emit each word
            this.ctx.Emit(new Values(word));
        }
    
        Context.Logger.Info("Execute exit");
    }
    
  5. Otevřete Counter.csa nahraďte obsah třídy následujícím kódem:Open Counter.cs, and replace the class contents with the following code:

    private Context ctx;
    
    // Dictionary for holding words and counts
    private Dictionary<string, int> counts = new Dictionary<string, int>();
    
    // Constructor
    public Counter(Context ctx)
    {
        Context.Logger.Info("Counter constructor called");
        // Set instance context
        this.ctx = ctx;
    
        // Declare Input and Output schemas
        Dictionary<string, List<Type>> inputSchema = new Dictionary<string, List<Type>>();
        // A tuple containing a string field - the word
        inputSchema.Add("default", new List<Type>() { typeof(string) });
    
        Dictionary<string, List<Type>> outputSchema = new Dictionary<string, List<Type>>();
        // A tuple containing a string and integer field - the word and the word count
        outputSchema.Add("default", new List<Type>() { typeof(string), typeof(int) });
        this.ctx.DeclareComponentSchema(new ComponentStreamSchema(inputSchema, outputSchema));
    }
    
    // Get a new instance
    public static Counter Get(Context ctx, Dictionary<string, Object> parms)
    {
        return new Counter(ctx);
    }
    
    // Called when a new tuple is available
    public void Execute(SCPTuple tuple)
    {
        Context.Logger.Info("Execute enter");
    
        // Get the word from the tuple
        string word = tuple.GetString(0);
        // Do we already have an entry for the word in the dictionary?
        // If no, create one with a count of 0
        int count = counts.ContainsKey(word) ? counts[word] : 0;
        // Increment the count
        count++;
        // Update the count in the dictionary
        counts[word] = count;
    
        Context.Logger.Info("Emit: {0}, count: {1}", word, count);
        // Emit the word and count information
        this.ctx.Emit(Constants.DEFAULT_STREAM_ID, new List<SCPTuple> { tuple }, new Values(word, count));
        Context.Logger.Info("Execute exit");
    }
    

Definování topologieDefine the topology

Spoutů a šrouby jsou uspořádány do grafu, který definuje způsob toku dat mezi komponentami.Spouts and bolts are arranged in a graph, which defines how the data flows between components. V této topologii je graf následující:For this topology, the graph is as follows:

Diagram uspořádání komponent

Věty jsou vydávány z Spout a jsou distribuovány do instancí rozdělovače.Sentences are emitted from the spout, and are distributed to instances of the Splitter bolt. Šroubce přerušuje věty na slova, která jsou distribuována do čítače čítačů.The Splitter bolt breaks the sentences into words, which are distributed to the Counter bolt.

Vzhledem k tomu, že počet slov se v instanci čítače nachází místně, chcete zajistit, aby určitá slova probíhala v toku ke stejné instanci počítadla.Because word count is held locally in the Counter instance, you want to make sure that specific words flow to the same Counter bolt instance. Každá instance uchovává záznam o konkrétních slovech.Each instance keeps track of specific words. Vzhledem k tomu, že rozdělovač oddělovače udržuje žádný stav, nezáleží na tom, která instance rozdělovače obdrží tuto větu.Since the Splitter bolt maintains no state, it really doesn't matter which instance of the splitter receives which sentence.

Otevřete program.cs.Open Program.cs. Důležitou metodou je GetTopologyBuilder, která slouží k definování topologie, která je odeslána do přeplavení.The important method is GetTopologyBuilder, which is used to define the topology that is submitted to Storm. Nahraďte obsah GetTopologyBuilder následujícím kódem k implementaci topologie popsané dříve:Replace the contents of GetTopologyBuilder with the following code to implement the topology described previously:

// Create a new topology named 'WordCount'
TopologyBuilder topologyBuilder = new TopologyBuilder("WordCount" + DateTime.Now.ToString("yyyyMMddHHmmss"));

// Add the spout to the topology.
// Name the component 'sentences'
// Name the field that is emitted as 'sentence'
topologyBuilder.SetSpout(
    "sentences",
    Spout.Get,
    new Dictionary<string, List<string>>()
    {
        {Constants.DEFAULT_STREAM_ID, new List<string>(){"sentence"}}
    },
    1);
// Add the splitter bolt to the topology.
// Name the component 'splitter'
// Name the field that is emitted 'word'
// Use suffleGrouping to distribute incoming tuples
//   from the 'sentences' spout across instances
//   of the splitter
topologyBuilder.SetBolt(
    "splitter",
    Splitter.Get,
    new Dictionary<string, List<string>>()
    {
        {Constants.DEFAULT_STREAM_ID, new List<string>(){"word"}}
    },
    1).shuffleGrouping("sentences");

// Add the counter bolt to the topology.
// Name the component 'counter'
// Name the fields that are emitted 'word' and 'count'
// Use fieldsGrouping to ensure that tuples are routed
//   to counter instances based on the contents of field
//   position 0 (the word). This could also have been
//   List<string>(){"word"}.
//   This ensures that the word 'jumped', for example, will always
//   go to the same instance
topologyBuilder.SetBolt(
    "counter",
    Counter.Get,
    new Dictionary<string, List<string>>()
    {
        {Constants.DEFAULT_STREAM_ID, new List<string>(){"word", "count"}}
    },
    1).fieldsGrouping("splitter", new List<int>() { 0 });

// Add topology config
topologyBuilder.SetTopologyConfig(new Dictionary<string, string>()
{
    {"topology.kryo.register","[\"[B\"]"}
});

return topologyBuilder;

Odeslat topologiiSubmit the topology

  1. V Průzkumník řešeníklikněte pravým tlačítkem myši na projekt a vyberte Odeslat prozaplavení v HDInsight.In Solution Explorer, right-click the project, and select Submit to Storm on HDInsight.

    Poznámka

    Pokud se zobrazí výzva, zadejte přihlašovací údaje k vašemu předplatnému Azure.If prompted, enter the credentials for your Azure subscription. Pokud máte více než jedno předplatné, přihlaste se k počítači, který obsahuje vaše navýšení na clusteru HDInsight.If you have more than one subscription, sign in to the one that contains your Storm on HDInsight cluster.

  2. Z rozevíracího seznamu cluster pro zaplavení vyberte svou navýšení na clusteru HDInsight a pak vyberte Odeslat.Select your Storm on HDInsight cluster from the Storm Cluster drop-down list, and then select Submit. Můžete sledovat, zda je odeslání úspěšné, pomocí okna výstup .You can monitor if the submission is successful by using the Output window.

  3. Po úspěšném odeslání topologie by se měly zobrazit topologie pro zaplavení clusteru.When the topology has been successfully submitted, the Storm Topologies for the cluster should appear. Výběrem topologie WORDCOUNT ze seznamu zobrazíte informace o spuštěné topologii.Select the WordCount topology from the list to view information about the running topology.

    Poznámka

    Topologie přePrůzkumník serverumůžete zobrazit také z.You can also view Storm Topologies from Server Explorer. Rozbalte Azure > HDInsight, klikněte pravým tlačítkem na cluster HDInsight a pak vyberte Zobrazit topologiepřeplavování.Expand Azure > HDInsight, right-click a Storm on HDInsight cluster, and then select View Storm Topologies.

    Chcete-li zobrazit informace o součástech v topologii, dvakrát klikněte na součást v diagramu.To view information about the components in the topology, double-click the component in the diagram.

  4. V zobrazení Souhrn topologie kliknutím na tlačítko Kill zastavte topologii.From the Topology Summary view, click Kill to stop the topology.

    Poznámka

    Topologie zaplavování se nadále spouštějí, dokud nejsou deaktivovány, nebo když se cluster odstraní.Storm topologies continue to run until they are deactivated, or the cluster is deleted.

Transakční topologieTransactional topology

Předchozí topologie je jiná než transakční.The previous topology is non-transactional. Komponenty v topologii neimplementují funkce pro přehrávání zpráv.The components in the topology do not implement functionality to replaying messages. Příklad transakční topologie získáte tak, že vytvoříte projekt a jako typ projektu vyberete možnost Nevytvářet vzorek .For an example of a transactional topology, create a project and select Storm Sample as the project type.

Transakční topologie implementují následující, aby podporovaly přehrávání dat:Transactional topologies implement the following to support replay of data:

  • Ukládání metadat do mezipaměti: Spout musí ukládat metadata o vysílaných datech, aby se data mohla načíst a emitovat znovu, pokud dojde k selhání.Metadata caching: The spout must store metadata about the data emitted, so that the data can be retrieved and emitted again if a failure occurs. Vzhledem k tomu, že data vygenerovaná ukázkou jsou malá, jsou nezpracovaná data pro každou řazenou kolekci členů uložena ve slovníku pro opětovné přehrání.Because the data emitted by the sample is small, the raw data for each tuple is stored in a dictionary for replay.

  • Potvrzení: Každé pole topologie může volat this.ctx.Ack(tuple) , aby bylo možné potvrdit, že úspěšně zpracovalo řazenou kolekci členů.Ack: Each bolt in the topology can call this.ctx.Ack(tuple) to acknowledge that it has successfully processed a tuple. Když všechny šrouby potvrdí řazenou kolekci členů, Ack vyvolá se metoda Spout.When all bolts have acknowledged the tuple, the Ack method of the spout is invoked. Ack Metoda umožňuje Spout odebrat data, která byla uložena do mezipaměti pro opětovné přehrání.The Ack method allows the spout to remove data that was cached for replay.

  • Selhání: Každé šroubové volání this.ctx.Fail(tuple) může značit, že zpracování pro řazenou kolekci členů selhalo.Fail: Each bolt can call this.ctx.Fail(tuple) to indicate that processing has failed for a tuple. Selhání se šíří do Fail metody Spout, kde je možné znovu přehrát řazenou kolekci členů pomocí metadat uložených v mezipaměti.The failure propagates to the Fail method of the spout, where the tuple can be replayed by using cached metadata.

  • ID sekvence: Při generování řazené kolekce členů lze zadat jedinečné ID sekvence.Sequence ID: When emitting a tuple, a unique sequence ID can be specified. Tato hodnota určuje počet řazené kolekce členů pro zpracování opětovného přehrání (ACK a selhání).This value identifies the tuple for replay (Ack and Fail) processing. Například Spout v projektu s ukázkovým zaplavení při vygenerování dat používá následující:For example, the spout in the Storm Sample project uses the following when emitting data:

      this.ctx.Emit(Constants.DEFAULT_STREAM_ID, new Values(sentence), lastSeqId);
    

    Tento kód vygeneruje řazenou kolekci členů, která obsahuje větu k výchozímu datovému proudu, s hodnotou ID sekvence obsaženou v lastSeqId.This code emits a tuple that contains a sentence to the default stream, with the sequence ID value contained in lastSeqId. V tomto příkladu se lastSeqId zvyšuje pro každou vydanou řazenou kolekci členů.For this example, lastSeqId is incremented for every tuple emitted.

Jak je znázorněno v projektu ukázkového navýšení, zda je součást transakční, lze nastavit za běhu na základě konfigurace.As demonstrated in the Storm Sample project, whether a component is transactional can be set at runtime, based on configuration.

Hybridní topologie pomocí C# a JavaHybrid topology with C# and Java

Můžete také použít nástroje Data Lake Tools for Visual Studio k vytvoření hybridních topologií, kde některé součásti C# a jiné jsou Java.You can also use Data Lake tools for Visual Studio to create hybrid topologies, where some components are C# and others are Java.

Příklad hybridní topologie získáte tak, že vytvoříte projekt a vyberete možnost navýšit hybridní vzorek.For an example of a hybrid topology, create a project and select Storm Hybrid Sample. Tento vzorový typ předvádí následující koncepty:This sample type demonstrates the following concepts:

  • Java Spout a C# šroub: Definováno v HybridTopology_javaSpout_csharpBolt.Java spout and C# bolt: Defined in HybridTopology_javaSpout_csharpBolt.

    • Transakční verze je definována v HybridTopologyTx_javaSpout_csharpBolt.A transactional version is defined in HybridTopologyTx_javaSpout_csharpBolt.
  • Spout a Java: C# Definováno v HybridTopology_csharpSpout_javaBolt.C# spout and Java bolt: Defined in HybridTopology_csharpSpout_javaBolt.

    • Transakční verze je definována v HybridTopologyTx_csharpSpout_javaBolt.A transactional version is defined in HybridTopologyTx_csharpSpout_javaBolt.

    Poznámka

    Tato verze také ukazuje, jak použít kód Clojure z textového souboru jako součást Java.This version also demonstrates how to use Clojure code from a text file as a Java component.

Chcete-li přepnout topologii, která se používá při odeslání projektu, přesuňte [Active(true)] příkaz do topologie, kterou chcete použít, před odesláním do clusteru.To switch the topology that is used when the project is submitted, move the [Active(true)] statement to the topology you want to use, before submitting it to the cluster.

Poznámka

Všechny soubory Java, které jsou požadovány, jsou k dispozici jako součást tohoto projektu ve složce JavaDependency .All the Java files that are required are provided as part of this project in the JavaDependency folder.

Při vytváření a odesílání hybridní topologie Vezměte v úvahu následující skutečnosti:Consider the following when you are creating and submitting a hybrid topology:

  • Pomocí JavaComponentConstructor můžete vytvořit instanci třídy Java pro Spout nebo šroub.Use JavaComponentConstructor to create an instance of the Java class for a spout or bolt.

  • K serializaci dat do komponent Java nebo z nich z objektů Java do formátu JSON použijte Microsoft. SCP. CustomizedInteropJSONSerializer. getlang. .Use microsoft.scp.storm.multilang.CustomizedInteropJSONSerializer to serialize data into or out of Java components from Java objects to JSON.

  • Při odesílání topologie na server je nutné použít možnost dalších konfigurací k určení cest k souborům Java.When submitting the topology to the server, you must use the Additional configurations option to specify the Java File paths. Zadaná cesta by měla být adresář, který obsahuje soubory JAR, které obsahují vaše třídy Java.The path specified should be the directory that contains the JAR files that contain your Java classes.

Azure Event HubsAzure Event Hubs

SCP.NET verze 0.9.4.203 zavádí novou třídu a metodu specificky pro práci s centrem událostí Spout (Java Spout, který čte z Event Hubs).SCP.NET version 0.9.4.203 introduces a new class and method specifically for working with the Event Hub spout (a Java spout that reads from Event Hubs). Při vytváření topologie, která používá Spout centra událostí, použijte následující metody:When you create a topology that uses an Event Hub spout, use the following methods:

  • Třída EventHubSpoutConfig : Vytvoří objekt, který obsahuje konfiguraci pro komponentu Spout.EventHubSpoutConfig class: Creates an object that contains the configuration for the spout component.

  • TopologyBuilder. SetEventHubSpout – metoda: Přidá do topologie komponentu Spout centra událostí.TopologyBuilder.SetEventHubSpout method: Adds the Event Hub spout component to the topology.

Poznámka

K serializaci dat vytvářených rozhraním Spout je však stále nutné použít rozhraní CustomizedInteropJSONSerializer .You must still use the CustomizedInteropJSONSerializer to serialize data produced by the spout.

Použití ConfigurationManagerUse ConfigurationManager

Nepoužívejte ConfigurationManager k načtení hodnot konfigurace ze součástí šroubů a Spout.Don't use ConfigurationManager to retrieve configuration values from bolt and spout components. V takovém případě může dojít k výjimce ukazatele s hodnotou null.Doing so can cause a null pointer exception. Místo toho je konfigurace pro váš projekt předána do topologie přetvoření jako dvojice klíč-hodnota v kontextu topologie.Instead, the configuration for your project is passed into the Storm topology as a key and value pair in the topology context. Každá komponenta, která závisí na hodnotách konfigurace, musí být při inicializaci načítána z kontextu.Each component that relies on configuration values must retrieve them from the context during initialization.

Následující kód ukazuje, jak načíst tyto hodnoty:The following code demonstrates how to retrieve these values:

public class MyComponent : ISCPBolt
{
    // To hold configuration information loaded from context
    Configuration configuration;
    ...
    public MyComponent(Context ctx, Dictionary<string, Object> parms)
    {
        // Save a copy of the context for this component instance
        this.ctx = ctx;
        // If it exists, load the configuration for the component
        if(parms.ContainsKey(Constants.USER_CONFIG))
        {
            this.configuration = parms[Constants.USER_CONFIG] as System.Configuration.Configuration;
        }
        // Retrieve the value of "Foo" from configuration
        var foo = this.configuration.AppSettings.Settings["Foo"].Value;
    }
    ...
}

Použijete Get -li metodu pro vrácení instance komponenty, je nutné zajistit, aby do konstruktoru předala Context parametry a Dictionary<string, Object> .If you use a Get method to return an instance of your component, you must ensure that it passes both the Context and Dictionary<string, Object> parameters to the constructor. Následující příklad je základní Get metoda, která správně předává tyto hodnoty:The following example is a basic Get method that properly passes these values:

public static MyComponent Get(Context ctx, Dictionary<string, Object> parms)
{
    return new MyComponent(ctx, parms);
}

Postup aktualizace SCP.NETHow to update SCP.NET

Nejnovější verze SCP.NET podporují upgrade balíčku prostřednictvím NuGet.Recent releases of SCP.NET support package upgrade through NuGet. Když je k dispozici nová aktualizace, obdržíte oznámení o upgradu.When a new update is available, you receive an upgrade notification. Chcete-li provést ruční kontrolu upgradu, postupujte podle následujících kroků:To manually check for an upgrade, follow these steps:

  1. V Průzkumníku řešení klikněte pravým tlačítkem na požadovaný projekt a vyberte Správa balíčků NuGet.In Solution Explorer, right-click the project, and select Manage NuGet Packages.

  2. Ve Správci balíčků vyberte aktualizace.From the package manager, select Updates. Pokud je aktualizace k dispozici, je uvedena v seznamu.If an update is available, it is listed. Kliknutím na aktualizovat balíček ho nainstalujete.Click Update for the package to install it.

Důležité

Pokud byl projekt vytvořen pomocí starší verze SCP.NET, která nepoužívala NuGet, je nutné provést následující kroky, aby se aktualizovala na novější verzi:If your project was created with an earlier version of SCP.NET that did not use NuGet, you must perform the following steps to update to a newer version:

  1. V Průzkumníku řešení klikněte pravým tlačítkem na požadovaný projekt a vyberte Správa balíčků NuGet.In Solution Explorer, right-click the project, and select Manage NuGet Packages.
  2. Pomocí vyhledávacího pole vyhledejte a potom do projektu přidejte Microsoft. SCP. NET. SDK .Using the Search field, search for, and then add, Microsoft.SCP.Net.SDK to the project.

Řešení běžných potíží s topologiemiTroubleshoot common issues with topologies

Výjimky ukazatele s hodnotou nullNull pointer exceptions

Pokud používáte C# topologii s clusterem HDInsight se systémem Linux, musí komponenty šroubů a Spout, které používají ConfigurationManager ke čtení konfiguračních nastavení za běhu, vracet výjimky ukazatele s hodnotou null.When you are using a C# topology with a Linux-based HDInsight cluster, bolt and spout components that use ConfigurationManager to read configuration settings at runtime may return null pointer exceptions.

Konfigurace pro váš projekt je předána do topologie přetvoření jako dvojice klíč a hodnota v kontextu topologie.The configuration for your project is passed into the Storm topology as a key and value pair in the topology context. Může být načten z objektu Dictionary, který je předán komponentám při inicializaci.It can be retrieved from the dictionary object that is passed to your components when they are initialized.

Další informace najdete v části ConfigurationManager tohoto dokumentu.For more information, see the ConfigurationManager section of this document.

System.TypeLoadExceptionSystem.TypeLoadException

Pokud používáte C# topologii s clusterem HDInsight se systémem Linux, může dojít k následující chybě:When you are using a C# topology with a Linux-based HDInsight cluster, you may encounter the following error:

System.TypeLoadException: Failure has occurred while loading a type.

K této chybě dochází, pokud použijete binární soubor, který není kompatibilní s verzí rozhraní .NET, kterou mono podporuje.This error occurs when you use a binary that is not compatible with the version of .NET that Mono supports.

U clusterů HDInsight se systémem Linux se ujistěte, že váš projekt používá binární soubory kompilované pro .NET 4,5.For Linux-based HDInsight clusters, make sure that your project uses binaries compiled for .NET 4.5.

Místní otestování topologieTest a topology locally

I když je možné topologii nasadit do clusteru, může být v některých případech nutné místně testovat topologii.Although it is easy to deploy a topology to a cluster, in some cases, you may need to test a topology locally. Následující postup použijte k místnímu spuštění a otestování ukázkové topologie v tomto článku ve vývojovém prostředí.Use the following steps to run and test the example topology in this article locally in your development environment.

Varování

Místní testování funguje pouze pro základní C#topologie.Local testing only works for basic, C#-only topologies. Místní testování nelze použít pro hybridní topologie nebo topologie, které používají více datových proudů.You cannot use local testing for hybrid topologies or topologies that use multiple streams.

  1. V Průzkumník řešeníklikněte pravým tlačítkem myši na projekt a vyberte vlastnosti.In Solution Explorer, right-click the project, and select Properties. Ve vlastnostech projektu změňte Typ výstupu na konzolovou aplikaci.In the project properties, change the Output type to Console Application.

    Snímek obrazovky s vlastnostmi projektu se zvýrazněným typem výstupu

    Poznámka

    Nezapomeňte změnit Typ výstupu zpátky do knihovny tříd před nasazením topologie do clusteru.Remember to change the Output type back to Class Library before you deploy the topology to a cluster.

  2. V Průzkumník řešeníklikněte pravým tlačítkem myši na projekt a vyberte možnost Přidat > novou položku.In Solution Explorer, right-click the project, and then select Add > New Item. Vyberte Třídaa jako název třídy zadejte LocalTest.cs .Select Class, and enter LocalTest.cs as the class name. Nakonec klikněte na tlačítko Přidat.Finally, click Add.

  3. Otevřete LocalTest.csa přidejte následující příkaz using v horní části:Open LocalTest.cs, and add the following using statement at the top:

    using Microsoft.SCP;
    
  4. Jako obsah třídy LocalTest použijte následující kód:Use the following code as the contents of the LocalTest class:

    // Drives the topology components
    public void RunTestCase()
    {
        // An empty dictionary for use when creating components
        Dictionary<string, Object> emptyDictionary = new Dictionary<string, object>();
    
        #region Test the spout
        {
            Console.WriteLine("Starting spout");
            // LocalContext is a local-mode context that can be used to initialize
            // components in the development environment.
            LocalContext spoutCtx = LocalContext.Get();
            // Get a new instance of the spout, using the local context
            Spout sentences = Spout.Get(spoutCtx, emptyDictionary);
    
            // Emit 10 tuples
            for (int i = 0; i < 10; i++)
            {
                sentences.NextTuple(emptyDictionary);
            }
            // Use LocalContext to persist the data stream to file
            spoutCtx.WriteMsgQueueToFile("sentences.txt");
            Console.WriteLine("Spout finished");
        }
        #endregion
    
        #region Test the splitter bolt
        {
            Console.WriteLine("Starting splitter bolt");
            // LocalContext is a local-mode context that can be used to initialize
            // components in the development environment.
            LocalContext splitterCtx = LocalContext.Get();
            // Get a new instance of the bolt
            Splitter splitter = Splitter.Get(splitterCtx, emptyDictionary);
    
            // Set the data stream to the data created by the spout
            splitterCtx.ReadFromFileToMsgQueue("sentences.txt");
            // Get a batch of tuples from the stream
            List<SCPTuple> batch = splitterCtx.RecvFromMsgQueue();
            // Process each tuple in the batch
            foreach (SCPTuple tuple in batch)
            {
                splitter.Execute(tuple);
            }
            // Use LocalContext to persist the data stream to file
            splitterCtx.WriteMsgQueueToFile("splitter.txt");
            Console.WriteLine("Splitter bolt finished");
        }
        #endregion
    
        #region Test the counter bolt
        {
            Console.WriteLine("Starting counter bolt");
            // LocalContext is a local-mode context that can be used to initialize
            // components in the development environment.
            LocalContext counterCtx = LocalContext.Get();
            // Get a new instance of the bolt
            Counter counter = Counter.Get(counterCtx, emptyDictionary);
    
            // Set the data stream to the data created by splitter bolt
            counterCtx.ReadFromFileToMsgQueue("splitter.txt");
            // Get a batch of tuples from the stream
            List<SCPTuple> batch = counterCtx.RecvFromMsgQueue();
            // Process each tuple in the batch
            foreach (SCPTuple tuple in batch)
            {
                counter.Execute(tuple);
            }
            // Use LocalContext to persist the data stream to file
            counterCtx.WriteMsgQueueToFile("counter.txt");
            Console.WriteLine("Counter bolt finished");
        }
        #endregion
    }
    

    Věnujte si chvilku, abyste si přečetli komentáře ke kódu.Take a moment to read through the code comments. Tento kód používá LocalContext ke spuštění komponent ve vývojovém prostředí a ukládá datový proud mezi komponentami do textových souborů na místním disku.This code uses LocalContext to run the components in the development environment, and it persists the data stream between components to text files on the local drive.

  5. Otevřete program.csa do metody Main přidejte následující:Open Program.cs, and add the following to the Main method:

    Console.WriteLine("Starting tests");
    System.Environment.SetEnvironmentVariable("microsoft.scp.logPrefix", "WordCount-LocalTest");
    // Initialize the runtime
    SCPRuntime.Initialize();
    
    //If we are not running under the local context, throw an error
    if (Context.pluginType != SCPPluginType.SCP_NET_LOCAL)
    {
        throw new Exception(string.Format("unexpected pluginType: {0}", Context.pluginType));
    }
    // Create test instance
    LocalTest tests = new LocalTest();
    // Run tests
    tests.RunTestCase();
    Console.WriteLine("Tests finished");
    Console.ReadKey();
    
  6. Uložte změny a pak klikněte na F5 nebo vyberte ladit > Spustit ladění a spusťte tak projekt.Save the changes, and then click F5 or select Debug > Start Debugging to start the project. Mělo by se zobrazit okno konzoly a log status jako průběh testů.A console window should appear, and log status as the tests progress. Po zobrazení dokončených testů stiskněte libovolnou klávesu pro zavření okna.When Tests finished appears, press any key to close the window.

  7. Pomocí Průzkumníka Windows vyhledejte adresář, který obsahuje váš projekt.Use Windows Explorer to locate the directory that contains your project. Příklad: C:\Users<your_user_name > \Documents\Visual Studio 2013 \ Projects\WordCount\WordCount.For example: C:\Users<your_user_name>\Documents\Visual Studio 2013\Projects\WordCount\WordCount. V tomto adresáři otevřete přihrádkua klikněte na tlačítko ladit.In this directory, open Bin, and then click Debug. Měli byste vidět textové soubory, které byly vytvořeny při spuštění testů: věty. txt, Counter. txt a rozdělovač. txt.You should see the text files that were produced when the tests ran: sentences.txt, counter.txt, and splitter.txt. Otevřete každý textový soubor a zkontrolujte data.Open each text file and inspect the data.

    Poznámka

    Řetězcová data v těchto souborech přetrvají jako pole desítkových hodnot.String data persists as an array of decimal values in these files. Například [[97 103 111]] v souboru rozdělovače. txt je slovo a.For example, [[97,103,111]] in the splitter.txt file is the word and.

Poznámka

Před nasazením do clusteru HDInsight nezapomeňte nastavit typ projektu zpátky na knihovnu tříd .Be sure to set the Project type back to Class Library before deploying to a Storm on HDInsight cluster.

Informace protokoluLog information

Informace ze svých komponent topologie můžete snadno protokolovat pomocí Context.Logger.You can easily log information from your topology components by using Context.Logger. Například následující příkaz vytvoří informační položku protokolu:For example, the following command creates an informational log entry:

Context.Logger.Info("Component started");

Protokolované informace můžete zobrazit z protokolu služby Hadoop, který najdete v Průzkumník serveru.Logged information can be viewed from the Hadoop Service Log, which is found in Server Explorer. Rozbalte položku pro vaše vyplavení v clusteru HDInsight a potom rozbalte protokol služby Hadoop.Expand the entry for your Storm on HDInsight cluster, and then expand Hadoop Service Log. Nakonec vyberte soubor protokolu, který chcete zobrazit.Finally, select the log file to view.

Poznámka

Protokoly se ukládají do účtu služby Azure Storage, který používá váš cluster.The logs are stored in the Azure storage account that is used by your cluster. Chcete-li zobrazit protokoly v aplikaci Visual Studio, musíte se přihlásit k předplatnému Azure, které vlastní účet úložiště.To view the logs in Visual Studio, you must sign in to the Azure subscription that owns the storage account.

Zobrazit informace o chyběView error information

Chcete-li zobrazit chyby, ke kterým došlo ve spuštěné topologii, použijte následující postup:To view errors that have occurred in a running topology, use the following steps:

  1. V Průzkumník serveruklikněte pravým tlačítkem na cluster se systémem HDInsight a vyberte Zobrazit topologiepřeplavení.From Server Explorer, right-click the Storm on HDInsight cluster, and select View Storm topologies.

  2. Sloupec Poslední chyba pro Spout a šroubyobsahuje informace o Poslední chybě.For the Spout and Bolts, the Last Error column contains information on the last error.

  3. Vyberte ID Spout nebo ID šroubu pro komponentu, u které je uvedená chyba.Select the Spout ID or Bolt ID for the component that has an error listed. Na zobrazené stránce podrobností se v části chyby v dolní části stránky zobrazí další informace o chybě.On the details page that is displayed, additional error information is listed in the Errors section at the bottom of the page.

  4. Pokud chcete získat další informace, vyberte port z části vykonavatelé na stránce, abyste viděli protokol pracovního procesu pro více než posledních pár minut.To obtain more information, select a Port from the Executors section of the page, to see the Storm worker log for the last few minutes.

Chyby při odesílání topologiíErrors submitting topologies

Pokud narazíte na chyby při odesílání topologie do služby HDInsight, můžete najít protokoly pro serverové komponenty, které zpracovávají odesílání topologie v clusteru HDInsight.If you encounter errors submitting a topology to HDInsight, you can find logs for the server-side components that handle topology submission on your HDInsight cluster. Chcete-li načíst tyto protokoly, použijte následující příkaz z příkazového řádku:To retrieve these logs, use the following command from a command line:

scp sshuser@clustername-ssh.azurehdinsight.net:/var/log/hdinsight-scpwebapi/hdinsight-scpwebapi.out .

Nahraďte sshuser uživatelským účtem SSH pro cluster.Replace sshuser with the SSH user account for the cluster. Položku název_clusteru nahraďte názvem clusteru HDInsight.Replace clustername with the name of the HDInsight cluster. Další informace o používání scp a ssh se službou HDInsight najdete v tématu Použití SSH se službou HDInsight.For more information on using scp and ssh with HDInsight, see Use SSH with HDInsight.

Odesílání může selhat z několika důvodů:Submissions can fail for multiple reasons:

  • JDK není nainstalován nebo není v cestě.JDK is not installed or is not in the path.
  • Požadované závislosti Java nejsou zahrnuté do odeslání.Required Java dependencies are not included in the submission.
  • Nekompatibilní závislostiIncompatible dependencies.
  • Duplicitní názvy topologie.Duplicate topology names.

hdinsight-scpwebapi.out Pokud protokolFileNotFoundExceptionobsahuje, může to být způsobeno následujícími podmínkami:If the hdinsight-scpwebapi.out log contains a FileNotFoundException, this might be caused by the following conditions:

  • JDK není v cestě k vývojovému prostředí.The JDK is not in the path on the development environment. Ověřte, že je JDK nainstalovaný ve vývojovém prostředí a že %JAVA_HOME%/bin je v cestě.Verify that the JDK is installed in the development environment, and that %JAVA_HOME%/bin is in the path.
  • Chybí závislost Java.You are missing a Java dependency. Ujistěte se, že jako součást odeslání budete zahrnovat všechny požadované soubory. jar.Make sure you are including any required .jar files as part of the submission.

Další postupNext steps

Příklad zpracování dat z Event Hubs najdete v tématu zpracování událostí z Azure Event Hubs sezaplavou v HDInsight.For an example of processing data from Event Hubs, see Process events from Azure Event Hubs with Storm on HDInsight.

Příklad C# topologie, která rozdělí streamovaná data do více datových proudů, najdete v tématu C# příkladzaplavení.For an example of a C# topology that splits stream data into multiple streams, see C# Storm example.

Další informace o vytváření C# topologií najdete v tématu GitHub.To discover more information about creating C# topologies, see GitHub.

Další způsoby, jak pracovat se službou HDInsight a větším využitím ukázek HDInsight, najdete v následujících dokumentech:For more ways to work with HDInsight and more Storm on HDInsight samples, see the following documents:

Microsoft SCP.NETMicrosoft SCP.NET

Apache Storm ve službě HDInsightApache Storm on HDInsight

Apache Hadoop ve službě HDInsightApache Hadoop on HDInsight

Apache HBA v HDInsightApache HBase on HDInsight