# თვითმასპინძელი ქეში {#self-hosted-cache}

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

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

> [!NOTE]
> Tuist-ის თვითმასპინძელი ქეშის კვანძებს ამუშავებს [Kura](https://github.com/tuist/tuist/tree/main/kura), Tuist-ის დეცენტრალიზებული ქეშის mesh-ი. Kura არის ქეშის კვანძების მონაცემთა ფენა: ის ემსახურება ქეშის წაკითხვებსა და ჩაწერებს, ინახავს ლოკალურ მდგომარეობას დისკზე და ავრცელებს არტეფაქტებსა და მეტამონაცემებს პირ კვანძებზე.

## როგორ ერწყმის თვითმასპინძელი ქეში Tuist-ს {#how-self-hosted-cache-fits-with-tuist}

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

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

```sh
export TUIST_CACHE_ENDPOINT=https://cache.example.com
```

ეს გადაფარვა უპირატესობას იღებს ორივე ტიპის სერვერზე და არის არასავალდებულო თვითმასპინძელი Tuist სერვერებისთვის. Xcode ქეშის დემონისთვის, ხელახლა გაუშვით `tuist setup cache` მისი დაყენების შემდეგ, რათა LaunchAgent-მა მიიღოს განახლებული გარემო.

თვითმასპინძელი Tuist სერვერი იღებს ბოლოწერტილებს სტატიკური კონფიგურაციიდან. Tuist-ის მასპინძელ სერვერზე, კვანძები ავთენტიკაციას გადიან კრედენციალით და რეგისტრირდებიან. ჯერ განათავსეთ კვანძი ქვემოთ მოცემული ორი სექციიდან ერთ-ერთით, შემდეგ იხილეთ [კვანძების Tuist-თან დაკავშირება](#connect-nodes-to-tuist).

## განთავსება Kubernetes-ზე {#deploy-on-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-ის გარეშე {#deploy-without-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
```

## კვანძების სატვირთო ბალანსერის უკან განთავსება {#load-balancers}

კლიენტები იყენებენ თითოეულ ქეშის ბოლოწერტილის 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 {#load-balancers-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 {#load-balancers-aws-alb}

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-ები {#load-balancers-cdns}

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

#### Cloudflare {#load-balancers-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-თან დაკავშირება {#connect-nodes-to-tuist}

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

**self-hosted Tuist server**-ზე, თქვენ აცხადებთ ბოლოწერტილებს სტატიკურად `TUIST_CACHE_ENDPOINTS`-ის მეშვეობით, როგორც ეს ნაჩვენებია ზემოთ განლაგების სექციებში. CLI იყენებს პირველ კონფიგურირებულ URL-ს. `TUIST_CACHE_ENDPOINT` გადაფარავს ამ URL-ს ინდივიდუალური კლიენტისთვის.

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

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

### კვანძის სერთიფიკატის გენერირება {#generate-a-node-credential}

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

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

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

### კვანძის რეგისტრაცია ჩატვირთვისას {#enroll-the-node-on-boot}

რეგისტრაცია არის კვანძის ამუშავების რეკომენდებული გზა. დააყენეთ `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](#build-a-cache-mesh)-ში.

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

### ბოლოწერტილის რეკლამირება {#advertise-the-endpoint}

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

### შეამოწმეთ, რომ კვანძი ემსახურება {#verify-the-node-is-serving}

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

### გამოიყენეთ ანგარიშის მუდმივი მომხმარებლის იდენტიფიკატორი {#match-the-tenant-identifier}

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

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

> [!IMPORTANT]
> როგორც Helm chart, ასევე ამ სახელმძღვანელოში ადრე მოყვანილი კონტეინერის მაგალითი ნაგულისხმევად აყენებს ამას `default`-ზე. შეცვალეთ ის ანგარიშის მომხმარებლის იდენტიფიკატორით კვანძის რეგისტრაციამდე. კვანძის რეგისტრაცია სრულად აცილებს ამ საკითხს, რადგან სამართავი სიბრტყე აწვდის მნიშვნელობას.

დაუყენებელი `KURA_TENANT_ID` არ ტოვებს შემოწმებას. ის სრულად თიშავს რეგისტრაციას: კვანძი აგრძელებს ქეშის ტრაფიკის მომსახურებას, დაფაზე არაფერი ჩანს და არანაირი შეცდომა არ მოხსენდება. თუ კვანძი ჯანმრთელია, მაგრამ აკლია **Registered nodes**-ს, პირველ რიგში შეამოწმეთ ეს ცვლადი.

### აირჩიეთ რეკლამირებული URL, რომელსაც თქვენი კლიენტები მიაღწევენ {#choose-an-advertised-url}

გამოიყენეთ კლიენტისთვის ხელმისაწვდომი მისამართი `KURA_ADVERTISED_HTTP_URL`-ისთვის და ქეშის URL-ისთვის, რომელიც კონფიგურირებულია Tuist სერვერზე ან CLI-ში.

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

## ააშენეთ ქეშის ბადე {#build-a-cache-mesh}

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

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

ჩვენ მკაცრად გირჩევთ, უზრუნველყოთ პირის სიბრტყის უსაფრთხოება [mTLS](https://en.wikipedia.org/wiki/Mutual_authentication)-ით, როდესაც კვანძები ერთმანეთთან კომუნიკაციას ახორციელებენ რეგიონებს, ღრუბლებს, 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
```

### კვანძებს შორის სინქრონიზაცია {#catch-up-between-nodes}

კვანძი, რომელიც უერთდება ან ხელახლა უერთდება ბადეს, **ავსებს**: ის გადახედავს თითოეული პირის ჩანაწერებს უახლესიდან დაწყებით და ჩამოტვირთავს იმას, რაც აკლია, ხოლო ცოცხალი რეპლიკაცია ფარავს იმ ჩაწერებს, რომლებიც განხორციელდა პირის ხილვადობის პერიოდში. შევსების ციკლი ვრცელდება პირის უახლესი ჩანაწერიდან კვანძის სეგმენტური რგოლის ჰორიზონტამდე ან მის ბოლო დასრულებულ ციკლამდე (რომელიც უფრო ძველია), ამიტომ კვანძს გარანტირებულად აქვს უახლესი მონაცემები, თუმცა არა აუცილებლად ყველა. `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 ბოლოწერტილების მეშვეობით და არა შიდა პირის სიბრტყის მეშვეობით.

## კონფიგურაცია {#configuration}

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-ის უკან](#load-balancers). | არა | გათიშულია | `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 პორტთან.
