გადადით შინაარსზე

თვითმასპინძელი ქეში

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

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

Note

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

როგორ ერწყმის თვითმასპინძელი ქეში Tuist-ს#

Tuist-ის მართული ქეში იყენებს https://<account>.cache.tuist.dev. თვითმასპინძელ Tuist სერვერთან, CLI იღებს ქეშის URL-ს სერვერის TUIST_CACHE_ENDPOINTS პარამეტრიდან. დააყენეთ ის თქვენი ძირითადი ქეშის სერვერის ან სატვირთო ბალანსერის URL-ზე. თუ ის შეიცავს რამდენიმე URL-ს, გამოიყენება პირველი.

პირადი/მორგებული ქეშის კვანძებისთვის, რომლებიც დაკავშირებულია მასპინძელ Tuist სერვერთან, დააყენეთ აშკარა ბოლოწერტილი დეველოპერის გარსებში და CI-ში:

bash
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 ტრაფიკისთვის.

bash
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 სერვერისთვის, დააკონფიგურირეთ მისი ძირითადი ქეშის ბოლოწერტილი:

yaml
server:
cacheEndpointUrl: "http://kura.kura.svc.cluster.local:4000"

ეს აყენებს TUIST_CACHE_ENDPOINTS სერვერის pod-ში. გამოიყენეთ მისამართი, რომელზეც დეველოპერის მანქანებსა და CI-ს შეუძლიათ წვდომა; ზემოთ მოცემული კლასტერ-ლოკალური სერვისის სახელი შესაფერისია კლასტერში მომუშავე კლიენტებისთვის.

Important

თითოეულ Kura კვანძს უნდა ჰქონდეს საკუთარი KURA_DATA_DIR. Kura იღებს აპლიკაციის დონის ჩამწერი ბლოკირებას მონაცემთა დირექტორიაზე და ელის, რომ ზუსტად ერთ პროცესს ეკუთვნოდეს ის. Kubernetes-ში, გამოიყენეთ ერთი მუდმივი ტომი თითოეული pod-ისთვის. Kubernetes-ის გარეთ, არ მიუთითოთ რამდენიმე პროცესი იმავე დაყენებულ დირექტორიაზე.

განთავსება Kubernetes-ის გარეშე#

Kura ასევე შეუძლია იმუშაოს როგორც ჩვეულებრივმა კონტეინერმა VM-ებზე ან bare-metal ჰოსტებზე. ამ რეჟიმში, თქვენ ხართ პასუხისმგებელი პროცესის ზედამხედველობაზე, მუდმივ შენახვაზე, მარშრუტიზაციაზე და პირების აღმოჩენაზე.

მინიმუმ, თითოეულ კვანძს სჭირდება მუდმივი მონაცემთა დირექტორია, დროებითი დირექტორია, საჯარო ქეშის პორტი (ერთი მომსმენი ემსახურება როგორც HTTP ქეშის API-ს, ასევე REAPI gRPC-ს), შიდა პირის URL და ან სტატიკური პირების სია, ან აღმოჩენის მექანიზმი:

bash
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-ს შეუძლიათ წვდომა:

bash
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-ს:

yaml
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 მომსმენი. ამ მომსმენზე:

  1. გადამისამართეთ ნაგულისხმევი წესი სამიზნე ჯგუფზე პროტოკოლის ვერსიით HTTP1 KURA_PORT-ზე, ჯანმრთელობის შემოწმებით HTTP-ზე /ready-ზე.
  2. შექმენით მეორე სამიზნე ჯგუფი პროტოკოლის ვერსიით gRPC, პროტოკოლის გამოყენებით HTTP KURA_GATEWAY_GRPC_PORT-ზე (ან KURA_PORT), ან პროტოკოლი HTTPS KURA_HTTPS_PORT-ზე. დააკონფიგურირეთ მისი ჯანმრთელობის შემოწმება ზემოთ აღწერილივით.
  3. დაამატეთ წესი, რომელიც გადაამისამართებს გზის ნიმუშებს /build.bazel.remote.execution.v2.*, /google.bytestream.*, /build.bazel.remote.asset.v1.* და /google.devtools.build.v1.* მეორე სამიზნე ჯგუფზე.
  4. გაზარდეთ სატვირთო ბალანსერის უმოქმედობის таймаუტი მინიმუმ 300 წამამდე.

CDN-ები#

კვანძის წინ მდებარე CDN-მა უნდა მხარი დაუჭიროს gRPC-ს და არ უნდა დაბლოკოს gRPC გზები თავისი სახანძრო კედლის წესებში. კლიენტები ტვირთავენ დიდ არტეფაქტებს მაქსიმუმ 2 MiB ზომის ნაწილებად და აწყობენ მათ კვანძზე, ამიტომ არცერთ მოთხოვნას არ სჭირდება დიდი სხეული ან ხანგრძლივი ატვირთვა. მოდულის ქეში და Xcode-ის კომპილაციის ქეში ასე იქცევიან, ისევე როგორც Bazel, თუ აგებულია --experimental_remote_cache_chunking ფლაგით (Bazel 8.7 და 9.1 ან უახლესი). ამ ფლაგის გარეშე, Bazel ტვირთავს თითოეულ გამონატანს ერთ მოთხოვნაში, ამიტომ CDN-მა ასევე უნდა დაუშვას დიდი მოთხოვნის სხეულები და ატვირთვები, რომლებიც იმდენ ხანს გრძელდება, რამდენსაც თქვენი უდიდესი გამონატანები საჭიროებენ თქვენს ყველაზე ნელ ბმულზე. თუ თქვენი CDN ვერ აკმაყოფილებს ამ მოთხოვნებს, მიაწოდეთ კლიენტებს ჰოსტნეიმი, რომელიც უვლის მას გვერდს, მაგალითად, მხოლოდ DNS ჩანაწერი.

Cloudflare#

მოდულის ქეშირება მუშაობს ნებისმიერ პაკეტზე პროქსირებული Cloudflare ჰოსტნეიმის მეშვეობით. ზონაში:

  1. Network-ის ქვეშ, ჩართეთ gRPC.
  2. SSL/TLS-ის ქვეშ, დააყენეთ შიფრაციის რეჟიმი Full-ზე ან Full (strict)-ზე. Cloudflare უკავშირდება ორიჯინს 443 პორტზე, ამიტომ ორიჯინმა უნდა მიწოდოს TLS იქ და შესთავაზოს HTTP/2 ALPN-ის მეშვეობით.
  3. დარწმუნდით, რომ არცერთი 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 plan

თვითმასპინძელი ქეშის კვანძები ხელმისაწვდომია Enterprise პაკეტზე. ქვემოთ აღწერილი სექცია Self-hosted servers ჩნდება მხოლოდ იმ ანგარიშებისთვის, რომლებიც ამ პაკეტზე არიან.

კვანძის სერთიფიკატის გენერირება#

Tuist-ის დაფაზე, გახსენით თქვენი ანგარიში, გადადით Cache-ზე და იპოვეთ Self-hosted servers. აირჩიეთ Generate credential კლიენტის ID-ის და საიდუმლოს შესაქმნელად.

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

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

კვანძის რეგისტრაცია ჩატვირთვისას#

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

bash
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-ს. დააყენეთ რეგისტრაციის ცვლადები:

bash
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-ით, ამიტომ კვანძი არასწორი მნიშვნელობით წარმატებით ავტორიზდება და მაინც არასდროს რეგისტრირდება.

Important

როგორც 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://.

Note

კვანძები, რომლებიც რეგისტრირდებიან Tuist-ის მიერ დასტუმრებულ სამართავ სიბრტყეზე, რეგისტრაციის დროს იღებენ თავიანთ პირის სერთიფიკატს და ანგარიშის CA-ს, ამიტომ ქვემოთ მოყვანილი ხელით შესრულებული ნაბიჯები ეხება იმ ბადეებს, რომლებიც არ რეგისტრირდებიან.

მაგალითად, ეს ქმნის კერძო CA-ს და ერთ პირის სერთიფიკატს, რომლის დამაგრებაც შეუძლია მცირე ბადის ყოველ კვანძს. შეცვალეთ DNS სახელები იმ შიდა სახელებით, რომლებსაც თქვენი კვანძები იყენებენ KURA_NODE_URL-ში და KURA_PEERS-ში.

bash
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 პორტთან.