ನನ್ನ ಹೆಸರು ಇಗೊರ್ ಸಿಡೊರೆಂಕೊ, ನಾನು ಸಂಪೂರ್ಣ ಡೊಮ್ಕ್ಲಿಕ್ ಮೂಲಸೌಕರ್ಯವನ್ನು ಕಾರ್ಯ ಕ್ರಮದಲ್ಲಿ ನಿರ್ವಹಿಸುವ ನಿರ್ವಾಹಕರ ತಂಡದಲ್ಲಿ ತಾಂತ್ರಿಕ ನಾಯಕನಾಗಿದ್ದೇನೆ.

Elasticsearch ನಲ್ಲಿ ವಿತರಿಸಿದ ಡೇಟಾ ಸಂಗ್ರಹಣೆಯನ್ನು ಹೊಂದಿಸುವಲ್ಲಿ ನನ್ನ ಅನುಭವವನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ನಾನು ಬಯಸುತ್ತೇನೆ. ನೋಡ್‌ಗಳಲ್ಲಿನ ಯಾವ ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಚೂರುಗಳ ವಿತರಣೆಗೆ ಕಾರಣವಾಗಿವೆ, ILM ಹೇಗೆ ರಚನೆಯಾಗಿದೆ ಮತ್ತು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ.

ಲಾಗ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವವರು ಒಂದು ರೀತಿಯಲ್ಲಿ ಅಥವಾ ಇನ್ನೊಂದು ನಂತರದ ವಿಶ್ಲೇಷಣೆಗಾಗಿ ದೀರ್ಘಕಾಲೀನ ಶೇಖರಣೆಯ ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸುತ್ತಾರೆ. Elasticsearch ನಲ್ಲಿ ಇದು ವಿಶೇಷವಾಗಿ ಸತ್ಯವಾಗಿದೆ ಏಕೆಂದರೆ ಕ್ಯುರೇಟರ್ ಕಾರ್ಯವು ಶೋಚನೀಯವಾಗಿದೆ. ಆವೃತ್ತಿ 6.6 ರಲ್ಲಿ, ILM ಕಾರ್ಯವು ಕಾಣಿಸಿಕೊಂಡಿತು. ಇದು 4 ಹಂತಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:

• ಬಿಸಿ-ಸೂಚ್ಯಂಕವನ್ನು ಸಕ್ರಿಯವಾಗಿ ನವೀಕರಿಸಲಾಗುತ್ತಿದೆ ಮತ್ತು ಪ್ರಶ್ನಿಸಲಾಗುತ್ತಿದೆ.
• ಬೆಚ್ಚಗಿನ - ಸೂಚ್ಯಂಕವನ್ನು ಇನ್ನು ಮುಂದೆ ನವೀಕರಿಸಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ಇನ್ನೂ ಪ್ರಶ್ನಿಸಲಾಗಿದೆ.
• ಶೀತ - ಸೂಚ್ಯಂಕವನ್ನು ಇನ್ನು ಮುಂದೆ ನವೀಕರಿಸಲಾಗುವುದಿಲ್ಲ ಮತ್ತು ವಿರಳವಾಗಿ ಪ್ರಶ್ನಿಸಲಾಗುತ್ತದೆ. ಮಾಹಿತಿಯನ್ನು ಇನ್ನೂ ಹುಡುಕಬಹುದಾಗಿದೆ, ಆದರೆ ಪ್ರಶ್ನೆಗಳು ನಿಧಾನವಾಗಿರಬಹುದು.
• ಅಳಿಸಿ-ಸೂಚ್ಯಂಕ ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲ ಮತ್ತು ಸುರಕ್ಷಿತವಾಗಿ ಅಳಿಸಬಹುದು.

ನೀಡಿದ

• Elasticsearch ಡೇಟಾ ಹಾಟ್: 24 ಪ್ರೊಸೆಸರ್‌ಗಳು, 128 GB ಮೆಮೊರಿ, 1,8 TB SSD RAID 10 (8 ನೋಡ್‌ಗಳು).
• Elasticsearch Data Warm: 24 ಪ್ರೊಸೆಸರ್‌ಗಳು, 64 GB ಮೆಮೊರಿ, 8 TB NetApp SSD ನೀತಿ (4 ನೋಡ್‌ಗಳು).
• Elasticsearch ಡೇಟಾ ಕೋಲ್ಡ್: 8 ಪ್ರೊಸೆಸರ್‌ಗಳು, 32 GB ಮೆಮೊರಿ, 128 TB HDD RAID 10 (4 ನೋಡ್‌ಗಳು).

ಗುರಿ

ಈ ಸೆಟ್ಟಿಂಗ್‌ಗಳು ವೈಯಕ್ತಿಕವಾಗಿವೆ, ಇದು ಎಲ್ಲಾ ನೋಡ್‌ಗಳಲ್ಲಿನ ಸ್ಥಳ, ಸೂಚ್ಯಂಕಗಳ ಸಂಖ್ಯೆ, ಲಾಗ್‌ಗಳು ಇತ್ಯಾದಿಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ನಮಗೆ ಇದು ದಿನಕ್ಕೆ 2-3 TB ಡೇಟಾ.

• 5 ದಿನಗಳು - ಬಿಸಿ ಹಂತ (8 ಮುಖ್ಯ / 1 ಪ್ರತಿಕೃತಿ).
• 20 ದಿನಗಳು - ಬೆಚ್ಚಗಿನ ಹಂತ (ಕುಗ್ಗುವಿಕೆ-ಸೂಚ್ಯಂಕ 4 ಮುಖ್ಯ / 1 ಪ್ರತಿಕೃತಿ).
• 90 ದಿನಗಳು - ಶೀತ ಹಂತ (ಫ್ರೀಜ್-ಇಂಡೆಕ್ಸ್ 4 ಮುಖ್ಯ / 1 ಪ್ರತಿಕೃತಿ).
• 120 ದಿನಗಳು - ಹಂತವನ್ನು ಅಳಿಸಿ.

ಸ್ಥಿತಿಸ್ಥಾಪಕ ಹುಡುಕಾಟವನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

ನೋಡ್‌ಗಳ ನಡುವೆ ಚೂರುಗಳನ್ನು ವಿತರಿಸಲು, ನಿಮಗೆ ಕೇವಲ ಒಂದು ಪ್ಯಾರಾಮೀಟರ್ ಅಗತ್ಯವಿದೆ:

• ಹಾಟ್-ನೋಡ್ಸ್:

  ~]# cat /etc/elasticsearch/elasticsearch.yml | grep attr
  # Add custom attributes to the node:
  node.attr.box_type: hot

• ವಾರ್ಮ್-ನೋಡ್ಸ್:

  ~]# cat /etc/elasticsearch/elasticsearch.yml | grep attr
  # Add custom attributes to the node:
  node.attr.box_type: warm

• ಶೀತಲ-ನೋಡ್ಸ್:

  ~]# cat /etc/elasticsearch/elasticsearch.yml | grep attr
  # Add custom attributes to the node:
  node.attr.box_type: cold

ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್ ಅನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

ಇದೆಲ್ಲವೂ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಾವು ಈ ಕಾರ್ಯವನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಿದ್ದೇವೆ? Elasticsearch ಗೆ ಲಾಗ್‌ಗಳನ್ನು ಪಡೆಯುವುದರೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ. ಎರಡು ಮಾರ್ಗಗಳಿವೆ:

1. ಲಾಗ್‌ಸ್ಟಾಶ್ ಕಾಫ್ಕಾದಿಂದ ಲಾಗ್‌ಗಳನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ. ಅದರ ಬದಿಯಲ್ಲಿ ಸ್ವಚ್ಛವಾಗಿ ಅಥವಾ ಪರಿವರ್ತಿಸಬಹುದು.
2. ಯಾವುದೋ ಎಲಾಸ್ಟಿಕ್ ಸರ್ಚ್‌ಗೆ ಸ್ವತಃ ಬರೆಯುತ್ತದೆ, ಉದಾಹರಣೆಗೆ, ಎಪಿಎಂ ಸರ್ವರ್.

ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್ ಮೂಲಕ ಸೂಚ್ಯಂಕಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ. ಇದು ಸೂಚ್ಯಂಕವನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಅನ್ವಯಿಸುತ್ತದೆ ಸೂಚ್ಯಂಕ ಟೆಂಪ್ಲೇಟ್ ಮತ್ತು ಅನುಗುಣವಾದ ಐಎಲ್ಎಂ.

k8s-ingress.conf

input {
    kafka {
        bootstrap_servers => "node01, node02, node03"
        topics => ["ingress-k8s"]
        decorate_events => false
        codec => "json"
    }
}

filter {
    ruby {
        path => "/etc/logstash/conf.d/k8s-normalize.rb"
    }
    if [log] =~ "[warn]" or [log] =~ "[error]" or [log] =~ "[notice]" or [log] =~ "[alert]" {
        grok {
            match => { "log" => "%{DATA:[nginx][error][time]} [%{DATA:[nginx][error][level]}] %{NUMBER:[nginx][error][pid]}#%{NUMBER:[nginx][error][tid]}: *%{NUMBER:[nginx][error][connection_id]} %{DATA:[nginx][error][message]}, client: %{IPORHOST:[nginx][error][remote_ip]}, server: %{DATA:[nginx][error][server]}, request: "%{WORD:[nginx][error][method]} %{DATA:[nginx][error][url]} HTTP/%{NUMBER:[nginx][error][http_version]}", (?:upstream: "%{DATA:[nginx][error][upstream][proto]}://%{DATA:[nginx][error][upstream][host]}:%{DATA:[nginx][error][upstream][port]}/%{DATA:[nginx][error][upstream][url]}", )?host: "%{DATA:[nginx][error][host]}"(?:, referrer: "%{DATA:[nginx][error][referrer]}")?" }
            remove_field => "log"
        }
    }
    else {
        grok {
            match => { "log" => "%{IPORHOST:[nginx][access][host]} - [%{IPORHOST:[nginx][access][remote_ip]}] - %{DATA:[nginx][access][remote_user]} [%{HTTPDATE:[nginx][access][time]}] "%{WORD:[nginx][access][method]} %{DATA:[nginx][access][url]} HTTP/%{NUMBER:[nginx][access][http_version]}" %{NUMBER:[nginx][access][response_code]} %{NUMBER:[nginx][access][bytes_sent]} "%{DATA:[nginx][access][referrer]}" "%{DATA:[nginx][access][agent]}" %{NUMBER:[nginx][access][request_lenght]} %{NUMBER:[nginx][access][request_time]} [%{DATA:[nginx][access][upstream][name]}] (?:-|%{IPORHOST:[nginx][access][upstream][addr]}:%{NUMBER:[nginx][access][upstream][port]}) (?:-|%{NUMBER:[nginx][access][upstream][response_lenght]}) %{DATA:[nginx][access][upstream][response_time]} %{DATA:[nginx][access][upstream][status]} %{DATA:[nginx][access][request_id]}" }
            remove_field => "log"
        }
    }
}
output {
    elasticsearch {
        id => "k8s-ingress"
        hosts => ["node01", "node02", "node03", "node04", "node05", "node06", "node07", "node08"]
        manage_template => true # включаем управление шаблонами
        template_name => "k8s-ingress" # имя применяемого шаблона
        ilm_enabled => true # включаем управление ILM
        ilm_rollover_alias => "k8s-ingress" # alias для записи в индексы, должен быть уникальным
        ilm_pattern => "{now/d}-000001" # шаблон для создания индексов, может быть как "{now/d}-000001" так и "000001"
        ilm_policy => "k8s-ingress" # политика прикрепляемая к индексу
        index => "k8s-ingress-%{+YYYY.MM.dd}" # название создаваемого индекса, может содержать %{+YYYY.MM.dd}, зависит от ilm_pattern
    }
}

ಕಿಬಾನಾವನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

ಎಲ್ಲಾ ಹೊಸ ಸೂಚ್ಯಂಕಗಳಿಗೆ ಅನ್ವಯಿಸುವ ಮೂಲ ಟೆಂಪ್ಲೇಟ್ ಇದೆ. ಇದು ಬಿಸಿ ಸೂಚ್ಯಂಕಗಳ ವಿತರಣೆ, ಚೂರುಗಳ ಸಂಖ್ಯೆ, ಪ್ರತಿಕೃತಿಗಳು ಇತ್ಯಾದಿಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ. ಟೆಂಪ್ಲೇಟ್ನ ತೂಕವನ್ನು ಆಯ್ಕೆಯಿಂದ ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ order. ಹೆಚ್ಚಿನ ತೂಕವನ್ನು ಹೊಂದಿರುವ ಟೆಂಪ್ಲೇಟ್‌ಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೆಂಪ್ಲೇಟ್ ನಿಯತಾಂಕಗಳನ್ನು ಅತಿಕ್ರಮಿಸುತ್ತದೆ ಅಥವಾ ಹೊಸದನ್ನು ಸೇರಿಸಿ.

GET_template/default

{
  "default" : {
    "order" : -1, # вес шаблона
    "version" : 1,
    "index_patterns" : [
      "*" # применяем ко всем индексам
    ],
    "settings" : {
      "index" : {
        "codec" : "best_compression", # уровень сжатия
        "routing" : {
          "allocation" : {
            "require" : {
              "box_type" : "hot" # распределяем только по горячим нодам
            },
            "total_shards_per_node" : "8" # максимальное количество шардов на ноду от одного индекса
          }
        },
        "refresh_interval" : "5s", # интервал обновления индекса
        "number_of_shards" : "8", # количество шардов
        "auto_expand_replicas" : "0-1", # количество реплик на ноду от одного индекса
        "number_of_replicas" : "1" # количество реплик
      }
    },
    "mappings" : {
      "_meta" : { },
      "_source" : { },
      "properties" : { }
    },
    "aliases" : { }
  }
}

ನಂತರ ಸೂಚ್ಯಂಕಗಳಿಗೆ ಮ್ಯಾಪಿಂಗ್ ಅನ್ನು ಅನ್ವಯಿಸಿ k8s-ingress-* ಹೆಚ್ಚಿನ ತೂಕದೊಂದಿಗೆ ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಬಳಸುವುದು.

GET _template/k8s-ingress

{
  "k8s-ingress" : {
    "order" : 100,
    "index_patterns" : [
      "k8s-ingress-*"
    ],
    "settings" : {
      "index" : {
        "lifecycle" : {
          "name" : "k8s-ingress",
          "rollover_alias" : "k8s-ingress"
        },
        "codec" : "best_compression",
        "routing" : {
          "allocation" : {
            "require" : {
              "box_type" : "hot"
            }
          }
        },
        "number_of_shards" : "8",
        "number_of_replicas" : "1"
      }
    },
    "mappings" : {
      "numeric_detection" : false,
      "_meta" : { },
      "_source" : { },
      "dynamic_templates" : [
        {
          "all_fields" : {
            "mapping" : {
              "index" : false,
              "type" : "text"
            },
            "match" : "*"
          }
        }
      ],
      "date_detection" : false,
      "properties" : {
        "kubernetes" : {
          "type" : "object",
          "properties" : {
            "container_name" : {
              "type" : "keyword"
            },
            "container_hash" : {
              "index" : false,
              "type" : "keyword"
            },
            "host" : {
              "type" : "keyword"
            },
            "annotations" : {
              "type" : "object",
              "properties" : {
                "value" : {
                  "index" : false,
                  "type" : "text"
                },
                "key" : {
                  "index" : false,
                  "type" : "keyword"
                }
              }
            },
            "docker_id" : {
              "index" : false,
              "type" : "keyword"
            },
            "pod_id" : {
              "type" : "keyword"
            },
            "labels" : {
              "type" : "object",
              "properties" : {
                "value" : {
                  "type" : "keyword"
                },
                "key" : {
                  "type" : "keyword"
                }
              }
            },
            "namespace_name" : {
              "type" : "keyword"
            },
            "pod_name" : {
              "type" : "keyword"
            }
          }
        },
        "@timestamp" : {
          "type" : "date"
        },
        "nginx" : {
          "type" : "object",
          "properties" : {
            "access" : {
              "type" : "object",
              "properties" : {
                "agent" : {
                  "type" : "text"
                },
                "response_code" : {
                  "type" : "integer"
                },
                "upstream" : {
                  "type" : "object",
                  "properties" : {
                    "port" : {
                      "type" : "keyword"
                    },
                    "name" : {
                      "type" : "keyword"
                    },
                    "response_lenght" : {
                      "type" : "integer"
                    },
                    "response_time" : {
                      "index" : false,
                      "type" : "text"
                    },
                    "addr" : {
                      "type" : "keyword"
                    },
                    "status" : {
                      "index" : false,
                      "type" : "text"
                    }
                  }
                },
                "method" : {
                  "type" : "keyword"
                },
                "http_version" : {
                  "type" : "keyword"
                },
                "bytes_sent" : {
                  "type" : "integer"
                },
                "request_lenght" : {
                  "type" : "integer"
                },
                "url" : {
                  "type" : "text",
                  "fields" : {
                    "keyword" : {
                      "type" : "keyword"
                    }
                  }
                },
                "remote_user" : {
                  "type" : "text"
                },
                "referrer" : {
                  "type" : "text"
                },
                "remote_ip" : {
                  "type" : "ip"
                },
                "request_time" : {
                  "format" : "yyyy/MM/dd HH:mm:ss||yyyy/MM/dd||epoch_millis||dd/MMM/YYYY:H:m:s Z",
                  "type" : "date"
                },
                "host" : {
                  "type" : "keyword"
                },
                "time" : {
                  "format" : "yyyy/MM/dd HH:mm:ss||yyyy/MM/dd||epoch_millis||dd/MMM/YYYY:H:m:s Z",
                  "type" : "date"
                }
              }
            },
            "error" : {
              "type" : "object",
              "properties" : {
                "server" : {
                  "type" : "keyword"
                },
                "upstream" : {
                  "type" : "object",
                  "properties" : {
                    "port" : {
                      "type" : "keyword"
                    },
                    "proto" : {
                      "type" : "keyword"
                    },
                    "host" : {
                      "type" : "keyword"
                    },
                    "url" : {
                      "type" : "text",
                      "fields" : {
                        "keyword" : {
                          "type" : "keyword"
                        }
                      }
                    }
                  }
                },
                "method" : {
                  "type" : "keyword"
                },
                "level" : {
                  "type" : "keyword"
                },
                "http_version" : {
                  "type" : "keyword"
                },
                "pid" : {
                  "index" : false,
                  "type" : "integer"
                },
                "message" : {
                  "type" : "text"
                },
                "tid" : {
                  "index" : false,
                  "type" : "keyword"
                },
                "url" : {
                  "type" : "text",
                  "fields" : {
                    "keyword" : {
                      "type" : "keyword"
                    }
                  }
                },
                "referrer" : {
                  "type" : "text"
                },
                "remote_ip" : {
                  "type" : "ip"
                },
                "connection_id" : {
                  "index" : false,
                  "type" : "keyword"
                },
                "host" : {
                  "type" : "keyword"
                },
                "time" : {
                  "format" : "yyyy/MM/dd HH:mm:ss||yyyy/MM/dd||epoch_millis||dd/MMM/YYYY:H:m:s Z",
                  "type" : "date"
                }
              }
            }
          }
        },
        "log" : {
          "type" : "text"
        },
        "@version" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "ignore_above" : 256,
              "type" : "keyword"
            }
          }
        },
        "eventtime" : {
          "type" : "float"
        }
      }
    },
    "aliases" : { }
  }
}

ಎಲ್ಲಾ ಟೆಂಪ್ಲೇಟ್‌ಗಳನ್ನು ಅನ್ವಯಿಸಿದ ನಂತರ, ನಾವು ILM ನೀತಿಯನ್ನು ಅನ್ವಯಿಸುತ್ತೇವೆ ಮತ್ತು ಸೂಚ್ಯಂಕಗಳ ಜೀವನವನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ.

GET _ilm/policy/k8s-ingress

{
  "k8s-ingress" : {
    "version" : 14,
    "modified_date" : "2020-06-11T10:27:01.448Z",
    "policy" : {
      "phases" : {
        "warm" : { # теплая фаза
          "min_age" : "5d", # срок жизни индекса после ротации до наступления теплой фазы
          "actions" : {
            "allocate" : {
              "include" : { },
              "exclude" : { },
              "require" : {
                "box_type" : "warm" # куда перемещаем индекс
              }
            },
            "shrink" : {
              "number_of_shards" : 4 # обрезание индексов, т.к. у нас 4 ноды
            }
          }
        },
        "cold" : { # холодная фаза
          "min_age" : "25d", # срок жизни индекса после ротации до наступления холодной фазы
          "actions" : {
            "allocate" : {
              "include" : { },
              "exclude" : { },
              "require" : {
                "box_type" : "cold" # куда перемещаем индекс
              }
            },
            "freeze" : { } # замораживаем для оптимизации
          }
        },
        "hot" : { # горячая фаза
          "min_age" : "0ms",
          "actions" : {
            "rollover" : {
              "max_size" : "50gb", # максимальный размер индекса до ротации (будет х2, т.к. есть 1 реплика)
              "max_age" : "1d" # максимальный срок жизни индекса до ротации
            },
            "set_priority" : {
              "priority" : 100
            }
          }
        },
        "delete" : { # фаза удаления
          "min_age" : "120d", # максимальный срок жизни после ротации перед удалением
          "actions" : {
            "delete" : { }
          }
        }
      }
    }
  }
}

ತೊಂದರೆಗಳು

ಸೆಟಪ್ ಮತ್ತು ಡೀಬಗ್ ಮಾಡುವ ಹಂತದಲ್ಲಿ ಸಮಸ್ಯೆಗಳಿದ್ದವು.

ಬಿಸಿ ಹಂತ

ಸೂಚ್ಯಂಕಗಳ ಸರಿಯಾದ ತಿರುಗುವಿಕೆಗಾಗಿ, ಕೊನೆಯಲ್ಲಿ ಇರುವ ಉಪಸ್ಥಿತಿ index_name-date-000026 ಫಾರ್ಮ್ಯಾಟ್ ಸಂಖ್ಯೆಗಳು 000001. ಕೊನೆಯಲ್ಲಿ ಸಂಖ್ಯೆಗಳಿಗೆ ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಸೂಚಿಕೆಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ಕೋಡ್‌ನಲ್ಲಿ ಸಾಲುಗಳಿವೆ. ಇಲ್ಲದಿದ್ದರೆ, ದೋಷವಿರುತ್ತದೆ, ನೀತಿಗಳನ್ನು ಸೂಚ್ಯಂಕಕ್ಕೆ ಅನ್ವಯಿಸಲಾಗುವುದಿಲ್ಲ ಮತ್ತು ಅದು ಯಾವಾಗಲೂ ಬಿಸಿ ಹಂತದಲ್ಲಿರುತ್ತದೆ.

ಬೆಚ್ಚಗಿನ ಹಂತ

ಕುಗ್ಗಿಸು (ಕತ್ತರಿಸುವುದು) - ಚೂರುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು, ಏಕೆಂದರೆ ನಾವು ಬೆಚ್ಚಗಿನ ಮತ್ತು ಶೀತ ಹಂತಗಳಲ್ಲಿ 4 ನೋಡ್ಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ. ದಸ್ತಾವೇಜನ್ನು ಈ ಕೆಳಗಿನ ಸಾಲುಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:

• ಸೂಚ್ಯಂಕವು ಓದಲು-ಮಾತ್ರವಾಗಿರಬೇಕು.
• ಸೂಚ್ಯಂಕದಲ್ಲಿನ ಪ್ರತಿ ಚೂರುಗಳ ನಕಲು ಅದೇ ನೋಡ್‌ನಲ್ಲಿ ಇರಬೇಕು.
• ಕ್ಲಸ್ಟರ್ ಆರೋಗ್ಯ ಸ್ಥಿತಿ ಹಸಿರಾಗಿರಬೇಕು.

ಸೂಚ್ಯಂಕವನ್ನು ಟ್ರಿಮ್ ಮಾಡಲು, Elasticsearch ಎಲ್ಲಾ ಪ್ರಾಥಮಿಕ ಚೂರುಗಳನ್ನು ಒಂದು ನೋಡ್‌ಗೆ ಚಲಿಸುತ್ತದೆ, ಅಗತ್ಯ ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ಟ್ರಿಮ್ ಮಾಡಿದ ಸೂಚಿಯನ್ನು ನಕಲು ಮಾಡುತ್ತದೆ ಮತ್ತು ನಂತರ ಹಳೆಯದನ್ನು ಅಳಿಸುತ್ತದೆ. ಪ್ಯಾರಾಮೀಟರ್ total_shards_per_node ಒಂದು ನೋಡ್‌ನಲ್ಲಿ ಅವುಗಳನ್ನು ಹೊಂದಿಸಲು ಮುಖ್ಯ ಚೂರುಗಳ ಸಂಖ್ಯೆಗೆ ಸಮನಾಗಿರಬೇಕು ಅಥವಾ ಹೆಚ್ಚಿನದಾಗಿರಬೇಕು. ಇಲ್ಲದಿದ್ದರೆ, ಅಧಿಸೂಚನೆಗಳು ಇರುತ್ತವೆ ಮತ್ತು ಚೂರುಗಳು ಅಗತ್ಯವಿರುವ ನೋಡ್‌ಗಳಿಗೆ ಚಲಿಸುವುದಿಲ್ಲ.

GET /shrink-k8s-ingress-2020.06.06-000025/_settings

{
  "shrink-k8s-ingress-2020.06.06-000025" : {
    "settings" : {
      "index" : {
        "refresh_interval" : "5s",
        "auto_expand_replicas" : "0-1",
        "blocks" : {
          "write" : "true"
        },
        "provided_name" : "shrink-k8s-ingress-2020.06.06-000025",
        "creation_date" : "1592225525569",
        "priority" : "100",
        "number_of_replicas" : "1",
        "uuid" : "psF4MiFGQRmi8EstYUQS4w",
        "version" : {
          "created" : "7060299",
          "upgraded" : "7060299"
        },
        "lifecycle" : {
          "name" : "k8s-ingress",
          "rollover_alias" : "k8s-ingress",
          "indexing_complete" : "true"
        },
        "codec" : "best_compression",
        "routing" : {
          "allocation" : {
            "initial_recovery" : {
              "_id" : "_Le0Ww96RZ-o76bEPAWWag"
            },
            "require" : {
              "_id" : null,
              "box_type" : "cold"
            },
            "total_shards_per_node" : "8"
          }
        },
        "number_of_shards" : "4",
        "routing_partition_size" : "1",
        "resize" : {
          "source" : {
            "name" : "k8s-ingress-2020.06.06-000025",
            "uuid" : "gNhYixO6Skqi54lBjg5bpQ"
          }
        }
      }
    }
  }
}

ಶೀತ ಹಂತ

ಫ್ರೀಜ್ (ಫ್ರೀಜ್) - ಐತಿಹಾಸಿಕ ಡೇಟಾದ ಆಧಾರದ ಮೇಲೆ ಪ್ರಶ್ನೆಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಲು ನಾವು ಸೂಚ್ಯಂಕವನ್ನು ಫ್ರೀಜ್ ಮಾಡುತ್ತೇವೆ.

ಘನೀಕೃತ ಸೂಚ್ಯಂಕಗಳಲ್ಲಿ ನಡೆಸಲಾದ ಹುಡುಕಾಟಗಳು ಪ್ರತಿ ನೋಡ್‌ನಲ್ಲಿ ಹೆಪ್ಪುಗಟ್ಟಿದ ಚೂರುಗಳನ್ನು ಹೊಡೆಯುವ ಏಕಕಾಲಿಕ ಹುಡುಕಾಟಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿಯಂತ್ರಿಸಲು ಸಣ್ಣ, ಮೀಸಲಾದ, ಹುಡುಕಾಟ_ಥ್ರೊಟಲ್ಡ್ ಥ್ರೆಡ್‌ಪೂಲ್ ಅನ್ನು ಬಳಸುತ್ತವೆ. ಇದು ಹೆಪ್ಪುಗಟ್ಟಿದ ಚೂರುಗಳಿಗೆ ಅನುಗುಣವಾದ ಅಸ್ಥಿರ ಡೇಟಾ ರಚನೆಗಳಿಗೆ ಅಗತ್ಯವಿರುವ ಹೆಚ್ಚುವರಿ ಮೆಮೊರಿಯ ಪ್ರಮಾಣವನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಹೆಚ್ಚಿನ ಮೆಮೊರಿ ಬಳಕೆಯಿಂದ ನೋಡ್‌ಗಳನ್ನು ರಕ್ಷಿಸುತ್ತದೆ.
ಘನೀಕೃತ ಸೂಚ್ಯಂಕಗಳು ಓದಲು-ಮಾತ್ರ: ನೀವು ಅವುಗಳನ್ನು ಸೂಚಿಕೆ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ.
ಹೆಪ್ಪುಗಟ್ಟಿದ ಸೂಚ್ಯಂಕಗಳ ಮೇಲಿನ ಹುಡುಕಾಟಗಳು ನಿಧಾನವಾಗಿ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ನಿರೀಕ್ಷೆಯಿದೆ. ಘನೀಕೃತ ಸೂಚ್ಯಂಕಗಳು ಹೆಚ್ಚಿನ ಹುಡುಕಾಟ ಲೋಡ್ಗಾಗಿ ಉದ್ದೇಶಿಸಿಲ್ಲ. ಸೂಚ್ಯಂಕಗಳು ಫ್ರೀಜ್ ಆಗದಿರುವಾಗ ಅದೇ ಹುಡುಕಾಟಗಳು ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳಲ್ಲಿ ಪೂರ್ಣಗೊಂಡರೂ ಸಹ, ಘನೀಕೃತ ಸೂಚ್ಯಂಕದ ಹುಡುಕಾಟವು ಪೂರ್ಣಗೊಳ್ಳಲು ಸೆಕೆಂಡುಗಳು ಅಥವಾ ನಿಮಿಷಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

ಫಲಿತಾಂಶಗಳು

ILM ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನೋಡ್‌ಗಳನ್ನು ಹೇಗೆ ತಯಾರಿಸಬೇಕೆಂದು ನಾವು ಕಲಿತಿದ್ದೇವೆ, ಹಾಟ್ ನೋಡ್‌ಗಳ ನಡುವೆ ಚೂರುಗಳನ್ನು ವಿತರಿಸಲು ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಹೊಂದಿಸಿದ್ದೇವೆ ಮತ್ತು ಎಲ್ಲಾ ಜೀವನ ಹಂತಗಳೊಂದಿಗೆ ಸೂಚ್ಯಂಕಕ್ಕಾಗಿ ILM ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ್ದೇವೆ.

ಉಪಯುಕ್ತ ಕೊಂಡಿಗಳು

• https://www.elastic.co/guide/en/elasticsearch/reference/master/index-lifecycle-management-api.html
• https://www.elastic.co/guide/en/elasticsearch/reference/master/recovery-prioritization.html
• https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-shrink-index.html#indices-shrink-index
• https://www.elastic.co/guide/en/elasticsearch/reference/master/frozen-indices.html
• https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-cluster.html#shard-allocation-awareness

ಮೂಲ: www.habr.com