0Pricing
MongoDB Academy · Pelajaran

Membuat Indeks Atlas Search

Peserta didik akan menentukan pemetaan indeks pencarian di antarmuka Atlas atau melalui API, serta memahami cara Lucene melakukan tokenisasi dan menyimpan nilai bidang.

Membuat Indeks Atlas Search adalah pelajaran MongoDB Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar MongoDB Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus MongoDB Academy mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

What Is Atlas Search?

Atlas Search is a fully managed, Apache Lucene-based search engine embedded directly into MongoDB Atlas. Unlike MongoDB's native text indexes, Atlas Search provides relevance scoring, fuzzy matching, autocomplete, faceted navigation, and sophisticated analyzers—all accessible through an aggregation pipeline stage called $search. You do not need to run a separate Elasticsearch or Solr cluster; Atlas Search lives alongside your data.

How Atlas Search Works Under the Hood

Atlas Search runs a Lucene engine as a separate process alongside each MongoDB node. When documents are inserted, updated, or deleted, MongoDB streams the changes to the Lucene index asynchronously. This means Atlas Search indexes are eventually consistent with the MongoDB data—there is a small lag (typically milliseconds) between a write and its appearance in search results. For most applications this is perfectly acceptable.

Creating a Search Index via Atlas UI

In the MongoDB Atlas UI, navigate to your cluster, click the Search tab, and choose Create Search Index. You can use the Visual Editor (point-and-click field mapping) or the JSON Editor to write the index definition directly. The index applies to a specific database and collection. After clicking Create, Atlas builds the index asynchronously—a green status indicator signals when it is ready to query.

The Default Search Index Mapping

The simplest Atlas Search index uses dynamic mapping: MongoDB automatically indexes all string, number, date, and boolean fields without requiring you to enumerate them. The default index definition is just { mappings: { dynamic: true } }. This is the fastest way to get started and is suitable for exploration. For production workloads, switch to static mappings to control which fields are indexed and how they are analyzed.

// Default index definition — dynamic mapping
// All string, number, date, boolean fields are indexed automatically
{
  'mappings': {
    'dynamic': true
  }
}

// This is what you paste into the Atlas JSON Editor when creating the index

Static Mapping: Controlling Field Indexing

Static mapping gives you explicit control over which fields are indexed and how they are analyzed. Set dynamic: false and list each field with its type and analyzer. Fields not listed in a static mapping are not indexed. This reduces index size and improves indexing throughput for large collections by avoiding unnecessary indexing of every field.

// Static mapping: only index 'title' and 'description' as searchable strings
{
  'mappings': {
    'dynamic': false,
    'fields': {
      'title': {
        'type': 'string',
        'analyzer': 'lucene.standard'
      },
      'description': {
        'type': 'string',
        'analyzer': 'lucene.standard'
      },
      'category': {
        'type': 'stringFacet' // for faceted navigation
      },
      'price': {
        'type': 'number'
      }
    }
  }
}

Analyzers: How Text Is Tokenized

An analyzer defines how text is broken into tokens and normalized before storage in the Lucene index. lucene.standard lowercases text and splits on whitespace and punctuation. lucene.english also applies stemming (reducing 'running' to 'run') for better recall. lucene.keyword treats the entire string as a single token, useful for exact-match fields like email addresses or SKU codes. The choice of analyzer significantly impacts search quality.

{
  'mappings': {
    'dynamic': false,
    'fields': {
      // 'Standard' analyzer: good for general text
      'title': { 'type': 'string', 'analyzer': 'lucene.standard' },

      // 'English' analyzer: stemming for better recall
      'description': { 'type': 'string', 'analyzer': 'lucene.english' },

      // 'Keyword' analyzer: exact match only
      'sku': { 'type': 'string', 'analyzer': 'lucene.keyword' },

      // Multi-analyzer: both standard and keyword on same field
      'email': {
        'type': 'string',
        'analyzer': 'lucene.keyword',
        'multi': {
          'standard': { 'type': 'string', 'analyzer': 'lucene.standard' }
        }
      }
    }
  }
}

Creating a Search Index via the Atlas CLI

For infrastructure-as-code and CI/CD pipelines, you can create Atlas Search indexes using the Atlas CLI or the Atlas Administration API. This lets you version-control your search index definitions alongside your application code. The Atlas CLI command is atlas clusters search indexes create with a JSON configuration file.

# Create a search index using the Atlas CLI
# 1. Save index definition to a file:
# cat search-index.json
# { "name": "products_search", "collectionName": "products",
#   "database": "shop", "mappings": { "dynamic": true } }

# 2. Create the index:
# atlas clusters search indexes create \
#   --clusterName MyCluster \
#   --file search-index.json \
#   --projectId <YOUR_PROJECT_ID>

Index Status and Monitoring

After creating a search index, it goes through the BUILDING state while Lucene processes existing documents. During this time, queries may return incomplete results or fail with an error. Once the status shows READY (green in Atlas UI), the index covers all existing documents. New documents added after index creation are indexed with a small lag. Monitor index status programmatically using the Atlas Administration API or the Atlas CLI.

// Check index status via Atlas Admin API
// GET https://cloud.mongodb.com/api/atlas/v1.0/groups/{groupId}/clusters/{clusterName}/fts/indexes/{collectionName}

// In application code, handle the case where the index is still building:
// - Catch errors with code 1261 (IndexNotFound)
// - Retry after a delay or show a 'search unavailable' message

Nested and Array Field Indexing

Atlas Search can index nested document fields and array elements. Use dot notation in the field path to reference nested fields, just like regular MongoDB queries. For arrays of subdocuments, each element is indexed separately. This allows you to search inside embedded objects—for example, finding products where any color option matches a search term.

// Index definition for a product with nested fields and arrays
{
  'mappings': {
    'dynamic': false,
    'fields': {
      'name': { 'type': 'string', 'analyzer': 'lucene.standard' },
      'variants.color': { 'type': 'string', 'analyzer': 'lucene.keyword' },
      'variants.size': { 'type': 'string', 'analyzer': 'lucene.keyword' },
      'reviews.text': { 'type': 'string', 'analyzer': 'lucene.english' },
      'reviews.rating': { 'type': 'number' }
    }
  }
}

Verifying the Index With $search

Once your Atlas Search index is READY, test it with a $search aggregation stage. The simplest query uses the text operator to search for a keyword across indexed string fields. A successful response confirms the index is built and queries are working. Examine the searchScore in the projected output to understand relevance ranking.

// Quick verification query
db.products.aggregate([
  {
    $search: {
      index: 'default', // name of your search index
      text: {
        query: 'wireless headphones',
        path: { wildcard: '*' } // search all indexed fields
      }
    }
  },
  {
    $project: {
      name: 1,
      category: 1,
      price: 1,
      score: { $meta: 'searchScore' }
    }
  },
  { $limit: 5 }
])

Index Naming and Multiple Indexes

You can create multiple Atlas Search indexes on the same collection, each with a different name, field configuration, and analyzers. This allows different use cases to use specialized indexes—a general search index with dynamic mapping, a strict-matching index with keyword analyzers, and an autocomplete index. When running a $search query, specify the index field to select which search index to use.

// Using a named search index in a $search query
db.products.aggregate([
  {
    $search: {
      index: 'products_autocomplete', // use the autocomplete-specific index
      autocomplete: {
        query: 'wire',
        path: 'name'
      }
    }
  }
]);

Quick Check

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

Lesson Recap

In this lesson you learned: Atlas Search is a Lucene-based full-text search engine embedded in MongoDB Atlas, dynamic mapping indexes all fields automatically while static mapping requires explicit field definitions for finer control, and analyzers like lucene.standard, lucene.english, and lucene.keyword control how text is tokenized and stored. Next up we explore writing $search aggregation queries including text, phrase, and wildcard operators.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membuat Indeks Atlas Search” gratis?

Ya — teks lengkap “Membuat Indeks Atlas Search” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus MongoDB Academy, upgrade ke CoddyKit PRO. Kursus MongoDB Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Membuat Indeks Atlas Search”?

Peserta didik akan menentukan pemetaan indeks pencarian di antarmuka Atlas atau melalui API, serta memahami cara Lucene melakukan tokenisasi dan menyimpan nilai bidang. Kamu berlatih MongoDB Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai MongoDB Academy?

Tidak diperlukan pengalaman sebelumnya. MongoDB Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Membuat Indeks Atlas Search” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran MongoDB Academy ini?

Ya. Setiap pelajaran MongoDB Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Membuat Indeks Atlas Search
  2. Menulis Kueri $search: Teks, Frasa, dan Wildcard
  3. Pelengkapan Otomatis dan Pencocokan Fuzzy
  4. Faset dan Kueri Gabungan
← Kembali ke MongoDB Academy