Yandex.Cloud, Python എന്നിവയുടെ സെർവർലെസ് ഫംഗ്‌ഷനുകളിൽ ആലീസിനായി ഒരു സ്‌റ്റേറ്റ്‌ഫുൾ സ്‌കിൽ സൃഷ്‌ടിക്കുന്നു

വാർത്തയിൽ നിന്ന് തുടങ്ങാം. ഇന്നലെ Yandex.Cloud ഒരു സെർവർലെസ് കമ്പ്യൂട്ടിംഗ് സേവനത്തിന്റെ സമാരംഭം പ്രഖ്യാപിച്ചു Yandex ക്ലൗഡ് പ്രവർത്തനങ്ങൾ. ഇതിനർത്ഥം: നിങ്ങൾ നിങ്ങളുടെ സേവനത്തിന്റെ കോഡ് മാത്രമേ എഴുതുകയുള്ളൂ (ഉദാഹരണത്തിന്, ഒരു വെബ് ആപ്ലിക്കേഷൻ അല്ലെങ്കിൽ ഒരു ചാറ്റ്ബോട്ട്), കൂടാതെ ക്ലൗഡ് തന്നെ അത് പ്രവർത്തിക്കുന്നിടത്ത് വെർച്വൽ മെഷീനുകൾ സൃഷ്ടിക്കുകയും പരിപാലിക്കുകയും ചെയ്യുന്നു, കൂടാതെ ലോഡ് വർദ്ധിക്കുകയാണെങ്കിൽ അവ ആവർത്തിക്കുകയും ചെയ്യുന്നു. നിങ്ങൾ ഒട്ടും ചിന്തിക്കേണ്ടതില്ല, ഇത് വളരെ സൗകര്യപ്രദമാണ്. കൂടാതെ പേയ്‌മെന്റ് കണക്കുകൂട്ടലുകളുടെ സമയത്തേക്ക് മാത്രം പോകുന്നു.

എന്നിരുന്നാലും, ചിലർക്ക് പണം നൽകണമെന്നില്ല. ഇവരാണ് ഡെവലപ്പർമാർ ആലീസിന്റെ ബാഹ്യ കഴിവുകൾ, അതായത്, അതിൽ നിർമ്മിച്ച ചാറ്റ്ബോട്ടുകൾ. ഏതൊരു ഡവലപ്പർക്കും അത്തരമൊരു വൈദഗ്ദ്ധ്യം എഴുതാനും ഹോസ്റ്റ് ചെയ്യാനും രജിസ്റ്റർ ചെയ്യാനും കഴിയും, ഇന്ന് മുതൽ കഴിവുകൾ ഹോസ്റ്റ് ചെയ്യേണ്ടതില്ല - ഫോമിൽ അവരുടെ കോഡ് ക്ലൗഡിലേക്ക് അപ്‌ലോഡ് ചെയ്യുക അതേ സെർവർലെസ് ഫംഗ്‌ഷൻ.

എന്നാൽ കുറച്ച് സൂക്ഷ്മതകളുണ്ട്. ഒന്നാമതായി, നിങ്ങളുടെ വളർത്തുമൃഗങ്ങളുടെ കോഡിന് ചില ഡിപൻഡൻസികൾ ആവശ്യമായി വന്നേക്കാം, അവയെ ക്ലൗഡിലേക്ക് വലിച്ചിടുന്നത് നിസ്സാരമല്ല. രണ്ടാമതായി, ഏതൊരു സാധാരണ ചാറ്റ്‌ബോട്ടിനും ഡയലോഗിന്റെ അവസ്ഥ എവിടെയെങ്കിലും സൂക്ഷിക്കേണ്ടതുണ്ട് (അതിനാൽ വ്യവസ്ഥാപിതമാണ്); സെർവർലെസ് ഫംഗ്‌ഷനിൽ ഏറ്റവും എളുപ്പമുള്ള രീതിയിൽ ഇത് എങ്ങനെ ചെയ്യാം? മൂന്നാമതായി, പൂജ്യമല്ലാത്ത പ്ലോട്ടുള്ള ആലീസിനോ അല്ലെങ്കിൽ ഏതെങ്കിലും തരത്തിലുള്ള ബോട്ടിനോ വേണ്ടി നിങ്ങൾക്ക് എങ്ങനെ പെട്ടെന്നുള്ളതും വൃത്തികെട്ടതുമായ കഴിവ് എഴുതാനാകും? ഈ സൂക്ഷ്മതകളെക്കുറിച്ച്, വാസ്തവത്തിൽ, ലേഖനം.

ധാർമ്മിക തയ്യാറെടുപ്പ്

അക്ഷമരായവർക്കായി: ഫംഗ്‌ഷൻ ക്ലൗഡിലേക്ക് അപ്‌ലോഡ് ചെയ്യുന്നതിന് മുമ്പ് ആവശ്യമായ ഡിപൻഡൻസികൾ ഞാൻ ഒരു മേക്ക്‌ഫൈൽ ഉപയോഗിച്ച് ശേഖരിക്കുന്നു, ഡയലോഗിന്റെ അവസ്ഥ ഞാൻ Yandex Object Storage-ൽ സംഭരിക്കുന്നു (ഇത് S3 API-യെ പിന്തുണയ്ക്കുന്നു), ഡയലോഗ് നിയന്ത്രിക്കാൻ ഞാൻ എന്റെ സ്വന്തം ലൈബ്രറി ഉപയോഗിക്കുന്നു tgalice. തത്ഫലമായി, അത് മാറുന്നു അത്തരമൊരു ഡെമോ വൈദഗ്ദ്ധ്യം. ഇനി ഇതെല്ലാം കുറച്ചുകൂടി വിശദമായി വിശകലനം ചെയ്യാം.

അൽപ്പം അക്ഷമയുള്ളവർക്ക്, സങ്കീർണ്ണതയുടെ എന്റെ കഥയിലേക്ക് കടക്കുന്നതിനുമുമ്പ്, ലളിതമായി ആരംഭിക്കാൻ ഞാൻ വളരെ ശുപാർശ ചെയ്യുന്നു. അതായത്, ഒരു സിംഗിൾ-ഫയൽ എക്കോബോട്ട് ഫംഗ്‌ഷൻ സൃഷ്‌ടിക്കുക, ഡയലോഗ് ഡെവലപ്പർ കൺസോളിൽ രജിസ്‌റ്റർ ചെയ്‌ത് പരീക്ഷിക്കുക; വിശദാംശങ്ങൾ - ഇൻ ബ്ലോഗ് ഡയലോഗുകൾ и ക്ലൗഡ് ഡോക്യുമെന്റേഷൻ. എന്നിട്ട് മാത്രമേ തുടങ്ങൂ.

ഞങ്ങൾ എന്തിനാണ് പോരാടുന്നതെന്ന് നിങ്ങൾക്ക് ഉടനടി അനുഭവപ്പെടണമെങ്കിൽ, ആലീസിനോട് ചോദിക്കുക."ഐടി ജാതകം" എന്ന വൈദഗ്ദ്ധ്യം ഓണാക്കുക'. ഇനിപ്പറയുന്ന സംഭാഷണം നടക്കണം:

ആലീസ്: ഹലോ! നിങ്ങൾ "ഐടി ജാതകം" കഴിവിലാണ്. നക്ഷത്രങ്ങൾ നിങ്ങൾക്ക് എന്താണ് വാഗ്ദാനം ചെയ്യുന്നതെന്ന് കണ്ടെത്താൻ "ആരംഭിക്കുക" എന്ന് പറയുക.
ഉപയോക്താവ്: ആരംഭിക്കുക
ഉത്തരം: ദയവായി നിങ്ങളുടെ പേര് പറയുക.
യു: വസിഷുവലി
ഉത്തരം: ഇപ്പോൾ നിങ്ങളുടെ ജനന വർഷം പറയൂ. നാല് അക്കങ്ങൾ മാത്രം, കൂടുതലൊന്നുമില്ല.
യു: രണ്ടാമത്
A: ദയവായി വീണ്ടും ശ്രമിക്കുക. നിങ്ങളുടെ ജനന വർഷം പ്രസ്താവിക്കുക - നാല് അക്കങ്ങൾ.
യു: 2002
ഒരു വലിയ! ഇപ്പോൾ നിങ്ങൾ ജനിച്ച മാസത്തിന് പേര് നൽകുക.
യു: ഫെബ്രുവരി
എ: മികച്ചത്! അവസാനമായി, നിങ്ങളുടെ ജനനത്തീയതി എന്നോട് പറയൂ - ഒരു സംഖ്യ, ഒന്നോ രണ്ടോ അക്കങ്ങൾ മാത്രം.
യു: 18
എ: നന്ദി, വസിഷ്വൽ! ഇപ്പോൾ ഞങ്ങൾക്കറിയാം: നിങ്ങൾക്ക് 17 വയസ്സായി, നിങ്ങൾ ഒരു അക്വേറിയസ് ആണ്. ഇവിടെ നിങ്ങൾ തീർച്ചയായും ഭാഗ്യവാനാണ്! നക്ഷത്രങ്ങൾ നിങ്ങളോട് പറയുന്നു а что говорят звёзды, вы узнаете, запустив навык.

അത്തരമൊരു ലളിതമായ ഡയലോഗ് പോലും നിലനിർത്താൻ, ഉപയോക്താവിന്റെ പേരും ജനനത്തീയതിയും നിങ്ങൾ ഓർമ്മിക്കേണ്ടതുണ്ട് എന്നതാണ് പ്രശ്നം, കൂടാതെ സെർവർ ഇല്ലാത്ത അന്തരീക്ഷത്തിൽ ഇത് നിസ്സാരമല്ല. സന്ദർഭം റാമിലോ ഡിസ്കിൽ ഒരു ഫയലായോ സംഭരിക്കുന്നതിന് ഇത് പ്രവർത്തിക്കില്ല, കാരണം Yandex.Cloud-ന് ഒരേ സമയം നിരവധി വെർച്വൽ മെഷീനുകളിൽ പ്രവർത്തനം പ്രവർത്തിപ്പിക്കാനും അവയ്ക്കിടയിൽ ഏകപക്ഷീയമായി മാറാനും കഴിയും. നിങ്ങൾ ഏതെങ്കിലും തരത്തിലുള്ള ബാഹ്യ സംഭരണം ഉപയോഗിക്കേണ്ടതുണ്ട്. ഒബ്ജക്റ്റ് സ്റ്റോറേജ് Yandex.Cloud-ൽ നേരിട്ട് വളരെ ചെലവുകുറഞ്ഞതും ലളിതവുമായ സംഭരണമായി തിരഞ്ഞെടുത്തു (അതായത്, വേഗതയേറിയതാണ്). ഒരു സ്വതന്ത്ര ബദലായി, നിങ്ങൾക്ക് ശ്രമിക്കാം, ഉദാഹരണത്തിന്, ഒരു സ്വതന്ത്ര കഷണം മേഘാവൃതമായ മോംഗി ദൂരെ എവിടെയോ. ഒബ്ജക്റ്റ് സ്റ്റോറേജിനായി (ഇത് എസ് 3 ഇന്റർഫേസിനെ പിന്തുണയ്ക്കുന്നു), മോംഗോയ്ക്ക് സൗകര്യപ്രദമായ പൈത്തൺ റാപ്പറുകൾ ഉണ്ട്.

മറ്റൊരു പ്രശ്നം, ഒബ്ജക്റ്റ് സ്റ്റോറേജ്, മോംഗോഡിബി, മറ്റേതെങ്കിലും ഡാറ്റാബേസ് അല്ലെങ്കിൽ ഡാറ്റ സ്റ്റോർ എന്നിവയിലേക്ക് പോകുന്നതിന്, നിങ്ങളുടെ ഫംഗ്ഷൻ കോഡിനൊപ്പം Yandex ഫംഗ്ഷനുകളിലേക്ക് അപ്‌ലോഡ് ചെയ്യേണ്ട ചില ബാഹ്യ ഡിപൻഡൻസികൾ ആവശ്യമാണ്. ഒപ്പം അത് സുഖകരമായി ചെയ്യാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഇത് പൂർണ്ണമായും സൗകര്യപ്രദമാണ് (ഹീറോകുവിൽ പോലെ), അയ്യോ, ഇത് പ്രവർത്തിക്കില്ല, എന്നാൽ പരിസ്ഥിതി നിർമ്മിക്കുന്നതിന് (ഫയൽ ഉണ്ടാക്കുക) ഒരു സ്ക്രിപ്റ്റ് എഴുതി നിങ്ങൾക്ക് ചില അടിസ്ഥാന സൗകര്യങ്ങൾ സൃഷ്ടിക്കാൻ കഴിയും.

ജാതക വൈദഗ്ദ്ധ്യം എങ്ങനെ ആരംഭിക്കാം

1. തയ്യാറാകൂ: Linux ഉപയോഗിച്ച് കുറച്ച് മെഷീനിലേക്ക് പോകുക. തത്വത്തിൽ, നിങ്ങൾക്ക് വിൻഡോസിലും പ്രവർത്തിക്കാൻ കഴിയും, എന്നാൽ നിങ്ങൾ മേക്ക്ഫയലിന്റെ സമാരംഭവുമായി ആലോചിക്കേണ്ടതുണ്ട്. ഏത് സാഹചര്യത്തിലും, നിങ്ങൾക്ക് കുറഞ്ഞത് 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

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഈ കോഡിന്റെ ഭൂരിഭാഗവും ഒബ്ജക്റ്റ് സ്റ്റോറേജ് എസ് 3 ഇന്റർഫേസിലേക്ക് ഒരു കണക്ഷൻ സൃഷ്ടിക്കുന്നു. ഈ കണക്ഷൻ എങ്ങനെയാണ് നേരിട്ട് ഉപയോഗിക്കുന്നത്, നിങ്ങൾക്ക് വായിക്കാം tgalice കോഡിൽ.
അവസാന വരി ഒരു ഫംഗ്ഷൻ സൃഷ്ടിക്കുന്നു alice_handler - ഞങ്ങൾ പാരാമീറ്റർ സജ്ജീകരിക്കുമ്പോൾ Yandex.Cloud വലിക്കാൻ ഞങ്ങൾ ഓർഡർ ചെയ്ത ഒന്ന് --entrypoint=main.alice_handler.

വാസ്തവത്തിൽ, അതാണ് എല്ലാം. നിർമ്മാണത്തിനുള്ള മേക്ക് ഫയലുകൾ, സന്ദർഭ സംഭരണത്തിനായി S3 പോലെയുള്ള ഒബ്ജക്റ്റ് സ്റ്റോറേജ്, ഒരു പൈത്തൺ ലൈബ്രറി tgalice. പൈത്തണിന്റെ സെർവർലെസ് സവിശേഷതകളും പ്രകടനശേഷിയും കൂടിച്ചേർന്ന്, ആരോഗ്യമുള്ള ഒരു വ്യക്തിയുടെ കഴിവ് വികസിപ്പിക്കാൻ ഇത് മതിയാകും.

എന്തുകൊണ്ടാണ് നിങ്ങൾ സൃഷ്ടിക്കേണ്ടതെന്ന് നിങ്ങൾ ചോദിച്ചേക്കാം tgalice? അഭ്യർത്ഥനയിൽ നിന്ന് പ്രതികരണത്തിലേക്കും സ്റ്റോറേജിൽ നിന്ന് മെമ്മറിയിലേക്കും പിന്നിലേക്കും JSON-കളെ കൈമാറുന്ന എല്ലാ ബോറിങ് കോഡും അതിലാണ്. ഒരു സാധാരണ എക്സ്പ്രഷൻ ആപ്ലിക്കേഷനും ഉണ്ട്, "ഫെബ്രുവരി" എന്നത് "ഫെബ്രുവരി" എന്നതിന് സമാനമാണെന്ന് മനസ്സിലാക്കുന്നതിനുള്ള ഒരു ഫംഗ്ഷൻ, കൂടാതെ പാവപ്പെട്ടവർക്ക് മറ്റ് NLU. എന്റെ ആശയം അനുസരിച്ച്, സാങ്കേതിക വിശദാംശങ്ങളിൽ നിന്ന് ശ്രദ്ധ തിരിക്കാതെ yaml ഫയലുകളിൽ നൈപുണ്യ പ്രോട്ടോടൈപ്പുകൾ വരയ്ക്കാൻ ഇത് ഇതിനകം തന്നെ മതിയാകും.

നിങ്ങൾക്ക് കൂടുതൽ ഗൗരവമേറിയ NLU വേണമെങ്കിൽ, നിങ്ങളുടെ വൈദഗ്ധ്യത്തിലേക്ക് അത് സ്ക്രൂ ചെയ്യാൻ കഴിയും രസാ അഥവാ ഡീപ്പാവ്ലോവ്, എന്നാൽ അവ സജ്ജീകരിക്കുന്നതിന് ടാംബോറിനോടൊപ്പം അധിക നൃത്തം ആവശ്യമാണ്, പ്രത്യേകിച്ച് സെർവർലെസ്. നിങ്ങൾക്ക് കോഡിംഗ് ചെയ്യാൻ തോന്നുന്നില്ലെങ്കിൽ, നിങ്ങൾ വിഷ്വൽ തരം കൺസ്ട്രക്റ്റർ ഉപയോഗിക്കണം എമിലോജിക്. Tgalice സൃഷ്ടിക്കുമ്പോൾ, ഒരുതരം ഇന്റർമീഡിയറ്റ് പാതയെക്കുറിച്ച് ഞാൻ ചിന്തിച്ചു. എന്താണ് സംഭവിക്കുന്നതെന്ന് നോക്കാം.

ശരി, ഇപ്പോൾ ചേരുക അലിയ് സ്‌കിൽ ഡെവലപ്പർ ചാറ്റ്, വായിക്കുക പ്രമാണീകരണംഒപ്പം അത്ഭുതകരമായ സൃഷ്ടിക്കും കഴിവുകൾ!

അവലംബം: www.habr.com