თვითმასპინძელი ქეში
თვითმასპინძელი ქეშის კვანძები საშუალებას გაძლევთ ბილდის არტეფაქტები და ქეშის მეტამონაცემები ახლოს შეინახოთ იმ მანქანებთან, რომლებიც წარმოქმნიან და მოიხმარენ ბილდის შედეგებს. გამოიყენეთ ისინი მაშინ, როცა ქეშის დაყოვნება მნიშვნელოვანია CI-ში, დეველოპერების ოფისებში, დაშორებულ სამუშაო სადგურებზე ან რეგიონულ საკომპიუტერო კლასტერებში.
მიზანია დაბალი დაყოვნებით ქეშირება ყველგან, არა მხოლოდ იმ ერთ გარემოში, სადაც ცენტრალური ქეში შემთხვევით ახლოსაა. თითოეული ქეშის კვანძი ემსახურება წაკითხვებსა და ჩაწერებს ლოკალური დისკიდან, ხოლო mesh-ი ავრცელებს არტეფაქტებსა და მეტამონაცემებს პირებს შორის, რათა სხვა ადგილებმაც დროთა განმავლობაში მიიღონ სარგებელი იმავე ქეშიდან.
Tuist-ის თვითმასპინძელი ქეშის კვანძებს ამუშავებს Kura, Tuist-ის დეცენტრალიზებული ქეშის mesh-ი. Kura არის ქეშის კვანძების მონაცემთა ფენა: ის ემსახურება ქეშის წაკითხვებსა და ჩაწერებს, ინახავს ლოკალურ მდგომარეობას დისკზე და ავრცელებს არტეფაქტებსა და მეტამონაცემებს პირ კვანძებზე.
როგორ ერწყმის თვითმასპინძელი ქეში Tuist-ს#
Tuist-ის მართული ქეში იყენებს https://<account>.cache.tuist.dev. თვითმასპინძელ Tuist სერვერთან, CLI იღებს ქეშის URL-ს სერვერის TUIST_CACHE_ENDPOINTS პარამეტრიდან. დააყენეთ ის თქვენი ძირითადი ქეშის სერვერის ან სატვირთო ბალანსერის URL-ზე. თუ ის შეიცავს რამდენიმე URL-ს, გამოიყენება პირველი.
პირადი/მორგებული ქეშის კვანძებისთვის, რომლებიც დაკავშირებულია მასპინძელ Tuist სერვერთან, დააყენეთ აშკარა ბოლოწერტილი დეველოპერის გარსებში და CI-ში:
export TUIST_CACHE_ENDPOINT=https://cache.example.com
ეს გადაფარვა უპირატესობას იღებს ორივე ტიპის სერვერზე და არის არასავალდებულო თვითმასპინძელი Tuist სერვერებისთვის. Xcode ქეშის დემონისთვის, ხელახლა გაუშვით tuist setup cache მისი დაყენების შემდეგ, რათა LaunchAgent-მა მიიღოს განახლებული გარემო.
თვითმასპინძელი Tuist სერვერი იღებს ბოლოწერტილებს სტატიკური კონფიგურაციიდან. Tuist-ის მასპინძელ სერვერზე, კვანძები ავთენტიკაციას გადიან კრედენციალით და რეგისტრირდებიან. ჯერ განათავსეთ კვანძი ქვემოთ მოცემული ორი სექციიდან ერთ-ერთით, შემდეგ იხილეთ კვანძების Tuist-თან დაკავშირება.
განთავსება Kubernetes-ზე#
Kura ვრცელდება Helm chart-ის სახით GitHub Container Registry-ის მეშვეობით. ის განათავსებს Kura-ს როგორც StatefulSet მუდმივი ტომებით, headless სერვისით პირების აღმოსაჩენად და ჩვეულებრივი სერვისით HTTP და gRPC ტრაფიკისთვის.
helm upgrade --install kura oci://ghcr.io/tuist/charts/kura \
--namespace kura \
--create-namespace \
--version <version> \
--set image.tag=<tag> \
--set config.region=local
იმავე კლასტერში მყოფი თვითმასპინძელი Tuist სერვერისთვის, დააკონფიგურირეთ მისი ძირითადი ქეშის ბოლოწერტილი:
server:
cacheEndpointUrl: "http://kura.kura.svc.cluster.local:4000"
ეს აყენებს TUIST_CACHE_ENDPOINTS სერვერის pod-ში. გამოიყენეთ მისამართი, რომელზეც დეველოპერის მანქანებსა და CI-ს შეუძლიათ წვდომა; ზემოთ მოცემული კლასტერ-ლოკალური სერვისის სახელი შესაფერისია კლასტერში მომუშავე კლიენტებისთვის.
თითოეულ Kura კვანძს უნდა ჰქონდეს საკუთარი KURA_DATA_DIR. Kura იღებს აპლიკაციის დონის ჩამწერი ბლოკირებას მონაცემთა დირექტორიაზე და ელის, რომ ზუსტად ერთ პროცესს ეკუთვნოდეს ის. Kubernetes-ში, გამოიყენეთ ერთი მუდმივი ტომი თითოეული pod-ისთვის. Kubernetes-ის გარეთ, არ მიუთითოთ რამდენიმე პროცესი იმავე დაყენებულ დირექტორიაზე.
განთავსება Kubernetes-ის გარეშე#
Kura ასევე შეუძლია იმუშაოს როგორც ჩვეულებრივმა კონტეინერმა VM-ებზე ან bare-metal ჰოსტებზე. ამ რეჟიმში, თქვენ ხართ პასუხისმგებელი პროცესის ზედამხედველობაზე, მუდმივ შენახვაზე, მარშრუტიზაციაზე და პირების აღმოჩენაზე.
მინიმუმ, თითოეულ კვანძს სჭირდება მუდმივი მონაცემთა დირექტორია, დროებითი დირექტორია, საჯარო ქეშის პორტი (ერთი მომსმენი ემსახურება როგორც HTTP ქეშის API-ს, ასევე REAPI gRPC-ს), შიდა პირის URL და ან სტატიკური პირების სია, ან აღმოჩენის მექანიზმი:
docker run -d --name kura \
-p 4000:4000 \
-p 7443:7443 \
-v /var/lib/kura:/var/cache/kura \
-e KURA_PORT=4000 \
-e KURA_INTERNAL_PORT=7443 \
-e KURA_TENANT_ID=default \
-e KURA_REGION=local \
-e KURA_TMP_DIR=/var/cache/kura/tmp \
-e KURA_DATA_DIR=/var/cache/kura \
-e KURA_NODE_URL=http://kura-1.internal:7443 \
-e KURA_PEERS=http://kura-1.internal:7443,http://kura-2.internal:7443 \
ghcr.io/tuist/kura:<tag>
თვითმასპინძელ Tuist სერვერზე, დააკონფიგურირეთ ძირითადი ქეშის URL, რომელზეც დეველოპერის მანქანებსა და CI-ს შეუძლიათ წვდომა:
TUIST_CACHE_ENDPOINTS=https://cache.example.com
კვანძების სატვირთო ბალანსერის უკან განთავსება#
კლიენტები იყენებენ თითოეულ ქეშის ბოლოწერტილის URL-ს როგორც HTTP-ისთვის, ასევე gRPC-ისთვის: HTTP ჯანმრთელობის შემოწმებებისა და HTTP ქეშის API-სთვის, ხოლო gRPC მოდულის ქეშისა და Bazel-ის დაშორებული ქეშისთვის. ნებისმიერმა ingress-მა, სატვირთო ბალანსერმა ან CDN-მა კლიენტებსა და Kura-ს შორის უნდა გადააგზავნოს ორივე იმავე ჰოსტნეიმსა და პორტზე. ეს ეხება ყველა ბოლოწერტილს, რომელსაც კლიენტები იღებენ, რადგან CLI ირჩევს იმას, რომელიც ყველაზე სწრაფად პასუხობს. თუ gRPC ვერ აღწევს Kura-ს, CLI აფრთხილებს, რომ დაშორებული მოდულის ქეშირება მიუწვდომელია და იყენებს მხოლოდ ლოკალურ მოდულის ქეშს.
მიმართეთ ეს გზის პრეფიქსები Kura-ზე როგორც gRPC HTTP/2-ზე, ხოლო ყველაფერი დანარჩენი როგორც HTTP:
| გზის პრეფიქსი | გამოიყენება |
|---|---|
/build.bazel.remote.execution.v2. |
მოდულის ქეში, Bazel |
/google.bytestream. |
მოდულის ქეში, Bazel |
/build.bazel.remote.asset.v1. |
Bazel |
/google.devtools.build.v1. |
Bazel ბილდის მოვლენები |
Kura იღებს plaintext HTTP/2-ს (h2c) KURA_PORT-ზე და HTTP/2-ს TLS-ზე KURA_HTTPS_PORT-ზე, როცა KURA_PUBLIC_TLS_CERT_PATH და KURA_PUBLIC_TLS_KEY_PATH დაყენებულია. თუ თქვენი პროქსი ხელახლა იყენებს upstream კავშირებს მოთხოვნებს შორის, როგორც ingress-nginx აკეთებს, დააყენეთ KURA_GATEWAY_GRPC_PORT და გაგზავნეთ gRPC ტრაფიკი იმ პორტზე. ის ემსახურება მხოლოდ gRPC-ს, ამიტომ HTTP/1.1 და gRPC მოთხოვნები არასდროს იზიარებენ კავშირს.
დააკონფიგურირეთ gRPC მარშრუტები:
- მოთხოვნის სხეულის ზომის ლიმიტი არ არის. ატვირთვა აგზავნის ერთ ფაილს ერთ მოთხოვნაში, 2 GiB-მდე.
- მოთხოვნისა და პასუხის ბუფერიზაცია გამორთულია.
- წაკითხვის, გაგზავნისა და უმოქმედობის таймаუტები მინიმუმ 300 წამი.
Kura არ ემსახურება gRPC ჯანმრთელობის შემოწმების სერვისს. შეამოწმეთ კვანძების ჯანმრთელობა HTTP-ზე /ready-ზე. თუ თქვენს სატვირთო ბალანსერს სჭირდება gRPC ჯანმრთელობის შემოწმება, გამოიძახეთ /build.bazel.remote.execution.v2.Capabilities/GetCapabilities და მიიღეთ gRPC სტატუსის კოდები 0 და 16. ავტორიზაციის ჩართული კვანძი პასუხობს მოთხოვნას ტოკენის გარეშე 16 (UNAUTHENTICATED)-ით.
ingress-nginx#
Helm chart-ით, შეინარჩუნეთ HTTP ingress /-ზე და დაამატეთ gRPC ingress იმავე ჰოსტისთვის. მხოლოდ HTTP ingress აცხადებს TLS-ს:
service:
gatewayGrpcPort: 4001
ingress:
enabled: true
className: nginx
annotations:
nginx.ingress.kubernetes.io/proxy-body-size: "0"
nginx.ingress.kubernetes.io/proxy-request-buffering: "off"
nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
nginx.ingress.kubernetes.io/proxy-send-timeout: "3600"
hosts:
- host: kura.example.com
paths:
- path: /
pathType: Prefix
tls:
- hosts:
- kura.example.com
secretName: kura-tls
grpcIngress:
enabled: true
className: nginx
annotations:
nginx.ingress.kubernetes.io/backend-protocol: "GRPC"
nginx.ingress.kubernetes.io/use-regex: "true"
nginx.ingress.kubernetes.io/proxy-body-size: "0"
nginx.ingress.kubernetes.io/proxy-buffering: "off"
nginx.ingress.kubernetes.io/proxy-request-buffering: "off"
nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
nginx.ingress.kubernetes.io/proxy-send-timeout: "3600"
hosts:
- host: kura.example.com
paths:
- path: /build\.bazel\.remote\.execution\.v2\.
pathType: ImplementationSpecific
- path: /google\.bytestream\.
pathType: ImplementationSpecific
- path: /build\.bazel\.remote\.asset\.v1\.
pathType: ImplementationSpecific
- path: /google\.devtools\.build\.v1\.
pathType: ImplementationSpecific
AWS Application Load Balancer#
gRPC სამიზნე ჯგუფებს სჭირდებათ HTTPS მომსმენი. ამ მომსმენზე:
- გადამისამართეთ ნაგულისხმევი წესი სამიზნე ჯგუფზე პროტოკოლის ვერსიით
HTTP1KURA_PORT-ზე, ჯანმრთელობის შემოწმებით HTTP-ზე/ready-ზე. - შექმენით მეორე სამიზნე ჯგუფი პროტოკოლის ვერსიით
gRPC, პროტოკოლის გამოყენებითHTTPKURA_GATEWAY_GRPC_PORT-ზე (ანKURA_PORT), ან პროტოკოლიHTTPSKURA_HTTPS_PORT-ზე. დააკონფიგურირეთ მისი ჯანმრთელობის შემოწმება ზემოთ აღწერილივით. - დაამატეთ წესი, რომელიც გადაამისამართებს გზის ნიმუშებს
/build.bazel.remote.execution.v2.*,/google.bytestream.*,/build.bazel.remote.asset.v1.*და/google.devtools.build.v1.*მეორე სამიზნე ჯგუფზე. - გაზარდეთ სატვირთო ბალანსერის უმოქმედობის таймаუტი მინიმუმ 300 წამამდე.
CDN-ები#
კვანძის წინ მდებარე CDN-მა უნდა მხარი დაუჭიროს gRPC-ს და არ უნდა დაბლოკოს gRPC გზები თავისი სახანძრო კედლის წესებში. კლიენტები ტვირთავენ დიდ არტეფაქტებს მაქსიმუმ 2 MiB ზომის ნაწილებად და აწყობენ მათ კვანძზე, ამიტომ არცერთ მოთხოვნას არ სჭირდება დიდი სხეული ან ხანგრძლივი ატვირთვა. მოდულის ქეში და Xcode-ის კომპილაციის ქეში ასე იქცევიან, ისევე როგორც Bazel, თუ აგებულია --experimental_remote_cache_chunking ფლაგით (Bazel 8.7 და 9.1 ან უახლესი). ამ ფლაგის გარეშე, Bazel ტვირთავს თითოეულ გამონატანს ერთ მოთხოვნაში, ამიტომ CDN-მა ასევე უნდა დაუშვას დიდი მოთხოვნის სხეულები და ატვირთვები, რომლებიც იმდენ ხანს გრძელდება, რამდენსაც თქვენი უდიდესი გამონატანები საჭიროებენ თქვენს ყველაზე ნელ ბმულზე. თუ თქვენი CDN ვერ აკმაყოფილებს ამ მოთხოვნებს, მიაწოდეთ კლიენტებს ჰოსტნეიმი, რომელიც უვლის მას გვერდს, მაგალითად, მხოლოდ DNS ჩანაწერი.
Cloudflare#
მოდულის ქეშირება მუშაობს ნებისმიერ პაკეტზე პროქსირებული Cloudflare ჰოსტნეიმის მეშვეობით. ზონაში:
- Network-ის ქვეშ, ჩართეთ gRPC.
- SSL/TLS-ის ქვეშ, დააყენეთ შიფრაციის რეჟიმი Full-ზე ან Full (strict)-ზე. Cloudflare უკავშირდება ორიჯინს 443 პორტზე, ამიტომ ორიჯინმა უნდა მიწოდოს TLS იქ და შესთავაზოს HTTP/2 ALPN-ის მეშვეობით.
- დარწმუნდით, რომ არცერთი WAF მორგებული წესი ან მართული წესი არ ბლოკავს ზემოთ ჩამოთვლილ gRPC გზებს.
Cloudflare ასრულებს მოთხოვნას, თუ ორიჯინმა დაახლოებით ორი წუთის შემდეგაც კი არ დაიწყო პასუხის გაცემა. Bazel-ის ატვირთვა --experimental_remote_cache_chunking-ის გარეშე პასუხობს მხოლოდ მას შემდეგ, რაც მისი ბოლო ბაიტი მივა, ამიტომ Cloudflare-ზე ასეთი ატვირთვები ვერ ხერხდება, თუ ისინი ამ დროზე მეტს გრძელდება.
კვანძების Tuist-თან დაკავშირება#
დააკონფიგურირეთ კლიენტის მარშრუტიზაცია და დაარეგისტრირეთ თქვენი კვანძები Tuist-ში, რათა მათი მისამართები, მზადყოფნა და გამოყენება გამოჩნდეს დაფაზე.
self-hosted Tuist server-ზე, თქვენ აცხადებთ ბოლოწერტილებს სტატიკურად TUIST_CACHE_ENDPOINTS-ის მეშვეობით, როგორც ეს ნაჩვენებია ზემოთ განლაგების სექციებში. CLI იყენებს პირველ კონფიგურირებულ URL-ს. TUIST_CACHE_ENDPOINT გადაფარავს ამ URL-ს ინდივიდუალური კლიენტისთვის.
Tuist-hosted server-ზე, დააყენეთ TUIST_CACHE_ENDPOINT დეველოპერის გარსებში და CI-ში, რათა ქეშის მოთხოვნები მიმართოთ თქვენს კვანძებზე. თითოეული კვანძი ავტორიზდება თქვენს მიერ შექმნილი სერთიფიკატით, შემდეგ აფიქსირებს თავის მისამართს და აცნობებს თავის მზადყოფნას დაფას. ეს სექცია ეხება კვანძის რეგისტრაციას.
თვითმასპინძელი ქეშის კვანძები ხელმისაწვდომია Enterprise პაკეტზე. ქვემოთ აღწერილი სექცია Self-hosted servers ჩნდება მხოლოდ იმ ანგარიშებისთვის, რომლებიც ამ პაკეტზე არიან.
კვანძის სერთიფიკატის გენერირება#
Tuist-ის დაფაზე, გახსენით თქვენი ანგარიში, გადადით Cache-ზე და იპოვეთ Self-hosted servers. აირჩიეთ Generate credential კლიენტის ID-ის და საიდუმლოს შესაქმნელად.
სერთიფიკატი ავტორიზებს ტრაფიკს მხოლოდ იმ ანგარიშისთვის, რომელმაც ის შექმნა.
საიდუმლო გამოისახება ერთხელ და არ აღდგება დიალოგის დახურვის შემდეგ, ამიტომ პირდაპირ დააკოპირეთ ის საიდუმლოების საცავში, საიდანაც თქვენი კვანძები კითხულობენ. სერთიფიკატის გაუქმება მყისიერად აჩერებს ყველა კვანძს, რომელიც მას იყენებს, ავტორიზაციისგან, ამიტომ შექმენით შემცვლელი, სანამ გააუქმებთ მოქმედ სერთიფიკატს.
კვანძის რეგისტრაცია ჩატვირთვისას#
რეგისტრაცია არის კვანძის ამუშავების რეკომენდებული გზა. დააყენეთ KURA_ENROLL_ON_BOOT და მიაწოდეთ კვანძს მისი სერთიფიკატი და საკუთარი პირის URL:
KURA_ENROLL_ON_BOOT=true
KURA_CONTROL_PLANE_URL=https://tuist.dev
KURA_CONTROL_PLANE_CLIENT_ID=<client ID>
KURA_CONTROL_PLANE_CLIENT_SECRET=<client secret>
KURA_NODE_URL=https://kura-1.internal:7443
კვანძი ადგილობრივად ქმნის თავის გასაღებების წყვილს, ამიტომ კერძო გასაღები არასდროს ტოვებს მას, და იღებს ხელმოწერილ პირის სერთიფიკატს, ანგარიშის CA-ს, მისი მომხმარებლის იდენტიფიკატორს და პირების სიას. ეს არის ყველაფერი, რასაც წინააღმდეგ შემთხვევაში ხელით დააკონფიგურირებდით: რეგისტრირებულ კვანძს არ სჭირდება KURA_TENANT_ID, არ KURA_PEERS და არ პირის TLS კონფიგურაცია.
დატოვეთ KURA_INTERNAL_TLS_* დაუყენებელი: რეგისტრაცია წერს სერთიფიკატის მასალას tls დირექტორიაში KURA_DATA_DIR-ის ქვეშ. დააყენეთ ეს გზები თავად მხოლოდ მაშინ, როდესაც თქვენ აწვდით სერთიფიკატებს რეგისტრაციის ნაცვლად, როგორც ეს აღწერილია Build a cache mesh-ში.
კვანძი, რომელიც პირველად უერთდება ანგარიშის ბადეს, იღებს ანგარიშის არსებულ ქეშს, სანამ გახდება რგოლის მომსახურე წევრი. გამოყავით მონაცემთა ტომი მთელი ქეშისთვის და ელოდეთ, რომ პირველი შეერთება გარკვეული დრო დასჭირდება ფართო არეალის ბმულზე. კვანძი აცნობებს joining-ს, სანამ არ დაეწევა, შემდეგ serving-ს.
ბოლოწერტილის რეკლამირება#
რეგისტრაცია აერთიანებს ბადეს. რეგისტრაცია აცნობებს კვანძის კლიენტისთვის ხილულ მისამართს და მზადყოფნას Tuist-ს. დააყენეთ რეგისტრაციის ცვლადები:
KURA_REGISTRATION_URL=https://tuist.dev/_internal/kura/mesh/registrations
KURA_ADVERTISED_HTTP_URL=https://kura-1.example.com:4443
კვანძი აგზავნის პულსაციას ყოველ 60 წამში 180-წამიანი იჯარის წინააღმდეგ. Tuist მიიჩნევს მის რეგისტრაციას მიუწვდომლად, როდესაც იჯარა იწურება. Tuist არასდროს ურეკავს კვანძს, ამიტომ ის მხოლოდ თქვენი კლიენტებისთვის უნდა იყოს ხელმისაწვდომი, არა ინტერნეტიდან.
შეამოწმეთ, რომ კვანძი ემსახურება#
დაფაზე Cache-ში დაბრუნებისას, კვანძი ჩანს Registered nodes-ის ქვეშ თავისი ბოლოწერტილით, რეგიონით, სტატუსით და ბოლო პულსაციით. კვანძი, რომელიც არასდროს ჩანს, ვერ აღწევს რეგისტრაციის ბოლოწერტილს ან ვერ ახერხებს ავტორიზაციას. კვანძი, რომელიც ჩანს და შემდეგ ქრება, შეწყვიტა პულსაციის გაგზავნა ან შეწყვიტა თავისი მზადყოფნის შესახებ მოხსენება.
გამოიყენეთ ანგარიშის მუდმივი მომხმარებლის იდენტიფიკატორი#
KURA_TENANT_ID არის ანგარიშის მუდმივი ქეშის იდენტობა. ანგარიშისთვის, რომელიც არასდროს გადაერქვა სახელი, ის უდრის ანგარიშის სახელს. სახელის შეცვლის შემდეგ, შეინარჩუნეთ საწყისი მნიშვნელობა ყველა კვანძზე, ჩანაცვლების კვანძების ჩათვლით: მისი შეცვლა ირჩევს სხვა შენახვის სივრცეს და ანგარიშის სახელის შეცვლა არ გადაიტანს შენახულ არტეფაქტებს. გამოიყენეთ მომხმარებელი არსებული კვანძიდან ან tenant_id რეგისტრაციის მიერ დაბრუნებული, ნაცვლად მისი გამოყვანისა ანგარიშის მიმდინარე URL-დან.
სამართავი სიბრტყე ადარებს პულსაციის მომხმარებელს სერთიფიკატიდან ამოხსნილ ანგარიშს და უარყოფს შეუსაბამობას 409 tenant_mismatch-ით, ამიტომ კვანძი არასწორი მნიშვნელობით წარმატებით ავტორიზდება და მაინც არასდროს რეგისტრირდება.
როგორც Helm chart, ასევე ამ სახელმძღვანელოში ადრე მოყვანილი კონტეინერის მაგალითი ნაგულისხმევად აყენებს ამას default-ზე. შეცვალეთ ის ანგარიშის მომხმარებლის იდენტიფიკატორით კვანძის რეგისტრაციამდე. კვანძის რეგისტრაცია სრულად აცილებს ამ საკითხს, რადგან სამართავი სიბრტყე აწვდის მნიშვნელობას.
დაუყენებელი KURA_TENANT_ID არ ტოვებს შემოწმებას. ის სრულად თიშავს რეგისტრაციას: კვანძი აგრძელებს ქეშის ტრაფიკის მომსახურებას, დაფაზე არაფერი ჩანს და არანაირი შეცდომა არ მოხსენდება. თუ კვანძი ჯანმრთელია, მაგრამ აკლია Registered nodes-ს, პირველ რიგში შეამოწმეთ ეს ცვლადი.
აირჩიეთ რეკლამირებული URL, რომელსაც თქვენი კლიენტები მიაღწევენ#
გამოიყენეთ კლიენტისთვის ხელმისაწვდომი მისამართი KURA_ADVERTISED_HTTP_URL-ისთვის და ქეშის URL-ისთვის, რომელიც კონფიგურირებულია Tuist სერვერზე ან CLI-ში.
მხოლოდ შიდა ჰოსტნეიმი შესაფერისია, როდესაც მის გამოყენებაზე კონფიგურირებული ყოველი კლიენტი ახერხებს ამ სახელის გარჩევას და მიღწევას. სხვადასხვა ქსელში მყოფი კლიენტებისთვის გამოიყენეთ საერთო ხელმისაწვდომი მისამართი ან დააკონფიგურირეთ ხელმისაწვდომი ქეშის კვანძი თითოეული გარემოსთვის.
ააშენეთ ქეშის ბადე#
ქეშის ბადე გაძლევთ საშუალებას, ქეშის სიმძლავრე განათავსოთ იმ გამოთვლითი რესურსების გვერდით, რომლებსაც ის სჭირდებათ. კომპანიამ შეიძლება ერთი კვანძი გაუშვას თავის ძირითად CI გამშვებებთან ახლოს, მეორე — ევროპაში მყოფ დეველოპერებთან ახლოს, ხოლო მესამე — აშშ-ის ოფისთან ან რეგიონულ ბილდის კლასტერთან ახლოს. თითოეული ადგილმდებარეობა კითხულობს და წერს უახლოეს კვანძთან, ხოლო Kura ფონურ რეჟიმში ახდენს არტიფაქტებისა და მეტამონაცემების რეპლიკაციას, რათა მოგვიანებით სხვა ადგილმდებარეობებში განხორციელებულმა ბილდებმა შეძლონ იგივე შედეგების ხელახლა გამოყენება.
ბადე მუშაობს მხოლოდ მაშინ, თუ კვანძებს შეუძლიათ ერთმანეთთან დაკავშირება Kura-ს შიდა პირის პორტზე. ეს პირის სიბრტყე გამოყოფილია იმ საჯარო ქეშის ბოლოწერტილებისგან, რომლებსაც Tuist-ის კლიენტები იყენებენ. Kura იყენებს მას წევრობის შესამოწმებლად, ახლად შეერთებული კვანძების შესავსებად და არტიფაქტების რეპლიკაციისთვის ადგილობრივი ჩაწერების მიღების შემდეგ.
ჩვენ მკაცრად გირჩევთ, უზრუნველყოთ პირის სიბრტყის უსაფრთხოება mTLS-ით, როდესაც კვანძები ერთმანეთთან კომუნიკაციას ახორციელებენ რეგიონებს, ღრუბლებს, VPC-ებს, ოფისებს ან ნებისმიერ ისეთ ქსელს შორის, რომელიც სრულად არ არის კერძო ქეშის განლაგებისთვის. mTLS-ის ჩართვისას, Kura შიდა რეპლიკაციის ბოლოწერტილებს მხოლოდ იმ პირებს სთავაზობს, რომლებიც წარმოადგენენ კონფიგურირებული CA-ს მიერ ხელმოწერილ სერთიფიკატს. პირის სერთიფიკატებმა უნდა მოიცვას DNS სახელები, რომლებსაც კვანძები ერთმანეთთან დასაკავშირებლად იყენებენ, ხოლო პირის URL-ებმა შიდა პორტზე უნდა გამოიყენონ https://.
კვანძები, რომლებიც რეგისტრირდებიან Tuist-ის მიერ დასტუმრებულ სამართავ სიბრტყეზე, რეგისტრაციის დროს იღებენ თავიანთ პირის სერთიფიკატს და ანგარიშის CA-ს, ამიტომ ქვემოთ მოყვანილი ხელით შესრულებული ნაბიჯები ეხება იმ ბადეებს, რომლებიც არ რეგისტრირდებიან.
მაგალითად, ეს ქმნის კერძო CA-ს და ერთ პირის სერთიფიკატს, რომლის დამაგრებაც შეუძლია მცირე ბადის ყოველ კვანძს. შეცვალეთ DNS სახელები იმ შიდა სახელებით, რომლებსაც თქვენი კვანძები იყენებენ KURA_NODE_URL-ში და KURA_PEERS-ში.
mkdir -p kura-peer-tls
cd kura-peer-tls
openssl ecparam -genkey -name prime256v1 -noout -out ca.key
openssl req -x509 -new -key ca.key -sha256 -days 3650 \
-subj "/CN=kura-peer-ca" \
-out ca.pem
openssl ecparam -genkey -name prime256v1 -noout -out tls.key
openssl req -new -key tls.key \
-subj "/CN=kura-peer" \
-out peer.csr
cat > peer.ext <<'EOF'
subjectAltName = DNS:kura-0.kura-headless.kura.svc.cluster.local,DNS:kura-1.kura-headless.kura.svc.cluster.local,DNS:kura-2.kura-headless.kura.svc.cluster.local,DNS:kura-1.internal,DNS:kura-2.internal
extendedKeyUsage = serverAuth,clientAuth
keyUsage = digitalSignature,keyEncipherment
EOF
openssl x509 -req -in peer.csr \
-CA ca.pem \
-CAkey ca.key \
-CAcreateserial \
-out tls.crt \
-days 730 \
-sha256 \
-extfile peer.ext
კვანძებს შორის სინქრონიზაცია#
კვანძი, რომელიც უერთდება ან ხელახლა უერთდება ბადეს, ავსებს: ის გადახედავს თითოეული პირის ჩანაწერებს უახლესიდან დაწყებით და ჩამოტვირთავს იმას, რაც აკლია, ხოლო ცოცხალი რეპლიკაცია ფარავს იმ ჩაწერებს, რომლებიც განხორციელდა პირის ხილვადობის პერიოდში. შევსების ციკლი ვრცელდება პირის უახლესი ჩანაწერიდან კვანძის სეგმენტური რგოლის ჰორიზონტამდე ან მის ბოლო დასრულებულ ციკლამდე (რომელიც უფრო ძველია), ამიტომ კვანძს გარანტირებულად აქვს უახლესი მონაცემები, თუმცა არა აუცილებლად ყველა. KURA_BACKFILL_MARGIN_PERCENT განსაზღვრავს, თუ რამდენად შორს მდებარეობს ჰორიზონტი.
ორი შედეგის ცოდნა ღირს ბადის გაშვებამდე:
- კვანძი იუწყება
/ready-ს, როდესაც მისი სეგმენტური რგოლიKURA_BACKFILL_READY_RING_PERCENT-ით არის სავსე ან როდესაც მისი პირველი შევსების ციკლი დასრულდება, და მზადყოფნა ნარჩუნდება პროცესის დარჩენილი სიცოცხლის განმავლობაში. მოგვიანებით პირის რყევა არასდროს აცილებს მომსახურე კვანძს როტაციიდან. - ციკლი ასევე სრულდება, როდესაც პირი საკმარისად დიდი ხნის განმავლობაში მიუწვდომელია. კვანძი, რომლის ერთადერთი პირიც გათიშულია, შესაბამისად, ხდება Ready (მზად), თუმცა მცირე ან საერთოდ არ აქვს მონაცემები. ის ემსახურება გამოტოვებებს (misses) და არა შეცდომებს.
/status/rolloutიუწყებაbackfill_initial_cycle-ს (pending,completeანdegraded), თუ განსხვავებაზე დაყრდნობით გსურთ განლაგების შეჩერება.
ბადის განახლება შევსების ცვლილების გადაკვეთისას. Kura-ს იმ ვერსიებში, რომლებიც შევსებამდეა, სინქრონიზაცია ხდებოდა სხვა, ახლა უკვე ამოღებული პირის პროტოკოლის მეშვეობით. გადაიყვანეთ ყოველი კვანძი ისეთ ვერსიაზე, რომელიც ასრულებს შევსებას მანამ, სანამ აიღებთ ვერსიას, რომელიც მხოლოდ შევსებას „ლაპარაკობს“. ორ პროტოკოლზე მყოფ კვანძებს ერთმანეთთან სინქრონიზაცია არ შეუძლიათ: „თბილი“ კვანძი აგრძელებს მომსახურებას თავისი ტომიდან, მაგრამ წყვეტს სხვაობის აღმოფხვრას, ხოლო კვანძი, რომელიც ამ ფანჯარაში ცარიელ ტომზე იწყება, არასდროს ხდება Ready. chart თქვენთვის აყენებს KURA_BACKFILL_ENABLED=true-ს, ამიტომ chart-ზე დაფუძნებული განახლება ამას ფარავს. ერთი helm upgrade, რომელიც ერთდროულად გადააადგილებს chart-სა და image-ს, ამას არ აკეთებს.
გამოიყენეთ ქსელის დონის შეზღუდვები mTLS-ის დამატებით. Kubernetes-ში, გაუშვით Kura როგორც StatefulSet თითოეული pod-ისთვის ერთი მუდმივი ტომით და headless სერვისით პირის აღმოჩენისთვის, შემდეგ კი დაუშვით შიდა პირის პორტი მხოლოდ იმ pod-ებს შორის, რომლებიც ერთსა და იმავე ქეშის განლაგებას ეკუთვნიან, მაგალითად, NetworkPolicy-ის გამოყენებით. Kubernetes-ის გარეთ, მიანიჭეთ თითოეულ კვანძს სტაბილური DNS სახელი ან IP მისამართი, ჩაატარეთ ბადის თესვა სხვა კვანძების შიდა URL-ებით და გამოიყენეთ firewall-ის წესები ან security groups ისე, რომ მხოლოდ ქეშის კვანძებმა შეძლონ პირის პორტთან მიღწევა. საჯარო ქეშის ტრაფიკი უნდა შედიოდეს საჯარო HTTP ან gRPC ბოლოწერტილების მეშვეობით და არა შიდა პირის სიბრტყის მეშვეობით.
კონფიგურაცია#
Helm chart აგენერირებს ზოგად დროის შესრულების პარამეტრებს values.yaml-დან. თუ Kura-ს Kubernetes-ის გარეშე აწარმოებთ, დააყენეთ იგივე ცვლადები პირდაპირ პროცესზე. ცვლადები, რომლებსაც chart პირდაპირ არ ასახავს, შეიძლება ჩაისხას extraEnv-ის ან extraEnvFrom-ის მეშვეობით.
| გარემოს ცვლადი | აღწერა | სავალდებულო | ნაგულისხმევი | Helm მნიშვნელობა |
|---|---|---|---|---|
KURA_PORT |
საჯარო ქეშის პორტი. ერთი მოსმენა ემსახურება HTTP ქეშის API-ს, ჯანმრთელობის ბოლოწერტილებს და Bazel/Buck2 REAPI gRPC-ს (h2c). | კი | ნაგულისხმევი არ არის | service.httpPort |
KURA_INTERNAL_PORT |
შიდა HTTP ან mTLS პორტი, რომელსაც Kura-ს პირები იყენებენ. | კი | ნაგულისხმევი არ არის | peerTls.internalPort |
KURA_TENANT_ID |
კვანძის ნაგულისხმევი მომხმარებლის იდენტიფიკატორი. | კი | ნაგულისხმევი არ არის | config.tenantId |
KURA_REGION |
რეგიონის ლეიბლი, რომელიც გამოიყენება მეტრიკებსა და რეპლიკაციის მდგომარეობაში. | კი | ნაგულისხმევი არ არის | config.region |
KURA_TMP_DIR |
დროებითი დირექტორია staged მოთხოვნის სხეულებისა და multipart აწყობისთვის. | კი | ნაგულისხმევი არ არის | ფიქსირებულია /var/cache/kura/tmp-ზე |
KURA_TMP_DIR_MAX_BYTES |
მაქსიმალური staged ბაიტები, რომლებიც დაიშვება KURA_TMP_DIR-ში, სანამ მოთხოვნები backpressure-ს მიიღებენ. |
არა | 8589934592 |
config.tmpDirMaxBytes |
KURA_DATA_DIR |
მუდმივი დირექტორია მეტამონაცემების მდგომარეობისა და სეგმენტური ფაილებისთვის. | კი | ნაგულისხმევი არ არის | ფიქსირებულია /var/cache/kura-ზე |
KURA_NODE_URL |
კანონიკური შიდა URL, რომელსაც სხვა პირები იყენებენ ამ კვანძთან დასაკავშირებლად. | კი | ნაგულისხმევი არ არის | მიღებულია pod-ის DNS სახელიდან და peerTls.internalPort-დან |
KURA_PEERS |
პირების საწყისი სია, რომელიც გამოიყენება აღმოჩენამდე. | არა | KURA_NODE_URL |
მიღებულია StatefulSet-ის რეპლიკებიდან |
KURA_DISCOVERY_DNS_NAME |
DNS სახელი, რომელიც გამოიყენება ავტომატური პირების აღმოჩენისთვის. | არა | გათიშულია | ჩართულია config.discovery.enabled-ით |
KURA_INTERNAL_TLS_CA_CERT_PATH |
CA სერთიფიკატი, რომელიც გამოიყენება პირების mTLS-ის ვერიფიკაციისთვის. | არა | გათიშულია, ან მიღებულია KURA_DATA_DIR-ის ქვეშ, როდესაც კვანძი რეგისტრირდება |
peerTls.enabled და peerTls.caCertFileName |
KURA_INTERNAL_TLS_CERT_PATH |
სერთიფიკატი, რომელიც გამოიყენება შიდა პირების mTLS მოსმენისთვის. | არა | გათიშულია, ან მიღებულია KURA_DATA_DIR-ის ქვეშ, როდესაც კვანძი რეგისტრირდება |
peerTls.enabled და peerTls.certFileName |
KURA_INTERNAL_TLS_KEY_PATH |
პირადი გასაღები, რომელიც გამოიყენება შიდა პირების mTLS მოსმენისთვის. | არა | გათიშულია, ან მიღებულია KURA_DATA_DIR-ის ქვეშ, როდესაც კვანძი რეგისტრირდება |
peerTls.enabled და peerTls.keyFileName |
KURA_PUBLIC_TLS_CERT_PATH |
სერთიფიკატი, რომელიც გამოიყენება TLS-ის დასასრულებლად თანაზომიერ HTTPS მოსმენაზე (KURA_HTTPS_PORT). |
არა | გათიშულია | extraEnv |
KURA_PUBLIC_TLS_KEY_PATH |
პირადი გასაღები, რომელიც შეესაბამება KURA_PUBLIC_TLS_CERT_PATH-ს. |
არა | გათიშულია | extraEnv |
KURA_HTTPS_PORT |
TLS პორტი, რომელიც ემსახურება იგივე თანაზომიერ HTTP + gRPC ზედაპირს (ALPN-ით შეთანხმებული). ბმული ხდება მხოლოდ მაშინ, როდესაც საჯარო TLS გზები დაყენებულია. | არა | 4443 |
extraEnv |
KURA_GATEWAY_GRPC_PORT |
Plaintext HTTP/2 პორტი, რომელიც ემსახურება მხოლოდ gRPC API-ებს, პროქსებისთვის, რომლებიც ხელახლა იყენებენ upstream კავშირებს. იხილეთ კვანძების განთავსება load balancer-ის უკან. | არა | გათიშულია | service.gatewayGrpcPort |
KURA_FILE_DESCRIPTOR_POOL_SIZE |
ფაილის დესკრიპტორების ბიუჯეტი მოთხოვნებისა და ფონური I/O-სთვის. | არა | ავტომატურად მიღებული | config.fileDescriptors.poolSize |
KURA_FILE_DESCRIPTOR_ACQUIRE_TIMEOUT_MS |
რამდენ ხანს ელოდება მოთხოვნა, სანამ FD backpressure ჩაშლის checkout-ს. | არა | 5000 |
config.fileDescriptors.acquireTimeoutMs |
KURA_SEGMENT_HANDLE_CACHE_SIZE |
მიმაგრებული სეგმენტის წაკითხვის handle-ების მაქსიმალური რაოდენობა. | არა | ავტომატურად მიღებული | config.fileDescriptors.segmentHandleCacheSize |
KURA_DRAIN_COMPLETION_TIMEOUT_MS |
შეწყვეტის დროს შესრულებადი HTTP და gRPC სამუშაოსთვის განკუთვნილი გრეის პერიოდი. | არა | 240000 |
config.shutdown.drainCompletionTimeoutMs |
KURA_MEMORY_SOFT_LIMIT_BYTES |
მეხსიერების რბილი ზღვარი, სადაც Kura იწყებს არასავალდებულო მეხსიერების გამოყენების შემცირებას. | არა | ავტომატურად მიღებული | config.memory.softLimitBytes |
KURA_MEMORY_HARD_LIMIT_BYTES |
მეხსიერების მკაცრი ზღვარი, სადაც Kura აჩერებს რეპლიკაციას და ამცირებს ცხელ ქეშებს. | არა | ავტომატურად მიღებული | config.memory.hardLimitBytes |
KURA_MANIFEST_CACHE_MAX_BYTES |
მეხსიერებაში მყოფი manifest ქეშის მაქსიმალური ზომა. | არა | ავტომატურად მიღებული | config.memory.manifestCacheMaxBytes |
KURA_MAX_KEYVALUE_BYTES |
მოთხოვნის ერთეულზე keyvalue payload-ის მაქსიმალური ზომა. | არა | 1048576 |
config.memory.maxKeyvalueBytes |
KURA_METADATA_STORE_MAX_OPEN_FILES |
მეტამონაცემთა საცავისთვის შენახული ფაილის დესკრიპტორების ბიუჯეტი. | არა | ავტომატურად მიღებული | config.metadataStore.maxOpenFiles |
KURA_METADATA_STORE_MAX_BACKGROUND_JOBS |
მეტამონაცემთა საცავის ფონური flush-ისა და კომპაქციის კონკურენტულობა. | არა | ავტომატურად მიღებული | config.metadataStore.maxBackgroundJobs |
KURA_METADATA_STORE_READ_CACHE_BYTES |
მეტამონაცემთა საცავის წაკითხვის ქეშის ტევადობა. | არა | ავტომატურად მიღებული | extraEnv |
KURA_METADATA_STORE_WRITE_BUFFER_POOL_BYTES |
მეტამონაცემთა ჩაწერის ბუფერირებისთვის შენახული მეხსიერების სრული ბიუჯეტი. | არა | ავტომატურად მიღებული | extraEnv |
KURA_METADATA_STORE_WRITE_BUFFER_BYTES |
თითოეული მეტამონაცემთა ჩაწერის ბუფერის ზომა flush-ამდე. | არა | ავტომატურად მიღებული | extraEnv |
KURA_METADATA_STORE_MAX_WRITE_BUFFERS |
მეხსიერებაში შენახული მეტამონაცემთა ჩაწერის ბუფერების მაქსიმალური რაოდენობა. | არა | ავტომატურად მიღებული | extraEnv |
KURA_MULTIPART_UPLOAD_TTL_MS |
რამდენ ხანს შეიძლება დარჩეს მიმდინარე multipart ატვირთვა ვადის გასვლამდე. | არა | 86400000 |
extraEnv |
KURA_MULTIPART_JANITOR_INTERVAL_MS |
რამდენად ხშირად ამოწმებს Kura ძველ multipart ატვირთვებს. | არა | 600000 |
extraEnv |
KURA_BACKFILL_MARGIN_PERCENT |
ასაკის მიხედვით დალაგებული სეგმენტების რგოლის წილი, რომელიც ითვლება უახლესიდან და განსაზღვრავს, თუ რამდენად შორს აღწევს backfill პასი. | არა | 40 |
config.backfill.marginPercent |
KURA_BACKFILL_READY_RING_PERCENT |
სეგმენტების რგოლის შევსებულობის დონე, რომლის დროსაც კვანძი, რომელიც ჯერ კიდევ ასრულებს თავის პირველ backfill ციკლს, საკუთარ თავს მზადყოფნად აცხადებს. | არა | KURA_BACKFILL_MARGIN_PERCENT-ის ნახევარი |
config.backfill.readyRingPercent |
KURA_BACKFILL_BATCH_BYTES |
ბაიტების ზღვარი, რომლის მიხედვითაც ფორმირდება ერთი backfill სხეულების ბათჩი, და ზომა, რომლის ზემოთაც ჩანაწერი ცალკე იტვირთება. | არა | 33554432 |
config.backfill.batchBytes |
KURA_TOKIO_WORKER_THREADS |
Tokio worker ძაფების რაოდენობა. | არა | ავტომატურად მიღებული | extraEnv |
KURA_OTEL_EXPORTER_OTLP_TRACES_ENDPOINT |
OTLP traces endpoint. დატოვეთ ცარიელი ტრეისინგის გასათიშად. | არა | გათიშული | config.telemetry.otlpTracesEndpoint |
KURA_OTEL_SERVICE_NAME |
OpenTelemetry სერვისის სახელი. | კი | ნაგულისხმები არ არის | Pod-ის სახელი Helm-ში |
KURA_OTEL_DEPLOYMENT_ENVIRONMENT |
OpenTelemetry განლაგების გარემო. | კი | ნაგულისხმები არ არის | config.telemetry.deploymentEnvironment |
KURA_SENTRY_DSN |
Sentry DSN პანიკისა და შეცდომების შესახებ ინფორმაციისთვის. | არა | გათიშული | extraEnv ან extraEnvFrom |
KURA_NODE_COUNTRY |
ISO 3166-1 alpha-2 ქვეყანა, სადაც მდებარეობს მონაცემთა ცენტრი, რომელშიც კვანძი მუშაობს; ექსპორტირებულ traces-ზე ინიშნება როგორც geo.country.iso_code. |
არა | მიღებულია KURA_REGION-დან, როცა მისი პრეფიქსი ქვეყნის კოდია |
extraEnv |
KURA_NODE_SUBDIVISION |
იმ მონაცემთა ცენტრის ISO 3166-2 ქვედანაყოფი (მაგ., US-CA), რომელიც ინიშნება როგორც geo.region.iso_code. |
არა | არ არის მითითებული | extraEnv |
KURA_AUTH_ENABLED |
მოითხოვს, რომ გამომძახებლებმა წარადგინონ მოქმედი Tuist ტოკენი. KURA_AUTH_TUIST_URL-ის მითითება საკუთარი თავით რთავს ავტორიზაციას, ხოლო ამის false-ზე დაყენება არ თიშავს მას — URL-ის გასუფთავება საჭიროა კვანძის ავტორიზაციის გარეშე გასაშვებად. |
არა | გათიშული | auth.enabled |
KURA_AUTH_TUIST_URL |
Tuist სერვერი, რომლის წინააღმდეგაც კვანძი ახდენს ავტორიზაციას. საკუთარი თავით რთავს ავტორიზაციას. | სავალდებულოა, როცა ავტორიზაცია ჩართულია | ნაგულისხმები არ არის | auth.tuistUrl |
KURA_AUTH_TUIST_CONNECT_TIMEOUT_MS |
კავშირის დროის ლიმიტი ამ სერვერთან ზარებისთვის. | არა | 500 |
extraEnv |
KURA_AUTH_TUIST_REQUEST_TIMEOUT_MS |
მოთხოვნის დროის ლიმიტი ამ სერვერთან ზარებისთვის. | არა | 1500 |
extraEnv |
KURA_AUTH_JWT_SECRET |
გაზიარებული საიდუმლო ტოკენებისთვის, რომელთა წაკითხვაც კვანძს შეუძლია პირდაპირ, დამატებითი მოთხოვნის გარეშე. ის ასევე აწერს ხელს და ამოწმებს, ამიტომ გამოიყენეთ მხოლოდ იქ, სადაც კვანძი და სერვერი ერთი და იგივე ნდობის საზღვარშია. თვითმასპინძელი კვანძები ჩვეულებრივ ტოვებენ ამ პარამეტრს მითითების გარეშე. | არა | გათიშული | extraEnv ან extraEnvFrom |
KURA_AUTH_JWT_PUBLIC_KEY |
საჯარო გასაღები, რომლითაც სერვერი აწერს ხელს cache ტოკენებს; ერთი ან რამდენიმე შეერთებული PEM ბლოკის სახით. კითხულობს ამ ტოკენებს მათი შექმნის შესაძლებლობის გარეშე, რაც ინტერნეტიდან ხელმისაწვდომი კვანძისთვის საჭიროა. ურთიერთგამომრიცხავია KURA_AUTH_JWT_SECRET-თან. |
არა | გათიშული | extraEnvFrom |
KURA_AUTH_JWT_ALGORITHM |
ალგორითმი ამ გასაღებისთვის: HS256, HS384 ან HS512 საიდუმლოთი, ES256 საჯარო გასაღებით. |
არა | HS256 საიდუმლოთი, ES256 საჯარო გასაღებით |
extraEnv |
KURA_AUTH_JWT_ISSUER |
გამომცემელი, რომელიც ტოკენებმა უნდა შეიცავდნენ. | არა | შეუმოწმებელი | extraEnv |
KURA_AUTH_JWT_AUDIENCES |
მსმენელები (audiences), რომლებიც ტოკენებმა უნდა შეიცავდნენ, გამოყოფილი მძიმით. | არა | შეუმოწმებელი | extraEnv |
KURA_AUTH_CACHE_MAX_ENTRIES |
მაქსიმალური ჩანაწერები, რომლებიც ინახება ავთენტიკაციისა და ავტორიზაციის თითოეულ cache-ში. | არა | 100000 |
extraEnv |
KURA_ENROLL_ON_BOOT |
არეგისტრირებს კვანძს სამართავ სიბრტყეზე ყოველ ჩართვაზე, აწვდის მის peer სერთიფიკატს და აწვდის KURA_TENANT_ID და KURA_PEERS. |
არა | გათიშული | extraEnv |
KURA_CONTROL_PLANE_URL |
Tuist სერვერი, რომლის წინააღმდეგაც კვანძი რეგისტრირდება. | სავალდებულოა რეგისტრაციისას | ნაგულისხმები არ არის | extraEnv |
KURA_CONTROL_PLANE_CLIENT_ID |
კვანძის რწმუნების Client ID, რომელიც გენერირდება dashboard-ში. | სავალდებულოა რეგისტრაციის ან დარეგისტრირებისას | ნაგულისხმები არ არის | extraEnv |
KURA_CONTROL_PLANE_CLIENT_SECRET |
Client secret, რომელიც შეესაბამება KURA_CONTROL_PLANE_CLIENT_ID-ს. |
სავალდებულოა რეგისტრაციის ან დარეგისტრირებისას | ნაგულისხმები არ არის | extraEnv |
KURA_REGISTRATION_URL |
აბსოლუტური URL, სადაც კვანძი აგზავნის რეგისტრაციის heartbeat-ებს, რითაც აცხადებს თავის client-facing endpoint-ს. | სავალდებულოა დარეგისტრირებისას | ნაგულისხმები არ არის | extraEnv |
KURA_ADVERTISED_HTTP_URL |
Client-facing cache URL, რომელსაც სამართავი სიბრტყე გადასცემს კლიენტებს. უნდა იყოს ხელმისაწვდომი ანგარიშის ყველა კლიენტისთვის. | სავალდებულოა დარეგისტრირებისას | ნაგულისხმები არ არის | extraEnv |
KURA_REGISTRATION_INTERVAL_MS |
რეგისტრაციის heartbeat-ების სიხშირე. ვადა რამდენიმე გამოტოვებულ heartbeat-ს მოიცავს, ამიტომ ერთი გამოტოვებული heartbeat არ ცვლის endpoint-ს. | არა | 60000 |
extraEnv |
თუ შიდა peer mTLS-ს ჩართავთ, ერთდროულად დააყენეთ KURA_INTERNAL_TLS_CA_CERT_PATH, KURA_INTERNAL_TLS_CERT_PATH და KURA_INTERNAL_TLS_KEY_PATH. KURA_NODE_URL და KURA_PEERS-ში ყველა მნიშვნელობა მაშინ უნდა იყენებდეს https://-ს შიდა peer პორტთან.