យើងទទួលយកព្រឹត្តិការណ៍ 10 នៅក្នុង Yandex.Cloud ។ ផ្នែកទី 000

សួស្តីមិត្តទាំងអស់គ្នា!

* អត្ថបទនេះគឺផ្អែកលើសិក្ខាសាលាបើកចំហរ REBRAIN & Yandex.Cloud ប្រសិនបើអ្នកចូលចិត្តមើលវីដេអូ អ្នកអាចស្វែងរកវានៅតំណនេះ - https://youtu.be/cZLezUm0ekE

ថ្មីៗនេះយើងមានឱកាសសាកល្បងផ្ទាល់ Yandex.Cloud ។ ដោយសារយើងចង់ស៊ើបអង្កេតយូរ និងពិបាក យើងបានបោះបង់ចោលភ្លាមៗនូវគំនិតនៃការចាប់ផ្តើមប្លក់ Wordpress សាមញ្ញជាមួយនឹងមូលដ្ឋានពពក - វាគួរឱ្យធុញពេក។ បន្ទាប់ពីការគិតមួយចំនួន យើងបានសម្រេចចិត្តដាក់ពង្រាយអ្វីមួយដែលស្រដៀងទៅនឹងស្ថាបត្យកម្មសេវាកម្មផលិតកម្មសម្រាប់ការទទួល និងវិភាគព្រឹត្តិការណ៍នៅក្នុងរបៀបពេលវេលាជាក់ស្តែង។

ខ្ញុំប្រាកដណាស់ថាភាគច្រើននៃអាជីវកម្មអនឡាញ (មិនត្រឹមតែប៉ុណ្ណោះ) ខ្លះប្រមូលព័ត៌មានអំពីអ្នកប្រើប្រាស់ និងសកម្មភាពរបស់ពួកគេ។ យ៉ាងហោចណាស់ វាចាំបាច់សម្រាប់ការសម្រេចចិត្តជាក់លាក់ - ឧទាហរណ៍ ប្រសិនបើអ្នកគ្រប់គ្រងហ្គេមអនឡាញ អ្នកអាចមើលស្ថិតិនៅកម្រិតណាដែលអ្នកប្រើប្រាស់ភាគច្រើនជាប់គាំង និងលុបប្រដាប់ក្មេងលេងរបស់អ្នក។ ឬហេតុអ្វីបានជាអ្នកប្រើប្រាស់ចាកចេញពីគេហទំព័ររបស់អ្នកដោយមិនទិញអ្វីទាំងអស់ (សួស្តី Yandex.Metrica)។

ដូច្នេះ រឿងរបស់យើង៖ របៀបដែលយើងសរសេរកម្មវិធីនៅក្នុងហ្គោលាំង សាកល្បង kafka vs rabbitmq vs yqs បានសរសេរការផ្សាយទិន្នន័យនៅក្នុងចង្កោម Clickhouse និងមើលឃើញទិន្នន័យដោយប្រើ yandex datalens ។ តាមធម្មជាតិ អ្វីៗទាំងអស់នេះត្រូវបានរៀបចំឡើងដោយភាពរីករាយនៃហេដ្ឋារចនាសម្ព័ន្ធក្នុងទម្រង់ជា docker, terraform, gitlab ci និងជាការពិតណាស់ prometheus ។ តោះ​ទៅ!

ខ្ញុំចង់ធ្វើការកក់ភ្លាមៗដែលយើងនឹងមិនអាចកំណត់រចនាសម្ព័ន្ធអ្វីៗទាំងអស់ក្នុងមួយអង្គុយបានទេ - សម្រាប់រឿងនេះយើងនឹងត្រូវការអត្ថបទជាច្រើននៅក្នុងស៊េរី។ បន្តិចអំពីរចនាសម្ព័ន្ធ៖

ផ្នែកទី 1 (អ្នកកំពុងអានវា) ។ យើងនឹងសម្រេចចិត្តលើលក្ខណៈជាក់លាក់ និងស្ថាបត្យកម្មនៃដំណោះស្រាយ ហើយក៏សរសេរកម្មវិធីជាភាសាហ្គោលឡាងផងដែរ។
ផ្នែកទី 2 ។ យើងបញ្ចេញកម្មវិធីរបស់យើងទៅក្នុងផលិតកម្ម ធ្វើឱ្យវាអាចធ្វើមាត្រដ្ឋានបាន និងសាកល្បងបន្ទុក។
ផ្នែកទី 3 ។ ចូរយើងព្យាយាមស្វែងយល់ថាហេតុអ្វីបានជាយើងត្រូវការរក្សាទុកសារនៅក្នុងសតិបណ្ដោះអាសន្ន ហើយមិននៅក្នុងឯកសារ ហើយក៏ប្រៀបធៀបសេវាកម្ម kafka, rabbitmq និង yandex ផងដែរ។
ផ្នែកទី 4 យើងនឹងដាក់ពង្រាយ Clickhouse cluster សរសេរសេវាកម្មស្ទ្រីមដើម្បីផ្ទេរទិន្នន័យពីសតិបណ្ដោះអាសន្ននៅទីនោះ ហើយរៀបចំការមើលឃើញនៅក្នុង datalens។
ផ្នែកទី 5 ចូរនាំហេដ្ឋារចនាសម្ព័ន្ធទាំងមូលទៅជាទម្រង់ត្រឹមត្រូវ - រៀបចំ ci/cd ដោយប្រើ gitlab ci ភ្ជាប់ការត្រួតពិនិត្យ និងការរកឃើញសេវាកម្មដោយប្រើ prometheus និងកុងស៊ុល។

ТЗ

ជាដំបូង ចូរយើងបង្កើតលក្ខខណ្ឌនៃសេចក្តីយោង - អ្វីដែលយើងចង់ទទួលបានជាលទ្ធផល។

1. យើងចង់មានចំណុចបញ្ចប់ដូចជា events.kis.im (kis.im គឺជាដែនសាកល្បងដែលយើងនឹងប្រើក្នុងអត្ថបទទាំងអស់) ដែលគួរតែទទួលបានព្រឹត្តិការណ៍ដោយប្រើ HTTPS ។
2. ព្រឹត្តិការណ៍គឺជា json សាមញ្ញដូចជា៖ {“event”: “view”, “os”: “linux”, “browser”: “chrome”}។ នៅដំណាក់កាលចុងក្រោយ យើងនឹងបន្ថែមវាលមួយបន្ថែមទៀត ប៉ុន្តែវានឹងមិនដើរតួនាទីធំនោះទេ។ ប្រសិនបើអ្នកចង់បាន អ្នកអាចប្តូរទៅ protobuf ។
3. សេវាកម្មត្រូវតែអាចដំណើរការព្រឹត្តិការណ៍ 10 ក្នុងមួយវិនាទី។
4. វាគួរតែអាចធ្វើមាត្រដ្ឋានផ្ដេកដោយគ្រាន់តែបន្ថែមករណីថ្មីទៅក្នុងដំណោះស្រាយរបស់យើង។ ហើយវានឹងល្អប្រសិនបើយើងអាចផ្លាស់ទីផ្នែកខាងមុខទៅទីតាំងភូមិសាស្ត្រផ្សេងៗ ដើម្បីកាត់បន្ថយភាពយឺតយ៉ាវសម្រាប់សំណើរបស់អតិថិជន។
5. ការអត់ឱនចំពោះកំហុស។ ដំណោះស្រាយត្រូវតែមានស្ថេរភាពគ្រប់គ្រាន់ និងអាចរស់រានមានជីវិតពីការដួលរលំនៃផ្នែកណាមួយ (ជាការពិតណាស់រហូតដល់ចំនួនជាក់លាក់)។

ស្ថាបត្យកម្ម

ជាទូទៅ សម្រាប់កិច្ចការប្រភេទនេះ ស្ថាបត្យកម្មបុរាណត្រូវបានបង្កើតឡើងជាយូរមកហើយ ដែលអនុញ្ញាតឱ្យធ្វើមាត្រដ្ឋានប្រកបដោយប្រសិទ្ធភាព។ តួលេខបង្ហាញពីឧទាហរណ៍នៃដំណោះស្រាយរបស់យើង។

ដូច្នេះអ្វីដែលយើងមាន៖

1. នៅខាងឆ្វេងគឺជាឧបករណ៍របស់យើងដែលបង្កើតព្រឹត្តិការណ៍ផ្សេងៗ មិនថាជាអ្នកលេងដែលបំពេញកម្រិតនៅក្នុងប្រដាប់ក្មេងលេងនៅលើស្មាតហ្វូន ឬបង្កើតការបញ្ជាទិញនៅក្នុងហាងអនឡាញតាមរយៈកម្មវិធីរុករកធម្មតា។ ព្រឹត្តិការណ៍មួយ ដូចដែលបានបញ្ជាក់នៅក្នុងការបញ្ជាក់ គឺជា json សាមញ្ញដែលត្រូវបានផ្ញើទៅកាន់ចំណុចបញ្ចប់របស់យើង - events.kis.im ។

2. ម៉ាស៊ីនមេពីរដំបូងគឺសមតុល្យសាមញ្ញ ភារកិច្ចចម្បងរបស់ពួកគេគឺ៖

• អាចរកបានជានិច្ច។ ដើម្បីធ្វើដូចនេះអ្នកអាចប្រើឧទាហរណ៍ Keepalived ដែលនឹងប្តូរ IP និម្មិតរវាងថ្នាំងក្នុងករណីមានបញ្ហា។
• បញ្ចប់ TLS ។ បាទ/ចាស យើងនឹងបញ្ចប់ TLS លើពួកគេ។ ទីមួយ ដើម្បីឱ្យដំណោះស្រាយរបស់យើងអនុលោមតាមលក្ខណៈបច្ចេកទេស និងទីពីរ ដើម្បីសម្រាលបន្ទុកនៃការបង្កើតការតភ្ជាប់ដែលបានអ៊ិនគ្រីបពីម៉ាស៊ីនមេខាងក្រោយរបស់យើង។
• ធ្វើសមតុល្យការស្នើសុំចូលទៅកាន់ម៉ាស៊ីនមេខាងក្រោយដែលមាន។ ពាក្យគន្លឹះនៅទីនេះគឺអាចចូលដំណើរការបាន។ ដោយផ្អែកលើចំណុចនេះ យើងមកស្វែងយល់ថា load balancers ត្រូវតែអាចត្រួតពិនិត្យម៉ាស៊ីនមេរបស់យើងជាមួយនឹងកម្មវិធី និងបញ្ឈប់ការធ្វើតុល្យភាពចរាចរណ៍ទៅកាន់ថ្នាំងដែលបរាជ័យ។

3. បន្ទាប់ពី Balancers យើងមានកម្មវិធី Servers ដំណើរការកម្មវិធីសាមញ្ញសមរម្យ។ វាគួរតែអាចទទួលយកសំណើចូលតាមរយៈ HTTP ធ្វើឱ្យមានសុពលភាព json ដែលបានផ្ញើ និងដាក់ទិន្នន័យទៅក្នុងសតិបណ្ដោះអាសន្ន។

4. ដ្យាក្រាមបង្ហាញ kafka ជាសតិបណ្ដោះអាសន្ន បើទោះជាជាការពិត សេវាស្រដៀងគ្នាផ្សេងទៀតអាចត្រូវបានប្រើនៅកម្រិតនេះក៏ដោយ។ យើងនឹងប្រៀបធៀប Kafka, rabbitmq និង yqs នៅក្នុងអត្ថបទទីបី។

5. ចំនុចចុងក្រោយនៃស្ថាបត្យកម្មរបស់យើងគឺ Clickhouse - មូលដ្ឋានទិន្នន័យ columnar ដែលអនុញ្ញាតឱ្យអ្នករក្សាទុក និងដំណើរការទិន្នន័យយ៉ាងច្រើន។ នៅកម្រិតនេះ យើងត្រូវផ្ទេរទិន្នន័យពីសតិបណ្ដោះអាសន្នទៅប្រព័ន្ធផ្ទុកដោយខ្លួនវា (បន្ថែមលើនេះក្នុងមាត្រា 4) ។

ការរចនានេះអនុញ្ញាតឱ្យយើងធ្វើមាត្រដ្ឋានស្រទាប់នីមួយៗដោយឯករាជ្យដោយផ្ដេក។ ម៉ាស៊ីនមេ backend មិនអាចដោះស្រាយបានទេ - សូមបន្ថែមរឿងមួយបន្ថែមទៀត - បន្ទាប់ពីទាំងអស់ ពួកវាជាកម្មវិធីគ្មានរដ្ឋ ដូច្នេះហើយ វាអាចត្រូវបានធ្វើដោយស្វ័យប្រវត្តិ។ សតិបណ្ដោះអាសន្នរចនាប័ទ្ម Kafka មិនដំណើរការទេ—សូមបន្ថែមម៉ាស៊ីនមេបន្ថែមទៀត និងផ្ទេរផ្នែកខ្លះនៃប្រធានបទរបស់យើងទៅពួកគេ។ Clickhouse មិនអាចដោះស្រាយវាបានទេ - វាមិនអាចទៅរួចទេ :) តាមពិតយើងនឹងភ្ជាប់ម៉ាស៊ីនមេ និងបំបែកទិន្នន័យផងដែរ។

ដោយវិធីនេះ ប្រសិនបើអ្នកចង់អនុវត្តផ្នែកស្រេចចិត្តនៃលក្ខណៈបច្ចេកទេស និងមាត្រដ្ឋានរបស់យើងនៅក្នុងទីតាំងភូមិសាស្ត្រផ្សេងៗគ្នានោះ មិនមានអ្វីសាមញ្ញជាងនេះទេ៖

នៅក្នុងទីតាំងភូមិសាស្ត្រនីមួយៗ យើងដាក់ពង្រាយតុល្យភាពបន្ទុកជាមួយនឹងកម្មវិធី និង kafka ។ ជាទូទៅ ម៉ាស៊ីនមេកម្មវិធី 2 ថ្នាំង kafka 3 និងឧបករណ៍តុល្យភាពពពក ឧទាហរណ៍ cloudflare គឺគ្រប់គ្រាន់ហើយ ដែលនឹងពិនិត្យមើលភាពអាចរកបាននៃថ្នាំងកម្មវិធី និងសំណើសមតុល្យតាមទីតាំងភូមិសាស្ត្រដោយផ្អែកលើអាសយដ្ឋាន IP ប្រភពរបស់អតិថិជន។ ដូច្នេះ ទិន្នន័យដែលផ្ញើដោយអតិថិជនអាមេរិកនឹងចុះចតនៅលើម៉ាស៊ីនមេរបស់អាមេរិក។ ហើយទិន្នន័យពីទ្វីបអាហ្រ្វិកគឺនៅអាហ្វ្រិក។

បន្ទាប់មកអ្វីគ្រប់យ៉ាងគឺសាមញ្ញណាស់ - យើងប្រើឧបករណ៍កញ្ចក់ពីសំណុំ Kafka ហើយចម្លងទិន្នន័យទាំងអស់ពីគ្រប់ទីតាំងទៅមជ្ឈមណ្ឌលទិន្នន័យកណ្តាលរបស់យើងដែលមានទីតាំងនៅប្រទេសរុស្ស៊ី។ នៅខាងក្នុង យើងញែកទិន្នន័យ និងកត់ត្រាវានៅក្នុង Clickhouse សម្រាប់ការមើលឃើញជាបន្តបន្ទាប់។

ដូច្នេះ យើងបានតម្រៀបចេញនូវស្ថាបត្យកម្ម - តោះចាប់ផ្តើមអង្រួន Yandex.Cloud!

ការសរសេរកម្មវិធី

មុនពេល Cloud អ្នកនៅតែត្រូវអត់ធ្មត់បន្តិច ហើយសរសេរសេវាកម្មដ៏សាមញ្ញមួយដើម្បីដំណើរការព្រឹត្តិការណ៍ដែលចូលមក។ យើងនឹងប្រើហ្គោលាំង ព្រោះវាបានបង្ហាញឱ្យឃើញយ៉ាងច្បាស់ថាជាភាសាសម្រាប់ការសរសេរកម្មវិធីបណ្តាញ។

បន្ទាប់ពីចំណាយពេលមួយម៉ោង (ប្រហែលជាពីរបីម៉ោង) យើងទទួលបានអ្វីមួយដូចនេះ៖ https://github.com/RebrainMe/yandex-cloud-events/blob/master/app/main.go.

តើចំណុចសំខាន់អ្វីខ្លះដែលខ្ញុំចង់កត់សម្គាល់នៅទីនេះ៖

1. នៅពេលចាប់ផ្តើមកម្មវិធី អ្នកអាចបញ្ជាក់ទង់ពីរ។ មួយគឺទទួលខុសត្រូវចំពោះច្រកដែលយើងនឹងស្តាប់សំណើ http ចូល (-addr) ។ ទីពីរគឺសម្រាប់អាសយដ្ឋានម៉ាស៊ីនមេ kafka ដែលយើងនឹងកត់ត្រាព្រឹត្តិការណ៍របស់យើង (-kafka):

addr     = flag.String("addr", ":8080", "TCP address to listen to")
kafka    = flag.String("kafka", "127.0.0.1:9092", "Kafka endpoints”)

2. កម្មវិធីប្រើបណ្ណាល័យ sarama ([] github.com/Shopify/sarama) ដើម្បីផ្ញើសារទៅកាន់ចង្កោម kafka ។ យើងកំណត់ភ្លាមៗនូវការកំណត់ដែលមានគោលបំណងក្នុងល្បឿនដំណើរការអតិបរមា៖

config := sarama.NewConfig()
config.Producer.RequiredAcks = sarama.WaitForLocal
config.Producer.Compression = sarama.CompressionSnappy
config.Producer.Return.Successes = true

3. កម្មវិធីរបស់យើងក៏មានម៉ាស៊ីនភ្ញៀវ prometheus ភ្ជាប់មកជាមួយផងដែរ ដែលប្រមូលរង្វាស់ផ្សេងៗដូចជា៖

• ចំនួនសំណើសម្រាប់កម្មវិធីរបស់យើង;
• ចំនួននៃកំហុសនៅពេលប្រតិបត្តិសំណើ (មិនអាចអានសំណើប្រកាស, json ខូច, មិនអាចសរសេរទៅ Kafka);
• ពេលវេលាដំណើរការសម្រាប់សំណើមួយពីអតិថិជន រួមទាំងពេលវេលាសម្រាប់ការសរសេរសារទៅ Kafka ។

4. ចំណុចបញ្ចប់ចំនួនបីដែលដំណើរការកម្មវិធីរបស់យើង៖

• / ស្ថានភាព - គ្រាន់តែត្រឡប់ ok ដើម្បីបង្ហាញថាយើងនៅរស់។ ទោះបីជាអ្នកអាចបន្ថែមការត្រួតពិនិត្យមួយចំនួនដូចជាភាពអាចរកបាននៃចង្កោម Kafka ក៏ដោយ។
• /metrics - យោងតាម ​​url នេះ អតិថិជន prometheus នឹងត្រឡប់ម៉ែត្រដែលវាបានប្រមូល។
• /post គឺជាចំណុចបញ្ចប់សំខាន់ដែល POST ស្នើសុំជាមួយ json ខាងក្នុងនឹងត្រូវបានផ្ញើ។ កម្មវិធីរបស់យើងពិនិត្យមើល json សម្រាប់សុពលភាព ហើយប្រសិនបើអ្វីៗទាំងអស់មិនអីទេ វាសរសេរទិន្នន័យទៅក្រុម Kafka ។

ខ្ញុំ​នឹង​ធ្វើការ​កក់​ទុក​ដែល​កូដ​មិន​ល្អ​ឥត​ខ្ចោះ - វា​អាច (ហើយ​គួរ​!) ត្រូវ​បាន​បញ្ចប់។ ឧទាហរណ៍ អ្នកអាចឈប់ប្រើ net/http ដែលភ្ជាប់មកជាមួយ ហើយប្តូរទៅ fasthttp លឿនជាងមុន។ ឬអ្នកអាចទទួលបានពេលវេលាដំណើរការ និងធនធាន cpu ដោយផ្លាស់ទីការត្រួតពិនិត្យសុពលភាព json ទៅដំណាក់កាលក្រោយ - នៅពេលដែលទិន្នន័យត្រូវបានផ្ទេរពីបណ្តុំទៅ clickhouse ។

បន្ថែមពីលើផ្នែកអភិវឌ្ឍន៍នៃបញ្ហានេះ យើងបានគិតភ្លាមៗអំពីហេដ្ឋារចនាសម្ព័ន្ធនាពេលអនាគតរបស់យើង ហើយបានសម្រេចចិត្តដាក់ឱ្យប្រើប្រាស់កម្មវិធីរបស់យើងតាមរយៈ docker ។ Dockerfile ចុងក្រោយសម្រាប់បង្កើតកម្មវិធីគឺ https://github.com/RebrainMe/yandex-cloud-events/blob/master/app/Dockerfile. ជាទូទៅវាសាមញ្ញណាស់ ចំណុចតែមួយគត់ដែលខ្ញុំចង់យកចិត្តទុកដាក់គឺការជួបប្រជុំគ្នាច្រើនដំណាក់កាល ដែលអនុញ្ញាតឱ្យយើងកាត់បន្ថយរូបភាពចុងក្រោយនៃកុងតឺន័ររបស់យើង។

ជំហានដំបូងនៅក្នុងពពក

ជាដំបូងនៃការទាំងអស់ចុះឈ្មោះនៅលើ cloud.yandex.ru. បន្ទាប់ពីបំពេញវាលចាំបាច់ទាំងអស់ យើងនឹងត្រូវបានបង្កើតគណនីមួយ និងផ្តល់ជំនួយសម្រាប់ចំនួនទឹកប្រាក់ជាក់លាក់មួយ ដែលអាចត្រូវបានប្រើដើម្បីសាកល្បងសេវាកម្មពពក។ ប្រសិនបើអ្នកចង់ធ្វើម្តងទៀតនូវជំហានទាំងអស់ពីអត្ថបទរបស់យើង ជំនួយនេះគួរតែគ្រប់គ្រាន់សម្រាប់អ្នក។

បន្ទាប់ពីការចុះឈ្មោះ ពពកដាច់ដោយឡែក និងថតលំនាំដើមនឹងត្រូវបានបង្កើតសម្រាប់អ្នក ដែលអ្នកអាចចាប់ផ្តើមបង្កើតធនធានពពក។ ជាទូទៅនៅក្នុង Yandex.Cloud ទំនាក់ទំនងនៃធនធានមើលទៅដូចនេះ៖

អ្នកអាចបង្កើតពពកជាច្រើនសម្រាប់គណនីមួយ។ ហើយនៅខាងក្នុងពពក បង្កើតថតផ្សេងៗគ្នាសម្រាប់គម្រោងក្រុមហ៊ុនផ្សេងៗគ្នា។ អ្នកអាចអានបន្ថែមអំពីរឿងនេះនៅក្នុងឯកសារ - https://cloud.yandex.ru/docs/resource-manager/concepts/resources-hierarchy. ដោយវិធីនេះ ជាញឹកញាប់ខ្ញុំនឹងយោងទៅវាខាងក្រោមនៅក្នុងអត្ថបទ។ នៅពេលដែលខ្ញុំរៀបចំហេដ្ឋារចនាសម្ព័ន្ធទាំងមូលតាំងពីដំបូង ឯកសារបានជួយខ្ញុំច្រើនដង ដូច្នេះខ្ញុំណែនាំអ្នកឱ្យសិក្សាវា។

ដើម្បីគ្រប់គ្រងពពក អ្នកអាចប្រើទាំងចំណុចប្រទាក់បណ្ដាញ និងឧបករណ៍ប្រើប្រាស់កុងសូល - yc ។ ការដំឡើងត្រូវបានអនុវត្តដោយប្រើពាក្យបញ្ជាមួយ (សម្រាប់ Linux និង Mac Os)៖

curl https://storage.yandexcloud.net/yandexcloud-yc/install.sh | bash

ប្រសិនបើអ្នកឯកទេសសន្តិសុខផ្ទៃក្នុងរបស់អ្នកកំពុងខឹងសម្បារចំពោះការដំណើរការស្គ្រីបពីអ៊ីនធឺណិត នោះដំបូង អ្នកអាចបើកស្គ្រីប ហើយអានវា ហើយទីពីរ យើងដំណើរការវានៅក្រោមអ្នកប្រើប្រាស់របស់យើង ដោយគ្មានសិទ្ធិជា root ។

ប្រសិនបើអ្នកចង់ដំឡើងម៉ាស៊ីនភ្ញៀវសម្រាប់ Windows អ្នកអាចប្រើការណែនាំ នៅទីនេះ ហើយបន្ទាប់មកប្រតិបត្តិ yc initដើម្បីប្ដូរតាមបំណងវាទាំងស្រុង៖

vozerov@mba:~ $ yc init
Welcome! This command will take you through the configuration process.
Please go to https://oauth.yandex.ru/authorize?response_type=token&client_id= in order to obtain OAuth token.

Please enter OAuth token:
Please select cloud to use:
 [1] cloud-b1gv67ihgfu3bp (id = b1gv67ihgfu3bpt24o0q)
 [2] fevlake-cloud (id = b1g6bvup3toribomnh30)
Please enter your numeric choice: 2
Your current cloud has been set to 'fevlake-cloud' (id = b1g6bvup3toribomnh30).
Please choose folder to use:
 [1] default (id = b1g5r6h11knotfr8vjp7)
 [2] Create a new folder
Please enter your numeric choice: 1
Your current folder has been set to 'default' (id = b1g5r6h11knotfr8vjp7).
Do you want to configure a default Compute zone? [Y/n]
Which zone do you want to use as a profile default?
 [1] ru-central1-a
 [2] ru-central1-b
 [3] ru-central1-c
 [4] Don't set default zone
Please enter your numeric choice: 1
Your profile default Compute zone has been set to 'ru-central1-a'.
vozerov@mba:~ $

ជាគោលការណ៍ ដំណើរការគឺសាមញ្ញ - ដំបូងអ្នកត្រូវទទួលបានសញ្ញាសម្ងាត់ oauth ដើម្បីគ្រប់គ្រងពពក ជ្រើសរើសពពក និងថតដែលអ្នកនឹងប្រើ។

ប្រសិនបើអ្នកមានគណនី ឬថតឯកសារជាច្រើននៅក្នុងពពកតែមួយ អ្នកអាចបង្កើតទម្រង់បន្ថែមជាមួយនឹងការកំណត់ដាច់ដោយឡែកតាមរយៈ yc config profile បង្កើត និងប្តូររវាងពួកវា។

បន្ថែមពីលើវិធីសាស្រ្តខាងលើក្រុមការងារ Yandex.Cloud បានសរសេរល្អណាស់ កម្មវិធីជំនួយសម្រាប់ terraform សម្រាប់ការគ្រប់គ្រងធនធានពពក។ សម្រាប់ផ្នែករបស់ខ្ញុំ ខ្ញុំបានរៀបចំឃ្លាំង git ដែលខ្ញុំបានពិពណ៌នាអំពីធនធានទាំងអស់ដែលនឹងត្រូវបានបង្កើតជាផ្នែកនៃអត្ថបទ - https://github.com/rebrainme/yandex-cloud-events/. យើងចាប់អារម្មណ៍នឹងសាខាមេ សូមក្លូនវានៅក្នុងស្រុក៖

vozerov@mba:~ $ git clone https://github.com/rebrainme/yandex-cloud-events/ events
Cloning into 'events'...
remote: Enumerating objects: 100, done.
remote: Counting objects: 100% (100/100), done.
remote: Compressing objects: 100% (68/68), done.
remote: Total 100 (delta 37), reused 89 (delta 26), pack-reused 0
Receiving objects: 100% (100/100), 25.65 KiB | 168.00 KiB/s, done.
Resolving deltas: 100% (37/37), done.
vozerov@mba:~ $ cd events/terraform/

អថេរសំខាន់ៗទាំងអស់ដែលប្រើក្នុង terraform ត្រូវបានសរសេរនៅក្នុងឯកសារ main.tf ។ ដើម្បីចាប់ផ្តើម សូមបង្កើតឯកសារ private.auto.tfvars នៅក្នុងថត terraform ដែលមានខ្លឹមសារដូចខាងក្រោម៖

# Yandex Cloud Oauth token
yc_token = ""
# Yandex Cloud ID
yc_cloud_id = ""
# Yandex Cloud folder ID
yc_folder_id = ""
# Default Yandex Cloud Region
yc_region = "ru-central1-a"
# Cloudflare email
cf_email = ""
# Cloudflare token
cf_token = ""
# Cloudflare zone id
cf_zone_id = ""

អថេរទាំងអស់អាចត្រូវបានយកចេញពីបញ្ជីកំណត់រចនាសម្ព័ន្ធ yc ចាប់តាំងពីយើងបានកំណត់រចនាសម្ព័ន្ធឧបករណ៍ប្រើប្រាស់កុងសូលរួចហើយ។ ខ្ញុំណែនាំអ្នកឱ្យបន្ថែម private.auto.tfvars ទៅ .gitignore ជាបន្ទាន់ ដើម្បីកុំឱ្យផ្សព្វផ្សាយទិន្នន័យឯកជនដោយចៃដន្យ។

នៅក្នុង private.auto.tfvars យើងក៏បានបញ្ជាក់ទិន្នន័យពី Cloudflare - ដើម្បីបង្កើតកំណត់ត្រា DNS និងប្រូកស៊ីដែនសំខាន់ events.kis.im ទៅកាន់ម៉ាស៊ីនមេរបស់យើង។ ប្រសិនបើអ្នកមិនចង់ប្រើ cloudflare ទេនោះ សូមលុបការចាប់ផ្ដើមរបស់អ្នកផ្តល់សេវា cloudflare នៅក្នុង main.tf និងឯកសារ dns.tf ដែលទទួលខុសត្រូវក្នុងការបង្កើតកំណត់ត្រា dns ចាំបាច់។

នៅក្នុងការងាររបស់យើង យើងនឹងរួមបញ្ចូលគ្នានូវវិធីសាស្រ្តទាំងបី - ចំណុចប្រទាក់គេហទំព័រ ឧបករណ៍ប្រើប្រាស់កុងសូល និង terraform ។

បណ្តាញនិម្មិត

និយាយឱ្យត្រង់ទៅ អ្នកអាចរំលងជំហាននេះ ព្រោះនៅពេលអ្នកបង្កើតពពកថ្មី អ្នកនឹងមានបណ្តាញដាច់ដោយឡែកមួយដោយស្វ័យប្រវត្តិ ហើយបណ្តាញរងចំនួន 3 ត្រូវបានបង្កើតឡើង - មួយសម្រាប់តំបន់ដែលអាចរកបាននីមួយៗ។ ប៉ុន្តែយើងនៅតែចង់បង្កើតបណ្តាញដាច់ដោយឡែកសម្រាប់គម្រោងរបស់យើងជាមួយនឹងអាសយដ្ឋានរបស់វាផ្ទាល់។ ដ្យាក្រាមទូទៅនៃប្រតិបត្តិការបណ្តាញនៅក្នុង Yandex.Cloud ត្រូវបានបង្ហាញនៅក្នុងរូបភាពខាងក្រោម (ដោយស្មោះត្រង់យកពី https://cloud.yandex.ru/docs/vpc/concepts/)

ដូច្នេះ អ្នកបង្កើតបណ្តាញរួមមួយ ដែលធនធានអាចទំនាក់ទំនងគ្នាទៅវិញទៅមក។ សម្រាប់តំបន់ដែលអាចរកបាននីមួយៗ បណ្តាញរងត្រូវបានបង្កើតដោយមានអាសយដ្ឋានផ្ទាល់ខ្លួនរបស់វា និងភ្ជាប់ទៅបណ្តាញទូទៅ។ ជាលទ្ធផល ធនធានពពកទាំងអស់នៅក្នុងវាអាចទំនាក់ទំនងបាន ទោះបីជាវាស្ថិតនៅក្នុងតំបន់ដែលអាចរកបានខុសៗគ្នាក៏ដោយ។ ធនធានដែលភ្ជាប់ទៅបណ្តាញពពកផ្សេងគ្នាអាចមើលឃើញគ្នាទៅវិញទៅមកតាមរយៈអាសយដ្ឋានខាងក្រៅប៉ុណ្ណោះ។ និយាយអីញ្ចឹង តើវេទមន្តនេះដំណើរការយ៉ាងដូចម្តេច? ត្រូវបានពិពណ៌នាយ៉ាងល្អនៅលើ Habre.

ការបង្កើតបណ្តាញត្រូវបានពិពណ៌នានៅក្នុងឯកសារ network.tf ពីឃ្លាំង។ នៅទីនោះយើងបង្កើតបណ្តាញឯកជនទូទៅមួយនៅខាងក្នុង ហើយភ្ជាប់បណ្តាញរងចំនួនបីទៅវានៅក្នុងតំបន់ដែលអាចរកបានផ្សេងៗគ្នា - internal-a (172.16.1.0/24), internal-b (172.16.2.0/24), internal-c (172.16.3.0/24) )

ចាប់ផ្តើម terraform និងបង្កើតបណ្តាញ៖

vozerov@mba:~/events/terraform (master) $ terraform init
... skipped ..

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_vpc_subnet.internal-a -target yandex_vpc_subnet.internal-b -target yandex_vpc_subnet.internal-c

... skipped ...

Plan: 4 to add, 0 to change, 0 to destroy.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

yandex_vpc_network.internal: Creating...
yandex_vpc_network.internal: Creation complete after 3s [id=enp2g2rhile7gbqlbrkr]
yandex_vpc_subnet.internal-a: Creating...
yandex_vpc_subnet.internal-b: Creating...
yandex_vpc_subnet.internal-c: Creating...
yandex_vpc_subnet.internal-a: Creation complete after 6s [id=e9b1dad6mgoj2v4funog]
yandex_vpc_subnet.internal-b: Creation complete after 7s [id=e2liv5i4amu52p64ac9p]
yandex_vpc_subnet.internal-c: Still creating... [10s elapsed]
yandex_vpc_subnet.internal-c: Creation complete after 10s [id=b0c2qhsj2vranoc9vhcq]

Apply complete! Resources: 4 added, 0 changed, 0 destroyed.

អស្ចារ្យ! យើងបានបង្កើតបណ្តាញរបស់យើង ហើយឥឡូវនេះត្រៀមខ្លួនជាស្រេចដើម្បីបង្កើតសេវាកម្មខាងក្នុងរបស់យើង។

ការបង្កើតម៉ាស៊ីននិម្មិត

ដើម្បីសាកល្បងកម្មវិធី យើងនឹងត្រូវការបង្កើតម៉ាស៊ីននិម្មិតពីរប៉ុណ្ណោះ - យើងនឹងត្រូវការទីមួយដើម្បីបង្កើត និងដំណើរការកម្មវិធី ទីពីរដើម្បីដំណើរការ kafka ដែលយើងនឹងប្រើដើម្បីរក្សាទុកសារចូល។ ហើយយើងនឹងបង្កើតម៉ាស៊ីនមួយទៀតដែលយើងនឹងកំណត់រចនាសម្ព័ន្ធ prometheus ដើម្បីត្រួតពិនិត្យកម្មវិធី។

ម៉ាស៊ីននិម្មិតនឹងត្រូវបានកំណត់រចនាសម្ព័ន្ធដោយប្រើ ansible ដូច្នេះមុនពេលចាប់ផ្តើម terraform សូមប្រាកដថាអ្នកមានកំណែចុងក្រោយបំផុតមួយនៃ ansible ។ ហើយដំឡើងតួនាទីចាំបាច់ជាមួយកាឡាក់ស៊ី ansible៖

vozerov@mba:~/events/terraform (master) $ cd ../ansible/
vozerov@mba:~/events/ansible (master) $ ansible-galaxy install -r requirements.yml
- cloudalchemy-prometheus (master) is already installed, skipping.
- cloudalchemy-grafana (master) is already installed, skipping.
- sansible.kafka (master) is already installed, skipping.
- sansible.zookeeper (master) is already installed, skipping.
- geerlingguy.docker (master) is already installed, skipping.
vozerov@mba:~/events/ansible (master) $

នៅខាងក្នុង ansible folder មានឧទាហរណ៍ .ansible.cfg configuration file ដែលខ្ញុំប្រើ។ វាអាចមានប្រយោជន៍។

មុននឹងបង្កើតម៉ាស៊ីននិម្មិត ត្រូវប្រាកដថាអ្នកមាន ssh-agent កំពុងដំណើរការ ហើយបានបន្ថែមសោ ssh បើមិនដូច្នោះទេ terraform នឹងមិនអាចភ្ជាប់ទៅម៉ាស៊ីនដែលបានបង្កើតបានទេ។ ជាការពិត ខ្ញុំបានជួបបញ្ហានៅក្នុង os x៖ https://github.com/ansible/ansible/issues/32499#issuecomment-341578864. ដើម្បីការពារកុំឱ្យវាកើតឡើងម្តងទៀត សូមបន្ថែមអថេរតូចមួយទៅ env មុនពេលចាប់ផ្តើម Terraform៖

vozerov@mba:~/events/terraform (master) $ export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES

នៅក្នុងថតជាមួយ terraform យើងបង្កើតធនធានចាំបាច់៖

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_compute_instance.build -target yandex_compute_instance.monitoring -target yandex_compute_instance.kafka
yandex_vpc_network.internal: Refreshing state... [id=enp2g2rhile7gbqlbrkr]
data.yandex_compute_image.ubuntu_image: Refreshing state...
yandex_vpc_subnet.internal-a: Refreshing state... [id=e9b1dad6mgoj2v4funog]

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create

... skipped ...

Plan: 3 to add, 0 to change, 0 to destroy.

... skipped ...

ប្រសិនបើអ្វីៗបានបញ្ចប់ដោយជោគជ័យ (ហើយវាគួរតែមាន) នោះយើងនឹងមានម៉ាស៊ីននិម្មិតចំនួនបី៖

1. build - ម៉ាស៊ីនសម្រាប់សាកល្បង និងបង្កើតកម្មវិធី។ Docker ត្រូវបានដំឡើងដោយស្វ័យប្រវត្តិដោយ Ansible ។
2. ការត្រួតពិនិត្យ - ម៉ាស៊ីនត្រួតពិនិត្យ - prometheus & grafana បានដំឡើងនៅលើវា។ ស្តង់ដារចូល / ពាក្យសម្ងាត់៖ គ្រប់គ្រង / អ្នកគ្រប់គ្រង
3. kafka គឺជាម៉ាស៊ីនតូចមួយដែលមាន kafka ដែលបានដំឡើង អាចចូលបាននៅលើច្រក 9092។

ចូរប្រាកដថាពួកវានៅនឹងកន្លែងទាំងអស់៖

vozerov@mba:~/events (master) $ yc compute instance list
+----------------------+------------+---------------+---------+---------------+-------------+
|          ID          |    NAME    |    ZONE ID    | STATUS  |  EXTERNAL IP  | INTERNAL IP |
+----------------------+------------+---------------+---------+---------------+-------------+
| fhm081u8bkbqf1pa5kgj | monitoring | ru-central1-a | RUNNING | 84.201.159.71 | 172.16.1.35 |
| fhmf37k03oobgu9jmd7p | kafka      | ru-central1-a | RUNNING | 84.201.173.41 | 172.16.1.31 |
| fhmt9pl1i8sf7ga6flgp | build      | ru-central1-a | RUNNING | 84.201.132.3  | 172.16.1.26 |
+----------------------+------------+---------------+---------+---------------+-------------+

ធនធានគឺនៅនឹងកន្លែង ហើយពីទីនេះយើងអាចទទួលបានអាសយដ្ឋាន IP របស់ពួកគេ។ តាមរយៈអ្វីដែលបន្ទាប់ខ្ញុំនឹងប្រើអាសយដ្ឋាន IP ដើម្បីភ្ជាប់តាមរយៈ ssh និងសាកល្បងកម្មវិធី។ ប្រសិនបើអ្នកមានគណនី cloudflare ភ្ជាប់ទៅ terraform សូមប្រើឈ្មោះ DNS ដែលទើបបង្កើតថ្មីៗ។
ដោយវិធីនេះ នៅពេលបង្កើតម៉ាស៊ីននិម្មិត IP ខាងក្នុង និងឈ្មោះ DNS ខាងក្នុងត្រូវបានផ្តល់ឱ្យ ដូច្នេះអ្នកអាចចូលប្រើម៉ាស៊ីនមេនៅក្នុងបណ្តាញតាមឈ្មោះ៖

ubuntu@build:~$ ping kafka.ru-central1.internal
PING kafka.ru-central1.internal (172.16.1.31) 56(84) bytes of data.
64 bytes from kafka.ru-central1.internal (172.16.1.31): icmp_seq=1 ttl=63 time=1.23 ms
64 bytes from kafka.ru-central1.internal (172.16.1.31): icmp_seq=2 ttl=63 time=0.625 ms
^C
--- kafka.ru-central1.internal ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 0.625/0.931/1.238/0.308 ms

វានឹងមានប្រយោជន៍សម្រាប់យើងក្នុងការចង្អុលបង្ហាញទៅកម្មវិធីបញ្ចប់ដោយ kafk ។

ការប្រមូលផ្តុំកម្មវិធី

អស្ចារ្យណាស់ មានម៉ាស៊ីនមេ មានកម្មវិធីមួយ - អ្វីដែលនៅសេសសល់គឺត្រូវប្រមូលផ្តុំវា ហើយបោះផ្សាយវា។ សម្រាប់ការបង្កើត យើងនឹងប្រើ docker build ធម្មតា ប៉ុន្តែជាកន្លែងផ្ទុករូបភាព យើងនឹងប្រើសេវាកម្មពី Yandex - container registry ។ ប៉ុន្តែរឿងដំបូង។

យើងចម្លងកម្មវិធីទៅម៉ាស៊ីនបង្កើត ចូលតាមរយៈ ssh ហើយប្រមូលផ្តុំរូបភាព៖

vozerov@mba:~/events/terraform (master) $ cd ..
vozerov@mba:~/events (master) $ rsync -av app/ [email protected]:app/

... skipped ...

sent 3849 bytes  received 70 bytes  7838.00 bytes/sec
total size is 3644  speedup is 0.93

vozerov@mba:~/events (master) $ ssh 84.201.132.3 -l ubuntu
ubuntu@build:~$ cd app
ubuntu@build:~/app$ sudo docker build -t app .
Sending build context to Docker daemon  6.144kB
Step 1/9 : FROM golang:latest AS build
... skipped ...

Successfully built 9760afd8ef65
Successfully tagged app:latest

ការប្រយុទ្ធពាក់កណ្តាលត្រូវបានធ្វើរួច - ឥឡូវនេះយើងអាចពិនិត្យមើលមុខងារនៃកម្មវិធីរបស់យើងដោយបើកដំណើរការវាហើយផ្ញើវាទៅ kafka:

ubuntu@build:~/app$ sudo docker run --name app -d -p 8080:8080 app /app/app -kafka=kafka.ru-central1.internal:9092</code>

С локальной машинки можно отправить тестовый event и посмотреть на ответ:

<code>vozerov@mba:~/events (master) $ curl -D - -s -X POST -d '{"key1":"data1"}' http://84.201.132.3:8080/post
HTTP/1.1 200 OK
Content-Type: application/json
Date: Mon, 13 Apr 2020 13:53:54 GMT
Content-Length: 41

{"status":"ok","partition":0,"Offset":0}
vozerov@mba:~/events (master) $

កម្មវិធីបានឆ្លើយតបដោយជោគជ័យនៃការថត និងបង្ហាញលេខសម្គាល់នៃភាគថាស និងអុហ្វសិតដែលសារត្រូវបានរួមបញ្ចូល។ អ្វីដែលនៅសល់ដើម្បីធ្វើគឺបង្កើតបញ្ជីឈ្មោះនៅក្នុង Yandex.Cloud ហើយបង្ហោះរូបភាពរបស់យើងនៅទីនោះ (របៀបធ្វើវាដោយប្រើបន្ទាត់បីត្រូវបានពិពណ៌នានៅក្នុងឯកសារ registry.tf) ។ បង្កើតកន្លែងផ្ទុក៖

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_container_registry.events

... skipped ...

Plan: 1 to add, 0 to change, 0 to destroy.

... skipped ...

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

មានវិធីជាច្រើនក្នុងការផ្ទៀងផ្ទាត់នៅក្នុងបញ្ជីឈ្មោះកុងតឺន័រ - ដោយប្រើសញ្ញាសម្ងាត់ oauth និមិត្តសញ្ញា iam ឬសោគណនីសេវាកម្ម។ ព័ត៌មានលម្អិតបន្ថែមអំពីវិធីសាស្រ្តទាំងនេះអាចរកបាននៅក្នុងឯកសារ។ https://cloud.yandex.ru/docs/container-registry/operations/authentication. យើងនឹងប្រើសោគណនីសេវាកម្ម ដូច្នេះយើងបង្កើតគណនីមួយ៖

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_iam_service_account.docker -target yandex_resourcemanager_folder_iam_binding.puller -target yandex_resourcemanager_folder_iam_binding.pusher

... skipped ...

Apply complete! Resources: 3 added, 0 changed, 0 destroyed.

ឥឡូវនេះអ្វីៗដែលនៅសល់គឺត្រូវបង្កើតកូនសោសម្រាប់វា៖

vozerov@mba:~/events/terraform (master) $ yc iam key create --service-account-name docker -o key.json
id: ajej8a06kdfbehbrh91p
service_account_id: ajep6d38k895srp9osij
created_at: "2020-04-13T14:00:30Z"
key_algorithm: RSA_2048

យើងទទួលបានព័ត៌មានអំពីលេខសម្គាល់នៃការផ្ទុករបស់យើង ផ្ទេរសោ និងចូល៖

vozerov@mba:~/events/terraform (master) $ scp key.json [email protected]:
key.json                                                                                                                    100% 2392   215.1KB/s   00:00

vozerov@mba:~/events/terraform (master) $ ssh 84.201.132.3 -l ubuntu

ubuntu@build:~$ cat key.json | sudo docker login --username json_key --password-stdin cr.yandex
WARNING! Your password will be stored unencrypted in /home/ubuntu/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded
ubuntu@build:~$

ដើម្បីបង្ហោះរូបភាពទៅក្នុងបញ្ជីឈ្មោះ យើងត្រូវការលេខសម្គាល់កុងតឺន័រចុះបញ្ជី យើងយកវាចេញពីឧបករណ៍ប្រើប្រាស់ yc៖

vozerov@mba:~ $ yc container registry get events
id: crpdgj6c9umdhgaqjfmm
folder_id:
name: events
status: ACTIVE
created_at: "2020-04-13T13:56:41.914Z"

បន្ទាប់ពីនោះ យើង tag រូបភាពរបស់យើងជាមួយនឹងឈ្មោះថ្មី ហើយបង្ហោះ៖

ubuntu@build:~$ sudo docker tag app cr.yandex/crpdgj6c9umdhgaqjfmm/events:v1
ubuntu@build:~$ sudo docker push cr.yandex/crpdgj6c9umdhgaqjfmm/events:v1
The push refers to repository [cr.yandex/crpdgj6c9umdhgaqjfmm/events]
8c286e154c6e: Pushed
477c318b05cb: Pushed
beee9f30bc1f: Pushed
v1: digest: sha256:1dd5aaa9dbdde2f60d833be0bed1c352724be3ea3158bcac3cdee41d47c5e380 size: 946

យើងអាចផ្ទៀងផ្ទាត់ថារូបភាពដែលបានផ្ទុកដោយជោគជ័យ៖

vozerov@mba:~/events/terraform (master) $ yc container repository list
+----------------------+-----------------------------+
|          ID          |            NAME             |
+----------------------+-----------------------------+
| crpe8mqtrgmuq07accvn | crpdgj6c9umdhgaqjfmm/events |
+----------------------+-----------------------------+

ដោយវិធីនេះ ប្រសិនបើអ្នកដំឡើងឧបករណ៍ប្រើប្រាស់ yc នៅលើម៉ាស៊ីនលីនុច អ្នកអាចប្រើពាក្យបញ្ជាបាន។

yc container registry configure-docker

ដើម្បីកំណត់រចនាសម្ព័ន្ធ docker ។

សេចក្តីសន្និដ្ឋាន

យើង​បាន​ធ្វើ​ការ​លំបាក​ជា​ច្រើន ហើយ​ជា​លទ្ធផល៖

1. យើងបានបង្កើតស្ថាបត្យកម្មនៃសេវាកម្មនាពេលអនាគតរបស់យើង។
2. យើងបានសរសេរកម្មវិធីមួយនៅក្នុង golang ដែលអនុវត្តតក្កវិជ្ជាអាជីវកម្មរបស់យើង។
3. យើងបានប្រមូលវាហើយចាក់វាទៅក្នុងបញ្ជីឈ្មោះធុងឯកជន។

នៅផ្នែកបន្ទាប់ យើងនឹងបន្តទៅវត្ថុដែលគួរឱ្យចាប់អារម្មណ៍ - យើងនឹងបញ្ចេញកម្មវិធីរបស់យើងទៅក្នុងផលិតកម្ម ហើយទីបំផុតចាប់ផ្តើមដំណើរការលើវា។ កុំប្តូរ!

សម្ភារៈនេះគឺនៅក្នុងការថតវីដេអូនៃសិក្ខាសាលាបើកចំហ REBRAIN & Yandex.Cloud: យើងទទួលយកសំណើ 10 ក្នុងមួយវិនាទីនៅលើ Yandex Cloud - https://youtu.be/cZLezUm0ekE

ប្រសិនបើអ្នកចាប់អារម្មណ៍ក្នុងការចូលរួមក្នុងព្រឹត្តិការណ៍បែបនេះតាមអ៊ីនធឺណិត និងសួរសំណួរក្នុងពេលជាក់ស្តែង សូមភ្ជាប់ទៅ DevOps ដោយឆានែល REBRAIN.

យើងសូមថ្លែងអំណរគុណយ៉ាងជ្រាលជ្រៅចំពោះ Yandex.Cloud សម្រាប់ឱកាសក្នុងការធ្វើជាម្ចាស់ផ្ទះព្រឹត្តិការណ៍បែបនេះ។ ភ្ជាប់ទៅពួកគេ - https://cloud.yandex.ru/prices

ប្រសិនបើអ្នកត្រូវការផ្លាស់ទីទៅពពក ឬមានសំណួរអំពីហេដ្ឋារចនាសម្ព័ន្ធរបស់អ្នក មានអារម្មណ៍សេរីក្នុងការដាក់សំណើ.

PS យើងមានសវនកម្មឥតគិតថ្លៃចំនួន 2 ក្នុងមួយខែ ប្រហែលជាគម្រោងរបស់អ្នកនឹងក្លាយជាមួយក្នុងចំណោមពួកគេ។

ប្រភព: www.habr.com