ફોસ્ટ પર પૃષ્ઠભૂમિ કાર્યો, ભાગ I: પરિચય

હું આવું કેવી રીતે જીવવા આવ્યો?

થોડા સમય પહેલા મને એક ખૂબ જ લોડ થયેલ પ્રોજેક્ટના બેકએન્ડ પર કામ કરવાનું હતું, જેમાં જટિલ ગણતરીઓ અને તૃતીય-પક્ષ સેવાઓ માટેની વિનંતીઓ સાથે મોટી સંખ્યામાં પૃષ્ઠભૂમિ કાર્યોના નિયમિત અમલને ગોઠવવું જરૂરી હતું. પ્રોજેક્ટ અસુમેળ છે અને હું આવ્યો તે પહેલાં, તેમાં ક્રોન-લોન્ચિંગ કાર્યો માટે એક સરળ પદ્ધતિ હતી: વર્તમાન સમયની તપાસ કરતી લૂપ અને કોરોટીન્સના જૂથોને ભેગી કરીને લોન્ચ કરવા - આ અભિગમ સ્વીકાર્ય બન્યો જ્યાં સુધી ડઝનેક અને સેંકડો આવા કોરોટીન ન હતા. જો કે, જ્યારે તેમની સંખ્યા બે હજારને વટાવી ગઈ, ત્યારે મારે બ્રોકર, ઘણા કામદારો વગેરે સાથે સામાન્ય કાર્ય કતાર ગોઠવવાનું વિચારવું પડ્યું.

પહેલા મેં સેલેરી અજમાવવાનું નક્કી કર્યું, જેનો મેં પહેલા ઉપયોગ કર્યો હતો. પ્રોજેક્ટની અસુમેળ પ્રકૃતિને લીધે, મેં પ્રશ્નમાં ડૂબકી મારી અને જોયું એક લેખ, અને પ્રોજેક્ટ, લેખના લેખક દ્વારા બનાવવામાં આવેલ.

હું આ કહીશ, પ્રોજેક્ટ ખૂબ જ રસપ્રદ છે અને અમારી ટીમની અન્ય એપ્લિકેશનોમાં ખૂબ સફળતાપૂર્વક કાર્ય કરે છે, અને લેખક પોતે કહે છે કે તે અસુમેળ પૂલનો ઉપયોગ કરીને તેને ઉત્પાદનમાં રોલ આઉટ કરવામાં સક્ષમ હતો. પરંતુ, કમનસીબે, તે ખરેખર મને અનુકૂળ ન હતું, કારણ કે તે બહાર આવ્યું છે સમસ્યા કાર્યોના જૂથ લોન્ચ સાથે (જુઓ. જૂથ). લેખન સમયે મુદ્દો પહેલેથી જ બંધ છે, જો કે એક મહિનાથી કામ ચાલી રહ્યું છે. કોઈ પણ સંજોગોમાં, લેખકને શુભકામનાઓ અને સર્વશ્રેષ્ઠ, કારણ કે લિબ પર પહેલેથી જ કાર્યકારી વસ્તુઓ છે... સામાન્ય રીતે, મુદ્દો મારામાં છે અને સાધન મારા માટે ભીનું બન્યું. વધુમાં, કેટલાક કાર્યોમાં વિવિધ સેવાઓ માટે 2-3 HTTP વિનંતીઓ હતી, તેથી કાર્યોને ઑપ્ટિમાઇઝ કરતી વખતે પણ, અમે 4 હજાર TCP કનેક્શન બનાવીએ છીએ, લગભગ દર 2 કલાકે - બહુ સારું નથી... હું એક પ્રકારનું સત્ર બનાવવા માંગુ છું કામદારો શરૂ કરતી વખતે કાર્ય. aiohttp દ્વારા મોટી સંખ્યામાં વિનંતીઓ વિશે થોડું વધુ અહીં.

આ સંદર્ભે, મેં જોવાનું શરૂ કર્યું વિકલ્પો અને તે મળ્યું! સેલરિના નિર્માતાઓ, ખાસ કરીને, હું તેને સમજું છું સોલેમને પૂછો, બનાવવામાં આવી હતી Faust, મૂળ પ્રોજેક્ટ માટે રોબિન હૂડ. ફોસ્ટ કાફકા સ્ટ્રીમ્સથી પ્રેરિત છે અને કાફકા સાથે બ્રોકર તરીકે કામ કરે છે, rocksdb નો ઉપયોગ એજન્ટોના કામના પરિણામોને સંગ્રહિત કરવા માટે પણ થાય છે અને સૌથી મહત્વની બાબત એ છે કે લાઇબ્રેરી અસુમેળ છે.

પણ, તમે જોઈ શકો છો ઝડપી સરખામણી બાદમાંના નિર્માતાઓ તરફથી સેલરી અને ફોસ્ટ: તેમના તફાવતો, દલાલો વચ્ચેના તફાવતો, પ્રારંભિક કાર્યનો અમલ. બધું એકદમ સરળ છે, જો કે, ફોસ્ટમાં એક સરસ સુવિધા ધ્યાન આકર્ષિત કરે છે - વિષય પર ટ્રાન્સમિશન માટે ટાઇપ કરેલ ડેટા.

આપણે શું કરીએ?

તેથી, લેખોની ટૂંકી શ્રેણીમાં, હું તમને બતાવીશ કે ફોસ્ટનો ઉપયોગ કરીને પૃષ્ઠભૂમિ કાર્યોમાંથી ડેટા કેવી રીતે એકત્રિત કરવો. અમારા ઉદાહરણ પ્રોજેક્ટ માટેનો સ્ત્રોત હશે, જેમ કે નામ સૂચવે છે, alphavantage.co. હું બતાવીશ કે એજન્ટો (સિંક, વિષયો, પાર્ટીશનો) કેવી રીતે લખવા, નિયમિત (ક્રોન) એક્ઝેક્યુશન કેવી રીતે કરવું, સૌથી અનુકૂળ ફૉસ્ટ ક્લિ કમાન્ડ્સ (એક રેપર ઓવર ક્લિક), સરળ ક્લસ્ટરિંગ, અને અંતે અમે ડેટાડોગ જોડીશું ( બોક્સની બહાર કામ કરો) અને કંઈક જોવાનો પ્રયાસ કરો. એકત્રિત ડેટા સંગ્રહિત કરવા માટે અમે કનેક્શન માટે mongodb અને મોટરનો ઉપયોગ કરીશું.

પીએસ જે આત્મવિશ્વાસ સાથે મોનિટરિંગ વિશેનો મુદ્દો લખવામાં આવ્યો હતો તેના આધારે, મને લાગે છે કે છેલ્લા લેખના અંતે વાચક હજી પણ કંઈક આના જેવો દેખાશે:

પ્રોજેક્ટ જરૂરિયાતો

એ હકીકતને કારણે કે મેં પહેલેથી જ વચન આપ્યું છે, ચાલો સેવા શું કરવા સક્ષમ હોવી જોઈએ તેની એક નાની સૂચિ બનાવીએ:

1. સિક્યોરિટીઝ અને તેનું વિહંગાવલોકન અપલોડ કરો (નફા અને નુકસાન, બેલેન્સ શીટ, રોકડ પ્રવાહ - છેલ્લા વર્ષ માટે) - નિયમિતપણે
2. ઐતિહાસિક ડેટા અપલોડ કરો (દરેક ટ્રેડિંગ વર્ષ માટે, ટ્રેડિંગની બંધ કિંમતના આત્યંતિક મૂલ્યો શોધો) - નિયમિતપણે
3. નવીનતમ ટ્રેડિંગ ડેટા અપલોડ કરો - નિયમિતપણે
4. દરેક સુરક્ષા માટે સૂચકોની કસ્ટમાઇઝ્ડ યાદી અપલોડ કરો - નિયમિતપણે

અપેક્ષા મુજબ, અમે શરૂઆતથી પ્રોજેક્ટ માટે નામ પસંદ કરીએ છીએ: હોર્ટોન

અમે ઈન્ફ્રાસ્ટ્રક્ચર તૈયાર કરી રહ્યા છીએ

શીર્ષક ચોક્કસપણે મજબૂત છે, જો કે, તમારે ફક્ત કાફકા (અને ઝૂકીપર - એક કન્ટેનરમાં), કાફડ્રોપ (જો આપણે વિષયોમાં સંદેશાઓ જોવા માંગતા હોય), મોંગોડબી સાથે ડોકર-કંપોઝ માટે એક નાનું રૂપરેખા લખવાની જરૂર છે. અમને મળે છે [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

અહીં બિલકુલ જટિલ નથી. કાફકા માટે બે શ્રોતાઓ જાહેર કરવામાં આવ્યા હતા: એક (આંતરિક) સંયુક્ત નેટવર્કની અંદર ઉપયોગ માટે, અને બીજો (બાહ્ય) બહારથી વિનંતીઓ માટે, તેથી તેઓએ તેને બહાર ફોરવર્ડ કર્યો. 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 *

*મેં નોંધ્યું બધું અમે હજી સુધી તેને સ્પર્શતા નથી, અમે ખાલી ફાઇલો બનાવીએ છીએ.**

અમે એક માળખું બનાવ્યું. હવે ચાલો જરૂરી નિર્ભરતાઓ ઉમેરીએ, રૂપરેખા લખીએ અને mongodb થી કનેક્ટ કરીએ. હું લેખમાં ફાઇલોનો સંપૂર્ણ ટેક્સ્ટ પ્રદાન કરીશ નહીં, જેથી તેમાં વિલંબ ન થાય, પરંતુ હું જરૂરી સંસ્કરણોની લિંક્સ પ્રદાન કરીશ.

ચાલો પ્રોજેક્ટ વિશે નિર્ભરતા અને મેટા સાથે પ્રારંભ કરીએ - pyproject.toml

આગળ, અમે નિર્ભરતા સ્થાપિત કરવાનું અને વર્ચ્યુઅલેનવ બનાવવાનું શરૂ કરીએ છીએ (અથવા તમે venv ફોલ્ડર જાતે બનાવી શકો છો અને પર્યાવરણને સક્રિય કરી શકો છો):

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

હવે ચાલો બનાવીએ config.yml - ઓળખપત્રો અને ક્યાં કઠણ કરવું. તમે તરત જ ત્યાં આલ્ફાવન્ટેજ માટે ડેટા મૂકી શકો છો. સારું, ચાલો આગળ વધીએ config.py - અમારી રૂપરેખામાંથી એપ્લિકેશન માટે ડેટા કાઢો. હા, હું કબૂલ કરું છું, મેં મારા લિબનો ઉપયોગ કર્યો - સિત્રિ.

મોંગો સાથે કનેક્ટ કરતી વખતે, બધું એકદમ સરળ છે. જાહેરાત કરી ગ્રાહક વર્ગ જોડવા માટે અને આધાર વર્ગ ક્રુડ્સ માટે, સંગ્રહો પર પ્રશ્નો બનાવવાનું સરળ બનાવવા માટે.

આગળ શું થશે?

લેખ બહુ લાંબો નથી, કારણ કે અહીં હું ફક્ત પ્રેરણા અને તૈયારી વિશે વાત કરી રહ્યો છું, તેથી મને દોષ ન આપો - હું વચન આપું છું કે આગળના ભાગમાં ક્રિયા અને ગ્રાફિક્સ હશે.

તેથી, આ જ આગળના ભાગમાં આપણે:

1. ચાલો aiohttp પર આલ્ફાવેન્ટેજ માટે એક નાનો ક્લાયંટ લખીએ અને આપણને જરૂરી એન્ડપોઈન્ટની વિનંતીઓ સાથે.
2. ચાલો એક એજન્ટ બનાવીએ જે તેમના માટે સિક્યોરિટીઝ અને ઐતિહાસિક કિંમતોનો ડેટા એકત્રિત કરશે.

પ્રોજેક્ટ કોડ

આ ભાગ માટે કોડ

સોર્સ: www.habr.com