Yandex.Cloud ਅਤੇ Python ਦੇ ਸਰਵਰ ਰਹਿਤ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਐਲਿਸ ਲਈ ਇੱਕ ਰਾਜਕੀ ਹੁਨਰ ਬਣਾਉਣਾ

ਆਓ ਖ਼ਬਰਾਂ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰੀਏ. ਕੱਲ੍ਹ Yandex.Cloud ਨੇ ਇੱਕ ਸਰਵਰ ਰਹਿਤ ਕੰਪਿਊਟਿੰਗ ਸੇਵਾ ਦੀ ਸ਼ੁਰੂਆਤ ਦੀ ਘੋਸ਼ਣਾ ਕੀਤੀ ਯਾਂਡੇਕਸ ਕਲਾਊਡ ਫੰਕਸ਼ਨ. ਇਸਦਾ ਅਰਥ ਹੈ: ਤੁਸੀਂ ਸਿਰਫ ਆਪਣੀ ਸੇਵਾ ਲਈ ਕੋਡ ਲਿਖਦੇ ਹੋ (ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨ ਜਾਂ ਇੱਕ ਚੈਟਬੋਟ), ਅਤੇ ਕਲਾਉਡ ਖੁਦ ਹੀ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਦੀ ਸਾਂਭ-ਸੰਭਾਲ ਕਰਦਾ ਹੈ ਜਿੱਥੇ ਇਹ ਚੱਲਦਾ ਹੈ, ਅਤੇ ਲੋਡ ਵਧਣ 'ਤੇ ਉਹਨਾਂ ਦੀ ਨਕਲ ਵੀ ਕਰਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਬਿਲਕੁਲ ਸੋਚਣ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ, ਇਹ ਬਹੁਤ ਸੁਵਿਧਾਜਨਕ ਹੈ। ਅਤੇ ਭੁਗਤਾਨ ਸਿਰਫ ਗਣਨਾ ਦੇ ਸਮੇਂ ਲਈ ਹੈ.

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

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

ਨੈਤਿਕ ਤਿਆਰੀ

ਬੇਸਬਰੀ ਲਈ: ਮੈਂ ਕਲਾਉਡ 'ਤੇ ਫੰਕਸ਼ਨ ਨੂੰ ਅਪਲੋਡ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਮੇਕਫਾਈਲ ਨਾਲ ਲੋੜੀਂਦੀ ਨਿਰਭਰਤਾ ਇਕੱਠੀ ਕਰਦਾ ਹਾਂ, ਮੈਂ ਡਾਇਲਾਗ ਦੀ ਸਥਿਤੀ ਨੂੰ ਯਾਂਡੇਕਸ ਆਬਜੈਕਟ ਸਟੋਰੇਜ (ਇਹ S3 API ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ) ਵਿੱਚ ਸਟੋਰ ਕਰਦਾ ਹਾਂ, ਅਤੇ ਮੈਂ ਡਾਇਲਾਗ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਆਪਣੀ ਖੁਦ ਦੀ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹਾਂ tgalice. ਅੰਤ ਵਿੱਚ ਇਹ ਬਾਹਰ ਕਾਮੁਕ ਅਜਿਹੇ ਇੱਕ ਡੈਮੋ ਹੁਨਰ. ਆਓ ਹੁਣ ਇਸ ਸਭ ਨੂੰ ਥੋੜਾ ਹੋਰ ਵਿਸਥਾਰ ਵਿੱਚ ਵੇਖੀਏ.

ਉਹਨਾਂ ਲਈ ਜੋ ਥੋੜੇ ਘੱਟ ਬੇਸਬਰੇ ਹਨ, ਜਟਿਲਤਾ ਬਾਰੇ ਮੇਰੀ ਕਹਾਣੀ ਵਿੱਚ ਗੋਤਾਖੋਰੀ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਮੈਂ ਕਿਸੇ ਸਧਾਰਨ ਚੀਜ਼ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਜ਼ੋਰਦਾਰ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ. ਅਰਥਾਤ, ਇੱਕ ਸਿੰਗਲ-ਫਾਈਲ ਈਕੋਬੋਟ ਫੰਕਸ਼ਨ ਬਣਾਓ, ਇਸਨੂੰ ਡਾਇਲਾਗ ਡਿਵੈਲਪਰ ਕੰਸੋਲ ਵਿੱਚ ਰਜਿਸਟਰ ਕਰੋ ਅਤੇ ਟੈਸਟ ਕਰੋ; ਵੇਰਵੇ - ਵਿੱਚ ਸੰਵਾਦ ਬਲੌਗ и ਕਲਾਉਡ ਦਸਤਾਵੇਜ਼. ਅਤੇ ਕੇਵਲ ਤਦ ਹੀ ਸ਼ੁਰੂ.

ਜੇ ਤੁਸੀਂ ਤੁਰੰਤ ਮਹਿਸੂਸ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਅਸੀਂ ਇੱਥੇ ਕਿਸ ਲਈ ਲੜ ਰਹੇ ਹਾਂ, ਤਾਂ ਐਲਿਸ ਨੂੰ ਪੁੱਛੋ'"IT ਕੁੰਡਲੀ" ਹੁਨਰ ਨੂੰ ਸਮਰੱਥ ਬਣਾਓ'। ਹੇਠ ਲਿਖੇ ਸਮਾਨ ਸੰਵਾਦ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ:

ਐਲਿਸ: ਹੈਲੋ! ਤੁਸੀਂ "IT ਕੁੰਡਲੀ" ਹੁਨਰ ਵਿੱਚ ਹੋ। ਇਹ ਪਤਾ ਲਗਾਉਣ ਲਈ "ਸ਼ੁਰੂ ਕਰੋ" ਕਹੋ ਕਿ ਤਾਰੇ ਤੁਹਾਡੇ ਨਾਲ ਕੀ ਵਾਅਦਾ ਕਰਦੇ ਹਨ।
ਉਪਭੋਗਤਾ: ਸ਼ੁਰੂ ਕਰੋ
ਜਵਾਬ: ਕਿਰਪਾ ਕਰਕੇ ਆਪਣਾ ਨਾਮ ਦੱਸੋ
ਯੂ: ਵਸੀਸੁਅਲੀ
ਜਵਾਬ: ਹੁਣ ਮੈਨੂੰ ਆਪਣੇ ਜਨਮ ਦਾ ਸਾਲ ਦੱਸੋ। ਸਿਰਫ਼ ਚਾਰ ਅੰਕ, ਵਾਧੂ ਕੁਝ ਨਹੀਂ।
ਯੂ: ਦੂਜਾ
A: ਕਿਰਪਾ ਕਰਕੇ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰੋ। ਆਪਣੇ ਜਨਮ ਦਾ ਸਾਲ ਦਰਜ ਕਰੋ - ਚਾਰ ਅੰਕ।
ਯੂ: 2002
A: ਬਹੁਤ ਵਧੀਆ! ਹੁਣ ਆਪਣੇ ਜਨਮ ਦੇ ਮਹੀਨੇ ਦਾ ਨਾਮ ਰੱਖੋ।
ਯੂ: ਫਰਵਰੀ
A: ਬਹੁਤ ਵਧੀਆ! ਅੰਤ ਵਿੱਚ, ਮੈਨੂੰ ਆਪਣੀ ਜਨਮ ਮਿਤੀ ਦੱਸੋ - ਸਿਰਫ਼ ਇੱਕ ਨੰਬਰ, ਸਿਰਫ਼ ਇੱਕ ਜਾਂ ਦੋ ਅੰਕ।
ਯੂ: 18
A: ਤੁਹਾਡਾ ਧੰਨਵਾਦ, ਵਸੀਸੁਅਲੀ! ਹੁਣ ਅਸੀਂ ਜਾਣਦੇ ਹਾਂ: ਤੁਹਾਡੀ ਉਮਰ 17 ਸਾਲ ਹੈ ਅਤੇ ਇੱਕ ਕੁੰਭ ਹੈ। ਖੈਰ, ਬੇਸ਼ਕ, ਤੁਸੀਂ ਖੁਸ਼ਕਿਸਮਤ ਹੋ! ਤਾਰੇ ਤੁਹਾਨੂੰ ਦੱਸਦੇ ਹਨ: а что говорят звёзды, вы узнаете, запустив навык.

ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਅਜਿਹੇ ਸਧਾਰਨ ਸੰਵਾਦ ਨੂੰ ਕਾਇਮ ਰੱਖਣ ਲਈ, ਤੁਹਾਨੂੰ ਉਪਭੋਗਤਾ ਦਾ ਨਾਮ ਅਤੇ ਜਨਮ ਮਿਤੀ ਯਾਦ ਰੱਖਣ ਦੀ ਲੋੜ ਹੈ, ਅਤੇ ਇੱਕ ਸਰਵਰ ਰਹਿਤ ਫੰਕਸ਼ਨ ਵਾਤਾਵਰਨ ਵਿੱਚ ਇਹ ਗੈਰ-ਮਾਮੂਲੀ ਹੈ। ਸੰਦਰਭ ਨੂੰ RAM ਵਿੱਚ ਜਾਂ ਡਿਸਕ ਉੱਤੇ ਇੱਕ ਫਾਈਲ ਦੇ ਰੂਪ ਵਿੱਚ ਸਟੋਰ ਕਰਨਾ ਸੰਭਵ ਨਹੀਂ ਹੋਵੇਗਾ, ਕਿਉਂਕਿ Yandex.Cloud ਇੱਕੋ ਸਮੇਂ ਕਈ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ 'ਤੇ ਇੱਕ ਫੰਕਸ਼ਨ ਚਲਾ ਸਕਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਵਿਚਕਾਰ ਆਪਣੀ ਮਰਜ਼ੀ ਨਾਲ ਬਦਲ ਸਕਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਕਿਸੇ ਕਿਸਮ ਦੀ ਬਾਹਰੀ ਸਟੋਰੇਜ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਪਵੇਗੀ। ਆਬਜੈਕਟ ਸਟੋਰੇਜ ਨੂੰ ਸਿੱਧੇ Yandex.Cloud ਵਿੱਚ ਇੱਕ ਕਾਫ਼ੀ ਸਸਤੀ ਅਤੇ ਗੁੰਝਲਦਾਰ ਸਟੋਰੇਜ ਵਜੋਂ ਚੁਣਿਆ ਗਿਆ ਸੀ (ਅਰਥਾਤ, ਸ਼ਾਇਦ ਤੇਜ਼)। ਇੱਕ ਮੁਫਤ ਵਿਕਲਪ ਵਜੋਂ, ਤੁਸੀਂ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹੋ, ਉਦਾਹਰਣ ਲਈ, ਇੱਕ ਮੁਫਤ ਟੁਕੜਾ ਬੱਦਲਵਾਈ ਮੋਂਗਾ ਕਿਤੇ ਦੂਰ. ਆਬਜੈਕਟ ਸਟੋਰੇਜ (ਜੋ S3 ਇੰਟਰਫੇਸ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ) ਅਤੇ ਮੋਂਗੋ ਦੋਵਾਂ ਲਈ ਸੁਵਿਧਾਜਨਕ ਪਾਈਥਨ ਰੈਪਰ ਹਨ।

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

ਕੁੰਡਲੀ ਦੇ ਹੁਨਰ ਨੂੰ ਕਿਵੇਂ ਸ਼ੁਰੂ ਕਰਨਾ ਹੈ

1. ਤਿਆਰ ਕਰੋ: ਲੀਨਕਸ ਨਾਲ ਕਿਸੇ ਮਸ਼ੀਨ 'ਤੇ ਜਾਓ। ਸਿਧਾਂਤ ਵਿੱਚ, ਤੁਸੀਂ ਸ਼ਾਇਦ ਵਿੰਡੋਜ਼ ਦੇ ਨਾਲ ਵੀ ਕੰਮ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਫਿਰ ਤੁਹਾਨੂੰ ਮੇਕਫਾਈਲ ਨੂੰ ਲਾਂਚ ਕਰਨ ਦੇ ਨਾਲ ਕੁਝ ਜਾਦੂ ਕਰਨਾ ਪਵੇਗਾ। ਅਤੇ ਕਿਸੇ ਵੀ ਸਥਿਤੀ ਵਿੱਚ, ਤੁਹਾਨੂੰ ਘੱਟੋ ਘੱਟ ਪਾਇਥਨ 3.6 ਸਥਾਪਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ.
2. ਇਸ ਨੂੰ ਗਿਥਬ ਤੋਂ ਕਲੋਨ ਕਰੋ ਕੁੰਡਲੀ ਹੁਨਰ ਦੀ ਉਦਾਹਰਨ.
3. Y.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, ਇਸ ਲਈ ਯਾਂਡੇਕਸ ਫੰਕਸ਼ਨਾਂ 'ਤੇ ਇੱਕ ਹੁਨਰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਸਿੱਧੀ ਸਕ੍ਰਿਪਟ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ:

...
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? ਸਾਰੇ ਬੋਰਿੰਗ ਕੋਡ ਜੋ JSONs ਨੂੰ ਬੇਨਤੀ ਤੋਂ ਜਵਾਬ ਤੱਕ ਅਤੇ ਸਟੋਰੇਜ ਤੋਂ ਮੈਮੋਰੀ ਅਤੇ ਬੈਕ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰਦੇ ਹਨ ਇਸ ਵਿੱਚ ਹਨ। ਇੱਥੇ ਇੱਕ ਨਿਯਮਤ ਕੋਡ ਐਪਲੀਕੇਸ਼ਨ ਵੀ ਹੈ, ਇਹ ਸਮਝਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਕਿ “ਫਰਵਰੀ” “ਫਰਵਰੀ” ਦੇ ਸਮਾਨ ਹੈ, ਅਤੇ ਗਰੀਬਾਂ ਲਈ ਹੋਰ NLU। ਮੇਰੇ ਵਿਚਾਰ ਦੇ ਅਨੁਸਾਰ, ਇਹ ਪਹਿਲਾਂ ਹੀ ਕਾਫ਼ੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਤਕਨੀਕੀ ਵੇਰਵਿਆਂ ਦੁਆਰਾ ਬਹੁਤ ਜ਼ਿਆਦਾ ਧਿਆਨ ਭਟਕਾਏ ਬਿਨਾਂ yaml ਫਾਈਲਾਂ ਵਿੱਚ ਹੁਨਰਾਂ ਦੇ ਪ੍ਰੋਟੋਟਾਈਪਾਂ ਨੂੰ ਸਕੈਚ ਕਰ ਸਕੋ.

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

ਖੈਰ, ਹੁਣ ਸ਼ਾਮਲ ਹੋਵੋ ਐਲਿਸ ਸਕਿੱਲ ਡਿਵੈਲਪਰ ਚੈਟ, ਪੜ੍ਹੋ ਦਸਤਾਵੇਜ਼, ਅਤੇ ਸ਼ਾਨਦਾਰ ਬਣਾਓ ਹੁਨਰ!

ਸਰੋਤ: www.habr.com