Elasticsearch

Das Kernstück des Elastic Stack

Elasticsearch ist eine verteilte RESTful-Suchmaschine und -Analytics Engine, die eine wachsende Zahl von Anwendungsfällen abdecken kann. Als Kernstück des Elastic Stack speichert sie Ihre Daten an einem zentralen Ort, sodass Sie in ihnen leicht Bekanntes finden und Unbekanntes aufdecken können.

Erste Schritte mit Elasticsearch. Video ansehen

Neu Neu in 6.5: _source only-Snapshots und Cluster-übergreifende Replikation (Beta). Plus: Unterstützung für Java 11 und G1GC Garbage Collector. Weitere Informationen

ABFRAGEN

Seien Sie neugierig. Stellen Sie Ihren Daten Fragen über Fragen.

Mit Elasticsearch können Sie viele Arten von Suchanfragen durchführen und kombinieren, ob strukturiert oder unstrukturiert, ob nach Geo-Daten oder Metriken – Ihrer Fantasie sind keine Grenzen gesetzt. Beginnen Sie mit einer einfachen Frage und sehen Sie, was sich daraus entwickelt.

ANALYSIEREN

Treten Sie einen Schritt zurück und betrachten Sie sich das Gesamtbild.

Die zehn passendsten Dokumente für eine Suchanfrage zu finden, ist das eine. Aber was, wenn es gilt, eine Milliarde Log-Zeilen zu analysieren? Mit den Elasticsearch-Aggregationen können Sie sich gewissermaßen aus dem Bild herauszoomen, um einen besseren Überblick zu erhalten und Trends und Muster in Ihren Daten zu finden.

GESCHWINDIGKEIT

Elasticsearch ist schnell.
Richtig, richtig schnell.

Wer stets sofort Antworten erhält, bekommt ein anderes Verhältnis zu seinen Daten. Plötzlich kann man sich Iterationen leisten und Daten großflächiger erfassen.

So schnell zu sein, ist nicht ganz einfach. Wir haben invertierte Indizes mit Finite-State Transducern (FSTs) für Volltextabfragen, BKD-Bäume zur Speicherung von numerischen und Geo-Daten sowie eine spaltenorientierte Datenstruktur für Analytics-Aufgaben implementiert.

Und da alles indexiert wird, kann Indexneid gar nicht erst aufkommen. Sie können alle Ihre Daten mit enorm hoher Geschwindigkeit abrufen und verarbeiten.

SKALIERBARKEIT

Egal, ob auf einem einzelnen Laptop
oder auf Hunderten von Servern mit Petabytes an Daten

Wir haben den nahtlosen Übergang vom Prototyp zur Produktion leicht gemacht: Ob Sie einen einzelnen Knoten haben oder ein 300-Knoten-Cluster – für die Kommunikation mit Elasticsearch macht das keinen Unterschied.

Horizontale Skalierung ermöglicht die Verarbeitung einer Zillion von Ereignissen pro Sekunde, während gleichzeitig automatisch verwaltet wird, wie Indizes und Abfragen für einen reibungslosen Betrieb im Cluster verteilt werden.

RESILIENZ

Wir haben alles unter Kontrolle, sodass Sie sich auf Ihre Arbeit konzentrieren können.

Die Hardware streikt. Das Netzwerk ist kaputt. Elasticsearch erkennt Fehler und gewährleistet so, dass Ihr Cluster (und Ihre Daten) sicher und verfügbar bleiben. Dank Cluster-übergreifender Replikation steht immer ein sekundärer Cluster bereit, um als Hot-Backup einzuspringen.

Elasticsearch arbeitet in einer verteilten Umgebung, die von Grund auf so entwickelt wurde, dass Sie sich keine Sorgen um Ihre Daten machen müssen.

FLEXIBILITÄT

Mehrere Anwendungsfälle? Kein Problem – Elasticsearch schafft alle.

Ob Zahlen, Text oder Geo-Daten, ob strukturiert oder unstrukturiert – alle Datentypen sind willkommen.

App Search, Security Analytics, Metriken und Logging sind nur einige der Beispiele dafür, wie Unternehmen in aller Welt Elasticsearch zur Lösung der unterschiedlichsten Herausforderungen verwenden.

IM DIENSTE DES KUNDEN

Damit Sie öfters mal die Hände zum Feiern frei haben

Einfache Dinge sollten auch einfach bleiben. Wir haben Elasticsearch so gestaltet, dass es in jeder Größe ohne Abstriche bei Leistung und Geschwindigkeit einfach zu betreiben ist.

CLIENT-BIBLIOTHEKEN

Elasticsearch unterstützt alle verbreiteten Programmiersprachen

Elasticsearch verwendet Standard-RESTful-APIs und JSON. Zudem entwickeln und pflegen wir Clients in vielen anderen Sprachen, wie Java, Python, .NET, SQL und PHP. Und unsere Community ist fleißig dabei, weitere Clients zu entwickeln. Sie sind benutzerfreundlich, intuitiv und setzen – ganz im Stil von Elasticsearch – Ihrem Ideenreichtum keine Grenzen.

                                    curl -H "Content-Type: application/json" -XGET
'http://localhost:9200/social-*/_search' -d '{
  "query": {
    "match": {
      "message": "myProduct"
    }
  },
  "aggregations": {
    "top_10_states": {
      "terms": {
        "field": "state",
        "size": 10
      }
    }
  }
}'
                                
                                    RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
                    new HttpHost("localhost", 9200, "http")));

SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.matchAllQuery());            
searchSourceBuilder.aggregation(AggregationBuilders.terms("top_10_states").field("state").size(10));

SearchRequest searchRequest = new SearchRequest();
searchRequest.indices("social-*");
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = client.search(searchRequest);
                                
                                    var client = new ElasticClient();

var searchResponse = client.Search<Tweet>(s => s
    .Index("social-*")
    .Query(q => q
        .Match(m => m
            .Field(f => f.Message)
            .Query("myProduct")
        )
    )
    .Aggregations(a => a
        .Terms("top_10_states", t => t
            .Field(f => f.State)
            .Size(10)
        )
    )
);
                                
                                    from elasticsearch import Elasticsearch

esclient = Elasticsearch(['localhost:9200'])
response = esclient.search(
index='social-*',
body={
    "query": {
        "match": {
            "message": "myProduct"
        }
    },
    "aggs": {
        "top_10_states": {
            "terms": {
                "field": "state",
                "size": 10
            }
        }
    }
}
)
                                
                                    var elasticsearch = require('elasticsearch');
var esclient = new elasticsearch.Client({
  host: 'localhost:9200'
});
esclient.search({
  index: 'social-*',
  body: {
    query: {
      match: { message: 'myProduct' }
    },
    aggs: {
      top_10_states: {
        terms: {
            field: 'state',
            size: 10
        }
      }
    }
  }
}
).then(function (response) {
    var hits = response.hits.hits;
}
);
                                
                                    $esclient = Elasticsearch\ClientBuilder::create()
              ->setHosts(["localhost:9200"])
              ->build();
$params = [
'index' => 'social-*',
'body' => [
    'query' => [
        'match' => [ 'message' => 'myProduct' ]
    ],
    'aggs' => [
        'top_10_states' => [
            'terms' => [
                'field' => 'state',
                'size' => 10,
            ]
        ]
    ]
]
];
$response = $esclient->search($params);
                                
                                    use Search::Elasticsearch;

my $esclient = Search::Elasticsearch->new( nodes => 'localhost:9200' );
my $response = $esclient->search(
index => 'social-*',
body => {
        query => {
            match => { message => 'myProduct' }
        },
        aggs => {
            top_10_states => {
                terms => {
                    field => 'state',
                    size => 10
                }
            }
        }
    }
);
                                
                                    require 'elasticsearch'

esclient = Elasticsearch::Client.new

response = esclient.search index: 'social-*', body: {
  query: {
    match: {
      message: 'myProduct'
    }
  },
  aggregations: {
    top_10_states: {
      terms: {
        field: 'state',
        size: 10
      }
    }
  }
}
                                
                                    SELECT SCORE(), * FROM social-* 
   WHERE match(message, 'myProduct') 
   ORDER BY SCORE() DESC

SELECT state, COUNT(*) AS state_count FROM social-* 
   WHERE match(message, 'myProduct') 
   GROUP BY state LIMIT 10
                                
Leistungsstarke Features

Elasticsearch erweitern

Mit integrierten Features für den Elastic Stack können Sie Ihrem Cluster einen Benutzernamen und ein Passwort hinzufügen, die Performance von Elasticsearch überwachen, Machine Learning-Jobs starten, um Anomalien zu erkennen, und so weiter.

Profitieren Sie von erweiterten Features für Sicherheit, Monitoring, Alerting, Reporting, Graphexploration, Machine Learning und mehr.

HADOOP UND SPARK

Elasticsearch Plus Hadoop

Speichern Sie viele Daten in Hadoop? Mit dem Elasticsearch-Hadoop (ES-Hadoop) Connector können Sie die Echtzeit-Suchmaschine und -Analytics Engine von Elasticsearch für die Arbeit an Ihren Big Data nutzen – hier trifft das Beste beider Welten unmittelbar aufeinander.