សេវាកម្មតាមដាន OpenTracing និង Jaeger

យើងប្រើប្រាស់ស្ថាបត្យកម្ម microservice នៅក្នុងគម្រោងរបស់យើង។ នៅពេលដែលការជាប់គាំងនៃការអនុវត្តកើតឡើង ពេលវេលាជាច្រើនត្រូវបានចំណាយក្នុងការត្រួតពិនិត្យ និងញែកកំណត់ហេតុ។ នៅពេលកត់ត្រាពេលវេលានៃប្រតិបត្តិការបុគ្គលទៅឯកសារកំណត់ហេតុ ជាធម្មតាវាពិបាកក្នុងការយល់ពីអ្វីដែលនាំទៅដល់ការហៅប្រតិបត្តិការទាំងនេះ ដើម្បីតាមដានលំដាប់នៃសកម្មភាព ឬការផ្លាស់ប្តូរពេលវេលានៃប្រតិបត្តិការមួយទាក់ទងទៅមួយផ្សេងទៀតនៅក្នុងសេវាកម្មផ្សេងៗ។

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

តើបញ្ហាអ្វីខ្លះអាចត្រូវបានដោះស្រាយជាមួយនឹងការតាមដាន

1. ស្វែងរកការរាំងស្ទះដំណើរការទាំងនៅក្នុងសេវាកម្មតែមួយ និងនៅក្នុងមែកធាងប្រតិបត្តិទាំងមូលរវាងសេវាកម្មដែលចូលរួមទាំងអស់។ ឧទាហរណ៍:
   • ការហៅទូរសព្ទជាប់ៗគ្នាជាច្រើនរវាងសេវាកម្ម ឧទាហរណ៍ ទៅកាន់ geocoding ឬទៅកាន់មូលដ្ឋានទិន្នន័យ។
   • រង់ចាំយូរ I/O ដូចជាការផ្ទេរបណ្តាញ ឬការអានថាស។
   • ការវិភាគទិន្នន័យវែង។
   • ប្រតិបត្តិការយូរដែលទាមទារ CPU ។
   • ផ្នែកនៃកូដដែលមិនចាំបាច់ដើម្បីទទួលបានលទ្ធផលចុងក្រោយ ហើយអាចដកចេញ ឬពន្យារពេលបាន។
2. យល់យ៉ាងច្បាស់នៅក្នុងលំដាប់អ្វីដែលហៅថាអ្វី និងអ្វីដែលកើតឡើងនៅពេលប្រតិបត្តិការត្រូវបានអនុវត្ត។
   
   វាអាចត្រូវបានគេមើលឃើញថាជាឧទាហរណ៍សំណើបានមកដល់សេវា WS -> សេវាកម្ម WS បានបន្ថែមទិន្នន័យតាមរយៈសេវាកម្ម R -> បន្ទាប់មកផ្ញើសំណើទៅសេវាកម្ម V -> សេវាកម្ម V ផ្ទុកទិន្នន័យជាច្រើនពី R ។ សេវាកម្ម -> បានទៅសេវាកម្ម P -> សេវាកម្ម P បានទៅសេវាកម្ម R -> សេវាកម្ម V មិនអើពើនឹងលទ្ធផលហើយបានទៅសេវាកម្ម J -> ហើយបានតែឆ្លើយតបទៅនឹងសេវាកម្ម WS ខណៈពេលដែលបន្តគណនាអ្វីផ្សេងទៀតនៅក្នុង ផ្ទៃខាងក្រោយ។
   បើគ្មានដាន ឬឯកសារលម្អិតសម្រាប់ដំណើរការទាំងមូលទេ វាពិតជាលំបាកណាស់ក្នុងការយល់ដឹងអំពីអ្វីដែលកំពុងកើតឡើងនៅពេលមើលកូដជាលើកដំបូង ហើយកូដត្រូវបានខ្ចាត់ខ្ចាយពាសពេញសេវាកម្មផ្សេងៗ ហើយលាក់នៅពីក្រោយធុងសំរាម និងចំណុចប្រទាក់ជាច្រើន។
3. ការប្រមូលព័ត៌មានអំពីមែកធាងប្រតិបត្តិសម្រាប់ការវិភាគពន្យាពេលជាបន្តបន្ទាប់។ នៅដំណាក់កាលនីមួយៗនៃការប្រតិបត្តិ អ្នកអាចបន្ថែមព័ត៌មានទៅដានដែលមាននៅដំណាក់កាលនេះ ហើយបន្ទាប់មករកមើលថាតើទិន្នន័យបញ្ចូលអ្វីខ្លះដែលនាំទៅដល់សេណារីយ៉ូស្រដៀងគ្នា។ ឧទាហរណ៍:
   • លេខ​សម្គាល់​អ្នក​ប្រើ
   • សិទ្ធិ
   • ប្រភេទនៃវិធីសាស្រ្តដែលបានជ្រើសរើស
   • កំហុសក្នុងកំណត់ហេតុ ឬដំណើរការ
4. បង្វែរដានទៅជាសំណុំរងនៃរង្វាស់ និងការវិភាគបន្ថែមរួចហើយក្នុងទម្រង់ជាម៉ែត្រ។

អ្វីដែលដានអាចកត់ត្រាបាន។ វិសាលភាព

នៅក្នុងការតាមដានមានគំនិតនៃវិសាលភាពមួយ នេះគឺជា analogue នៃកំណត់ហេតុមួយទៅកាន់កុងសូល។ ស្ប៉ាមាន៖

• ឈ្មោះ ជាធម្មតាឈ្មោះនៃវិធីសាស្ត្រដែលត្រូវបានប្រតិបត្តិ
• ឈ្មោះនៃសេវាកម្មដែលវិសាលភាពត្រូវបានបង្កើត
• លេខសម្គាល់តែមួយគត់
• ប្រភេទនៃព័ត៌មានមេតាមួយចំនួនក្នុងទម្រង់ជាសោ/តម្លៃដែលត្រូវបានចូលទៅក្នុងវា។ ឧទាហរណ៍ ប៉ារ៉ាម៉ែត្រវិធីសាស្រ្ត ឬវិធីសាស្ត្របញ្ចប់ដោយកំហុស ឬអត់
• ពេលវេលាចាប់ផ្តើម និងបញ្ចប់សម្រាប់វិសាលភាពនេះ។
• លេខសម្គាល់វិសាលភាពមាតាបិតា

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

Opentrace, Jagger និងរបៀបដែលយើងបានអនុវត្តវាសម្រាប់គម្រោងរបស់យើង។

មានស្តង់ដារធម្មតា។ opentraceដែលពិពណ៌នាអំពីរបៀប និងអ្វីដែលគួរត្រូវបានប្រមូល ដោយមិនភ្ជាប់ដោយការតាមដានទៅនឹងការអនុវត្តជាក់លាក់ណាមួយជាភាសាណាមួយ។ ឧទាហរណ៍ នៅក្នុង Java ការងារទាំងអស់ជាមួយនឹងដានត្រូវបានអនុវត្តតាមរយៈ Opentrace API ទូទៅ ហើយនៅក្រោមវា ឧទាហរណ៍ Jaeger ឬការអនុវត្តលំនាំដើមទទេដែលមិនមានអ្វីអាចត្រូវបានលាក់។
យើងកំពុងប្រើ នាងហិនទ័រ ជាការអនុវត្ត Opentrace ។ វាមានសមាសធាតុជាច្រើន៖

• Jaeger-agent គឺជាភ្នាក់ងារក្នុងស្រុកដែលជាធម្មតាត្រូវបានដំឡើងនៅលើម៉ាស៊ីននីមួយៗ ហើយសេវាកម្មត្រូវបានចូលទៅក្នុងវានៅលើច្រកលំនាំដើមក្នុងតំបន់។ ប្រសិនបើមិនមានភ្នាក់ងារទេ នោះដាននៃសេវាកម្មទាំងអស់នៅលើម៉ាស៊ីននេះជាធម្មតាត្រូវបានបិទ
• Jaeger-collector - ភ្នាក់ងារទាំងអស់ផ្ញើដានដែលប្រមូលបានទៅវា ហើយវាដាក់ពួកវានៅក្នុងមូលដ្ឋានទិន្នន័យដែលបានជ្រើសរើស។
• មូលដ្ឋានទិន្នន័យគឺជា cassandra ដែលពួកគេចូលចិត្ត ប៉ុន្តែយើងប្រើ elasticsearch មានការអនុវត្តសម្រាប់មូលដ្ឋានទិន្នន័យពីរបីផ្សេងទៀត និងការអនុវត្តក្នុងអង្គចងចាំដែលមិនរក្សាទុកអ្វីទៅថាសទេ។
• Jaeger-query គឺជាសេវាកម្មដែលចូលទៅកាន់មូលដ្ឋានទិន្នន័យ ហើយត្រឡប់ដានដែលបានប្រមូលរួចហើយសម្រាប់ការវិភាគ
• Jaeger-ui គឺជាចំណុចប្រទាក់បណ្ដាញសម្រាប់ស្វែងរក និងមើលដាន វាទៅ jaeger-query

សមាសភាគដាច់ដោយឡែកមួយអាចត្រូវបានគេហៅថាការអនុវត្ត opentrace jaeger សម្រាប់ភាសាជាក់លាក់ ដែលតាមរយៈនោះវិសាលភាពត្រូវបានបញ្ជូនទៅ jaeger-agent ។
ការភ្ជាប់ Jagger នៅក្នុង Java ចុះមកដើម្បីអនុវត្តចំណុចប្រទាក់ io.opentracing.Tracer បន្ទាប់ពីនោះដានទាំងអស់តាមរយៈវានឹងហោះហើរទៅកាន់ភ្នាក់ងារពិត។

ផងដែរសម្រាប់សមាសភាគនិទាឃរដូវអ្នកអាចភ្ជាប់ opentracing-spring-cloud-starter និងការអនុវត្តពី Jaeger opentracing-spring-jaeger-cloud-starter ដែលនឹងកំណត់រចនាសម្ព័ន្ធការតាមដានដោយស្វ័យប្រវត្តិសម្រាប់អ្វីគ្រប់យ៉ាងដែលឆ្លងកាត់សមាសធាតុទាំងនេះ ឧទាហរណ៍ សំណើ http ទៅកាន់ឧបករណ៍បញ្ជា សំណើទៅកាន់មូលដ្ឋានទិន្នន័យតាមរយៈ jdbc ។ល។

តាមដាន​ការ​ចូល​ក្នុង Java

នៅកន្លែងណាមួយនៅកម្រិតកំពូល ត្រូវតែបង្កើត Span ដំបូង វាអាចត្រូវបានធ្វើដោយស្វ័យប្រវត្តិ ជាឧទាហរណ៍ ដោយឧបករណ៍បញ្ជានិទាឃរដូវនៅពេលទទួលសំណើ ឬដោយដៃប្រសិនបើមិនមាន។ បន្ទាប់មកវាត្រូវបានបញ្ជូនតាមរយៈវិសាលភាពខាងក្រោម។ ប្រសិនបើវិធីសាស្រ្តណាមួយខាងក្រោមចង់បន្ថែម Span វាយក activeSpan បច្ចុប្បន្នពី Scope បង្កើត Span ថ្មី ហើយនិយាយថាមេរបស់វាជា activeSpan លទ្ធផល ហើយធ្វើឱ្យ Span ថ្មីសកម្ម។ នៅពេលហៅទៅសេវាកម្មខាងក្រៅ វិសាលភាពសកម្មបច្ចុប្បន្នត្រូវបានបញ្ជូនទៅពួកគេ ហើយសេវាកម្មទាំងនោះបង្កើតវិសាលភាពថ្មីដោយយោងទៅលើវិសាលភាពនេះ។
ការងារទាំងអស់ឆ្លងកាត់តាមឧទាហរណ៍ Tracer អ្នកអាចទទួលបានវាតាមរយៈយន្តការ DI ឬ GlobalTracer.get () ជាអថេរសកល ប្រសិនបើយន្តការ DI មិនដំណើរការ។ តាមលំនាំដើម ប្រសិនបើដានមិនត្រូវបានចាប់ផ្តើមទេ NoopTracer នឹងត្រឡប់មកវិញដែលមិនធ្វើអ្វីសោះ។
លើសពីនេះ វិសាលភាពបច្ចុប្បន្នត្រូវបានទទួលពី tracer តាមរយៈ ScopeManager វិសាលភាពថ្មីត្រូវបានបង្កើតឡើងពីបច្ចុប្បន្នជាមួយនឹងការចងនៃវិសាលភាពថ្មី ហើយបន្ទាប់មកវិសាលភាពដែលបានបង្កើតត្រូវបានបិទ ដែលបិទវិសាលភាពដែលបានបង្កើត ហើយត្រឡប់វិសាលភាពមុនទៅ រដ្ឋសកម្ម។ វិសាលភាព​ត្រូវ​បាន​ភ្ជាប់​ទៅ​នឹង​ខ្សែ​ស្រឡាយ ដូច្នេះ​នៅ​ពេល​ដែល​ការ​សរសេរ​កម្មវិធី​ច្រើន​ខ្សែ អ្នក​មិន​ត្រូវ​ភ្លេច​ផ្ទេរ​វិសាលភាព​សកម្ម​ទៅ​ខ្សែ​ស្រឡាយ​ផ្សេង​ទៀត​ឡើយ ​សម្រាប់​ការ​ធ្វើ​ឱ្យ​សកម្ម​បន្ថែម​នៃ​វិសាលភាព​នៃ​ខ្សែស្រឡាយ​ផ្សេង​ទៀត​ដោយ​យោង​ទៅ​លើ​វិសាលភាព​នេះ។

io.opentracing.Tracer tracer = ...; // GlobalTracer.get()

void DoSmth () {
   try (Scope scope = tracer.buildSpan("DoSmth").startActive(true)) {
      ...
   }
}
void DoOther () {
    Span span = tracer.buildSpan("someWork").start();
    try (Scope scope = tracer.scopeManager().activate(span, false)) {
        // Do things.
    } catch(Exception ex) {
        Tags.ERROR.set(span, true);
        span.log(Map.of(Fields.EVENT, "error", Fields.ERROR_OBJECT, ex, Fields.MESSAGE, ex.getMessage()));
    } finally {
        span.finish();
    }
}

void DoAsync () {
    try (Scope scope = tracer.buildSpan("ServiceHandlerSpan").startActive(false)) {
        ...
        final Span span = scope.span();
        doAsyncWork(() -> {
            // STEP 2 ABOVE: reactivate the Span in the callback, passing true to
            // startActive() if/when the Span must be finished.
            try (Scope scope = tracer.scopeManager().activate(span, false)) {
                ...
            }
        });
    }
}

សម្រាប់ការសរសេរកម្មវិធីពហុខ្សែ ក៏មានសេវាកម្ម TracedExecutorService និងរុំស្រដៀងគ្នា ដែលបញ្ជូនវិសាលភាពបច្ចុប្បន្នដោយស្វ័យប្រវត្តិទៅខ្សែស្រលាយ នៅពេលដែលកិច្ចការអសមកាលត្រូវបានចាប់ផ្តើម៖

private ExecutorService executor = new TracedExecutorService(
    Executors.newFixedThreadPool(10), GlobalTracer.get()
);

សម្រាប់សំណើរ http ខាងក្រៅមាន TracingHttpClient

HttpClient httpClient = new TracingHttpClientBuilder().build();

បញ្ហាដែលយើងជួបប្រទះ

• សណ្តែក និង DI មិនតែងតែដំណើរការទេ ប្រសិនបើឧបករណ៍តាមដានមិនត្រូវបានប្រើនៅក្នុងសេវាកម្ម ឬសមាសភាគ មានខ្សែស្វ័យប្រវត្តិ Tracer ប្រហែលជាមិនដំណើរការទេ ហើយអ្នកនឹងត្រូវប្រើ GlobalTracer.get()។
• ចំណារពន្យល់មិនដំណើរការទេ ប្រសិនបើវាមិនមែនជាសមាសភាគ ឬសេវាកម្ម ឬប្រសិនបើវិធីសាស្ត្រត្រូវបានហៅពីវិធីសាស្ត្រជិតខាងនៃថ្នាក់ដូចគ្នា។ អ្នកត្រូវតែប្រុងប្រយ័ត្នដើម្បីពិនិត្យមើលអ្វីដែលដំណើរការ និងប្រើការបង្កើតដានដោយដៃ ប្រសិនបើ @Traced មិនដំណើរការ។ អ្នកក៏អាចភ្ជាប់កម្មវិធីចងក្រងបន្ថែមសម្រាប់ java annotations បន្ទាប់មកពួកវាគួរតែដំណើរការគ្រប់ទីកន្លែង។
• នៅក្នុងការចាប់ផ្ដើមនិទាឃរដូវ និងនិទាឃរដូវចាស់ ការកំណត់រចនាសម្ព័ន្ធស្វ័យប្រវត្ដិពពកនិទាឃរដូវ opentraing មិនដំណើរការទេដោយសារតែកំហុសនៅក្នុង DI បន្ទាប់មកប្រសិនបើអ្នកចង់ឱ្យដាននៅក្នុងសមាសធាតុនិទាឃរដូវដំណើរការដោយស្វ័យប្រវត្តិ អ្នកអាចធ្វើវាដោយភាពស្រដៀងគ្នាជាមួយ github.com/opentracing-contrib/java-spring-jaeger/blob/master/opentracing-spring-jaeger-starter/src/main/java/io/opentracing/contrib/java/spring/jaeger/starter/JaegerAutoConfiguration.java
• សាកល្បងជាមួយធនធានមិនដំណើរការជាចង្អូរទេ អ្នកត្រូវតែប្រើសាកល្បងចុងក្រោយ។
• សេវាកម្មនីមួយៗត្រូវតែមាន spring.application.name ផ្ទាល់ខ្លួនរបស់វា ដែលដាននឹងត្រូវបានកត់ត្រា។ តើអ្វីជាឈ្មោះដាច់ដោយឡែកសម្រាប់ការលក់និងការធ្វើតេស្តដូច្នេះជាការមិនឱ្យជ្រៀតជ្រែកជាមួយពួកគេរួមគ្នា។
• ប្រសិនបើអ្នកប្រើ GlobalTracer និង tomcat នោះសេវាកម្មទាំងអស់ដែលដំណើរការនៅក្នុង tomcat នេះមាន GlobalTracer មួយ ដូច្នេះពួកវាទាំងអស់នឹងមានឈ្មោះសេវាកម្មដូចគ្នា។
• នៅពេលបន្ថែមដានទៅវិធីសាស្ត្រ អ្នកត្រូវប្រាកដថាវាមិនត្រូវបានគេហៅថាច្រើនដងក្នុងរង្វិលជុំទេ។ វាចាំបាច់ក្នុងការបន្ថែមដានទូទៅមួយសម្រាប់ការហៅទូរស័ព្ទទាំងអស់ដែលធានារយៈពេលការងារសរុប។ បើមិនដូច្នោះទេបន្ទុកលើសនឹងត្រូវបានបង្កើត។
• នៅពេលដែលនៅក្នុង jaeger-ui សំណើធំពេកត្រូវបានធ្វើឡើងសម្រាប់ដានមួយចំនួនធំ ហើយដោយសារពួកគេមិនបានរង់ចាំការឆ្លើយតប ពួកគេបានធ្វើវាម្តងទៀត។ ជាលទ្ធផល jaeger-query ចាប់ផ្តើមញ៉ាំការចងចាំច្រើន និងបន្ថយល្បឿនយឺត។ ជួយដោយការចាប់ផ្ដើម jaeger-query ឡើងវិញ

គំរូ រក្សាទុក និងមើលដាន

មានបីប្រភេទ ដានគំរូ:

1. Const ដែលផ្ញើ និងរក្សាទុកដានទាំងអស់។
2. Probabilistic ដែលត្រងដានជាមួយនឹងប្រូបាប៊ីលីតេដែលបានផ្តល់ឱ្យមួយចំនួន។
3. ការកំណត់កម្រិតដែលកំណត់ចំនួនដានក្នុងមួយវិនាទី។ អ្នកអាចកំណត់រចនាសម្ព័ន្ធការកំណត់ទាំងនេះនៅលើម៉ាស៊ីនភ្ញៀវ ទាំងនៅលើភ្នាក់ងារ jaeger ឬនៅលើអ្នកប្រមូល។ ឥឡូវនេះយើងប្រើ const 1 នៅក្នុងជង់អ្នកវាយតម្លៃ ព្រោះមិនមានសំណើច្រើនទេ ប៉ុន្តែពួកគេចំណាយពេលយូរ។ នៅពេលអនាគត ប្រសិនបើវានឹងផ្ទុកលើសទម្ងន់លើប្រព័ន្ធ អ្នកអាចកំណត់វាបាន។

ប្រសិនបើអ្នកប្រើ cassandra នោះតាមលំនាំដើម វារក្សាទុកតែរយៈពេលពីរថ្ងៃប៉ុណ្ណោះ។ យើងកំពុងប្រើ សរសៃពួរ។ ហើយ​ដាន​ត្រូវ​បាន​រក្សា​ទុក​គ្រប់​ពេល​វេលា ហើយ​មិន​ត្រូវ​បាន​លុប​ចេញ​ឡើយ។ លិបិក្រមដាច់ដោយឡែកត្រូវបានបង្កើតឡើងសម្រាប់ថ្ងៃនីមួយៗ ឧទាហរណ៍ jaeger-service-2019-03-04។ នៅពេលអនាគតអ្នកត្រូវកំណត់រចនាសម្ព័ន្ធការសម្អាតដោយស្វ័យប្រវត្តិនូវដានចាស់។

ដើម្បីមើលដានដែលអ្នកត្រូវការ៖

• ជ្រើសរើសសេវាកម្មដែលអ្នកចង់ត្រងដាន ឧទាហរណ៍ tomcat7-លំនាំដើមសម្រាប់សេវាកម្មដែលកំពុងដំណើរការនៅក្នុង tomcat ហើយមិនអាចមានឈ្មោះរបស់វាបានទេ។
• បន្ទាប់មកជ្រើសរើសប្រតិបត្តិការ ចន្លោះពេល និងពេលវេលាប្រតិបត្តិការអប្បបរមា ឧទាហរណ៍ចាប់ពី 10 វិនាទី ដើម្បីធ្វើការប្រតិបត្តិយូរប៉ុណ្ណោះ។
  
• ចូលទៅកាន់ដានមួយ ហើយមើលអ្វីដែលកំពុងថយចុះនៅទីនោះ។
  

ដូចគ្នានេះផងដែរ ប្រសិនបើលេខសម្គាល់សំណើមួយចំនួនត្រូវបានគេស្គាល់ នោះអ្នកអាចស្វែងរកដានដោយលេខសម្គាល់នេះតាមរយៈការស្វែងរកស្លាក ប្រសិនបើលេខសម្គាល់នេះត្រូវបានចូលទៅក្នុងចន្លោះដាន។

ឯកសារ

• ឯកសារបើកចំហ opentracing.io/docs/overview/what-is-tracing
• ឯកសារ jaeger www.jaegertracing.io/docs/1.10
• ការតភ្ជាប់ Jaeger java github.com/jaegertracing/jaeger-client-java
• ការតភ្ជាប់តាមដានការបើកចំហនិទាឃរដូវ
  github.com/jaegertracing/jaeger-client-java
  github.com/opentracing-contrib/java-spring-cloud

អត្ថបទ

• habr.com/ru/company/carprice/blog/340946 Jaeger Opentracing និង Microservices នៅក្នុងគម្រោង PHP និង Golang ពិតប្រាកដ
• www.uber.com/distributed-tracing ការវិវត្តនៃការតាមដានការចែកចាយនៅ Uber Engineering
• opentracing.io/guides/java
• medium.com/jaegertracing/running-jaeger-agent-on-bare-metal-d1fc47d31fab កំពុងដំណើរការភ្នាក់ងារ Jaeger លើដែកទទេ

Видео

• www.youtube.com/watch?v=qg0ENOdP1Lo របៀបដែលយើងប្រើ Jaeger និង Prometheus ដើម្បីចែកចាយសំណួរអ្នកប្រើប្រាស់រហ័ស - Bryan Boreham
• www.youtube.com/watch?v=WRntQsUajow ការណែនាំ៖ Jaeger - Yuri Shkuro, Uber & Pavol Loffay, Red Hat
• www.youtube.com/watch?v=fsHb0qK37bc Serghei Iakovlev, "រឿងតូចមួយនៃជ័យជម្នះដ៏ធំមួយ: OpenTracing, AWS និង Jaeger"

ប្រភព: www.habr.com