Tutorial: Streamen von Daten an Azure Databricks unter Verwendung von Event HubsTutorial: Stream data into Azure Databricks using Event Hubs

In diesem Tutorial verbinden Sie ein Datenerfassungssystem mit Azure Databricks, um Daten nahezu in Echtzeit in einen Apache Spark-Cluster zu streamen.In this tutorial, you connect a data ingestion system with Azure Databricks to stream data into an Apache Spark cluster in near real-time. Sie richten ein Datenerfassungssystem mit Azure Event Hubs ein und verbinden es zur Verarbeitung der eingehenden Nachrichten mit Azure Databricks.You set up data ingestion system using Azure Event Hubs and then connect it to Azure Databricks to process the messages coming through. Für den Zugriff auf Streamingdaten verwenden Sie Twitter-APIs, um Tweets in Event Hubs zu erfassen.To access a stream of data, you use Twitter APIs to ingest tweets into Event Hubs. Sobald sich die Daten in Azure Databricks befinden, können Sie Analyseaufträge ausführen, um die Daten näher zu analysieren.Once you have the data in Azure Databricks, you can run analytical jobs to further analyze the data.

Am Ende dieses Tutorials haben Sie Tweets, die den Begriff „Azure“ enthalten, von Twitter gestreamt und die Tweets in Azure Databricks gelesen.By the end of this tutorial, you would have streamed tweets from Twitter (that have the term "Azure" in them) and read the tweets in Azure Databricks.

In der folgenden Abbildung ist der Anwendungsfluss dargestellt:The following illustration shows the application flow:

Azure Databricks mit Event HubsAzure Databricks with Event Hubs

Dieses Tutorial enthält die folgenden Aufgaben:This tutorial covers the following tasks:

  • Erstellen eines Azure Databricks-ArbeitsbereichsCreate an Azure Databricks workspace
  • Erstellen eines Spark-Clusters in Azure DatabricksCreate a Spark cluster in Azure Databricks
  • Erstellen einer Twitter-App für den Zugriff auf StreamingdatenCreate a Twitter app to access streaming data
  • Erstellen von Notebooks in Azure DatabricksCreate notebooks in Azure Databricks
  • Anfügen von Bibliotheken für Event Hubs und die Twitter-APIAttach libraries for Event Hubs and Twitter API
  • Senden von Tweets an Event HubsSend tweets to Event Hubs
  • Lesen von Tweets aus Event HubsRead tweets from Event Hubs

Wenn Sie kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.If you don't have an Azure subscription, create a free account before you begin.

VoraussetzungenPrerequisites

Vergewissern Sie sich zunächst, dass die folgenden Anforderungen erfüllt sind bzw. dass Folgendes vorhanden ist:Before you start with this tutorial, make sure to meet the following requirements:

  • Ein Azure Event Hubs-NamespaceAn Azure Event Hubs namespace.
  • Ein Event Hub innerhalb des Namespace.An Event Hub within the namespace.
  • Die Verbindungszeichenfolge für den Zugriff auf den Event Hubs-Namespace.Connection string to access the Event Hubs namespace. Die Verbindungszeichenfolge sollte in etwa das folgende Format haben: Endpoint=sb://<namespace>.servicebus.windows.net/;SharedAccessKeyName=<key name>;SharedAccessKey=<key value>.The connection string should have a format similar to Endpoint=sb://<namespace>.servicebus.windows.net/;SharedAccessKeyName=<key name>;SharedAccessKey=<key value>.
  • Der Name der SAS-Richtlinie und der Richtlinienschlüssel für Event Hubs.Shared access policy name and policy key for Event Hubs.

Sie können diese Anforderungen erfüllen, indem Sie die Schritte im Artikel Erstellen eines Event Hubs-Namespace und eines Event Hubs mithilfe des Azure-Portals ausführen.You can meet these requirements by completing the steps in the article, Create an Azure Event Hubs namespace and event hub.

Anmelden beim Azure-PortalLog in to the Azure portal

Melden Sie sich beim Azure-Portalan.Log in to the Azure portal.

Erstellen eines Azure Databricks-ArbeitsbereichsCreate an Azure Databricks workspace

In diesem Abschnitt erstellen Sie einen Azure Databricks-Arbeitsbereich über das Azure-Portal.In this section, you create an Azure Databricks workspace using the Azure portal.

  1. Klicken Sie im Azure-Portal auf Ressource erstellen > Daten + Analysen > Azure Databricks.In the Azure portal, select Create a resource > Data + Analytics > Azure Databricks.

    Databricks im Azure-PortalDatabricks on Azure portal

  2. Geben Sie unter Azure Databricks-Dienst die Werte für die Erstellung eines Databricks-Arbeitsbereichs an.Under Azure Databricks Service, provide the values to create a Databricks workspace.

    Erstellen eines Azure Databricks-ArbeitsbereichsCreate an Azure Databricks workspace

    Geben Sie außerdem die folgenden Werte an:Provide the following values:

    EigenschaftProperty BESCHREIBUNGDescription
    ArbeitsbereichsnameWorkspace name Geben Sie einen Namen für Ihren Databricks-Arbeitsbereich an.Provide a name for your Databricks workspace
    AbonnementSubscription Wählen Sie in der Dropdownliste Ihr Azure-Abonnement aus.From the drop-down, select your Azure subscription.
    RessourcengruppeResource group Geben Sie an, ob Sie eine neue Ressourcengruppe erstellen oder eine vorhandene Ressourcengruppe verwenden möchten.Specify whether you want to create a new resource group or use an existing one. Eine Ressourcengruppe ist ein Container, der verwandte Ressourcen für eine Azure-Lösung enthält.A resource group is a container that holds related resources for an Azure solution. Weitere Informationen finden Sie in der Übersicht über den Azure Resource Manager.For more information, see Azure Resource Group overview.
    LocationLocation Wählen Sie USA, Osten 2 aus.Select East US 2. Informationen zu weiteren verfügbaren Regionen finden Sie unter Verfügbare Produkte nach Region.For other available regions, see Azure services available by region.
    TarifPricing Tier Wählen Sie zwischen Standard und Premium.Choose between Standard or Premium. Weitere Informationen zu diesen Tarifen, finden Sie unter Azure Databricks – Preise.For more information on these tiers, see Databricks pricing page.

    Aktivieren Sie das Kontrollkästchen An Dashboard anheften, und klicken Sie anschließend auf Erstellen.Select Pin to dashboard and then select Create.

  3. Die Kontoerstellung dauert einige Minuten.The account creation takes a few minutes. Während der Erstellung des Kontos wird im Portal auf der rechten Seite die Kachel Submitting deployment for Azure Databricks (Bereitstellung für Azure Databricks wird übermittelt) angezeigt.During account creation, the portal displays the Submitting deployment for Azure Databricks tile on the right side. Möglicherweise müssen Sie im Dashboard nach rechts scrollen, um die Kachel zu sehen.You may need to scroll right on your dashboard to see the tile. Am oberen Bildschirmrand wird auch eine Statusanzeige angezeigt.There is also a progress bar displayed near the top of the screen. Sie können den Status beider Bereiche beobachten.You can watch either area for progress.

    Kachel zur Bereitstellung von DatabricksDatabricks deployment tile

Erstellen eines Spark-Clusters in DatabricksCreate a Spark cluster in Databricks

  1. Navigieren Sie im Azure-Portal zum erstellten Databricks-Arbeitsbereich, und klicken Sie auf Launch Workspace (Arbeitsbereich starten).In the Azure portal, go to the Databricks workspace that you created, and then select Launch Workspace.

  2. Sie werden zum Azure Databricks-Portal weitergeleitet.You are redirected to the Azure Databricks portal. Klicken Sie im Portal auf Cluster.From the portal, select Cluster.

    Databricks in AzureDatabricks on Azure

  3. Geben Sie auf der Seite Neuer Cluster die erforderlichen Werte an, um einen Cluster zu erstellen.In the New cluster page, provide the values to create a cluster.

    Erstellen eines Databricks-Spark-Clusters in AzureCreate Databricks Spark cluster on Azure

    Übernehmen Sie alle anderen Standardwerte bis auf Folgendes:Accept all other default values other than the following:

    • Geben Sie einen Namen für den Cluster ein.Enter a name for the cluster.
    • Erstellen Sie im Rahmen dieses Artikels einen Cluster mit der Runtime 4.0.For this article, create a cluster with 4.0 runtime.
    • Aktivieren Sie das Kontrollkästchen Terminate after __ minutes of inactivity (Nach Minuten Inaktivität beenden).Make sure you select the **Terminate after _ minutes of inactivity** checkbox. Geben Sie an, nach wie vielen Minuten der Cluster beendet werden soll, wenn er nicht verwendet wird.Provide a duration (in minutes) to terminate the cluster, if the cluster is not being used.

      Klicken Sie auf Cluster erstellen.Select Create cluster. Sobald der Cluster ausgeführt wird, können Sie Notizbücher an den Cluster anfügen und Spark-Aufträge ausführen.Once the cluster is running, you can attach notebooks to the cluster and run Spark jobs.

Erstellen einer Twitter-AnwendungCreate a Twitter application

Für den Empfang eines Datenstroms mit Tweets erstellen Sie eine Anwendung in Twitter.To receive a stream of tweets, you create an application in Twitter. Gehen Sie gemäß der Anleitung vor, um eine Twitter-Anwendung zu erstellen, und erfassen Sie die Werte, die Sie für dieses Tutorial benötigen.Follow the instructions create a Twitter application and record the values that you need to complete this tutorial.

  1. Navigieren Sie in einem Webbrowser zur Anwendungsverwaltung von Twitter (Twitter Application Management), und klicken Sie auf Create New App (Neue App erstellen).From a web browser, go to Twitter Application Management, and select Create New App.

    Erstellen einer Twitter-AnwendungCreate Twitter application

  2. Geben Sie auf der Seite Create an application (Anwendung erstellen) die Details für die neue App an, und klicken Sie anschließend auf Create your Twitter application (Twitter-Anwendung erstellen).In the Create an application page, provide the details for the new app, and then select Create your Twitter application.

    Twitter-AnwendungsdetailsTwitter application details

  3. Klicken Sie auf der Anwendungsseite auf die Registerkarte Keys and Access Tokens (Schlüssel und Zugriffstoken), und kopieren Sie die Werte für Consumer Key (Consumerschlüssel) und Consumer Secret (Consumergeheimnis).In the application page, select the Keys and Access Tokens tab and copy the values for Consume Key and Consumer Secret. Klicken Sie außerdem auf Create my access token (Mein Zugriffstoken erstellen), um die Zugriffstoken zu generieren.Also, select Create my access token to generate the access tokens. Kopieren Sie die Werte für Access Token (Zugriffstoken) und Access Token Secret (Zugriffstokengeheimnis).Copy the values for Access Token and Access Token Secret.

    Twitter-AnwendungsdetailsTwitter application details

Speichern Sie die Werte, die Sie für die Twitter-Anwendung abgerufen haben.Save the values that you retrieved for the Twitter application. Diese werden im weiteren Verlauf des Tutorials benötigt.You need the values later in the tutorial.

Anfügen von Bibliotheken an einen Spark-ClusterAttach libraries to Spark cluster

In diesem Tutorial verwenden Sie die Twitter-APIs, um Tweets an Event Hubs zu senden.In this tutorial, you use the Twitter APIs to send tweets to Event Hubs. Außerdem verwenden Sie den Apache Spark-Event Hubs-Connector, um Daten in Azure Event Hubs zu lesen und zu schreiben.You also use the Apache Spark Event Hubs connector to read and write data into Azure Event Hubs. Fügen Sie diese APIs als Bibliotheken in Azure Databricks hinzu, und ordnen Sie sie dann Ihrem Spark-Cluster zu, um sie als Teil Ihres Clusters zu nutzen.To use these APIs as part of your cluster, add them as libraries to Azure Databricks and then associate them with your Spark cluster. In der folgenden Anleitung wird veranschaulicht, wie Sie die Bibliothek in Ihrem Arbeitsbereich dem Ordner Freigegeben hinzufügen.The following instructions show how to add the library to the Shared folder in your workspace.

  1. Klicken Sie im Azure Databricks-Arbeitsbereich auf Arbeitsbereich und anschließend mit der rechten Maustaste auf Freigegeben.In the Azure Databricks workspace, select Workspace, and then right-click Shared. Klicken Sie im Kontextmenü auf Erstellen > Bibliothek.From the context menu, select Create > Library.

    Dialogfeld „Bibliothek hinzufügen“Add library dialog box

  2. Wählen Sie auf der Seite „Neue Bibliothek“ unter Quelle die Option Maven Coordinate (Maven-Koordinate) aus.In the New Library page, for Source select Maven Coordinate. Geben Sie unter Koordinate die Koordinate für das Paket ein, das Sie hinzufügen möchten.For Coordinate, enter the coordinate for the package you want to add. Im Anschluss finden Sie die Maven-Koordinaten für die Bibliotheken, die in diesem Tutorial verwendet werden:Here is the Maven coordinates for the libraries used in this tutorial:

    • Spark-Event Hubs-Connector: com.microsoft.azure:azure-eventhubs-spark_2.11:2.3.1Spark Event Hubs connector - com.microsoft.azure:azure-eventhubs-spark_2.11:2.3.1
    • Twitter-API: org.twitter4j:twitter4j-core:4.0.6Twitter API - org.twitter4j:twitter4j-core:4.0.6

      Angeben von Maven-KoordinatenProvide Maven coordinates

  3. Klicken Sie auf Bibliothek erstellen.Select Create Library.

  4. Wählen Sie den Ordner aus, dem Sie die Bibliothek hinzugefügt haben, und wählen Sie anschließend den Namen der Bibliothek aus.Select the folder where you added the library, and then select the library name.

    Auswählen der hinzuzufügenden BibliothekSelect library to add

  5. Wählen Sie auf der Seite für die Bibliothek den Cluster aus, in dem Sie die Bibliothek verwenden möchten.On the library page, select the cluster where you want to use the library. Nachdem die Bibliothek dem Cluster zugeordnet wurde, ändert sich der Status sofort in Angefügt.Once the library is successfully associated with the cluster, the status immediately changes to Attached.

    Anfügen der Bibliothek an den ClusterAttach library to cluster

  6. Wiederholen Sie diese Schritte für das Twitter-Paket twitter4j-core:4.0.6.Repeat these steps for the Twitter package, twitter4j-core:4.0.6.

Erstellen von Notebooks in DatabricksCreate notebooks in Databricks

In diesem Abschnitt erstellen Sie im Databricks-Arbeitsbereich zwei Notebooks mit folgenden Namen:In this section, you create two notebooks in Databricks workspace with the following names:

  • SendTweetsToEventHub: Ein Producer-Notebook, um Tweets von Twitter abzurufen und an Event Hubs zu streamen.SendTweetsToEventHub - A producer notebook you use to get tweets from Twitter and stream them to Event Hubs.
  • ReadTweetsFromEventHub: Ein Consumer-Notebook zum Lesen der Tweets aus Event Hubs.ReadTweetsFromEventHub - A consumer notebook you use to read the tweets from Event Hubs.
  1. Klicken Sie im linken Bereich auf Arbeitsbereich.In the left pane, select Workspace. Wählen Sie in der Dropdownliste Arbeitsbereich die Option Erstellen > Notebook aus.From the Workspace drop-down, select Create > Notebook.

    Erstellen eines Notizbuchs in DatabricksCreate notebook in Databricks

  2. Geben Sie im Dialogfeld Notizbuch erstellen den Namen SendTweetsToEventHub ein, wählen Sie Scala als Sprache aus, und wählen Sie den zuvor erstellten Spark-Cluster aus.In the Create Notebook dialog box, enter SendTweetsToEventHub, select Scala as the language, and select the Spark cluster that you created earlier.

    Erstellen eines Notizbuchs in DatabricksCreate notebook in Databricks

    Klicken Sie auf Erstellen.Select Create.

  3. Wiederholen Sie die Schritte, um das Notebook ReadTweetsFromEventHub zu erstellen.Repeat the steps to create the ReadTweetsFromEventHub notebook.

Senden von Tweets an Event HubsSend tweets to Event Hubs

Fügen Sie im Notebook SendTweetsToEventHub den folgenden Code ein, und ersetzen Sie die Platzhalter durch Werte für Ihren Event Hubs-Namespace und die zuvor erstellte Twitter-Anwendung.In the SendTweetsToEventHub notebook, paste the following code, and replace the placeholders with values for your Event Hubs namesapce and Twitter application that you created earlier. Mit diesem Notebook werden Tweets mit dem Schlüsselwort „Azure“ in Echtzeit an Event Hubs gestreamt.This notebook streams tweets with the keyword "Azure" into Event Hubs in real time.

    import java.util._
    import scala.collection.JavaConverters._
    import com.microsoft.azure.eventhubs._
    import java.util.concurrent._

    val namespaceName = "<EVENT HUBS NAMESPACE>"
    val eventHubName = "<EVENT HUB NAME>"
    val sasKeyName = "<POLICY NAME>"
    val sasKey = "<POLICY KEY>"
    val connStr = new ConnectionStringBuilder()
                .setNamespaceName(namespaceName)
                .setEventHubName(eventHubName)
                .setSasKeyName(sasKeyName)
                .setSasKey(sasKey)

    val pool = Executors.newFixedThreadPool(1)
    val eventHubClient = EventHubClient.create(connStr.toString(), pool)

    def sendEvent(message: String) = {
      val messageData = EventData.create(message.getBytes("UTF-8"))
      eventHubClient.get().send(messageData)
      System.out.println("Sent event: " + message + "\n")
    }

    import twitter4j._
    import twitter4j.TwitterFactory
    import twitter4j.Twitter
    import twitter4j.conf.ConfigurationBuilder

    // Twitter configuration!
    // Replace values below with yours

    val twitterConsumerKey = "<CONSUMER KEY>"
    val twitterConsumerSecret = "<CONSUMER SECRET>"
    val twitterOauthAccessToken = "<ACCESS TOKEN>"
    val twitterOauthTokenSecret = "<TOKEN SECRET>"

    val cb = new ConfigurationBuilder()
      cb.setDebugEnabled(true)
      .setOAuthConsumerKey(twitterConsumerKey)
      .setOAuthConsumerSecret(twitterConsumerSecret)
      .setOAuthAccessToken(twitterOauthAccessToken)
      .setOAuthAccessTokenSecret(twitterOauthTokenSecret)

    val twitterFactory = new TwitterFactory(cb.build())
    val twitter = twitterFactory.getInstance()

    // Getting tweets with keyword "Azure" and sending them to the Event Hub in realtime!

    val query = new Query(" #Azure ")
    query.setCount(100)
    query.lang("en")
    var finished = false
    while (!finished) {
      val result = twitter.search(query)
      val statuses = result.getTweets()
      var lowestStatusId = Long.MaxValue
      for (status <- statuses.asScala) {
        if(!status.isRetweet()){
          sendEvent(status.getText())
        }
        lowestStatusId = Math.min(status.getId(), lowestStatusId)
        Thread.sleep(2000)
      }
      query.setMaxId(lowestStatusId - 1)
    }

    // Closing connection to the Event Hub
    eventHubClient.get().close()

Drücken Sie UMSCHALT+EINGABE, um das Notebook auszuführen.To run the notebook, press SHIFT + ENTER. Die Ausgabe sieht in etwa wie im folgenden Codeausschnitt aus.You see an output like the snippet below. Jedes Ereignis der Ausgabe ist ein Tweet, der in Event Hubs erfasst wird und den Begriff „Azure“ enthält.Each event in the output is a tweet that is ingested into the Event Hubs containing the term "Azure".

Sent event: @Microsoft and @Esri launch Geospatial AI on Azure https://t.co/VmLUCiPm6q via @geoworldmedia #geoai #azure #gis #ArtificialIntelligence

Sent event: Public preview of Java on App Service, built-in support for Tomcat and OpenJDK
https://t.co/7vs7cKtvah
#cloudcomputing #Azure

Sent event: 4 Killer #Azure Features for #Data #Performance https://t.co/kpIb7hFO2j by @RedPixie

Sent event: Migrate your databases to a fully managed service with Azure SQL Database Managed Instance | #Azure | #Cloud https://t.co/sJHXN4trDk

Sent event: Top 10 Tricks to #Save Money with #Azure Virtual Machines https://t.co/F2wshBXdoz #Cloud

...
...

Lesen von Tweets aus Event HubsRead tweets from Event Hubs

Fügen Sie im Notebook ReadTweetsFromEventHub den folgenden Code ein, und ersetzen Sie den Platzhalter durch Werte für Ihre zuvor erstellten Azure Event Hubs.In the ReadTweetsFromEventHub notebook, paste the following code, and replace the placeholder with values for your Azure Event Hubs that you created earlier. Mit diesem Notebook werden die Tweets gelesen, die Sie weiter oben mit dem Notebook SendTweetsToEventHub an Event Hubs gestreamt haben.This notebook reads the tweets that you earlier streamed into Event Hubs using the SendTweetsToEventHub notebook.

    import org.apache.spark.eventhubs._

    // Build connection string with the above information
    val connectionString = ConnectionStringBuilder("<EVENT HUBS CONNECTION STRING>")
      .setEventHubName("<EVENT HUB NAME>")
      .build

    val customEventhubParameters =
      EventHubsConf(connectionString)
      .setMaxEventsPerTrigger(5)

    val incomingStream = spark.readStream.format("eventhubs").options(customEventhubParameters.toMap).load()

    incomingStream.printSchema

    // Sending the incoming stream into the console.
    // Data comes in batches!
    incomingStream.writeStream.outputMode("append").format("console").option("truncate", false).start().awaitTermination()

Sie erhalten die folgende Ausgabe:You get the following output:

root
 |-- body: binary (nullable = true)
 |-- offset: long (nullable = true)
 |-- seqNumber: long (nullable = true)
 |-- enqueuedTime: long (nullable = true)
 |-- publisher: string (nullable = true)
 |-- partitionKey: string (nullable = true)

-------------------------------------------
Batch: 0
-------------------------------------------
+------+------+--------------+---------------+---------+------------+
|body  |offset|sequenceNumber|enqueuedTime   |publisher|partitionKey|
+------+------+--------------+---------------+---------+------------+
|[50 75 62 6C 69 63 20 70 72 65 76 69 65 77 20 6F 66 20 4A 61 76 61 20 6F 6E 20 41 70 70 20 53 65 72 76 69 63 65 2C 20 62 75 69 6C 74 2D 69 6E 20 73 75 70 70 6F 72 74 20 66 6F 72 20 54 6F 6D 63 61 74 20 61 6E 64 20 4F 70 65 6E 4A 44 4B 0A 68 74 74 70 73 3A 2F 2F 74 2E 63 6F 2F 37 76 73 37 63 4B 74 76 61 68 20 0A 23 63 6C 6F 75 64 63 6F 6D 70 75 74 69 6E 67 20 23 41 7A 75 72 65]                              |0     |0             |2018-03-09 05:49:08.86 |null     |null        |
|[4D 69 67 72 61 74 65 20 79 6F 75 72 20 64 61 74 61 62 61 73 65 73 20 74 6F 20 61 20 66 75 6C 6C 79 20 6D 61 6E 61 67 65 64 20 73 65 72 76 69 63 65 20 77 69 74 68 20 41 7A 75 72 65 20 53 51 4C 20 44 61 74 61 62 61 73 65 20 4D 61 6E 61 67 65 64 20 49 6E 73 74 61 6E 63 65 20 7C 20 23 41 7A 75 72 65 20 7C 20 23 43 6C 6F 75 64 20 68 74 74 70 73 3A 2F 2F 74 2E 63 6F 2F 73 4A 48 58 4E 34 74 72 44 6B]            |168   |1             |2018-03-09 05:49:24.752|null     |null        |
+------+------+--------------+---------------+---------+------------+

-------------------------------------------
Batch: 1
-------------------------------------------
...
...

Da die Ausgabe in einem Binärmodus vorliegt, verwenden Sie den folgenden Codeausschnitt, um sie in eine Zeichenfolge zu konvertieren.Because the output is in a binary mode, use the following snippet to convert it into string.

    import org.apache.spark.sql.types._
    import org.apache.spark.sql.functions._

    // Event Hub message format is JSON and contains "body" field
    // Body is binary, so we cast it to string to see the actual content of the message
    val messages =
      incomingStream
      .withColumn("Offset", $"offset".cast(LongType))
      .withColumn("Time (readable)", $"enqueuedTime".cast(TimestampType))
      .withColumn("Timestamp", $"enqueuedTime".cast(LongType))
      .withColumn("Body", $"body".cast(StringType))
      .select("Offset", "Time (readable)", "Timestamp", "Body")

    messages.printSchema

    messages.writeStream.outputMode("append").format("console").option("truncate", false).start().awaitTermination()

Die Ausgabe sieht nun in etwa wie im folgenden Codeausschnitt aus:The output now resembles the following snippet:

root
 |-- Offset: long (nullable = true)
 |-- Time (readable): timestamp (nullable = true)
 |-- Timestamp: long (nullable = true)
 |-- Body: string (nullable = true)

-------------------------------------------
Batch: 0
-------------------------------------------
+------+-----------------+----------+-------+
|Offset|Time (readable)  |Timestamp |Body
+------+-----------------+----------+-------+
|0     |2018-03-09 05:49:08.86 |1520574548|Public preview of Java on App Service, built-in support for Tomcat and OpenJDK
https://t.co/7vs7cKtvah
#cloudcomputing #Azure          |
|168   |2018-03-09 05:49:24.752|1520574564|Migrate your databases to a fully managed service with Azure SQL Database Managed Instance | #Azure | #Cloud https://t.co/sJHXN4trDk    |
|0     |2018-03-09 05:49:02.936|1520574542|@Microsoft and @Esri launch Geospatial AI on Azure https://t.co/VmLUCiPm6q via @geoworldmedia #geoai #azure #gis #ArtificialIntelligence|
|176   |2018-03-09 05:49:20.801|1520574560|4 Killer #Azure Features for #Data #Performance https://t.co/kpIb7hFO2j by @RedPixie                                                    |
+------+-----------------+----------+-------+
-------------------------------------------
Batch: 1
-------------------------------------------
...
...

Das ist alles!That's it! Sie haben mit Azure Databricks erfolgreich und nahezu in Echtzeit Daten an Azure Event Hubs gestreamt.Using Azure Databricks, you have successfully streamed data into Azure Event Hubs in near real-time. Anschließend haben Sie die Streamdaten mithilfe des Event Hubs-Connectors für Apache Spark verarbeitet.You then consumed the stream data using the Event Hubs connector for Apache Spark. Weitere Informationen zur Verwendung des Event Hubs-Connectors für Spark finden Sie in der Connector-Dokumentation.For more information on how to use the Event Hubs connector for Spark, see the connector documentation.

Bereinigen von RessourcenClean up resources

Nach Abschluss des Tutorials können Sie den Cluster beenden.After you have finished running the tutorial, you can terminate the cluster. Klicken Sie hierzu im linken Bereich des Azure Databricks-Arbeitsbereichs auf Cluster.To do so, from the Azure Databricks workspace, from the left pane, select Clusters. Bewegen Sie den Cursor zum Beenden des Clusters auf die Auslassungspunkte in der Spalte Aktionen, und klicken Sie auf das Symbol Beenden.For the cluster you want to terminate, move the cursor over the ellipsis under Actions column, and select the Terminate icon.

Beenden eines Databricks-ClustersStop a Databricks cluster

Wenn Sie den Cluster nicht manuell beenden, wird er automatisch beendet, sofern Sie bei der Erstellung des Clusters das Kontrollkästchen Terminate after __ minutes of inactivity (Nach Minuten Inaktivität beenden) aktiviert haben.If you do not manually terminate the cluster it will automatically stop, provided you selected the **Terminate after minutes of inactivity** checkbox while creating the cluster. Der Cluster wird dann automatisch beendet, wenn er für den angegebenen Zeitraum inaktiv war.In such a case, the cluster will automatically stop if it has been inactive for the specified time.

Nächste SchritteNext steps

In diesem Tutorial haben Sie Folgendes gelernt:In this tutorial, you learned how to:

  • Erstellen eines Azure Databricks-ArbeitsbereichsCreate an Azure Databricks workspace
  • Erstellen eines Spark-Clusters in Azure DatabricksCreate a Spark cluster in Azure Databricks
  • Erstellen einer Twitter-App zum Generieren von StreamingdatenCreate a Twitter app to generate streaming data
  • Erstellen von Notebooks in Azure DatabricksCreate notebooks in Azure Databricks
  • Hinzufügen von Bibliotheken für Event Hubs und die Twitter-APIAdd libraries for Event Hubs and Twitter API
  • Senden von Tweets an Event HubsSend tweets to Event Hubs
  • Lesen von Tweets aus Event HubsRead tweets from Event Hubs

Im nächsten Tutorial erfahren Sie, wie Sie unter Verwendung von Azure Databricks und der Microsoft Cognitive Services-API eine Standpunktanalyse auf der Grundlage der gestreamten Daten durchführen.Advance to the next tutorial to learn about performing sentiment analysis on the streamed data using Azure Databricks and Microsoft Cognitive Services API.