កិច្ចការផ្ទៃខាងក្រោយនៅលើ Faust, ផ្នែកទី I: ការណែនាំ

ម៉េចក៏ខ្ញុំមករស់នៅបែបនេះ?

មិនយូរប៉ុន្មានខ្ញុំត្រូវធ្វើការលើផ្នែកខាងក្រោយនៃគម្រោងដែលមានបន្ទុកខ្ពស់ ដែលក្នុងនោះចាំបាច់ត្រូវរៀបចំការប្រតិបត្តិជាប្រចាំនៃកិច្ចការផ្ទៃខាងក្រោយមួយចំនួនធំជាមួយនឹងការគណនាស្មុគស្មាញ និងសំណើសម្រាប់សេវាកម្មភាគីទីបី។ គម្រោងនេះគឺអសមកាល ហើយមុនពេលដែលខ្ញុំមក វាមានយន្តការសាមញ្ញមួយសម្រាប់កិច្ចការចាប់ផ្តើម cron៖ រង្វិលជុំពិនិត្យមើលពេលវេលាបច្ចុប្បន្ន និងការបើកដំណើរការក្រុមនៃ coroutines តាមរយៈការប្រមូលផ្តុំ - វិធីសាស្រ្តនេះបានប្រែទៅជាអាចទទួលយកបានរហូតដល់មានទម្លាប់បែបនេះរាប់សិបនិងរាប់រយ។ ទោះយ៉ាងណាក៏ដោយ នៅពេលដែលចំនួនរបស់ពួកគេលើសពីពីរពាន់ ខ្ញុំត្រូវគិតអំពីការរៀបចំជួរកិច្ចការធម្មតាជាមួយមេខ្យល់ កម្មករជាច្រើននាក់ជាដើម។

ដំបូងខ្ញុំសម្រេចចិត្តសាកល្បងប្រើ Celery ដែលខ្ញុំធ្លាប់ប្រើពីមុនមក។ ដោយសារលក្ខណៈអសមកាលនៃគម្រោង ខ្ញុំបានចូលទៅក្នុងសំណួរ ហើយបានឃើញ អត្ថបទ, និង គម្រោងបង្កើតឡើងដោយអ្នកនិពន្ធអត្ថបទ។

ខ្ញុំនឹងនិយាយរឿងនេះ គម្រោងនេះគួរឱ្យចាប់អារម្មណ៍ណាស់ ហើយដំណើរការយ៉ាងជោគជ័យនៅក្នុងកម្មវិធីផ្សេងទៀតនៃក្រុមរបស់យើង ហើយអ្នកនិពន្ធផ្ទាល់បាននិយាយថាគាត់អាចរមៀលវាចូលទៅក្នុងផលិតកម្មដោយប្រើអាងអសមកាល។ ប៉ុន្តែជាអកុសល វាពិតជាមិនសមនឹងខ្ញុំទេ ដូចដែលវាបានប្រែក្លាយ បញ្ហា ជាមួយនឹងការចាប់ផ្តើមការងារជាក្រុម (សូមមើល។ ក្រុម) នៅពេលសរសេរ issue ត្រូវបានបិទរួចហើយ ប៉ុន្តែការងារបានបន្តអស់រយៈពេលមួយខែ។ ក្នុងករណីណាក៏ដោយ សូមសំណាងល្អដល់អ្នកនិពន្ធ និងអ្វីៗដែលល្អបំផុត ព្រោះមានការងាររួចហើយនៅលើ lib... ជាទូទៅ ចំនុចគឺនៅក្នុងខ្ញុំ ហើយឧបករណ៍ប្រែទៅជាសើមសម្រាប់ខ្ញុំ។ លើសពីនេះ កិច្ចការមួយចំនួនមានសំណើ 2-3 http ទៅកាន់សេវាកម្មផ្សេងៗគ្នា ដូច្នេះសូម្បីតែនៅពេលបង្កើនប្រសិទ្ធភាពការងារ យើងបង្កើតការតភ្ជាប់ TCP ចំនួន 4 ពាន់ ប្រហែលរៀងរាល់ 2 ម៉ោងម្តង - មិនល្អទេ... ខ្ញុំចង់បង្កើតវគ្គសម្រាប់ប្រភេទមួយ ភារកិច្ចនៅពេលចាប់ផ្តើមកម្មករ។ បន្តិចបន្ថែមទៀតអំពីចំនួនដ៏ធំនៃសំណើតាមរយៈ aiohttp នៅទីនេះ.

ក្នុងន័យនេះខ្ញុំចាប់ផ្តើមមើល ជម្មើសជំនួស ហើយបានរកឃើញវា! អ្នកបង្កើត celery ជាពិសេសដូចដែលខ្ញុំយល់ សួរ Solem, ត្រូវ​បាន​បង្កើត​ឡើង Faustដើមឡើយសម្រាប់គម្រោង ភាពសាហាវ. Faust ត្រូវបានបំផុសគំនិតដោយ Kafka Stream និងធ្វើការជាមួយ Kafka ក្នុងនាមជាឈ្មួញកណ្តាល Rocksdb ក៏ត្រូវបានប្រើដើម្បីរក្សាទុកលទ្ធផលពីការងាររបស់ភ្នាក់ងារ ហើយអ្វីដែលសំខាន់បំផុតនោះគឺថាបណ្ណាល័យគឺអសមកាល។

អ្នកក៏អាចមើលផងដែរ។ ការប្រៀបធៀបរហ័ស celery និង faust ពីអ្នកបង្កើតក្រោយ: ភាពខុសគ្នារបស់ពួកគេ ភាពខុសគ្នារវាងឈ្មួញកណ្តាល ការអនុវត្តកិច្ចការបឋម។ អ្វីគ្រប់យ៉ាងគឺសាមញ្ញណាស់ទោះជាយ៉ាងណា លក្ខណៈពិសេសដ៏ល្អមួយនៅក្នុង faust ទាក់ទាញការយកចិត្តទុកដាក់ - ទិន្នន័យដែលបានវាយបញ្ចូលសម្រាប់ការបញ្ជូនទៅកាន់ប្រធានបទ។

តើ​យើង​ធ្វើអ្វី?

ដូច្នេះ នៅក្នុងអត្ថបទខ្លីៗ ខ្ញុំនឹងបង្ហាញអ្នកពីរបៀបប្រមូលទិន្នន័យពីកិច្ចការផ្ទៃខាងក្រោយដោយប្រើ Faust ។ ប្រភពសម្រាប់គម្រោងឧទាហរណ៍របស់យើងនឹងមានដូចដែលឈ្មោះបានបង្ហាញ alphavantage.co. ខ្ញុំនឹងបង្ហាញពីរបៀបសរសេរភ្នាក់ងារ (លិច ប្រធានបទ ភាគថាស) របៀបអនុវត្តធម្មតា (cron) ពាក្យបញ្ជា faust cli ដែលងាយស្រួលបំផុត (រុំពីលើការចុច) ការដាក់ចង្កោមសាមញ្ញ ហើយនៅចុងបញ្ចប់យើងនឹងភ្ជាប់ datadog ( ធ្វើការចេញពីប្រអប់) ហើយព្យាយាមមើលអ្វីមួយ។ ដើម្បីរក្សាទុកទិន្នន័យដែលប្រមូលបាន យើងនឹងប្រើ mongodb និងម៉ូទ័រសម្រាប់ភ្ជាប់។

PS វិនិច្ឆ័យដោយទំនុកចិត្តដែលចំណុចអំពីការត្រួតពិនិត្យត្រូវបានសរសេរខ្ញុំគិតថាអ្នកអាននៅចុងបញ្ចប់នៃអត្ថបទចុងក្រោយនឹងនៅតែមើលទៅដូចនេះ:

តម្រូវការគម្រោង

ដោយសារ​តែ​ខ្ញុំ​បាន​សន្យា​រួច​ហើយ សូម​ធ្វើ​បញ្ជី​តូច​មួយ​អំពី​អ្វី​ដែល​សេវាកម្ម​គួរ​ធ្វើ៖

1. បង្ហោះមូលបត្រ និងទិដ្ឋភាពទូទៅនៃពួកគេ (រួមទាំងប្រាក់ចំណេញ និងការបាត់បង់ តារាងតុល្យការ លំហូរសាច់ប្រាក់ - សម្រាប់ឆ្នាំមុន) - ទៀងទាត់
2. ផ្ទុកឡើងទិន្នន័យប្រវត្តិសាស្រ្ត (សម្រាប់ឆ្នាំជួញដូរនីមួយៗ ស្វែងរកតម្លៃខ្លាំងនៃតម្លៃបិទនៃការជួញដូរ) - ទៀងទាត់
3. បង្ហោះទិន្នន័យជួញដូរចុងក្រោយបំផុត - ទៀងទាត់
4. បង្ហោះបញ្ជីសូចនាករតាមតម្រូវការសម្រាប់សុវត្ថិភាពនីមួយៗ - ជាទៀងទាត់

ដូចដែលបានរំពឹងទុក យើងជ្រើសរើសឈ្មោះសម្រាប់គម្រោងពីដំបូង៖ ហ័រតុន

យើងកំពុងរៀបចំហេដ្ឋារចនាសម្ព័ន្ធ

ចំណងជើងពិតជាខ្លាំង ទោះជាយ៉ាងណាក៏ដោយ អ្វីដែលអ្នកត្រូវធ្វើគឺសរសេរការកំណត់តូចមួយសម្រាប់ docker-compose ជាមួយ kafka (និង zookeeper - នៅក្នុងធុងតែមួយ) kafdrop (ប្រសិនបើយើងចង់មើលសារក្នុងប្រធានបទ) mongodb។ យើង​ទទួល​បាន [docker-compose.yml](https://github.com/Egnod/horton/blob/562fa5ec14df952cd74760acf76e141707d2ef58/docker-compose.yml) នៃទម្រង់ខាងក្រោម៖

version: '3'

services:
  db:
    container_name: horton-mongodb-local
    image: mongo:4.2-bionic
    command: mongod --port 20017
    restart: always
    ports:
      - 20017:20017
    environment:
      - MONGO_INITDB_DATABASE=horton
      - MONGO_INITDB_ROOT_USERNAME=admin
      - MONGO_INITDB_ROOT_PASSWORD=admin_password

  kafka-service:
    container_name: horton-kafka-local
    image: obsidiandynamics/kafka
    restart: always
    ports:
      - "2181:2181"
      - "9092:9092"
    environment:
      KAFKA_LISTENERS: "INTERNAL://:29092,EXTERNAL://:9092"
      KAFKA_ADVERTISED_LISTENERS: "INTERNAL://kafka-service:29092,EXTERNAL://localhost:9092"
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: "INTERNAL:PLAINTEXT,EXTERNAL:PLAINTEXT"
      KAFKA_INTER_BROKER_LISTENER_NAME: "INTERNAL"
      KAFKA_ZOOKEEPER_SESSION_TIMEOUT: "6000"
      KAFKA_RESTART_ATTEMPTS: "10"
      KAFKA_RESTART_DELAY: "5"
      ZOOKEEPER_AUTOPURGE_PURGE_INTERVAL: "0"

  kafdrop:
    container_name: horton-kafdrop-local
    image: 'obsidiandynamics/kafdrop:latest'
    restart: always
    ports:
      - '9000:9000'
    environment:
      KAFKA_BROKERCONNECT: kafka-service:29092
    depends_on:
      - kafka-service

មិនមានអ្វីស្មុគស្មាញនៅទីនេះទាល់តែសោះ។ អ្នកស្តាប់ពីរនាក់ត្រូវបានប្រកាសសម្រាប់ kafka: មួយ (ខាងក្នុង) សម្រាប់ប្រើនៅខាងក្នុងបណ្តាញសមាសធាតុ និងទីពីរ (ខាងក្រៅ) សម្រាប់សំណើពីខាងក្រៅ ដូច្នេះពួកគេបានបញ្ជូនវាទៅខាងក្រៅ។ 2181 - កំពង់ផែសួនសត្វ។ នៅសល់ ខ្ញុំគិតថាច្បាស់ហើយ។

ការរៀបចំគ្រោងឆ្អឹងនៃគម្រោង

នៅក្នុងកំណែមូលដ្ឋាន រចនាសម្ព័ន្ធនៃគម្រោងរបស់យើងគួរតែមើលទៅដូចនេះ៖

horton
├── docker-compose.yml
└── horton
    ├── agents.py *
    ├── alphavantage.py *
    ├── app.py *
    ├── config.py
    ├── database
    │   ├── connect.py
    │   ├── cruds
    │   │   ├── base.py
    │   │   ├── __init__.py
    │   │   └── security.py *
    │   └── __init__.py
    ├── __init__.py
    ├── records.py *
    └── tasks.py *

*អ្វីគ្រប់យ៉ាងដែលខ្ញុំបានកត់សម្គាល់ យើងមិនទាន់ប៉ះវាទេ យើងគ្រាន់តែបង្កើតឯកសារទទេ។**

យើងបានបង្កើតរចនាសម្ព័ន្ធ។ ឥឡូវនេះ ចូរយើងបន្ថែមភាពអាស្រ័យចាំបាច់ សរសេរ config ហើយភ្ជាប់ទៅ mongodb ។ ខ្ញុំនឹងមិនផ្តល់អត្ថបទពេញលេញនៃឯកសារនៅក្នុងអត្ថបទនោះទេ ដើម្បីកុំឱ្យពន្យារពេល ប៉ុន្តែខ្ញុំនឹងផ្តល់តំណភ្ជាប់ទៅកាន់កំណែចាំបាច់។

ចូរចាប់ផ្តើមជាមួយភាពអាស្រ័យ និងមេតាអំពីគម្រោង - pyproject.toml

បន្ទាប់មក យើងចាប់ផ្តើមដំឡើងភាពអាស្រ័យ និងបង្កើត virtualenv (ឬអ្នកអាចបង្កើតថត venv ដោយខ្លួនឯង និងធ្វើឱ្យបរិស្ថានសកម្ម)៖

pip3 install poetry (если ещё не установлено)
poetry install

ឥឡូវនេះសូមបង្កើត config.yml - លិខិតសម្គាល់និងកន្លែងដែលត្រូវគោះ។ អ្នកអាចដាក់ទិន្នន័យសម្រាប់ alphavantage នៅទីនោះភ្លាមៗ។ អញ្ចឹងតោះបន្តទៅ config.py - ស្រង់ទិន្នន័យសម្រាប់កម្មវិធីពីការកំណត់របស់យើង។ បាទ ខ្ញុំសារភាព ខ្ញុំបានប្រើ lib របស់ខ្ញុំ - អង្គុយ.

នៅពេលភ្ជាប់ទៅម៉ុងហ្គោ អ្វីគ្រប់យ៉ាងគឺសាមញ្ញណាស់។ បានប្រកាស ថ្នាក់អតិថិជន ដើម្បីភ្ជាប់និង ថ្នាក់មូលដ្ឋាន សម្រាប់ cruds ដើម្បីធ្វើឱ្យវាកាន់តែងាយស្រួលក្នុងការធ្វើសំណួរលើបណ្តុំ។

តើនឹងមានអ្វីកើតឡើងបន្ទាប់?

អត្ថបទមិនយូរប៉ុន្មានទេ ព្រោះនៅទីនេះខ្ញុំគ្រាន់តែនិយាយអំពីការលើកទឹកចិត្ត និងការរៀបចំ ដូច្នេះកុំបន្ទោសខ្ញុំអី ខ្ញុំសន្យាថាផ្នែកបន្ទាប់នឹងមានសកម្មភាព និងក្រាហ្វិក។

ដូច្នេះនៅក្នុងផ្នែកបន្ទាប់នេះ យើង:

1. ចូរយើងសរសេរកម្មវិធីតូចមួយសម្រាប់ alphavantage នៅលើ aiohttp ជាមួយនឹងសំណើសម្រាប់ចំណុចបញ្ចប់ដែលយើងត្រូវការ។
2. តោះបង្កើតភ្នាក់ងារដែលនឹងប្រមូលទិន្នន័យស្តីពីមូលបត្រ និងតម្លៃប្រវត្តិសាស្ត្រសម្រាប់ពួកគេ។

កូដគម្រោង

លេខកូដសម្រាប់ផ្នែកនេះ។

ប្រភព: www.habr.com