שמי איגור סידורנקו, אני מוביל טכני בצוות המנהלים שמתחזק את כל התשתית של Domclick.

אני רוצה לחלוק את הניסיון שלי בהגדרת אחסון נתונים מבוזר ב- Elasticsearch. נבחן אילו הגדרות בצמתים אחראיות להפצה של רסיסים, איך ILM עובד ופועל.

מי שעובד עם יומנים, בדרך זו או אחרת, מתמודד עם הבעיה של אחסון לטווח ארוך לצורך ניתוח מאוחר יותר. ב- Elasticsearch זה נכון במיוחד, כי הכל היה מצער עם פונקציונליות האוצר. גרסה 6.6 הציגה פונקציונליות ILM. זה מורכב מ-4 שלבים:

• חם - האינדקס מתעדכן ושאילתה באופן פעיל.
• חם - האינדקס כבר לא מעודכן, אבל עדיין נמצא בשאילתה.
• קר - האינדקס אינו מעודכן יותר ולעתים רחוקות נשאלת שאילתה. המידע עדיין חייב להיות ניתן לחיפוש, אך ייתכן שהשאילתות יהיו איטיות יותר.
• מחק - אין צורך יותר באינדקס וניתן למחוק אותו בבטחה.

נָתוּן

• Elasticsearch Data Hot: 24 מעבדים, 128 ג'יגה-בייט זיכרון, 1,8 TB SSD RAID 10 (8 צמתים).
• Elasticsearch Data Warm: 24 מעבדים, 64 GB זיכרון, 8 TB NetApp SSD Policy (4 צמתים).
• Elasticsearch Data Cold: 8 מעבדים, זיכרון של 32 ג'יגה-בייט, RAID 128 HDD 10 TB (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. ישנן שתי דרכים:

1. Logstash מביא יומני קפקא. יכול להרים נקי או להמיר בצד שלך.
2. משהו בעצמו כותב אל Elasticsearch, למשל, שרת APM.

שקול דוגמה לניהול אינדקסים באמצעות Logstash. זה יוצר אינדקס וחל עליו תבנית אינדקס ומתאים סיומת ilm.

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
    }
}

התקנה של Kibana

יש דפוס בסיס שמתאים לכל האינדקסים החדשים. הוא קובע את התפלגות האינדקסים החמים, מספר הרסיסים, העתקים וכו'. משקל התבנית נקבע לפי האופציה 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 ומתחילים לעקוב אחר חיי האינדקסים.

קבל _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. ישנן שורות בקוד שבודקות אינדקסים באמצעות ביטוי רגולרי לנוכחות של מספרים בסוף. אחרת, תהיה שגיאה, לא תחול פוליסות על המדד, והוא תמיד יהיה בשלב החם.

שלב חם

פסיכולוג (cutoff) — הפחתת מספר הרסיסים, מכיוון שיש לנו 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"
          }
        }
      }
    }
  }
}

שלב קר

להקפיא (הקפאה) - אנו מקפיאים את האינדקס כדי לייעל שאילתות על נתונים היסטוריים.

חיפושים המבוצעים על מדדים קפואים משתמשים ב-threadpool הקטן, הייעודי, search_throttled כדי לשלוט במספר החיפושים במקביל שפגעו ברסיסים קפואים בכל צומת. זה מגביל את כמות הזיכרון הנוסף הנדרשת עבור מבני הנתונים החולפים התואמים לרסיסים קפואים, אשר כתוצאה מכך מגן על צמתים מפני צריכת זיכרון מוגזמת.
מדדים קפואים הם לקריאה בלבד: אינך יכול להיכנס אליהם באינדקס.
חיפושים על מדדים קפואים צפויים להתבצע באיטיות. מדדים קפואים אינם מיועדים לעומס חיפוש גבוה. ייתכן שחיפוש של אינדקס קפוא עשוי להימשך שניות או דקות להשלמתו, גם אם אותם חיפושים הושלמו באלפיות שניות כאשר המדדים לא הוקפאו.

תוצאות של

למדנו כיצד להכין צמתים לעבודה עם 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