Parsen von Apache Avro-Daten in einem Artikel

Zusammenfassung: Dieser Artikel zeigt, wie Avro-Daten serialisiert und generiert und mit FlinkSQL analysiert werden.

Offizielle Avro-Dokumentation, http://avro.apache.org/docs/current/index.html.

Einführung in Avro

Avro ist ein Datenserialisierungssystem

Bietet:

• Umfangreiche Datenstruktur
• Kompaktes, schnelles, binäres Datenformat
• Ein Dateiformat zum Speichern persistenter Daten
• Remote Procedure Call (RPC)-System
• Einfache Interaktion mit dynamischen Sprachen. Es ist nicht erforderlich, Code zum Lesen und Schreiben von Datendateien zu generieren, und es ist auch nicht erforderlich, das RPC-Protokoll zu verwenden oder zu implementieren. Die Codegenerierung ist eine Form der Optimierung, die allerdings nur bei statischen Sprachen sinnvoll ist.

Technischer Hintergrund

Mit der rasanten Entwicklung des Internets sind Spitzentechnologien wie Cloud Computing, Big Data, künstliche Intelligenz (KI) und das Internet der Dinge zum Mainstream der heutigen Hightech-Welt geworden. E-Commerce-Websites, Gesichtserkennung, selbstfahrende Autos, Smart Homes und Smart Cities usw. erleichtern den Menschen nicht nur die Versorgung mit Lebensmitteln, Kleidung, Wohnen und Transport, sondern es werden auch ständig große Mengen an Daten von verschiedenen Systemplattformen gesammelt, verarbeitet und analysiert. Dabei ist es besonders wichtig, geringe Latenz, hohen Durchsatz und Datensicherheit sicherzustellen. Apache Avro selbst wird über Schema zur binären Übertragung serialisiert, was einerseits eine schnelle Datenübertragung und andererseits Datensicherheit gewährleistet. Avro wird derzeit in verschiedenen Branchen immer häufiger eingesetzt. Besonders wichtig ist dabei die Verarbeitung und Analyse von Avro-Daten. In diesem Artikel wird gezeigt, wie Avro-Daten durch Serialisierung generiert und mit FlinkSQL analysiert werden.

Dieser Artikel ist eine Demo der Avro-Analyse. Derzeit ist FlinkSQL nur für die einfache Analyse von Avro-Daten geeignet, und komplexe verschachtelte Avro-Daten werden noch nicht unterstützt.

Szeneneinführung

In diesem Artikel werden hauptsächlich die folgenden drei Schlüsselpunkte vorgestellt:

• So serialisieren und generieren Sie Avro-Daten
• So deserialisieren und analysieren Sie Avro-Daten
• So analysieren Sie Avro-Daten mit FlinkSQL

Voraussetzungen

• Weitere Informationen zu Avro finden Sie in der Kurzanleitung auf der offiziellen Apache Avro-Website.
• Avro-Anwendungsszenarien verstehen

Verfahren

1. Erstellen Sie ein neues Avro-Maven-Projekt und konfigurieren Sie POM-Abhängigkeiten

Der Inhalt der POM-Datei ist wie folgt:

<?xml version="1.0" encoding="UTF-8"?>
<Projekt xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.huawei.bigdata</groupId>
    <artifactId>avrodemo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <Abhängigkeiten>
        <Abhängigkeit>
            <groupId>org.apache.avro</groupId>
            <artifactId>avro</artifactId>
            <version>1.8.1</version>
        </Abhängigkeit>
        <Abhängigkeit>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </Abhängigkeit>
    </Abhängigkeiten>

    <Bauen>
        <Plugins>
            <Plugin>
                <groupId>org.apache.avro</groupId>
                <artifactId>avro-maven-plugin</artifactId>
                <version>1.8.1</version>
                <Hinrichtungen>
                    <Ausführung>
                        <phase>Quellen generieren</phase>
                        <Ziele>
                            <goal>Schema</goal>
                        </Ziele>
                        <Konfiguration>
                            <sourceDirectory>${project.basedir}/src/main/avro/</sourceDirectory>
                            <outputDirectory>${project.basedir}/src/main/java/</outputDirectory>
                        </Konfiguration>
                    </Ausführung>
                </Ausführungen>
            </plugin>
            <Plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>Maven-Compiler-Plugin</artifactId>
                <Konfiguration>
                    <Quelle>1.6</Quelle>
                    <target>1.6</target>
                </Konfiguration>
            </plugin>
        </plugins>
    </bauen>

</Projekt>

Hinweis: Die obige POM-Datei konfiguriert den Pfad für automatisch generierte Klassen, nämlich ${project.basedir}/src/main/avro/ und ${project.basedir}/src/main/java/. Nach dieser Konfiguration generiert das Plug-In bei Ausführung des MVN-Befehls automatisch Klassendateien aus dem AVSC-Schema in diesem Verzeichnis und legt sie im letzteren Verzeichnis ab. Wenn das Avro-Verzeichnis nicht generiert wird, erstellen Sie es manuell.

2. Definieren Sie das Schema

Definieren Sie das Schema für Avro mit JSON. Das Schema besteht aus primitiven Typen (Null, Boolean, Int, Long, Float, Double, Bytes und String) und komplexen Typen (Record, Enum, Array, Map, Union und Fixed). Im Folgenden wird beispielsweise ein Benutzerschema definiert, ein Avro-Verzeichnis unter dem Hauptverzeichnis erstellt und dann eine neue Datei user.avsc unter dem Avro-Verzeichnis erstellt:

{"namespace": "lancoo.ecbdc.pre",
 "Typ": "Datensatz",
 "name": "Benutzer",
 "Felder": [
     {"name": "Name", "Typ": "Zeichenfolge"},
     {"name": "Favoritennummer", "Typ": ["int", "null"]},
     {"Name": "Lieblingsfarbe", "Typ": ["Zeichenfolge", "null"]}
 ]
} 

3. Kompilieren Sie das Schema

Klicken Sie auf „Kompilieren“ des zu kompilierenden Maven-Projekts. Dadurch werden automatisch der Namespace-Pfad und der Benutzerklassencode erstellt.

4. Serialisierung

Erstellen einer TestUser-Klasse zum Serialisieren generierter Daten

Benutzer user1 = neuer Benutzer();
Benutzer1.setName("Alyssa");
Benutzer1.setFavoriteNumber(256);
//Belassen Sie die bevorzugte Spalte oder null

// Alternativer Konstruktor
Benutzer user2 = neuer Benutzer("Ben", 7, "rot");

// Über den Builder konstruieren
Benutzer user3 = User.newBuilder()
        .setName("Charlie")
        .setFavoriteColor("blau")
        .setFavoriteNumber(null)
        .bauen();

//Benutzer1, Benutzer2 und Benutzer3 auf die Festplatte serialisieren
DatumWriter<Benutzer> userDatumWriter = neuer SpecificDatumWriter<Benutzer>(User.class);
DataFileWriter<Benutzer> dataFileWriter = neuer DataFileWriter<Benutzer>(userDatumWriter);
dataFileWriter.create(user1.getSchema(), neue Datei("user_generic.avro"));
dataFileWriter.append(Benutzer1);
dataFileWriter.append(Benutzer2);
dataFileWriter.append(Benutzer3);
dataFileWriter.close();

Nach der Ausführung des Serialisierungsprogramms werden Avro-Daten im selben Verzeichnis des Projekts generiert

Der Inhalt von user_generic.avro ist wie folgt:

Objavro.schema�{"Typ":"Datensatz","Name":"Benutzer","Namespace":"lancoo.ecbdc.pre","Felder":[{"Name":"Name","Typ":"Zeichenfolge"},{"Name":"Favoritennummer","Typ":["int","null"]},{"Name":"Favoritenfarbe","Typ":["Zeichenfolge","null"]}]}

5. Deserialisierung

Analysieren von Avro-Daten durch Deserialisierungscode

// Deserialisieren Sie Benutzer von der Festplatte
DatumReader<Benutzer> userDatumReader = neuer SpecificDatumReader<Benutzer>(User.class);
DataFileReader<Benutzer> dataFileReader = neuer DataFileReader<Benutzer>(neue Datei("user_generic.avro"), userDatumReader);
Benutzer Benutzer = null;
während (dataFileReader.hasNext()) {
    // Benutzerobjekt wiederverwenden, indem es an next() übergeben wird. Dies erspart uns
    // Zuweisen und Garbage Collecting vieler Objekte für Dateien mit
    // viele Artikel.
    Benutzer = dataFileReader.next(Benutzer);
    System.out.println(Benutzer);
}

Führen Sie den Deserialisierungscode aus, um user_generic.avro zu analysieren

Die Avro-Datenanalyse war erfolgreich.

6. Laden Sie user_generic.avro in den hdfs-Pfad hoch

hdfs dfs -mkdir -p /tmp/lztest/
hdfs dfs -put user_generic.avro /tmp/lztest/ 

7. Konfigurieren Sie Flinkserver

Bereiten Sie das Avro-JAR-Paket vor

Fügen Sie flink-sql-avro-*.jar und flink-sql-avro-confluent-registry-*.jar in die Flinkserver-Bibliothek ein und führen Sie den folgenden Befehl auf allen Flinkserver-Knoten aus

cp /opt/huawei/Bigdata/FusionInsight_Flink_8.1.2/install/FusionInsight-Flink-1.12.2/flink/opt/flink-sql-avro*.jar /opt/huawei/Bigdata/FusionInsight_Flink_8.1.3/install/FusionInsight-Flink-1.12.2/flink/lib
chmod 500 flink-sql-avro*.jar
chown omm:wheel flink-sql-avro*.jar 

Starten Sie gleichzeitig die FlinkServer-Instanz neu und prüfen Sie, ob das Avro-Paket nach dem Neustart hochgeladen ist.

hdfs dfs -ls /FusionInsight_FlinkServer/8.1.2-312005/lib

8. Schreiben Sie FlinkSQL

Tabelle erstellen testHdfs(
  Name-String,
  Favoritennummer int,
  favorite_color Zeichenfolge
) MIT(
  'Connector' = 'Dateisystem',
  'Pfad' = 'hdfs:///tmp/lztest/user_generic.avro',
  'Format' = 'avro'
);TABELLE ERSTELLEN KafkaTable (
  Name-String,
  Favoritennummer int,
  favorite_color Zeichenfolge
) MIT (
  'Anschluss' = 'kafka',
  'Thema' = 'Testavro',
  'Eigenschaften.bootstrap.servers' = '96.10.2.1:21005',
  'properties.group.id' = 'Testgruppe',
  'scan.startup.mode' = 'neuester Offset',
  'Format' = 'avro'
);
einfügen in
  KafkaTisch
wählen
  *
aus
  testeHdfs; 

Aufgabe speichern

9. Prüfen Sie, ob im entsprechenden Thema Daten vorhanden sind

FlinkSQL hat die Avro-Daten erfolgreich analysiert.

Dies ist das Ende dieses Artikels zum Parsen von Apache Avro-Daten in einem Artikel. Weitere relevante Apache Avro-Dateninhalte finden Sie in den vorherigen Artikeln von 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!