C#-topologieën ontwikkelen voor Apache Storm met behulp van de Data Lake-tools voor Visual StudioDevelop C# topologies for Apache Storm by using the Data Lake tools for Visual Studio

Meer informatie over het maken van een C# Apache Storm-topologie met behulp van de Azure Data Lake (Apache Hadoop)-hulpprogramma's 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 begeleidt bij het proces van het maken van een Storm-project in Visual Studio, lokaal te testen en u deze implementeert in een Apache Storm op 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 maken die gebruik van C# en Java-onderdelen.You also learn how to create hybrid topologies that use C# and Java components.

Notitie

Terwijl de stappen in dit document, is afhankelijk van een Windows-ontwikkelomgeving met Visual Studio, kan de gecompileerde project worden verstuurd naar een Linux- of Windows-gebaseerde 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. Op basis van Linux-clusters die zijn gemaakt na 28 oktober 2016 vallen, ondersteunen alleen SCP.NET-topologieën.Only Linux-based clusters created after October 28, 2016, support SCP.NET topologies.

Voor het gebruik van een C#-topologie met een cluster op basis van Linux, moet u het Microsoft.scp.NET.SDK dat NuGet-pakket gebruikt door uw project naar versie 0.10.0.6 of hoger bijwerken.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 Windows gebaseerde HDInsight)(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. Controleer Mono-compatibiliteit voor mogelijke compatibiliteitsproblemen.Check Mono compatibility for potential incompatibilities.

Visual Studio installerenInstall Visual Studio

U kunt C#-topologieën ontwikkelen met SCP.NET met behulp van een van de volgende versies van Visual Studio:You can develop C# topologies with SCP.NET by using one of the following versions of Visual Studio:

Installatie van Data Lake tools voor Visual StudioInstall Data Lake tools for Visual Studio

Volg de stappen in voor het installeren van Data Lake tools voor Visual Studio, aan de slag met Data Lake tools 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 hebt ingediend, 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 voor het maken van deze zip-bestanden omdat het gebruikmaakt van een indeling die meer compatibel zijn met op basis van Linux-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 op uw ontwikkelomgeving.Install the Java Developer Kit (JDK) 7 or later on your development environment. Krijgt u de Oracle-JDK van Oracle.You can get the Oracle JDK from Oracle. U kunt ook andere Java-distributies.You can also use other Java distributions.

  2. De JAVA_HOME omgevingsvariabele moet verwijzen naar de map met Java.The JAVA_HOME environment variable must point to the directory that contains Java.

  3. De PATH omgevingsvariabele moet bevatten de %JAVA_HOME%\bin directory.The PATH environment variable must include the %JAVA_HOME%\bin directory.

U kunt de volgende C#-consoletoepassing om te controleren of Java en de JDK correct zijn geïnstalleerd: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.");
           }
       }  
   }
}

Apache Storm-sjablonenApache Storm templates

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

ProjecttypeProject type Ziet uDemonstrates
Storm-toepassingStorm Application Een lege Storm-topologie-project.An empty Storm topology project.
Storm Azure SQL Writer voorbeeldStorm Azure SQL Writer Sample Over het schrijven naar Azure SQL Database.How to write to Azure SQL Database.
Voorbeeld van storm Azure Cosmos DB-lezerStorm Azure Cosmos DB Reader Sample Klik hier voor meer informatie over het lezen van Azure Cosmos DB.How to read from Azure Cosmos DB.
Voorbeeld van de schrijver storm Azure Cosmos DBStorm Azure Cosmos DB Writer Sample Het schrijven naar Azure Cosmos DB.How to write to Azure Cosmos DB.
Voorbeeld van storm EventHub-lezerStorm EventHub Reader Sample Klik hier voor meer informatie over het lezen uit Azure Event Hubs.How to read from Azure Event Hubs.
Voorbeeld van storm EventHub-schrijverStorm EventHub Writer Sample Over het schrijven naar Azure Event Hubs.How to write to Azure Event Hubs.
Storm-lezer van de HBase-voorbeeldStorm HBase Reader Sample Klik hier voor meer informatie over het lezen van HBase op HDInsight-clusters.How to read from HBase on HDInsight clusters.
Storm-schrijver van de HBase-voorbeeldStorm HBase Writer Sample Het schrijven naar HBase op HDInsight-clusters.How to write to HBase on HDInsight clusters.
Voorbeeld van de storm-hybrideStorm Hybrid Sample Het gebruik van een Java-component.How to use a Java component.
Storm voorbeeldStorm Sample Eenvoudige topologie voor aantal 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 worden gebruikt door de sjablonen zijn mogelijk niet compatibel is met Mono.NuGet packages used by the templates may not be compatible with Mono. Controleer de Mono-compatibiliteit document en gebruik de .NET draagbaarheid Analyzer om potentiële problemen te identificeren.Check the Mono compatibility document and use the .NET Portability Analyzer to identify potential problems.

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

Opmerkingen bij de Apache HBase-sjablonenApache HBase templates notes

De HBase REST API, niet de HBase Java API de HBase-lees- en schrijftoegang sjablonen gebruiken om te communiceren met een HBase op 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.

Opmerkingen bij de EventHub-sjablonenEventHub templates notes

Belangrijk

Het onderdeel op Java gebaseerde EventHub spout van de sjabloon Event hub-lezer werkt mogelijk niet met Storm op 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 voor een voorbeeldtopologie die gebruikmaakt van dit onderdeel en werkt met Storm op HDInsight 3.5, GitHub.For an example topology that uses this component and works with Storm on HDInsight 3.5, see GitHub.

Maak een C#-topologieCreate a C# topology

  1. Open Visual Studio, selecteer bestand > nieuw, en selecteer vervolgens Project.Open Visual Studio, select File > New, and then select Project.

  2. Uit de nieuw Project venster, vouw geïnstalleerde > sjablonen, en selecteer Azure Data Lake.From the New Project window, expand Installed > Templates, and select Azure Data Lake. Selecteer in de lijst met sjablonen Storm-toepassing.From the list of templates, select Storm Application. Aan de onderkant van het scherm, voer WordCount als de naam van de toepassing.At the bottom of the screen, enter WordCount as the name of the application.

    Schermopname van nieuw Project-venster

  3. Nadat u het project hebt gemaakt, hebt u de volgende bestanden:After you have created the project, you should have the following files:

    • Program.cs: Dit bestand definieert de topologie voor uw project.Program.cs: This file defines the topology for your project. Een standaard-topologie die uit één spout en één bolt bestaat wordt standaard gemaakt.A default topology that consists of one spout and one bolt is created by default.

    • Spout.cs: Een voorbeeld-spout die willekeurige getallen verzendt.Spout.cs: An example spout that emits random numbers.

    • Bolt.cs: Een voorbeeld-bolt die een aantal van de getallen die worden gegenereerd door de spout houdt.Bolt.cs: An example bolt that keeps a count of numbers emitted by the spout.

      Wanneer u het project maakt, NuGet de meest recente downloads 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

  1. Open Spout.cs.Open Spout.cs. Spouts worden gebruikt voor het lezen van gegevens in een topologie van een externe bron.Spouts are used to read data in a topology from an external source. De belangrijkste onderdelen van een spout zijn:The main components for a spout are:

    • NextTuple: Wordt aangeroepen door Storm wanneer de spout is toegestaan om te verzenden van nieuwe tuples.NextTuple: Called by Storm when the spout is allowed to emit new tuples.

    • ACK (alleen voor transactionele topologie): Bevestigingen gestart door andere onderdelen in de topologie voor verzonden vanaf de spout tuples worden verwerkt.Ack (transactional topology only): Handles acknowledgements initiated by other components in the topology for tuples sent from the spout. Een tuple zijn bevestigd, kunt de spout weten dat het door downstream-onderdelen met succes is verwerkt.Acknowledging a tuple lets the spout know that it was processed successfully by downstream components.

    • Mislukken (alleen voor transactionele topologie): Tuples die zijn mislukt-verwerking van andere onderdelen in de topologie worden verwerkt.Fail (transactional topology only): Handles tuples that are fail-processing other components in the topology. Implementatie van een methode is mislukt, kunt u de tuple opnieuw te 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 Spout klasse met de volgende tekst: Deze spout verzendt willekeurig een zin in de 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
    }
    

De bolts implementerenImplement the bolts

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

  2. In Solution Explorer, met de rechtermuisknop op het project en selecteer toevoegen > nieuw item.In Solution Explorer, right-click the project, and select Add > New item. Selecteer in de lijst Storm Bolt, en voer Splitter.cs als de naam.From the list, select Storm Bolt, and enter Splitter.cs as the name. Herhaal dit proces voor het maken van een tweede bolt met de naam Counter.cs.Repeat this process to create a second bolt named Counter.cs.

    • Splitter.cs: Implementeert een bolt die zinnen splitst in afzonderlijke woorden en verzendt een nieuwe reeks woorden.Splitter.cs: Implements a bolt that splits sentences into individual words, and emits a new stream of words.

    • Counter.cs: Implementeert een bolt die elk woord geteld en verzendt een nieuwe gegevensstroom 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 bolts lezen en schrijven naar stromen, maar u kunt ook een bolt gebruiken om te communiceren met bronnen, zoals een database of de 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 wordt slechts één methode standaard: Execute.It has only one method by default: Execute. De Execute-methode wordt aangeroepen wanneer de bolt een tuple voor verwerking ontvangt.The Execute method is called when the bolt receives a tuple for processing. U kunt hier lezen en verwerken van inkomende tuples en verzenden van uitgaande tuples.Here, you can read and process incoming tuples, and emit outbound tuples.

  4. Vervang de inhoud van de splitsen klasse met 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.cs, en 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 bolts zijn gerangschikt in een grafiek, waarmee wordt gedefinieerd hoe gegevens stromen tussen de onderdelen.Spouts and bolts are arranged in a graph, which defines how the data flows between components. Voor deze topologie wordt is de grafiek als volgt uit:For this topology, the graph is as follows:

Diagram van hoe onderdelen zijn gerangschikt

Zinnen zijn die afkomstig zijn van de spout en worden gedistribueerd naar exemplaren van de bolt splitsen.Sentences are emitted from the spout, and are distributed to instances of the Splitter bolt. De zinnen de bolt splitsen opgesplitst in woorden die worden gedistribueerd naar de teller-bolt.The Splitter bolt breaks the sentences into words, which are distributed to the Counter bolt.

Omdat het aantal woorden lokaal bewaard in het exemplaar van prestatiemeteritem, wilt u om ervoor te zorgen dat specifieke woorden naar de hetzelfde exemplaar van het prestatiemeteritem-bolt overgebracht.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. Elk exemplaar houdt van specifieke woorden.Each instance keeps track of specific words. Omdat er geen status wordt bijgehouden door de bolt splitsen, het echt maakt niet uit welk exemplaar van de splitser ontvangt welke zin.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 belangrijke 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 voor het implementeren van de topologie die eerder zijn 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;

Verzenden van de topologieSubmit the topology

  1. In Solution Explorer, met de rechtermuisknop op het project en selecteer indienen bij Storm op HDInsight.In Solution Explorer, right-click the project, and select Submit to Storm on HDInsight.

    Notitie

    Als u wordt gevraagd, voert u de referenties voor uw Azure-abonnement.If prompted, enter the credentials for your Azure subscription. Als u meer dan één abonnement hebt, moet u zich aanmelden bij de optie die uw Storm op HDInsight-cluster bevat.If you have more than one subscription, sign in to the one that contains your Storm on HDInsight cluster.

  2. Selecteer uw Storm op HDInsight-cluster op basis van de Storm-Cluster vervolgkeuzelijst en selecteer vervolgens indienen.Select your Storm on HDInsight cluster from the Storm Cluster drop-down list, and then select Submit. U kunt controleren als het verzenden voltooid met behulp van is de uitvoer venster.You can monitor if the submission is successful by using the Output window.

  3. Wanneer de topologie is ingediend, de Storm-topologieën voor het cluster moet worden weergegeven.When the topology has been successfully submitted, the Storm Topologies for the cluster should appear. Selecteer de WordCount topologie in de lijst om informatie over de actieve topologie weer te geven.Select the WordCount topology from the list to view information about the running topology.

    Notitie

    U kunt ook weergeven Storm-topologieën van Server Explorer.You can also view Storm Topologies from Server Explorer. Vouw Azure > HDInsight, met de rechtermuisknop op een Storm op HDInsight-cluster en selecteer vervolgens Zobrazit topologie Stormu.Expand Azure > HDInsight, right-click a Storm on HDInsight cluster, and then select View Storm Topologies.

    Als u informatie over de onderdelen in de topologie, dubbelklikt u op het onderdeel in het diagram.To view information about the components in the topology, double-click the component in the diagram.

  4. Uit de Topology Summary weergeven, klikt u op Kill stoppen van de topologie.From the Topology Summary view, click Kill to stop the topology.

    Notitie

    Storm-topologieën verder worden uitgevoerd tot ze zijn uitgeschakeld 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-transactionele.The previous topology is non-transactional. De onderdelen in de topologie alle niet functionaliteit voor het spelen van berichten.The components in the topology do not implement functionality to replaying messages. Voor een voorbeeld van een transactionele topologie, maak een project en selecteer Storm voorbeeld als het projecttype.For an example of a transactional topology, create a project and select Storm Sample as the project type.

Transactionele topologieën implementeren de volgende ter ondersteuning van de herhaling van gegevens:Transactional topologies implement the following to support replay of data:

  • Metagegevens opslaan in cache: De spout moet slaan metagegevens over de gegevens die worden geproduceerd, zodat de gegevens kunnen worden opgehaald en opnieuw 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 voorbeeld klein is, wordt de onbewerkte gegevens voor elke tuple opgeslagen in een woordenlijst 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 bolt in de topologie kunt aanroepen this.ctx.Ack(tuple) om te bevestigen dat deze is een tuple verwerkt.Ack: Each bolt in the topology can call this.ctx.Ack(tuple) to acknowledge that it has successfully processed a tuple. Wanneer alle bolts hebt bevestigd de tuple, het Ack -methode van de spout wordt aangeroepen.When all bolts have acknowledged the tuple, the Ack method of the spout is invoked. De Ack methode kunt u de spout het verwijderen van gegevens die in cache is opgeslagen voor opnieuw afspelen.The Ack method allows the spout to remove data that was cached for replay.

  • Mislukken: Elke bolt kunt aanroepen this.ctx.Fail(tuple) om aan te geven dat de verwerking is mislukt voor een tuple.Fail: Each bolt can call this.ctx.Fail(tuple) to indicate that processing has failed for a tuple. De fout doorgegeven aan de Fail -methode van de spout, waar de tuple kan opnieuw worden afgespeeld met behulp van metagegevens in de cache opgeslagen.The failure propagates to the Fail method of the spout, where the tuple can be replayed by using cached metadata.

  • ID-reeks: Bij het genereren van een tuple kan een unieke volgorde-ID worden opgegeven.Sequence ID: When emitting a tuple, a unique sequence ID can be specified. Deze waarde geeft de tuple voor de verwerking van opnieuw afspelen (Ack en mislukken).This value identifies the tuple for replay (Ack and Fail) processing. Bijvoorbeeld, de spout in de Storm voorbeeld project gebruikgemaakt van de volgende bij het genereren van gegevens: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);
    

    Deze code verzendt een tuple met een zin aan de standaardstream, met de waarde van de volgorde-ID die is opgenomen in lastSeqId.This code emits a tuple that contains a sentence to the default stream, with the sequence ID value contained in lastSeqId. In dit voorbeeld lastSeqId wordt verhoogd voor elke tuple verzonden.For this example, lastSeqId is incremented for every tuple emitted.

Zoals u in de Storm voorbeeld project, of een onderdeel is transactionele kan worden ingesteld tijdens runtime, op basis van 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 Data Lake tools voor Visual Studio ook gebruiken om te maken van hybride topologieën, waarin bepaalde onderdelen zich C# en andere resources zijn Java.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 voorbeeld van een hybride-topologie, maak een project en selecteer Storm hybride voorbeeld.For an example of a hybrid topology, create a project and select Storm Hybrid Sample. Dit Voorbeeldtype ziet u de volgende concepten:This sample type demonstrates the following concepts:

  • Java spout en C# bolt: Gedefinieerd in HybridTopology_javaSpout_csharpBolt.Java spout and C# bolt: Defined in HybridTopology_javaSpout_csharpBolt.

    • Een transactionele versie is gedefinieerd in HybridTopologyTx_javaSpout_csharpBolt.A transactional version is defined in HybridTopologyTx_javaSpout_csharpBolt.
  • C#spout en Java bolt: Defined in HybridTopology_csharpSpout_javaBolt.C# spout and Java bolt: Defined in HybridTopology_csharpSpout_javaBolt.

    • A transactional version is defined in HybridTopologyTx_csharpSpout_javaBolt.A transactional version is defined in HybridTopologyTx_csharpSpout_javaBolt.

    Notitie

    Deze versie laat ook zien hoe u Clojure code uit een tekstbestand gebruiken als een Java-component.This version also demonstrates how to use Clojure code from a text file as a Java component.

Als u wilt overschakelen van de topologie die wordt gebruikt wanneer het project wordt ingediend, gaan de [Active(true)] instructie voor de topologie die u gebruiken wilt, voordat u deze verzendt met het cluster.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 moeten worden geleverd als onderdeel van dit project in de JavaDependency map.All the Java files that are required are provided as part of this project in the JavaDependency folder.

Overweeg het volgende wanneer u het maken en verzenden van een hybride-topologie:Consider the following when you are creating and submitting a hybrid topology:

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

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

  • Bij het indienen van de topologie op de server, moet u de aanvullende configuraties optie om op te geven de Java bestandspaden.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 waarin de JAR-bestanden die uw Java-klassen bevatten.The path specified should be the directory that contains the JAR files that contain your Java classes.

Azure Event HubsAzure Event Hubs

SCP.NET versie 0.9.4.203 introduceert een nieuwe klasse en methode specifiek voor het werken met de Event Hub spout (een Java-spout die uit Eventhubs lezen).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 die gebruikmaakt van een Event Hub spout maakt, moet u de volgende methoden gebruiken:When you create a topology that uses an Event Hub spout, use the following methods:

  • EventHubSpoutConfig klasse: Hiermee maakt u 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: De Event Hub spout-component toevoegen aan de topologie.TopologyBuilder.SetEventHubSpout method: Adds the Event Hub spout component to the topology.

Notitie

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

Gebruik ConfigurationManagerUse ConfigurationManager

Gebruik geen ConfigurationManager configuratiewaarden ophalen uit bolt en spout-onderdelen.Don't use ConfigurationManager to retrieve configuration values from bolt and spout components. In dat geval kan leiden tot een null-aanwijzer-uitzondering.Doing so can cause a null pointer exception. In plaats daarvan wordt de configuratie voor uw project in de Storm-topologie doorgegeven als een sleutel-waardepaar in de context van de topologie.Instead, the configuration for your project is passed into the Storm topology as a key and value pair in the topology context. Elk onderdeel die is gebaseerd op configuratiewaarden moet deze worden opgehaald van de context tijdens de initialisatie.Each component that relies on configuration values must retrieve them from the context during initialization.

De volgende code ziet u 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 om te retourneren van een exemplaar van het onderdeel, moet u ervoor zorgen dat deze wordt doorgegeven zowel de Context en Dictionary<string, Object> parameters voor 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 voorbeeld wordt een eenvoudige Get methode die deze waarden correct is geslaagd: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);
}

Het bijwerken van SCP.NETHow to update SCP.NET

Recente versies van het SCP.NET ondersteunen pakketupgrade 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. U kunt handmatig controleren voor een upgrade door de volgende stappen uit: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 in de package manager, Updates.From the package manager, select Updates. Als een update beschikbaar is, wordt deze weergegeven.If an update is available, it is listed. Klik op Update voor het pakket te installeren.Click Update for the package to install it.

Belangrijk

Als uw project is gemaakt met een eerdere versie van het SCP.NET die niet NuGet hebt gebruikt, moet u de volgende stappen uit om bij te werken naar een nieuwere versie uitvoeren: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. Met behulp van de zoeken veld, zoeken en vervolgens toevoegt, Microsoft.scp.NET.SDK dat aan het project.Using the Search field, search for, and then add, Microsoft.SCP.Net.SDK to the project.

Oplossen van veelvoorkomende problemen met topologieënTroubleshoot common issues with topologies

Null-aanwijzer uitzonderingenNull pointer exceptions

Wanneer u van een C#-topologie met een Linux gebaseerde HDInsight-cluster gebruikmaakt, bolt en onderdelen die gebruikmaken van spout ConfigurationManager lezen van configuratie-instellingen tijdens runtime kunnen null-aanwijzer uitzonderingen retourneren.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.

De configuratie voor uw project wordt doorgegeven in de Storm-topologie als een sleutel-waardepaar in de context van de topologie.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 de dictionary-object dat wordt doorgegeven aan de onderdelen van de wanneer ze worden geïnitialiseerd.It can be retrieved from the dictionary object that is passed to your components when they are initialized.

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

System.TypeLoadExceptionSystem.TypeLoadException

Wanneer u van een C#-topologie met een Linux gebaseerde HDInsight-cluster gebruikmaakt, kunt u de volgende fout tegenkomen: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.

Deze fout treedt op wanneer u een binair bestand dat is niet compatibel met de versie van .NET die ondersteuning biedt voor Mono gebruiken.This error occurs when you use a binary that is not compatible with the version of .NET that Mono supports.

HDInsight op basis van Linux-clusters, zorg ervoor dat het project gecompileerd voor .NET 4.5 binaire bestanden gebruikt.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 is eenvoudig te implementeren van een topologie in een cluster, in sommige gevallen moet u mogelijk een topologie lokaal testen.Although it is easy to deploy a topology to a cluster, in some cases, you may need to test a topology locally. Gebruik de volgende stappen uitvoeren en testen van de voorbeeldtopologie in dit artikel lokaal in uw ontwikkelingsomgeving.Use the following steps to run and test the example topology in this article locally in your development environment.

Waarschuwing

Lokale tests werkt alleen voor basic, C#-topologieën voor alleen.Local testing only works for basic, C#-only topologies. U kunt lokaal testen voor hybride topologieën of topologieën met meerdere streams niet gebruiken.You cannot use local testing for hybrid topologies or topologies that use multiple streams.

  1. In Solution Explorer, met de rechtermuisknop op het project en selecteer eigenschappen.In Solution Explorer, right-click the project, and select Properties. In de Projecteigenschappen, wijzigt u de type uitvoer naar consoletoepassing.In the project properties, change the Output type to Console Application.

    Schermopname van het Projecteigenschappen, met het type uitvoer gemarkeerd

    Notitie

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

  2. In Solution Explorer, met de rechtermuisknop op het project en selecteer vervolgens toevoegen > Nieuw Item.In Solution Explorer, right-click the project, and then select Add > New Item. Selecteer klasse, en voer LocalTest.cs als naam van de klasse.Select Class, and enter LocalTest.cs as the class name. Klik tot slot, toevoegen.Finally, click Add.

  3. Open LocalTest.cs, en voeg de volgende met behulp van instructie aan de bovenkant: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 LocalTest klasse: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 te lezen via de codeopmerkingen.Take a moment to read through the code comments. Deze code gebruikt LocalContext om uit te voeren van de onderdelen in de ontwikkelomgeving, en deze zich blijft voordoen de gegevensstroom tussen de onderdelen in een tekstbestand opslaan op de lokale schijf.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. Open Program.cs, en het volgende toevoegen aan de Main methode: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. Sla de wijzigingen op en klik vervolgens op F5 of selecteer Debug > Start Debugging om het project te starten.Save the changes, and then click F5 or select Debug > Start Debugging to start the project. Een consolevenster moet worden weergegeven en meld u aan de status als de tests uitgevoerd.A console window should appear, and log status as the tests progress. Wanneer Tests voltooid wordt weergegeven, drukt u op een willekeurige toets om het venster te sluiten.When Tests finished appears, press any key to close the window.

  7. Gebruik Windows Explorer te vinden van de map waarin het project.Use Windows Explorer to locate the directory that contains your project. Bijvoorbeeld: 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. In deze map openen Bin, en klik vervolgens op Debug.In this directory, open Bin, and then click Debug. U ziet de tekstbestanden die zijn gemaakt als de tests uitgevoerd: sentences.txt counter.txt en splitter.txt.You should see the text files that were produced when the tests ran: sentences.txt, counter.txt, and splitter.txt. Open elk tekstbestand en controleren van de gegevens.Open each text file and inspect the data.

    Notitie

    Tekenreeksgegevens zich blijft voordoen als een matrix met decimale waarden in deze bestanden.String data persists as an array of decimal values in these files. Bijvoorbeeld, [[97,103,111]] in de splitter.txt bestand is het woord en.For example, [[97,103,111]] in the splitter.txt file is the word and.

Notitie

Zorg dat de projecttype terug naar Class Library voordat u implementeert in een Storm op HDInsight-cluster.Be sure to set the Project type back to Class Library before deploying to a Storm on HDInsight cluster.

LogboekgegevensLog information

U kunt eenvoudig gegevens van de onderdelen van uw topologie vastleggen met behulp van Context.Logger.You can easily log information from your topology components by using Context.Logger. De volgende opdracht maakt bijvoorbeeld een informatieve logboekvermelding:For example, the following command creates an informational log entry:

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

Geregistreerde gegevens kan worden bekeken via de Hadoop Service-logboek, die is gevonden Server Explorer.Logged information can be viewed from the Hadoop Service Log, which is found in Server Explorer. Vouw de vermelding voor uw Storm op HDInsight-cluster uit en vouw vervolgens Hadoop Service-logboek.Expand the entry for your Storm on HDInsight cluster, and then expand Hadoop Service Log. Selecteer ten slotte het logboekbestand om weer te geven.Finally, select the log file to view.

Notitie

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

Fout-informatie weergevenView error information

Als u wilt weergeven van fouten die zijn opgetreden in een actieve topologie, gebruikt u de volgende stappen uit:To view errors that have occurred in a running topology, use the following steps:

  1. Van Server Explorer, met de rechtermuisknop op het Storm op HDInsight-cluster en selecteert u weergave Storm-topologieën.From Server Explorer, right-click the Storm on HDInsight cluster, and select View Storm topologies.

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

  3. Selecteer de Spout-Id of Bolt Id voor het onderdeel waarvoor een fout weergegeven.Select the Spout Id or Bolt Id for the component that has an error listed. Op de pagina die wordt weergegeven, extra onjuiste informatie wordt weergegeven in de fouten sectie aan de onderkant van de pagina.On the details page that is displayed, additional error information is listed in the Errors section at the bottom of the page.

  4. Voor meer informatie, selecteert u een poort uit de Executor sectie van de pagina om te zien van het logboek van de werknemer Storm voor de afgelopen paar minuten.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 verzenden topologieënErrors submitting topologies

Als er een topologie op HDInsight verzenden fouten optreden, kunt u Logboeken vinden voor de server-side-onderdelen die de verzending van de topologie op uw HDInsight-cluster worden verwerkt.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. Als u wilt deze logboeken kunt ophalen, gebruikt u de volgende opdracht uit vanaf de opdrachtregel: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 .

Vervang sshuser met de SSH-gebruikersaccount voor het cluster.Replace sshuser with the SSH user account for the cluster. Vervang clustername met de naam van het HDInsight-cluster.Replace clustername with the name of the HDInsight cluster. Voor meer informatie over het gebruik van scp en ssh met HDInsight, raadpleegt u SSH gebruiken 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:

  • JDK is niet geïnstalleerd of is niet in het pad.JDK is not installed or is not in the path.
  • Vereiste Java-afhankelijkheden zijn niet opgenomen in de inzending.Required Java dependencies are not included in the submission.
  • Niet-compatibele afhankelijkheden.Incompatible dependencies.
  • Dubbele namen van de topologie.Duplicate topology names.

Als de hdinsight-scpwebapi.out logboek bevat een FileNotFoundException, dit wordt mogelijk veroorzaakt door de volgende voorwaarden:If the hdinsight-scpwebapi.out log contains a FileNotFoundException, this might be caused by the following conditions:

  • De JDK is niet in het pad op de ontwikkelomgeving.The JDK is not in the path on the development environment. Controleer of de JDK is geïnstalleerd in de ontwikkelomgeving en die %JAVA_HOME%/bin is in het pad.Verify that the JDK is installed in the development environment, and that %JAVA_HOME%/bin is in the path.
  • Er ontbreken een Java-afhankelijkheid.You are missing a Java dependency. Zorg ervoor dat u alle vereiste JAR-bestanden zijn opnemen als onderdeel van de inzending.Make sure you are including any required .jar files as part of the submission.

Volgende stappenNext steps

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

Zie voor een voorbeeld van een C#-topologie die streaminggegevens in meerdere streams splitst C# Storm voorbeeld.For an example of a C# topology that splits stream data into multiple streams, see C# Storm example.

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

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

Microsoft SCP.NETMicrosoft SCP.NET

Apache Storm op HDInsightApache Storm on HDInsight

Apache Hadoop op HDInsightApache Hadoop on HDInsight

Apache HBase op HDInsightApache HBase on HDInsight