મારું નામ ઇગોર સિડોરેન્કો છે, હું એડમિન્સની ટીમમાં એક ટેકનિકલ લીડર છું જે ડોમક્લિકના સમગ્ર ઇન્ફ્રાસ્ટ્રક્ચરને જાળવે છે.

હું Elasticsearch માં વિતરિત ડેટા સ્ટોરેજ સેટ કરવા માટેનો મારો અનુભવ શેર કરવા માંગુ છું. અમે જોઈશું કે ગાંઠો પરની કઈ સેટિંગ્સ શાર્ડના વિતરણ માટે જવાબદાર છે, ILM કેવી રીતે કાર્ય કરે છે અને કાર્ય કરે છે.

જેઓ લોગ સાથે કામ કરે છે, એક રીતે અથવા બીજી રીતે, પછીના વિશ્લેષણ માટે લાંબા ગાળાના સ્ટોરેજની સમસ્યાનો સામનો કરવો પડે છે. Elasticsearch માં, આ ખાસ કરીને સાચું છે, કારણ કે ક્યુરેટર કાર્યક્ષમતા સાથે બધું કમનસીબ હતું. સંસ્કરણ 6.6 એ ILM કાર્યક્ષમતા રજૂ કરી. તે 4 તબક્કાઓ ધરાવે છે:

ગરમ - ઇન્ડેક્સ સક્રિયપણે અપડેટ કરવામાં આવી રહ્યો છે અને પૂછપરછ કરવામાં આવી રહી છે.
ગરમ - અનુક્રમણિકા હવે અપડેટ કરવામાં આવી નથી, પરંતુ હજુ પણ પૂછપરછ કરવામાં આવી રહી છે.
કોલ્ડ - ઇન્ડેક્સ હવે અપડેટ થતો નથી અને ભાગ્યે જ પૂછવામાં આવે છે. માહિતી હજુ પણ શોધવા યોગ્ય હોવી જોઈએ, પરંતુ ક્વેરી ધીમી હોઈ શકે છે.
કાઢી નાખો - અનુક્રમણિકાની હવે જરૂર નથી અને સુરક્ષિત રીતે કાઢી શકાય છે.

આપેલ

Elasticsearch ડેટા હોટ: 24 પ્રોસેસર્સ, 128 GB મેમરી, 1,8 TB SSD RAID 10 (8 નોડ્સ).
ઇલાસ્ટિકસર્ચ ડેટા વોર્મ: 24 પ્રોસેસર્સ, 64 જીબી મેમરી, 8 ટીબી નેટએપ એસએસડી પોલિસી (4 નોડ્સ).
Elasticsearch ડેટા કોલ્ડ: 8 પ્રોસેસર્સ, 32 GB મેમરી, 128 TB HDD RAID 10 (4 નોડ્સ).

લક્ષ્ય

આ સેટિંગ્સ વ્યક્તિગત છે, તે બધા ગાંઠો પરના સ્થાન, અનુક્રમણિકાઓની સંખ્યા, લૉગ્સ વગેરે પર આધારિત છે. અમારી પાસે દરરોજ 2-3 TB ડેટા છે.

5 દિવસ - ગરમ તબક્કો (8 મુખ્ય / 1 પ્રતિકૃતિ).
20 દિવસ - ગરમ તબક્કો (સંકોચો-ઇન્ડેક્સ 4 મુખ્ય / 1 પ્રતિકૃતિ).
90 દિવસ - શીત તબક્કો (ફ્રીઝ-ઇન્ડેક્સ 4 મુખ્ય / 1 પ્રતિકૃતિ).
120 દિવસ - તબક્કો કાઢી નાખો.

Elasticsearch સુયોજિત કરી રહ્યા છીએ

ગાંઠો પર શાર્ડ વિતરિત કરવા માટે, તમારે ફક્ત એક પરિમાણની જરૂર છે:

હોટ-નોડ્સ:

~]# 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

Logstash સેટ કરી રહ્યું છે

તે બધું કેવી રીતે કાર્ય કરે છે અને અમે આ સુવિધાને કેવી રીતે અમલમાં મૂકી? ચાલો Elasticsearch માં લોગ મેળવીને શરૂઆત કરીએ. ત્યાં બે માર્ગો છે:

Logstash કાફકા પાસેથી લોગ મેળવે છે. સ્વચ્છ પસંદ કરી શકો છો અથવા તમારી બાજુ પર કન્વર્ટ કરી શકો છો.
ઇલાસ્ટિકસર્ચ પર કંઈક લખે છે, ઉદાહરણ તરીકે, એપીએમ સર્વર.

Logstash દ્વારા અનુક્રમણિકાઓનું સંચાલન કરવાના ઉદાહરણનો વિચાર કરો. તે ઇન્ડેક્સ બનાવે છે અને તેને લાગુ પડે છે અનુક્રમણિકા પેટર્ન અને અનુરૂપ આઈએલએમ.

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. વધુ વજનવાળા નમૂનાઓ હાલના ટેમ્પલેટ પરિમાણોને ઓવરરાઇડ કરે છે અથવા નવા ઉમેરે છે.

_ટેમ્પલેટ/ડિફોલ્ટ મેળવો

{
  "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-* ઊંચા વજન સાથે નમૂનાનો ઉપયોગ કરીને.

_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 નીતિ લાગુ કરીએ છીએ અને અનુક્રમણિકાઓના જીવનનું નિરીક્ષણ કરવાનું શરૂ કરીએ છીએ.

_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 નોડ્સ છે. દસ્તાવેજીકરણમાં નીચેની લીટીઓ છે:

અનુક્રમણિકા ફક્ત વાંચવા માટે જ હોવી જોઈએ.

અનુક્રમણિકામાં દરેક શાર્ડની નકલ સમાન નોડ પર રહેવી જોઈએ.

ક્લસ્ટર આરોગ્ય સ્થિતિ લીલી હોવી જોઈએ.

અનુક્રમણિકાને કાપવા માટે, ઇલાસ્ટિકસર્ચ તમામ પ્રાથમિક શાર્ડને એક નોડ પર ખસેડે છે, જરૂરી પરિમાણો સાથે કપાયેલ અનુક્રમણિકાનું ડુપ્લિકેટ કરે છે, અને પછી જૂનાને કાઢી નાખે છે. પરિમાણ total_shards_per_node એક નોડ પર ફિટ કરવા માટે મુખ્ય શાર્ડ્સની સંખ્યા જેટલી અથવા તેનાથી વધુ હોવી જોઈએ. નહિંતર, સૂચનાઓ હશે અને શાર્ડ્સ યોગ્ય નોડ્સ પર જશે નહીં.

મેળવો /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 કેવી રીતે સેટ કરવું.

ઉપયોગી લિંક્સ

સોર્સ: www.habr.com

Elasticsearch માં લાંબા ગાળાના ડેટા સ્ટોરેજ

આપેલ

લક્ષ્ય

Elasticsearch સુયોજિત કરી રહ્યા છીએ

Logstash સેટ કરી રહ્યું છે

કિબાના સેટઅપ

સમસ્યાઓ

ગરમ તબક્કો

ગરમ તબક્કો

શીત તબક્કો

પરિણામો

ઉપયોગી લિંક્સ