Amazon Kinesis ਅਤੇ ਸਰਵਰ ਰਹਿਤ ਸਾਦਗੀ ਦੇ ਨਾਲ Aviasales API ਏਕੀਕਰਣ

ਹੇ ਹਬਰ!

ਕੀ ਤੁਹਾਨੂੰ ਉੱਡਦੇ ਹਵਾਈ ਜਹਾਜ਼ ਪਸੰਦ ਹਨ? ਮੈਨੂੰ ਇਹ ਪਸੰਦ ਹੈ, ਪਰ ਸਵੈ-ਅਲੱਗ-ਥਲੱਗ ਹੋਣ ਦੇ ਦੌਰਾਨ ਮੈਨੂੰ ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਸਰੋਤ - Aviasales ਤੋਂ ਹਵਾਈ ਟਿਕਟਾਂ ਦੇ ਡੇਟਾ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਨਾਲ ਵੀ ਪਿਆਰ ਹੋ ਗਿਆ।

ਅੱਜ ਅਸੀਂ Amazon Kinesis ਦੇ ਕੰਮ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਾਂਗੇ, ਰੀਅਲ-ਟਾਈਮ ਵਿਸ਼ਲੇਸ਼ਣ ਦੇ ਨਾਲ ਇੱਕ ਸਟ੍ਰੀਮਿੰਗ ਸਿਸਟਮ ਬਣਾਵਾਂਗੇ, Amazon DynamoDB NoSQL ਡੇਟਾਬੇਸ ਨੂੰ ਮੁੱਖ ਡਾਟਾ ਸਟੋਰੇਜ ਵਜੋਂ ਸਥਾਪਿਤ ਕਰਾਂਗੇ, ਅਤੇ ਦਿਲਚਸਪ ਟਿਕਟਾਂ ਲਈ SMS ਸੂਚਨਾਵਾਂ ਸੈਟ ਅਪ ਕਰਾਂਗੇ।

ਸਾਰੇ ਵੇਰਵੇ ਕੱਟ ਦੇ ਅਧੀਨ ਹਨ! ਜਾਣਾ!

ਜਾਣ ਪਛਾਣ

ਉਦਾਹਰਨ ਲਈ, ਸਾਨੂੰ ਤੱਕ ਪਹੁੰਚ ਦੀ ਲੋੜ ਹੈ Aviasales API. ਇਸ ਤੱਕ ਪਹੁੰਚ ਮੁਫਤ ਅਤੇ ਪਾਬੰਦੀਆਂ ਤੋਂ ਬਿਨਾਂ ਪ੍ਰਦਾਨ ਕੀਤੀ ਜਾਂਦੀ ਹੈ; ਤੁਹਾਨੂੰ ਡੇਟਾ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਆਪਣਾ API ਟੋਕਨ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ "ਡਿਵੈਲਪਰ" ਭਾਗ ਵਿੱਚ ਰਜਿਸਟਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਇਸ ਲੇਖ ਦਾ ਮੁੱਖ ਉਦੇਸ਼ AWS ਵਿੱਚ ਜਾਣਕਾਰੀ ਸਟ੍ਰੀਮਿੰਗ ਦੀ ਵਰਤੋਂ ਬਾਰੇ ਇੱਕ ਆਮ ਸਮਝ ਦੇਣਾ ਹੈ; ਅਸੀਂ ਇਸ ਗੱਲ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹਾਂ ਕਿ ਵਰਤੇ ਗਏ API ਦੁਆਰਾ ਵਾਪਸ ਕੀਤਾ ਗਿਆ ਡੇਟਾ ਸਖਤੀ ਨਾਲ ਅੱਪ-ਟੂ-ਡੇਟ ਨਹੀਂ ਹੈ ਅਤੇ ਕੈਸ਼ ਤੋਂ ਪ੍ਰਸਾਰਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ਕਿ ਪਿਛਲੇ 48 ਘੰਟਿਆਂ ਲਈ Aviasales.ru ਅਤੇ Jetradar.com ਸਾਈਟਾਂ ਦੇ ਉਪਭੋਗਤਾਵਾਂ ਦੁਆਰਾ ਖੋਜਾਂ ਦੇ ਅਧਾਰ ਤੇ ਬਣਾਈ ਗਈ ਹੈ।

ਕਾਇਨੇਸਿਸ-ਏਜੰਟ, ਪ੍ਰੋਡਿਊਸਿੰਗ ਮਸ਼ੀਨ 'ਤੇ ਸਥਾਪਿਤ, API ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ, Kinesis ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਦੁਆਰਾ ਲੋੜੀਂਦੇ ਸਟ੍ਰੀਮ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਆਪਣੇ ਆਪ ਪਾਰਸ ਅਤੇ ਪ੍ਰਸਾਰਿਤ ਕਰੇਗਾ। ਇਸ ਸਟ੍ਰੀਮ ਦਾ ਕੱਚਾ ਸੰਸਕਰਣ ਸਟੋਰ 'ਤੇ ਸਿੱਧਾ ਲਿਖਿਆ ਜਾਵੇਗਾ। DynamoDB ਵਿੱਚ ਤੈਨਾਤ ਕੱਚਾ ਡੇਟਾ ਸਟੋਰੇਜ BI ਟੂਲਸ, ਜਿਵੇਂ ਕਿ AWS Quick Sight ਦੁਆਰਾ ਡੂੰਘੇ ਟਿਕਟ ਵਿਸ਼ਲੇਸ਼ਣ ਦੀ ਆਗਿਆ ਦੇਵੇਗੀ।

ਅਸੀਂ ਪੂਰੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਨੂੰ ਤੈਨਾਤ ਕਰਨ ਲਈ ਦੋ ਵਿਕਲਪਾਂ 'ਤੇ ਵਿਚਾਰ ਕਰਾਂਗੇ:

• ਮੈਨੁਅਲ - AWS ਪ੍ਰਬੰਧਨ ਕੰਸੋਲ ਦੁਆਰਾ;
• ਟੈਰਾਫਾਰਮ ਕੋਡ ਤੋਂ ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਆਲਸੀ ਆਟੋਮੇਟਰਾਂ ਲਈ ਹੈ;

ਵਿਕਸਤ ਸਿਸਟਮ ਦਾ ਆਰਕੀਟੈਕਚਰ

ਵਰਤੇ ਗਏ ਹਿੱਸੇ:

• Aviasales API - ਇਸ API ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਗਏ ਡੇਟਾ ਨੂੰ ਅਗਲੇ ਸਾਰੇ ਕੰਮ ਲਈ ਵਰਤਿਆ ਜਾਵੇਗਾ;
• EC2 ਨਿਰਮਾਤਾ ਉਦਾਹਰਣ — ਕਲਾਉਡ ਵਿੱਚ ਇੱਕ ਨਿਯਮਤ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਜਿਸ ਉੱਤੇ ਇਨਪੁਟ ਡੇਟਾ ਸਟ੍ਰੀਮ ਤਿਆਰ ਕੀਤਾ ਜਾਵੇਗਾ:
  • ਕੀਨੇਸਿਸ ਏਜੰਟ ਮਸ਼ੀਨ 'ਤੇ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਸਥਾਪਤ ਕੀਤੀ ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨ ਹੈ ਜੋ ਕਿਨੇਸਿਸ (ਕਿਨੇਸਿਸ ਡੇਟਾ ਸਟ੍ਰੀਮਜ਼ ਜਾਂ ਕਾਇਨੇਸਿਸ ਫਾਇਰਹੋਜ਼) ਨੂੰ ਡਾਟਾ ਇਕੱਠਾ ਕਰਨ ਅਤੇ ਭੇਜਣ ਦਾ ਆਸਾਨ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ। ਏਜੰਟ ਲਗਾਤਾਰ ਨਿਰਧਾਰਿਤ ਡਾਇਰੈਕਟਰੀਆਂ ਵਿੱਚ ਫਾਈਲਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਦੀ ਨਿਗਰਾਨੀ ਕਰਦਾ ਹੈ ਅਤੇ Kinesis ਨੂੰ ਨਵਾਂ ਡੇਟਾ ਭੇਜਦਾ ਹੈ;
  • API ਕਾਲਰ ਸਕ੍ਰਿਪਟ — ਇੱਕ ਪਾਈਥਨ ਸਕ੍ਰਿਪਟ ਜੋ API ਨੂੰ ਬੇਨਤੀਆਂ ਕਰਦੀ ਹੈ ਅਤੇ ਜਵਾਬ ਨੂੰ ਇੱਕ ਫੋਲਡਰ ਵਿੱਚ ਰੱਖਦੀ ਹੈ ਜਿਸਦੀ ਕਿਨੇਸਿਸ ਏਜੰਟ ਦੁਆਰਾ ਨਿਗਰਾਨੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ;
• Kinesis ਡਾਟਾ ਸਟ੍ਰੀਮਜ਼ - ਵਿਆਪਕ ਸਕੇਲਿੰਗ ਸਮਰੱਥਾਵਾਂ ਵਾਲੀ ਰੀਅਲ-ਟਾਈਮ ਡਾਟਾ ਸਟ੍ਰੀਮਿੰਗ ਸੇਵਾ;
• Kinesis ਵਿਸ਼ਲੇਸ਼ਣ ਇੱਕ ਸਰਵਰ ਰਹਿਤ ਸੇਵਾ ਹੈ ਜੋ ਰੀਅਲ ਟਾਈਮ ਵਿੱਚ ਸਟ੍ਰੀਮਿੰਗ ਡੇਟਾ ਦੇ ਵਿਸ਼ਲੇਸ਼ਣ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦੀ ਹੈ। ਐਮਾਜ਼ਾਨ ਕਾਇਨੇਸਿਸ ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਐਪਲੀਕੇਸ਼ਨ ਸਰੋਤਾਂ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਦਾ ਹੈ ਅਤੇ ਆਉਣ ਵਾਲੇ ਡੇਟਾ ਦੀ ਕਿਸੇ ਵੀ ਮਾਤਰਾ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਆਪਣੇ ਆਪ ਸਕੇਲ ਕਰਦਾ ਹੈ;
• AWS Lambda — ਇੱਕ ਸੇਵਾ ਜੋ ਤੁਹਾਨੂੰ ਸਰਵਰ ਦਾ ਬੈਕਅੱਪ ਲਏ ਜਾਂ ਸੈੱਟਅੱਪ ਕੀਤੇ ਬਿਨਾਂ ਕੋਡ ਚਲਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ। ਹਰੇਕ ਕਾਲ ਲਈ ਸਾਰੀ ਕੰਪਿਊਟਿੰਗ ਪਾਵਰ ਆਟੋਮੈਟਿਕ ਹੀ ਸਕੇਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ;
• ਐਮਾਜ਼ਾਨ ਡਾਇਨਾਮੋਡੀਬੀ - ਮੁੱਖ-ਮੁੱਲ ਦੇ ਜੋੜਿਆਂ ਅਤੇ ਦਸਤਾਵੇਜ਼ਾਂ ਦਾ ਇੱਕ ਡੇਟਾਬੇਸ ਜੋ ਕਿਸੇ ਵੀ ਪੈਮਾਨੇ 'ਤੇ ਚੱਲਣ ਵੇਲੇ 10 ਮਿਲੀਸਕਿੰਟ ਤੋਂ ਘੱਟ ਦੀ ਲੇਟੈਂਸੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। DynamoDB ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਤੁਹਾਨੂੰ ਕਿਸੇ ਸਰਵਰ ਦਾ ਪ੍ਰਬੰਧ, ਪੈਚ ਜਾਂ ਪ੍ਰਬੰਧਨ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। DynamoDB ਉਪਲਬਧ ਸਰੋਤਾਂ ਦੀ ਮਾਤਰਾ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰਨ ਅਤੇ ਉੱਚ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਣ ਲਈ ਆਪਣੇ ਆਪ ਟੇਬਲ ਨੂੰ ਸਕੇਲ ਕਰਦਾ ਹੈ। ਕੋਈ ਸਿਸਟਮ ਪ੍ਰਸ਼ਾਸਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ;
• ਐਮਾਜ਼ਾਨ SNS - ਪ੍ਰਕਾਸ਼ਕ-ਸਬਸਕ੍ਰਾਈਬਰ (Pub/Sub) ਮਾਡਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸੁਨੇਹੇ ਭੇਜਣ ਲਈ ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਪ੍ਰਬੰਧਿਤ ਸੇਵਾ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਮਾਈਕ੍ਰੋਸੇਵਾਵਾਂ, ਵੰਡੀਆਂ ਪ੍ਰਣਾਲੀਆਂ ਅਤੇ ਸਰਵਰ ਰਹਿਤ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਅਲੱਗ ਕਰ ਸਕਦੇ ਹੋ। SNS ਦੀ ਵਰਤੋਂ ਮੋਬਾਈਲ ਪੁਸ਼ ਸੂਚਨਾਵਾਂ, SMS ਸੰਦੇਸ਼ਾਂ ਅਤੇ ਈਮੇਲਾਂ ਰਾਹੀਂ ਅੰਤਮ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਜਾਣਕਾਰੀ ਭੇਜਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਸ਼ੁਰੂਆਤੀ ਸਿਖਲਾਈ

ਡੇਟਾ ਪ੍ਰਵਾਹ ਦੀ ਨਕਲ ਕਰਨ ਲਈ, ਮੈਂ Aviasales API ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੀ ਏਅਰਲਾਈਨ ਟਿਕਟ ਜਾਣਕਾਰੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ। IN ਦਸਤਾਵੇਜ਼ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਦੀ ਕਾਫ਼ੀ ਇੱਕ ਵਿਆਪਕ ਸੂਚੀ, ਆਓ ਉਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਨੂੰ ਲੈਂਦੇ ਹਾਂ - "ਮਾਸਿਕ ਕੀਮਤ ਕੈਲੰਡਰ", ਜੋ ਕਿ ਮਹੀਨੇ ਦੇ ਹਰ ਦਿਨ ਲਈ ਕੀਮਤਾਂ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਟ੍ਰਾਂਸਫਰ ਦੀ ਸੰਖਿਆ ਦੁਆਰਾ ਸਮੂਹ ਕੀਤਾ ਗਿਆ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਬੇਨਤੀ ਵਿੱਚ ਖੋਜ ਦਾ ਮਹੀਨਾ ਨਹੀਂ ਦਰਸਾਉਂਦੇ ਹੋ, ਤਾਂ ਮੌਜੂਦਾ ਮਹੀਨੇ ਤੋਂ ਬਾਅਦ ਦੇ ਮਹੀਨੇ ਲਈ ਜਾਣਕਾਰੀ ਵਾਪਸ ਕਰ ਦਿੱਤੀ ਜਾਵੇਗੀ।

ਇਸ ਲਈ, ਆਓ ਰਜਿਸਟਰ ਕਰੀਏ ਅਤੇ ਆਪਣਾ ਟੋਕਨ ਪ੍ਰਾਪਤ ਕਰੀਏ।

ਇੱਕ ਉਦਾਹਰਨ ਬੇਨਤੀ ਹੇਠਾਂ ਦਿੱਤੀ ਗਈ ਹੈ:

http://api.travelpayouts.com/v2/prices/month-matrix?currency=rub&origin=LED&destination=HKT&show_to_affiliates=true&token=TOKEN_API

ਬੇਨਤੀ ਵਿੱਚ ਇੱਕ ਟੋਕਨ ਨਿਰਧਾਰਤ ਕਰਕੇ API ਤੋਂ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਉਪਰੋਕਤ ਵਿਧੀ ਕੰਮ ਕਰੇਗੀ, ਪਰ ਮੈਂ ਹੈਡਰ ਰਾਹੀਂ ਐਕਸੈਸ ਟੋਕਨ ਪਾਸ ਕਰਨ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦਾ ਹਾਂ, ਇਸਲਈ ਅਸੀਂ ਇਸ ਵਿਧੀ ਨੂੰ api_caller.py ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਵਰਤਾਂਗੇ।

ਨਮੂਨਾ ਜਵਾਬ:

{{
   "success":true,
   "data":[{
      "show_to_affiliates":true,
      "trip_class":0,
      "origin":"LED",
      "destination":"HKT",
      "depart_date":"2015-10-01",
      "return_date":"",
      "number_of_changes":1,
      "value":29127,
      "found_at":"2015-09-24T00:06:12+04:00",
      "distance":8015,
      "actual":true
   }]
}

ਉਪਰੋਕਤ ਉਦਾਹਰਨ API ਜਵਾਬ ਸੇਂਟ ਪੀਟਰਸਬਰਗ ਤੋਂ ਫੁਕ ਤੱਕ ਟਿਕਟ ਦਿਖਾਉਂਦਾ ਹੈ... ਓਹ, ਕੀ ਸੁਪਨਾ ਹੈ...
ਕਿਉਂਕਿ ਮੈਂ ਕਜ਼ਾਨ ਤੋਂ ਹਾਂ, ਅਤੇ ਫੂਕੇਟ ਹੁਣ "ਸਿਰਫ਼ ਇੱਕ ਸੁਪਨਾ" ਹੈ, ਆਓ ਸੇਂਟ ਪੀਟਰਸਬਰਗ ਤੋਂ ਕਾਜ਼ਾਨ ਤੱਕ ਦੀਆਂ ਟਿਕਟਾਂ ਲੱਭੀਏ।

ਇਹ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਇੱਕ AWS ਖਾਤਾ ਹੈ। ਮੈਂ ਤੁਰੰਤ ਇਸ ਤੱਥ ਵੱਲ ਵਿਸ਼ੇਸ਼ ਧਿਆਨ ਖਿੱਚਣਾ ਚਾਹਾਂਗਾ ਕਿ Kinesis ਅਤੇ SMS ਦੁਆਰਾ ਸੂਚਨਾਵਾਂ ਭੇਜਣਾ ਸਾਲਾਨਾ ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹਨ। ਮੁਫਤ ਟੀਅਰ (ਮੁਫਤ ਵਰਤੋਂ). ਪਰ ਇਸਦੇ ਬਾਵਜੂਦ, ਕੁਝ ਡਾਲਰਾਂ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ, ਪ੍ਰਸਤਾਵਿਤ ਪ੍ਰਣਾਲੀ ਨੂੰ ਬਣਾਉਣਾ ਅਤੇ ਇਸ ਨਾਲ ਖੇਡਣਾ ਕਾਫ਼ੀ ਸੰਭਵ ਹੈ. ਅਤੇ, ਬੇਸ਼ਕ, ਉਹਨਾਂ ਦੀ ਲੋੜ ਨਾ ਹੋਣ ਤੋਂ ਬਾਅਦ ਸਾਰੇ ਸਰੋਤਾਂ ਨੂੰ ਮਿਟਾਉਣਾ ਨਾ ਭੁੱਲੋ.

ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, DynamoDb ਅਤੇ lambda ਫੰਕਸ਼ਨ ਸਾਡੇ ਲਈ ਮੁਫਤ ਹੋਣਗੇ ਜੇਕਰ ਅਸੀਂ ਆਪਣੀਆਂ ਮਹੀਨਾਵਾਰ ਮੁਫਤ ਸੀਮਾਵਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹਾਂ। ਉਦਾਹਰਨ ਲਈ, DynamoDB ਲਈ: 25 GB ਸਟੋਰੇਜ, 25 WCU/RCU ਅਤੇ 100 ਮਿਲੀਅਨ ਸਵਾਲ। ਅਤੇ ਪ੍ਰਤੀ ਮਹੀਨਾ ਇੱਕ ਮਿਲੀਅਨ ਲਾਂਬਡਾ ਫੰਕਸ਼ਨ ਕਾਲਾਂ।

ਮੈਨੁਅਲ ਸਿਸਟਮ ਤੈਨਾਤੀ

ਕਾਇਨੇਸਿਸ ਡਾਟਾ ਸਟ੍ਰੀਮਜ਼ ਸੈਟ ਅਪ ਕਰਨਾ

ਚਲੋ ਕੀਨੇਸਿਸ ਡਾਟਾ ਸਟ੍ਰੀਮਜ਼ ਸੇਵਾ 'ਤੇ ਚੱਲੀਏ ਅਤੇ ਦੋ ਨਵੀਆਂ ਸਟ੍ਰੀਮਾਂ ਬਣਾਈਏ, ਹਰੇਕ ਲਈ ਇੱਕ ਸ਼ਾਰਡ।

ਇੱਕ ਸ਼ਾਰਡ ਕੀ ਹੈ?
ਇੱਕ ਸ਼ਾਰਡ ਇੱਕ ਐਮਾਜ਼ਾਨ ਕਾਇਨੇਸਿਸ ਸਟ੍ਰੀਮ ਦੀ ਬੁਨਿਆਦੀ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਯੂਨਿਟ ਹੈ। ਇੱਕ ਖੰਡ 1 MB/s ਦੀ ਗਤੀ ਨਾਲ ਇਨਪੁਟ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਅਤੇ 2 MB/s ਦੀ ਗਤੀ ਨਾਲ ਆਉਟਪੁੱਟ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇੱਕ ਖੰਡ ਪ੍ਰਤੀ ਸਕਿੰਟ 1000 PUT ਐਂਟਰੀਆਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। ਡਾਟਾ ਸਟ੍ਰੀਮ ਬਣਾਉਂਦੇ ਸਮੇਂ, ਤੁਹਾਨੂੰ ਲੋੜੀਂਦੇ ਖੰਡਾਂ ਦੀ ਗਿਣਤੀ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਦੋ ਹਿੱਸਿਆਂ ਦੇ ਨਾਲ ਇੱਕ ਡਾਟਾ ਸਟ੍ਰੀਮ ਬਣਾ ਸਕਦੇ ਹੋ। ਇਹ ਡਾਟਾ ਸਟ੍ਰੀਮ 2 MB/s 'ਤੇ ਇਨਪੁਟ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਅਤੇ 4 MB/s 'ਤੇ ਆਉਟਪੁੱਟ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਪ੍ਰਦਾਨ ਕਰੇਗਾ, 2000 PUT ਰਿਕਾਰਡ ਪ੍ਰਤੀ ਸਕਿੰਟ ਤੱਕ ਦਾ ਸਮਰਥਨ ਕਰੇਗਾ।

ਤੁਹਾਡੀ ਸਟ੍ਰੀਮ ਵਿੱਚ ਜਿੰਨੇ ਜ਼ਿਆਦਾ ਸ਼ਾਰਡਸ, ਇਸਦਾ ਥ੍ਰੋਪੁੱਟ ਓਨਾ ਹੀ ਵੱਡਾ ਹੈ। ਸਿਧਾਂਤ ਵਿੱਚ, ਇਸ ਤਰ੍ਹਾਂ ਵਹਾਅ ਨੂੰ ਸਕੇਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ - ਸ਼ਾਰਡਜ਼ ਜੋੜ ਕੇ। ਪਰ ਤੁਹਾਡੇ ਕੋਲ ਜਿੰਨੇ ਜ਼ਿਆਦਾ ਸ਼ਾਰਡ ਹੋਣਗੇ, ਕੀਮਤ ਓਨੀ ਹੀ ਜ਼ਿਆਦਾ ਹੋਵੇਗੀ। ਹਰੇਕ ਸ਼ਾਰਡ ਦੀ ਕੀਮਤ 1,5 ਸੈਂਟ ਪ੍ਰਤੀ ਘੰਟਾ ਹੈ ਅਤੇ ਹਰੇਕ ਮਿਲੀਅਨ PUT ਪੇਲੋਡ ਯੂਨਿਟਾਂ ਲਈ ਇੱਕ ਵਾਧੂ 1.4 ਸੈਂਟ ਹੈ।

ਆਓ ਨਾਮ ਨਾਲ ਇੱਕ ਨਵੀਂ ਧਾਰਾ ਬਣਾਈਏ ਏਅਰਲਾਈਨ_ਟਿਕਟਾਂ, 1 ਸ਼ਾਰਡ ਉਸ ਲਈ ਕਾਫੀ ਹੋਵੇਗਾ:

ਹੁਣ ਨਾਮ ਦੇ ਨਾਲ ਇੱਕ ਹੋਰ ਥਰਿੱਡ ਬਣਾਉਂਦੇ ਹਾਂ ਵਿਸ਼ੇਸ਼_ਸਟ੍ਰੀਮ:

ਨਿਰਮਾਤਾ ਸੈੱਟਅੱਪ

ਕਿਸੇ ਕੰਮ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਲਈ, ਡੇਟਾ ਉਤਪਾਦਕ ਵਜੋਂ ਇੱਕ ਨਿਯਮਤ EC2 ਉਦਾਹਰਣ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਕਾਫ਼ੀ ਹੈ। ਇਹ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ, ਮਹਿੰਗੀ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਨਹੀਂ ਹੋਣੀ ਚਾਹੀਦੀ; ਇੱਕ ਸਪਾਟ t2.micro ਬਿਲਕੁਲ ਠੀਕ ਕਰੇਗਾ।

ਮਹੱਤਵਪੂਰਨ ਨੋਟ: ਉਦਾਹਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਚਿੱਤਰ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ - Amazon Linux AMI 2018.03.0, ਇਸ ਵਿੱਚ ਕਾਇਨੇਸਿਸ ਏਜੰਟ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਲਾਂਚ ਕਰਨ ਲਈ ਘੱਟ ਸੈਟਿੰਗਾਂ ਹਨ।

EC2 ਸੇਵਾ 'ਤੇ ਜਾਓ, ਇੱਕ ਨਵੀਂ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਬਣਾਓ, ਟਾਈਪ t2.micro ਨਾਲ ਲੋੜੀਦਾ AMI ਚੁਣੋ, ਜੋ ਕਿ ਮੁਫਤ ਟੀਅਰ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ:

ਨਵੀਂ ਬਣੀ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਨੂੰ ਕਾਇਨੇਸਿਸ ਸੇਵਾ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣ ਲਈ, ਇਸ ਨੂੰ ਅਜਿਹਾ ਕਰਨ ਦੇ ਅਧਿਕਾਰ ਦਿੱਤੇ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ। ਅਜਿਹਾ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਹੈ ਇੱਕ IAM ਰੋਲ ਨਿਰਧਾਰਤ ਕਰਨਾ। ਇਸ ਲਈ, ਸਟੈਪ 3 'ਤੇ: ਇੰਸਟੈਂਸ ਡਿਟੇਲ ਸਕ੍ਰੀਨ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰੋ, ਤੁਹਾਨੂੰ ਚੁਣਨਾ ਚਾਹੀਦਾ ਹੈ ਨਵੀਂ IAM ਰੋਲ ਬਣਾਓ:

EC2 ਲਈ ਇੱਕ IAM ਰੋਲ ਬਣਾਉਣਾ

ਖੁੱਲਣ ਵਾਲੀ ਵਿੰਡੋ ਵਿੱਚ, ਚੁਣੋ ਕਿ ਅਸੀਂ EC2 ਲਈ ਇੱਕ ਨਵੀਂ ਭੂਮਿਕਾ ਬਣਾ ਰਹੇ ਹਾਂ ਅਤੇ ਅਨੁਮਤੀਆਂ ਭਾਗ ਵਿੱਚ ਜਾਓ:

ਸਿਖਲਾਈ ਦੀ ਉਦਾਹਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਸਾਨੂੰ ਸਰੋਤ ਅਧਿਕਾਰਾਂ ਦੇ ਦਾਣੇਦਾਰ ਸੰਰਚਨਾ ਦੀਆਂ ਸਾਰੀਆਂ ਪੇਚੀਦਗੀਆਂ ਵਿੱਚ ਜਾਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਇਸਲਈ ਅਸੀਂ ਐਮਾਜ਼ਾਨ ਦੁਆਰਾ ਪਹਿਲਾਂ ਤੋਂ ਸੰਰਚਿਤ ਕੀਤੀਆਂ ਨੀਤੀਆਂ ਦੀ ਚੋਣ ਕਰਾਂਗੇ: AmazonKinesisFullAccess ਅਤੇ CloudWatchFullAccess।

ਆਓ ਇਸ ਭੂਮਿਕਾ ਲਈ ਕੁਝ ਅਰਥਪੂਰਨ ਨਾਮ ਦੇਈਏ, ਉਦਾਹਰਨ ਲਈ: EC2-KinesisStreams-FullAccess. ਨਤੀਜਾ ਉਹੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਹੇਠਾਂ ਦਿੱਤੀ ਤਸਵੀਰ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ:

ਇਸ ਨਵੀਂ ਭੂਮਿਕਾ ਨੂੰ ਬਣਾਉਣ ਤੋਂ ਬਾਅਦ, ਇਸ ਨੂੰ ਬਣਾਈ ਗਈ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਉਦਾਹਰਣ ਨਾਲ ਜੋੜਨਾ ਨਾ ਭੁੱਲੋ:

ਅਸੀਂ ਇਸ ਸਕ੍ਰੀਨ 'ਤੇ ਹੋਰ ਕੁਝ ਨਹੀਂ ਬਦਲਦੇ ਅਤੇ ਅਗਲੀਆਂ ਵਿੰਡੋਜ਼ 'ਤੇ ਚਲੇ ਜਾਂਦੇ ਹਾਂ।

ਹਾਰਡ ਡਰਾਈਵ ਸੈਟਿੰਗਾਂ ਨੂੰ ਡਿਫੌਲਟ ਦੇ ਨਾਲ-ਨਾਲ ਟੈਗਸ ਦੇ ਤੌਰ 'ਤੇ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ (ਹਾਲਾਂਕਿ ਟੈਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚੰਗਾ ਅਭਿਆਸ ਹੈ, ਘੱਟੋ-ਘੱਟ ਉਦਾਹਰਣ ਨੂੰ ਇੱਕ ਨਾਮ ਦਿਓ ਅਤੇ ਵਾਤਾਵਰਣ ਨੂੰ ਦਰਸਾਓ)।

ਹੁਣ ਅਸੀਂ ਕਦਮ 6 'ਤੇ ਹਾਂ: ਸੁਰੱਖਿਆ ਸਮੂਹ ਟੈਬ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰੋ, ਜਿੱਥੇ ਤੁਹਾਨੂੰ ਇੱਕ ਨਵਾਂ ਬਣਾਉਣ ਜਾਂ ਆਪਣਾ ਮੌਜੂਦਾ ਸੁਰੱਖਿਆ ਸਮੂਹ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਜੋ ਤੁਹਾਨੂੰ ssh (ਪੋਰਟ 22) ਦੁਆਰਾ ਉਦਾਹਰਣ ਨਾਲ ਜੁੜਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਸਰੋਤ -> ਮੇਰਾ ਆਈਪੀ ਉੱਥੇ ਚੁਣੋ ਅਤੇ ਤੁਸੀਂ ਉਦਾਹਰਣ ਨੂੰ ਲਾਂਚ ਕਰ ਸਕਦੇ ਹੋ.

ਜਿਵੇਂ ਹੀ ਇਹ ਚੱਲ ਰਹੀ ਸਥਿਤੀ 'ਤੇ ਬਦਲਦਾ ਹੈ, ਤੁਸੀਂ ssh ਦੁਆਰਾ ਇਸ ਨਾਲ ਜੁੜਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹੋ।

ਕਾਇਨੇਸਿਸ ਏਜੰਟ ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣ ਲਈ, ਮਸ਼ੀਨ ਨਾਲ ਸਫਲਤਾਪੂਰਵਕ ਜੁੜਨ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਟਰਮੀਨਲ ਵਿੱਚ ਹੇਠ ਲਿਖੀਆਂ ਕਮਾਂਡਾਂ ਦਰਜ ਕਰਨੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ:

sudo yum -y update
sudo yum install -y python36 python36-pip
sudo /usr/bin/pip-3.6 install --upgrade pip
sudo yum install -y aws-kinesis-agent

ਚਲੋ API ਜਵਾਬਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ ਇੱਕ ਫੋਲਡਰ ਬਣਾਈਏ:

sudo mkdir /var/log/airline_tickets

ਏਜੰਟ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਇਸਦੀ ਸੰਰਚਨਾ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

sudo vim /etc/aws-kinesis/agent.json

agent.json ਫਾਈਲ ਦੀ ਸਮੱਗਰੀ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਣੀ ਚਾਹੀਦੀ ਹੈ:

{
  "cloudwatch.emitMetrics": true,
  "kinesis.endpoint": "",
  "firehose.endpoint": "",

  "flows": [
    {
      "filePattern": "/var/log/airline_tickets/*log",
      "kinesisStream": "airline_tickets",
      "partitionKeyOption": "RANDOM",
      "dataProcessingOptions": [
         {
            "optionName": "CSVTOJSON",
            "customFieldNames": ["cost","trip_class","show_to_affiliates",
                "return_date","origin","number_of_changes","gate","found_at",
                "duration","distance","destination","depart_date","actual","record_id"]
         }
      ]
    }
  ]
}

ਜਿਵੇਂ ਕਿ ਸੰਰਚਨਾ ਫਾਈਲ ਤੋਂ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਏਜੰਟ /var/log/airline_tickets/ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ .log ਐਕਸਟੈਂਸ਼ਨ ਨਾਲ ਫਾਈਲਾਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰੇਗਾ, ਉਹਨਾਂ ਨੂੰ ਪਾਰਸ ਕਰੇਗਾ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਏਅਰਲਾਈਨ_ਟਿਕੇਟ ਸਟ੍ਰੀਮ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰੇਗਾ।

ਅਸੀਂ ਸੇਵਾ ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰਦੇ ਹਾਂ ਅਤੇ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਾਂ ਕਿ ਇਹ ਚਾਲੂ ਹੈ ਅਤੇ ਚੱਲ ਰਹੀ ਹੈ:

sudo service aws-kinesis-agent restart

ਆਉ ਹੁਣ ਪਾਈਥਨ ਸਕ੍ਰਿਪਟ ਨੂੰ ਡਾਉਨਲੋਡ ਕਰੀਏ ਜੋ API ਤੋਂ ਡੇਟਾ ਦੀ ਬੇਨਤੀ ਕਰੇਗੀ:

REPO_PATH=https://raw.githubusercontent.com/igorgorbenko/aviasales_kinesis/master/producer

wget $REPO_PATH/api_caller.py -P /home/ec2-user/
wget $REPO_PATH/requirements.txt -P /home/ec2-user/
sudo chmod a+x /home/ec2-user/api_caller.py
sudo /usr/local/bin/pip3 install -r /home/ec2-user/requirements.txt

api_caller.py ਸਕ੍ਰਿਪਟ Aviasales ਤੋਂ ਡੇਟਾ ਦੀ ਬੇਨਤੀ ਕਰਦੀ ਹੈ ਅਤੇ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਵਾਬ ਨੂੰ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕਰਦੀ ਹੈ ਜਿਸਨੂੰ Kinesis ਏਜੰਟ ਸਕੈਨ ਕਰਦਾ ਹੈ। ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਕਾਫ਼ੀ ਮਿਆਰੀ ਹੈ, ਇੱਥੇ ਇੱਕ TicketsApi ਕਲਾਸ ਹੈ, ਇਹ ਤੁਹਾਨੂੰ API ਨੂੰ ਅਸਿੰਕਰੋਨਸ ਤੌਰ 'ਤੇ ਖਿੱਚਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਅਸੀਂ ਇੱਕ ਟੋਕਨ ਦੇ ਨਾਲ ਇੱਕ ਸਿਰਲੇਖ ਪਾਸ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇਸ ਕਲਾਸ ਨੂੰ ਪੈਰਾਮੀਟਰਾਂ ਦੀ ਬੇਨਤੀ ਕਰਦੇ ਹਾਂ:

class TicketsApi:
    """Api caller class."""

    def __init__(self, headers):
        """Init method."""
        self.base_url = BASE_URL
        self.headers = headers

    async def get_data(self, data):
        """Get the data from API query."""
        response_json = {}
        async with ClientSession(headers=self.headers) as session:
            try:
                response = await session.get(self.base_url, data=data)
                response.raise_for_status()
                LOGGER.info('Response status %s: %s',
                            self.base_url, response.status)
                response_json = await response.json()
            except HTTPError as http_err:
                LOGGER.error('Oops! HTTP error occurred: %s', str(http_err))
            except Exception as err:
                LOGGER.error('Oops! An error ocurred: %s', str(err))
            return response_json


def prepare_request(api_token):
    """Return the headers and query fot the API request."""
    headers = {'X-Access-Token': api_token,
               'Accept-Encoding': 'gzip'}

    data = FormData()
    data.add_field('currency', CURRENCY)
    data.add_field('origin', ORIGIN)
    data.add_field('destination', DESTINATION)
    data.add_field('show_to_affiliates', SHOW_TO_AFFILIATES)
    data.add_field('trip_duration', TRIP_DURATION)
    return headers, data


async def main():
    """Get run the code."""
    if len(sys.argv) != 2:
        print('Usage: api_caller.py <your_api_token>')
        sys.exit(1)
        return
    api_token = sys.argv[1]
    headers, data = prepare_request(api_token)

    api = TicketsApi(headers)
    response = await api.get_data(data)
    if response.get('success', None):
        LOGGER.info('API has returned %s items', len(response['data']))
        try:
            count_rows = log_maker(response)
            LOGGER.info('%s rows have been saved into %s',
                        count_rows,
                        TARGET_FILE)
        except Exception as e:
            LOGGER.error('Oops! Request result was not saved to file. %s',
                         str(e))
    else:
        LOGGER.error('Oops! API request was unsuccessful %s!', response)

ਏਜੰਟ ਦੀਆਂ ਸਹੀ ਸੈਟਿੰਗਾਂ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ, ਆਓ api_caller.py ਸਕ੍ਰਿਪਟ ਦੀ ਜਾਂਚ ਕਰੀਏ:

sudo ./api_caller.py TOKEN

ਅਤੇ ਅਸੀਂ ਏਜੰਟ ਲੌਗਸ ਅਤੇ ਏਅਰਲਾਈਨ_ਟਿਕਟਸ ਡੇਟਾ ਸਟ੍ਰੀਮ ਵਿੱਚ ਨਿਗਰਾਨੀ ਟੈਬ ਵਿੱਚ ਕੰਮ ਦੇ ਨਤੀਜੇ ਨੂੰ ਦੇਖਦੇ ਹਾਂ:

tail -f /var/log/aws-kinesis-agent/aws-kinesis-agent.log

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਸਭ ਕੁਝ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਕਾਇਨੇਸਿਸ ਏਜੰਟ ਸਫਲਤਾਪੂਰਵਕ ਸਟ੍ਰੀਮ ਨੂੰ ਡੇਟਾ ਭੇਜਦਾ ਹੈ. ਆਉ ਹੁਣ ਖਪਤਕਾਰ ਦੀ ਸੰਰਚਨਾ ਕਰੀਏ।

ਕਾਇਨੇਸਿਸ ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਸਥਾਪਤ ਕਰਨਾ

ਆਉ ਪੂਰੇ ਸਿਸਟਮ ਦੇ ਕੇਂਦਰੀ ਹਿੱਸੇ ਵੱਲ ਵਧੀਏ - Kinesis_analytics_airlines_app ਨਾਮਕ Kinesis ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਓ:

Kinesis ਡਾਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਤੁਹਾਨੂੰ SQL ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ Kinesis ਸਟ੍ਰੀਮ ਤੋਂ ਰੀਅਲ-ਟਾਈਮ ਡਾਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਇਹ ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਆਟੋਸਕੇਲਿੰਗ ਸੇਵਾ ਹੈ (ਕਿਨੇਸਿਸ ਸਟ੍ਰੀਮਜ਼ ਦੇ ਉਲਟ) ਜੋ:

1. ਤੁਹਾਨੂੰ ਸਰੋਤ ਡੇਟਾ ਲਈ ਬੇਨਤੀਆਂ ਦੇ ਅਧਾਰ ਤੇ ਨਵੀਆਂ ਸਟ੍ਰੀਮਾਂ (ਆਉਟਪੁੱਟ ਸਟ੍ਰੀਮ) ਬਣਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ;
2. ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਚੱਲਦੇ ਸਮੇਂ ਆਈਆਂ ਗਲਤੀਆਂ ਨਾਲ ਇੱਕ ਸਟ੍ਰੀਮ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ (ਗਲਤੀ ਸਟ੍ਰੀਮ);
3. ਇਨਪੁਟ ਡੇਟਾ ਸਕੀਮ ਨੂੰ ਆਟੋਮੈਟਿਕ ਹੀ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦਾ ਹੈ (ਜੇ ਲੋੜ ਹੋਵੇ ਤਾਂ ਇਸਨੂੰ ਹੱਥੀਂ ਮੁੜ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ)।

ਇਹ ਕੋਈ ਸਸਤੀ ਸੇਵਾ ਨਹੀਂ ਹੈ - 0.11 USD ਪ੍ਰਤੀ ਘੰਟਾ ਕੰਮ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਇਸਨੂੰ ਧਿਆਨ ਨਾਲ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਜਦੋਂ ਤੁਸੀਂ ਪੂਰਾ ਕਰ ਲੈਂਦੇ ਹੋ ਤਾਂ ਇਸਨੂੰ ਮਿਟਾਉਣਾ ਚਾਹੀਦਾ ਹੈ।

ਆਉ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਡੇਟਾ ਸਰੋਤ ਨਾਲ ਕਨੈਕਟ ਕਰੀਏ:

ਉਹ ਸਟ੍ਰੀਮ ਚੁਣੋ ਜਿਸ ਨਾਲ ਅਸੀਂ ਜੁੜਨ ਜਾ ਰਹੇ ਹਾਂ (airline_tickets):

ਅੱਗੇ, ਤੁਹਾਨੂੰ ਇੱਕ ਨਵੀਂ IAM ਰੋਲ ਨੱਥੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਜੋ ਐਪਲੀਕੇਸ਼ਨ ਸਟ੍ਰੀਮ ਤੋਂ ਪੜ੍ਹ ਸਕੇ ਅਤੇ ਸਟ੍ਰੀਮ ਵਿੱਚ ਲਿਖ ਸਕੇ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਪਹੁੰਚ ਅਨੁਮਤੀਆਂ ਬਲਾਕ ਵਿੱਚ ਕੁਝ ਵੀ ਨਾ ਬਦਲਣਾ ਕਾਫ਼ੀ ਹੈ:

ਹੁਣ ਸਟ੍ਰੀਮ ਵਿੱਚ ਡੇਟਾ ਸਕੀਮਾ ਦੀ ਖੋਜ ਲਈ ਬੇਨਤੀ ਕਰੀਏ; ਅਜਿਹਾ ਕਰਨ ਲਈ, "ਡਿਸਕਵਰ ਸਕੀਮਾ" ਬਟਨ 'ਤੇ ਕਲਿੱਕ ਕਰੋ। ਨਤੀਜੇ ਵਜੋਂ, IAM ਭੂਮਿਕਾ ਨੂੰ ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਵੇਗਾ (ਇੱਕ ਨਵਾਂ ਬਣਾਇਆ ਜਾਵੇਗਾ) ਅਤੇ ਸਕੀਮਾ ਖੋਜ ਨੂੰ ਉਸ ਡੇਟਾ ਤੋਂ ਲਾਂਚ ਕੀਤਾ ਜਾਵੇਗਾ ਜੋ ਪਹਿਲਾਂ ਹੀ ਸਟ੍ਰੀਮ ਵਿੱਚ ਆ ਚੁੱਕਾ ਹੈ:

ਹੁਣ ਤੁਹਾਨੂੰ SQL ਐਡੀਟਰ 'ਤੇ ਜਾਣ ਦੀ ਲੋੜ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ ਇਸ ਬਟਨ 'ਤੇ ਕਲਿੱਕ ਕਰਦੇ ਹੋ, ਤਾਂ ਇੱਕ ਵਿੰਡੋ ਦਿਖਾਈ ਦੇਵੇਗੀ ਜੋ ਤੁਹਾਨੂੰ ਐਪਲੀਕੇਸ਼ਨ ਲਾਂਚ ਕਰਨ ਲਈ ਕਹੇਗੀ - ਚੁਣੋ ਕਿ ਤੁਸੀਂ ਕੀ ਲਾਂਚ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ:

SQL ਸੰਪਾਦਕ ਵਿੰਡੋ ਵਿੱਚ ਹੇਠ ਦਿੱਤੀ ਸਧਾਰਨ ਪੁੱਛਗਿੱਛ ਪਾਓ ਅਤੇ ਸੁਰੱਖਿਅਤ ਕਰੋ ਅਤੇ SQL ਚਲਾਓ 'ਤੇ ਕਲਿੱਕ ਕਰੋ:

CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" ("cost" DOUBLE, "gate" VARCHAR(16));

CREATE OR REPLACE PUMP "STREAM_PUMP" AS INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM "cost", "gate"
FROM "SOURCE_SQL_STREAM_001"
WHERE "cost" < 5000
    and "gate" = 'Aeroflot';

ਰਿਲੇਸ਼ਨਲ ਡੇਟਾਬੇਸ ਵਿੱਚ, ਤੁਸੀਂ ਰਿਕਾਰਡਾਂ ਨੂੰ ਜੋੜਨ ਲਈ INSERT ਸਟੇਟਮੈਂਟਾਂ ਅਤੇ ਪੁੱਛਗਿੱਛ ਡੇਟਾ ਲਈ ਇੱਕ SELECT ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਟੇਬਲਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ। ਐਮਾਜ਼ਾਨ ਕਾਇਨੇਸਿਸ ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ, ਤੁਸੀਂ ਸਟ੍ਰੀਮਜ਼ (ਸਟ੍ਰੀਮ) ਅਤੇ ਪੰਪਾਂ (ਪੰਪਸ) ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ - ਲਗਾਤਾਰ ਸੰਮਿਲਿਤ ਕਰਨ ਦੀਆਂ ਬੇਨਤੀਆਂ ਜੋ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਇੱਕ ਸਟ੍ਰੀਮ ਤੋਂ ਡੇਟਾ ਨੂੰ ਦੂਜੀ ਸਟ੍ਰੀਮ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਦੀਆਂ ਹਨ।

ਉਪਰੋਕਤ ਪੇਸ਼ ਕੀਤੀ SQL ਪੁੱਛਗਿੱਛ ਪੰਜ ਹਜ਼ਾਰ ਰੂਬਲ ਤੋਂ ਘੱਟ ਕੀਮਤ 'ਤੇ ਐਰੋਫਲੋਟ ਟਿਕਟਾਂ ਦੀ ਖੋਜ ਕਰਦੀ ਹੈ। ਇਹਨਾਂ ਸ਼ਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਵਾਲੇ ਸਾਰੇ ਰਿਕਾਰਡਾਂ ਨੂੰ DESTINATION_SQL_STREAM ਸਟ੍ਰੀਮ ਵਿੱਚ ਰੱਖਿਆ ਜਾਵੇਗਾ।

ਮੰਜ਼ਿਲ ਬਲਾਕ ਵਿੱਚ, ਵਿਸ਼ੇਸ਼_ਸਟ੍ਰੀਮ ਸਟ੍ਰੀਮ ਦੀ ਚੋਣ ਕਰੋ, ਅਤੇ ਇਨ-ਐਪਲੀਕੇਸ਼ਨ ਸਟ੍ਰੀਮ ਨਾਮ DESTINATION_SQL_STREAM ਡ੍ਰੌਪ-ਡਾਉਨ ਸੂਚੀ ਵਿੱਚ:

ਸਾਰੀਆਂ ਹੇਰਾਫੇਰੀਆਂ ਦਾ ਨਤੀਜਾ ਹੇਠਾਂ ਦਿੱਤੀ ਤਸਵੀਰ ਦੇ ਸਮਾਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ:

ਇੱਕ SNS ਵਿਸ਼ੇ ਨੂੰ ਬਣਾਉਣਾ ਅਤੇ ਗਾਹਕੀ ਲੈਣਾ

ਸਧਾਰਨ ਸੂਚਨਾ ਸੇਵਾ 'ਤੇ ਜਾਓ ਅਤੇ ਉੱਥੇ ਏਅਰਲਾਈਨਜ਼ ਨਾਮ ਨਾਲ ਇੱਕ ਨਵਾਂ ਵਿਸ਼ਾ ਬਣਾਓ:

ਇਸ ਵਿਸ਼ੇ ਦੀ ਗਾਹਕੀ ਲਓ ਅਤੇ ਮੋਬਾਈਲ ਫ਼ੋਨ ਨੰਬਰ ਦੱਸੋ ਜਿਸ 'ਤੇ SMS ਸੂਚਨਾਵਾਂ ਭੇਜੀਆਂ ਜਾਣਗੀਆਂ:

DynamoDB ਵਿੱਚ ਇੱਕ ਸਾਰਣੀ ਬਣਾਓ

ਉਹਨਾਂ ਦੀ airline_tickets ਸਟ੍ਰੀਮ ਤੋਂ ਕੱਚੇ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ, ਚਲੋ ਉਸੇ ਨਾਮ ਨਾਲ DynamoDB ਵਿੱਚ ਇੱਕ ਸਾਰਣੀ ਬਣਾਈਏ। ਅਸੀਂ ਪ੍ਰਾਇਮਰੀ ਕੁੰਜੀ ਵਜੋਂ record_id ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ:

ਲਾਂਬਡਾ ਫੰਕਸ਼ਨ ਕੁਲੈਕਟਰ ਬਣਾਉਣਾ

ਚਲੋ ਕਲੈਕਟਰ ਨਾਮਕ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਬਣਾਉਂਦੇ ਹਾਂ, ਜਿਸਦਾ ਕੰਮ ਏਅਰਲਾਈਨ_ਟਿਕਟਸ ਸਟ੍ਰੀਮ ਨੂੰ ਪੋਲ ਕਰਨਾ ਹੋਵੇਗਾ ਅਤੇ, ਜੇਕਰ ਉੱਥੇ ਨਵੇਂ ਰਿਕਾਰਡ ਮਿਲੇ ਹਨ, ਤਾਂ ਇਹਨਾਂ ਰਿਕਾਰਡਾਂ ਨੂੰ ਡਾਇਨਾਮੋਡੀਬੀ ਟੇਬਲ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ। ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ, ਡਿਫੌਲਟ ਅਧਿਕਾਰਾਂ ਤੋਂ ਇਲਾਵਾ, ਇਸ ਲਾਂਬਡਾ ਕੋਲ ਕਾਇਨੇਸਿਸ ਡੇਟਾ ਸਟ੍ਰੀਮ ਤੱਕ ਪੜ੍ਹਨ ਦੀ ਪਹੁੰਚ ਅਤੇ ਡਾਇਨਾਮੋਡੀਬੀ ਤੱਕ ਲਿਖਣ ਦੀ ਪਹੁੰਚ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।

ਕੁਲੈਕਟਰ ਲਾਂਬਡਾ ਫੰਕਸ਼ਨ ਲਈ ਇੱਕ IAM ਰੋਲ ਬਣਾਉਣਾ
ਪਹਿਲਾਂ, ਆਓ ਲੈਂਬਡਾ ਲਈ ਇੱਕ ਨਵੀਂ IAM ਭੂਮਿਕਾ ਬਣਾਈਏ ਜਿਸਦਾ ਨਾਮ Lambda-TicketsProcessingRole ਹੈ:

ਟੈਸਟ ਉਦਾਹਰਨ ਲਈ, ਪਹਿਲਾਂ ਤੋਂ ਸੰਰਚਿਤ AmazonKinesisReadOnlyAccess ਅਤੇ AmazonDynamoDBFullAccess ਨੀਤੀਆਂ ਕਾਫ਼ੀ ਢੁਕਵੀਆਂ ਹਨ, ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਤਸਵੀਰ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ:

ਜਦੋਂ ਨਵੀਆਂ ਐਂਟਰੀਆਂ ਏਅਰਲਾਈਨ_ਸਟ੍ਰੀਮ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦੀਆਂ ਹਨ ਤਾਂ ਇਸ ਲਾਂਬਡਾ ਨੂੰ ਕਿਨੇਸਿਸ ਤੋਂ ਇੱਕ ਟਰਿੱਗਰ ਦੁਆਰਾ ਲਾਂਚ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਇਸ ਲਈ ਸਾਨੂੰ ਇੱਕ ਨਵਾਂ ਟਰਿੱਗਰ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ:

ਜੋ ਕੁਝ ਰਹਿੰਦਾ ਹੈ ਉਹ ਕੋਡ ਨੂੰ ਸੰਮਿਲਿਤ ਕਰਨਾ ਅਤੇ ਲਾਂਬਡਾ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨਾ ਹੈ.

"""Parsing the stream and inserting into the DynamoDB table."""
import base64
import json
import boto3
from decimal import Decimal

DYNAMO_DB = boto3.resource('dynamodb')
TABLE_NAME = 'airline_tickets'

class TicketsParser:
    """Parsing info from the Stream."""

    def __init__(self, table_name, records):
        """Init method."""
        self.table = DYNAMO_DB.Table(table_name)
        self.json_data = TicketsParser.get_json_data(records)

    @staticmethod
    def get_json_data(records):
        """Return deserialized data from the stream."""
        decoded_record_data = ([base64.b64decode(record['kinesis']['data'])
                                for record in records])
        json_data = ([json.loads(decoded_record)
                      for decoded_record in decoded_record_data])
        return json_data

    @staticmethod
    def get_item_from_json(json_item):
        """Pre-process the json data."""
        new_item = {
            'record_id': json_item.get('record_id'),
            'cost': Decimal(json_item.get('cost')),
            'trip_class': json_item.get('trip_class'),
            'show_to_affiliates': json_item.get('show_to_affiliates'),
            'origin': json_item.get('origin'),
            'number_of_changes': int(json_item.get('number_of_changes')),
            'gate': json_item.get('gate'),
            'found_at': json_item.get('found_at'),
            'duration': int(json_item.get('duration')),
            'distance': int(json_item.get('distance')),
            'destination': json_item.get('destination'),
            'depart_date': json_item.get('depart_date'),
            'actual': json_item.get('actual')
        }
        return new_item

    def run(self):
        """Batch insert into the table."""
        with self.table.batch_writer() as batch_writer:
            for item in self.json_data:
                dynamodb_item = TicketsParser.get_item_from_json(item)
                batch_writer.put_item(dynamodb_item)

        print('Has been added ', len(self.json_data), 'items')

def lambda_handler(event, context):
    """Parse the stream and insert into the DynamoDB table."""
    print('Got event:', event)
    parser = TicketsParser(TABLE_NAME, event['Records'])
    parser.run()

ਇੱਕ lambda ਫੰਕਸ਼ਨ ਨੋਟੀਫਾਇਰ ਬਣਾਉਣਾ

ਦੂਜਾ ਲਾਂਬਡਾ ਫੰਕਸ਼ਨ, ਜੋ ਦੂਜੀ ਸਟ੍ਰੀਮ (ਵਿਸ਼ੇਸ਼_ਸਟ੍ਰੀਮ) ਦੀ ਨਿਗਰਾਨੀ ਕਰੇਗਾ ਅਤੇ SNS ਨੂੰ ਇੱਕ ਨੋਟੀਫਿਕੇਸ਼ਨ ਭੇਜੇਗਾ, ਇਸੇ ਤਰ੍ਹਾਂ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਇਸ ਲਈ, ਇਸ ਲਾਂਬਡਾ ਕੋਲ ਕਾਇਨੇਸਿਸ ਤੋਂ ਪੜ੍ਹਨ ਅਤੇ ਦਿੱਤੇ ਗਏ SNS ਵਿਸ਼ੇ 'ਤੇ ਸੰਦੇਸ਼ ਭੇਜਣ ਲਈ ਪਹੁੰਚ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਜੋ ਫਿਰ SNS ਸੇਵਾ ਦੁਆਰਾ ਇਸ ਵਿਸ਼ੇ ਦੇ ਸਾਰੇ ਗਾਹਕਾਂ (ਈਮੇਲ, SMS, ਆਦਿ) ਨੂੰ ਭੇਜੇ ਜਾਣਗੇ।

ਇੱਕ IAM ਰੋਲ ਬਣਾਉਣਾ
ਪਹਿਲਾਂ, ਅਸੀਂ ਇਸ ਲਾਂਬਡਾ ਲਈ IAM ਰੋਲ Lambda-KinesisAlarm ਬਣਾਉਂਦੇ ਹਾਂ, ਅਤੇ ਫਿਰ ਇਸ ਰੋਲ ਨੂੰ ਬਣਾਏ ਜਾ ਰਹੇ ਅਲਾਰਮ_ਨੋਟੀਫਾਇਰ ਲਾਂਬਡਾ ਨੂੰ ਸੌਂਪਦੇ ਹਾਂ:

ਇਸ ਲਾਂਬਡਾ ਨੂੰ ਵਿਸ਼ੇਸ਼_ਸਟ੍ਰੀਮ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਲਈ ਨਵੇਂ ਰਿਕਾਰਡਾਂ ਲਈ ਇੱਕ ਟ੍ਰਿਗਰ 'ਤੇ ਕੰਮ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਇਸਲਈ ਤੁਹਾਨੂੰ ਟ੍ਰਿਗਰ ਨੂੰ ਉਸੇ ਤਰ੍ਹਾਂ ਸੰਰਚਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਜਿਵੇਂ ਅਸੀਂ ਕੁਲੈਕਟਰ ਲਾਂਬਡਾ ਲਈ ਕੀਤਾ ਸੀ।

ਇਸ ਲਾਂਬਡਾ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਣ ਲਈ, ਆਓ ਇੱਕ ਨਵਾਂ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਪੇਸ਼ ਕਰੀਏ - TOPIC_ARN, ਜਿੱਥੇ ਅਸੀਂ ਏਅਰਲਾਈਨਜ਼ ਵਿਸ਼ੇ ਦਾ ANR (ਐਮਾਜ਼ਾਨ ਰਿਕੋਰਸ ਨਾਮ) ਰੱਖਦੇ ਹਾਂ:

ਅਤੇ ਲਾਂਬਡਾ ਕੋਡ ਪਾਓ, ਇਹ ਬਿਲਕੁਲ ਵੀ ਗੁੰਝਲਦਾਰ ਨਹੀਂ ਹੈ:

import boto3
import base64
import os

SNS_CLIENT = boto3.client('sns')
TOPIC_ARN = os.environ['TOPIC_ARN']


def lambda_handler(event, context):
    try:
        SNS_CLIENT.publish(TopicArn=TOPIC_ARN,
                           Message='Hi! I have found an interesting stuff!',
                           Subject='Airline tickets alarm')
        print('Alarm message has been successfully delivered')
    except Exception as err:
        print('Delivery failure', str(err))

ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਮੈਨੂਅਲ ਸਿਸਟਮ ਸੰਰਚਨਾ ਪੂਰੀ ਹੋਈ ਹੈ। ਜੋ ਕੁਝ ਬਚਿਆ ਹੈ ਉਹ ਟੈਸਟ ਕਰਨਾ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਹੈ ਕਿ ਅਸੀਂ ਸਭ ਕੁਝ ਸਹੀ ਢੰਗ ਨਾਲ ਕੌਂਫਿਗਰ ਕੀਤਾ ਹੈ।

ਟੈਰਾਫਾਰਮ ਕੋਡ ਤੋਂ ਤੈਨਾਤ ਕਰੋ

ਜ਼ਰੂਰੀ ਤਿਆਰੀ

ਟੈਰਾਫਾਰਮ ਕੋਡ ਤੋਂ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਨੂੰ ਤੈਨਾਤ ਕਰਨ ਲਈ ਇੱਕ ਬਹੁਤ ਹੀ ਸੁਵਿਧਾਜਨਕ ਓਪਨ-ਸੋਰਸ ਟੂਲ ਹੈ। ਇਸਦਾ ਆਪਣਾ ਸੰਟੈਕਸ ਹੈ ਜੋ ਸਿੱਖਣਾ ਆਸਾਨ ਹੈ ਅਤੇ ਇਸ ਦੀਆਂ ਕਈ ਉਦਾਹਰਣਾਂ ਹਨ ਕਿ ਕਿਵੇਂ ਅਤੇ ਕੀ ਤੈਨਾਤ ਕਰਨਾ ਹੈ। ਐਟਮ ਸੰਪਾਦਕ ਜਾਂ ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ ਕੋਡ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਆਸਾਨ ਪਲੱਗਇਨ ਹਨ ਜੋ ਟੈਰਾਫਾਰਮ ਨਾਲ ਕੰਮ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਂਦੇ ਹਨ।

ਤੁਸੀਂ ਵੰਡ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰ ਸਕਦੇ ਹੋ ਇੱਥੋਂ. ਸਾਰੀਆਂ ਟੈਰਾਫਾਰਮ ਸਮਰੱਥਾਵਾਂ ਦਾ ਵਿਸਤ੍ਰਿਤ ਵਿਸ਼ਲੇਸ਼ਣ ਇਸ ਲੇਖ ਦੇ ਦਾਇਰੇ ਤੋਂ ਬਾਹਰ ਹੈ, ਇਸ ਲਈ ਅਸੀਂ ਆਪਣੇ ਆਪ ਨੂੰ ਮੁੱਖ ਬਿੰਦੂਆਂ ਤੱਕ ਸੀਮਤ ਕਰਾਂਗੇ।

ਕਿਸ ਨੂੰ ਚਲਾਉਣ ਲਈ

ਪ੍ਰੋਜੈਕਟ ਦਾ ਪੂਰਾ ਕੋਡ ਹੈ ਮੇਰੇ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ. ਅਸੀਂ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਆਪਣੇ ਲਈ ਕਲੋਨ ਕਰਦੇ ਹਾਂ। ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ ਕਿ ਤੁਹਾਡੇ ਕੋਲ AWS CLI ਸਥਾਪਤ ਅਤੇ ਸੰਰਚਿਤ ਹੈ, ਕਿਉਂਕਿ... Terraform ~/.aws/credentials ਫਾਈਲ ਵਿੱਚ ਕ੍ਰੇਡੇੰਸ਼ਿਅਲਸ ਦੀ ਖੋਜ ਕਰੇਗਾ।

ਇਹ ਦੇਖਣ ਲਈ ਕਿ ਟੈਰਾਫਾਰਮ ਇਸ ਸਮੇਂ ਕਲਾਉਡ ਵਿੱਚ ਸਾਡੇ ਲਈ ਕੀ ਬਣਾ ਰਿਹਾ ਹੈ, ਪੂਰੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਨੂੰ ਤੈਨਾਤ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਯੋਜਨਾ ਕਮਾਂਡ ਨੂੰ ਚਲਾਉਣਾ ਇੱਕ ਵਧੀਆ ਅਭਿਆਸ ਹੈ:

terraform.exe plan

ਤੁਹਾਨੂੰ ਸੂਚਨਾਵਾਂ ਭੇਜਣ ਲਈ ਇੱਕ ਫ਼ੋਨ ਨੰਬਰ ਦਰਜ ਕਰਨ ਲਈ ਕਿਹਾ ਜਾਵੇਗਾ। ਇਸ ਪੜਾਅ 'ਤੇ ਇਸ ਨੂੰ ਦਾਖਲ ਕਰਨਾ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹੈ.

ਪ੍ਰੋਗਰਾਮ ਦੀ ਸੰਚਾਲਨ ਯੋਜਨਾ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਸਰੋਤ ਬਣਾਉਣਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹਾਂ:

terraform.exe apply

ਇਸ ਕਮਾਂਡ ਨੂੰ ਭੇਜਣ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਦੁਬਾਰਾ ਇੱਕ ਫ਼ੋਨ ਨੰਬਰ ਦਰਜ ਕਰਨ ਲਈ ਕਿਹਾ ਜਾਵੇਗਾ; ਜਦੋਂ ਅਸਲ ਵਿੱਚ ਕਾਰਵਾਈਆਂ ਕਰਨ ਬਾਰੇ ਕੋਈ ਸਵਾਲ ਪ੍ਰਦਰਸ਼ਿਤ ਹੁੰਦਾ ਹੈ ਤਾਂ "ਹਾਂ" ਡਾਇਲ ਕਰੋ। ਇਹ ਤੁਹਾਨੂੰ ਪੂਰਾ ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਸਥਾਪਤ ਕਰਨ, EC2 ਦੀਆਂ ਸਾਰੀਆਂ ਲੋੜੀਂਦੀਆਂ ਸੰਰਚਨਾਵਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ, ਆਦਿ ਦੀ ਆਗਿਆ ਦੇਵੇਗਾ।

ਟੈਰਾਫਾਰਮ ਕੋਡ ਦੁਆਰਾ ਸਾਰੇ ਸਰੋਤਾਂ ਨੂੰ ਸਫਲਤਾਪੂਰਵਕ ਬਣਾਏ ਜਾਣ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਕਾਇਨੇਸਿਸ ਐਨਾਲਿਟਿਕਸ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਵੇਰਵਿਆਂ ਵਿੱਚ ਜਾਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ (ਬਦਕਿਸਮਤੀ ਨਾਲ, ਮੈਨੂੰ ਇਹ ਨਹੀਂ ਪਤਾ ਲੱਗਾ ਕਿ ਇਹ ਕੋਡ ਤੋਂ ਸਿੱਧਾ ਕਿਵੇਂ ਕਰਨਾ ਹੈ)।

ਐਪਲੀਕੇਸ਼ਨ ਲਾਂਚ ਕਰੋ:

ਇਸ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਡ੍ਰੌਪ-ਡਾਉਨ ਸੂਚੀ ਵਿੱਚੋਂ ਚੁਣ ਕੇ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਇਨ-ਐਪਲੀਕੇਸ਼ਨ ਸਟ੍ਰੀਮ ਨਾਮ ਸੈੱਟ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ:

ਹੁਣ ਸਭ ਕੁਝ ਜਾਣ ਲਈ ਤਿਆਰ ਹੈ.

ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰ ਰਿਹਾ ਹੈ

ਚਾਹੇ ਤੁਸੀਂ ਸਿਸਟਮ ਨੂੰ ਹੱਥੀਂ ਜਾਂ ਟੈਰਾਫਾਰਮ ਕੋਡ ਰਾਹੀਂ ਤੈਨਾਤ ਕੀਤਾ ਹੋਵੇ, ਇਹ ਉਹੀ ਕੰਮ ਕਰੇਗਾ।

ਅਸੀਂ SSH ਰਾਹੀਂ EC2 ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਵਿੱਚ ਲੌਗਇਨ ਕਰਦੇ ਹਾਂ ਜਿੱਥੇ ਕਿਨੇਸਿਸ ਏਜੰਟ ਸਥਾਪਤ ਹੈ ਅਤੇ api_caller.py ਸਕ੍ਰਿਪਟ ਚਲਾਉਂਦਾ ਹੈ

sudo ./api_caller.py TOKEN

ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਆਪਣੇ ਨੰਬਰ 'ਤੇ ਇੱਕ SMS ਦੀ ਉਡੀਕ ਕਰਨੀ ਪਵੇਗੀ:

SMS - ਲਗਭਗ 1 ਮਿੰਟ ਵਿੱਚ ਤੁਹਾਡੇ ਫ਼ੋਨ 'ਤੇ ਇੱਕ ਸੁਨੇਹਾ ਆਉਂਦਾ ਹੈ:

ਇਹ ਦੇਖਣਾ ਬਾਕੀ ਹੈ ਕਿ ਕੀ ਰਿਕਾਰਡਾਂ ਨੂੰ ਬਾਅਦ ਦੇ, ਵਧੇਰੇ ਵਿਸਤ੍ਰਿਤ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਡਾਇਨਾਮੋਡੀਬੀ ਡੇਟਾਬੇਸ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਗਿਆ ਸੀ। ਏਅਰਲਾਈਨ_ਟਿਕਟ ਸਾਰਣੀ ਵਿੱਚ ਲਗਭਗ ਹੇਠਾਂ ਦਿੱਤੇ ਡੇਟਾ ਸ਼ਾਮਲ ਹਨ:

ਸਿੱਟਾ

ਕੀਤੇ ਗਏ ਕੰਮ ਦੇ ਦੌਰਾਨ, Amazon Kinesis 'ਤੇ ਆਧਾਰਿਤ ਇੱਕ ਔਨਲਾਈਨ ਡਾਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਸਿਸਟਮ ਬਣਾਇਆ ਗਿਆ ਸੀ। ਕਾਇਨੇਸਿਸ ਡੇਟਾ ਸਟ੍ਰੀਮਜ਼ ਅਤੇ SQL ਕਮਾਂਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਅਸਲ-ਸਮੇਂ ਦੇ ਵਿਸ਼ਲੇਸ਼ਣ ਕਾਇਨੇਸਿਸ ਵਿਸ਼ਲੇਸ਼ਣ ਦੇ ਨਾਲ ਨਾਲ ਕਿਨੇਸਿਸ ਏਜੰਟ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਵਿਕਲਪਾਂ ਦੇ ਨਾਲ-ਨਾਲ ਹੋਰ AWS ਸੇਵਾਵਾਂ ਦੇ ਨਾਲ ਐਮਾਜ਼ਾਨ ਕਾਇਨੇਸਿਸ ਦੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਵਿਚਾਰਿਆ ਗਿਆ ਸੀ।

ਅਸੀਂ ਉਪਰੋਕਤ ਸਿਸਟਮ ਨੂੰ ਦੋ ਤਰੀਕਿਆਂ ਨਾਲ ਤੈਨਾਤ ਕੀਤਾ ਹੈ: ਇੱਕ ਲੰਮਾ ਮੈਨੂਅਲ ਅਤੇ ਟੈਰਾਫਾਰਮ ਕੋਡ ਤੋਂ ਇੱਕ ਤੇਜ਼।

ਸਾਰਾ ਪ੍ਰੋਜੈਕਟ ਸਰੋਤ ਕੋਡ ਉਪਲਬਧ ਹੈ ਮੇਰੇ GitHub ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ, ਮੈਂ ਤੁਹਾਨੂੰ ਇਸ ਨਾਲ ਆਪਣੇ ਆਪ ਨੂੰ ਜਾਣੂ ਕਰਵਾਉਣ ਦਾ ਸੁਝਾਅ ਦਿੰਦਾ ਹਾਂ।

ਮੈਂ ਲੇਖ 'ਤੇ ਚਰਚਾ ਕਰਕੇ ਖੁਸ਼ ਹਾਂ, ਮੈਂ ਤੁਹਾਡੀਆਂ ਟਿੱਪਣੀਆਂ ਦੀ ਉਮੀਦ ਕਰਦਾ ਹਾਂ. ਮੈਂ ਉਸਾਰੂ ਆਲੋਚਨਾ ਦੀ ਉਮੀਦ ਕਰਦਾ ਹਾਂ।

ਮੈਂ ਤੁਹਾਨੂੰ ਸਫਲਤਾ ਦੀ ਕਾਮਨਾ ਕਰਦਾ ਹਾਂ!

ਸਰੋਤ: www.habr.com