เทมเพลตดัชนีและชื่อแทน

As your Elasticsearch usage grows, you'll often deal with many indices. Think about logs, time-series data, or different versions of your application's data.

• Manually configuring settings (like shard count) and mappings (field types) for each new index can be tedious and error-prone.
• Changing the underlying index for an application without downtime is another challenge.

This lesson introduces two powerful features to simplify these tasks: Index Templates and Aliases.

Index Templates are like blueprints for new indices. They allow you to define default settings and mappings that will be automatically applied to any new index that matches a specified pattern.

• Consistency: Ensures all matching indices have the same configuration.
• Automation: No need to manually create mappings or settings for new data streams.
• Flexibility: Easily update templates, and new indices will pick up the changes.

This is especially useful for managing daily, weekly, or monthly indices (e.g., logs-2023-10-26).

You create an index template using the _index_template API. The most important part is index_patterns, which specifies which index names the template should apply to.

Here's a basic template named my_logs_template that will apply to any index starting with logs-:

In the previous example, notice the template block. This is where you define the actual settings and mappings that will be applied:

• settings: Controls index-level configurations like number_of_shards, number_of_replicas, or custom analyzers.
• mappings: Defines how fields within documents are stored and indexed, including their data types (e.g., date, text, keyword).

The priority field helps resolve conflicts if multiple templates match an index.

What if more than one template matches a new index's name? Elasticsearch uses priority to decide which template 'wins'.

• Templates with a higher priority take precedence.
• If conflicting settings or mappings are defined in multiple matching templates, the one with the highest priority will be applied.
• This allows you to create general templates (low priority) and more specific ones (high priority) that override specific settings for certain index patterns.

You can also use _component_templates to build reusable blocks of settings/mappings and combine them in composite templates.

Index Aliases are like symbolic links or pointers. They give a logical name to one or more physical indices.

• Abstraction: Your application interacts with the alias name, not the actual index name.
• Flexibility: You can change which physical index an alias points to without updating your application code.
• Zero-Downtime Operations: Crucial for reindexing data or swapping between index versions seamlessly.

An alias can point to a single index or multiple indices. It can also include filters to restrict which documents are visible through the alias.

You can create an alias when you create an index, or add it later using the _alias endpoint or the _aliases API.

Here's how to create an index and assign an alias my_app_data to it:

The real power of aliases comes from their ability to be updated atomically. You can add or remove indices from an alias in a single request.

For instance, to switch the my_app_data alias from my_application_v1 to a new my_application_v2 index:

This dynamic alias management is key for zero-downtime reindexing. Imagine you need to change your index's mapping, which requires creating a new index.

1. Your application queries my_app_data (which points to my_application_v1).
2. You create my_application_v2 with the new mapping and reindex data from my_application_v1 into it.
3. Once my_application_v2 is ready, you use the _aliases API to atomically switch my_app_data from my_application_v1 to my_application_v2.
4. Your application continues to query my_app_data without interruption, now getting data from the new index.

Finally, you can delete the old my_application_v1 index.

Congratulations! You've learned how to leverage two advanced Elasticsearch features for robust index management:

• Index Templates: Automate the application of consistent settings and mappings to newly created indices based on name patterns. They ensure uniformity and reduce manual configuration.
• Index Aliases: Offer a layer of abstraction, allowing your applications to interact with a stable logical name while the underlying physical indices can change. They are essential for performing zero-downtime reindexing and other flexible index operations.

Mastering these concepts is vital for building scalable and maintainable Elasticsearch solutions.