ಅಮೆಜಾನ್ ಕೈನೆಸಿಸ್ ಮತ್ತು ಸರ್ವರ್‌ಲೆಸ್ ಸರಳತೆಯೊಂದಿಗೆ Aviasales API ಏಕೀಕರಣ

ಹಲೋ, ಹಬ್ರ್!

ನೀವು ಹಾರುವ ವಿಮಾನಗಳನ್ನು ಇಷ್ಟಪಡುತ್ತೀರಾ? ನಾನು ಅದನ್ನು ಪ್ರೀತಿಸುತ್ತೇನೆ, ಆದರೆ ಸ್ವಯಂ-ಪ್ರತ್ಯೇಕತೆಯ ಸಮಯದಲ್ಲಿ ನಾನು ಒಂದು ಪ್ರಸಿದ್ಧ ಸಂಪನ್ಮೂಲದಿಂದ ಏರ್ ಟಿಕೆಟ್‌ಗಳ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸಲು ಸಹ ಪ್ರೀತಿಸುತ್ತಿದ್ದೆ - Aviasales.

ಇಂದು ನಾವು Amazon Kinesis ನ ಕೆಲಸವನ್ನು ವಿಶ್ಲೇಷಿಸುತ್ತೇವೆ, ನೈಜ-ಸಮಯದ ವಿಶ್ಲೇಷಣೆಯೊಂದಿಗೆ ಸ್ಟ್ರೀಮಿಂಗ್ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸುತ್ತೇವೆ, Amazon DynamoDB NoSQL ಡೇಟಾಬೇಸ್ ಅನ್ನು ಮುಖ್ಯ ಡೇಟಾ ಸಂಗ್ರಹಣೆಯಾಗಿ ಸ್ಥಾಪಿಸುತ್ತೇವೆ ಮತ್ತು ಆಸಕ್ತಿದಾಯಕ ಟಿಕೆಟ್‌ಗಳಿಗಾಗಿ SMS ಅಧಿಸೂಚನೆಗಳನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ.

ಎಲ್ಲಾ ವಿವರಗಳು ಕಟ್ ಅಡಿಯಲ್ಲಿವೆ! ಹೋಗು!

ಪರಿಚಯ

ಉದಾಹರಣೆಗೆ, ನಮಗೆ ಪ್ರವೇಶದ ಅಗತ್ಯವಿದೆ Aviasales API. ಇದಕ್ಕೆ ಪ್ರವೇಶವನ್ನು ಉಚಿತವಾಗಿ ಮತ್ತು ನಿರ್ಬಂಧಗಳಿಲ್ಲದೆ ಒದಗಿಸಲಾಗಿದೆ; ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಲು ನಿಮ್ಮ API ಟೋಕನ್ ಅನ್ನು ಸ್ವೀಕರಿಸಲು ನೀವು "ಡೆವಲಪರ್‌ಗಳು" ವಿಭಾಗದಲ್ಲಿ ನೋಂದಾಯಿಸಿಕೊಳ್ಳಬೇಕು.

AWS ನಲ್ಲಿ ಮಾಹಿತಿ ಸ್ಟ್ರೀಮಿಂಗ್ ಬಳಕೆಯ ಬಗ್ಗೆ ಸಾಮಾನ್ಯ ತಿಳುವಳಿಕೆಯನ್ನು ನೀಡುವುದು ಈ ಲೇಖನದ ಮುಖ್ಯ ಉದ್ದೇಶವಾಗಿದೆ; ಬಳಸಿದ API ನಿಂದ ಹಿಂತಿರುಗಿಸಲಾದ ಡೇಟಾವು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ನವೀಕೃತವಾಗಿಲ್ಲ ಮತ್ತು ಸಂಗ್ರಹದಿಂದ ರವಾನೆಯಾಗುತ್ತದೆ ಎಂದು ನಾವು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ. ಕಳೆದ 48 ಗಂಟೆಗಳ ಕಾಲ Aviasales.ru ಮತ್ತು Jetradar.com ಸೈಟ್‌ಗಳ ಬಳಕೆದಾರರ ಹುಡುಕಾಟಗಳ ಆಧಾರದ ಮೇಲೆ ರಚಿಸಲಾಗಿದೆ.

ಕೈನೆಸಿಸ್-ಏಜೆಂಟ್, ಉತ್ಪಾದಿಸುವ ಯಂತ್ರದಲ್ಲಿ ಸ್ಥಾಪಿಸಲಾಗಿದೆ, API ಮೂಲಕ ಸ್ವೀಕರಿಸಲಾಗಿದೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪಾರ್ಸ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಕೈನೆಸಿಸ್ ಡೇಟಾ ಅನಾಲಿಟಿಕ್ಸ್ ಮೂಲಕ ಬಯಸಿದ ಸ್ಟ್ರೀಮ್‌ಗೆ ಡೇಟಾವನ್ನು ರವಾನಿಸುತ್ತದೆ. ಈ ಸ್ಟ್ರೀಮ್‌ನ ಕಚ್ಚಾ ಆವೃತ್ತಿಯನ್ನು ನೇರವಾಗಿ ಸ್ಟೋರ್‌ಗೆ ಬರೆಯಲಾಗುತ್ತದೆ. DynamoDB ನಲ್ಲಿ ನಿಯೋಜಿಸಲಾದ ಕಚ್ಚಾ ಡೇಟಾ ಸಂಗ್ರಹಣೆಯು AWS ಕ್ವಿಕ್ ಸೈಟ್‌ನಂತಹ BI ಪರಿಕರಗಳ ಮೂಲಕ ಆಳವಾದ ಟಿಕೆಟ್ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಅನುಮತಿಸುತ್ತದೆ.

ಸಂಪೂರ್ಣ ಮೂಲಸೌಕರ್ಯವನ್ನು ನಿಯೋಜಿಸಲು ನಾವು ಎರಡು ಆಯ್ಕೆಗಳನ್ನು ಪರಿಗಣಿಸುತ್ತೇವೆ:

• ಕೈಪಿಡಿ - AWS ಮ್ಯಾನೇಜ್ಮೆಂಟ್ ಕನ್ಸೋಲ್ ಮೂಲಕ;
• ಟೆರಾಫಾರ್ಮ್ ಕೋಡ್‌ನಿಂದ ಮೂಲಸೌಕರ್ಯವು ಸೋಮಾರಿಯಾದ ಆಟೋಮೇಟರ್‌ಗಳಿಗೆ ಆಗಿದೆ;

ಅಭಿವೃದ್ಧಿ ಹೊಂದಿದ ವ್ಯವಸ್ಥೆಯ ಆರ್ಕಿಟೆಕ್ಚರ್

ಬಳಸಿದ ಘಟಕಗಳು:

• Aviasales API - ಈ API ಮೂಲಕ ಹಿಂತಿರುಗಿಸಿದ ಡೇಟಾವನ್ನು ಎಲ್ಲಾ ನಂತರದ ಕೆಲಸಗಳಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ;
• EC2 ನಿರ್ಮಾಪಕ ನಿದರ್ಶನ — ಇನ್‌ಪುಟ್ ಡೇಟಾ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ರಚಿಸುವ ಕ್ಲೌಡ್‌ನಲ್ಲಿ ಸಾಮಾನ್ಯ ವರ್ಚುವಲ್ ಯಂತ್ರ:
  • ಕಿನೆಸಿಸ್ ಏಜೆಂಟ್ ಗಣಕದಲ್ಲಿ ಸ್ಥಳೀಯವಾಗಿ ಸ್ಥಾಪಿಸಲಾದ ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್ ಇದು ಕಿನೆಸಿಸ್ (ಕಿನೆಸಿಸ್ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳು ಅಥವಾ ಕಿನೆಸಿಸ್ ಫೈರ್‌ಹೋಸ್) ಗೆ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಕಳುಹಿಸಲು ಸುಲಭವಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಏಜೆಂಟ್ ನಿರಂತರವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೈರೆಕ್ಟರಿಗಳಲ್ಲಿ ಫೈಲ್ಗಳ ಸೆಟ್ ಅನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಹೊಸ ಡೇಟಾವನ್ನು ಕಿನೆಸಿಸ್ಗೆ ಕಳುಹಿಸುತ್ತದೆ;
  • API ಕಾಲರ್ ಸ್ಕ್ರಿಪ್ಟ್ - API ಗೆ ವಿನಂತಿಗಳನ್ನು ಮಾಡುವ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಕೈನೆಸಿಸ್ ಏಜೆಂಟ್ ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವ ಫೋಲ್ಡರ್‌ಗೆ ಹಾಕುತ್ತದೆ;
• ಕಿನೆಸಿಸ್ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳು - ವ್ಯಾಪಕ ಸ್ಕೇಲಿಂಗ್ ಸಾಮರ್ಥ್ಯಗಳೊಂದಿಗೆ ನೈಜ-ಸಮಯದ ಡೇಟಾ ಸ್ಟ್ರೀಮಿಂಗ್ ಸೇವೆ;
• ಕೈನೆಸಿಸ್ ಅನಾಲಿಟಿಕ್ಸ್ ನೈಜ ಸಮಯದಲ್ಲಿ ಸ್ಟ್ರೀಮಿಂಗ್ ಡೇಟಾದ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಸರಳಗೊಳಿಸುವ ಸರ್ವರ್‌ಲೆಸ್ ಸೇವೆಯಾಗಿದೆ. Amazon Kinesis ಡೇಟಾ ಅನಾಲಿಟಿಕ್ಸ್ ಅಪ್ಲಿಕೇಶನ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಒಳಬರುವ ಡೇಟಾದ ಯಾವುದೇ ಪರಿಮಾಣವನ್ನು ನಿರ್ವಹಿಸಲು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮಾಪಕಗಳನ್ನು ಮಾಡುತ್ತದೆ;
• ಎಡಬ್ಲ್ಯೂಎಸ್ ಲ್ಯಾಂಬ್ಡಾ — ಬ್ಯಾಕ್‌ಅಪ್ ಅಥವಾ ಸರ್ವರ್‌ಗಳನ್ನು ಹೊಂದಿಸದೆಯೇ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಸೇವೆ. ಪ್ರತಿ ಕರೆಗೆ ಎಲ್ಲಾ ಕಂಪ್ಯೂಟಿಂಗ್ ಶಕ್ತಿಯನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮಾಪನ ಮಾಡಲಾಗುತ್ತದೆ;
• ಅಮೆಜಾನ್ ಡೈನಮೋಡಿಬಿ - ಯಾವುದೇ ಸ್ಕೇಲ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ 10 ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳಿಗಿಂತ ಕಡಿಮೆ ಸುಪ್ತತೆಯನ್ನು ಒದಗಿಸುವ ಪ್ರಮುಖ ಮೌಲ್ಯದ ಜೋಡಿಗಳು ಮತ್ತು ದಾಖಲೆಗಳ ಡೇಟಾಬೇಸ್. DynamoDB ಅನ್ನು ಬಳಸುವಾಗ, ಯಾವುದೇ ಸರ್ವರ್‌ಗಳನ್ನು ಒದಗಿಸುವ, ಪ್ಯಾಚ್ ಮಾಡುವ ಅಥವಾ ನಿರ್ವಹಿಸುವ ಅಗತ್ಯವಿಲ್ಲ. ಲಭ್ಯವಿರುವ ಸಂಪನ್ಮೂಲಗಳ ಪ್ರಮಾಣವನ್ನು ಸರಿಹೊಂದಿಸಲು ಮತ್ತು ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನಿರ್ವಹಿಸಲು DynamoDB ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕೋಷ್ಟಕಗಳನ್ನು ಅಳೆಯುತ್ತದೆ. ಸಿಸ್ಟಮ್ ಆಡಳಿತದ ಅಗತ್ಯವಿಲ್ಲ;
• ಅಮೆಜಾನ್ SNS - ಪ್ರಕಾಶಕ-ಚಂದಾದಾರರ (ಪಬ್/ಸಬ್) ಮಾದರಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸಲು ಸಂಪೂರ್ಣವಾಗಿ ನಿರ್ವಹಿಸಲಾದ ಸೇವೆ, ಇದರೊಂದಿಗೆ ನೀವು ಸೂಕ್ಷ್ಮ ಸೇವೆಗಳು, ವಿತರಣೆ ವ್ಯವಸ್ಥೆಗಳು ಮತ್ತು ಸರ್ವರ್‌ಲೆಸ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಬಹುದು. ಮೊಬೈಲ್ ಪುಶ್ ಅಧಿಸೂಚನೆಗಳು, SMS ಸಂದೇಶಗಳು ಮತ್ತು ಇಮೇಲ್‌ಗಳ ಮೂಲಕ ಅಂತಿಮ ಬಳಕೆದಾರರಿಗೆ ಮಾಹಿತಿಯನ್ನು ಕಳುಹಿಸಲು SNS ಅನ್ನು ಬಳಸಬಹುದು.

ಆರಂಭಿಕ ತರಬೇತಿ

ಡೇಟಾ ಹರಿವನ್ನು ಅನುಕರಿಸಲು, ನಾನು 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 ಖಾತೆಯನ್ನು ಹೊಂದಿರುವಿರಿ ಎಂದು ಇದು ಊಹಿಸುತ್ತದೆ. ಕಿನೆಸಿಸ್ ಮತ್ತು SMS ಮೂಲಕ ಅಧಿಸೂಚನೆಗಳನ್ನು ಕಳುಹಿಸುವುದನ್ನು ವಾರ್ಷಿಕವಾಗಿ ಸೇರಿಸಲಾಗಿಲ್ಲ ಎಂಬ ಅಂಶಕ್ಕೆ ನಾನು ತಕ್ಷಣ ವಿಶೇಷ ಗಮನವನ್ನು ಸೆಳೆಯಲು ಬಯಸುತ್ತೇನೆ ಉಚಿತ ಶ್ರೇಣಿ (ಉಚಿತ ಬಳಕೆ). ಆದರೆ ಇದರ ಹೊರತಾಗಿಯೂ, ಒಂದೆರಡು ಡಾಲರ್ಗಳನ್ನು ಮನಸ್ಸಿನಲ್ಲಿಟ್ಟುಕೊಂಡು, ಪ್ರಸ್ತಾವಿತ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ಅದರೊಂದಿಗೆ ಆಡಲು ಸಾಕಷ್ಟು ಸಾಧ್ಯವಿದೆ. ಮತ್ತು, ಸಹಜವಾಗಿ, ಎಲ್ಲಾ ಸಂಪನ್ಮೂಲಗಳು ಅಗತ್ಯವಿಲ್ಲದ ನಂತರ ಅಳಿಸಲು ಮರೆಯಬೇಡಿ.

ಅದೃಷ್ಟವಶಾತ್, ನಾವು ನಮ್ಮ ಮಾಸಿಕ ಉಚಿತ ಮಿತಿಗಳನ್ನು ಪೂರೈಸಿದರೆ DynamoDb ಮತ್ತು ಲ್ಯಾಂಬ್ಡಾ ಕಾರ್ಯಗಳು ನಮಗೆ ಉಚಿತವಾಗಿರುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, 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.ಮೈಕ್ರೋ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಪ್ರಮುಖ ಟಿಪ್ಪಣಿ: ಉದಾಹರಣೆಗೆ, ನೀವು ಚಿತ್ರವನ್ನು ಬಳಸಬೇಕು - Amazon Linux AMI 2018.03.0, ಇದು ಕೈನೆಸಿಸ್ ಏಜೆಂಟ್ ಅನ್ನು ತ್ವರಿತವಾಗಿ ಪ್ರಾರಂಭಿಸಲು ಕಡಿಮೆ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಹೊಂದಿದೆ.

EC2 ಸೇವೆಗೆ ಹೋಗಿ, ಹೊಸ ವರ್ಚುವಲ್ ಯಂತ್ರವನ್ನು ರಚಿಸಿ, ಉಚಿತ ಶ್ರೇಣಿಯಲ್ಲಿ ಒಳಗೊಂಡಿರುವ t2.micro ಪ್ರಕಾರದೊಂದಿಗೆ ಬಯಸಿದ AMI ಅನ್ನು ಆಯ್ಕೆಮಾಡಿ:

ಹೊಸದಾಗಿ ರಚಿಸಲಾದ ವರ್ಚುವಲ್ ಯಂತ್ರವು ಕೈನೆಸಿಸ್ ಸೇವೆಯೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಸಾಧ್ಯವಾಗುವಂತೆ ಮಾಡಲು, ಅದನ್ನು ಮಾಡಲು ಹಕ್ಕುಗಳನ್ನು ನೀಡಬೇಕು. ಇದನ್ನು ಮಾಡಲು ಉತ್ತಮ ಮಾರ್ಗವೆಂದರೆ IAM ಪಾತ್ರವನ್ನು ನಿಯೋಜಿಸುವುದು. ಆದ್ದರಿಂದ, ಹಂತ 3: ನಿದರ್ಶನ ವಿವರಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ, ನೀವು ಆಯ್ಕೆ ಮಾಡಬೇಕು ಹೊಸ IAM ಪಾತ್ರವನ್ನು ರಚಿಸಿ:

EC2 ಗಾಗಿ IAM ಪಾತ್ರವನ್ನು ರಚಿಸುವುದು

ತೆರೆಯುವ ವಿಂಡೋದಲ್ಲಿ, ನಾವು EC2 ಗಾಗಿ ಹೊಸ ಪಾತ್ರವನ್ನು ರಚಿಸುತ್ತಿದ್ದೇವೆ ಎಂದು ಆಯ್ಕೆಮಾಡಿ ಮತ್ತು ಅನುಮತಿಗಳ ವಿಭಾಗಕ್ಕೆ ಹೋಗಿ:

ತರಬೇತಿ ಉದಾಹರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು, ನಾವು ಸಂಪನ್ಮೂಲ ಹಕ್ಕುಗಳ ಗ್ರ್ಯಾನ್ಯುಲರ್ ಕಾನ್ಫಿಗರೇಶನ್‌ನ ಎಲ್ಲಾ ಜಟಿಲತೆಗಳಿಗೆ ಹೋಗಬೇಕಾಗಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು Amazon ನಿಂದ ಮೊದಲೇ ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ ನೀತಿಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತೇವೆ: 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 ವಿಸ್ತರಣೆಯೊಂದಿಗೆ ಫೈಲ್‌ಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತದೆ, ಅವುಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು airline_tickets ಸ್ಟ್ರೀಮ್‌ಗೆ ವರ್ಗಾಯಿಸುತ್ತದೆ.

ನಾವು ಸೇವೆಯನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಅದು ಚಾಲನೆಯಲ್ಲಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ:

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 ಡೇಟಾ ಅನಾಲಿಟಿಕ್ಸ್‌ನಲ್ಲಿ ಹೊಸ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸಿ:

SQL ಭಾಷೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಕೈನೆಸಿಸ್ ಸ್ಟ್ರೀಮ್‌ಗಳಿಂದ ನೈಜ-ಸಮಯದ ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಕೈನೆಸಿಸ್ ಡೇಟಾ ಅನಾಲಿಟಿಕ್ಸ್ ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು ಸಂಪೂರ್ಣ ಆಟೋಸ್ಕೇಲಿಂಗ್ ಸೇವೆಯಾಗಿದೆ (ಕೈನೆಸಿಸ್ ಸ್ಟ್ರೀಮ್‌ಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿ):

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 ಹೇಳಿಕೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಕೋಷ್ಟಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತೀರಿ. Amazon Kinesis ಡೇಟಾ ಅನಾಲಿಟಿಕ್ಸ್‌ನಲ್ಲಿ, ನೀವು ಸ್ಟ್ರೀಮ್‌ಗಳು (ಸ್ಟ್ರೀಮ್‌ಗಳು) ಮತ್ತು ಪಂಪ್‌ಗಳು (ಪಂಪ್‌ಗಳು) ಜೊತೆ ಕೆಲಸ ಮಾಡುತ್ತೀರಿ - ಒಂದು ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿನ ಒಂದು ಸ್ಟ್ರೀಮ್‌ನಿಂದ ಮತ್ತೊಂದು ಸ್ಟ್ರೀಮ್‌ಗೆ ಡೇಟಾವನ್ನು ಸೇರಿಸುವ ನಿರಂತರ ಇನ್ಸರ್ಟ್ ವಿನಂತಿಗಳು.

ಮೇಲೆ ಪ್ರಸ್ತುತಪಡಿಸಲಾದ SQL ಪ್ರಶ್ನೆಯು ಐದು ಸಾವಿರ ರೂಬಲ್ಸ್‌ಗಿಂತ ಕಡಿಮೆ ವೆಚ್ಚದಲ್ಲಿ ಏರೋಫ್ಲಾಟ್ ಟಿಕೆಟ್‌ಗಳಿಗಾಗಿ ಹುಡುಕಾಟಗಳನ್ನು ಮಾಡುತ್ತದೆ. ಈ ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸುವ ಎಲ್ಲಾ ದಾಖಲೆಗಳನ್ನು DESTINATION_SQL_STREAM ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ.

ಡೆಸ್ಟಿನೇಶನ್ ಬ್ಲಾಕ್‌ನಲ್ಲಿ, ವಿಶೇಷ_ಸ್ಟ್ರೀಮ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿ ಮತ್ತು ಇನ್-ಅಪ್ಲಿಕೇಶನ್ ಸ್ಟ್ರೀಮ್ ಹೆಸರು DESTINATION_SQL_STREAM ಡ್ರಾಪ್-ಡೌನ್ ಪಟ್ಟಿಯಲ್ಲಿ:

ಎಲ್ಲಾ ಕುಶಲತೆಯ ಫಲಿತಾಂಶವು ಕೆಳಗಿನ ಚಿತ್ರಕ್ಕೆ ಹೋಲುವಂತಿರಬೇಕು:

SNS ವಿಷಯವನ್ನು ರಚಿಸುವುದು ಮತ್ತು ಚಂದಾದಾರರಾಗುವುದು

ಸರಳ ಅಧಿಸೂಚನೆ ಸೇವೆಗೆ ಹೋಗಿ ಮತ್ತು ಏರ್ಲೈನ್ಸ್ ಹೆಸರಿನೊಂದಿಗೆ ಹೊಸ ವಿಷಯವನ್ನು ರಚಿಸಿ:

ಈ ವಿಷಯಕ್ಕೆ ಚಂದಾದಾರರಾಗಿ ಮತ್ತು SMS ಅಧಿಸೂಚನೆಗಳನ್ನು ಕಳುಹಿಸುವ ಮೊಬೈಲ್ ಫೋನ್ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸಿ:

DynamoDB ನಲ್ಲಿ ಟೇಬಲ್ ರಚಿಸಿ

ಅವರ airline_tickets ಸ್ಟ್ರೀಮ್‌ನಿಂದ ಕಚ್ಚಾ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು, ಅದೇ ಹೆಸರಿನೊಂದಿಗೆ DynamoDB ನಲ್ಲಿ ಟೇಬಲ್ ಅನ್ನು ರಚಿಸೋಣ. ನಾವು record_id ಅನ್ನು ಪ್ರಾಥಮಿಕ ಕೀಲಿಯಾಗಿ ಬಳಸುತ್ತೇವೆ:

ಲ್ಯಾಂಬ್ಡಾ ಫಂಕ್ಷನ್ ಸಂಗ್ರಾಹಕವನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ

ನಾವು ಕಲೆಕ್ಟರ್ ಎಂಬ ಲ್ಯಾಂಬ್ಡಾ ಫಂಕ್ಷನ್ ಅನ್ನು ರಚಿಸೋಣ, ಅದರ ಕಾರ್ಯವು ಏರ್‌ಲೈನ್_ಟಿಕೆಟ್‌ಗಳ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಪೋಲ್ ಮಾಡುವುದು ಮತ್ತು ಅಲ್ಲಿ ಹೊಸ ದಾಖಲೆಗಳು ಕಂಡುಬಂದರೆ, ಈ ದಾಖಲೆಗಳನ್ನು DynamoDB ಟೇಬಲ್‌ಗೆ ಸೇರಿಸಿ. ನಿಸ್ಸಂಶಯವಾಗಿ, ಡೀಫಾಲ್ಟ್ ಹಕ್ಕುಗಳ ಜೊತೆಗೆ, ಈ ಲ್ಯಾಂಬ್ಡಾ ಕಿನೆಸಿಸ್ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗೆ ಓದುವ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರಬೇಕು ಮತ್ತು ಡೈನಮೊಡಿಬಿಗೆ ಪ್ರವೇಶವನ್ನು ಬರೆಯಬೇಕು.

ಸಂಗ್ರಾಹಕ ಲ್ಯಾಂಬ್ಡಾ ಕಾರ್ಯಕ್ಕಾಗಿ IAM ಪಾತ್ರವನ್ನು ರಚಿಸುವುದು
ಮೊದಲಿಗೆ, Lambda-TicketsProcessingRole ಹೆಸರಿನ ಲ್ಯಾಂಬ್ಡಾಗೆ ಹೊಸ IAM ಪಾತ್ರವನ್ನು ರಚಿಸೋಣ:

ಪರೀಕ್ಷಾ ಉದಾಹರಣೆಗಾಗಿ, ಕೆಳಗಿನ ಚಿತ್ರದಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ ಮೊದಲೇ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾದ 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()

ಲ್ಯಾಂಬ್ಡಾ ಫಂಕ್ಷನ್ ನೋಟಿಫೈಯರ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ

ಎರಡನೇ ಸ್ಟ್ರೀಮ್ (ವಿಶೇಷ_ಸ್ಟ್ರೀಮ್) ಅನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವ ಮತ್ತು SNS ಗೆ ಅಧಿಸೂಚನೆಯನ್ನು ಕಳುಹಿಸುವ ಎರಡನೇ ಲ್ಯಾಂಬ್ಡಾ ಕಾರ್ಯವನ್ನು ಇದೇ ರೀತಿಯಲ್ಲಿ ರಚಿಸಲಾಗಿದೆ. ಆದ್ದರಿಂದ, ಈ ಲ್ಯಾಂಬ್ಡಾ ಕೈನೆಸಿಸ್‌ನಿಂದ ಓದಲು ಮತ್ತು ನಿರ್ದಿಷ್ಟ SNS ವಿಷಯಕ್ಕೆ ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸಲು ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರಬೇಕು, ನಂತರ ಈ ವಿಷಯದ ಎಲ್ಲಾ ಚಂದಾದಾರರಿಗೆ (ಇಮೇಲ್, SMS, ಇತ್ಯಾದಿ) SNS ಸೇವೆಯಿಂದ ಕಳುಹಿಸಲಾಗುತ್ತದೆ.

IAM ಪಾತ್ರವನ್ನು ರಚಿಸುವುದು
ಮೊದಲಿಗೆ, ನಾವು ಈ ಲ್ಯಾಂಬ್ಡಾಗಾಗಿ IAM ಪಾತ್ರ Lambda-KinesisAlarm ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಈ ಪಾತ್ರವನ್ನು ರಚಿಸಲಾಗುತ್ತಿರುವ alarm_notifier lambda ಗೆ ನಿಯೋಜಿಸುತ್ತೇವೆ:

ವಿಶೇಷ_ಸ್ಟ್ರೀಮ್‌ಗೆ ಪ್ರವೇಶಿಸಲು ಹೊಸ ದಾಖಲೆಗಳಿಗಾಗಿ ಈ ಲ್ಯಾಂಬ್ಡಾ ಟ್ರಿಗ್ಗರ್‌ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬೇಕು, ಆದ್ದರಿಂದ ನಾವು ಕಲೆಕ್ಟರ್ ಲ್ಯಾಂಬ್ಡಾಗಾಗಿ ಮಾಡಿದ ರೀತಿಯಲ್ಲಿಯೇ ನೀವು ಟ್ರಿಗ್ಗರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ.

ಈ ಲ್ಯಾಂಬ್ಡಾವನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದನ್ನು ಸುಲಭಗೊಳಿಸಲು, ನಾವು ಹೊಸ ಪರಿಸರ ವೇರಿಯಬಲ್ ಅನ್ನು ಪರಿಚಯಿಸೋಣ - 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 ನ ಎಲ್ಲಾ ಅಗತ್ಯ ಸಂರಚನೆಗಳನ್ನು ಕೈಗೊಳ್ಳಲು, ಲ್ಯಾಂಬ್ಡಾ ಕಾರ್ಯಗಳನ್ನು ನಿಯೋಜಿಸಲು, ಇತ್ಯಾದಿಗಳನ್ನು ಅನುಮತಿಸುತ್ತದೆ.

ಟೆರ್ರಾಫಾರ್ಮ್ ಕೋಡ್ ಮೂಲಕ ಎಲ್ಲಾ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಯಶಸ್ವಿಯಾಗಿ ರಚಿಸಿದ ನಂತರ, ನೀವು ಕಿನೆಸಿಸ್ ಅನಾಲಿಟಿಕ್ಸ್ ಅಪ್ಲಿಕೇಶನ್‌ನ ವಿವರಗಳಿಗೆ ಹೋಗಬೇಕಾಗುತ್ತದೆ (ದುರದೃಷ್ಟವಶಾತ್, ಕೋಡ್‌ನಿಂದ ನೇರವಾಗಿ ಇದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ನಾನು ಕಂಡುಹಿಡಿಯಲಿಲ್ಲ).

ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ:

ಇದರ ನಂತರ, ಡ್ರಾಪ್-ಡೌನ್ ಪಟ್ಟಿಯಿಂದ ಆಯ್ಕೆ ಮಾಡುವ ಮೂಲಕ ನೀವು ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿನ ಸ್ಟ್ರೀಮ್ ಹೆಸರನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಹೊಂದಿಸಬೇಕು:

ಈಗ ಎಲ್ಲವೂ ಹೋಗಲು ಸಿದ್ಧವಾಗಿದೆ.

ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲಾಗುತ್ತಿದೆ

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

Kinesis ಏಜೆಂಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿದ EC2 ವರ್ಚುವಲ್ ಯಂತ್ರಕ್ಕೆ SSH ಮೂಲಕ ನಾವು ಲಾಗ್ ಇನ್ ಮಾಡುತ್ತೇವೆ ಮತ್ತು api_caller.py ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತೇವೆ

sudo ./api_caller.py TOKEN

ನೀವು ಮಾಡಬೇಕಾಗಿರುವುದು ನಿಮ್ಮ ಸಂಖ್ಯೆಗೆ SMS ಗಾಗಿ ನಿರೀಕ್ಷಿಸಿ:

SMS - ಸಂದೇಶವು ಸುಮಾರು 1 ನಿಮಿಷದಲ್ಲಿ ಫೋನ್‌ಗೆ ಬರುತ್ತದೆ:

ನಂತರದ, ಹೆಚ್ಚು ವಿವರವಾದ ವಿಶ್ಲೇಷಣೆಗಾಗಿ DynamoDB ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ದಾಖಲೆಗಳನ್ನು ಉಳಿಸಲಾಗಿದೆಯೇ ಎಂದು ನೋಡಲು ಉಳಿದಿದೆ. Airline_tickets ಕೋಷ್ಟಕವು ಸರಿಸುಮಾರು ಕೆಳಗಿನ ಡೇಟಾವನ್ನು ಒಳಗೊಂಡಿದೆ:

ತೀರ್ಮಾನಕ್ಕೆ

ಮಾಡಿದ ಕೆಲಸದ ಸಂದರ್ಭದಲ್ಲಿ, ಅಮೆಜಾನ್ ಕೈನೆಸಿಸ್ ಅನ್ನು ಆಧರಿಸಿ ಆನ್‌ಲೈನ್ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸಲಾಯಿತು. ಕೈನೆಸಿಸ್ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳ ಜೊತೆಯಲ್ಲಿ ಕೈನೆಸಿಸ್ ಏಜೆಂಟ್ ಅನ್ನು ಬಳಸುವ ಆಯ್ಕೆಗಳು ಮತ್ತು SQL ಆಜ್ಞೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನೈಜ-ಸಮಯದ ಅನಾಲಿಟಿಕ್ಸ್ ಕೈನೆಸಿಸ್ ಅನಾಲಿಟಿಕ್ಸ್, ಹಾಗೆಯೇ ಇತರ AWS ಸೇವೆಗಳೊಂದಿಗೆ Amazon Kinesis ನ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಪರಿಗಣಿಸಲಾಗಿದೆ.

ನಾವು ಮೇಲಿನ ವ್ಯವಸ್ಥೆಯನ್ನು ಎರಡು ರೀತಿಯಲ್ಲಿ ನಿಯೋಜಿಸಿದ್ದೇವೆ: ಬದಲಿಗೆ ದೀರ್ಘ ಕೈಪಿಡಿ ಮತ್ತು ಟೆರಾಫಾರ್ಮ್ ಕೋಡ್‌ನಿಂದ ತ್ವರಿತ.

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

ಲೇಖನವನ್ನು ಚರ್ಚಿಸಲು ನನಗೆ ಸಂತೋಷವಾಗಿದೆ, ನಿಮ್ಮ ಕಾಮೆಂಟ್ಗಳಿಗಾಗಿ ನಾನು ಎದುರು ನೋಡುತ್ತಿದ್ದೇನೆ. ರಚನಾತ್ಮಕ ಟೀಕೆಗಾಗಿ ನಾನು ಆಶಿಸುತ್ತೇನೆ.

ನಾನು ನಿಮಗೆ ಯಶಸ್ಸನ್ನು ಬಯಸುತ್ತೇನೆ!

ಮೂಲ: www.habr.com