Tutorial: Verwenden von strukturiertem Apache Spark-Streaming mit Apache Kafka in HDInsightTutorial: Use Apache Spark Structured Streaming with Apache Kafka on HDInsight

Dieses Tutorial veranschaulicht die Verwendung des strukturierten Apache Spark-Streamings zum Lesen und Schreiben von Daten mit Apache Kafka in Azure HDInsight.This tutorial demonstrates how to use Apache Spark Structured Streaming to read and write data with Apache Kafka on Azure HDInsight.

Strukturiertes Spark-Streaming ist ein auf Spark SQL beruhendes Modul zur Streamverarbeitung.Spark Structured Streaming is a stream processing engine built on Spark SQL. Sie können damit Streamingberechnungen genauso wie Batchberechnung auf statischen Daten ausdrücken.It allows you to express streaming computations the same as batch computation on static data.

In diesem Tutorial lernen Sie Folgendes:In this tutorial, you learn how to:

  • Verwenden einer Azure Resource Manager-Vorlage zum Erstellen von ClusternUse an Azure Resource Manager template to create clusters
  • Verwenden des strukturierten Spark-Streamings mit KafkaUse Spark Structured Streaming with Kafka

Denken Sie nach dem Ausführen der Schritte in diesem Dokument daran, die Cluster zu löschen, um das Anfallen von Gebühren zu verhindern.When you are done with the steps in this document, remember to delete the clusters to avoid excess charges.

VoraussetzungenPrerequisites

Wichtig

Für die in diesem Dokument beschriebenen Schritte wird eine Azure-Ressourcengruppe benötigt, die sowohl einen Spark- und einen Kafka-Cluster in HDInsight beinhaltet.The steps in this document require an Azure resource group that contains both a Spark on HDInsight and a Kafka on HDInsight cluster. Die Cluster befinden sich innerhalb eines virtuellen Azure-Netzwerks, wodurch Spark- und Kafka-Cluster direkt miteinander kommunizieren können.These clusters are both located within an Azure Virtual Network, which allows the Spark cluster to directly communicate with the Kafka cluster.

Der Einfachheit halber enthält dieses Dokument Links zu einer Vorlage, mit der die erforderlichen Azure-Ressourcen erstellt werden können.For your convenience, this document links to a template that can create all the required Azure resources.

Weitere Informationen zur Verwendung von HDInsight in einem virtuellen Netzwerk finden Sie im Dokument Erweitern von HDInsight mit einem virtuellen Netzwerk.For more information on using HDInsight in a virtual network, see the Extend HDInsight using a virtual network document.

Strukturiertes Streaming mit Apache KafkaStructured Streaming with Apache Kafka

Das strukturierte Spark-Streaming ist eine auf Spark SQL basierende Streamverarbeitungs-Engine.Spark Structured Streaming is a stream processing engine built on the Spark SQL engine. Wenn Sie das strukturierte Streaming verwenden, können Sie Streamingabfragen auf dieselbe Weise wie Batchabfragen schreiben.When using Structured Streaming, you can write streaming queries the same way that you write batch queries.

Die folgenden Codeausschnitte veranschaulichen das Lesen aus Kafka und das Speichern in einer Datei.The following code snippets demonstrate reading from Kafka and storing to file. Der erste ist ein Batchvorgang, und der zweite ist ein Streamingvorgang:The first one is a batch operation, while the second one is a streaming operation:

// Read a batch from Kafka
val kafkaDF = spark.read.format("kafka")
                .option("kafka.bootstrap.servers", kafkaBrokers)
                .option("subscribe", kafkaTopic)
                .option("startingOffsets", "earliest")
                .load()

// Select data and write to file
kafkaDF.select(from_json(col("value").cast("string"), schema) as "trip")
                .write
                .format("parquet")
                .option("path","/example/batchtripdata")
                .option("checkpointLocation", "/batchcheckpoint")
                .save()
// Stream from Kafka
val kafkaStreamDF = spark.readStream.format("kafka")
                .option("kafka.bootstrap.servers", kafkaBrokers)
                .option("subscribe", kafkaTopic)
                .option("startingOffsets", "earliest")
                .load()

// Select data from the stream and write to file
kafkaStreamDF.select(from_json(col("value").cast("string"), schema) as "trip")
                .writeStream
                .format("parquet")
                .option("path","/example/streamingtripdata")
                .option("checkpointLocation", "/streamcheckpoint")
                .start.awaitTermination(30000)

In beiden Ausschnitten werden die Daten aus Kafka gelesen und in eine Datei geschrieben.In both snippets, data is read from Kafka and written to file. Folgende Unterschiede weisen die Beispiele auf:The differences between the examples are:

BatchBatch StreamingStreaming
read readStream
write writeStream
save start

Der Streamingvorgang verwendet außerdem awaitTermination(30000), sodass der Stream nach 30.000 ms beendet wird.The streaming operation also uses awaitTermination(30000), which stops the stream after 30,000 ms.

Um das strukturierte Streaming mit Kafka zu verwenden, benötigt das Projekt eine Abhängigkeit im Paket org.apache.spark : spark-sql-kafka-0-10_2.11.To use Structured Streaming with Kafka, your project must have a dependency on the org.apache.spark : spark-sql-kafka-0-10_2.11 package. Die Version dieses Pakets sollte der Version von Spark in HDInsight entsprechen.The version of this package should match the version of Spark on HDInsight. Für Spark 2.2.0 (verfügbar in HDInsight 3.6) finden Sie die Abhängigkeitsinformationen für verschiedene Projekttypen unter https://search.maven.org/#artifactdetails%7Corg.apache.spark%7Cspark-sql-kafka-0-10_2.11%7C2.2.0%7Cjar.For Spark 2.2.0 (available in HDInsight 3.6), you can find the dependency information for different project types at https://search.maven.org/#artifactdetails%7Corg.apache.spark%7Cspark-sql-kafka-0-10_2.11%7C2.2.0%7Cjar.

Für das in diesem Tutorial verwendete Jupyter Notebook lädt die folgende Zelle diese Paketabhängigkeit:For the Jupyter Notebook used with this tutorial, the following cell loads this package dependency:

%%configure -f
{
    "conf": {
        "spark.jars.packages": "org.apache.spark:spark-sql-kafka-0-10_2.11:2.2.0",
        "spark.jars.excludes": "org.scala-lang:scala-reflect,org.apache.spark:spark-tags_2.11"
    }
}

Erstellen von ClusternCreate the clusters

Apache Kafka in HDInsight ermöglicht keinen Zugriff auf die Kafka-Broker über das öffentliche Internet.Apache Kafka on HDInsight does not provide access to the Kafka brokers over the public internet. Alle von Kafka verwendeten Elemente müssen sich im gleichen virtuellen Azure-Netzwerk befinden.Anything that uses Kafka must be in the same Azure virtual network. In diesem Tutorial befinden sich der Kafka- und der Spark-Cluster im gleichen virtuellen Azure-Netzwerk.In this tutorial, both the Kafka and Spark clusters are located in the same Azure virtual network.

Das folgende Diagramm zeigt den Kommunikationsfluss zwischen Spark und Kafka:The following diagram shows how communication flows between Spark and Kafka:

Diagramm der Spark- und Kafka-Cluster in einem virtuellen Azure-Netzwerk

Hinweis

Der Kafka-Dienst ist auf die Kommunikation innerhalb des virtuellen Netzwerks beschränkt.The Kafka service is limited to communication within the virtual network. Auf andere Dienste auf dem Cluster, wie z.B. SSH und Ambari, kann über das Internet zugegriffen werden.Other services on the cluster, such as SSH and Ambari, can be accessed over the internet. Weitere Informationen zu den öffentlichen Ports, die für HDInsight verfügbar sind, finden Sie unter Von HDInsight verwendete Ports und URIs.For more information on the public ports available with HDInsight, see Ports and URIs used by HDInsight.

Führen Sie zum Erstellen eines virtuellen Azure-Netzwerks und zum anschließenden Erstellen der Kafka- und Spark-Cluster in diesem die folgenden Schritte aus:To create an Azure Virtual Network, and then create the Kafka and Spark clusters within it, use the following steps:

  1. Verwenden Sie die folgende Schaltfläche, um sich bei Azure anzumelden, und öffnen Sie die Vorlage im Azure-Portal.Use the following button to sign in to Azure and open the template in the Azure portal.

    Deploy to Azure

    Die Azure Resource Manager-Vorlage finden Sie unter https://raw.githubusercontent.com/Azure-Samples/hdinsight-spark-kafka-structured-streaming/master/azuredeploy.json .The Azure Resource Manager template is located at https://raw.githubusercontent.com/Azure-Samples/hdinsight-spark-kafka-structured-streaming/master/azuredeploy.json.

    Diese Vorlage erstellt die folgenden Ressourcen:This template creates the following resources:

    • Ein Kafka-auf-HDInsight-3.6-Cluster.A Kafka on HDInsight 3.6 cluster.

    • Einen Spark 2.2.0-Cluster in HDInsight 3.6.A Spark 2.2.0 on HDInsight 3.6 cluster.

    • Ein Azure Virtual Network, das die HDInsight-Cluster enthält.An Azure Virtual Network, which contains the HDInsight clusters.

      Wichtig

      Das in diesem Tutorial für strukturiertes Streaming verwendete Notebook benötigt Spark 2.2.0 in HDInsight 3.6.The structured streaming notebook used in this tutorial requires Spark 2.2.0 on HDInsight 3.6. Bei Verwendung einer früheren Version von Spark auf HDInsight erhalten Sie Fehlermeldungen, wenn Sie das Notebook verwenden.If you use an earlier version of Spark on HDInsight, you receive errors when using the notebook.

  2. Geben Sie im Abschnitt Benutzerdefinierte Vorlage folgende Informationen an:Use the following information to populate the entries on the Customized template section:

    EinstellungSetting WertValue
    AbonnementSubscription Ihr Azure-AbonnementYour Azure subscription
    RessourcengruppeResource group Die Ressourcengruppe mit den Ressourcen.The resource group that contains the resources.
    LocationLocation Die Azure-Region, in der die Ressourcen erstellt werden.The Azure region that the resources are created in.
    Spark Cluster Name (Spark-Clustername)Spark Cluster Name Der Name des Spark-Clusters.The name of the Spark cluster. Die ersten sechs Zeichen müssen sich vom Kafka-Clusternamen unterscheiden.The first six characters must be different than the Kafka cluster name.
    Kafka Cluster Name (Kafka-Clustername)Kafka Cluster Name Der Name des Kafka-Clusters.The name of the Kafka cluster. Die ersten sechs Zeichen müssen sich vom Spark-Clusternamen unterscheiden.The first six characters must be different than the Spark cluster name.
    Benutzername für ClusteranmeldungCluster Login User Name Der Administratorbenutzername für die Cluster.The admin user name for the clusters.
    Kennwort für ClusteranmeldungCluster Login Password Das Administratorbenutzerkennwort für die Cluster.The admin user password for the clusters.
    SSH-BenutzernameSSH User Name Der SSH-Benutzer, der für die Cluster erstellt werden soll.The SSH user to create for the clusters.
    SSH-KennwortSSH Password Das Kennwort für den SSH-Benutzer.The password for the SSH user.

    Screenshot der angepassten Vorlage

  3. Lesen Sie die Geschäftsbedingungen, und wählen Sie anschließend die Option Ich stimme den oben genannten Geschäftsbedingungen zu aus.Read the Terms and Conditions, and then select I agree to the terms and conditions stated above

  4. Aktivieren Sie zum Schluss An Dashboard anheften, und wählen Sie dann Kaufen aus.Finally, check Pin to dashboard and then select Purchase.

Hinweis

Die Clustererstellung kann bis zu 20 Minuten dauern.It can take up to 20 minutes to create the clusters.

Verwenden des strukturierten Spark-StreamingsUse Spark Structured Streaming

Dieses Beispiel zeigt, wie Sie strukturiertes Spark-Streaming mit Kafka in HDInsight verwenden.This example demonstrates how to use Spark Structured Streaming with Kafka on HDInsight. Im Beispiel werden von New York City bereitgestellte Daten für Taxifahrten verwendet.It uses data on taxi trips, which is provided by New York City. Das von diesem Notebook verwendete Dataset stammt aus 2016 Green Taxi Trip Data.The data set used by this notebook is from 2016 Green Taxi Trip Data.

  1. Sammeln Sie Hostinformationen.Gather host information. Verwenden Sie die unten stehenden cURL- und jq-Befehle, um Ihre Kafka ZooKeeper- und -Broker-Hostinformationen abzurufen.Use the curl and jq commands below to obtain your Kafka ZooKeeper and broker hosts information. Die Befehle sind für eine Windows-Eingabeaufforderung vorgesehen. Für andere Umgebungen sind geringfügige Änderungen erforderlich.The commands are designed for a Windows command prompt, slight variations will be needed for other environments. Ersetzen Sie KafkaCluster durch den Namen Ihres Kafka-Clusters und KafkaPassword durch das Kennwort für die Clusteranmeldung.Replace KafkaCluster with the name of your Kafka cluster, and KafkaPassword with the cluster login password. Ersetzen Sie außerdem C:\HDI\jq-win64.exe durch den tatsächlichen Pfad zu Ihrer jq-Installation.Also, replace C:\HDI\jq-win64.exe with the actual path to your jq installation. Geben Sie die Befehle an einer Windows-Eingabeaufforderung ein, und speichern Sie die Ausgabe zur Verwendung in späteren Schritten.Enter the commands in a Windows command prompt and save the output for use in later steps.

    set CLUSTERNAME=KafkaCluster
    set PASSWORD=KafkaPassword
    
    curl -u admin:%PASSWORD% -G "https://%CLUSTERNAME%.azurehdinsight.net/api/v1/clusters/%CLUSTERNAME%/services/ZOOKEEPER/components/ZOOKEEPER_SERVER" | C:\HDI\jq-win64.exe -r "["""\(.host_components[].HostRoles.host_name):2181"""] | join(""",""")"
    
    curl -u admin:%PASSWORD% -G "https://%CLUSTERNAME%.azurehdinsight.net/api/v1/clusters/%CLUSTERNAME%/services/KAFKA/components/KAFKA_BROKER" | C:\HDI\jq-win64.exe -r "["""\(.host_components[].HostRoles.host_name):9092"""] | join(""",""")"
    
  2. Verbinden Sie in Ihrem Webbrowser das Jupyter Notebook mit Ihrem Spark-Cluster.In your web browser, connect to the Jupyter notebook on your Spark cluster. Ersetzen Sie in der folgenden URL CLUSTERNAME durch den Namen Ihres Spark-Clusters:In the following URL, replace CLUSTERNAME with the name of your Spark cluster:

     https://CLUSTERNAME.azurehdinsight.net/jupyter
    

    Geben Sie bei Aufforderung den Clusterbenutzernamen (Administrator) und das Kennwort ein, den bzw. das Sie beim Erstellen des Clusters verwendet haben.When prompted, enter the cluster login (admin) and password used when you created the cluster.

  3. Wählen Sie Neu > Spark aus, um ein Notebook zu erstellen.Select New > Spark to create a notebook.

  4. Laden Sie die vom Notebook verwendeten Pakete, indem Sie die folgenden Informationen in einer Zelle des Notebooks eingeben.Load packages used by the Notebook by entering the following information in a Notebook cell. Führen Sie den Befehl mit STRG+EINGABETASTEaus.Run the command by using CTRL + ENTER.

    %%configure -f
    {
        "conf": {
            "spark.jars.packages": "org.apache.spark:spark-sql-kafka-0-10_2.11:2.2.0",
            "spark.jars.excludes": "org.scala-lang:scala-reflect,org.apache.spark:spark-tags_2.11"
        }
    }
    
  5. Erstellen Sie das Kafka-Thema.Create the Kafka topic. Bearbeiten Sie den folgenden Befehl, indem Sie YOUR_ZOOKEEPER_HOSTS durch die ZooKeeper-Hostinformationen ersetzen, die Sie im ersten Schritt extrahiert haben.Edit the command below by replacing YOUR_ZOOKEEPER_HOSTS with the Zookeeper host information extracted in the first step. Geben Sie den bearbeiteten Befehl in Ihrem Jupyter Notebook ein, um das Thema tripdata zu erstellen.Enter the edited command in your Jupyter Notebook to create the tripdata topic.

    %%bash
    export KafkaZookeepers="YOUR_ZOOKEEPER_HOSTS"
    
    /usr/hdp/current/kafka-broker/bin/kafka-topics.sh --create --replication-factor 3 --partitions 8 --topic tripdata --zookeeper $KafkaZookeepers
    
  6. Rufen Sie Daten zu Taxifahrten ab.Retrieve data on taxi trips. Geben Sie den Befehl in der nächsten Zelle ein, um Daten zu Taxifahrten in New York City zu laden.Enter the command in the next cell to load data on taxi trips in New York City. Die Daten werden in einen Datenrahmen geladen, der dann als Zellenausgabe angezeigt wird.The data is loaded into a dataframe and then the dataframe is displayed as the cell output.

    import spark.implicits._
    
    // Load the data from the New York City Taxi data REST API for 2016 Green Taxi Trip Data
    val url="https://data.cityofnewyork.us/resource/pqfs-mqru.json"
    val result = scala.io.Source.fromURL(url).mkString
    
    // Create a dataframe from the JSON data
    val taxiDF = spark.read.json(Seq(result).toDS)
    
    // Display the dataframe containing trip data
    taxiDF.show()
    
  7. Legen Sie die Hostinformationen für den Kafka-Broker fest.Set the Kafka broker hosts information. Ersetzen Sie YOUR_KAFKA_BROKER_HOSTS durch die Broker-Hostinformationen, die Sie in Schritt 1 extrahiert haben.Replace YOUR_KAFKA_BROKER_HOSTS with the broker hosts information you extracted in step 1. Geben Sie den bearbeiteten Befehl in der nächsten Zelle des Jupyter Notebooks ein.Enter the edited command in the next Jupyter Notebook cell.

    // The Kafka broker hosts and topic used to write to Kafka
    val kafkaBrokers="YOUR_KAFKA_BROKER_HOSTS"
    val kafkaTopic="tripdata"
    
    println("Finished setting Kafka broker and topic configuration.")
    
  8. Senden Sie die Daten an Kafka.Send the data to Kafka. Im folgenden Befehl wird das Feld vendorid als Schlüsselwert für die Kafka-Nachricht verwendet.In the following command, the vendorid field is used as the key value for the Kafka message. Der Schlüssel wird beim Partitionieren von Daten von Kafka verwendet.The key is used by Kafka when partitioning data. Alle Felder werden in der Kafka-Nachricht als JSON-Zeichenfolgenwert gespeichert.All of the fields are stored in the Kafka message as a JSON string value. Geben Sie den folgenden Befehl in Jupyter ein, um die Daten mithilfe einer Batchabfrage in Kafka zu speichern.Enter the following command in Jupyter to save the data to Kafka using a batch query.

    // Select the vendorid as the key and save the JSON string as the value.
    val query = taxiDF.selectExpr("CAST(vendorid AS STRING) as key", "to_JSON(struct(*)) AS value").write.format("kafka").option("kafka.bootstrap.servers", kafkaBrokers).option("topic", kafkaTopic).save()
    
    println("Data sent to Kafka")
    
  9. Deklarieren Sie ein Schema.Declare a schema. Der folgende Befehl zeigt, wie Sie beim Lesen von JSON-Daten aus Kafka ein Schema verwenden.The following command demonstrates how to use a schema when reading JSON data from kafka. Geben Sie den Befehl in der nächsten Jupyter-Zelle ein.Enter the command in your next Jupyter cell.

    // Import bits useed for declaring schemas and working with JSON data
    import org.apache.spark.sql._
    import org.apache.spark.sql.types._
    import org.apache.spark.sql.functions._
    
    // Define a schema for the data
    val schema = (new StructType).add("dropoff_latitude", StringType).add("dropoff_longitude", StringType).add("extra", StringType).add("fare_amount", StringType).add("improvement_surcharge", StringType).add("lpep_dropoff_datetime", StringType).add("lpep_pickup_datetime", StringType).add("mta_tax", StringType).add("passenger_count", StringType).add("payment_type", StringType).add("pickup_latitude", StringType).add("pickup_longitude", StringType).add("ratecodeid", StringType).add("store_and_fwd_flag", StringType).add("tip_amount", StringType).add("tolls_amount", StringType).add("total_amount", StringType).add("trip_distance", StringType).add("trip_type", StringType).add("vendorid", StringType)
    // Reproduced here for readability
    //val schema = (new StructType)
    //   .add("dropoff_latitude", StringType)
    //   .add("dropoff_longitude", StringType)
    //   .add("extra", StringType)
    //   .add("fare_amount", StringType)
    //   .add("improvement_surcharge", StringType)
    //   .add("lpep_dropoff_datetime", StringType)
    //   .add("lpep_pickup_datetime", StringType)
    //   .add("mta_tax", StringType)
    //   .add("passenger_count", StringType)
    //   .add("payment_type", StringType)
    //   .add("pickup_latitude", StringType)
    //   .add("pickup_longitude", StringType)
    //   .add("ratecodeid", StringType)
    //   .add("store_and_fwd_flag", StringType)
    //   .add("tip_amount", StringType)
    //   .add("tolls_amount", StringType)
    //   .add("total_amount", StringType)
    //   .add("trip_distance", StringType)
    //   .add("trip_type", StringType)
    //   .add("vendorid", StringType)
    
    println("Schema declared")
    
  10. Wählen Sie Daten aus, und starten Sie den Stream.Select data and start the stream. Der folgende Befehl zeigt, wie Daten mithilfe einer Batchabfrage aus Kafka abgerufen und die Ergebnisse anschließend in das Hadoop Distributed File System (HDFS) auf dem Spark-Cluster geschrieben werden.The following command demonstrates how to retrieve data from kafka using a batch query, and then write the results out to HDFS on the Spark cluster. In diesem Beispiel ruft select die Nachricht (Wertfeld) aus Kafka ab und wendet das Schema an.In this example, the select retrieves the message (value field) from Kafka and applies the schema to it. Die Daten werden dann im Parquet-Format in das Hadoop Distributed File System (WASB oder ADL) geschrieben.The data is then written to HDFS (WASB or ADL) in parquet format. Geben Sie den Befehl in der nächsten Jupyter-Zelle ein.Enter the command in your next Jupyter cell.

    // Read a batch from Kafka
    val kafkaDF = spark.read.format("kafka").option("kafka.bootstrap.servers", kafkaBrokers).option("subscribe", kafkaTopic).option("startingOffsets", "earliest").load()
    
    // Select data and write to file
    val query = kafkaDF.select(from_json(col("value").cast("string"), schema) as "trip").write.format("parquet").option("path","/example/batchtripdata").option("checkpointLocation", "/batchcheckpoint").save()
    
    println("Wrote data to file")
    
  11. Sie können überprüfen, ob die Dateien erstellt wurden, indem Sie den Befehl in Ihrer nächsten Jupyter-Zelle eingeben.You can verify that the files were created by entering the command in your next Jupyter cell. Der Befehl listet die Dateien im Verzeichnis /example/batchtripdata auf.It lists the files in the /example/batchtripdata directory.

    %%bash
    hdfs dfs -ls /example/batchtripdata
    
  12. Im vorherige Beispiel wurde eine Batchabfrage verwendet. Der folgende Befehl zeigt, wie Sie den gleichen Vorgang mit einer Streamingabfrage ausführen.While the previous example used a batch query, the following command demonstrates how to do the same thing using a streaming query. Geben Sie den Befehl in der nächsten Jupyter-Zelle ein.Enter the command in your next Jupyter cell.

    // Stream from Kafka
    val kafkaStreamDF = spark.readStream.format("kafka").option("kafka.bootstrap.servers", kafkaBrokers).option("subscribe", kafkaTopic).option("startingOffsets", "earliest").load()
    
    // Select data from the stream and write to file
    kafkaStreamDF.select(from_json(col("value").cast("string"), schema) as "trip").writeStream.format("parquet").option("path","/example/streamingtripdata").option("checkpointLocation", "/streamcheckpoint").start.awaitTermination(30000)
    println("Wrote data to file")
    
  13. Führen Sie die folgende Zelle aus, um zu überprüfen, ob die Dateien von der Streamingabfrage geschrieben wurden.Run the following cell to verify that the files were written by the streaming query.

    %%bash
    hdfs dfs -ls /example/streamingtripdata
    

Bereinigen von RessourcenClean up resources

Zum Bereinigen der im Rahmen dieses Tutorials erstellten Ressourcen können Sie die Ressourcengruppe löschen.To clean up the resources created by this tutorial, you can delete the resource group. Dadurch werden auch der zugeordnete HDInsight-Cluster sowie alle anderen Ressourcen gelöscht, die der Ressourcengruppe zugeordnet sind.Deleting the resource group also deletes the associated HDInsight cluster, and any other resources associated with the resource group.

So entfernen Sie die Ressourcengruppe über das Azure-Portal:To remove the resource group using the Azure portal:

  1. Erweitern Sie im Azure-Portal das Menü auf der linken Seite, um das Menü mit den Diensten zu öffnen, und klicken Sie auf Ressourcengruppen, um die Liste mit Ihren Ressourcengruppen anzuzeigen.In the Azure portal, expand the menu on the left side to open the menu of services, and then choose Resource Groups to display the list of your resource groups.
  2. Suchen Sie die zu löschende Ressourcengruppe, und klicken Sie mit der rechten Maustaste rechts neben dem Eintrag auf die Schaltfläche Mehr (...).Locate the resource group to delete, and then right-click the More button (...) on the right side of the listing.
  3. Klicken Sie auf Ressourcengruppe löschen, und bestätigen Sie den Vorgang.Select Delete resource group, and then confirm.

Warnung

Die Abrechnung für einen HDInsight-Cluster beginnt, sobald der Cluster erstellt wurde, und endet mit dem Löschen des Clusters.HDInsight cluster billing starts once a cluster is created and stops when the cluster is deleted. Die Gebühren werden anteilig nach Minuten erhoben. Daher sollten Sie Ihren Cluster immer löschen, wenn Sie ihn nicht mehr verwenden.Billing is pro-rated per minute, so you should always delete your cluster when it is no longer in use.

Wenn Sie einen Kafka-Cluster in HDInsight löschen, werden auch alle in Kafka gespeicherten Daten gelöscht.Deleting a Kafka on HDInsight cluster deletes any data stored in Kafka.

Nächste SchritteNext steps

In diesem Tutorial haben Sie gelernt, wie Sie das strukturierte Apache Spark-Streaming zum Schreiben und Lesen von Daten aus Apache Kafka in HDInsight verwenden.In this tutorial, you learned how to use Apache Spark Structured Streaming to write and read data from Apache Kafka on HDInsight. Unter dem folgenden Link erfahren Sie, wie Sie Apache Storm mit Kafka verwenden:Use the following link to learn how to use Apache Storm with Kafka.