Juniper NETWORKS Streaming API Software User Guide

შესავალი:
ეს სახელმძღვანელო გთავაზობთ ინსტრუქციებს, თუ როგორ უნდა ამოიღოთ მონაცემები Paragon Active Assurance-დან პროდუქტის ნაკადის API-ს გამოყენებით. ნაკადის კლიენტი და API შედის Paragon Active Assurance-ის ინსტალაციაში, მაგრამ გარკვეული კონფიგურაციაა საჭირო API-ს გამოყენებამდე. კონფიგურაციის პროცესი დაფარულია "სტრიმინგის API-ის კონფიგურაცია" განყოფილებაში.

Streaming API-ს კონფიგურაცია:
შემდეგი ნაბიჯები ასახავს ნაკადის API-ს კონფიგურაციის პროცესს:

დასრულდაview
კაფკა არის მოვლენის სტრიმინგის პლატფორმა, რომელიც შექმნილია სხვადასხვა წყაროდან მონაცემების რეალურ დროში გადასაღებად და შესანახად. ის იძლევა მოვლენის ნაკადების მართვას განაწილებული, მასშტაბირებადი, შეცდომის შემწყნარებელი და უსაფრთხო გზით. ეს სახელმძღვანელო ფოკუსირებულია კაფკას კონფიგურაციაზე, რათა გამოიყენოს Streaming API ფუნქცია Paragon Active Assurance Control Center-ში.

ტერმინოლოგია
Streaming API საშუალებას აძლევს გარე კლიენტებს მიიღონ მეტრიკის ინფორმაცია კაფკადან. ტესტის აგენტების მიერ ტესტირების ან მონიტორინგის დავალების დროს შეგროვებული მეტრიკა იგზავნება Stream სერვისში. დამუშავების შემდეგ, Stream-ის სერვისი აქვეყნებს ამ მაჩვენებლებს კაფკაზე დამატებით მეტამონაცემებთან ერთად.

კაფკას თემები
Streaming API იყენებს კაფკას თემებს მეტრიკისა და მეტამონაცემების ორგანიზებისა და შესანახად. კაფკას თემების შექმნა და მართვა შესაძლებელია კონკრეტული მოთხოვნების შესაბამისად.

Streaming API-ის ჩართვა
Streaming API-ის ჩასართავად, მიჰყევით ამ ნაბიჯებს:

შეასრულეთ შემდეგი ბრძანებები საკონტროლო ცენტრის სერვერზე sudo-ს გამოყენებით:

KAFKA_METRICS_ENABLED = True sudo ncc სერვისები ჩართავს timescaledb მეტრიკა sudo ncc სერვისების დაწყების დროscaledb მეტრიკა sudo ncc სერვისების გადატვირთვა

შეამოწმეთ, რომ Streaming API მუშაობს საკონტროლო ცენტრში:
იმის დასადასტურებლად, რომ იღებთ მეტრიკას სწორ კაფკას თემებზე:

დააინსტალირეთ kafkacat პროგრამა შემდეგი ბრძანებებით:
sudo apt-get განახლება
sudo apt-get install kafkacat

შეცვალეთ "myaccount" თქვენი ანგარიშის მოკლე სახელით
საკონტროლო ცენტრი URL:
ექსპორტი METRICS_TOPIC=paa.public.accounts.myaccount.metrics
ექსპორტი METADATA_TOPIC=paa.public.accounts.myaccount.metadata

გაუშვით შემდეგი ბრძანება view მეტრიკა:
kafkacat -b ${KAFKA_FQDN}:9092 -t ${METRICS_TOPIC} -C -e
შენიშვნა: ზემოაღნიშნული ბრძანება აჩვენებს მეტრიკას.
რომ view მეტამონაცემები, გაუშვით შემდეგი ბრძანება:
kafkacat -b ${KAFKA_FQDN}:9092 -t ${METADATA_TOPIC} -C -e

შენიშვნა: ზემოთ მოცემული ბრძანება აჩვენებს მეტამონაცემებს, მაგრამ ის არ განახლდება ხშირად.

კლიენტი ეგamples
კლიენტისთვის ყოფილიampმეტი ინფორმაცია და დამატებითი ინფორმაცია იხილეთ მომხმარებლის სახელმძღვანელოს მე-14 გვერდზე.

FAQ (ხშირად დასმული კითხვები)

Q: რა არის Paragon Active Assurance?
პასუხი: Paragon Active Assurance არის პროდუქტი, რომელიც უზრუნველყოფს მონიტორინგისა და ტესტირების შესაძლებლობებს.

Q: რა არის Streaming API?
პასუხი: Streaming API არის ფუნქცია Paragon Active Assurance-ში, რომელიც საშუალებას აძლევს გარე კლიენტებს მიიღონ მეტრიკის ინფორმაცია კაფკადან.
Q: როგორ გავააქტიურო Streaming API?
A: Streaming API-ის ჩასართავად, მიჰყევით ინსტრუქციის „Streaming API-ს ჩართვა“ განყოფილებაში მოცემულ ნაბიჯებს.

Q: როგორ შემიძლია გადავამოწმო, რომ Streaming API მუშაობს?
A: იხილეთ განყოფილება „გადამოწმება, რომ Streaming API მუშაობს საკონტროლო ცენტრში“ ინსტრუქციებისთვის, თუ როგორ უნდა გადაამოწმოთ Streaming API-ს ფუნქციონირება.

შესავალი

ეს სახელმძღვანელო აღწერს, თუ როგორ უნდა ამოიღოთ მონაცემები Paragon Active Assurance-დან პროდუქტის ნაკადის API-ის მეშვეობით.
API, ისევე როგორც ნაკადის კლიენტი შედის Paragon Active Assurance ინსტალაციაში. თუმცა, ცოტა კონფიგურაციაა საჭირო, სანამ შეძლებთ API-ს გამოყენებას. ეს აღწერილია "სტრიმინგის API-ის კონფიგურაცია" გვერდზე 1 თავში.

დასრულდაview
ეს თავი აღწერს, თუ როგორ უნდა დააკონფიგურიროთ Streaming API, რათა მოხდეს მეტრიკის შეტყობინებების გამოწერა კაფკას მეშვეობით.
pr
ქვემოთ განვიხილავთ:

როგორ ჩართოთ Streaming API

როგორ დავაკონფიგურიროთ კაფკა გარე კლიენტების მოსასმენად
როგორ დავაკონფიგურიროთ კაფკა, რომ გამოიყენოს ACL და დააყენოს SSL დაშიფვრა აღნიშნული კლიენტებისთვის

რა არის კაფკა?
კაფკა არის მოვლენის სტრიმინგის პლატფორმა, რომელიც საშუალებას აძლევს რეალურ დროში გადაიღოს სხვადასხვა მოვლენის წყაროდან (სენსორები, მონაცემთა ბაზები, მობილური მოწყობილობები) გაგზავნილი მონაცემები მოვლენის ნაკადების სახით, ასევე ამ მოვლენების ნაკადების გრძელვადიანი შენახვა შემდგომი მოძიებისა და მანიპულირებისთვის.
კაფკასთან ერთად შესაძლებელია ღონისძიების სტრიმინგის თავიდან ბოლომდე მართვა განაწილებული, ძალიან მასშტაბირებადი, ელასტიური, ხარვეზებისადმი ტოლერანტული და უსაფრთხო გზით.

შენიშვნა: კაფკას კონფიგურაცია შესაძლებელია სხვადასხვა გზით და შექმნილია მასშტაბურობისა და ზედმეტი სისტემებისთვის. ეს დოკუმენტი ყურადღებას ამახვილებს მხოლოდ იმაზე, თუ როგორ უნდა დააკონფიგურიროთ ის, რომ გამოიყენოთ Streaming API ფუნქცია, რომელიც ნაპოვნია Paragon Active Assurance Control Center-ში. უფრო მოწინავე პარამეტრებისთვის ჩვენ მივმართავთ კაფკას ოფიციალურ დოკუმენტაციას: kafka.apache.org/26/documentation.html.

ტერმინოლოგია

კაფკა: ღონისძიების სტრიმინგის პლატფორმა.

კაფკას თემა: მოვლენათა კრებული.
კაფკას აბონენტი/მომხმარებელი: კომპონენტი, რომელიც პასუხისმგებელია კაფკას თემაში შენახული მოვლენების მოძიებაზე.
კაფკას ბროკერი: კაფკას კლასტერის შენახვის ფენის სერვერი.
SSL/TLS: SSL არის უსაფრთხო პროტოკოლი, რომელიც შემუშავებულია ინფორმაციის უსაფრთხოდ გასაგზავნად ინტერნეტით. TLS არის SSL-ის მემკვიდრე, რომელიც დაინერგა 1999 წელს.
SASL: ჩარჩო, რომელიც უზრუნველყოფს მომხმარებლის ავთენტიფიკაციის, მონაცემთა მთლიანობის შემოწმების და დაშიფვრის მექანიზმებს.
Streaming API აბონენტი: კომპონენტი, რომელიც პასუხისმგებელია Paragon Active Assurance-ში განსაზღვრულ თემებში შენახული მოვლენების მოძიებაზე და განკუთვნილია გარე წვდომისთვის.
სერტიფიკატის ავტორიტეტი: სანდო სუბიექტი, რომელიც გასცემს და აუქმებს საჯარო გასაღების სერტიფიკატებს.
სერტიფიკატის ავტორიტეტის ძირეული სერტიფიკატი: საჯარო გასაღების სერტიფიკატი, რომელიც განსაზღვრავს სერტიფიკატის ორგანოს.

როგორ მუშაობს Streaming API
როგორც უკვე აღვნიშნეთ, Streaming API საშუალებას აძლევს გარე კლიენტებს მიიღონ ინფორმაცია მეტრიკის შესახებ კაფკადან.

ტესტის აგენტების მიერ ტესტირების ან მონიტორინგის დავალების დროს შეგროვებული ყველა მეტრიკა იგზავნება Stream სერვისში. დამუშავების ფაზის შემდეგ, Stream სერვისი აქვეყნებს ამ მაჩვენებლებს კაფკაზე დამატებით მეტამონაცემებთან ერთად.

კაფკას თემები
კაფკას აქვს თემების კონცეფცია, რომლებზეც გამოქვეყნებულია ყველა მონაცემი. Paragon Active Assurance-ში ბევრი ასეთი კაფკას თემაა ხელმისაწვდომი; თუმცა, მათგან მხოლოდ მცირე ნაწილია გათვლილი გარე წვდომისთვის.
ყოველ Paragon Active Assurance ანგარიშს საკონტროლო ცენტრში აქვს ორი გამოყოფილი თემა. ქვემოთ, ACCOUNT არის ანგარიშის მოკლე სახელი:

paa.public.accounts.{ACCOUNT}.metrics
- ყველა მეტრიკის შეტყობინება მოცემული ანგარიშისთვის გამოქვეყნებულია ამ თემაზე
- დიდი რაოდენობით მონაცემები
- განახლების მაღალი სიხშირე
paa.public.accounts.{ACCOUNT}.მეტამონაცემები
- შეიცავს მეტამონაცემებს, რომლებიც დაკავშირებულია მეტრიკის მონაცემებთან, მაგampმეტრიკასთან დაკავშირებული ტესტი, მონიტორი ან ტესტის აგენტი
- მცირე რაოდენობით მონაცემები
- განახლების დაბალი სიხშირე

Streaming API-ის ჩართვა

შენიშვნა: ეს ინსტრუქციები უნდა იყოს გაშვებული საკონტროლო ცენტრის სერვერზე sudo-ს გამოყენებით.

მას შემდეგ, რაც Streaming API ამატებს გარკვეულ ზედნადებს საკონტროლო ცენტრს, ის არ არის ჩართული ნაგულისხმევად. API-ს ჩასართავად, ჯერ უნდა გავააქტიუროთ მეტრიკის გამოქვეყნება კაფკაზე მთავარ კონფიგურაციაში. file:

/etc/netrounds/netrounds.conf

KAFKA_METRICS_ENABLED = მართალია

გაფრთხილება: ამ ფუნქციის ჩართვამ შესაძლოა გავლენა მოახდინოს საკონტროლო ცენტრის მუშაობაზე. დარწმუნდით, რომ თქვენი ინსტანციის განზომილება შესაბამისად გაქვთ.

შემდეგი, ამ მეტრიკის გადაგზავნა კაფკას სწორ თემებზე:

/etc/netrounds/metrics.yaml

ნაკადი-api: მართალია

Streaming API სერვისების ჩასართავად და დასაწყებად, გაუშვით:

sudo ncc სერვისები რთავს timescaledb მეტრიკას
sudo ncc სერვისები იწყება timescaledb მეტრიკა

და ბოლოს, გადატვირთეთ სერვისები:

sudo ncc სერვისების გადატვირთვა

დადასტურება, რომ Streaming API მუშაობს საკონტროლო ცენტრში

შენიშვნა: ეს ინსტრუქციები უნდა იყოს გაშვებული საკონტროლო ცენტრის სერვერზე.

ახლა შეგიძლიათ დაადასტუროთ, რომ იღებთ მეტრიკას სწორ კაფკას თემებზე. ამისათვის დააინსტალირეთ kafkacat უტილიტა:

sudo apt-get განახლება

sudo apt-get install kafkacat

თუ თქვენ გაქვთ ტესტი ან მონიტორი გაშვებული საკონტროლო ცენტრში, თქვენ უნდა შეგეძლოთ გამოიყენოთ kafkacat ამ თემებზე მეტრიკისა და მეტამონაცემების მისაღებად.
შეცვალეთ myaccount თქვენი ანგარიშის მოკლე სახელით (ეს არის ის, რასაც ხედავთ თქვენს საკონტროლო ცენტრში URL):

ექსპორტი METRICS_TOPIC=paa.public.accounts.myaccount.metrics

ექსპორტი METADATA_TOPIC=paa.public.accounts.myaccount.metadata

ახლა თქვენ უნდა ნახოთ მეტრიკა ამ ბრძანების გაშვებით:

kafkacat -b ${KAFKA_FQDN}:9092 -t ${METRICS_TOPIC} -C -e

რომ view მეტამონაცემები, გაუშვით შემდეგი ბრძანება (გაითვალისწინეთ, რომ ეს არ განახლდება ხშირად):

kafkacat -b ${KAFKA_FQDN}:9092 -t ${METADATA_TOPIC} -C -e

შენიშვნა:
kafkacat”კლიენტი ყოფილიamples ”მე –14 გვერდზე

ეს ადასტურებს, რომ ჩვენ გვაქვს მოქმედი Streaming API საკონტროლო ცენტრიდან. თუმცა, სავარაუდოდ, თქვენ დაინტერესებული ხართ გარე კლიენტის მონაცემებზე წვდომით. შემდეგი განყოფილება აღწერს, თუ როგორ უნდა გახსნათ კაფკა გარე წვდომისთვის.

კაფკას გახსნა გარე მასპინძლებისთვის

ნაგულისხმევად, საკონტროლო ცენტრში გაშვებული კაფკა არის კონფიგურირებული, რომ მოუსმინოს მხოლოდ ლოკალჰოსტს შიდა გამოყენებისთვის. შესაძლებელია კაფკას გახსნა გარე კლიენტებისთვის კაფკას პარამეტრების შეცვლით.

კაფკასთან დაკავშირება: გაფრთხილებები

სიფრთხილე: გთხოვთ, ყურადღებით წაიკითხოთ ეს, რადგან ადვილია კაფკასთან კავშირთან დაკავშირებული საკითხების გაჩენა, თუ ეს ცნებები არ გესმით.

ამ დოკუმენტში აღწერილი საკონტროლო ცენტრის კონფიგურაციაში არის მხოლოდ ერთი კაფკას ბროკერი.
თუმცა, გაითვალისწინეთ, რომ კაფკას ბროკერი გამიზნულია იმუშაოს როგორც კაფკას კლასტერის ნაწილი, რომელიც შეიძლება შედგებოდეს მრავალი კაფკას ბროკერისგან.
კაფკას ბროკერთან დაკავშირებისას, საწყისი კავშირი იქმნება კაფკას კლიენტის მიერ. ამასთან დაკავშირებით, კაფკას ბროკერი თავის მხრივ დააბრუნებს „რეკლამირებული მსმენელთა“ სიას, რომელიც არის ერთი ან რამდენიმე კაფკას ბროკერის სია.
ამ სიის მიღებისას კაფკას კლიენტი გათიშავს და შემდეგ ხელახლა დაუკავშირდება ამ რეკლამირებულ მსმენელს. რეკლამირებული მსმენელები უნდა შეიცავდეს ჰოსტის სახელებს ან IP მისამართებს, რომლებიც ხელმისაწვდომია კაფკას კლიენტისთვის, წინააღმდეგ შემთხვევაში კლიენტი ვერ დაუკავშირდება.
თუ გამოიყენება SSL დაშიფვრა, რომელიც მოიცავს SSL სერთიფიკატს, რომელიც დაკავშირებულია კონკრეტულ ჰოსტის სახელთან, კიდევ უფრო მნიშვნელოვანია, რომ კაფკას კლიენტმა მიიღოს სწორი მისამართი დასაკავშირებლად, რადგან წინააღმდეგ შემთხვევაში კავშირი შეიძლება უარყოფილი იყოს.
წაიკითხეთ მეტი კაფკას მსმენელების შესახებ აქ: www.confluent.io/blog/kafka-listeners-explained

SSL/TLS დაშიფვრა
იმისათვის, რომ დავრწმუნდეთ, რომ მხოლოდ სანდო კლიენტებს აქვთ წვდომა Kafka-სა და Streaming API-ზე, ჩვენ უნდა დავაკონფიგურიროთ შემდეგი:

ავთენტიფიკაცია: კლიენტებმა უნდა მიაწოდონ მომხმარებლის სახელი და პაროლი კლიენტსა და კაფკას შორის SSL/TLS უსაფრთხო კავშირის საშუალებით.
ავტორიზაცია: ავთენტიფიცირებულ კლიენტებს შეუძლიათ შეასრულონ ამოცანები, რომლებიც რეგულირდება ACL-ებით.

აქ არის დასრულდაview:

*) მომხმარებლის სახელის/პაროლის ავთენტიფიკაცია შესრულებულია SSL-ში დაშიფრულ არხზე

იმის გასაგებად, თუ როგორ მუშაობს SSL/TLS დაშიფვრა კაფკასთვის, გთხოვთ, მიმართოთ ოფიციალურ დოკუმენტაციას: docs.confluent.io/platform/current/kafka/encryption.html

SSL/TLS სერთიფიკატი დასრულდაview

შენიშვნა: ამ ქვეგანყოფილებაში ჩვენ გამოვიყენებთ შემდეგ ტერმინოლოგიას:

სერთიფიკატი: SSL სერთიფიკატი, რომელსაც ხელს აწერს სერტიფიკატის ავტორიტეტი (CA). კაფკას თითოეულ ბროკერს ჰყავს ერთი.
გასაღებების მაღაზია: გასაღების მაღაზია file რომელიც ინახავს სერთიფიკატს. გასაღებების მაღაზია file შეიცავს სერტიფიკატის პირად გასაღებს; ამიტომ საჭიროა მისი უსაფრთხოდ შენახვა.
Truststore: ა file შეიცავს სანდო CA სერთიფიკატებს.

კონტროლის ცენტრში გაშვებულ გარე კლიენტსა და კაფკას შორის ავტორიზაციის დასაყენებლად, ორივე მხარეს უნდა ჰქონდეს გასაღების საცავი განსაზღვრული შესაბამისი სერტიფიკატით, რომელსაც ხელს აწერს სერტიფიკატის ორგანო (CA) CA root სერთიფიკატთან ერთად.
გარდა ამისა, კლიენტს ასევე უნდა ჰქონდეს Truststore CA root სერთიფიკატით.
CA root სერთიფიკატი საერთოა კაფკას ბროკერისთვის და კაფკას კლიენტისთვის.

საჭირო სერთიფიკატების შექმნა
ეს მოცემულია „დანართში“ მე-17 გვერდზე.

კაფკა ბროკერის SSL/TLS კონფიგურაცია საკონტროლო ცენტრში

შენიშვნა: სანამ გააგრძელებთ, თქვენ უნდა შექმნათ გასაღების საცავი, რომელიც შეიცავს SSL სერთიფიკატს, მიჰყვებით ინსტრუქციებს „დანართში“ გვერდზე 17. ქვემოთ აღნიშნული ბილიკები მოდის ამ ინსტრუქციებიდან.
SSL გასაღებების მაღაზია არის ა file ინახება დისკზე ერთად file გაფართოება .jks.

მას შემდეგ რაც თქვენ გექნებათ საჭირო სერთიფიკატები შექმნილი როგორც კაფკას ბროკერისთვის, ასევე კაფკას კლიენტისთვის, შეგიძლიათ გააგრძელოთ საკონტროლო ცენტრში გაშვებული კაფკას ბროკერის კონფიგურაცია. თქვენ უნდა იცოდეთ შემდეგი:

: საკონტროლო ცენტრის საჯარო ჰოსტის სახელი; ეს უნდა იყოს მოგვარებადი და ხელმისაწვდომი კაფკას კლიენტებისთვის.
: გასაღების მაღაზიის პაროლი, რომელიც მითითებულია SSL სერთიფიკატის შექმნისას.

და : ეს არის პაროლები, რომლებიც გსურთ დააყენოთ ადმინისტრატორისა და კლიენტის მომხმარებლისთვის, შესაბამისად. გაითვალისწინეთ, რომ თქვენ შეგიძლიათ დაამატოთ მეტი მომხმარებელი, როგორც ეს მითითებულია ყოფილშიampლე.

შეცვალეთ ან დაამატეთ (sudo წვდომით) ქვემოთ მოცემული თვისებები /etc/kafka/server.properties-ში, ჩასვით ზემოთ ცვლადები, როგორც ნაჩვენებია:

გაფრთხილება: არ წაშალოთ PLAINTEXT://localhost:9092; ეს დაარღვევს საკონტროლო ცენტრის ფუნქციონირებას, რადგან შიდა სერვისები ვერ შეძლებენ კომუნიკაციას.

…
# მისამართები, რომლებსაც კაფკას ბროკერი უსმენს.
მსმენელები=PLAINTEXT://localhost:9092,SASL_SSL://0.0.0.0:9093

# ეს არის მასპინძლები, რომლებიც რეკლამირებულია ნებისმიერ კლიენტთან, რომელიც აკავშირებს.
advertised.listeners=PLAINTEXT://localhost:9092,SASL_SSL:// :9093…
####### მორგებული კონფიგურაცია

# SSL კონფიგურაცია
ssl.endpoint.identification.algorithm=
ssl.keystore.location=/var/ssl/private/kafka.server.keystore.jks
ssl.keystore.password=

ssl.key.password=
ssl.client.auth=none
ssl.protocol=TLSv1.2

# SASL კონფიგურაცია
sasl.enabled.mechanisms=PLAIN
მომხმარებლის სახელი=”ადმინ” \

პაროლი =” ” \
user_admin=” ” \
მომხმარებლის_კლიენტი=” ”;

# შენიშვნა მომხმარებლის_თან შეიძლება დაემატოს მეტი მომხმარებელი =
# ავტორიზაცია, ჩართეთ ACL
autorizer.class.name=kafka.security.authorizer.AclAuthorizer super.users=მომხმარებელი:admin

წვდომის კონტროლის სიების (ACL) დაყენება

ACL-ების ჩართვა ლოკალჰოსტზე

გაფრთხილება: ჯერ უნდა დავაყენოთ ACL ლოკალური ჰოსტისთვის, რათა თავად საკონტროლო ცენტრმა მაინც შეძლოს კაფკაზე წვდომა. თუ ეს არ გაკეთდა, ყველაფერი იშლება.

–ავტორიზატორი kafka.security.authorizer.AclAuthorizer \

–autorizer-properties zookeeper.connect=localhost:2181 \
–დამატება –დაშვება–ძირითადი მომხმარებელი:ANONYMOUS –allow-host 127.0.0.1 –კლასტერი
/usr/lib/kafka/bin/kafka-acls.sh \

–ავტორიზატორი kafka.security.authorizer.AclAuthorizer \
–autorizer-properties zookeeper.connect=localhost:2181 \
–add –allow-ძირითადი მომხმარებელი:ANONYMOUS –allow-host 127.0.0.1 –თემა '*'

/usr/lib/kafka/bin/kafka-acls.sh \
–ავტორიზატორი kafka.security.authorizer.AclAuthorizer \
–autorizer-properties zookeeper.connect=localhost:2181 \

–add –allow-ძირითადი მომხმარებელი:ANONYMOUS –allow-host 127.0.0.1 –ჯგუფი '*'

შემდეგ ჩვენ უნდა გავააქტიუროთ ACL გარე მხოლოდ წასაკითხად წვდომისთვის, რათა გარე მომხმარებლებს მიეცეთ უფლება წაიკითხონ paa.public.* თემები.

### ACL-ის ჩანაწერები ანონიმური მომხმარებლებისთვის /usr/lib/kafka/bin/kafka-acls.sh \

შენიშვნა: უფრო წვრილმარცვლოვანი კონტროლისთვის, გთხოვთ, მიმართოთ კაფკას ოფიციალურ დოკუმენტაციას.

–ავტორიზატორი kafka.security.authorizer.AclAuthorizer \
–autorizer-properties zookeeper.connect=localhost:2181 \
–დამატება –დაშვება–ძირითადი მომხმარებელი:* –ოპერაციის წაკითხვა –ოპერაციის აღწერა \ –ჯგუფი „NCC“

/usr/lib/kafka/bin/kafka-acls.sh \
–ავტორიზატორი kafka.security.authorizer.AclAuthorizer \
–autorizer-properties zookeeper.connect=localhost:2181 \

–add –allow-principal მომხმარებელი:* –ოპერაცია წაკითხვა –ოპერაცია describe \ –თემა paa.public. -რესურსების-თარგის ტიპის პრეფიქსი

ამის დასრულების შემდეგ, თქვენ უნდა გადატვირთოთ სერვისები:

### ACL-ის ჩანაწერები გარე მომხმარებლებისთვის /usr/lib/kafka/bin/kafka-acls.sh \

sudo ncc სერვისების გადატვირთვა

იმის დასადასტურებლად, რომ კლიენტს შეუძლია უსაფრთხო კავშირის დამყარება, გაუშვით შემდეგი ბრძანება გარედან
კლიენტის კომპიუტერი (არა საკონტროლო ცენტრის სერვერზე). ქვემოთ, PUBLIC_HOSTNAME არის საკონტროლო ცენტრის ჰოსტის სახელი:

openssl s_client -debug -დაკავშირება ${PUBLIC_HOSTNAME}:9093 -tls1_2 | grep "უსაფრთხო ხელახალი მოლაპარაკება მხარდაჭერილია"

ბრძანების გამომავალში თქვენ უნდა ნახოთ სერვერის სერთიფიკატი, ასევე შემდეგი:

უსაფრთხო ხელახალი მოლაპარაკება არის მხარდაჭერილი

იმის უზრუნველსაყოფად, რომ შიდა სერვისებს მიენიჭათ წვდომა კაფკას სერვერზე, გთხოვთ, შეამოწმოთ შემდეგი ჟურნალიfiles:

/var/log/kafka/server.log

/var/log/kafka/kafka-authorizer.log

გარე კლიენტებთან კავშირის დადასტურება

კაფკაკატი

შენიშვნა: ეს ინსტრუქციები უნდა იყოს გაშვებული კლიენტის კომპიუტერზე (არა საკონტროლო ცენტრის სერვერზე).
შენიშვნა: მეტრიკის ინფორმაციის საჩვენებლად, დარწმუნდით, რომ მინიმუმ ერთი მონიტორი მუშაობს საკონტროლო ცენტრში.

კავშირის, როგორც გარე კლიენტის შესამოწმებლად და დასადასტურებლად, შესაძლებელია გამოიყენოთ kafkacat პროგრამა, რომელიც დაინსტალირებული იყო განყოფილებაში „გადამოწმება, რომ Streaming API მუშაობს საკონტროლო ცენტრში“ მე-4 გვერდზე.
შეასრულეთ შემდეგი ნაბიჯები:

შენიშვნა: ქვემოთ, CLIENT_USER არის ადრე მითითებული მომხმარებელი file /etc/kafka/server.properties საკონტროლო ცენტრში: კერძოდ, user_client და იქ დაყენებული პაროლი.
CA root სერთიფიკატი, რომელიც გამოიყენება სერვერის SSL სერთიფიკატის ხელმოწერისთვის, უნდა იყოს წარმოდგენილი კლიენტზე.

შექმენით ა file კლიენტი.თვისებები შემდეგი შინაარსით:

security.protocol=SASL_SSL
ssl.ca.location={PATH_TO_CA_CERT}
sasl.mechanisms=PLAIN
sasl.username={CLIENT_USER}
sasl.password={CLIENT_PASSWORD}

სადაც

{PATH_TO_CA_CERT} არის CA root სერტიფიკატის მდებარეობა, რომელსაც იყენებს კაფკა ბროკერი
{CLIENT_USER} და {CLIENT_PASSWORD} არის მომხმარებლის სერთიფიკატები კლიენტისთვის.

გაუშვით შემდეგი ბრძანება kafkacat-ის მიერ მოხმარებული შეტყობინების სანახავად:

ექსპორტი KAFKA_FQDN=
METRICS_TOPIC=paa.public.accounts ექსპორტი. .მეტრიკა
kafkacat -b ${KAFKA_FQDN}:9093 -F client.properties -t ${METRICS_TOPIC} -C -e

სადაც {METRICS_TOPIC} არის კაფკას თემის სახელი პრეფიქსით „paa.public.“.

შენიშვნა: kafkacat-ის ძველი ვერსიები არ იძლევა -F ვარიანტს a-დან კლიენტის პარამეტრების წასაკითხად file. თუ თქვენ იყენებთ ასეთ ვერსიას, თქვენ უნდა მიაწოდოთ იგივე პარამეტრები ბრძანების ხაზიდან, როგორც ნაჩვენებია ქვემოთ.

kafkacat -b ${KAFKA_FQDN}:9093 \

X security.protocol=SASL_SSL \
X ssl.ca.location={PATH_TO_CA_CERT} \
X sasl.mechanisms=PLAIN \
X sasl.username={CLIENT_USER} \
X sasl.password={CLIENT_PASSWORD} \
t ${METRICS_TOPIC} -C -e

კავშირის გამართვის მიზნით, შეგიძლიათ გამოიყენოთ -d ვარიანტი:

სამომხმარებლო კომუნიკაციების გამართვა
kafkacat -d მომხმარებელი -b ${KAFKA_FQDN}:9093 -F client.properties -t ${METRICS_TOPIC} -C -e
# ბროკერის კომუნიკაციების გამართვა
kafkacat -d ბროკერი -b ${KAFKA_FQDN}:9093 -F client.properties -t ${METRICS_TOPIC} -C -e

დარწმუნდით, რომ მიმართეთ დოკუმენტაციას გამოყენებული კაფკას კლიენტის ბიბლიოთეკისთვის, რადგან თვისებები შეიძლება განსხვავდებოდეს client.properties-ში.

შეტყობინების ფორმატი
მეტრიკისა და მეტამონაცემების თემებისთვის გამოყენებული შეტყობინებები სერიალირებულია პროტოკოლის ბუფერების (protobuf) ფორმატში (იხ. developers.google.com/protocol-buffers). ამ შეტყობინებების სქემები შეესაბამება შემდეგ ფორმატს:

Metrics Protobuf სქემა

სინტაქსი = “proto3”;
იმპორტი „google/protobuf/timestamp.პროტო”;
პაკეტი paa.streamingapi;
ვარიანტი go_package = „.;paa_streamingapi“;
შეტყობინების მეტრიკა {
google.protobuf.Timestamp დროისamp = 1;
რუკა მნიშვნელობები = 2;
int32 stream_id = 3;
}
/**
* მეტრიკული მნიშვნელობა შეიძლება იყოს მთელი რიცხვი ან float.
*/
შეტყობინება MetricValue {
ერთი ტიპის {
int64 int_val = 1;
float float_val = 2;
}
}

მეტამონაცემების Protobuf სქემა

სინტაქსი = “proto3”;
პაკეტი paa.streamingapi;
ვარიანტი go_package = „.;paa_streamingapi“;
შეტყობინების მეტამონაცემები {
int32 stream_id = 1;
სიმებიანი ნაკადის_სახელი = 2;
რუკა tags = 13;
}

კლიენტი ეგamples

შენიშვნა: ეს ბრძანებები გამიზნულია გარე კლიენტზე გასაშვებად, მაგampთქვენი ლეპტოპი ან მსგავსი, და არა საკონტროლო ცენტრში.
შენიშვნა: მეტრიკის ინფორმაციის ჩვენებისთვის, დარწმუნდით, რომ მინიმუმ ერთი მონიტორი მუშაობს საკონტროლო ცენტრში.

საკონტროლო ცენტრის tarball მოიცავს არქივს paa-streaming-api-client-examples.tar.gz (კლიენტი-ექსamples), რომელიც შეიცავს ყოფილიample Python სკრიპტი, რომელიც აჩვენებს, თუ როგორ გამოიყენოთ Streaming API.

კლიენტის ინსტალაცია და კონფიგურაცია Examples
თქვენ იპოვით კლიენტ-ყოფილსampParagon Active Assurance Control Center საქაღალდეში:

ექსპორტი CC_VERSION=4.1.0
cd ./paa-control-center_${CC_VERSION}
ls paa-streaming-api-client-examples*

კლიენტის ყოფილი ინსტალაციისთვისampთქვენს გარე კლიენტ კომპიუტერზე, გააგრძელეთ შემდეგნაირად:

# შექმენით დირექტორია კლიენტის შინაარსის ამოსაღებადamples tarball
mkdir paa-streaming-api-client-examples
# ამოიღეთ კლიენტის შინაარსი examples tarball
tar xzf paa-streaming-api-client-examples.tar.gz -C paa-streaming-api-client-examples
# გადადით ახლად შექმნილ დირექტორიაში
cd paa-streaming-api-client-examples

კლიენტი-ყოფილიamples მოითხოვს Docker-ის გასაშვებად. Docker-ის ჩამოტვირთვების და ინსტალაციის ინსტრუქციები შეგიძლიათ იხილოთ აქ https://docs.docker.com/engine/install.

კლიენტის გამოყენება Examples
კლიენტი-ყოფილიamples ინსტრუმენტებს შეუძლიათ იმუშაონ როგორც საბაზისო, ისე გაფართოებულ რეჟიმში ყოფილი ასაშენებლადampსხვადასხვა სირთულის. ორივე შემთხვევაში შესაძლებელია ყოფილის გაშვებაცamples კონფიგურაციით file შეიცავს დამატებით თვისებებს კლიენტის მხარის შემდგომი პერსონალიზაციისთვის.

ძირითადი რეჟიმი
საბაზისო რეჟიმში, მეტრიკა და მათი მეტამონაცემები ცალ-ცალკე გადაიცემა. ამ მიზნით, კლიენტი უსმენს კაფკას თითოეულ თემას, რომელიც ხელმისაწვდომია გარე წვდომისთვის და უბრალოდ ბეჭდავს მიღებულ შეტყობინებებს კონსოლში.
ძირითადი ყოფილი აღსრულების დასაწყებადamples, გაუშვით:

build.sh run-basic –kafka-brokers localhost:9092 –ანგარიში ACCOUNT_SHORTNAME

სადაც ACCOUNT_SHORTNAME არის ანგარიშის მოკლე სახელი, საიდანაც გსურთ მიიღოთ მეტრიკა.
შეწყვიტოს აღსრულება ყოფილიample, დააჭირეთ Ctrl + C. (შეიძლება იყოს მცირე შეფერხება შესრულების შეწყვეტამდე, რადგან კლიენტი ელოდება დროის ამოწურვის მოვლენას.)

გაფართოებული რეჟიმი

შენიშვნა: მეტრიკა ნაჩვენებია მხოლოდ საკონტროლო ცენტრში გაშვებული HTTP მონიტორებისთვის.

გაფართოებულ რეჟიმში შესრულება აჩვენებს მეტრიკასა და მეტამონაცემების შეტყობინებებს შორის კორელაციას. Ეს არის
შესაძლებელია თითოეულ მეტრულ შეტყობინებაში ნაკადის id ველის არსებობის წყალობით, რომელიც ეხება შესაბამის მეტამონაცემების შეტყობინებას.
შეასრულოს მოწინავე ყოფილიamples, გაუშვით:

build.sh run-advanced –kafka-brokers localhost:9092 –ანგარიში ACCOUNT_SHORTNAME

დამატებითი პარამეტრები
შესაძლებელია ყოფილი გაშვებაamples კლიენტის დამატებითი კონფიგურაციით –config--ის გამოყენებითfile ვარიანტი მოჰყვება ა file სახელი, რომელიც შეიცავს თვისებებს ფორმაში key=value.

build.sh run-advanced \
–kafka-brokers localhost:9092 \
-ანგარიში ACCOUNT_SHORTNAME \
-კონფიგურაცია-file client_config.properties

შენიშვნა: ყველა fileზემოთ მოცემულ ბრძანებაში მითითებული s უნდა იყოს განთავსებული მიმდინარე დირექტორიაში და მითითებული იყოს მხოლოდ შედარებითი ბილიკების გამოყენებით. ეს ეხება როგორც –config--სfile არგუმენტი და ყველა ჩანაწერი კონფიგურაციაში file რომ აღწერს file ლოკაციები.

გარე კლიენტის ავთენტიფიკაციის დადასტურება
კლიენტის ავთენტიფიკაციის დასადასტურებლად საკონტროლო ცენტრის გარედან კლიენტ-ექსის გამოყენებითamples, შეასრულეთ შემდეგი ნაბიჯები:

Paragon Active Assurance Control Center საქაღალდიდან გადადით paa-streaming-api-client-ex-ზეamples საქაღალდე:

cd paa-streaming-api-client-examples

დააკოპირეთ CA root სერტიფიკატის ca-cert მიმდინარე დირექტორიაში.
შექმენით კლიენტი.თვისებები file შემდეგი შინაარსით:

security.protocol=SASL_SSL ssl.ca.location=ca-cert
სასლ.მექანიზმი=სადა
sasl.username={CLIENT_USER}
sasl.password={CLIENT_PASSWORD}

სადაც {CLIENT_USER} და {CLIENT_PASSWORD} არის კლიენტის მომხმარებლის რწმუნებათა სიგელები.

გაუშვით ძირითადი ყოფილიamples:

ექსპორტი KAFKA_FQDN=
build.sh run-basic –kafka-brokers ${KAFKA_FQDN}:9093 \
-ანგარიში ACCOUNT_SHORTNAME
-კონფიგურაცია-file კლიენტი.თვისებები

სადაც ACCOUNT_SHORTNAME არის ანგარიშის მოკლე სახელი, საიდანაც გსურთ მიიღოთ მეტრიკა.

გაუშვით მოწინავე ყოფილიamples:

ექსპორტი KAFKA_FQDN=
build.sh run-advanced –kafka-brokers ${KAFKA_FQDN}:9093 \
-ანგარიში ACCOUNT_SHORTNAME
-კონფიგურაცია-file კლიენტი.თვისებები

დანართი

ამ დანართში ჩვენ აღწერს როგორ შევქმნათ:

გასაღების მაღაზია file კაფკას ბროკერის SSL სერთიფიკატის შესანახად
ნდობის მაღაზია file სასერთიფიკატო ორგანოს (CA) ძირეული სერტიფიკატის შესანახად, რომელიც გამოიყენება კაფკას ბროკერის სერტიფიკატზე ხელმოწერისთვის.

კაფკას ბროკერის სერთიფიკატის შექმნა
სერტიფიკატის შექმნა რეალური სერტიფიკატის ავტორიტეტის გამოყენებით (რეკომენდირებულია)
რეკომენდირებულია მიიღოთ რეალური SSL სერთიფიკატი სანდო CA-სგან.
მას შემდეგ რაც გადაწყვეტთ CA-ს შესახებ, დააკოპირეთ მათი CA root სერტიფიკატის ca-cert file საკუთარ გზაზე, როგორც ნაჩვენებია ქვემოთ:

ექსპორტი CA_PATH=~/my-ca
mkdir ${CA_PATH}
cp ca-cert ${CA_PATH}

შექმენით თქვენი საკუთარი სერტიფიკატის ავტორიტეტი

შენიშვნა: ჩვეულებრივ, თქვენ უნდა გქონდეთ თქვენი სერტიფიკატი ხელმოწერილი რეალური სერტიფიკატის ორგანოს მიერ; იხილეთ წინა ქვეპუნქტი. რაც მოყვება არის მხოლოდ ყოფილიampლე.

აქ ჩვენ ვქმნით ჩვენს საკუთარ სერტიფიკატის ორგანოს (CA) ძირეულ სერტიფიკატს file მოქმედებს 999 დღის განმავლობაში (წარმოებაში არ არის რეკომენდებული):

# შექმენით დირექტორია CA-ს შესანახად
ექსპორტი CA_PATH=~/my-ca
mkdir ${CA_PATH}
# შექმენით CA სერთიფიკატი
openssl req -new -x509 -keyout ${CA_PATH}/ca-key -out ${CA_PATH}/ca-cert -days 999

კლიენტების Truststore-ის შექმნა
ახლა თქვენ შეგიძლიათ შექმნათ ნდობის მაღაზია file რომელიც შეიცავს ზემოთ გენერირებულ ca-სერთიფიკატს. ეს file დასჭირდება კაფკას კლიენტს, რომელიც მიიღებს წვდომას Streaming API-ზე:

keytool -keystore kafka.client.truststore.jks \
- მეტსახელი CARoot \
- იმპორტიორი -file ${CA_PATH}/ca-cert

ახლა, როდესაც CA სერთიფიკატი არის truststore-ში, კლიენტი ენდობა მასთან ხელმოწერილ ნებისმიერ სერტიფიკატს.
თქვენ უნდა დააკოპიროთ file kafka.client.truststore.jks თქვენს კლიენტის კომპიუტერის ცნობილ ადგილას და მიუთითეთ მასზე პარამეტრებში.

Keystore-ის შექმნა კაფკას ბროკერისთვის
Kafka ბროკერის SSL სერთიფიკატის და შემდეგ keystore kafka.server.keystore.jks-ის გენერირებისთვის, გააკეთეთ შემდეგი:

SSL სერთიფიკატის გენერირება
ქვემოთ, 999 არის keystore-ის მოქმედების დღეების რაოდენობა, ხოლო FQDN არის კლიენტის სრულად კვალიფიციური დომენის სახელი (კვანძის საჯარო ჰოსტის სახელი).

შენიშვნა: მნიშვნელოვანია, რომ FQDN ზუსტად ემთხვეოდეს ჰოსტის სახელს, რომელსაც კაფკას კლიენტი გამოიყენებს საკონტროლო ცენტრთან დასაკავშირებლად.

sudo mkdir -p /var/ssl/private
sudo chown -R $USER: /var/ssl/პირადი
cd /var/ssl/private
ექსპორტი FQDN= keytool -keystore kafka.server.keystore.jks \
– მეტსახელი სერვერი \
– მოქმედების ვადა 999 \
– genkey -keyalg RSA -ext SAN=dns:${FQDN}

შექმენით სერტიფიკატის ხელმოწერის მოთხოვნა და შეინახეთ მასში file დასახელებული cert-server-მოთხოვნა:

keytool -keystore kafka.server.keystore.jks \
- – მეტსახელი სერვერი \
- – certreq \
- – file სერთიფიკატი-სერვერი-მოთხოვნა

ახლა თქვენ უნდა გამოაგზავნოთ file cert-server-მოთხოვნა თქვენი სერტიფიკატის ორგანოს (CA), თუ იყენებთ რეალურს. შემდეგ ისინი დააბრუნებენ ხელმოწერილ სერთიფიკატს. ამას ქვემოთ მოვიხსენიებთ, როგორც სერტიფიკატის სერვერზე ხელმოწერილი.

SSL სერთიფიკატზე ხელმოწერა თვითშექმნილი CA სერთიფიკატის გამოყენებით

შენიშვნა: ისევ და ისევ, საკუთარი CA-ს გამოყენება არ არის რეკომენდებული საწარმოო სისტემაში.

ხელი მოაწერეთ სერთიფიკატს CA-ს საშუალებით file cert-server-request, რომელიც აწარმოებს ხელმოწერილ სერთიფიკატს cert-server-signed. Იხილეთ ქვემოთ; ca-password არის პაროლი დაყენებული CA სერთიფიკატის შექმნისას.

cd /var/ssl/private openssl x509 -req \
- – CA ${CA_PATH}/ca-cert \
- – CAkey ${CA_PATH}/ca-key \
- – სერთიფიკატის სერვერის მოთხოვნაში \
- – სერთიფიკატის სერვერზე ხელმოწერილი \
- – დღე 999 -CAcreateserial \
- – passin pass:{ca-password}

ხელმოწერილი სერთიფიკატის იმპორტი Keystore-ში

Ca-cert root სერთიფიკატის იმპორტი გასაღების მაღაზიაში:

keytool -keystore kafka.server.keystore.jks \
- – მეტსახელად ca-cert \
- – იმპორტი \
- – file ${CA_PATH}/ca-cert

ხელმოწერილი სერთიფიკატის იმპორტი, რომელიც მოიხსენიება როგორც სერტიფიკატის სერვერზე ხელმოწერილი:

keytool -keystore kafka.server.keystore.jks \
- – მეტსახელი სერვერი \
- – იმპორტი \
- – file სერთიფიკატის სერვერზე ხელმოწერილი

The file kafka.server.keystore.jks უნდა დაკოპირდეს საკონტროლო ცენტრის სერვერის ცნობილ ადგილას და შემდეგ მოიხსენიოთ /etc/kafka/server.properties-ში.

Streaming API-ის გამოყენება

ამ განყოფილებაში

ზოგადი | 20
კაფკა თემის სახელები | 21
Exampნაკადის API-ის გამოყენება | 21

გენერალი
ნაკადის API იღებს როგორც ტესტის, ასევე მონიტორის მონაცემებს. ამ კატეგორიებიდან ერთის გამოყოფა შეუძლებელია.
სტრიმინგის API არ იღებს მონაცემებს სკრიპტზე დაფუძნებული ტესტებიდან (ისინი, რომლებიც წარმოდგენილია მართკუთხედით საკონტროლო ცენტრის GUI-ში სტრიმინგის ნაცვლად), როგორიცაა Ethernet სერვისის აქტივაციის ტესტები და გამჭვირვალობის ტესტები.

კაფკას თემების სახელები
კაფკას თემების სახელები ნაკადის API-სთვის შემდეგია, სადაც %s არის საკონტროლო ცენტრის ანგარიშის მოკლე სახელი (მითითებულია ანგარიშის შექმნისას):

კონსტი (
exporterName = „კაფკა“
metadataTopicTpl = "paa.public.accounts.%s.metadata" metricsTopicTpl = "paa.public.accounts.%s.metrics" )

Exampსტრიმინგის API-ს გამოყენება
ყოფილმაampქვემოთ მოყვანილი ინფორმაცია გვხვდება tarball paa-streaming-api-client-ex-შიamples.tar.gz შეიცავს საკონტროლო ცენტრის tarball-ში.
პირველი, არსებობს ძირითადი ყოფილიampაჩვენეთ, თუ როგორ ხდება მეტრიკა და მათი მეტამონაცემების სტრიმინგი ცალკე და უბრალოდ დაბეჭდეთ მიღებული შეტყობინებები კონსოლში. მისი გაშვება შეგიძლიათ შემდეგნაირად:

sudo ./build.sh run-basic –kafka-brokers localhost:9092 –ანგარიში ACCOUNT_SHORTNAME

ასევე არის უფრო მოწინავე ყოფილიampსადაც მეტრიკა და მეტამონაცემების შეტყობინებები კორელაციაშია. გამოიყენეთ ეს ბრძანება მის გასაშვებად:

sudo ./build.sh run-advanced –kafka-brokers localhost:9092 –ანგარიში ACCOUNT_SHORTNAME

თქვენ უნდა გამოიყენოთ sudo Docker ბრძანებების გასაშვებად, როგორიცაა ზემოთ. სურვილისამებრ, შეგიძლიათ მიჰყვეთ Linux-ის ინსტალაციის შემდგომ ნაბიჯებს, რათა შეძლოთ Docker ბრძანებების გაშვება sudo-ს გარეშე. დეტალებისთვის გადადით docs.docker.com/engine/install/linux-postinstall.

Juniper Networks, Juniper Networks-ის ლოგო, Juniper და Junos არის Juniper Networks, Inc.-ის რეგისტრირებული სავაჭრო ნიშნები შეერთებულ შტატებში და სხვა ქვეყნებში. ყველა სხვა სავაჭრო ნიშანი, მომსახურების ნიშანი, რეგისტრირებული ან რეგისტრირებული სერვისის ნიშანი მათი შესაბამისი მფლობელების საკუთრებაა. Juniper Networks არ იღებს პასუხისმგებლობას ამ დოკუმენტის უზუსტობებზე. Juniper Networks იტოვებს უფლებას შეცვალოს, შეცვალოს, გადაიტანოს ან სხვაგვარად გადახედოს ამ პუბლიკაციას შეტყობინების გარეშე. საავტორო უფლება © 2023 Juniper Networks, Inc. ყველა უფლება დაცულია.

დოკუმენტები / რესურსები

Juniper NETWORKS Streaming API პროგრამული უზრუნველყოფა [pdf] მომხმარებლის სახელმძღვანელო
Streaming API Software, API Software, Software

ცნობები

მომხმარებლის სახელმძღვანელო

Juniper NETWORKS Streaming API პროგრამული უზრუნველყოფა

პროდუქტის ინფორმაცია