Topologieën ontwikkelen C# voor Apache Storm met behulp van de data Lake-hulpprogram Ma's voor Visual StudioDevelop C# topologies for Apache Storm by using the Data Lake tools for Visual Studio

Meer informatie over het maken C# van een Apache Storm topologie met behulp van de Azure data Lake-hulpprogram ma's (Apache Hadoop) voor Visual Studio.Learn how to create a C# Apache Storm topology by using the Azure Data Lake (Apache Hadoop) tools for Visual Studio. Dit document gaat over het proces van het maken van een storm-project in Visual Studio, het lokaal testen en het implementeren van een Apache Storm op een Azure HDInsight-cluster.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.

U leert ook hoe u hybride topologieën maakt die C# gebruikmaken van en Java-onderdelen.You also learn how to create hybrid topologies that use C# and Java components.

Notitie

Hoewel de stappen in dit document afhankelijk zijn van een Windows-ontwikkel omgeving met Visual Studio, kan het gecompileerde project worden verzonden naar een op Linux of Windows gebaseerd HDInsight-cluster.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. Alleen op Linux gebaseerde clusters die zijn gemaakt na 28 oktober 2016 ondersteunen SCP.NET-topologieën.Only Linux-based clusters created after October 28, 2016 support SCP.NET topologies.

Als u een C# topologie met een op Linux gebaseerd cluster wilt gebruiken, moet u het Microsoft.SCP.Net.SDK NuGet-pakket dat door uw project wordt gebruikt, bijwerken naar versie 0.10.0.6 of hoger.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. De versie van het pakket moet ook overeenkomen met de primaire versie van Storm die op HDInsight is geïnstalleerd.The version of the package must also match the major version of Storm installed on HDInsight.

HDInsight-versieHDInsight version Apache Storm versieApache Storm version SCP.NET-versieSCP.NET version Standaard-mono-versieDefault Mono version
3,33.3 0,10. x0.10.x 0,10. x. x0.10.x.x
(alleen op HDInsight op basis van Windows)(only on Windows-based HDInsight)
N.v.t.NA
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

Belangrijk

C#-topologieën met op Linux gebaseerde clusters moeten .NET 4.5 en Mono gebruiken om op het HDInsight-cluster te worden uitgevoerd.C# topologies on Linux-based clusters must use .NET 4.5, and use Mono to run on the HDInsight cluster. Zie mono-compatibiliteitvoor meer informatie over mogelijke compatibiliteits problemen.For information about potential incompatibilities, see Mono compatibility.

Visual Studio installerenInstall Visual Studio

U kunt topologieën ontwikkelen C# met SCP.net met behulp van Visual Studio.You can develop C# topologies with SCP.NET by using Visual Studio. In deze instructies wordt gebruikgemaakt van Visual Studio 2019, maar u kunt ook eerdere versies van Visual Studio gebruiken.The instructions here use Visual Studio 2019, but you may also use earlier versions of Visual Studio.

Data Lake-hulpprogram ma's voor Visual Studio installerenInstall Data Lake tools for Visual Studio

Als u Data Lake-hulpprogram ma's voor Visual Studio wilt installeren, volgt u de stappen in aan de slag met data Lake-hulpprogram ma's voor Visual Studio.To install Data Lake tools for Visual Studio, follow the steps in Get started using Data Lake tools for Visual Studio.

Java installerenInstall Java

Wanneer u een storm-topologie vanuit Visual Studio verzendt, genereert SCP.NET een zip-bestand dat de topologie en de afhankelijkheden bevat.When you submit a Storm topology from Visual Studio, SCP.NET generates a zip file that contains the topology and dependencies. Java wordt gebruikt om deze zip-bestanden te maken, omdat er een indeling wordt gebruikt die compatibel is met op Linux gebaseerde clusters.Java is used to create these zip files, because it uses a format that is more compatible with Linux-based clusters.

  1. Installeer de Java Developer Kit (JDK) 7 of hoger in uw ontwikkel omgeving.Install the Java Developer Kit (JDK) 7 or later on your development environment. U kunt de Oracle-JDK ophalen van Oracle.You can get the Oracle JDK from Oracle. U kunt ook andere Java-distributiesgebruiken.You can also use other Java distributions.

  2. Stel de omgevings variabele JAVA_HOME in op de map die Java bevat.Set the JAVA_HOME environment variable to the directory that contains Java.

  3. Stel de PATH omgevings variabele in op het toevoegen van de map % JAVA_HOME% \ bin .Set the PATH environment variable to include the %JAVA_HOME%\bin directory.

U kunt de volgende C# console toepassing bouwen en uitvoeren om te controleren of Java en de JDK correct zijn geïnstalleerd:You can build and run 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.");
           }
       }  
   }
}

Apache Storm sjablonenApache Storm templates

De Data Lake-hulpprogram ma's voor Visual Studio bieden de volgende sjablonen:The Data Lake tools for Visual Studio provide the following templates:

ProjecttypeProject type Laat zienDemonstrates
Storm-toepassingStorm Application Een leeg Storm-topologie project.An empty Storm topology project.
Voor beeld van Storm voor Azure SQL WriterStorm Azure SQL Writer Sample Schrijven naar Azure SQL Database.How to write to Azure SQL Database.
Voor beeld van Storm Azure Cosmos DB ReaderStorm Azure Cosmos DB Reader Sample Lezen uit Azure Cosmos DB.How to read from Azure Cosmos DB.
Voor beeld Storm Azure Cosmos DB WriterStorm Azure Cosmos DB Writer Sample Schrijven naar Azure Cosmos DB.How to write to Azure Cosmos DB.
Voor beeld Storm EventHub ReaderStorm EventHub Reader Sample Lezen van Azure Event Hubs.How to read from Azure Event Hubs.
Voor beeld Storm EventHub WriterStorm EventHub Writer Sample Schrijven naar Azure Event Hubs.How to write to Azure Event Hubs.
Voor beeld Storm HBase ReaderStorm HBase Reader Sample Lezen van HBase in HDInsight-clusters.How to read from HBase on HDInsight clusters.
Voor beeld Storm HBase WriterStorm HBase Writer Sample Schrijven naar HBase in HDInsight-clusters.How to write to HBase on HDInsight clusters.
Storm hybride-voor beeldStorm Hybrid Sample Een Java-onderdeel gebruiken.How to use a Java component.
Storm-voor beeldStorm Sample Een eenvoudige topologie voor het tellen van woorden.A basic word count topology.

Waarschuwing

Niet alle sjablonen werken met HDInsight op basis van Linux.Not all templates work with Linux-based HDInsight. NuGet pakketten die door de sjablonen worden gebruikt, zijn mogelijk niet compatibel met mono.NuGet packages used by the templates may not be compatible with Mono. Zie voor het identificeren van mogelijke problemen de compatibiliteit van mono en het gebruik van de .net-portabiliteit Analyzer.To identify potential problems, see Mono compatibility and use the .NET Portability Analyzer.

In de stappen in dit document gebruikt u het Basic Storm-toepassings project type om een topologie te maken.In the steps in this document, you use the basic Storm Application project type to create a topology.

Apache HBase-sjablonenApache HBase templates

De HBase Reader-en Writer-sjablonen gebruiken de HBase REST API, niet de HBase Java API, om te communiceren met een HBase in HDInsight-cluster.The HBase reader and writer templates use the HBase REST API, not the HBase Java API, to communicate with an HBase on HDInsight cluster.

EventHub-sjablonenEventHub templates

Belangrijk

Het op Java gebaseerde EventHub Spout-onderdeel dat is opgenomen in de EventHub Reader-sjabloon, werkt mogelijk niet met storm in HDInsight-versie 3,5 of hoger.The Java-based EventHub spout component included with the EventHub Reader template may not work with Storm on HDInsight version 3.5 or later. Een bijgewerkte versie van dit onderdeel is beschikbaar op github.An updated version of this component is available at GitHub.

Zie githubvoor een voorbeeld topologie die gebruikmaakt van dit onderdeel en werkt met Storm op HDInsight 3,5.For an example topology that uses this component and works with Storm on HDInsight 3.5, see GitHub.

Een C# topologie makenCreate a C# topology

Een C# topologie project maken in Visual Studio:To create a C# topology project in Visual Studio:

  1. Open Visual Studio.Open Visual Studio.

  2. Selecteer in het Start venster een nieuw project maken.In the Start window, select Create a new project.

  3. Ga in het venster een nieuw project maken naar en kies Storm-toepassingen selecteer volgende.In the Create a new project window, scroll to and pick Storm Application, then select Next.

  4. Voer in het venster uw nieuwe project configureren de project naam WordCountin, ga naar of maak een pad naar de map voor het project en selecteer vervolgens maken.In the Configure your new project window, enter a Project name of WordCount, go to or create a Location directory path for the project, and then select Create.

    Storm-toepassing, het dialoog venster Nieuw project configureren, Visual Studio

Nadat u het project hebt gemaakt, hebt u de volgende bestanden nodig:After you've created the project, you should have the following files:

  • Program.cs: de topologie definitie voor uw project.Program.cs: The topology definition for your project. Een standaard topologie die bestaat uit één Spout en één schicht, wordt standaard gemaakt.A default topology that consists of one spout and one bolt is created by default.

  • Spout.cs: een voor beeld Spout die wille keurige getallen afstraalt.Spout.cs: An example spout that emits random numbers.

  • Bolt.cs: een voor beeld van een flits waarmee het aantal getallen wordt bijgehouden dat door de Spout wordt gegenereerd.Bolt.cs: An example bolt that keeps a count of numbers emitted by the spout.

Wanneer u het project maakt, downloadt NuGet het meest recente SCP.net-pakket.When you create the project, NuGet downloads the latest SCP.NET package.

Belangrijk

Het SCP.NET-versie die wordt gebruikt in uw project moet overeenkomen met de Storm-versie die aanwezig zijn op uw HDInsight-cluster.The SCP.NET version used in your project must match the Storm version present on your HDInsight cluster. Gebruik de volgende tabel om te bepalen welke versie u moet gebruiken:Use the following table to determine which version you should use:

HDInsight-versieHDInsight version Apache Storm-versieApache Storm version SCP.NET-versieSCP.NET version Standaard-Mono-versieDefault Mono version
3.33.3 0.10.0.x0.10.0.x 0.10.0.x (alleen voor Windows gebaseerde clusters)0.10.0.x (Windows-based clusters only) N.V.T.NA
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

Zie voor meer informatie over onderdelen die zijn voorzien van HDInsight HDInsight onderdeel versies.For more information on components provided with HDInsight, see HDInsight component versions.

De Spout implementerenImplement the spout

Voeg vervolgens de code toe voor de Spout, die wordt gebruikt om gegevens uit een externe bron te lezen in een topologie.Next, add the code for the spout, which is used to read data in a topology from an external source. Deze Spout verzendt een zin wille keurig in de topologie.This spout randomly emits a sentence into the topology.

  1. Open Spout.cs.Open Spout.cs. De belangrijkste onderdelen voor een Spout zijn:The main components for a spout are:

    • NextTuple: aangeroepen door storm wanneer de Spout nieuwe Tuples mag verzenden.NextTuple: Called by Storm when the spout is allowed to emit new tuples.

    • Ack (alleen transactionele topologie): verwerkt de bevestigingen die zijn gestart door andere onderdelen in de topologie voor Tuples die vanuit de Spout zijn verzonden.Ack (transactional topology only): Handles acknowledgments started by other components in the topology for tuples sent from the spout. Door een tuple te bevestigen, kan de Spout weten dat deze is verwerkt door downstream-onderdelen.Acknowledging a tuple lets the spout know that it was processed successfully by downstream components.

    • Fail (alleen transactionele topologie): verwerkt Tuples die niet worden verwerkt door andere onderdelen in de topologie.Fail (transactional topology only): Handles tuples that are fail-processing other components in the topology. Als u een Fail methode implementeert, kunt u de tuple opnieuw verzenden zodat deze opnieuw kan worden verwerkt.Implementing a Fail method allows you to re-emit the tuple so that it can be processed again.

  2. Vervang de inhoud van de klasse Spout door de volgende tekst:Replace the contents of the Spout class with the following text:

    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
    }
    

De bouten implementerenImplement the bolts

Maak nu twee Storm-schichten in dit voor beeld:Now create two Storm bolts in this example:

  1. Verwijder het bestaande Bolt.cs -bestand uit het project.Delete the existing Bolt.cs file from the project.

  2. Klik in Solution Explorermet de rechter muisknop op het project en selecteer > Nieuw item toevoegen .In Solution Explorer, right-click the project, and select Add > New item. Selecteer in de lijst Storm bouten voer splitter.cs in als de naam.From the list, select Storm Bolt, and enter Splitter.cs as the name. Wijzig in de code van het nieuwe bestand de naam van de naam ruimte in WordCount.In the new file's code, change the namespace name to WordCount. Herhaal dit proces om een tweede Schicht te maken met de naam Counter.cs.Then repeat this process to create a second bolt named Counter.cs.

    • Splitter.cs: implementeert een Schicht waarmee zinnen in afzonderlijke woorden worden gesplitst en waarmee een nieuwe stroom van woorden wordt uitgesplitst.Splitter.cs: Implements a bolt that splits sentences into individual words, and emits a new stream of words.

    • Counter.cs: implementeert een Schicht die elk woord telt, en verzendt een nieuwe stroom van woorden en het aantal voor elk woord.Counter.cs: Implements a bolt that counts each word, and emits a new stream of words and the count for each word.

      Notitie

      Deze schichten lezen en schrijven naar stromen, maar u kunt ook een Schicht gebruiken om te communiceren met bronnen zoals een Data Base of service.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. Open splitter.cs.Open Splitter.cs. Er is slechts één methode standaard: Execute.It has only one method by default: Execute. De Execute methode wordt aangeroepen wanneer de schicht een tuple voor verwerking ontvangt.The Execute method is called when the bolt receives a tuple for processing. Hier kunt u binnenkomende Tuples lezen en verwerken en uitgaande Tuples verzenden.Here, you can read and process incoming tuples, and emit outbound tuples.

  4. Vervang de inhoud van de klasse Splitter door de volgende code: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. Open Counter.csen vervang de inhoud van de klasse door de volgende code: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");
    }
    

De topologie definiërenDefine the topology

Spouts en schichten worden gerangschikt in een grafiek, waarmee wordt gedefinieerd hoe de gegevens stromen tussen onderdelen.Spouts and bolts are arranged in a graph, which defines how the data flows between components. Voor deze topologie is de grafiek als volgt:For this topology, the graph is as follows:

Schema voor spout-en Schicht-onderdelen, Storm-topologie

De Spout verzendt zinnen die worden gedistribueerd naar instanties van de Splits schicht.The spout emits sentences that are distributed to instances of the Splitter bolt. De Splits Schicht breekt de zinnen op in woorden, die worden gedistribueerd naar de Counter-bout.The Splitter bolt breaks the sentences into words, which are distributed to the Counter bolt.

Omdat het item exemplaar lokaal het aantal woorden bevat, moet u ervoor zorgen dat specifieke woorden naar hetzelfde exemplaar van de counter-teller stromen.Because the Counter instance holds the word count locally, you want to make sure that specific words flow to the same Counter bolt instance. Elk exemplaar houdt specifieke woorden bij.Each instance keeps track of specific words. Omdat de Splits Schicht geen status heeft, is het niet belang rijk welk exemplaar van de Splitser de zin niet ontvangt.Since the Splitter bolt maintains no state, it really doesn't matter which instance of the splitter receives which sentence.

Open Program.cs.Open Program.cs. De belang rijke methode is GetTopologyBuilder, die wordt gebruikt voor het definiëren van de topologie die wordt verzonden naar Storm.The important method is GetTopologyBuilder, which is used to define the topology that is submitted to Storm. Vervang de inhoud van GetTopologyBuilder door de volgende code om de topologie te implementeren die eerder is beschreven: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;

De topologie verzendenSubmit the topology

U bent nu klaar om de topologie naar uw HDInsight-cluster te verzenden.You are now ready to submit the topology to your HDInsight cluster.

  1. Klik in Solution Explorermet de rechter muisknop op het project en kies verzenden naar Storm op HDInsight.In Solution Explorer, right-click the project, and choose Submit to Storm on HDInsight.

    Notitie

    Voer de referenties voor uw Azure-abonnement in als u hierom wordt gevraagd.If prompted, enter the credentials for your Azure subscription. Als u meer dan één abonnement hebt, meldt u zich aan bij de versie met uw Storm op HDInsight-cluster.If you have more than one subscription, sign in to the one that contains your Storm on HDInsight cluster.

  2. Kies in het dialoog venster topologie indienen in de vervolg keuzelijst Storm-cluster het Storm-cluster op HDInsight en selecteer vervolgens verzenden.In the Submit Topology dialog box, under the Storm Cluster drop-down list, choose your Storm on HDInsight cluster, and then select Submit. U kunt controleren of de verzen ding is geslaagd door het deel venster uitvoer weer te geven.You can check whether the submission is successful by viewing the Output pane.

    Wanneer de topologie is verzonden, moet het weergave venster Storm-topologieën voor het cluster worden weer gegeven.When the topology has been successfully submitted, the Storm Topologies View window for the cluster should appear. Kies de WordCount -topologie in de lijst om informatie over de actieve topologie weer te geven.Choose the WordCount topology from the list to view information about the running topology.

    Venster Storm-topologie weergave, HDInsight-cluster, Visual Studio

    Notitie

    U kunt Storm- topologieën ook bekijken vanuit Server Explorer.You can also view Storm Topologies from Server Explorer. Vouw Azure > HDInsightuit, klik met de rechter muisknop op een storm op HDInsight-cluster en kies vervolgens Storm-topologieën weer geven.Expand Azure > HDInsight, right-click a Storm on HDInsight cluster, and then choose View Storm Topologies.

    Als u informatie wilt weer geven over de onderdelen in de topologie, selecteert u een onderdeel in het diagram.To view information about the components in the topology, select a component in the diagram.

  3. Selecteer in het gedeelte topologie samenvatting de optie Kill om de topologie te stoppen.In the Topology Summary section, select Kill to stop the topology.

    Notitie

    Storm-topologieën blijven actief totdat ze worden gedeactiveerd of het cluster wordt verwijderd.Storm topologies continue to run until they are deactivated, or the cluster is deleted.

Transactionele topologieTransactional topology

De vorige topologie is niet transactioneel.The previous topology is non-transactional. De onderdelen in de topologie implementeren geen functionaliteit om berichten opnieuw af te spelen.The components in the topology don't implement functionality to replaying messages. Voor een voor beeld van een transactionele topologie maakt u een project en selecteert u Storm sample als het project type.For an example of a transactional topology, create a project and select Storm Sample as the project type.

Transactionele topologieën implementeren het volgende om het opnieuw afspelen van gegevens te ondersteunen:Transactional topologies implement the following to support replay of data:

  • Meta gegevens in cache opslaan: de Spout moet meta gegevens over de verzonden gegevens opslaan, zodat de gegevens kunnen worden opgehaald en opnieuw worden verzonden als er een fout optreedt.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. Omdat de gegevens die door het voor beeld worden verzonden, klein zijn, worden de onbewerkte gegevens voor elke tuple opgeslagen in een woorden lijst voor opnieuw afspelen.Because the data emitted by the sample is small, the raw data for each tuple is stored in a dictionary for replay.

  • ACK: elke Schicht in de topologie kan this.ctx.Ack(tuple) aanroepen om te bevestigen dat een tuple is verwerkt.Ack: Each bolt in the topology can call this.ctx.Ack(tuple) to acknowledge that it has successfully processed a tuple. Wanneer alle schichten de tuple hebben bevestigd, wordt de Ack methode van de Spout aangeroepen.When all bolts have acknowledged the tuple, the Ack method of the spout is invoked. Met de methode Ack kan de Spout gegevens verwijderen die in de cache zijn opgeslagen voor opnieuw afspelen.The Ack method allows the spout to remove data that was cached for replay.

  • Mislukt: elke schicht kan this.ctx.Fail(tuple) aanroepen om aan te geven dat de verwerking voor een tuple is mislukt.Fail: Each bolt can call this.ctx.Fail(tuple) to indicate that processing has failed for a tuple. De fout wordt door gegeven aan de Fail methode van de Spout, waarbij de tuple opnieuw kan worden afgespeeld met behulp van meta gegevens in de cache.The failure propagates to the Fail method of the spout, where the tuple can be replayed by using cached metadata.

  • Reeks-id: wanneer een tuple wordt verzonden, kan een unieke reeks-id worden opgegeven.Sequence ID: When emitting a tuple, a unique sequence ID can be specified. Met deze waarde wordt de tuple geïdentificeerd voor de verwerking van herhalingen (Ack en Fail).This value identifies the tuple for replay (Ack and Fail) processing. De spout in het Storm-voorbeeld project gebruikt bijvoorbeeld de volgende methode aanroep bij het verzenden van gegevens:For example, the spout in the Storm Sample project uses the following method call when emitting data:

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

    Met deze code wordt een tuple verzonden die een zin bevat voor de standaard stroom, met de reeks-ID-waarde in lastSeqId.This code emits a tuple that contains a sentence to the default stream, with the sequence ID value contained in lastSeqId. Voor dit voor beeld wordt lastSeqId verhoogd voor elke tupel die wordt verzonden.For this example, lastSeqId is incremented for every tuple emitted.

Zoals gedemonstreerd in het Storm-voorbeeld project, of een onderdeel transactioneel kan worden ingesteld tijdens runtime, op basis van de configuratie.As demonstrated in the Storm Sample project, whether a component is transactional can be set at runtime, based on configuration.

Hybride topologie met C# en JavaHybrid topology with C# and Java

U kunt ook Data Lake-hulpprogram ma's voor Visual Studio gebruiken om hybride topologieën te maken, C# waarbij sommige onderdelen zijn en andere Java zijn.You can also use Data Lake tools for Visual Studio to create hybrid topologies, where some components are C# and others are Java.

Voor een voor beeld van een hybride topologie maakt u een project en selecteert u Storm hybride voor beeld.For an example of a hybrid topology, create a project and select Storm Hybrid Sample. In dit voorbeeld type worden de volgende concepten gedemonstreerd:This sample type demonstrates the following concepts:

  • Java Spout en C# bout: gedefinieerd in de klasse HybridTopology_javaSpout_csharpBolt.Java spout and C# bolt: Defined in the HybridTopology_javaSpout_csharpBolt class.

    Er wordt een transactionele versie gedefinieerd in de klasse HybridTopologyTx_javaSpout_csharpBolt.A transactional version is defined in the HybridTopologyTx_javaSpout_csharpBolt class.

  • Spout en Java-flits: gedefinieerd in de klasse HybridTopology_csharpSpout_javaBolt. C#C# spout and Java bolt: Defined in the HybridTopology_csharpSpout_javaBolt class.

    Er wordt een transactionele versie gedefinieerd in de klasse HybridTopologyTx_csharpSpout_javaBolt.A transactional version is defined in the HybridTopologyTx_csharpSpout_javaBolt class.

    Notitie

    In deze versie wordt ook gedemonstreerd hoe u clojure code uit een tekst bestand kunt gebruiken als Java-onderdeel.This version also demonstrates how to use Clojure code from a text file as a Java component.

Als u wilt overschakelen naar de topologie die wordt gebruikt wanneer het project wordt verzonden, verplaatst u de [Active(true)]-instructie naar de topologie die u wilt gebruiken, voordat u deze naar het cluster verzendt.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.

Notitie

Alle Java-bestanden die zijn vereist, worden in de map JavaDependency als onderdeel van dit project verstrekt.All the Java files that are required are provided as part of this project in the JavaDependency folder.

Houd rekening met het volgende bij het maken en verzenden van een hybride topologie:Consider the following when you're creating and submitting a hybrid topology:

  • Gebruik JavaComponentConstructor om een exemplaar van de Java-klasse te maken voor een Spout of bout.Use JavaComponentConstructor to create an instance of the Java class for a spout or bolt.

  • Gebruik microsoft.scp.storm.multilang.CustomizedInteropJSONSerializer om gegevens van Java-objecten te serialiseren naar of uit een Java-object naar JSON.Use microsoft.scp.storm.multilang.CustomizedInteropJSONSerializer to serialize data into or out of Java components from Java objects to JSON.

  • Wanneer u de topologie verzendt naar de-server, moet u de optie extra configuraties gebruiken om de Java-bestands padenop te geven.When submitting the topology to the server, you must use the Additional configurations option to specify the Java File paths. Het opgegeven pad moet de map zijn met het JAR-bestand dat uw Java-klassen bevat.The path specified should be the directory that has the JAR files containing your Java classes.

Azure Event HubsAzure Event Hubs

SCP.NET versie 0.9.4.203 introduceert een nieuwe klasse en methode voor het werken met de Event hub Spout (een Java-Spout die van Event Hubs wordt gelezen).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). Wanneer u een topologie maakt die gebruikmaakt van een event hub-Spout (bijvoorbeeld met behulp van de voorbeeld sjabloon Storm EventHub Reader ), gebruikt u de volgende api's:When you create a topology that uses an Event Hub spout (for example, using the Storm EventHub Reader Sample template), use the following APIs:

  • EventHubSpoutConfig klasse: maakt een object dat de configuratie voor het onderdeel Spout bevat.EventHubSpoutConfig class: Creates an object that contains the configuration for the spout component.

  • TopologyBuilder.SetEventHubSpout methode: voegt het onderdeel Event hub Spout toe aan de topologie.TopologyBuilder.SetEventHubSpout method: Adds the Event Hub spout component to the topology.

Notitie

U moet nog steeds de CustomizedInteropJSONSerializer gebruiken om gegevens te serialiseren die door de Spout worden geproduceerd.You must still use the CustomizedInteropJSONSerializer to serialize data produced by the spout.

ConfigurationManager gebruikenUse ConfigurationManager

Gebruik ConfigurationManager niet om configuratie waarden van de onderdelen bout en Spout op te halen.Don't use ConfigurationManager to retrieve configuration values from bolt and spout components. Dit kan een null-wijzer uitzondering veroorzaken.Doing so can cause a null pointer exception. In plaats daarvan geeft u de configuratie voor uw project door in de Storm-topologie als een sleutel-en een waardepaar in de topologie context.Instead, pass the configuration for your project into the Storm topology as a key and value pair in the topology context. Elk onderdeel dat afhankelijk is van configuratie waarden, moet deze ophalen uit de context tijdens de initialisatie.Each component that relies on configuration values must retrieve them from the context during initialization.

De volgende code laat zien hoe u deze waarden ophaalt: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;
    }
    ...
}

Als u een Get methode gebruikt om een exemplaar van uw onderdeel te retour neren, moet u ervoor zorgen dat de para meters Context en Dictionary<string, Object> worden door gegeven aan de constructor.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. Het volgende voor beeld is een basis Get methode waarmee deze waarden correct worden door gegeven: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);
}

SCP.NET bijwerkenHow to update SCP.NET

Recente releases van de SCP.NET-ondersteunings pakket upgrade via NuGet.Recent releases of SCP.NET support package upgrade through NuGet. Wanneer een nieuwe update beschikbaar is, ontvangt u een upgrade melding.When a new update is available, you receive an upgrade notification. Voer de volgende stappen uit om hand matig te controleren op een upgrade:To manually check for an upgrade, follow these steps:

  1. Klik in Solution Explorer met de rechtermuisknop op het project en klik op NuGet-pakketten beheren.In Solution Explorer, right-click the project, and select Manage NuGet Packages.

  2. Selecteer updatesin Package Manager.From the package manager, select Updates. Als er een update voor het SCP.NET-ondersteunings pakket beschikbaar is, wordt dit weer gegeven.If an update for the SCP.NET support package is available, it's listed. Selecteer Update voor het pakket en selecteer vervolgens in het dialoog venster voor beeld van wijzigingen OK om het te installeren.Select Update for the package, and then in the Preview Changes dialog box, select OK to install it.

Belangrijk

Als uw project is gemaakt met een eerdere versie van SCP.NET die geen NuGet gebruikt, moet u de volgende stappen uitvoeren om naar een nieuwere versie bij te werken: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. Klik in Solution Explorer met de rechtermuisknop op het project en klik op NuGet-pakketten beheren.In Solution Explorer, right-click the project, and select Manage NuGet Packages.
  2. Zoek met het Zoek veld naar en voeg Microsoft.SCP.Net.SDK toe aan het project.Using the Search field, search for, and then add, Microsoft.SCP.Net.SDK to the project.

Veelvoorkomende problemen met topologieën oplossenTroubleshoot common issues with topologies

Null-aanwijzer uitzonderingenNull pointer exceptions

Wanneer u een C# topologie gebruikt met een HDInsight-cluster op basis van Linux, kunnen de onderdelen van de Spout die ConfigurationManager gebruiken voor het lezen van de configuratie-instellingen tijdens runtime, null-pointer-uitzonde ringen retour neren.When you're 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.

De configuratie voor uw project wordt door gegeven aan de Storm-topologie als een sleutel-en waarde-paar in de topologie context.The configuration for your project is passed into the Storm topology as a key and value pair in the topology context. Het kan worden opgehaald uit het Dictionary-object dat wordt door gegeven aan uw onderdelen wanneer deze zijn geïnitialiseerd.It can be retrieved from the dictionary object that's passed to your components when they're initialized.

Zie de sectie ConfigurationManager gebruiken van dit document voor meer informatie.For more information, see the Use ConfigurationManager section of this document.

System. TypeLoadExceptionSystem.TypeLoadException

Wanneer u een C# topologie met een HDInsight-cluster op basis van Linux gebruikt, kan de volgende fout optreden:When you're using a C# topology with a Linux-based HDInsight cluster, you may come across the following error:

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

Deze fout treedt op wanneer u een binair element gebruikt dat niet compatibel is met de versie van .NET die door mono wordt ondersteund.This error occurs when you use a binary that isn't compatible with the version of .NET that Mono supports.

Voor HDInsight-clusters op basis van Linux moet u ervoor zorgen dat uw project binaire bestanden gebruikt die zijn gecompileerd voor .NET 4,5.For Linux-based HDInsight clusters, make sure that your project uses binaries compiled for .NET 4.5.

Een topologie lokaal testenTest a topology locally

Hoewel het eenvoudig is om een topologie te implementeren in een cluster, moet u in sommige gevallen een topologie lokaal testen.Although it's easy to deploy a topology to a cluster, in some cases, you may need to test a topology locally. Gebruik de volgende stappen om de voorbeeld topologie in dit artikel lokaal in uw ontwikkel omgeving uit te voeren en te testen.Use the following steps to run and test the example topology in this article locally in your development environment.

Waarschuwing

Lokale tests werken alleen voor basis- C#,-alleen-topologieën.Local testing only works for basic, C#-only topologies. U kunt geen lokale tests gebruiken voor hybride topologieën of topologieën die gebruikmaken van meerdere streams.You cannot use local testing for hybrid topologies or topologies that use multiple streams.

  1. Klik in Solution Explorermet de rechter muisknop op het project en selecteer Eigenschappen.In Solution Explorer, right-click the project, and select Properties. In de project eigenschappen.In the project properties. Wijzig vervolgens het uitvoer type in console toepassing.Then change the Output type to Console Application.

    HDInsight Storm-toepassing, project eigenschappen, uitvoer type

    Notitie

    Vergeet niet om het uitvoer type terug te wijzigen in Class Library voordat u de topologie op een cluster implementeert.Remember to change the Output type back to Class Library before you deploy the topology to a cluster.

  2. Klik in Solution Explorermet de rechter muisknop op het project en selecteer vervolgens > Nieuw item toevoegen .In Solution Explorer, right-click the project, and then select Add > New Item. Selecteer klasseen voer LocalTest.cs in als de naam van de klasse.Select Class, and enter LocalTest.cs as the class name. Selecteer ten slotte toevoegen.Finally, select Add.

  3. Open LocalTest.csen voeg bovenaan de volgende using-instructie toe:Open LocalTest.cs, and add the following using statement at the top:

    using Microsoft.SCP;
    
  4. Gebruik de volgende code als de inhoud van de klasse LocalTest: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
    }
    

    Neem even de tijd om de opmerkingen van de code te lezen.Take a moment to read through the code comments. Deze code maakt gebruik van LocalContext om de onderdelen in de ontwikkel omgeving uit te voeren.This code uses LocalContext to run the components in the development environment. De gegevens stroom tussen onderdelen wordt persistent gemaakt naar tekst bestanden op het lokale station.It persists the data stream between components to text files on the local drive.

  5. Open Program.csen voeg de volgende code toe aan de Main methode:Open Program.cs, and add the following code 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. Sla de wijzigingen op en selecteer vervolgens F5 of kies fout opsporing > fout opsporing starten om het project te starten.Save the changes, and then select F5 or choose Debug > Start Debugging to start the project. Er moet een console venster worden weer gegeven en de status van het logboek registreren als de tests worden uitgevoerd.A console window should appear, and log status as the tests progress. Wanneer Tests finished wordt weer gegeven, selecteert u een wille keurige toets om het venster te sluiten.When Tests finished appears, select any key to close the window.

  7. Gebruik Windows Verkenner om de map te zoeken die het project bevat.Use Windows Explorer to locate the directory that contains your project. (Bijvoorbeeld: C:\gebruikers\<your_user_name >\source\opslag plaatsen\WordCount\WordCount.) Open vervolgens binin deze map en selecteer vervolgens fout opsporing.(For example: C:\Users\<your_user_name>\source\repos\WordCount\WordCount.) Then in this directory, open Bin, and then select Debug. U moet de tekst bestanden zien die zijn gemaakt toen de tests werden uitgevoerd: zinnen. txt, Counter. txten splitter. txt.You should see the text files that were produced when the tests ran: sentences.txt, counter.txt, and splitter.txt. Open elk tekst bestand en controleer de gegevens.Open each text file and inspect the data.

    Notitie

    Teken reeks gegevens blijven bestaan als een matrix met decimale waarden in deze bestanden.String data persists as an array of decimal values in these files. [[97,103,111]] in het bestand splitter. txt bijvoorbeeld vertegenwoordigt het woord geleden.For example, [[97,103,111]] in the splitter.txt file represents the word ago.

Notitie

Zorg ervoor dat u het project type weer instelt op klassen bibliotheek in de project eigenschappen voordat u implementeert in een storm op HDInsight-cluster.Be sure to set the Project type back to Class Library in the project properties before deploying to a Storm on HDInsight cluster.

Logboek gegevensLog information

U kunt eenvoudig gegevens uit uw topologie onderdelen vastleggen met behulp van Context.Logger.You can easily log information from your topology components by using Context.Logger. Met de volgende opdracht wordt bijvoorbeeld een informatie logboek vermelding gemaakt:For example, the following command creates an informational log entry:

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

Geregistreerde gegevens kunnen worden bekeken in het logboekvan de Hadoop-service, dat is te vinden in Server Explorer.Logged information can be viewed from the Hadoop Service Log, which is found in Server Explorer. Vouw de vermelding voor uw Storm in HDInsight-cluster uit en vouw vervolgens het Hadoop-service logboekuit.Expand the entry for your Storm on HDInsight cluster, and then expand Hadoop Service Log. Selecteer ten slotte het logboek bestand dat u wilt weer geven.Finally, select the log file to view.

Notitie

De logboeken worden opgeslagen in het Azure-opslag account dat door uw cluster wordt gebruikt.The logs are stored in the Azure storage account that is used by your cluster. Als u de logboeken in Visual Studio wilt weer geven, moet u zich aanmelden bij het Azure-abonnement dat eigenaar is van het opslag account.To view the logs in Visual Studio, you must sign in to the Azure subscription that owns the storage account.

Fout gegevens weer gevenView error information

Voer de volgende stappen uit om fouten te bekijken die zich hebben voorgedaan in een actieve topologie:To view errors that have occurred in a running topology, use the following steps:

  1. Klik vanuit Server Explorermet de rechter muisknop op de storm in HDInsight-cluster en selecteer Storm-topologieën weer geven.From Server Explorer, right-click the Storm on HDInsight cluster, and select View Storm Topologies.

    Voor de Spout en- boutenbevat de laatste fout kolom informatie over de laatste fout.For the Spout and Bolts, the Last Error column contains information on the last error.

  2. Selecteer de Spout-id of de Schicht-id voor het onderdeel waarvoor een fout wordt weer gegeven.Select the Spout ID or Bolt ID for the component that has an error listed. Op de pagina Details wordt aanvullende fout informatie weer gegeven in de sectie fouten onder aan de pagina.The details page displays additional error information in the Errors section at the bottom of the page.

  3. Als u meer informatie wilt verkrijgen, selecteert u een poort in het gedeelte uitvoerendeers van de pagina om het Storm-werk logboek voor de laatste paar minuten te bekijken.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.

Fouten bij het verzenden van topologieënErrors submitting topologies

Als er fouten optreden bij het verzenden van een topologie naar HDInsight, kunt u Logboeken vinden voor de Server onderdelen die de verzen ding van de topologie op uw HDInsight-cluster verwerken.If you come across errors submitting a topology to HDInsight, you can find logs for the server-side components that handle topology submission on your HDInsight cluster. Als u deze logboeken wilt downloaden, gebruikt u de volgende opdracht vanaf een opdracht regel:To download these logs, use the following command from a command line:

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

Vervang sshuser door het SSH-gebruikers account voor het cluster.Replace sshuser with the SSH user account for the cluster. Vervang clustername door de naam van het HDInsight-cluster.Replace clustername with the name of the HDInsight cluster. Zie SSH gebruiken met hdinsightvoor meer informatie over het gebruik van scp en ssh met hdinsight.For more information on using scp and ssh with HDInsight, see Use SSH with HDInsight.

Inzendingen kunnen om verschillende redenen mislukken:Submissions can fail for multiple reasons:

  • De JDK is niet geïnstalleerd of bevindt zich niet in het pad.The JDK isn't installed or isn't in the path.
  • Vereiste Java-afhankelijkheden zijn niet opgenomen in de verzen ding.Required Java dependencies aren't included in the submission.
  • Afhankelijkheden zijn incompatibel.Dependencies are incompatible.
  • De topologie namen zijn gedupliceerd.Topology names are duplicated.

Als het logboek bestand hdinsight-scpwebapi. out een FileNotFoundExceptionbevat, kan de uitzonde ring worden veroorzaakt door de volgende voor waarden:If the hdinsight-scpwebapi.out log file contains a FileNotFoundException, the exception might be caused by the following conditions:

  • De JDK bevindt zich niet in het pad van de ontwikkel omgeving.The JDK isn't in the path on the development environment. Controleer of de JDK in de ontwikkel omgeving is geïnstalleerd en of %JAVA_HOME%/bin zich in het pad bevindt.Verify that the JDK is installed in the development environment, and that %JAVA_HOME%/bin is in the path.
  • Er ontbreekt een Java-afhankelijkheid.You're missing a Java dependency. Zorg ervoor dat u alle vereiste. jar-bestanden opneemt als onderdeel van de verzen ding.Make sure you're including any required .jar files as part of the submission.

Volgende stappenNext steps

Zie gebeurtenissen van Azure Event hubs verwerken met Storm op HDInsightvoor een voor beeld van het verwerken van gegevens uit Event hubs.For an example of processing data from Event Hubs, see Process events from Azure Event Hubs with Storm on HDInsight.

Zie C# Storm voor beeldvoor C# een voor beeld van een topologie waarmee gegevens van streams in meerdere streams worden gesplitst.For an example of a C# topology that splits stream data into multiple streams, see C# Storm example.

Zie github voor meer informatie over C# het maken van topologieën.To discover more information about creating C# topologies, see GitHub.

Raadpleeg de volgende documenten voor meer manieren om te werken met HDInsight en meer Storm over HDInsight-voor beelden:For more ways to work with HDInsight and more Storm on HDInsight samples, see the following documents:

Micro soft SCP.NETMicrosoft SCP.NET

Apache Storm op HDInsightApache Storm on HDInsight

Apache Hadoop op HDInsightApache Hadoop on HDInsight

Apache HBase in HDInsightApache HBase on HDInsight