Tworzenie C# topologii dla Apache Storm przy użyciu narzędzi Data Lake Tools for Visual StudioDevelop C# topologies for Apache Storm by using the Data Lake tools for Visual Studio

Dowiedz się, jak C# utworzyć topologię Apache Storm przy użyciu narzędzi Azure Data Lake (Apache Hadoop) dla programu Visual Studio.Learn how to create a C# Apache Storm topology by using the Azure Data Lake (Apache Hadoop) tools for Visual Studio. Ten dokument zawiera opis procesu tworzenia projektu burzy w programie Visual Studio, testowania go lokalnie i wdrażania go w Apache Storm w klastrze usługi Azure HDInsight.This document walks through the process of creating a Storm project in Visual Studio, testing it locally, and deploying it to an Apache Storm on Azure HDInsight cluster.

Dowiesz się również, jak tworzyć topologie hybrydowe używające składników C# i.You also learn how to create hybrid topologies that use C# and Java components.

Uwaga

Chociaż kroki opisane w tym dokumencie polegają na środowisku programistycznym systemu Windows z programem Visual Studio, skompilowany projekt można przesłać do klastra usługi HDInsight opartego na systemie Linux lub Windows.While the steps in this document rely on a Windows development environment with Visual Studio, the compiled project can be submitted to either a Linux or Windows-based HDInsight cluster. SCP.NET topologie nie obsługują tylko klastrów opartych na systemie Linux utworzonych po 28 października 2016.Only Linux-based clusters created after October 28, 2016, support SCP.NET topologies.

Aby użyć C# topologii z klastrem opartym na systemie Linux, należy zaktualizować pakiet NuGet Microsoft. scp. NET. SDK używany przez projekt do wersji 0.10.0.6 lub nowszej.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. Wersja pakietu musi być również zgodna z wersją główną systemu Storm zainstalowanego w usłudze HDInsight.The version of the package must also match the major version of Storm installed on HDInsight.

Wersja usługi HDInsightHDInsight version Wersja Apache StormApache Storm version Wersja SCP.NETSCP.NET version Domyślna wersja narzędzia monoDefault Mono version
3.33.3 0.10.x0.10.x 0.10.x.x0.10.x.x
(tylko w usłudze HDInsight opartej na systemie Windows)(only on Windows-based HDInsight)
Nie dotyczyNA
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

Ważne

Topologie C# w klastrach opartych na systemie Linux muszą korzystać z platformy .NET 4.5 i używać platformy Mono, aby mogły działać w klastrze usługi HDInsight.C# topologies on Linux-based clusters must use .NET 4.5, and use Mono to run on the HDInsight cluster. Sprawdź zgodność z programem mono, aby uzyskać potencjalne niezgodności.Check Mono compatibility for potential incompatibilities.

Instalacja programu Visual StudioInstall Visual Studio

Można opracowywać C# topologie z SCP.NET przy użyciu jednej z następujących wersji programu Visual Studio:You can develop C# topologies with SCP.NET by using one of the following versions of Visual Studio:

Zainstaluj narzędzia Data Lake Tools for Visual StudioInstall Data Lake tools for Visual Studio

Aby zainstalować narzędzia Data Lake Tools for Visual Studio, wykonaj kroki opisane w temacie wprowadzenie do narzędzia Data Lake Tools for Visual Studio.To install Data Lake tools for Visual Studio, follow the steps in Get started using Data Lake tools for Visual Studio.

Instalowanie języka JavaInstall Java

Po przesłaniu topologii burzy z programu Visual Studio SCP.NET generuje plik zip, który zawiera topologię i zależności.When you submit a Storm topology from Visual Studio, SCP.NET generates a zip file that contains the topology and dependencies. Środowisko Java służy do tworzenia tych plików zip, ponieważ używa formatu, który jest bardziej zgodny z klastrami opartymi na systemie Linux.Java is used to create these zip files, because it uses a format that is more compatible with Linux-based clusters.

  1. Zainstaluj zestaw Java developer Kit (JDK) 7 lub nowszy w środowisku deweloperskim.Install the Java Developer Kit (JDK) 7 or later on your development environment. Możesz pobrać oprogramowanie Oracle JDK z firmy Oracle.You can get the Oracle JDK from Oracle. Można również użyć innych dystrybucji języka Java.You can also use other Java distributions.

  2. Zmienna JAVA_HOME środowiskowa musi wskazywać katalog zawierający język Java.The JAVA_HOME environment variable must point to the directory that contains Java.

  3. Zmienna środowiskowa musi %JAVA_HOME%\bin zawierać katalog. PATHThe PATH environment variable must include the %JAVA_HOME%\bin directory.

Aby sprawdzić, czy środowisko C# Java i JDK są poprawnie zainstalowane, można użyć następującej aplikacji konsolowej: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.");
           }
       }  
   }
}

Szablony Apache StormApache Storm templates

Narzędzia Data Lake Tools for Visual Studio oferują następujące szablony:The Data Lake tools for Visual Studio provide the following templates:

Typ projektuProject type DemonstracjeDemonstrates
Aplikacja burzaStorm Application Pusty projekt topologii burzowej.An empty Storm topology project.
Przykład składnika zapisywania SQL platformy AzureStorm Azure SQL Writer Sample Jak pisać do Azure SQL Database.How to write to Azure SQL Database.
Przykład czytnika Azure Cosmos DB burzyStorm Azure Cosmos DB Reader Sample Jak czytać z Azure Cosmos DB.How to read from Azure Cosmos DB.
Przykład składnika zapisywania Azure Cosmos DB burzyStorm Azure Cosmos DB Writer Sample Jak pisać do Azure Cosmos DB.How to write to Azure Cosmos DB.
Przykład czytnika burzy EventHubStorm EventHub Reader Sample Jak czytać z usługi Azure Event Hubs.How to read from Azure Event Hubs.
Przykład składnika zapisywania centrów EventHubStorm EventHub Writer Sample Jak pisać do Event Hubs platformy Azure.How to write to Azure Event Hubs.
Przykład czytnika HBase burzyStorm HBase Reader Sample Jak czytać z HBase w klastrach usługi HDInsight.How to read from HBase on HDInsight clusters.
Przykład składnika zapisywania HBase burzyStorm HBase Writer Sample Jak pisać do HBase w klastrach usługi HDInsight.How to write to HBase on HDInsight clusters.
Przykład hybrydowy burzyStorm Hybrid Sample Jak używać składnika Java.How to use a Java component.
Przykład burzyStorm Sample Podstawowa topologia zliczania wyrazów.A basic word count topology.

Ostrzeżenie

Nie wszystkie szablony pracują z usługą HDInsight opartą na systemie Linux.Not all templates work with Linux-based HDInsight. Pakiety NuGet używane przez szablony mogą nie być zgodne z programem mono.NuGet packages used by the templates may not be compatible with Mono. Sprawdź dokument zgodności mono i Użyj analizatora przenośności platformy .NET , aby zidentyfikować potencjalne problemy.Check the Mono compatibility document and use the .NET Portability Analyzer to identify potential problems.

W procedurach przedstawionych w tym dokumencie używany jest typ projektu podstawowa aplikacja burzowa do utworzenia topologii.In the steps in this document, you use the basic Storm Application project type to create a topology.

Uwagi dotyczące szablonów Apache HBaseApache HBase templates notes

Szablony czytnika i składnika zapisywania HBase używają interfejsu API REST HBase, a nie interfejsu API języka HBase Java do komunikowania się z HBase w klastrze usługi HDInsight.The HBase reader and writer templates use the HBase REST API, not the HBase Java API, to communicate with an HBase on HDInsight cluster.

Uwagi dotyczące szablonów EventHubEventHub templates notes

Ważne

Oparty na języku Java składnik EventHub elementu Spout zawarty w szablonie czytnika centrów EventHub może nie współpracować z burzą w usłudze HDInsight w wersji 3,5 lub nowszej.The Java-based EventHub spout component included with the EventHub Reader template may not work with Storm on HDInsight version 3.5 or later. Zaktualizowana wersja tego składnika jest dostępna w serwisie GitHub.An updated version of this component is available at GitHub.

Aby zapoznać się z przykładową topologią, która używa tego składnika i współpracuje z usługą HDInsight 3,5, zobacz witrynę GitHub.For an example topology that uses this component and works with Storm on HDInsight 3.5, see GitHub.

Tworzenie C# topologiiCreate a C# topology

  1. Otwórz program Visual Studio, wybierz pozycję plik > Nowy, a następnie wybierz pozycję projekt.Open Visual Studio, select File > New, and then select Project.

  2. W oknie Nowy projekt rozwiń węzeł zainstalowane > Szablony, a następnie wybierz pozycję Azure Data Lake.From the New Project window, expand Installed > Templates, and select Azure Data Lake. Z listy szablonów wybierz pozycję aplikacja burzowa.From the list of templates, select Storm Application. W dolnej części ekranu wprowadź WORDCOUNT jako nazwę aplikacji.At the bottom of the screen, enter WordCount as the name of the application.

    Zrzut ekranu przedstawiający okno nowy projekt

  3. Po utworzeniu projektu należy mieć następujące pliki:After you have created the project, you should have the following files:

    • Program.cs: Ten plik definiuje topologię projektu.Program.cs: This file defines the topology for your project. Domyślna topologia składająca się z jednego elementu spoutu i jednego pioruna jest tworzona domyślnie.A default topology that consists of one spout and one bolt is created by default.

    • Spout.cs: Przykład elementu Spout, który emituje liczby losowe.Spout.cs: An example spout that emits random numbers.

    • Bolt.cs: Przykładowy piorun, który przechowuje liczbę liczb emitowanych przez elementu Spout.Bolt.cs: An example bolt that keeps a count of numbers emitted by the spout.

      Podczas tworzenia projektu NuGet pobiera najnowszy pakiet SCP.NET.When you create the project, NuGet downloads the latest SCP.NET package.

      Ważne

      Wersja platformy SCP.NET, używany w projekcie musi odpowiadać wersji systemu Storm obecne w klastrze usługi HDInsight.The SCP.NET version used in your project must match the Storm version present on your HDInsight cluster. Skorzystaj z poniższej tabeli, aby określić, która wersja, należy użyć:Use the following table to determine which version you should use:

      HDInsight w wersjiHDInsight version Wersja systemu Apache StormApache Storm version Wersja platformy SCP.NETSCP.NET version Domyślna wersja narzędzia MonoDefault Mono version
      3.33.3 0.10.0.x0.10.0.x 0.10.0.x (tylko na podstawie Windows Klastry)0.10.0.x (Windows-based clusters only) Nie dotyczyNA
      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

      Aby uzyskać więcej informacji na temat składników dołączonym HDInsight, zobacz wersje składników HDInsight.For more information on components provided with HDInsight, see HDInsight component versions.

Implementowanie elementu SpoutImplement the spout

  1. Otwórz Spout.cs.Open Spout.cs. Elementy Spout są używane do odczytywania danych w topologii ze źródła zewnętrznego.Spouts are used to read data in a topology from an external source. Główne składniki elementu Spout są następujące:The main components for a spout are:

    • NextTuple: Wywoływane przez burzę, gdy elementu Spout może emitować nowe krotki.NextTuple: Called by Storm when the spout is allowed to emit new tuples.

    • Potwierdzenie (tylko topologia transakcyjna): Obsługuje potwierdzenia zainicjowane przez inne składniki w topologii dla krotek wysłanych z elementu Spout.Ack (transactional topology only): Handles acknowledgments initiated by other components in the topology for tuples sent from the spout. Potwierdzenie krotki umożliwia elementu Spout, że została przetworzona pomyślnie przez składniki podrzędne.Acknowledging a tuple lets the spout know that it was processed successfully by downstream components.

    • Nie powiodło się (tylko topologia transakcyjna): Obsługuje krotki, które kończą się niepowodzeniem przetwarzania innych składników w topologii.Fail (transactional topology only): Handles tuples that are fail-processing other components in the topology. Implementacja metody niepowodzenia umożliwia ponowne wyemitowanie spójnej kolekcji, aby można było ją przetworzyć ponownie.Implementing a Fail method allows you to re-emit the tuple so that it can be processed again.

  2. Zastąp zawartość klasy elementu Spout następującym tekstem: Ta elementu Spout losowo emituje zdanie do topologii.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
    }
    

Zaimplementuj piorunyImplement the bolts

  1. Usuń istniejący plik Bolt.cs z projektu.Delete the existing Bolt.cs file from the project.

  2. W Eksplorator rozwiązańkliknij prawym przyciskiem myszy projekt, a następnie wybierz pozycję Dodaj > nowy element.In Solution Explorer, right-click the project, and select Add > New item. Z listy wybierz pozycję pioruni wprowadź Splitter.cs jako nazwę.From the list, select Storm Bolt, and enter Splitter.cs as the name. Powtórz ten proces, aby utworzyć drugi piorun o nazwie Counter.cs.Repeat this process to create a second bolt named Counter.cs.

    • Splitter.cs: Implementuje obiekt, który dzieli zdania na poszczególne wyrazy i emituje nowy strumień wyrazów.Splitter.cs: Implements a bolt that splits sentences into individual words, and emits a new stream of words.

    • Counter.cs: Implementuje obiekt piorun, który zlicza każdy wyraz, i emituje nowy strumień słów oraz liczbę dla każdego wyrazu.Counter.cs: Implements a bolt that counts each word, and emits a new stream of words and the count for each word.

      Uwaga

      Te pioruny odczytują i zapisują strumienie, ale można również używać pioruna do komunikowania się ze źródłami, takimi jak baza danych lub usługa.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. Otwórz Splitter.cs.Open Splitter.cs. Domyślnie ma tylko jedną metodę: Wykonaj.It has only one method by default: Execute. Metoda Execute jest wywoływana, gdy obiekt piorun odbiera krotkę do przetwarzania.The Execute method is called when the bolt receives a tuple for processing. Tutaj można odczytywać i przetwarzać kolekcje przychodzące oraz emitować kolekcje wychodzące.Here, you can read and process incoming tuples, and emit outbound tuples.

  4. Zastąp zawartość klasy rozdzielacza następującym kodem: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. Otwórz Counter.csi Zastąp zawartość klasy następującym kodem: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");
    }
    

Definiowanie topologiiDefine the topology

Elementy Spout i pioruny są rozmieszczone na grafie, który definiuje sposób przepływu danych między składnikami.Spouts and bolts are arranged in a graph, which defines how the data flows between components. W przypadku tej topologii wykres jest następujący:For this topology, the graph is as follows:

Diagram przedstawiający sposób rozmieszczenia składników

Zdania są emitowane z elementu Spout i są dystrybuowane do wystąpień pioruna rozdzielacza.Sentences are emitted from the spout, and are distributed to instances of the Splitter bolt. Piorun rozdzielacza dzieli zdania na wyrazy, które są dystrybuowane do błyskawicy licznika.The Splitter bolt breaks the sentences into words, which are distributed to the Counter bolt.

Ponieważ liczba słów jest przechowywana lokalnie w wystąpieniu licznika, należy upewnić się, że określone słowa przepływają do tego samego wystąpienia obiektu.Because word count is held locally in the Counter instance, you want to make sure that specific words flow to the same Counter bolt instance. Każde wystąpienie śledzi określone słowa.Each instance keeps track of specific words. Ponieważ piorun rozdzielacza nie ma stanu, naprawdę nie ma znaczenia, które wystąpienie rozdzielacza otrzymuje zdanie.Since the Splitter bolt maintains no state, it really doesn't matter which instance of the splitter receives which sentence.

Otwórz program.cs.Open Program.cs. Ważna Metoda to GetTopologyBuilder, która jest używana do definiowania topologii, która jest przesyłana do burzy.The important method is GetTopologyBuilder, which is used to define the topology that is submitted to Storm. Zastąp zawartość GetTopologyBuilder następującym kodem w celu zaimplementowania opisanej wcześniej topologii: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;

Przesyłanie topologiiSubmit the topology

  1. W Eksplorator rozwiązańkliknij prawym przyciskiem myszy projekt, a następnie wybierz pozycję Prześlij do burzy w usłudze HDInsight.In Solution Explorer, right-click the project, and select Submit to Storm on HDInsight.

    Uwaga

    Jeśli zostanie wyświetlony monit, wprowadź poświadczenia dla subskrypcji platformy Azure.If prompted, enter the credentials for your Azure subscription. Jeśli masz więcej niż jedną subskrypcję, zaloguj się do niej, która zawiera swoją burzę w klastrze usługi HDInsight.If you have more than one subscription, sign in to the one that contains your Storm on HDInsight cluster.

  2. Wybierz pozycję burza w klastrze usługi HDInsight z listy rozwijanej klaster burzy , a następnie wybierz pozycję Prześlij.Select your Storm on HDInsight cluster from the Storm Cluster drop-down list, and then select Submit. Możesz monitorować, czy przesyłanie zakończy się pomyślnie przy użyciu okna dane wyjściowe .You can monitor if the submission is successful by using the Output window.

  3. Po pomyślnym przesłaniu topologii powinny pojawić się topologie burzy w klastrze.When the topology has been successfully submitted, the Storm Topologies for the cluster should appear. Wybierz topologię WORDCOUNT z listy, aby wyświetlić informacje o uruchomionej topologii.Select the WordCount topology from the list to view information about the running topology.

    Uwaga

    Można również wyświetlić topologie burzy w Eksplorator serwera.You can also view Storm Topologies from Server Explorer. Rozwiń węzeł AzureHDInsight, kliknij prawym przyciskiem myszy burzę w klastrze usługi > HDInsight, a następnie wybierz pozycję Wyświetl topologie burzy.Expand Azure > HDInsight, right-click a Storm on HDInsight cluster, and then select View Storm Topologies.

    Aby wyświetlić informacje o składnikach w topologii, kliknij dwukrotnie składnik na diagramie.To view information about the components in the topology, double-click the component in the diagram.

  4. W widoku podsumowania topologii kliknij przycisk Kill , aby zatrzymać topologię.From the Topology Summary view, click Kill to stop the topology.

    Uwaga

    Topologie burzy są nadal uruchamiane, dopóki nie zostaną dezaktywowane lub klaster zostanie usunięty.Storm topologies continue to run until they are deactivated, or the cluster is deleted.

Topologia transakcyjnaTransactional topology

Poprzednia topologia nie jest transakcyjna.The previous topology is non-transactional. Składniki w topologii nie implementują funkcji odtwarzania komunikatów.The components in the topology do not implement functionality to replaying messages. Aby zapoznać się z przykładem topologii transakcyjnej, Utwórz projekt i wybierz pozycję burza jako typ projektu.For an example of a transactional topology, create a project and select Storm Sample as the project type.

Topologie transakcyjne implementują następujące czynności w celu obsługi ponownego odtwarzania danych:Transactional topologies implement the following to support replay of data:

  • Buforowanie metadanych: Elementu Spout musi przechowywać metadane dotyczące emitowanych danych, aby dane mogły zostać pobrane i wyemitowane ponownie w przypadku wystąpienia błędu.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. Ponieważ dane emitowane przez próbę są małe, dane pierwotne dla każdej krotki są przechowywane w słowniku do odtworzenia.Because the data emitted by the sample is small, the raw data for each tuple is stored in a dictionary for replay.

  • ACK: Każdy piorun w topologii może wywołać this.ctx.Ack(tuple) , aby potwierdzić, że pomyślnie przetworzył krotkę.Ack: Each bolt in the topology can call this.ctx.Ack(tuple) to acknowledge that it has successfully processed a tuple. Gdy wszystkie pioruny potwierdzili spójność, Ack Metoda elementu Spout jest wywoływana.When all bolts have acknowledged the tuple, the Ack method of the spout is invoked. Ack Metoda zezwala elementu Spout na usuwanie danych, które zostały zbuforowane w celu odtworzenia.The Ack method allows the spout to remove data that was cached for replay.

  • Nie powiodło się: Każdy obiekt piorun może this.ctx.Fail(tuple) wywołać, aby wskazać, że przetwarzanie nie powiodło się dla krotki.Fail: Each bolt can call this.ctx.Fail(tuple) to indicate that processing has failed for a tuple. Błąd jest propagowany do Fail metody elementu Spout, gdzie krotka może zostać powtórzona przy użyciu metadanych w pamięci podręcznej.The failure propagates to the Fail method of the spout, where the tuple can be replayed by using cached metadata.

  • Identyfikator sekwencji: W przypadku emitowania spójnej kolekcji można określić unikatowy identyfikator sekwencji.Sequence ID: When emitting a tuple, a unique sequence ID can be specified. Ta wartość identyfikuje krotkę do przetwarzania powtórzeń (ACK i niepowodzenie).This value identifies the tuple for replay (Ack and Fail) processing. Na przykład elementu Spout w projekcie przykładowym burzy używa następujących podczas emitowania danych: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);
    

    Ten kod emituje krotkę zawierającą zdanie do domyślnego strumienia, z wartością identyfikatora sekwencji zawartą w lastSeqId.This code emits a tuple that contains a sentence to the default stream, with the sequence ID value contained in lastSeqId. W tym przykładzie lastSeqId jest zwiększana dla każdej emisji kolekcji.For this example, lastSeqId is incremented for every tuple emitted.

Jak pokazano w projekcie przykładu burzy , niezależnie od tego, czy składnik jest transakcyjny można ustawić w czasie wykonywania na podstawie konfiguracji.As demonstrated in the Storm Sample project, whether a component is transactional can be set at runtime, based on configuration.

Topologia hybrydowa z C# i JavaHybrid topology with C# and Java

Możesz również użyć narzędzi Data Lake Tools for Visual Studio, aby tworzyć topologie hybrydowe, w C# których niektóre składniki są inne niż Java.You can also use Data Lake tools for Visual Studio to create hybrid topologies, where some components are C# and others are Java.

Przykład topologii hybrydowej, tworzenie projektu i wybieranie hybrydowego przykładu burzy.For an example of a hybrid topology, create a project and select Storm Hybrid Sample. Ten przykładowy typ ilustruje następujące koncepcje:This sample type demonstrates the following concepts:

  • Elementu Spout Java i C# piorun: Zdefiniowane w HybridTopology_javaSpout_csharpBolt.Java spout and C# bolt: Defined in HybridTopology_javaSpout_csharpBolt.

    • Wersja transakcyjna jest definiowana w HybridTopologyTx_javaSpout_csharpBolt.A transactional version is defined in HybridTopologyTx_javaSpout_csharpBolt.
  • elementu Spout i środowisko Java: C# Zdefiniowane w HybridTopology_csharpSpout_javaBolt.C# spout and Java bolt: Defined in HybridTopology_csharpSpout_javaBolt.

    • Wersja transakcyjna jest definiowana w HybridTopologyTx_csharpSpout_javaBolt.A transactional version is defined in HybridTopologyTx_csharpSpout_javaBolt.

    Uwaga

    W tej wersji pokazano również, jak używać kodu Clojure z pliku tekstowego jako składnika języka Java.This version also demonstrates how to use Clojure code from a text file as a Java component.

Aby przełączyć topologię używaną podczas przesyłania projektu, Przenieś [Active(true)] instrukcję do topologii, której chcesz użyć, przed przesłaniem jej do klastra.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.

Uwaga

Wszystkie wymagane pliki języka Java są dostępne jako część tego projektu w folderze JavaDependency .All the Java files that are required are provided as part of this project in the JavaDependency folder.

Podczas tworzenia i przesyłania topologii hybrydowej należy wziąć pod uwagę następujące kwestie:Consider the following when you are creating and submitting a hybrid topology:

  • Użyj JavaComponentConstructor , aby utworzyć wystąpienie klasy Java dla elementu Spout lub pioruna.Use JavaComponentConstructor to create an instance of the Java class for a spout or bolt.

  • Użyj pliku Microsoft. scp. burz. wielolang. CustomizedInteropJSONSerializer , aby serializować dane do składników języka Java lub z nich z obiektów Java do formatu JSON.Use microsoft.scp.storm.multilang.CustomizedInteropJSONSerializer to serialize data into or out of Java components from Java objects to JSON.

  • Podczas przesyłania topologii do serwera należy użyć opcji dodatkowe konfiguracje , aby określić ścieżki plików Java.When submitting the topology to the server, you must use the Additional configurations option to specify the Java File paths. Określona ścieżka powinna być katalogiem zawierającym pliki JAR, które zawierają klasy języka Java.The path specified should be the directory that contains the JAR files that contain your Java classes.

Azure Event HubsAzure Event Hubs

W wersji SCP.NET 0.9.4.203 wprowadzono nową klasę i metodę przeznaczone do pracy z centrum zdarzeń elementu Spout (Java elementu Spout, który odczytuje z Event Hubs).SCP.NET version 0.9.4.203 introduces a new class and method specifically for working with the Event Hub spout (a Java spout that reads from Event Hubs). Podczas tworzenia topologii korzystającej z centrum zdarzeń elementu Spout należy użyć następujących metod:When you create a topology that uses an Event Hub spout, use the following methods:

  • Klasa EventHubSpoutConfig : Tworzy obiekt, który zawiera konfigurację dla składnika elementu Spout.EventHubSpoutConfig class: Creates an object that contains the configuration for the spout component.

  • TopologyBuilder. SetEventHubSpout — Metoda: Dodaje składnik elementu Spout centrum zdarzeń do topologii.TopologyBuilder.SetEventHubSpout method: Adds the Event Hub spout component to the topology.

Uwaga

Aby serializować dane wytwarzane przez elementu Spout, należy nadal używać CustomizedInteropJSONSerializer .You must still use the CustomizedInteropJSONSerializer to serialize data produced by the spout.

Użyj ConfigurationManagerUse ConfigurationManager

Nie należy używać programu ConfigurationManager do pobierania wartości konfiguracyjnych ze składników piorun i elementu Spout.Don't use ConfigurationManager to retrieve configuration values from bolt and spout components. Wykonanie tej operacji może spowodować wystąpienie wyjątku wskaźnika o wartości null.Doing so can cause a null pointer exception. Zamiast tego Konfiguracja projektu jest przenoszona do topologii burzy jako para klucza i wartości w kontekście topologii.Instead, the configuration for your project is passed into the Storm topology as a key and value pair in the topology context. Każdy składnik, który opiera się na wartościach konfiguracji, musi pobrać je z kontekstu podczas inicjalizacji.Each component that relies on configuration values must retrieve them from the context during initialization.

Poniższy kod ilustruje sposób pobierania następujących wartości: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;
    }
    ...
}

Jeśli używasz Get metody do zwrócenia wystąpienia składnika, musisz upewnić się, że przekazuje Context zarówno parametr, jak i Dictionary<string, Object> do konstruktora.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. Poniższy przykład jest metodą podstawową Get , która prawidłowo przekazuje te wartości: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);
}

Jak zaktualizować SCP.NETHow to update SCP.NET

Najnowsze wersje pakietu SCP.NET support Upgrades za pomocą narzędzia NuGet.Recent releases of SCP.NET support package upgrade through NuGet. Po udostępnieniu nowej aktualizacji otrzymujesz powiadomienie o uaktualnieniu.When a new update is available, you receive an upgrade notification. Aby ręcznie sprawdzić uaktualnienie, wykonaj następujące kroki:To manually check for an upgrade, follow these steps:

  1. W Eksploratorze rozwiązań kliknij prawym przyciskiem myszy projekt, a następnie wybierz pozycję Zarządzanie pakietami NuGet.In Solution Explorer, right-click the project, and select Manage NuGet Packages.

  2. W Menedżerze pakietów wybierz pozycję aktualizacje.From the package manager, select Updates. Jeśli aktualizacja jest dostępna, zostanie wyświetlona.If an update is available, it is listed. Kliknij przycisk Aktualizuj , aby zainstalować pakiet.Click Update for the package to install it.

Ważne

Jeśli projekt został utworzony przy użyciu wcześniejszej wersji programu SCP.NET, która nie korzystała z narzędzia NuGet, należy wykonać następujące kroki, aby zaktualizować do nowszej wersji: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. W Eksploratorze rozwiązań kliknij prawym przyciskiem myszy projekt, a następnie wybierz pozycję Zarządzanie pakietami NuGet.In Solution Explorer, right-click the project, and select Manage NuGet Packages.
  2. Korzystając z pola wyszukiwania , Wyszukaj, a następnie Dodaj do projektu pakiet Microsoft. scp. NET. SDK .Using the Search field, search for, and then add, Microsoft.SCP.Net.SDK to the project.

Rozwiązywanie typowych problemów z topologiamiTroubleshoot common issues with topologies

Wyjątki wskaźnika o wartości nullNull pointer exceptions

W przypadku korzystania z C# topologii z klastrem usługi HDInsight opartej na systemie Linux składniki piorun i elementu Spout, które używają elementu ConfigurationManager do odczytywania ustawień konfiguracji w czasie wykonywania, mogą zwracać wyjątki wskaźnika o wartości null.When you are using a C# topology with a Linux-based HDInsight cluster, bolt and spout components that use ConfigurationManager to read configuration settings at runtime may return null pointer exceptions.

Konfiguracja projektu jest przenoszona do topologii burzy jako para klucza i wartości w kontekście topologii.The configuration for your project is passed into the Storm topology as a key and value pair in the topology context. Można go pobrać z obiektu dictionary, który jest przesyłany do składników, gdy są one inicjowane.It can be retrieved from the dictionary object that is passed to your components when they are initialized.

Aby uzyskać więcej informacji, zobacz sekcję ConfigurationManager w tym dokumencie.For more information, see the ConfigurationManager section of this document.

System.TypeLoadExceptionSystem.TypeLoadException

W przypadku korzystania z C# topologii z klastrem usługi HDInsight opartej na systemie Linux może wystąpić następujący błąd: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.

Ten błąd występuje, gdy używany jest plik binarny, który nie jest zgodny z wersją platformy .NET obsługiwaną przez program mono.This error occurs when you use a binary that is not compatible with the version of .NET that Mono supports.

W przypadku klastrów usługi HDInsight opartych na systemie Linux upewnij się, że w projekcie są używane pliki binarne skompilowane dla programu .NET 4,5.For Linux-based HDInsight clusters, make sure that your project uses binaries compiled for .NET 4.5.

Lokalne testowanie topologiiTest a topology locally

Chociaż można łatwo wdrożyć topologię w klastrze, w niektórych przypadkach może być konieczne lokalne przetestowanie topologii.Although it is easy to deploy a topology to a cluster, in some cases, you may need to test a topology locally. Wykonaj następujące kroki, aby uruchomić i przetestować przykładową topologię w tym artykule lokalnie w środowisku deweloperskim.Use the following steps to run and test the example topology in this article locally in your development environment.

Ostrzeżenie

Testowanie lokalne działa tylko dla topologii C#podstawowej.Local testing only works for basic, C#-only topologies. Nie można użyć lokalnego testowania dla topologii hybrydowej lub topologii, które używają wielu strumieni.You cannot use local testing for hybrid topologies or topologies that use multiple streams.

  1. W Eksplorator rozwiązańkliknij prawym przyciskiem myszy projekt, a następnie wybierz polecenie Właściwości.In Solution Explorer, right-click the project, and select Properties. We właściwościach projektu Zmień Typ danych wyjściowych na Aplikacja konsolowa.In the project properties, change the Output type to Console Application.

    Zrzut ekranu właściwości projektu z wyróżnionym typem danych wyjściowych

    Uwaga

    Pamiętaj, aby zmienić Typ danych wyjściowych z powrotem na bibliotekę klas przed wdrożeniem topologii w klastrze.Remember to change the Output type back to Class Library before you deploy the topology to a cluster.

  2. W Eksplorator rozwiązańkliknij prawym przyciskiem myszy projekt, a następnie wybierz polecenie Dodaj > nowy element.In Solution Explorer, right-click the project, and then select Add > New Item. Wybierz klasęi wprowadź LocalTest.cs jako nazwę klasy.Select Class, and enter LocalTest.cs as the class name. Na koniec kliknij przycisk Dodaj.Finally, click Add.

  3. Otwórz LocalTest.csi Dodaj następującą instrukcję using u góry:Open LocalTest.cs, and add the following using statement at the top:

    using Microsoft.SCP;
    
  4. Użyj następującego kodu jako zawartości klasy 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
    }
    

    Poświęć chwilę na odczytanie komentarzy do kodu.Take a moment to read through the code comments. Ten kod używa LocalContext do uruchamiania składników w środowisku deweloperskim i utrzymuje strumień danych między składnikami do plików tekstowych na dysku lokalnym.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. Otwórz program.csi Dodaj do metody Main następujące polecenie: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. Zapisz zmiany, a następnie kliknij F5 lub wybierz Debuguj > Rozpocznij debugowanie , aby uruchomić projekt.Save the changes, and then click F5 or select Debug > Start Debugging to start the project. Powinno zostać wyświetlone okno konsoli i stan rejestrowania w miarę postępów testów.A console window should appear, and log status as the tests progress. Gdy zostaną wyświetlone testy , naciśnij dowolny klawisz, aby zamknąć okno.When Tests finished appears, press any key to close the window.

  7. Aby zlokalizować katalog zawierający projekt, użyj Eksploratora Windows .Use Windows Explorer to locate the directory that contains your project. Na przykład: 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. W tym katalogu Otwórz pozycję bin, a następnie kliknij pozycję Debuguj.In this directory, open Bin, and then click Debug. Powinny zostać wyświetlone pliki tekstowe, które zostały utworzone po uruchomieniu testów: zdania. txt, Counter. txt i rozdzielacz. txt.You should see the text files that were produced when the tests ran: sentences.txt, counter.txt, and splitter.txt. Otwórz każdy plik tekstowy i sprawdź dane.Open each text file and inspect the data.

    Uwaga

    Dane ciągu są utrwalane jako tablica wartości dziesiętnych w tych plikach.String data persists as an array of decimal values in these files. Na przykład [[97 103 111]] w pliku rozdzielacza. txt jest wyraz i.For example, [[97,103,111]] in the splitter.txt file is the word and.

Uwaga

Pamiętaj, aby przed wdrożeniem w klastrze usługi HDInsight ustawić Typ projektu z powrotem do biblioteki klas .Be sure to set the Project type back to Class Library before deploying to a Storm on HDInsight cluster.

Informacje dziennikaLog information

Korzystając z programu Context.Logger, można łatwo rejestrować informacje ze składników topologii.You can easily log information from your topology components by using Context.Logger. Na przykład następujące polecenie tworzy wpis dziennika informacyjnego:For example, the following command creates an informational log entry:

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

Zarejestrowane informacje można wyświetlać z dziennika usługi Hadoop, który znajduje się w Eksplorator serwera.Logged information can be viewed from the Hadoop Service Log, which is found in Server Explorer. Rozwiń pozycję burzy w klastrze usługi HDInsight, a następnie rozwiń węzeł Dziennik usług Hadoop.Expand the entry for your Storm on HDInsight cluster, and then expand Hadoop Service Log. Na koniec wybierz plik dziennika do wyświetlenia.Finally, select the log file to view.

Uwaga

Dzienniki są przechowywane na koncie usługi Azure Storage, które jest używane przez klaster.The logs are stored in the Azure storage account that is used by your cluster. Aby wyświetlić dzienniki w programie Visual Studio, musisz zalogować się do subskrypcji platformy Azure należącej do konta magazynu.To view the logs in Visual Studio, you must sign in to the Azure subscription that owns the storage account.

Wyświetl informacje o błędzieView error information

Aby wyświetlić błędy, które wystąpiły w uruchomionej topologii, wykonaj następujące czynności:To view errors that have occurred in a running topology, use the following steps:

  1. W Eksplorator serwerakliknij prawym przyciskiem myszy burzę w klastrze usługi HDInsight, a następnie wybierz pozycję Wyświetl topologie burzy.From Server Explorer, right-click the Storm on HDInsight cluster, and select View Storm topologies.

  2. W przypadku elementu Spout i piorunówkolumna ostatniej błędu zawiera informacje dotyczące ostatniego błędu.For the Spout and Bolts, the Last Error column contains information on the last error.

  3. Wybierz Identyfikator elementu Spout lub Identyfikator obiektu dla składnika, w którym znajduje się błąd.Select the Spout ID or Bolt ID for the component that has an error listed. Na wyświetlonej stronie Szczegóły dodatkowe informacje o błędzie znajdują się w sekcji Błędy w dolnej części strony.On the details page that is displayed, additional error information is listed in the Errors section at the bottom of the page.

  4. Aby uzyskać więcej informacji, wybierz port z sekcji wykonawcy strony, aby zobaczyć dziennik procesów roboczych burzy w ciągu ostatnich kilku minut.To obtain more information, select a Port from the Executors section of the page, to see the Storm worker log for the last few minutes.

Błędy przesyłania topologiiErrors submitting topologies

Jeśli wystąpią błędy podczas przesyłania topologii do usługi HDInsight, można znaleźć dzienniki dla składników po stronie serwera, które obsługują przesyłanie topologii w klastrze HDInsight.If you encounter errors submitting a topology to HDInsight, you can find logs for the server-side components that handle topology submission on your HDInsight cluster. Aby pobrać te dzienniki, użyj następującego polecenia w wierszu polecenia: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 .

Zastąp sshuser przy użyciu konta użytkownika SSH dla klastra.Replace sshuser with the SSH user account for the cluster. Zastąp wartość ClusterName nazwą klastra usługi HDInsight.Replace clustername with the name of the HDInsight cluster. Aby uzyskać więcej informacji na scp temat ssh używania usługi i usługi HDInsight, zobacz Używanie protokołu SSH z usługą HDInsight.For more information on using scp and ssh with HDInsight, see Use SSH with HDInsight.

Zgłoszenia mogą się nie powieść z wielu powodów:Submissions can fail for multiple reasons:

  • JDK nie jest zainstalowana lub nie znajduje się w ścieżce.JDK is not installed or is not in the path.
  • W przesyłaniu nie są uwzględniane wymagane zależności języka Java.Required Java dependencies are not included in the submission.
  • Niezgodne zależności.Incompatible dependencies.
  • Zduplikowane nazwy topologii.Duplicate topology names.

hdinsight-scpwebapi.out Jeśli DziennikFileNotFoundExceptionzawiera, może to być spowodowane następującymi warunkami:If the hdinsight-scpwebapi.out log contains a FileNotFoundException, this might be caused by the following conditions:

  • JDK nie znajduje się w ścieżce w środowisku deweloperskim.The JDK is not in the path on the development environment. Sprawdź, czy program JDK jest zainstalowany w środowisku deweloperskim i czy %JAVA_HOME%/bin znajduje się w ścieżce.Verify that the JDK is installed in the development environment, and that %JAVA_HOME%/bin is in the path.
  • Brak zależności Java.You are missing a Java dependency. Upewnij się, że w ramach przesłania dołączane są wszystkie wymagane pliki jar.Make sure you are including any required .jar files as part of the submission.

Następne krokiNext steps

Przykład przetwarzania danych z Event Hubs można znaleźć w temacie zdarzenia przetwarzania z platformy Azure Event Hubs z burzą w usłudze HDInsight.For an example of processing data from Event Hubs, see Process events from Azure Event Hubs with Storm on HDInsight.

Przykład C# topologii dzielącej dane strumienia na wiele strumieni, zobacz C# przykład burzy.For an example of a C# topology that splits stream data into multiple streams, see C# Storm example.

Aby uzyskać więcej informacji na temat C# tworzenia topologii, zobacz witrynę GitHub.To discover more information about creating C# topologies, see GitHub.

Aby uzyskać więcej metod pracy z usługą HDInsight i więcej informacji na temat przykładów usługi HDInsight, zobacz następujące dokumenty:For more ways to work with HDInsight and more Storm on HDInsight samples, see the following documents:

Microsoft SCP.NETMicrosoft SCP.NET

Apache Storm w usłudze HDInsightApache Storm on HDInsight

Apache Hadoop w usłudze HDInsightApache Hadoop on HDInsight

Apache HBase w usłudze HDInsightApache HBase on HDInsight