Linux Foundation OpenSearch Certified Associate

Learn by running it. You start a single node, see how a cluster is made of nodes with roles, and use the REST API and the Dashboards console to ask the cluster about itself.

• Starting OpenSearch and Dashboards in containers
• Nodes, clusters and node roles
• The REST API and talking to it with curl
• The Dev Tools console
• Cluster health and what the colors mean
• Configuration files and settings in outline

You build A local OpenSearch and Dashboards setup, with a note of the health and settings you checked.

Data goes in as JSON documents inside indexes. You create, read, update and delete documents, load many at once with the bulk API, and control how fields are stored by defining mappings.

• Creating an index and indexing a document
• Reading, updating and deleting documents
• The bulk API for loading data
• Field types: text, keyword, numbers, dates
• Dynamic and explicit mappings
• Changing a mapping with reindexing

You build An index with an explicit mapping, loaded with a sample dataset through the bulk API.

Search quality depends on how text is broken down and scored. You see how analyzers tokenize and normalize text, why text and keyword fields behave differently, and how scoring orders results.

• Tokenizers, filters and analyzers
• Text fields compared with keyword fields
• Testing an analyzer on sample text
• Relevance scoring with BM25 in outline
• Boosting fields and terms
• Synonyms and stemming

You build A custom analyzer for a product catalog, with queries that show how it changes results.

The Query DSL is how you ask questions. You write full-text and exact-match queries, combine them with boolean logic, filter without scoring, and shape the response with sorting, paging and highlighting.

• Match and term queries
• Boolean queries: must, should, must not, filter
• Range queries and date math
• Query context compared with filter context
• Sorting, pagination and highlighting
• Vector search in outline: embeddings and nearest neighbors

You build A set of saved queries that answer a range of questions about a sample dataset.

Search finds documents, and aggregations summarize them. You compute metrics, group results into buckets, nest one aggregation in another, and build time-based summaries of events and logs.

• Metric aggregations: counts, averages, percentiles
• Bucket aggregations: terms, ranges and histograms
• Date histograms for time series
• Nesting aggregations
• Filtering before aggregating
• Reading aggregation results

You build An aggregation that reports traffic by hour, status and endpoint from a sample log index.

An index is split into shards spread over nodes. You learn what primaries and replicas do, why health turns yellow or red, and how shard counts, node roles and time-based indexes affect speed and growth.

• Primary and replica shards
• How documents are routed to shards
• Allocation and why health turns yellow or red
• Choosing a sensible shard count
• Time-based indexes and rollover
• Node roles and scaling out

You build A two-node cluster with an index that has replicas, and a record of what happens when a node stops.

Real data arrives messy and continuous. You transform documents on the way in with ingest pipelines, learn where log shippers and data pipelines fit, and handle failures in loading.

• Ingest pipelines and processors
• Parsing and enriching documents on arrival
• Log shippers and data pipelines in outline
• Bulk loading and handling rejected documents
• Index templates for new indexes
• Checking what was indexed

You build An ingest pipeline that parses raw log lines into structured fields, with a template for daily indexes.

Dashboards turn indexed data into something people can read. You connect an index, explore it interactively, build visualizations, and combine them into a dashboard that others can use.

• Index patterns and the Discover view
• Searching and filtering interactively
• Building bar, line and table visualizations
• Combining visualizations into a dashboard
• Saved objects and sharing
• Time ranges and refresh

You build A dashboard that shows volume, errors and top sources for a sample dataset.

A cluster that holds real data needs protection and care. You enable encryption and roles, take snapshots you can restore, manage index lifecycles, and watch cluster health.

• Encrypting traffic with TLS
• Users, roles and permissions
• Snapshots and restores
• Lifecycle policies for aging data
• Monitoring cluster and node health
• Upgrading in outline

You build A secured cluster with a read-only role for analysts, a snapshot schedule and a tested restore.

Take a dataset you care about from file to finished result. You design the mapping, load and transform the data, write queries and aggregations, and present the answers in a dashboard that someone else can use.

• Choosing a dataset and the questions to ask
• Designing the mapping and the pipeline
• Loading and checking the data
• Writing queries and aggregations
• Building and sharing the dashboard
• Reviewing the design with a teammate

You build A working OpenSearch index and dashboard for a real dataset, with a short guide to how it was built.