Protokollaggregation und -analyse (Arbeiten mit AWS Athena in Java)

Vorherige Geschichte

Ich überlegte, die Protokolle der Webanwendung zu sammeln und zu analysieren und die Ergebnisse zu visualisieren, und überlegte, welche Art von Konfiguration es sein würde, wenn ich sie selbst erstellen wollte. Es ist eine Geschichte des Prüfungsprozesses zu dieser Zeit und des Dienstes, der tatsächlich in der angenommenen AWS-Umgebung verwendet wird.

Zu Beginn der Überlegung

Ich dachte, Kibana wäre genug ...

Zuerst gab es eine Zeit, in der ich mich fragte, ob elastische Suche → Kibana ausreichen würde ... Natürlich ist es mit Elasticsearch möglich, Protokolle zu suchen, zu aggregieren und mit Kibana zu visualisieren. Es ist jedoch schwierig, die aggregierten Ergebnisse auf einer anderen Achse anzuzeigen. Wenn Sie Kibana verwenden, können andere Personen das Rohprotokoll anzeigen. Daher gibt es verschiedene Probleme, sodass der Kibana-Plan verschwunden ist. Es war.

Vorschlag, das aggregierte Ergebnis in RDB zu setzen

Die Aggregation scheint bei der elastischen Suche kein Problem zu sein. Kann ich also die erforderlichen Daten von RDB abrufen, wenn ich das aggregierte Ergebnis in RDB einfüge und es visualisiere? Ich dachte.

Aber ... ich habe mich für die Zeitreihen-Datenbank entschieden, weil ich selbst dann, wenn ich die aggregierten Ergebnisse in die RDB eingefügt habe, keine so guten Ergebnisse in Bezug auf die Leistung erzielt habe, als ich sie zur Analyse herausgenommen habe.

Fassen Sie den bisherigen Ablauf zusammen

1. Schieben Sie das Web-App-Protokoll in Elasticsearch
2. Aggregieren Sie mit Elasticsearch und fügen Sie es in die Zeitreihen-DB ein (Kandidat zu diesem Zeitpunkt ist InfluxDB).
3. Extrahieren Sie aus InfluxDB auf der Achse, die Sie analysieren und grafisch darstellen möchten

Ich habe mich für eine solche Systemkonfiguration entschieden.

Aufgrund verschiedener Überlegungen scheint es jedoch, dass es in Bezug auf die Infrastruktur Geld kosten wird, weshalb ich beschlossen habe, einen anderen Plan in Betracht zu ziehen ...

Daher wurde vorgeschlagen, die AWS-Umgebung einzubauen.

Ziehen Sie die Konfiguration in Betracht, indem Sie AWS-Services kombinieren

Organisieren Sie, was Sie tun möchten

Was ich tun möchte, ist die von der Anwendung ausgegebene Ausgabe "Ich möchte Protokolle aggregieren, analysieren und visualisieren !!".

Zu verwendende Dienste

Wenn Sie den AWS-Service vorerst überprüfen, scheint der folgende Ablauf möglich zu sein

1. Platzieren Sie Anwendungsprotokolle mit fluentd auf S3
2. Rufen Sie Athena von Lambda aus an und fassen Sie die in S3 platzierten Protokolle zusammen (Wenn Athena ausgeführt wird, wird die CSV des Aggregationsergebnisses ausgegeben.)
3. Richten Sie für die Analyse die CSV-Ausgabe auf 2 aus und aggregieren Sie sie erneut mit Athena auf der gewünschten Achse.

Der Ablauf ist so einfach.

Probe zur Bedienung von Athena

Verwenden Sie den von AWS bereitgestellten JDBC für Athena, um Athena von Java aus zu betreiben. Derzeit (Stand November 2018) ist AthenaJDBC42-2.0.5.jar die neueste Version, jedoch [hier herunterladen](https://docs.aws.amazon.com/athena/latest/ug/connect-with-jdbc. html) Sie können.

Java-Code zum Aufrufen von Athena zur Registrierung bei Lambda in Flow 2.

    import java.io.File;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.Statement;
    import java.util.Properties;
  
    public class AthenaService {  

        //Athena Ohio Einstellungen
        private static final String CONNECTION_URL = "jdbc:awsathena://athena.us-east-2.amazonaws.com:443";
        private static final String S3_BUCKET = "test-bucket";

        public void execute(String dateTime) {

            Properties info = new Properties();

            info.put("UID", "XXXXXXXX");
            info.put("PWD", "XXXXXXXX");
            info.put("S3OutputLocation",
               + "s3://" + S3_BUCKET + File.separator
               + "test-dir" + File.separator);

            Class.forName("com.simba.athena.jdbc.Driver");
            Connection connection = DriverManager.getConnection(CONNECTION_URL, info);
            Statement statement = connection.createStatement();

            String query = "SELECT xxxxxxxxxxxxxxxxxxxx";
            ResultSet result = statement.executeQuery(query);

            while(result.next()) {
                System.out.println(rs.getString("Schlüsselname"));
            }

            result.close();
            statement.close();
            connection.close();
    }

Sie können eine einfache Verbindung herstellen, indem Sie einfach die erforderlichen Informationen in den Eigenschaften auf diese Weise festlegen.

Bonus

Löschen von Metadaten, die beim Ausführen von Athena ausgeführt werden können

Als Bonus benötige ich die Datei mit der Erweiterung .metadata, die beim Ausführen von Athena erstellt wurde, nicht. Daher werde ich sie löschen. Klicken Sie hier für das Beispiel

import com.amazonaws.services.s3.model.ObjectListing;
import com.amazonaws.services.s3.model.S3ObjectSummary;

import open.ag.kabigon.athena.Constant;
import open.ag.kabigon.s3.service.S3Base;

public class S3Handler {

　　　　　　　　private static final String S3_BUCKET = "test-bucket";

    private AmazonS3 s3;

    public void deleteAtenaMetadate(String dateTime) {
        BasicAWSCredentials awsCreds = new BasicAWSCredentials(
                "UID", "PWD");

        s3 = AmazonS3ClientBuilder.standard()
                .withCredentials(new AWSStaticCredentialsProvider(awsCreds))
                .withRegion(Regions.US_EAST_2)
                .build();

        //Rufen Sie das Objekt ab, das im Verzeichnis des angegebenen Buckets vorhanden ist
        ObjectListing objectList = s3.listObjects(Constant.S3_AG_BACKET, "test-dir" + File.separator);

        deleteObject(objectList);
        s3.shutdown();
    }

    private void deleteObject(ObjectListing objectList) {
        objectList.getObjectSummaries().forEach(i -> {
            //Die Erweiterung ist.metadata or .TXT-Objekt löschen
            if (i.getKey().endsWith(".metadata") || i.getKey().endsWith(".txt"))
                this.s3.deleteObject(Constant.S3_AG_BACKET, i.getKey());
        });

        if (objectList.isTruncated()) {
            ObjectListing remainsObject = this.s3.listNextBatchOfObjects(objectList);
            this.deleteObject(remainsObject);
        }
    }
}