ניתוח יומני Nginx באמצעות Amazon Athena ו-Cube.js

בדרך כלל, מוצרים מסחריים או חלופות מוכנות של קוד פתוח, כגון Prometheus + Grafana, משמשים לניטור וניתוח הפעולה של Nginx. זוהי אפשרות טובה לניטור או לניתוח בזמן אמת, אך לא מאוד נוחה לניתוח היסטורי. בכל משאב פופולרי, נפח הנתונים מיומני nginx גדל במהירות, וכדי לנתח כמות גדולה של נתונים, זה הגיוני להשתמש במשהו מיוחד יותר.

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

TL: DR;
קישור ללוח המחוונים המוגמר.

כדי לאסוף מידע שאנו משתמשים בו פלואנט, לעיבוד - AWS Kinesis Data Firehose и דבק AWS, לאחסון - AWS S3. באמצעות חבילה זו, אתה יכול לאחסן לא רק יומני nginx, אלא גם אירועים אחרים, כמו גם יומנים של שירותים אחרים. אתה יכול להחליף חלקים מסוימים עם חלקים דומים עבור המחסנית שלך, לדוגמה, אתה יכול לכתוב יומנים ל-kinesis ישירות מ-nginx, עוקף את fluentd, או להשתמש ב-logstash בשביל זה.

איסוף יומני Nginx

כברירת מחדל, יומני Nginx נראים בערך כך:

4/9/2019 12:58:17 PM1.1.1.1 - - [09/Apr/2019:09:58:17 +0000] "GET /sign-up HTTP/2.0" 200 9168 "https://example.com/sign-in" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36" "-"
4/9/2019 12:58:17 PM1.1.1.1 - - [09/Apr/2019:09:58:17 +0000] "GET /sign-in HTTP/2.0" 200 9168 "https://example.com/sign-up" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36" "-"

ניתן לנתח אותם, אבל הרבה יותר קל לתקן את תצורת Nginx כך שהיא תייצר יומנים ב-JSON:

log_format json_combined escape=json '{ "created_at": "$msec", '
            '"remote_addr": "$remote_addr", '
            '"remote_user": "$remote_user", '
            '"request": "$request", '
            '"status": $status, '
            '"bytes_sent": $bytes_sent, '
            '"request_length": $request_length, '
            '"request_time": $request_time, '
            '"http_referrer": "$http_referer", '
            '"http_x_forwarded_for": "$http_x_forwarded_for", '
            '"http_user_agent": "$http_user_agent" }';

access_log  /var/log/nginx/access.log  json_combined;

S3 לאחסון

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

יצירת מעגל בקונסולת Athena

בואו ניצור טבלה באתנה עבור יומנים. זה נחוץ הן לכתיבה והן לקריאה אם ​​אתם מתכננים להשתמש ב-Kinesis Firehose. פתח את מסוף Athena וצור טבלה:

יצירת טבלת SQL

CREATE EXTERNAL TABLE `kinesis_logs_nginx`(
  `created_at` double, 
  `remote_addr` string, 
  `remote_user` string, 
  `request` string, 
  `status` int, 
  `bytes_sent` int, 
  `request_length` int, 
  `request_time` double, 
  `http_referrer` string, 
  `http_x_forwarded_for` string, 
  `http_user_agent` string)
ROW FORMAT SERDE 
  'org.apache.hadoop.hive.ql.io.orc.OrcSerde' 
STORED AS INPUTFORMAT 
  'org.apache.hadoop.hive.ql.io.orc.OrcInputFormat' 
OUTPUTFORMAT 
  'org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat'
LOCATION
  's3://<YOUR-S3-BUCKET>'
TBLPROPERTIES ('has_encrypted_data'='false');

יצירת Kinesis Firehose Stream

Kinesis Firehose תכתוב את הנתונים שהתקבלו מ-Nginx ל-S3 בפורמט הנבחר, ותחלק אותם לספריות בפורמט YYYY/MM/DD/HH. זה יהיה שימושי בעת קריאת נתונים. אפשר כמובן לכתוב ישירות ל-S3 מ-fluentd, אבל במקרה הזה תצטרכו לכתוב JSON, וזה לא יעיל בגלל הגודל הגדול של הקבצים. בנוסף, בעת שימוש ב-PrestoDB או Athena, JSON הוא פורמט הנתונים האיטי ביותר. אז פתחו את קונסולת Kinesis Firehose, לחצו על "צור זרם משלוח", בחרו "PUT ישיר" בשדה "מסירה":

בכרטיסייה הבאה, בחר "המרת פורמט להקליט" - "מופעל" ובחר "Apache ORC" כפורמט ההקלטה. לפי כמה מחקרים אוון אומאלי, זהו הפורמט האופטימלי עבור PrestoDB ו- Athena. אנו משתמשים בטבלה שיצרנו למעלה כסכימה. שים לב שאתה יכול לציין כל מיקום S3 ב-kinesis; רק הסכימה משמשת מהטבלה. אבל אם תציין מיקום S3 אחר, לא תוכל לקרוא את הרשומות האלה מהטבלה הזו.

אנו בוחרים את S3 לאחסון ואת הדלי שיצרנו קודם לכן. Aws Glue Crawler, עליו אדבר מעט בהמשך, לא יכול לעבוד עם קידומות בדלי S3, ולכן חשוב להשאיר אותו ריק.

ניתן לשנות את האפשרויות הנותרות בהתאם לעומס שלך; אני בדרך כלל משתמש בברירת המחדל. שים לב שדחיסה של S3 אינה זמינה, אך ORC משתמשת בדחיסה מקורית כברירת מחדל.

פלואנט

כעת, לאחר שהגדרנו אחסון וקבלה של יומנים, עלינו להגדיר את השליחה. אנחנו נשתמש פלואנט, כי אני אוהב את רובי, אבל אתה יכול להשתמש ב-Logstash או לשלוח יומנים ל-kinesis ישירות. ניתן להפעיל את שרת Fluent בכמה דרכים, אני אספר לכם על docker כי זה פשוט ונוח.

ראשית, אנחנו צריכים את קובץ התצורה fluent.conf. צור אותו והוסף מקור:

סוג קָדִימָה
יציאה 24224
לאגד 0.0.0.0

עכשיו אתה יכול להפעיל את שרת Fluent. אם אתה צריך תצורה מתקדמת יותר, עבור אל רכזת דוקר יש מדריך מפורט, כולל איך להרכיב את התמונה שלך.

$ docker run 
  -d 
  -p 24224:24224 
  -p 24224:24224/udp 
  -v /data:/fluentd/log 
  -v <PATH-TO-FLUENT-CONF>:/fluentd/etc fluentd 
  -c /fluentd/etc/fluent.conf
  fluent/fluentd:stable

תצורה זו משתמשת בנתיב /fluentd/log לאחסן יומנים לפני השליחה. אתה יכול להסתדר בלי זה, אבל אז כשתתחיל מחדש, אתה יכול לאבד את כל מה שנמצא במטמון עם צירים חוזרים. אתה יכול גם להשתמש בכל יציאה; 24224 היא יציאת ברירת המחדל של Fluentd.

כעת, כאשר יש לנו את Fluent פועלת, אנו יכולים לשלוח לשם יומני Nginx. בדרך כלל אנו מריצים את Nginx בקונטיינר של Docker, ובמקרה זה ל-Docker יש מנהל התקן רישום מקורי עבור Fluentd:

$ docker run 
--log-driver=fluentd 
--log-opt fluentd-address=<FLUENTD-SERVER-ADDRESS>
--log-opt tag="{{.Name}}" 
-v /some/content:/usr/share/nginx/html:ro 
-d 
nginx

אם אתה מפעיל את Nginx בצורה שונה, אתה יכול להשתמש בקובצי יומן, כך יש ל-Fuentd תוסף זנב קובץ.

בואו נוסיף את ניתוח היומן שהוגדר לעיל לתצורת Fluent:

<filter YOUR-NGINX-TAG.*>
  @type parser
  key_name log
  emit_invalid_record_to_error false
  <parse>
    @type json
  </parse>
</filter>

ושליחת יומנים לקינזיס באמצעות plugin kinesis firehose:

<match YOUR-NGINX-TAG.*>
    @type kinesis_firehose
    region region
    delivery_stream_name <YOUR-KINESIS-STREAM-NAME>
    aws_key_id <YOUR-AWS-KEY-ID>
    aws_sec_key <YOUR_AWS-SEC_KEY>
</match>

אתנה

אם הגדרתם הכל כהלכה, לאחר זמן מה (כברירת מחדל, Kinesis מתעד נתונים שהתקבלו פעם ב-10 דקות) אתם אמורים לראות קבצי יומן ב-S3. בתפריט "ניטור" של Kinesis Firehose אתה יכול לראות כמה נתונים נרשמים ב-S3, כמו גם שגיאות. אל תשכח לתת גישת כתיבה לדלי S3 לתפקיד Kinesis. אם Kinesis לא הצליח לנתח משהו, הוא יוסיף את השגיאות לאותו דלי.

עכשיו אתה יכול להציג את הנתונים באתנה. בוא נמצא את הבקשות האחרונות שעבורן החזרנו שגיאות:

SELECT * FROM "db_name"."table_name" WHERE status > 499 ORDER BY created_at DESC limit 10;

סריקת כל הרשומות עבור כל בקשה

כעת היומנים שלנו עברו עיבוד ואוחסנו ב-S3 ב-ORC, דחוסים ומוכנים לניתוח. Kinesis Firehose אפילו ארגנה אותם בספריות עבור כל שעה. עם זאת, כל עוד הטבלה אינה מחולקת, Athena תטען נתונים מכל הזמנים על כל בקשה, למעט חריגים נדירים. זו בעיה גדולה משתי סיבות:

• נפח הנתונים גדל כל הזמן, ומאט את השאילתות;
• אתנה מחויבת על סמך נפח הנתונים שנסרקו, עם מינימום של 10 MB לכל בקשה.

כדי לתקן זאת, אנו משתמשים ב-AWS Glue Crawler, אשר יסרוק את הנתונים ב-S3 ויכתוב את פרטי המחיצה ל-Glue Metastore. זה יאפשר לנו להשתמש במחיצות כמסנן בעת ​​שאילתת Athena, והוא יסרוק רק את הספריות שצוינו בשאילתה.

הגדרת Amazon Glue Crawler

Amazon Glue Crawler סורק את כל הנתונים בדלי S3 ויוצר טבלאות עם מחיצות. צור סורק דבק ממסוף הדבק של AWS והוסף דלי שבו אתה מאחסן את הנתונים. ניתן להשתמש בסורק אחד עבור מספר דליים, ובמקרה זה הוא יצור טבלאות במסד הנתונים שצוין עם שמות התואמים את שמות הדליים. אם אתה מתכנן להשתמש בנתונים אלה באופן קבוע, הקפד להגדיר את לוח הזמנים של ההשקה של Crawler כך שיתאים לצרכים שלך. אנו משתמשים ב-Crawler אחד עבור כל השולחנות, שפועל כל שעה.

שולחנות מחולקים

לאחר ההשקה הראשונה של הסורק, טבלאות עבור כל דלי סרוק צריכות להופיע במסד הנתונים שצוין בהגדרות. פתח את מסוף Athena ומצא את הטבלה עם יומני Nginx. בוא ננסה לקרוא משהו:

SELECT * FROM "default"."part_demo_kinesis_bucket"
WHERE(
  partition_0 = '2019' AND
  partition_1 = '04' AND
  partition_2 = '08' AND
  partition_3 = '06'
  );

שאילתה זו תבחר את כל הרשומות שהתקבלו בין השעות 6:7 ל-8:2019 ב-XNUMX באפריל, XNUMX. אבל כמה זה יעיל יותר מסתם קריאה מטבלה לא מחולקת? בואו נברר ונבחר את אותן רשומות, ונסנן אותן לפי חותמת זמן:

3.59 שניות ו-244.34 מגה-בייט של נתונים במערך נתונים עם רק שבוע של יומנים. בוא ננסה לסנן לפי מחיצה:

קצת יותר מהר, אבל הכי חשוב - רק 1.23 מגה בייט של נתונים! זה יהיה הרבה יותר זול אלמלא המינימום 10 מגה-בייט לכל בקשה בתמחור. אבל זה עדיין הרבה יותר טוב, ובמערכי נתונים גדולים ההבדל יהיה הרבה יותר מרשים.

בניית לוח מחוונים באמצעות Cube.js

כדי להרכיב את לוח המחוונים, אנו משתמשים במסגרת האנליטית Cube.js. יש לו די הרבה פונקציות, אבל אנחנו מעוניינים בשתיים: היכולת להשתמש באופן אוטומטי במסנני מחיצות ובצבירה מראש של נתונים. הוא משתמש בסכימת נתונים סכמת נתונים, כתוב ב-Javascript כדי ליצור SQL ולבצע שאילתת מסד נתונים. עלינו רק לציין כיצד להשתמש במסנן המחיצות בסכימת הנתונים.

בואו ניצור יישום Cube.js חדש. מכיוון שאנו כבר משתמשים בערימת AWS, זה הגיוני להשתמש ב- Lambda לצורך פריסה. אתה יכול להשתמש בתבנית האקספרס ליצירת אם אתה מתכנן לארח את ה-Cube.js backend ב-Heroku או ב-Docker. התיעוד מתאר אחרים שיטות אירוח.

$ npm install -g cubejs-cli
$ cubejs create nginx-log-analytics -t serverless -d athena

משתני סביבה משמשים להגדרת גישה למסד נתונים ב-cube.js. המחולל יצור קובץ .env שבו תוכל לציין את המפתחות שלך אתנה.

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

במדריך schema, צור קובץ Logs.js. להלן מודל נתונים לדוגמה עבור nginx:

קוד דגם

const partitionFilter = (from, to) => `
    date(from_iso8601_timestamp(${from})) <= date_parse(partition_0 || partition_1 || partition_2, '%Y%m%d') AND
    date(from_iso8601_timestamp(${to})) >= date_parse(partition_0 || partition_1 || partition_2, '%Y%m%d')
    `

cube(`Logs`, {
  sql: `
  select * from part_demo_kinesis_bucket
  WHERE ${FILTER_PARAMS.Logs.createdAt.filter(partitionFilter)}
  `,

  measures: {
    count: {
      type: `count`,
    },

    errorCount: {
      type: `count`,
      filters: [
        { sql: `${CUBE.isError} = 'Yes'` }
      ]
    },

    errorRate: {
      type: `number`,
      sql: `100.0 * ${errorCount} / ${count}`,
      format: `percent`
    }
  },

  dimensions: {
    status: {
      sql: `status`,
      type: `number`
    },

    isError: {
      type: `string`,
      case: {
        when: [{
          sql: `${CUBE}.status >= 400`, label: `Yes`
        }],
        else: { label: `No` }
      }
    },

    createdAt: {
      sql: `from_unixtime(created_at)`,
      type: `time`
    }
  }
});

כאן אנו משתמשים במשתנה FILTER_PARAMSכדי ליצור שאילתת SQL עם מסנן מחיצות.

אנחנו גם מגדירים את המדדים והפרמטרים שברצוננו להציג בלוח המחוונים ומציינים צבירות מראש. Cube.js תיצור טבלאות נוספות עם נתונים מצטברים מראש ויעדכן את הנתונים באופן אוטומטי כשהם מגיעים. זה לא רק מאיץ את השאילתות, אלא גם מפחית את עלות השימוש באתנה.

בואו נוסיף את המידע הזה לקובץ סכימת הנתונים:

preAggregations: {
  main: {
    type: `rollup`,
    measureReferences: [count, errorCount],
    dimensionReferences: [isError, status],
    timeDimensionReference: createdAt,
    granularity: `day`,
    partitionGranularity: `month`,
    refreshKey: {
      sql: FILTER_PARAMS.Logs.createdAt.filter((from, to) => 
        `select
           CASE WHEN from_iso8601_timestamp(${to}) + interval '3' day > now()
           THEN date_trunc('hour', now()) END`
      )
    }
  }
}

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

עכשיו אנחנו יכולים להרכיב את לוח המחוונים!

Cube.js backend מספק REST API ומערכת של ספריות לקוח עבור מסגרות חזיתיות פופולריות. אנו נשתמש בגרסת React של הלקוח כדי לבנות את לוח המחוונים. Cube.js מספק רק נתונים, אז נצטרך ספריית הדמיה - אני אוהב את זה תרשימים מחדש, אבל אתה יכול להשתמש בכל.

שרת Cube.js מקבל את הבקשה ב פורמט JSON, המפרט את המדדים הנדרשים. לדוגמה, כדי לחשב כמה שגיאות Nginx נתן ביום, עליך לשלוח את הבקשה הבאה:

{
  "measures": ["Logs.errorCount"],
  "timeDimensions": [
    {
      "dimension": "Logs.createdAt",
      "dateRange": ["2019-01-01", "2019-01-07"],
      "granularity": "day"
    }
  ]
}

בואו נתקין את לקוח Cube.js ואת ספריית הרכיבים React דרך NPM:

$ npm i --save @cubejs-client/core @cubejs-client/react

אנו מייבאים רכיבים cubejs и QueryRendererכדי להוריד את הנתונים, ולאסוף את לוח המחוונים:

קוד לוח המחוונים

import React from 'react';
import { LineChart, Line, XAxis, YAxis } from 'recharts';
import cubejs from '@cubejs-client/core';
import { QueryRenderer } from '@cubejs-client/react';

const cubejsApi = cubejs(
  'YOUR-CUBEJS-API-TOKEN',
  { apiUrl: 'http://localhost:4000/cubejs-api/v1' },
);

export default () => {
  return (
    <QueryRenderer
      query={{
        measures: ['Logs.errorCount'],
        timeDimensions: [{
            dimension: 'Logs.createdAt',
            dateRange: ['2019-01-01', '2019-01-07'],
            granularity: 'day'
        }]
      }}
      cubejsApi={cubejsApi}
      render={({ resultSet }) => {
        if (!resultSet) {
          return 'Loading...';
        }

        return (
          <LineChart data={resultSet.rawData()}>
            <XAxis dataKey="Logs.createdAt"/>
            <YAxis/>
            <Line type="monotone" dataKey="Logs.errorCount" stroke="#8884d8"/>
          </LineChart>
        );
      }}
    />
  )
}

מקורות לוח המחוונים זמינים ב ארגז חול של קוד.

מקור: www.habr.com