Vad används Elasticsearch för?

Elasticsearch är en distribuerad sökmotor och analysmotor som används för fulltextsökning, loganalys, övervakning av applikationer och realtidsdataanalys. Den används vanligtvis för webbplatsökning, logaggregering med ELK-stacken och affärsintelligens.

Hur kontrollerar jag Elasticsearch-clustrets hälsa?

Använd kommandot curl -X GET "localhost:9200/_cluster/health?pretty" för att kontrollera klusterstatus. Grön status betyder att alla shards är tilldelade, gul status indikerar att repliker inte är tilldelade, och röd status visar att vissa primära shards inte är tilldelade.

Vilken är skillnaden mellan en fråga och en filtrering i Elasticsearch?

Frågor beräknar relevansbetyg och används för fulltextssökning, medan filter är ja/nej-beslut som inte betygsätter dokument. Filter är snabbare och kan cachas, vilket gör dem idealiska för strukturerad data som intervaller, termer och boolesk logik.

Hur optimerar jag Elasticsearch-prestanda?

Viktiga optimeringar inkluderar korrekt storlek för shards (20–50 GB per shard), användning av bulk-API för indexering, implementering av korrekta mappningar med rätt fälttyper, aktivering av index-uppdateringsintervall samt användning av filter istället för frågor när poängsättning inte behövs.

ELK står för Elasticsearch, Logstash och Kibana. Elasticsearch lagrar och söker data, Logstash samlar och bearbetar loggar, och Kibana visualiserar data. Tillsammans utgör de en komplett lösning för loghantering och analys.

Hur säkerhetskopierar jag Elasticsearch-data?

Använd Elasticsearch:s API för snapshot och återställning. Registrera först ett repositorium med PUT /_snapshot/my_backup, skapa sedan snapshots med PUT /_snapshot/my_backup/snapshot_1?wait_for_completion=true. Lagra snapshots i gemensamma filsystem, S3, Azure eller GCS.

Elasticsearch-snabbkurs: Viktiga kommandon och tips

Elasticsearch-kommandon för sökning, indexering och analys.

Sidinnehåll

Elasticsearch är en kraftfull distribuerad sökmotor och analysmotor byggd på Apache Lucene. Denna omfattande snabbreferens täcker essentiella kommandon, bästa praxis och korta referenser för att jobba med Elasticsearch-kluster.

elasticsearch

Notera: De flesta exempel i denna guide använder cURL för HTTP-anrop. Om du är ny till cURL eller behöver en snabb referens för avancerade alternativ, kolla vår cURL-snabbreferens för detaljerade tekniker för HTTP-anrop i kommandotolken.

Hantering av kluster

Kontrollera klusterhälsa

Alla kommandon i detta avsnitt använder cURL för att interagera med Elasticsearchs REST API. Du kan anpassa dessa anrop med ytterligare huvuden, autentisering och andra alternativ vid behov.

# Grundläggande hälsokontroll
curl -X GET "localhost:9200/_cluster/health?pretty"

# Detaljerad klusterhälsa med shard-information
curl -X GET "localhost:9200/_cluster/health?level=shards&pretty"

# Kontrollera nodinformation
curl -X GET "localhost:9200/_cat/nodes?v"

# Kontrollera klusterinställningar
curl -X GET "localhost:9200/_cluster/settings?pretty"

Nodoperationer

# Lista alla noder
curl -X GET "localhost:9200/_cat/nodes?v&h=name,node.role,heap.percent,ram.percent,cpu,load_1m"

# Nodstatistik
curl -X GET "localhost:9200/_nodes/stats?pretty"

# Heta trådar (felsökning)
curl -X GET "localhost:9200/_nodes/hot_threads"

Indexhantering

Skapa och radera index

# Skapa index
curl -X PUT "localhost:9200/my_index?pretty"

# Skapa index med inställningar
curl -X PUT "localhost:9200/my_index" -H 'Content-Type: application/json' -d'
{
  "settings": {
    "number_of_shards": 3,
    "number_of_replicas": 1
  }
}
'

# Radera index
curl -X DELETE "localhost:9200/my_index?pretty"

# Lista alla index
curl -X GET "localhost:9200/_cat/indices?v"

# Indexstatistik
curl -X GET "localhost:9200/my_index/_stats?pretty"

Indexmappningar

# Definiera mappning
curl -X PUT "localhost:9200/products" -H 'Content-Type: application/json' -d'
{
  "mappings": {
    "properties": {
      "name": { "type": "text" },
      "price": { "type": "float" },
      "created_at": { "type": "date" },
      "tags": { "type": "keyword" },
      "description": { 
        "type": "text",
        "analyzer": "english"
      }
    }
  }
}
'

# Hämta mappning
curl -X GET "localhost:9200/products/_mapping?pretty"

# Uppdatera mappning (lägg till fält)
curl -X PUT "localhost:9200/products/_mapping" -H 'Content-Type: application/json' -d'
{
  "properties": {
    "category": { "type": "keyword" }
  }
}
'

Indexmallar

# Skapa indexmall
curl -X PUT "localhost:9200/_index_template/logs_template" -H 'Content-Type: application/json' -d'
{
  "index_patterns": ["logs-*"],
  "template": {
    "settings": {
      "number_of_shards": 1
    },
    "mappings": {
      "properties": {
        "timestamp": { "type": "date" },
        "message": { "type": "text" },
        "level": { "type": "keyword" }
      }
    }
  }
}
'

# Lista mallar
curl -X GET "localhost:9200/_index_template?pretty"

Dokumentoperationer (CRUD)

Skapa dokument

# Indexa dokument med automatiskt genererat ID
curl -X POST "localhost:9200/products/_doc?pretty" -H 'Content-Type: application/json' -d'
{
  "name": "Bärbar dator",
  "price": 999.99,
  "tags": ["elektronik", "datorer"]
}
'

# Indexa dokument med specifikt ID
curl -X PUT "localhost:9200/products/_doc/1?pretty" -H 'Content-Type: application/json' -d'
{
  "name": "Bärbar dator",
  "price": 999.99
}
'

# Bulk-indexering
curl -X POST "localhost:9200/_bulk?pretty" -H 'Content-Type: application/json' -d'
{ "index": { "_index": "products", "_id": "1" }}
{ "name": "Bärbar dator", "price": 999.99 }
{ "index": { "_index": "products", "_id": "2" }}
{ "name": "Mus", "price": 29.99 }
'

Läs dokument

# Hämta dokument efter ID
curl -X GET "localhost:9200/products/_doc/1?pretty"

# Hämta flera dokument
curl -X GET "localhost:9200/_mget?pretty" -H 'Content-Type: application/json' -d'
{
  "docs": [
    { "_index": "products", "_id": "1" },
    { "_index": "products", "_id": "2" }
  ]
}
'

# Kontrollera om dokumentet finns
curl -I "localhost:9200/products/_doc/1"

Uppdatera dokument

# Uppdatera dokument
curl -X POST "localhost:9200/products/_update/1?pretty" -H 'Content-Type: application/json' -d'
{
  "doc": {
    "price": 899.99
  }
}
'

# Uppdatera med skript
curl -X POST "localhost:9200/products/_update/1?pretty" -H 'Content-Type: application/json' -d'
{
  "script": {
    "source": "ctx._source.price *= params.discount",
    "params": {
      "discount": 0.9
    }
  }
}
'

# Upsert (uppdatera eller infoga)
curl -X POST "localhost:9200/products/_update/1?pretty" -H 'Content-Type: application/json' -d'
{
  "doc": {
    "price": 899.99
  },
  "doc_as_upsert": true
}
'

Radera dokument

# Radera efter ID
curl -X DELETE "localhost:9200/products/_doc/1?pretty"

# Radera efter fråga
curl -X POST "localhost:9200/products/_delete_by_query?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "match": {
      "name": "old"
    }
  }
}
'

Sökfrågor

Grundläggande sökning

# Matcha allt
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "match_all": {}
  }
}
'

# Match-fråga
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "match": {
      "name": "laptop"
    }
  }
}
'

# Multi-match fråga
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "multi_match": {
      "query": "laptop gaming",
      "fields": ["name", "description"]
    }
  }
}
'

Frågor på termnivå

# Term-fråga (exakt träff)
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "term": {
      "tags": "electronics"
    }
  }
}
'

# Terms-fråga (flera värden)
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "terms": {
      "tags": ["electronics", "computers"]
    }
  }
}
'

# Range-fråga
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "range": {
      "price": {
        "gte": 100,
        "lte": 1000
      }
    }
  }
}
'

# Exists-fråga
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "exists": {
      "field": "description"
    }
  }
}
'

Booleska frågor

# Bool-fråga (must, should, must_not, filter)
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "bool": {
      "must": [
        { "match": { "name": "laptop" }}
      ],
      "filter": [
        { "range": { "price": { "gte": 500 }}}
      ],
      "should": [
        { "term": { "tags": "gaming" }}
      ],
      "must_not": [
        { "term": { "tags": "refurbished" }}
      ]
    }
  }
}
'

Avancerad sökning

# Wildcard-fråga
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "wildcard": {
      "name": "lap*"
    }
  }
}
'

# Fuzzy-fråga (tolerans mot stavfel)
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "fuzzy": {
      "name": {
        "value": "laptpo",
        "fuzziness": "AUTO"
      }
    }
  }
}
'

# Prefix-fråga
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "prefix": {
      "name": "lap"
    }
  }
}
'

Aggregeringar

Metrikaggregeringar

# Genomsnitt, summa, min, max
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "aggs": {
    "avg_price": { "avg": { "field": "price" }},
    "max_price": { "max": { "field": "price" }},
    "min_price": { "min": { "field": "price" }},
    "total_sales": { "sum": { "field": "price" }}
  }
}
'

# Stats-aggregering
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "aggs": {
    "price_stats": {
      "stats": { "field": "price" }
    }
  }
}
'

Bucket-aggregeringar

# Terms-aggregering (gruppera efter)
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "aggs": {
    "popular_tags": {
      "terms": {
        "field": "tags",
        "size": 10
      }
    }
  }
}
'

# Range-aggregering
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "aggs": {
    "price_ranges": {
      "range": {
        "field": "price",
        "ranges": [
          { "to": 50 },
          { "from": 50, "to": 100 },
          { "from": 100 }
        ]
      }
    }
  }
}
'

# Datumhistogram
curl -X GET "localhost:9200/logs/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "aggs": {
    "logs_over_time": {
      "date_histogram": {
        "field": "timestamp",
        "calendar_interval": "day"
      }
    }
  }
}
'

Inbäddade aggregeringar

# Inbäddade aggregeringar
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "aggs": {
    "categories": {
      "terms": { "field": "category" },
      "aggs": {
        "avg_price": {
          "avg": { "field": "price" }
        }
      }
    }
  }
}
'

Sortering och paginering

# Sortera efter fält
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": { "match_all": {} },
  "sort": [
    { "price": { "order": "desc" }},
    { "_score": { "order": "desc" }}
  ]
}
'

# Paginering med from/size
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "from": 0,
  "size": 10,
  "query": { "match_all": {} }
}
'

# Search after (för djup paginering)
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "size": 10,
  "query": { "match_all": {} },
  "sort": [{ "price": "asc" }, { "_id": "asc" }],
  "search_after": [100, "product_123"]
}
'

Fältspecifikation och markering

# Välj specifika fält
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": { "match_all": {} },
  "_source": ["name", "price"]
}
'

# Markering (highlighting)
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "match": { "description": "gaming laptop" }
  },
  "highlight": {
    "fields": {
      "description": {}
    }
  }
}
'

Indexalias

# Skapa alias
curl -X POST "localhost:9200/_aliases?pretty" -H 'Content-Type: application/json' -d'
{
  "actions": [
    { "add": { "index": "products_v1", "alias": "products" }}
  ]
}
'

# Byt alias till nytt index (noll driftstopp)
curl -X POST "localhost:9200/_aliases?pretty" -H 'Content-Type: application/json' -d'
{
  "actions": [
    { "remove": { "index": "products_v1", "alias": "products" }},
    { "add": { "index": "products_v2", "alias": "products" }}
  ]
}
'

# Lista alias
curl -X GET "localhost:9200/_cat/aliases?v"

Reindexering

# Reindexera från ett index till ett annat
curl -X POST "localhost:9200/_reindex?pretty" -H 'Content-Type: application/json' -d'
{
  "source": {
    "index": "old_products"
  },
  "dest": {
    "index": "new_products"
  }
}
'

# Reindexera med fråga
curl -X POST "localhost:9200/_reindex?pretty" -H 'Content-Type: application/json' -d'
{
  "source": {
    "index": "products",
    "query": {
      "range": {
        "price": { "gte": 100 }
      }
    }
  },
  "dest": {
    "index": "expensive_products"
  }
}
'

Snapshot och backup

# Registrera snapshot-repositorium
curl -X PUT "localhost:9200/_snapshot/my_backup?pretty" -H 'Content-Type: application/json' -d'
{
  "type": "fs",
  "settings": {
    "location": "/mount/backups/my_backup"
  }
}
'

# Skapa snapshot
curl -X PUT "localhost:9200/_snapshot/my_backup/snapshot_1?wait_for_completion=true&pretty"

# Återställ snapshot
curl -X POST "localhost:9200/_snapshot/my_backup/snapshot_1/_restore?pretty"

# Lista snapshots
curl -X GET "localhost:9200/_snapshot/my_backup/_all?pretty"

# Radera snapshot
curl -X DELETE "localhost:9200/_snapshot/my_backup/snapshot_1?pretty"

Prestandaoptimering

Indexinställningar

# Inaktivera refresh under bulk-indexering
curl -X PUT "localhost:9200/products/_settings?pretty" -H 'Content-Type: application/json' -d'
{
  "index": {
    "refresh_interval": "-1"
  }
}
'

# Återaktivera efter bulk-indexering
curl -X PUT "localhost:9200/products/_settings?pretty" -H 'Content-Type: application/json' -d'
{
  "index": {
    "refresh_interval": "1s"
  }
}
'

# Force merge (optimera)
curl -X POST "localhost:9200/products/_forcemerge?max_num_segments=1&pretty"

Cache-tömning

# Töm alla cachar
curl -X POST "localhost:9200/_cache/clear?pretty"

# Töm specifik cache
curl -X POST "localhost:9200/products/_cache/clear?query=true&pretty"

Övervakning och felsökning

# Väntande uppgifter
curl -X GET "localhost:9200/_cat/pending_tasks?v"

# Trådpoolstatistik
curl -X GET "localhost:9200/_cat/thread_pool?v"

# Segmentinformation
curl -X GET "localhost:9200/_cat/segments?v"

# Återställningsinformation
curl -X GET "localhost:9200/_cat/recovery?v&h=index,stage,time"

# Tasks API
curl -X GET "localhost:9200/_tasks?detailed=true&pretty"

Python-klientexempel

from elasticsearch import Elasticsearch

# Anslut till Elasticsearch
es = Elasticsearch(['http://localhost:9200'])

# Indexa dokument
doc = {
    'name': 'Bärbar dator',
    'price': 999.99,
    'tags': ['elektronik']
}
es.index(index='products', id=1, document=doc)

# Sök
resp = es.search(index='products', query={'match': {'name': 'laptop'}})
for hit in resp['hits']['hits']:
    print(hit['_source'])

# Bulk-indexering
from elasticsearch.helpers import bulk

actions = [
    {
        '_index': 'products',
        '_id': i,
        '_source': {'name': f'Produkt {i}', 'price': i * 10}
    }
    for i in range(1000)
]
bulk(es, actions)

JavaScript/Node.js-klientexempel

Elasticsearch JavaScript-klienten ger ett typsäkert sätt att interagera med ditt kluster. För produktionsapplikationer bör du överväga att använda TypeScript för bättre typsäkerhet och autocompletion. Se vår TypeScript-snabbreferens för bästa praxis gällande typdefinitioner och gränssnitt.

const { Client } = require('@elastic/elasticsearch');
const client = new Client({ node: 'http://localhost:9200' });

// Indexa dokument
async function indexDoc() {
  await client.index({
    index: 'products',
    id: 1,
    document: {
      name: 'Bärbar dator',
      price: 999.99
    }
  });
}

// Sök
async function search() {
  const result = await client.search({
    index: 'products',
    query: {
      match: { name: 'laptop' }
    }
  });
  console.log(result.hits.hits);
}

// Bulk-indexering
async function bulkIndex() {
  const operations = [];
  for (let i = 0; i < 1000; i++) {
    operations.push({ index: { _index: 'products', _id: i } });
    operations.push({ name: `Produkt ${i}`, price: i * 10 });
  }
  await client.bulk({ operations });
}

TypeScript-exempel med stark typning

import { Client } from '@elastic/elasticsearch';

interface Product {
  name: string;
  price: number;
  tags?: string[];
  created_at?: Date;
}

const client = new Client({ node: 'http://localhost:9200' });

async function indexProduct(product: Product, id: number): Promise<void> {
  await client.index<Product>({
    index: 'products',
    id: id.toString(),
    document: product
  });
}

async function searchProducts(query: string): Promise<Product[]> {
  const result = await client.search<Product>({
    index: 'products',
    query: {
      match: { name: query }
    }
  });
  
  return result.hits.hits.map(hit => hit._source as Product);
}

Bäst praxis

Indexdesign

Håll shard-storleken mellan 20-50 GB för optimal prestanda
Använd indexlivscykelhantering (ILM) för tids-seriedata
Designa mappningar noggrant innan du indexerar data
Använd lämpliga fälttyper (keyword vs text, datumformat)
Inaktivera _source för stora dokument om det inte behövs

Frågoptimering

Använd filter istället för frågor när betyg (scoring) inte behövs
Föredra term-nivåfrågor för strukturerad data
Använd bool-fråga för att kombinera flera villkor effektivt
Implementera paginering med search_after för djup paginering
Cacha ofta använda filter

Indexeringsprestanda

Använd bulk-API för batch-indexering (1000-5000 dokument per anrop)
Inaktivera refresh under bulk-operationer
Öka index.refresh_interval under tung indexering
Använd flera trådar/arbeterare för parallell indexering
Överväg att använda routing för bättre shardfördelning

Klusterhantering

Övervaka klusterhälsa regelbundet
Sätt upp korrekt replikakonfiguration
Använd dedikerade master-noder för stora kluster
Implementera korrekt backup-strategi med snapshots
Övervaka JVM-hälsanvändning (håll under 75%)

Säkerhet

Aktivera autentisering och auktorisering (X-Pack Security)
Använd HTTPS för produktionsdeployment (konfigurera cURL med --cacert, --cert och --key-alternativ för SSL/TLS)
Implementera korrekt rollbaserad åtkontroll
Regelbundna säkerhetsuppdateringar och patchar
Kryptera data i vila och under överföring

Vanliga användningsområden

Fulltextssökning

Elasticsearch excellerar i fulltextssökning med funktioner som:

Relevansbetyg
Fuzzy-matching
Fras-matchning
Synonymhantering
Stöd för flera språk Om du utvärderar om du ska behålla sökningen i Postgres eller flytta till en dedikerad sökmotor, denna jämförelse mellan PostgreSQL fulltextssökning och Elasticsearch bryter ner de praktiska avvägningarna.

Logganalys (ELK-stacken)

Samla loggar med Logstash/Filebeat
Indexa och sök loggar i Elasticsearch
Visualisera med Kibana-dashboards
Ställ upp larm för avvikelser

E-handelssökning

Sökning i produktkatalog
Facetterad navigering med aggregeringar
Autocompletion och förslag
Personliga sökresultat

Applikationsprestandaövervakning

Indexa applikationsmått
Dashboard för realtidsövervakning
Avvikelsedetektering
Analys av prestandatrender

Användbara länkar

Officiella Elasticsearch-resurser

Relaterade snabbreferenser och guider

cURL-snabbreferens - Essentiell för att behärska HTTP-anrop till Elasticsearch REST API
TypeScript-snabbreferens: Grundläggande koncept och bästa praxis - Bygg typsäkra Elasticsearch-klientapplikationer