Elasticsearch Cheatsheet: Väsentliga kommandon & 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 grundläggande kommandon, bästa praxis och snabba referenser för att arbeta med Elasticsearch-kluster.

elasticsearch

Obs: De flesta exempel i den här guiden använder cURL för HTTP-förfrågningar. Om du är ny på cURL eller behöver en snabbreferens för avancerade alternativ, kolla in vår cURL Snabbreferens för detaljerade kommandorads-HTTF-förfrågningsmetoder.

Klusterhantering

Kontrollera klusterhälsa

Alla kommandon i detta avsnitt använder cURL för att interagera med Elasticsearchs REST-API. Du kan anpassa dessa förfrågningar med ytterligare rubriker, autentisering och andra alternativ efter 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"

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

Indexhantering

Skapa och ta bort 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
  }
}
'

# Ta bort 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

# Indexera dokument med automatiskt genererad ID
curl -X POST "localhost:9200/products/_doc?pretty" -H 'Content-Type: application/json' -d'
{
  "name": "Laptop",
  "price": 999.99,
  "tags": ["electronics", "computers"]
}
'

# Indexera dokument med specifik ID
curl -X PUT "localhost:9200/products/_doc/1?pretty" -H 'Content-Type: application/json' -d'
{
  "name": "Laptop",
  "price": 999.99
}
'

# Massindexering
curl -X POST "localhost:9200/_bulk?pretty" -H 'Content-Type: application/json' -d'
{ "index": { "_index": "products", "_id": "1" }}
{ "name": "Laptop", "price": 999.99 }
{ "index": { "_index": "products", "_id": "2" }}
{ "name": "Mouse", "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 dokument existerar
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
}
'

Ta bort dokument

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

# Ta bort 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 alla
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "match_all": {}
  }
}
'

# Matcha 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"]
    }
  }
}
'

Termnivåfrågor

# Termfråga (exakt matchning)
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"]
    }
  }
}
'

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

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

Boolska frågor

# Boolsk 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 (stavningsfelstolerans)
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"
    }
  }
}
'

Aggregationer

Metrisk aggregation

# Medelvärde, 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 aggregation
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "aggs": {
    "price_stats": {
      "stats": { "field": "price" }
    }
  }
}
'

Bucket aggregationer

# Terms aggregation (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
      }
    }
  }
}
'

# Intervall aggregation
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 aggregationer

# Inbäddade aggregationer
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 sidnumrering

# 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" }}
  ]
}
'

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

# Sök efter (för djup sidnumrering)
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ältval 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
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "match": { "description": "gaming laptop" }
  },
  "highlight": {
    "fields": {
      "description": {}
    }
  }
}
'

Index Aliaser

# 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 ny index (noll nedtid)
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 aliaser
curl -X GET "localhost:9200/_cat/aliases?v"

Omindexering

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

# Omindexera 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-repository
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"

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

Prestandaoptimering

Indexinställningar

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

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

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

Cache-rensning

# Rensa alla caches
curl -X POST "localhost:9200/_cache/clear?pretty"

# Rensa 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ådpool-statistik
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"

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

Python-klientexempel

from elasticsearch import Elasticsearch

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

# Indexera dokument
doc = {
    'name': 'Laptop',
    'price': 999.99,
    'tags': ['electronics']
}
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'])

# Massindexering
from elasticsearch.helpers import bulk

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

JavaScript/Node.js-klientexempel

Elasticsearch JavaScript-klienten ger ett typ-säkert sätt att interagera med din kluster. För produktionsapplikationer, överväg att använda TypeScript för bättre typ-säkerhet och autokomplettering. Se vår TypeScript Cheatsheet för bästa praxis för typdefinitioner och gränssnitt.

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

// Indexera dokument
async function indexDoc() {
  await client.index({
    index: 'products',
    id: 1,
    document: {
      name: 'Laptop',
      price: 999.99
    }
  });
}

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

// Massindexering
async function bulkIndex() {
  const operations = [];
  for (let i = 0; i < 1000; i++) {
    operations.push({ index: { _index: 'products', _id: i } });
    operations.push({ name: `Product ${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ästa praxis

Indexdesign

  • Håll shardstorlek mellan 20-50GB för optimal prestanda
  • Använd indexlivscykelhantering (ILM) för tidsbaserad data
  • Designa mappningar noggrant innan indexering av data
  • Använd lämpliga fälttyper (keyword vs text, datumformat)
  • Inaktivera _source för stora dokument om inte nödvändigt

Frågeoptimering

  • Använd filter istället för frågor när poängsättning inte behövs
  • Föredra termnivåfrågor för strukturerad data
  • Använd bool fråga för att effektivt kombinera flera villkor
  • Implementera sidor med search_after för djup sidor
  • Cacha frekvent använda filter

Indexeringsprestanda

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

Klusterhantering

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

Säkerhet

  • Aktivera autentisering och auktorisering (X-Pack Security)
  • Använd HTTPS för produktionsdistributioner (konfigurera cURL med --cacert, --cert och --key alternativ för SSL/TLS)
  • Implementera lämplig rollbaserad åtkomstkontroll
  • Reguljära säkerhetsuppdateringar och patchar
  • Kryptera data i vila och i transit

Vanliga användningsområden

Fulltextsökning

Elasticsearch utmärker sig vid fulltextsökning med funktioner som:

  • Relevanspoängsättning
  • Otydlig matchning
  • Frasmatchning
  • Synonymhantering
  • Stöd för flera språk

Logganalys (ELK Stack)

  • Samla in loggar med Logstash/Filebeat
  • Indexera och söka loggar i Elasticsearch
  • Visualisera med Kibana-dashboards
  • Sätt upp varningar för avvikelser

E-handelsökning

  • Produktsortimentssökning
  • Facetterad navigation med aggregationer
  • Autokomplettering och förslag
  • Personliga sökresultat

Applikationsprestandaövervakning

  • Indexera applikationsmätvärden
  • Real-tidsövervakningsdashboards
  • Avvikelsedetektering
  • Prestandatrendanalys

Användbara länkar

Officiella Elasticsearch-resurser

Relaterade cheatsheets och guider