Yandex.Cloud ಮತ್ತು Python ನ ಸರ್ವರ್‌ಲೆಸ್ ಕಾರ್ಯಗಳಲ್ಲಿ ಆಲಿಸ್‌ಗೆ ರಾಜ್ಯಪೂರ್ಣ ಕೌಶಲ್ಯವನ್ನು ರಚಿಸುವುದು

ಸುದ್ದಿಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ. ನಿನ್ನೆ Yandex.Cloud ಸರ್ವರ್‌ಲೆಸ್ ಕಂಪ್ಯೂಟಿಂಗ್ ಸೇವೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವುದಾಗಿ ಘೋಷಿಸಿತು ಯಾಂಡೆಕ್ಸ್ ಮೇಘ ಕಾರ್ಯಗಳು. ಇದರರ್ಥ: ನೀವು ನಿಮ್ಮ ಸೇವೆಯ ಕೋಡ್ ಅನ್ನು ಮಾತ್ರ ಬರೆಯುತ್ತೀರಿ (ಉದಾಹರಣೆಗೆ, ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಅಥವಾ ಚಾಟ್‌ಬಾಟ್), ಮತ್ತು ಕ್ಲೌಡ್ ಸ್ವತಃ ವರ್ಚುವಲ್ ಯಂತ್ರಗಳನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ನಿರ್ವಹಿಸುತ್ತದೆ ಅಲ್ಲಿ ಅದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಲೋಡ್ ಹೆಚ್ಚಾದರೆ ಅವುಗಳನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತದೆ. ನೀವು ಯೋಚಿಸಬೇಕಾಗಿಲ್ಲ, ಇದು ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿದೆ. ಮತ್ತು ಪಾವತಿಯು ಲೆಕ್ಕಾಚಾರದ ಸಮಯಕ್ಕೆ ಮಾತ್ರ ಹೋಗುತ್ತದೆ.

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

ಆದರೆ ಒಂದೆರಡು ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳಿವೆ. ಮೊದಲನೆಯದಾಗಿ, ನಿಮ್ಮ ಪಿಇಟಿ ಕೋಡ್‌ಗೆ ಕೆಲವು ಅವಲಂಬನೆಗಳು ಬೇಕಾಗಬಹುದು ಮತ್ತು ಅವುಗಳನ್ನು ಕ್ಲೌಡ್‌ಗೆ ಎಳೆಯುವುದು ಕ್ಷುಲ್ಲಕವಲ್ಲ. ಎರಡನೆಯದಾಗಿ, ಯಾವುದೇ ಸಾಮಾನ್ಯ ಚಾಟ್‌ಬಾಟ್‌ಗೆ ಸಂವಾದದ ಸ್ಥಿತಿಯನ್ನು ಎಲ್ಲೋ ಸಂಗ್ರಹಿಸಬೇಕಾಗುತ್ತದೆ (ಆದ್ದರಿಂದ ಸ್ಟೇಟ್‌ಫುಲ್); ಸರ್ವರ್‌ಲೆಸ್ ಕಾರ್ಯದಲ್ಲಿ ಅದನ್ನು ಹೇಗೆ ಮಾಡುವುದು ಸುಲಭವಾದ ರೀತಿಯಲ್ಲಿ? ಮೂರನೆಯದಾಗಿ, ನೀವು ಆಲಿಸ್‌ಗಾಗಿ ತ್ವರಿತ-ಕೊಳಕು ಕೌಶಲ್ಯವನ್ನು ಅಥವಾ ಶೂನ್ಯವಲ್ಲದ ಕಥಾವಸ್ತುವನ್ನು ಹೊಂದಿರುವ ಕೆಲವು ರೀತಿಯ ಬೋಟ್ ಅನ್ನು ಹೇಗೆ ಬರೆಯಬಹುದು? ಈ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳ ಬಗ್ಗೆ, ವಾಸ್ತವವಾಗಿ, ಲೇಖನ.

ನೈತಿಕ ಸಿದ್ಧತೆ

ತಾಳ್ಮೆಯಿಲ್ಲದವರಿಗೆ: ಕಾರ್ಯವನ್ನು ಕ್ಲೌಡ್‌ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡುವ ಮೊದಲು ನಾನು ಮೇಕ್‌ಫೈಲ್‌ನೊಂದಿಗೆ ಅಗತ್ಯ ಅವಲಂಬನೆಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತೇನೆ, ನಾನು ಡೈಲಾಗ್‌ನ ಸ್ಥಿತಿಯನ್ನು ಯಾಂಡೆಕ್ಸ್ ಆಬ್ಜೆಕ್ಟ್ ಸ್ಟೋರೇಜ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತೇನೆ (ಇದು S3 API ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ), ಮತ್ತು ಸಂವಾದವನ್ನು ನಿರ್ವಹಿಸಲು ನಾನು ನನ್ನ ಸ್ವಂತ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುತ್ತೇನೆ tgalice. ಪರಿಣಾಮವಾಗಿ, ಇದು ತಿರುಗುತ್ತದೆ ಇಂತಹ ಡೆಮೊ ಕೌಶಲ್ಯ. ಮತ್ತು ಈಗ ಈ ಎಲ್ಲವನ್ನು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ವಿವರವಾಗಿ ವಿಶ್ಲೇಷಿಸೋಣ.

ಸ್ವಲ್ಪ ತಾಳ್ಮೆಯಿಲ್ಲದವರಿಗೆ, ನನ್ನ ಸಂಕೀರ್ಣತೆಯ ಕಥೆಯಲ್ಲಿ ಮುಳುಗುವ ಮೊದಲು, ಸರಳವಾಗಿ ಪ್ರಾರಂಭಿಸಲು ನಾನು ಹೆಚ್ಚು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ. ಅವುಗಳೆಂದರೆ, ಏಕ-ಫೈಲ್ ಎಕೋಬಾಟ್ ಕಾರ್ಯವನ್ನು ರಚಿಸಿ, ಅದನ್ನು ಡೈಲಾಗ್ ಡೆವಲಪರ್ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ನೋಂದಾಯಿಸಿ ಮತ್ತು ಪರೀಕ್ಷಿಸಿ; ವಿವರಗಳು - ರಲ್ಲಿ ಬ್ಲಾಗ್ ಸಂವಾದಗಳು и ಕ್ಲೌಡ್ ದಸ್ತಾವೇಜನ್ನು. ಮತ್ತು ನಂತರ ಮಾತ್ರ ಪ್ರಾರಂಭಿಸಿ.

ನಾವು ಯಾವುದಕ್ಕಾಗಿ ಹೋರಾಡುತ್ತಿದ್ದೇವೆ ಎಂದು ನೀವು ತಕ್ಷಣ ಅನುಭವಿಸಲು ಬಯಸಿದರೆ, ಆಲಿಸ್ ಅವರನ್ನು ಕೇಳಿ"ಐಟಿ ಜಾತಕ" ಕೌಶಲ್ಯವನ್ನು ಆನ್ ಮಾಡಿ'. ಕೆಳಗಿನ ಸಂವಾದ ನಡೆಯಬೇಕು:

ಆಲಿಸ್: ಹಲೋ! ನೀವು "ಐಟಿ ಜಾತಕ" ಕೌಶಲ್ಯದಲ್ಲಿದ್ದೀರಿ. ನಕ್ಷತ್ರಗಳು ನಿಮಗೆ ಏನು ಭರವಸೆ ನೀಡುತ್ತವೆ ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯಲು "ಪ್ರಾರಂಭಿಸು" ಎಂದು ಹೇಳಿ.
ಬಳಕೆದಾರ: ಪ್ರಾರಂಭಿಸಿ
ಉ: ದಯವಿಟ್ಟು ನಿಮ್ಮ ಹೆಸರನ್ನು ತಿಳಿಸಿ.
ಯು: ವಸಿಸುಲಿ
ಉ: ಈಗ ನೀನು ಹುಟ್ಟಿದ ವರ್ಷ ಹೇಳು. ಕೇವಲ ನಾಲ್ಕು ಅಂಕೆಗಳು, ಹೆಚ್ಚೇನೂ ಇಲ್ಲ.
ಯು: ಎರಡನೆಯದು
ಉ: ದಯವಿಟ್ಟು ಮತ್ತೆ ಪ್ರಯತ್ನಿಸಿ. ನಿಮ್ಮ ಹುಟ್ಟಿದ ವರ್ಷವನ್ನು ತಿಳಿಸಿ - ನಾಲ್ಕು ಅಂಕೆಗಳು.
ಯು: 2002
ಉ: ಅದ್ಭುತವಾಗಿದೆ! ಈಗ ನೀವು ಹುಟ್ಟಿದ ತಿಂಗಳನ್ನು ಹೆಸರಿಸಿ.
ಯು: ಫೆಬ್ರವರಿ
ಉ: ಅತ್ಯುತ್ತಮ! ಅಂತಿಮವಾಗಿ, ನಿಮ್ಮ ಜನ್ಮ ದಿನಾಂಕವನ್ನು ನನಗೆ ತಿಳಿಸಿ - ಕೇವಲ ಒಂದು ಸಂಖ್ಯೆ, ಕೇವಲ ಒಂದು ಅಥವಾ ಎರಡು ಅಂಕೆಗಳು.
ಯು: 18
ಉ: ಧನ್ಯವಾದಗಳು, ವಸಿಶುವಲ್! ಈಗ ನಮಗೆ ತಿಳಿದಿದೆ: ನೀವು 17 ವರ್ಷ ವಯಸ್ಸಿನವರು ಮತ್ತು ನೀವು ಅಕ್ವೇರಿಯಸ್. ಇಲ್ಲಿ ನೀವು ಖಂಡಿತವಾಗಿಯೂ ಅದೃಷ್ಟವಂತರು! ನಕ್ಷತ್ರಗಳು ನಿಮಗೆ ಹೇಳುತ್ತವೆ а что говорят звёзды, вы узнаете, запустив навык.

ಸಮಸ್ಯೆಯೆಂದರೆ ಅಂತಹ ಸರಳ ಸಂವಾದವನ್ನು ಸಹ ನಿರ್ವಹಿಸಲು, ನೀವು ಬಳಕೆದಾರರ ಹೆಸರು ಮತ್ತು ಹುಟ್ಟಿದ ದಿನಾಂಕವನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಬೇಕು ಮತ್ತು ಸರ್ವರ್‌ಲೆಸ್ ಪರಿಸರದಲ್ಲಿ ಇದು ಕ್ಷುಲ್ಲಕವಲ್ಲ. ಸನ್ನಿವೇಶವನ್ನು RAM ನಲ್ಲಿ ಅಥವಾ ಡಿಸ್ಕ್ನಲ್ಲಿ ಫೈಲ್ ಆಗಿ ಸಂಗ್ರಹಿಸಲು ಇದು ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ, ಏಕೆಂದರೆ Yandex.Cloud ಒಂದೇ ಸಮಯದಲ್ಲಿ ಹಲವಾರು ವರ್ಚುವಲ್ ಗಣಕಗಳಲ್ಲಿ ಕಾರ್ಯವನ್ನು ಚಲಾಯಿಸಬಹುದು ಮತ್ತು ಅವುಗಳ ನಡುವೆ ನಿರಂಕುಶವಾಗಿ ಬದಲಾಯಿಸಬಹುದು. ನೀವು ಕೆಲವು ರೀತಿಯ ಬಾಹ್ಯ ಸಂಗ್ರಹಣೆಯನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಆಬ್ಜೆಕ್ಟ್ ಸ್ಟೋರೇಜ್ ಅನ್ನು Yandex.Cloud ನಲ್ಲಿ ನೇರವಾಗಿ ಅಗ್ಗವಾದ ಮತ್ತು ಸರಳವಾದ ಸಂಗ್ರಹಣೆಯಾಗಿ ಆಯ್ಕೆ ಮಾಡಲಾಗಿದೆ (ಅಂದರೆ, ಬಹುಶಃ ವೇಗವಾಗಿದೆ). ಉಚಿತ ಪರ್ಯಾಯವಾಗಿ, ನೀವು ಪ್ರಯತ್ನಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, ಉಚಿತ ತುಣುಕು ಮೋಡದ ಮೊಂಗಿ ಎಲ್ಲೋ ದೂರ. ಆಬ್ಜೆಕ್ಟ್ ಸ್ಟೋರೇಜ್ (ಇದು S3 ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ) ಮತ್ತು ಮೊಂಗೋ ಎರಡೂ ಅನುಕೂಲಕರ ಪೈಥಾನ್ ಹೊದಿಕೆಗಳನ್ನು ಹೊಂದಿವೆ.

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

ಜಾತಕ ಕೌಶಲ್ಯವನ್ನು ಹೇಗೆ ಪ್ರಾರಂಭಿಸುವುದು

1. ಸಿದ್ಧರಾಗಿ: ಲಿನಕ್ಸ್‌ನೊಂದಿಗೆ ಕೆಲವು ಯಂತ್ರಕ್ಕೆ ಹೋಗಿ. ತಾತ್ವಿಕವಾಗಿ, ನೀವು ಬಹುಶಃ ವಿಂಡೋಸ್‌ನೊಂದಿಗೆ ಸಹ ಕೆಲಸ ಮಾಡಬಹುದು, ಆದರೆ ನಂತರ ನೀವು ಮೇಕ್‌ಫೈಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವುದರೊಂದಿಗೆ ಬೇಡಿಕೊಳ್ಳಬೇಕಾಗುತ್ತದೆ. ಮತ್ತು ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ, ನಿಮಗೆ ಕನಿಷ್ಟ 3.6 ಸ್ಥಾಪಿಸಲಾದ ಪೈಥಾನ್ ಅಗತ್ಯವಿರುತ್ತದೆ.
2. ಗಿಥಬ್‌ನಿಂದ ಕ್ಲೋನ್ ಜಾತಕ ಕೌಶಲ್ಯದ ಉದಾಹರಣೆ.
3. Ya.Cloud ನಲ್ಲಿ ನೋಂದಾಯಿಸಿ: https://cloud.yandex.ru
4. ನೀವೇ ಎರಡು ಬಕೆಟ್‌ಗಳನ್ನು ರಚಿಸಿ ವಸ್ತು ಸಂಗ್ರಹಣೆ, ಅವರನ್ನು ಯಾವುದೇ ಹೆಸರಿನಿಂದ ಕರೆಯಿರಿ {BUCKET NAME} и tgalice-test-cold-storage (ಈ ಮಧ್ಯದ ಹೆಸರನ್ನು ಈಗ ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಲಾಗಿದೆ main.py ನನ್ನ ಉದಾಹರಣೆ). ಮೊದಲ ಬಕೆಟ್ ನಿಯೋಜನೆಗಾಗಿ ಮಾತ್ರ ಬೇಕಾಗುತ್ತದೆ, ಎರಡನೆಯದು - ಸಂವಾದ ಸ್ಥಿತಿಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು.
5. ಎ ರಚಿಸಿ ಸೇವಾ ಖಾತೆ, ಅವನಿಗೆ ಒಂದು ಪಾತ್ರವನ್ನು ನೀಡಿ editor, ಮತ್ತು ಅದಕ್ಕೆ ಸ್ಥಿರ ರುಜುವಾತುಗಳನ್ನು ಪಡೆಯಿರಿ {KEY ID} и {KEY VALUE} - ಸಂಭಾಷಣೆಯ ಸ್ಥಿತಿಯನ್ನು ರೆಕಾರ್ಡ್ ಮಾಡಲು ನಾವು ಅವುಗಳನ್ನು ಬಳಸುತ್ತೇವೆ. Ya.Cloud ನಿಂದ ಕಾರ್ಯವು Ya.Cloud ನಿಂದ ಸಂಗ್ರಹಣೆಯನ್ನು ಪ್ರವೇಶಿಸಲು ಇವೆಲ್ಲವೂ ಅಗತ್ಯವಿದೆ. ಒಂದು ದಿನ, ಅಧಿಕಾರವು ಸ್ವಯಂಚಾಲಿತವಾಗುತ್ತದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ, ಆದರೆ ಇದೀಗ - ಆದ್ದರಿಂದ.
6. (ಐಚ್ಛಿಕ) ಸ್ಥಾಪಿಸಿ ಆಜ್ಞಾ ಸಾಲಿನ ಇಂಟರ್ಫೇಸ್ yc. ನೀವು ವೆಬ್ ಇಂಟರ್ಫೇಸ್ ಮೂಲಕ ಕಾರ್ಯವನ್ನು ಸಹ ರಚಿಸಬಹುದು, ಆದರೆ CLI ಒಳ್ಳೆಯದು ಏಕೆಂದರೆ ಎಲ್ಲಾ ರೀತಿಯ ನಾವೀನ್ಯತೆಗಳು ಅದರಲ್ಲಿ ವೇಗವಾಗಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ.
7. ಈಗ ನೀವು ವಾಸ್ತವವಾಗಿ, ಅವಲಂಬನೆಗಳ ಜೋಡಣೆಯನ್ನು ತಯಾರಿಸಬಹುದು: ಕೌಶಲ್ಯ ಉದಾಹರಣೆಯೊಂದಿಗೆ ಫೋಲ್ಡರ್ನಿಂದ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ರನ್ ಮಾಡಿ make all. ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಲೈಬ್ರರಿಗಳ ಗುಂಪನ್ನು (ಹೆಚ್ಚಾಗಿ, ಎಂದಿನಂತೆ, ಅನಗತ್ಯ) ಸ್ಥಾಪಿಸಲಾಗುತ್ತದೆ dist.
8. ಆಬ್ಜೆಕ್ಟ್ ಸ್ಟೋರೇಜ್‌ಗೆ ಪೆನ್ನುಗಳನ್ನು ತುಂಬಿಸಿ (ಬಕೆಟ್‌ಗೆ {BUCKET NAME}) ಹಿಂದಿನ ಹಂತದಲ್ಲಿ ಪಡೆದ ಆರ್ಕೈವ್ dist.zip. ಬಯಸಿದಲ್ಲಿ, ನೀವು ಇದನ್ನು ಆಜ್ಞಾ ಸಾಲಿನಿಂದಲೂ ಮಾಡಬಹುದು, ಉದಾಹರಣೆಗೆ, ಬಳಸಿ AWS CLI.
9. ವೆಬ್ ಇಂಟರ್ಫೇಸ್ ಮೂಲಕ ಅಥವಾ ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಸರ್ವರ್‌ಲೆಸ್ ಕಾರ್ಯವನ್ನು ರಚಿಸಿ yc. ಉಪಯುಕ್ತತೆಗಾಗಿ, ಆಜ್ಞೆಯು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

yc serverless function version create
    --function-name=horoscope
    --environment=AWS_ACCESS_KEY_ID={KEY ID},AWS_SECRET_ACCESS_KEY={KEY VALUE}
    --runtime=python37
    --package-bucket-name={BUCKET NAME}
    --package-object-name=dist.zip
    --entrypoint=main.alice_handler
    --memory=128M
    --execution-timeout=3s

ಹಸ್ತಚಾಲಿತವಾಗಿ ಕಾರ್ಯವನ್ನು ರಚಿಸುವಾಗ, ಎಲ್ಲಾ ನಿಯತಾಂಕಗಳನ್ನು ಒಂದೇ ರೀತಿಯಲ್ಲಿ ತುಂಬಿಸಲಾಗುತ್ತದೆ.

ಈಗ ನೀವು ರಚಿಸಿದ ಕಾರ್ಯವನ್ನು ಡೆವಲಪರ್ ಕನ್ಸೋಲ್ ಮೂಲಕ ಪರೀಕ್ಷಿಸಬಹುದು ಮತ್ತು ನಂತರ ಕೌಶಲ್ಯವನ್ನು ಅಂತಿಮಗೊಳಿಸಬಹುದು ಮತ್ತು ಪ್ರಕಟಿಸಬಹುದು.

ಹುಡ್ ಅಡಿಯಲ್ಲಿ ಏನಿದೆ

ಮೇಕ್‌ಫೈಲ್ ವಾಸ್ತವವಾಗಿ ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸಲು ಮತ್ತು ಅವುಗಳನ್ನು ಆರ್ಕೈವ್‌ಗೆ ಹಾಕಲು ಸರಳವಾದ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ. dist.zip, ಈ ರೀತಿಯ ಏನಾದರೂ:

mkdir -p dist/
pip3 install -r requirements.txt --target dist/ 
cp main.py dist/main.py
cp form.yaml dist/form.yaml
cd dist && zip --exclude '*.pyc' -r ../dist.zip ./*

ಉಳಿದವು ಗ್ರಂಥಾಲಯದಲ್ಲಿ ಸುತ್ತುವ ಕೆಲವು ಸರಳ ಸಾಧನಗಳಾಗಿವೆ tgalice. ಬಳಕೆದಾರರ ಡೇಟಾವನ್ನು ಭರ್ತಿ ಮಾಡುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸಂರಚನೆಯಿಂದ ವಿವರಿಸಲಾಗಿದೆ form.yaml:

form_name: 'horoscope_form'
start:
  regexp: 'старт|нач(ать|ни)'
  suggests:
    - Старт
fields:
  - name: 'name'
    question: Пожалуйста, назовите своё имя.
  - name: 'year'
    question: Теперь скажите мне год вашего рождения. Только четыре цифры, ничего лишнего.
    validate_regexp: '^[0-9]{4}$'
    validate_message: Пожалуйста, попробуйте ещё раз. Назовите год вашего рождения - четыре цифры.
  - name: 'month'
    question: Замечательно! Теперь назовите месяц вашего рождения.
    options:
      - январь
     ...
      - декабрь
    validate_message: То, что вы назвали, не похоже на месяц. Пожалуйста, назовите месяц вашего рождения, без других слов.
  - name: 'day'
    question: Отлично! Наконец, назовите мне дату вашего рождения - только число, всего одна или две цифры.
    validate_regexp: '[0123]?d$'
    validate_message: Пожалуйста, попробуйте ещё раз. Вам нужно назвать число своего рождения (например, двадцатое); это одна или две цифры.

ಪೈಥಾನ್ ವರ್ಗವು ಈ ಸಂರಚನೆಯನ್ನು ಪಾರ್ಸ್ ಮಾಡುವ ಮತ್ತು ಅಂತಿಮ ಫಲಿತಾಂಶವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಕೆಲಸವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

class CheckableFormFiller(tgalice.dialog_manager.form_filling.FormFillingDialogManager):
    SIGNS = {
        'январь': 'Козерог',
        ...
    }

    def handle_completed_form(self, form, user_object, ctx):
        response = tgalice.dialog_manager.base.Response(
            text='Спасибо, {}! Теперь мы знаем: вам {} лет, и вы {}. n'
                 'Вот это вам, конечно, повезло! Звёзды говорят вам: {}'.format(
                form['fields']['name'],
                2019 - int(form['fields']['year']),
                self.SIGNS[form['fields']['month']],
                random.choice(FORECASTS),
            ),
            user_object=user_object,
        )
        return response

ಹೆಚ್ಚು ನಿಖರವಾಗಿ, ಮೂಲ ವರ್ಗ FormFillingDialogManager "ಫಾರ್ಮ್" ಅನ್ನು ಭರ್ತಿ ಮಾಡುವಲ್ಲಿ ತೊಡಗಿಸಿಕೊಂಡಿದೆ, ಮತ್ತು ಮಗುವಿನ ವರ್ಗದ ವಿಧಾನವನ್ನು handle_completed_form ಅವಳು ಸಿದ್ಧವಾದಾಗ ಏನು ಮಾಡಬೇಕೆಂದು ಹೇಳುತ್ತಾಳೆ.

ಬಳಕೆದಾರರ ಸಂವಾದದ ಈ ಮುಖ್ಯ ಹರಿವಿನ ಜೊತೆಗೆ, ಬಳಕೆದಾರರನ್ನು ಅಭಿನಂದಿಸುವುದು ಸಹ ಅಗತ್ಯವಾಗಿದೆ, ಜೊತೆಗೆ "ಸಹಾಯ" ಆಜ್ಞೆಯಲ್ಲಿ ಸಹಾಯವನ್ನು ನೀಡಿ ಮತ್ತು "ನಿರ್ಗಮನ" ಆಜ್ಞೆಯಲ್ಲಿನ ಕೌಶಲ್ಯದಿಂದ ಬಿಡುಗಡೆ ಮಾಡಿ. ಇದಕ್ಕಾಗಿ tgalice ಒಂದು ಟೆಂಪ್ಲೇಟ್ ಸಹ ಇದೆ, ಆದ್ದರಿಂದ ಇಡೀ ಸಂವಾದ ನಿರ್ವಾಹಕವು ತುಣುಕುಗಳಿಂದ ಮಾಡಲ್ಪಟ್ಟಿದೆ:

dm = tgalice.dialog_manager.CascadeDialogManager(
    tgalice.dialog_manager.GreetAndHelpDialogManager(
        greeting_message=DEFAULT_MESSAGE,
        help_message=DEFAULT_MESSAGE,
        exit_message='До свидания, приходите в навык "Айтишный гороскоп" ещё!'
    ),
    CheckableFormFiller(`form.yaml`, default_message=DEFAULT_MESSAGE)
)

CascadeDialogManager ಸರಳವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ: ಇದು ಸಂವಾದದ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಗೆ ಅದರ ಎಲ್ಲಾ ಘಟಕಗಳನ್ನು ಅನ್ವಯಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಮತ್ತು ಮೊದಲ ಸಂಬಂಧಿತ ಒಂದನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ.

ಪ್ರತಿ ಸಂದೇಶಕ್ಕೆ ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ, ಡೈಲಾಗ್ ಮ್ಯಾನೇಜರ್ ಪೈಥಾನ್ ವಸ್ತುವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ Response, ನಂತರ ಅದನ್ನು ಸರಳ ಪಠ್ಯವಾಗಿ ಅಥವಾ ಆಲಿಸ್ ಅಥವಾ ಟೆಲಿಗ್ರಾಮ್‌ನಲ್ಲಿ ಸಂದೇಶವಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು - ಬೋಟ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಸ್ಥಳವನ್ನು ಅವಲಂಬಿಸಿ; ಇದು ಉಳಿಸಬೇಕಾದ ಸಂವಾದದ ಬದಲಾದ ಸ್ಥಿತಿಯನ್ನು ಸಹ ಒಳಗೊಂಡಿದೆ. ಈ ಎಲ್ಲಾ ಅಡುಗೆಮನೆಯನ್ನು ಮತ್ತೊಂದು ವರ್ಗದವರು ನಿರ್ವಹಿಸುತ್ತಾರೆ, DialogConnector, ಆದ್ದರಿಂದ Yandex ಕಾರ್ಯಗಳಲ್ಲಿ ಕೌಶಲ್ಯವನ್ನು ಪ್ರಾರಂಭಿಸಲು ನೇರ ಸ್ಕ್ರಿಪ್ಟ್ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

...
session = boto3.session.Session()
s3 = session.client(
    service_name='s3',
    endpoint_url='https://storage.yandexcloud.net',
    aws_access_key_id=os.environ['AWS_ACCESS_KEY_ID'],
    aws_secret_access_key=os.environ['AWS_SECRET_ACCESS_KEY'],
    region_name='ru-central1',
)
storage = tgalice.session_storage.S3BasedStorage(s3_client=s3, bucket_name='tgalice-test-cold-storage')
connector = tgalice.dialog_connector.DialogConnector(dialog_manager=dm, storage=storage)
alice_handler = connector.serverless_alice_handler

ನೀವು ನೋಡುವಂತೆ, ಈ ಕೋಡ್‌ನ ಹೆಚ್ಚಿನವು ಆಬ್ಜೆಕ್ಟ್ ಸ್ಟೋರೇಜ್ S3 ಇಂಟರ್ಫೇಸ್‌ಗೆ ಸಂಪರ್ಕವನ್ನು ರಚಿಸುತ್ತದೆ. ಈ ಸಂಪರ್ಕವನ್ನು ನೇರವಾಗಿ ಹೇಗೆ ಬಳಸಲಾಗುತ್ತದೆ, ನೀವು ಓದಬಹುದು tgalice ಕೋಡ್‌ನಲ್ಲಿ.
ಕೊನೆಯ ಸಾಲು ಒಂದು ಕಾರ್ಯವನ್ನು ರಚಿಸುತ್ತದೆ alice_handler - ನಾವು ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಹೊಂದಿಸಿದಾಗ Yandex.Cloud ಅನ್ನು ಎಳೆಯಲು ನಾವು ಆದೇಶಿಸಿದ್ದೇವೆ --entrypoint=main.alice_handler.

ಅದು, ವಾಸ್ತವವಾಗಿ, ಅಷ್ಟೆ. ನಿರ್ಮಾಣಕ್ಕಾಗಿ ಮೇಕ್‌ಫೈಲ್‌ಗಳು, ಸಂದರ್ಭ ಸಂಗ್ರಹಣೆಗಾಗಿ S3 ತರಹದ ವಸ್ತು ಸಂಗ್ರಹಣೆ ಮತ್ತು ಪೈಥಾನ್ ಲೈಬ್ರರಿ tgalice. ಪೈಥಾನ್‌ನ ಸರ್ವರ್‌ಲೆಸ್ ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು ಅಭಿವ್ಯಕ್ತಿಶೀಲತೆಯೊಂದಿಗೆ, ಆರೋಗ್ಯವಂತ ವ್ಯಕ್ತಿಯ ಕೌಶಲ್ಯವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಇದು ಸಾಕು.

ನೀವು ಏಕೆ ರಚಿಸಬೇಕು ಎಂದು ನೀವು ಕೇಳಬಹುದು tgalice? JSON ಗಳನ್ನು ವಿನಂತಿಯಿಂದ ಪ್ರತಿಕ್ರಿಯೆಗೆ ಮತ್ತು ಸಂಗ್ರಹಣೆಯಿಂದ ಮೆಮೊರಿಗೆ ಮತ್ತು ಹಿಂದಕ್ಕೆ ವರ್ಗಾಯಿಸುವ ಎಲ್ಲಾ ಬೋರಿಂಗ್ ಕೋಡ್ ಅದರಲ್ಲಿದೆ. ನಿಯಮಿತ ಅಪ್ಲಿಕೇಶನ್ ಸಹ ಇದೆ, "ಫೆಬ್ರವರಿ" "ಫೆಬ್ರವರಿ" ಅನ್ನು ಹೋಲುತ್ತದೆ ಎಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಒಂದು ಕಾರ್ಯ, ಮತ್ತು ಬಡವರಿಗೆ ಇತರ NLU. ನನ್ನ ಕಲ್ಪನೆಯ ಪ್ರಕಾರ, ತಾಂತ್ರಿಕ ವಿವರಗಳಿಂದ ಹೆಚ್ಚು ವಿಚಲಿತರಾಗದೆ yaml ಫೈಲ್‌ಗಳಲ್ಲಿ ಕೌಶಲ್ಯ ಮೂಲಮಾದರಿಗಳನ್ನು ಸ್ಕೆಚ್ ಮಾಡಲು ಇದು ಈಗಾಗಲೇ ಸಾಕಷ್ಟು ಆಗಿರಬೇಕು.

ನೀವು ಹೆಚ್ಚು ಗಂಭೀರವಾದ NLU ಬಯಸಿದರೆ, ನೀವು ಅದನ್ನು ನಿಮ್ಮ ಕೌಶಲ್ಯಕ್ಕೆ ತಿರುಗಿಸಬಹುದು ರಾಸ ಅಥವಾ ಡೀಪ್ ಪಾವ್ಲೋವ್, ಆದರೆ ಅವುಗಳನ್ನು ಹೊಂದಿಸಲು ಟಾಂಬೊರಿನ್‌ನೊಂದಿಗೆ ಹೆಚ್ಚುವರಿ ನೃತ್ಯದ ಅಗತ್ಯವಿರುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಸರ್ವರ್‌ಲೆಸ್‌ನಲ್ಲಿ. ನಿಮಗೆ ಕೋಡಿಂಗ್ ಮಾಡಲು ಇಷ್ಟವಿಲ್ಲದಿದ್ದರೆ, ನೀವು ದೃಶ್ಯ ಪ್ರಕಾರದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಬಳಸಬೇಕು ಐಮಿಲಾಜಿಕ್. Tgalice ರಚಿಸುವಾಗ, ನಾನು ಕೆಲವು ರೀತಿಯ ಮಧ್ಯಂತರ ಮಾರ್ಗದ ಬಗ್ಗೆ ಯೋಚಿಸಿದೆ. ಏನಾಗುತ್ತದೆ ಎಂದು ನೋಡೋಣ.

ಸರಿ, ಈಗ ಸೇರಿಕೊಳ್ಳಿ ಅಲಿ ಕೌಶಲ್ಯ ಡೆವಲಪರ್ ಚಾಟ್, ಓದಿ ದಸ್ತಾವೇಜನ್ನುಮತ್ತು ಅದ್ಭುತವನ್ನು ರಚಿಸಿ ಕೌಶಲ್ಯಗಳು!

ಮೂಲ: www.habr.com