Tarantool እጅግ በጣም ፈጣን የሆነ የውሂብ ጎታ እና አፕሊኬሽን ከነሱ ጋር አብሮ ለመስራት ይፈቅድልሃል። ይህን ማድረግ ቀላል ነው

ከአምስት አመት በፊት ከ Tarantool ጋር ለመስራት ሞከርኩኝ, ግን ከዚያ በኋላ ለእኔ አልሰራም. ግን በቅርቡ ስለ Hadoop እና MapReduce እንዴት እንደሚሰራ የተናገርኩበት ዌቢናር አደረግሁ። እዚያም አንድ ጥያቄ ጠየቁኝ፡- “ለምን Tarantoolን ለዚህ ተግባር አትጠቀምበትም?”

ከጉጉት የተነሳ ወደ እሱ ለመመለስ ወሰንኩኝ, የቅርብ ጊዜውን ስሪት ለመሞከር - እና በዚህ ጊዜ ፕሮጀክቱን በጣም ወድጄዋለሁ. አሁን በ Tarantool ውስጥ ቀላል አፕሊኬሽን እንዴት እንደሚጽፉ አሳይዎታለሁ, ይጫኑት እና አፈፃፀሙን ያረጋግጡ, እና ሁሉም ነገር ምን ያህል ቀላል እና ቀዝቃዛ እንደሆነ ያያሉ.

Tarantool ምንድን ነው?

Tarantool እራሱን እንደ እጅግ በጣም ፈጣን የውሂብ ጎታ አድርጎ ያስቀምጣል። የሚፈልጉትን ማንኛውንም ውሂብ እዚያ ማስቀመጥ ይችላሉ. በተጨማሪም ፣ እነሱን ይድገሙ ፣ shard - ማለትም ፣ ብዙ መጠን ያለው ውሂብ በበርካታ አገልጋዮች ላይ ይከፋፍሉ እና ውጤቶቹን ከነሱ ያጣምሩ - ስህተትን የሚቋቋም ዋና-ዋና ግንኙነቶችን ያድርጉ።

በሁለተኛ ደረጃ, ይህ የመተግበሪያ አገልጋይ ነው. ማመልከቻዎችዎን በእሱ ላይ መጻፍ, ከውሂብ ጋር መስራት, ለምሳሌ, በተወሰኑ ህጎች መሰረት የድሮ መዝገቦችን ከበስተጀርባ መሰረዝ ይችላሉ. ከውሂብ ጋር የሚሰራ የኤችቲቲፒ አገልጋይ በቀጥታ በ Tarantula ውስጥ መፃፍ ይችላሉ-ብዛታቸውን ይስጡ ፣ እዚያ አዲስ ውሂብ ይፃፉ እና ሁሉንም ወደ ጌታው ይቀንሱ።

ወንዶቹ 300 መስመሮችን የያዘ የመልእክት ወረፋ እንዳደረጉ የሚገልጽ ጽሑፍ አነበብኩ፣ ይህም በቀላሉ የሚፈነዳ እና የሚጣደፈው - ቢያንስ ቢያንስ 20 መልዕክቶች በሰከንድ አላቸው። እዚህ በጣም ትልቅ አፕሊኬሽን መዞር እና መፃፍ ይችላሉ፣ እና እንደ PostgreS ማከማቻ አይሆንም።

በዚህ ጽሑፍ ውስጥ እንደዚህ ያለ አገልጋይ ፣ ቀላል ብቻ ፣ የሆነ ነገር ለመግለጽ እሞክራለሁ።

ቅንብር

ለፈተናው፣ ሶስት መደበኛ ቨርቹዋል ማሽኖችን ጀመርኩ - ባለ 20 ጂቢ ሃርድ ድራይቭ፣ ኡቡንቱ 18.04። 2 ምናባዊ ሲፒዩዎች እና 4 ጊጋዎች የማህደረ ትውስታ።

Tarantool ን እንጭነዋለን - የ bash ስክሪፕት እናሰራለን ወይም ማከማቻ እንጨምራለን እና Tarantool ን እንጭነዋለን። ወደ ስክሪፕት ማገናኘት - (curl -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash)። እንደዚህ ያሉ ትዕዛዞች አሉን:

tarantoolctl - የ Tarantula ምሳሌዎችን ለማስተዳደር ዋናው ትእዛዝ።
/ወዘተ/tarantool - አጠቃላይ ውቅር እዚህ አለ።
var / log / tarantool - ምዝግብ ማስታወሻዎቹ እዚህ አሉ።
var/lib/tarantool - ውሂቡ እዚህ አለ ፣ እና ከዚያ ወደ ምሳሌዎች ተከፍሏል።

በአቃፊዎች ለምሳሌ የሚገኙ እና ለምሳሌ የሚቻሉ - የሚጀመረውን ይይዛል - የምሳሌ ማዋቀር ፋይል ከሉአ ኮድ ጋር፣ የትኛውን ወደቦች እንደሚያዳምጥ፣ ምን ማህደረ ትውስታ እንደሚገኝለት የሚገልጽ፣ የቪኒል ሞተር ቅንጅቶች፣ ሲጀመር የሚሰራ ኮድ ሰርቨሮች፣ ሻርዲንግ፣ ወረፋዎች፣ ጊዜ ያለፈበት ውሂብ መሰረዝ እና የመሳሰሉት።

ምሳሌዎች እንደ PostgreS ይሰራሉ። ለምሳሌ በተለያዩ ወደቦች ላይ የሚሰቀል የውሂብ ጎታ ብዙ ቅጂዎችን ማሄድ ትፈልጋለህ። በተለያዩ ወደቦች ላይ የሚንጠለጠሉ በርካታ የመረጃ ቋቶች በአንድ አገልጋይ ላይ ተጀምረዋል ። ሙሉ ለሙሉ የተለያዩ ቅንብሮች ሊኖራቸው ይችላል - አንድ ምሳሌ አንድ ሎጂክን ይተገብራል, ሁለተኛው - ሌላ.

የምሳሌ አስተዳደር

የ Tarantula ምሳሌዎችን ለመቆጣጠር የሚያስችል የ tarantoolctl ትዕዛዝ አለን. ለምሳሌ የ tarantoolctl ቼክ ምሳሌ የውቅረት ፋይሉን ይፈትሻል እና ይላል - እዚያ ምንም የአገባብ ስህተቶች ከሌሉ ፋይሉ ደህና ነው።

የምሳሌውን ሁኔታ ማየት ይችላሉ - tarantoolctl ሁኔታ ምሳሌ። በተመሳሳይ መንገድ መጀመር, ማቆም, እንደገና መጀመር ይችላሉ.

አንዴ ምሳሌ እየሄደ ከሆነ፣ በሁለት መንገዶች ማገናኘት ይችላሉ።

1. የአስተዳደር ኮንሶል

በነባሪነት Tarantool ሶኬት ይከፍታል፣ Tarantoolን ለመቆጣጠር መደበኛ የASCII ጽሑፍ ወደዚያ ይላካል። ከኮንሶል ጋር ያለው ግንኙነት ሁል ጊዜ በአስተዳዳሪው ተጠቃሚ ስር ነው የሚከሰተው, ምንም ማረጋገጫ የለም, ስለዚህ ታርታላ ለማስተዳደር የኮንሶል ወደብ ውጫዊ ማድረግ አያስፈልግም.

ይህንን ዘዴ በመጠቀም ለመገናኘት Tarantoolctl ያስገቡ ለምሳሌ ስም ያስገቡ። ትዕዛዙ ኮንሶሉን ያስነሳና እንደ አስተዳዳሪ ተጠቃሚ ይገናኛል። የኮንሶል ወደብ በጭራሽ አታጋልጥ - እንደ አንድ ክፍል ሶኬት መተው ይሻላል። ከዚያ ወደ ሶኬቱ ለመጻፍ መዳረሻ ያላቸው ብቻ ከታርታላ ጋር መገናኘት ይችላሉ.

ይህ ዘዴ ለአስተዳደራዊ ነገሮች ያስፈልጋል. ከመረጃ ጋር ለመስራት, ሁለተኛውን ዘዴ ይጠቀሙ - የሁለትዮሽ ፕሮቶኮል.

2. ከአንድ የተወሰነ ወደብ ጋር ለመገናኘት የሁለትዮሽ ፕሮቶኮልን መጠቀም

ውቅሩ ለውጫዊ ግንኙነቶች ወደብ የሚከፍት የማዳመጥ መመሪያ ይዟል። ይህ ወደብ ከሁለትዮሽ ፕሮቶኮል ጋር ጥቅም ላይ ይውላል እና ማረጋገጥ እዚያ ነቅቷል።

ለዚህ ግንኙነት፣ tarantoolctl ከወደብ ቁጥር ጋር መገናኘት ስራ ላይ ይውላል። እሱን በመጠቀም ከርቀት አገልጋዮች ጋር መገናኘት ፣ ማረጋገጫን መጠቀም እና የተለያዩ የመዳረሻ መብቶችን መስጠት ይችላሉ ።

የውሂብ ቀረጻ እና ሳጥን ሞዱል

Tarantool ሁለቱም የውሂብ ጎታ እና የመተግበሪያ አገልጋይ ስለሆነ, የተለያዩ ሞጁሎች አሉት. በሳጥኑ ሞጁል ላይ ፍላጎት አለን - ከውሂብ ጋር መስራትን ተግባራዊ ያደርጋል. አንድ ነገር ወደ ሳጥን ሲጽፉ ታራንቶል ውሂቡን ወደ ዲስክ ይጽፋል, በማህደረ ትውስታ ውስጥ ያከማቻል ወይም ሌላ ነገር በእሱ ላይ ያደርጋል.

መቅዳት

ለምሳሌ, ወደ ሳጥን ሞጁል ውስጥ እንገባለን እና ወደ box.once function ይደውሉ. ይህ አገልጋዩ ሲጀመር Tarantool የእኛን ኮድ እንዲያሄድ ያስገድደዋል። ውሂባችን የሚከማችበት ቦታ እንፈጥራለን።

local function bootstrap()
    local space = box.schema.create_space('example')
    space:create_index('primary')
    box.schema.user.grant('guest', 'read,write,execute', 'universe')

    -- Keep things safe by default
    --  box.schema.user.create('example', { password = 'secret' })
    --  box.schema.user.grant('example', 'replication')
    --  box.schema.user.grant('example', 'read,write,execute', 'space', 'example')
end

ከዚህ በኋላ, ውሂብ መፈለግ የምንችልበት ዋና መረጃ ጠቋሚ - ቀዳሚ - እንፈጥራለን. በነባሪነት ምንም አይነት መለኪያዎችን ካልገለጹ በእያንዳንዱ መዝገብ ውስጥ ያለው የመጀመሪያው መስክ ለዋና መረጃ ጠቋሚ ጥቅም ላይ ይውላል.

ከዚያ ለእንግዳ ተጠቃሚው ስጦታ እንሰራለን, በእሱ ስር በሁለትዮሽ ፕሮቶኮል በኩል እንገናኛለን. በአጠቃላይ ማንበብ፣ መጻፍ እና ማስፈጸምን እንፈቅዳለን።

ከተለምዷዊ የውሂብ ጎታዎች ጋር ሲነጻጸር, እዚህ ሁሉም ነገር በጣም ቀላል ነው. ቦታ አለን - ውሂባችን በቀላሉ የሚከማችበት አካባቢ። እያንዳንዱ መዝገብ tuple ይባላል። በ MessagePack ውስጥ የታሸገ ነው። ይህ በጣም አሪፍ ቅርጸት ነው - ሁለትዮሽ ነው እና ትንሽ ቦታ ይወስዳል - 18 ባይት ከ 27 ጋር።

ከእሱ ጋር ለመስራት በጣም ምቹ ነው. እያንዳንዱ መስመር ማለት ይቻላል፣ እያንዳንዱ የውሂብ መዝገብ ሙሉ ለሙሉ የተለያዩ አምዶች ሊኖረው ይችላል።

የBox.space ትዕዛዝን በመጠቀም ሁሉንም ቦታዎች ማየት እንችላለን። አንድን የተወሰነ ምሳሌ ለመምረጥ የBox.space ምሳሌን ይፃፉ እና ስለሱ የተሟላ መረጃ ያግኙ።

Tarantool ሁለት አብሮገነብ ሞተሮች አሉት: ማህደረ ትውስታ እና ቪኒል. ማህደረ ትውስታ ሁሉንም ውሂብ በማህደረ ትውስታ ውስጥ ያከማቻል። ስለዚህ, ሁሉም ነገር በቀላሉ እና በፍጥነት ይሰራል. ውሂቡ ወደ ዲስክ ተጥሏል፣ እና ወደፊት የመፃፍ ዘዴም አለ፣ ስለዚህ አገልጋዩ ከተበላሸ ምንም ነገር አናጣም።

ቪኒል መረጃን በዲስክ ላይ ለእኛ ይበልጥ በሚታወቅ ቅጽ ያከማቻል - ማለትም እኛ ካለን ማህደረ ትውስታ በላይ ብዙ መረጃዎችን ማከማቸት ይችላሉ እና ታራንቱላ ከዲስክ ያነበዋል።

ለአሁን ማህደረ ትውስታን እንጠቀማለን.

unix/:/var/run/tarantool/example.control> box.space.example
---
- engine: memtx
  before_replace: 'function: 0x41eb02c8'
  on_replace: 'function: 0x41eb0568'
  ck_constraint: []
  field_count: 0
  temporary: false
  index:
    0: &0
      unique: true
      parts:
      - type: unsigned
        is_nullable: false
        fieldno: 1
      id: 0
      space_id: 512
      type: TREE
      name: primary
    primary: *0
  is_local: false
  enabled: true
  name: example
  id: 512
...

unix/:/var/run/tarantool/example.control>

ማውጫ

ለማንኛውም ቦታ ዋና መረጃ ጠቋሚ መፈጠር አለበት, ምክንያቱም ያለሱ ምንም አይሰራም. እንደ ማንኛውም የውሂብ ጎታ, የመጀመሪያውን መስክ እንፈጥራለን - የመመዝገብ መታወቂያ.

ክፍሎች

እዚህ የእኛ ጠቋሚ ምን እንደሚያካትት እንጠቁማለን. አንድ ክፍልን ያቀፈ ነው - እኛ የምንጠቀመው የመጀመሪያው መስክ ዓይነት ያልተፈረመ ነው - አዎንታዊ ኢንቲጀር። ከሰነዱ እስከማስታውስ ድረስ, ከፍተኛው ቁጥር 18 ኩንታል ሊሆን ይችላል. ያ ብዙ ነው.

ከዚያ የማስገባት ትዕዛዙን በመጠቀም መረጃን ማስገባት እንችላለን።

unix/:/var/run/tarantool/example.control> box.space.example:insert{1, 'test1', 'test2'}
---
- [1, 'test1', 'test2']
...

unix/:/var/run/tarantool/example.control> box.space.example:insert{2, 'test2', 'test3', 'test4'}
---
- [2, 'test2', 'test3', 'test4']
...

unix/:/var/run/tarantool/example.control> box.space.example:insert{3, 'test3'}
---
- [3, 'test3']
...

unix/:/var/run/tarantool/example.control> box.space.example:insert{4, 'test4'}
---
- [4, 'test4']
...

unix/:/var/run/tarantool/example.control>

የመጀመሪያው መስክ እንደ ዋና ቁልፍ ጥቅም ላይ ይውላል, ስለዚህ ልዩ መሆን አለበት. በአምዶች ብዛት የተወሰንን አይደለንም, ስለዚህ የፈለግነውን ያህል ውሂብ እዚያ ውስጥ ማስገባት እንችላለን. ከላይ የገለጽኩት በመልእክት ፓክ ቅርጸት ነው የተገለጹት።

የውሂብ ውፅዓት

ከዚያ የመረጡትን ትዕዛዝ በመጠቀም ውሂቡን ማሳየት እንችላለን.

Box.example.ከ{1}ቁልፍ ጋር ምረጥ የሚፈለገውን ግቤት ያሳያል። ቁልፉን ዝቅ ካደረግን, ያለንን ሁሉንም መዝገቦች እናያለን. ሁሉም በአምዶች ብዛት ይለያያሉ, ግን እዚህ, በመርህ ደረጃ, የአምዶች ጽንሰ-ሀሳብ የለም - የመስክ ቁጥሮች አሉ.

ሙሉ በሙሉ የውሂብ መጠን ሊኖር ይችላል. እና ለምሳሌ, በሁለተኛው መስክ እነሱን መፈለግ አለብን. ይህንን ለማድረግ, አዲስ ሁለተኛ ደረጃ ኢንዴክስ እንፈጥራለን.

box.space.example:create_index( ‘secondary’, { type = ‘TREE’, unique = false, parts = {{field = 2, type =’string’} }}) 

የ Create_index ትዕዛዙን እንጠቀማለን።
ሁለተኛ ደረጃ እንበለው።

ከዚህ በኋላ መለኪያዎችን መግለጽ ያስፈልግዎታል. የመረጃ ጠቋሚው ዓይነት TREE ነው። ልዩ ላይሆን ይችላል፣ ስለዚህ ልዩ = ውሸት ያስገቡ።

ከዚያ የእኛ መረጃ ጠቋሚ ምን ክፍሎች እንዳሉ እንጠቁማለን. መስክ ኢንዴክስን የምናስርበት የመስክ ቁጥር ነው፣ እና የሕብረቁምፊውን አይነት ይግለጹ። ስለዚህም ተፈጠረ።

unix/:/var/run/tarantool/example.control> box.space.example:create_index('secondary', { type = 'TREE', unique = false, parts = {{field = 2, type = 'string'}}})
---
- unique: false
  parts:
  - type: string
    is_nullable: false
    fieldno: 2
  id: 1
  space_id: 512
  type: TREE
  name: secondary
...

unix/:/var/run/tarantool/example.control>

አሁን እንዲህ ብለን መጥራት እንችላለን፡-

unix/:/var/run/tarantool/example.control> box.space.example.index.secondary:select('test1')
---
- - [1, 'test1', 'test2']
...

መጠበቅ

ምሳሌውን እንደገና ከጀመርን እና ውሂቡን እንደገና ለመጥራት ከሞከርን ፣ እዚያ እንደሌለ እናያለን - ሁሉም ነገር ባዶ ነው። ይህ የሆነው Tarantool የፍተሻ ነጥቦችን ስለሚያደርግ እና ውሂቡን በዲስክ ላይ ስለሚያስቀምጥ ነው, ነገር ግን እስከሚቀጥለው ቆጣቢነት ድረስ መስራታችንን ካቆምን, ሁሉንም ስራዎች እናጣለን - ምክንያቱም ከመጨረሻው የፍተሻ ነጥብ እናገግማለን, ለምሳሌ, ከሁለት ሰዓታት በፊት.

በየሰከንዱ ለመቆጠብም አይሰራም ምክንያቱም ያለማቋረጥ 20 ጂቢ ወደ ዲስክ መጣል ጥሩ ሀሳብ አይደለም.

ለዚሁ ዓላማ, የመጻፊያ መዝገብ ጽንሰ-ሐሳብ ተፈለሰፈ እና ተተግብሯል. በእሱ እርዳታ, በመረጃው ላይ ላለው እያንዳንዱ ለውጥ, በትንሽ ጻፍ-ወደፊት የምዝግብ ማስታወሻ ፋይል ውስጥ ግቤት ይፈጠራል.

እስከ ፍተሻ ነጥቡ ድረስ ያለው እያንዳንዱ ግቤት በውስጣቸው ይከማቻል። ለእነዚህ ፋይሎች መጠኑን እናዘጋጃለን - ለምሳሌ, 64 ሜባ. ሲሞላ ቀረጻ ወደ ሁለተኛው ፋይል መሄድ ይጀምራል። እና ከዳግም ማስጀመር በኋላ ታራንቶል ከመጨረሻው የፍተሻ ነጥብ ወደነበረበት ይመለሳል እና እስኪቆም ድረስ ሁሉንም የኋለኛውን ግብይቶች ይሽከረከራል።

እንዲህ ዓይነቱን ቀረጻ ለማከናወን በbox.cfg ቅንብሮች (በ example.lua ፋይል) ውስጥ ያለውን አማራጭ መግለጽ ያስፈልግዎታል።

wal_mode = “write”;

የውሂብ አጠቃቀም

አሁን በጻፍነው ነገር መረጃን ለማከማቸት Tarantula ን መጠቀም ይችላሉ እና እንደ ዳታቤዝ በፍጥነት ይሰራል። እና አሁን በኬክ ላይ ያለው አይስክሬም ሁሉንም ነገር ማድረግ ይችላሉ.

ማመልከቻ በመጻፍ ላይ

ለምሳሌ፣ ለ Tarantula የሚከተለውን መተግበሪያ እንፃፍ

ማመልከቻውን በአበላሹ ስር ይመልከቱ

box.cfg {
    listen = '0.0.0.0:3301';
    io_collect_interval = nil;
    readahead = 16320;
    memtx_memory = 128 * 1024 * 1024; -- 128Mb
    memtx_min_tuple_size = 16;
    memtx_max_tuple_size = 128 * 1024 * 1024; -- 128Mb
    vinyl_memory = 128 * 1024 * 1024; -- 128Mb
    vinyl_cache = 128 * 1024 * 1024; -- 128Mb
    vinyl_max_tuple_size = 128 * 1024 * 1024; -- 128Mb
    vinyl_write_threads = 2;
    wal_mode = "write";
    wal_max_size = 256 * 1024 * 1024;
    checkpoint_interval = 60 * 60; -- one hour
    checkpoint_count = 6;
    force_recovery = true;
    log_level = 5;
    log_nonblock = false;
    too_long_threshold = 0.5;
    read_only   = false
}

local function bootstrap()
    local space = box.schema.create_space('example')
    space:create_index('primary')

    box.schema.user.create('example', { password = 'secret' })
    box.schema.user.grant('example', 'read,write,execute', 'space', 'example')

    box.schema.user.create('repl', { password = 'replication' })
    box.schema.user.grant('repl', 'replication')
end

-- for first run create a space and add set up grants
box.once('replica', bootstrap)

-- enabling console access
console = require('console')
console.listen('127.0.0.1:3302')

-- http config
local charset = {}  do -- [0-9a-zA-Z]
    for c = 48, 57  do table.insert(charset, string.char(c)) end
    for c = 65, 90  do table.insert(charset, string.char(c)) end
    for c = 97, 122 do table.insert(charset, string.char(c)) end
end

local function randomString(length)
    if not length or length <= 0 then return '' end
    math.randomseed(os.clock()^5)
    return randomString(length - 1) .. charset[math.random(1, #charset)]
end

local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')

local httpd = http_server.new('0.0.0.0', 8080, {
    log_requests = true,
    log_errors = true
})

local router = http_router.new()

local function get_count()
 local cnt = box.space.example:len()
 return cnt
end

router:route({method = 'GET', path = '/count'}, function()
    return {status = 200, body = json.encode({count = get_count()})}
end)

router:route({method = 'GET', path = '/token'}, function()
    local token = randomString(32)
    local last = box.space.example:len()
    box.space.example:insert{ last + 1, token }
    return {status = 200, body = json.encode({token = token})}
end)

prometheus = require('prometheus')

fiber = require('fiber')
tokens_count = prometheus.gauge("tarantool_tokens_count",
                              "API Tokens Count")

function monitor_tokens_count()
  while true do
    tokens_count:set(get_count())
    fiber.sleep(5)
  end
end
fiber.create(monitor_tokens_count)

router:route( { method = 'GET', path = '/metrics' }, prometheus.collect_http)

httpd:set_router(router)
httpd:start()

ገጸ ባህሪያቱን የሚገልጽ አንዳንድ ሠንጠረዥ በ lua እናውጃለን። የዘፈቀደ ሕብረቁምፊ ለመፍጠር ይህ ሳህን ያስፈልጋል።

local charset = {}  do -- [0-9a-zA-Z]
    for c = 48, 57  do table.insert(charset, string.char(c)) end
    for c = 65, 90  do table.insert(charset, string.char(c)) end
    for c = 97, 122 do table.insert(charset, string.char(c)) end
end

ከዚያ በኋላ, ተግባሩን - randomString እናውጃለን እና የርዝመቱን ዋጋ በቅንፍ ውስጥ እንሰጣለን.

local function randomString(length)
    if not length or length <= 0 then return '' end
    math.randomseed(os.clock()^5)
    return randomString(length - 1) .. charset[math.random(1, #charset)]
end

ከዚያም http ራውተር እና http አገልጋይ ከታራንቱላ አገልጋይ JSON ጋር እናገናኘዋለን, ይህም ለደንበኛው የምንልከው.

local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')

ከዚህ በኋላ በሁሉም የ http አገልጋይ መገናኛዎች ላይ ወደብ 8080 እንጀምራለን, ይህም ሁሉንም ጥያቄዎች እና ስህተቶች ይመዘግባል.

local httpd = http_server.new('0.0.0.0', 8080, {
    log_requests = true,
    log_errors = true
})

በመቀጠል መንገዱን እናውጃለን, ስለዚህ ከ GET ዘዴ ጋር ጥያቄ በፖርት 8080 / ቆጠራ ላይ ከደረሰ, ተግባሩን ከአንድ መስመር እንጠራዋለን. ሁኔታውን ይመልሳል - 200, 404, 403 ወይም ሌላ እኛ የገለጽነውን.

router:route({method = 'GET', path = '/count'}, function()
    return {status = 200, body = json.encode({count = get_count()})}
end)

በሰውነት ውስጥ json.encode ን እንመለሳለን ፣ በእሱ ውስጥ ቆጠራ እና ግቤት ቆጠራን እናሳያለን ፣ ይህም የተጠራው እና በመረጃ ቋታችን ውስጥ ያሉትን የመዝገቦች ብዛት ያሳያል።

ሁለተኛ ዘዴ

router:route({method = 'GET', path = '/token'}, function() 
    local token = randomString(32) 
    local last = box.space.example:len() 
    box.space.example:insert{ last + 1, token } 
    return {status = 200, body = json.encode({token = token})}
end)

በመስመሩ ውስጥ የት ራውተር: መንገድ ({ዘዴ = 'GET'፣ path = '/token'}፣ ተግባር() ተግባሩን እንጠራዋለን እና ማስመሰያ እንፈጥራለን።

መስመር አካባቢያዊ ማስመሰያ = randomString (32) የ32 ቁምፊዎች የዘፈቀደ ሕብረቁምፊ ነው።
በአግባቡ local የመጨረሻ = box.space.example:len() የመጨረሻውን አካል እናወጣለን.
እና በመስመሩ ውስጥ box.space.example:insert{የመጨረሻ +1፣ ማስመሰያ} መረጃውን ወደ የውሂብ ጎታችን እንጽፋለን ፣ ማለትም ፣ በቀላሉ መታወቂያውን በ 1 እንጨምራለን ። በነገራችን ላይ ፣ በዚህ ብልሹ መንገድ ብቻ ሳይሆን ሊከናወን ይችላል። በ Tarantula ውስጥ ለዚህ ቅደም ተከተሎች አሉ.

ምልክቱን እዚያ እንጽፋለን.

ስለዚህ, ማመልከቻውን በአንድ ፋይል ውስጥ ጽፈናል. ውሂቡን ወዲያውኑ ማቀናበር ይችላሉ, እና የሳጥን ሞጁል ሁሉንም ቆሻሻ ስራዎች ለእርስዎ ያደርግልዎታል.

http ያዳምጣል እና ከውሂብ ጋር ይሰራል, ሁሉም ነገር በአንድ ነጠላ ሁኔታ ውስጥ ነው - አፕሊኬሽኑ እና ውሂቡ. ስለዚህ, ሁሉም ነገር በፍጥነት ይከሰታል.

ለመጀመር http ሞጁሉን እንጭነዋለን-

ይህንን እንዴት እንደምናደርግ, ከአጥፊው ስር ይመልከቱ

root@test2:/# tarantoolctl rocks install http
Installing http://rocks.tarantool.org/http-scm-1.src.rock
Missing dependencies for http scm-1:
   checks >= 3.0.1 (not installed)

http scm-1 depends on checks >= 3.0.1 (not installed)
Installing http://rocks.tarantool.org/checks-3.0.1-1.rockspec

Cloning into 'checks'...
remote: Enumerating objects: 28, done.
remote: Counting objects: 100% (28/28), done.
remote: Compressing objects: 100% (19/19), done.
remote: Total 28 (delta 1), reused 16 (delta 1), pack-reused 0
Receiving objects: 100% (28/28), 12.69 KiB | 12.69 MiB/s, done.
Resolving deltas: 100% (1/1), done.
Note: checking out '580388773ef11085015b5a06fe52d61acf16b201'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

  git checkout -b <new-branch-name>

No existing manifest. Attempting to rebuild...
checks 3.0.1-1 is now installed in /.rocks (license: BSD)

-- The C compiler identification is GNU 7.5.0
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Found TARANTOOL: /usr/include (found version "2.4.2-80-g18f2bc82d")
-- Tarantool LUADIR is /.rocks/share/tarantool/rocks/http/scm-1/lua
-- Tarantool LIBDIR is /.rocks/share/tarantool/rocks/http/scm-1/lib
-- Configuring done
-- Generating done
CMake Warning:
  Manually-specified variables were not used by the project:

    version


-- Build files have been written to: /tmp/luarocks_http-scm-1-V4P9SM/http/build.luarocks
Scanning dependencies of target httpd
[ 50%] Building C object http/CMakeFiles/httpd.dir/lib.c.o
In file included from /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:32:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c: In function ‘tpl_term’:
/usr/include/tarantool/lauxlib.h:144:15: warning: this statement may fall through [-Wimplicit-fallthrough=]
    (*(B)->p++ = (char)(c)))
    ~~~~~~~~~~~^~~~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:62:7: note: in expansion of macro ‘luaL_addchar’
       luaL_addchar(b, '\');
       ^~~~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:63:6: note: here
      default:
      ^~~~~~~
In file included from /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:39:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h: In function ‘tpe_parse’:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h:147:9: warning: this statement may fall through [-Wimplicit-fallthrough=]
    type = TPE_TEXT;
    ~~~~~^~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h:149:3: note: here
   case TPE_LINECODE:
   ^~~~
In file included from /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:40:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h: In function ‘httpfast_parse’:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:372:22: warning: this statement may fall through [-Wimplicit-fallthrough=]
                 code = 0;
                 ~~~~~^~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:374:13: note: here
             case status:
             ^~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:393:23: warning: this statement may fall through [-Wimplicit-fallthrough=]
                 state = message;
                 ~~~~~~^~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:395:13: note: here
             case message:
             ^~~~
[100%] Linking C shared library lib.so
[100%] Built target httpd
[100%] Built target httpd
Install the project...
-- Install configuration: "Debug"
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/VERSION.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lib/http/lib.so
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/server/init.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/server/tsgi_adapter.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/nginx_server/init.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/init.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/fs.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/matching.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/middleware.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/request.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/response.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/tsgi.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/utils.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/mime_types.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/codes.lua
http scm-1 is now installed in /.rocks (license: BSD)

root@test2:/#

ለማሄድ ፕሮሜቲየስ ያስፈልገናል፡-

root@test2:/# tarantoolctl rocks install prometheus
Installing http://rocks.tarantool.org/prometheus-scm-1.rockspec

Cloning into 'prometheus'...
remote: Enumerating objects: 19, done.
remote: Counting objects: 100% (19/19), done.
remote: Compressing objects: 100% (19/19), done.
remote: Total 19 (delta 2), reused 5 (delta 0), pack-reused 0
Receiving objects: 100% (19/19), 10.73 KiB | 10.73 MiB/s, done.
Resolving deltas: 100% (2/2), done.
prometheus scm-1 is now installed in /.rocks (license: BSD)

root@test2:/#

ሞጁሎቹን እንጀምራለን እና መድረስ እንችላለን

root@test2:/# curl -D - -s http://127.0.0.1:8080/token
HTTP/1.1 200 Ok
Content-length: 44
Server: Tarantool http (tarantool v2.4.2-80-g18f2bc82d)
Connection: keep-alive

{"token":"e2tPq9l5Z3QZrewRf6uuoJUl3lJgSLOI"}

root@test2:/# curl -D - -s http://127.0.0.1:8080/token
HTTP/1.1 200 Ok
Content-length: 44
Server: Tarantool http (tarantool v2.4.2-80-g18f2bc82d)
Connection: keep-alive

{"token":"fR5aCA84gj9eZI3gJcV0LEDl9XZAG2Iu"}

root@test2:/# curl -D - -s http://127.0.0.1:8080/count
HTTP/1.1 200 Ok
Content-length: 11
Server: Tarantool http (tarantool v2.4.2-80-g18f2bc82d)
Connection: keep-alive

{"count":2}root@test2:/#

/ ቆጠራ ደረጃ 200 ይሰጠናል.
/ቶከን ማስመሰያ አውጥቶ ይህንን ማስመሰያ ወደ ዳታቤዝ ይጽፋል።

ፍጥነትን መሞከር

ለ50 ጥያቄዎች ቤንችማርክን እናካሂድ። 000 የሚወዳደሩ ጥያቄዎች ይኖራሉ።

root@test2:/# ab -c 500 -n 50000 http://127.0.0.1:8080/token
This is ApacheBench, Version 2.3 <$Revision: 1807734 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking 127.0.0.1 (be patient)
Completed 5000 requests
Completed 10000 requests
Completed 15000 requests
Completed 20000 requests
Completed 25000 requests
Completed 30000 requests
Completed 35000 requests
Completed 40000 requests
Completed 45000 requests
Completed 50000 requests
Finished 50000 requests


Server Software:        Tarantool
Server Hostname:        127.0.0.1
Server Port:            8080

Document Path:          /token
Document Length:        44 bytes

Concurrency Level:      500
Time taken for tests:   14.578 seconds
Complete requests:      50000
Failed requests:        0
Total transferred:      7950000 bytes
HTML transferred:       2200000 bytes
Requests per second:    3429.87 [#/sec] (mean)
Time per request:       145.778 [ms] (mean)
Time per request:       0.292 [ms] (mean, across all concurrent requests)
Transfer rate:          532.57 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0   10 103.2      0    3048
Processing:    12   69 685.1     15   13538
Waiting:       12   69 685.1     15   13538
Total:         12   78 768.2     15   14573

Percentage of the requests served within a certain time (ms)
  50%     15
  66%     15
  75%     16
  80%     16
  90%     16
  95%     16
  98%     21
  99%     42
 100%  14573 (longest request)
root@test2:/#

ማስመሰያዎች ወጥተዋል። እና እኛ ያለማቋረጥ ውሂብ እንቀዳለን። 99% ጥያቄዎች በ42 ሚሊሰከንዶች ተካሂደዋል። በዚህ መሠረት 3500 ኮር እና 2 ጊጋባይት ማህደረ ትውስታ ባለው አነስተኛ ማሽን ላይ በሰከንድ 4 ጥያቄዎች አሉን.

እንዲሁም አንዳንድ 50000 ማስመሰያዎች መምረጥ እና ዋጋውን ማየት ይችላሉ።

http ብቻ ሳይሆን ውሂብዎን የሚያስኬዱ የጀርባ ተግባራትን ማሄድ ይችላሉ። በተጨማሪም የተለያዩ ቀስቅሴዎች አሉ. ለምሳሌ, በዝማኔዎች ላይ ተግባራትን መደወል, የሆነ ነገር መፈተሽ - ግጭቶችን ማስተካከል ይችላሉ.

የስክሪፕት አፕሊኬሽኖችን በቀጥታ በመረጃ ቋት አገልጋዩ ውስጥ መፃፍ ትችላላችሁ፣ እና በምንም ነገር አይገደቡም ፣ ማንኛውንም ሞጁሎችን ያገናኙ እና ማንኛውንም አመክንዮ ይተግብሩ።

አፕሊኬሽኑ አገልጋዩ የውጭ አገልጋዮችን መድረስ፣ መረጃ ማውጣት እና ወደ ዳታቤዙ ማከል ይችላል። ከዚህ ዳታቤዝ የሚገኘው መረጃ በሌሎች መተግበሪያዎች ጥቅም ላይ ይውላል።

ታራንቱላ ይህንን በራሱ ያደርገዋል, እና የተለየ መተግበሪያ መጻፍ አያስፈልግዎትም.

በማጠቃለያው

ይህ የአንድ ትልቅ ሥራ የመጀመሪያ ክፍል ብቻ ነው። ሁለተኛው በ Mail.ru ቡድን ብሎግ ላይ በጣም በቅርቡ ይታተማል, እና በእርግጠኝነት በዚህ ጽሑፍ ውስጥ ለእሱ አገናኝ እንጨምራለን.

በመስመር ላይ እነዚህን ነገሮች በምንገነባባቸው ዝግጅቶች ላይ ለመሳተፍ እና በእውነተኛ ጊዜ ጥያቄዎችን ለመጠየቅ ፍላጎት ካሎት፣ ይከታተሉ DevOps በREBRAIN ሰርጥ.

ወደ ደመና መሄድ ከፈለጉ ወይም ስለ መሠረተ ልማትዎ ጥያቄዎች ካሉዎት፣ ጥያቄ ለማቅረብ ነፃነት ይሰማህ.

PS በወር 2 ነፃ ኦዲት አለን፣ ምናልባት የእርስዎ ፕሮጀክት ከእነዚህ ውስጥ አንዱ ሊሆን ይችላል።

ምንጭ: hab.com