# ავტორიზაცია {#authentication}

სერვერთან ურთიერთობისთვის CLI-მ მოთხოვნები უნდა დააავტოროს [bearer ავტორიზაციის](https://swagger.io/docs/specification/authentication/bearer-authentication/) გამოყენებით. CLI მხარდაჭერილია როგორც მომხმარებლის, ასევე ანგარიშის სახელით ავტორიზაციას, ან OIDC ტოკენის გამოყენებით.

## მომხმარებლის სახელით {#as-a-user}

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

```bash
tuist auth login
```

ბრძანება გაგიყვანთ ვებზე დაფუძნებულ ავტორიზაციის პროცესში. ავტორიზაციის შემდეგ CLI შეინახავს ხანგრძლივი ვადის განახლების ტოკენს და მოკლე ვადის წვდომის ტოკენს `~/.config/tuist/credentials` საქაღალდეში. ამ საქაღალდის თითოეული ფაილი წარმოადგენს დომენს, რომლის მიმართაც მოახდინეთ ავტორიზაცია; ნაგულისხმევად ეს უნდა იყოს `tuist.dev.json`. ამ საქაღალდეში შენახული ინფორმაცია მგრძნობიარეა, ამიტომ **აუცილებლად შეინახეთ ის უსაფრთხოდ**.

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

> [!NOTE]
> თუ თქვენი ორგანიზაცია იყენებს ერთჯერად შესვლას (SSO), ბრაუზერში აირჩიეთ საწარმოს შესვლის ვარიანტი და შეიყვანეთ სამუშაო ელფოსტის მისამართი. Tuist-ს შეუძლია პროვაიდერის პოვნა თქვენი არსებული ორგანიზაციის წევრობიდან ან <.localized_link href="/guides/integrations/authentication/sso#verify-a-login-email-domain">დადასტურებული შესვლის ელფოსტის დომენიდან</.localized_link>.

## OIDC ტოკენები {#oidc-tokens}

CI გარემოებისთვის, რომლებიც მხარს უჭერენ OpenID Connect-ს (OIDC), Tuist-ს შეუძლია ავტომატური ავტორიზაცია ხანგრძლივი ვადის საიდუმლოების მართვის საჭიროების გარეშე. მხარდაჭერილ CI გარემოში გაშვებისას CLI ავტომატურად აღმოაჩენს OIDC ტოკენის პროვაიდერს და ცვლის CI-ს მიერ მოწოდებულ ტოკენს Tuist-ის წვდომის ტოკენზე.

### მხარდაჭერილი პროვაიდერები {#supported-ci-providers}

Tuist ცნობს ამ CI პროვაიდერებს და რეპოზიტორიის კავშირის მეშვეობით მათ ტოკენებს პროექტებს უკავშირებს:

- GitHub Actions
- CircleCI
- Bitrise

[Amp](#amp-orbs)-ის ორბები ავტორიზდება Amp სამუშაო სივრცეების მეშვეობით, რომლებსაც თქვენს Tuist ანგარიშს უკავშირებთ, ხოლო [Claude Code სესიები](#claude-code-sessions) — Claude Code გარემოების მეშვეობით, რომლებსაც Tuist Sandboxes-ზე გასაშვებად უკავშირებთ.

ნებისმიერი სხვა იდენტობის პროვაიდერი, რომელიც გასცემს OpenID Connect ტოკენებს, შეუძლია ავტორიზაცია [სამუშაო დატვირთვის იდენტობის ნდობის პოლიტიკის](#workload-identity-trust-policies) მეშვეობით, რომელსაც ერთხელ აკონფიგურირებთ თქვენი ანგარიშის ყველა არსებული და მომავალი პროექტისთვის, მაგალითად [Fly.io Machines](#flyio-machines).

### OIDC ავტორიზაციის დაყენება {#setting-up-oidc-authentication}

GitHub Actions-ის, CircleCI-ის და Bitrise-ისთვის:

1. **დააკავშირეთ თქვენი რეპოზიტორია Tuist-თან**: მიჰყევით <.localized_link href="/guides/integrations/gitforge/github">GitHub ინტეგრაციის სახელმძღვანელოს</.localized_link>, რათა დააკავშიროთ თქვენი GitHub რეპოზიტორია თქვენს Tuist პროექტთან.

2. **მიანიჭეთ იდენტობის ტოკენი**: GitHub Actions-ში მიანიჭეთ ჯობს `permissions: id-token: write`; CircleCI-სა და Bitrise-ში ჩართეთ OIDC პროექტისთვის. Tuist 4.218.0-დან, როდესაც CLI არ არის შესული და `TUIST_TOKEN` არ არის დაყენებული, ის აღმოაჩენს CI გარემოს და პირველ მოთხოვნაზე ცვლის იდენტობის ტოკენს, ამიტომ შესვლის ეტაპი არ არის საჭირო. ადრეულ ვერსიებს სჭირდებათ ჯერ `tuist auth login`, და შეგიძლიათ მაინც გაუშვათ ის, რათა ცალსახად შეხვიდეთ და ადრე დაფიქსირდეთ შეცდომა, თუ გაცვლა უარყოფილია.

პროვაიდერის სპეციფიკური კონფიგურაციის მაგალითებისთვის იხილეთ <.localized_link href="/guides/integrations/continuous-integration">უწყვეტი ინტეგრაციის სახელმძღვანელო</.localized_link>.

### Amp ორბები {#amp-orbs}

[Amp](https://ampcode.com)-ის ორბებს შეუძლიათ შექმნან OIDC ტოკენები, რომლებიც აიდენტიფიცირებენ მათ Amp სამუშაო სივრცეს. ერთხელ დააკავშირეთ სამუშაო სივრცე თქვენს Tuist ანგარიშთან და Tuist CLI და ამ სამუშაო სივრცის ნებისმიერ ორბში არსებული `tuist_ex` Mix ამოცანები თავად შევლენ, შენახული ტოკენის ან შესვლის ეტაპის გარეშე:

1. იპოვეთ ID-ები: სამუშაო სივრცის ნაკადში, რომელიც ორბში მუშაობს, გაუშვით `echo $AMP_WORKSPACE_ID $AMP_PROJECT_ID`.
2. თქვენს Tuist ანგარიშში გახსენით **პარამეტრები → ინტეგრაციები**, Amp ბარათზე აირჩიეთ **სამუშაო სივრცის დაკავშირება** და ჩასვით სამუშაო სივრცის ID. თუ მხოლოდ ერთი Amp პროექტის ორბების დაშვება გსურთ, ასევე ჩასვით მისი პროექტის ID. უნდა იყოთ ანგარიშის ადმინისტრატორი ან მფლობელი.
3. გამოიყენეთ Tuist ამ სამუშაო სივრცის ორბებში. როდესაც ის არ არის შესული, CLI ან Mix ამოცანა აღმოაჩენს ორბს, ქმნის ტოკენს `amp orb id-token --audience https://tuist.dev`-ით და ცვლის მას Tuist სესიაზე. `tuist auth login` და `mix tuist.login` აკეთებენ იგივე გაცვლას ცალსახად.

ისევე, როგორც [Amp-ის OIDC სახელმძღვანელოში](https://ampcode.com/manual/orbs/oidc) არსებული ნდობის კონფიგურაციები, Tuist ამოწმებს Amp-ის ხელმოწერას ყოველ ტოკენზე და იღებს მას მხოლოდ მაშინ, როდესაც მისი აუდიტორიაა `https://tuist.dev`, მისი `token_use` არის `exchanged`, მისი `workspace_id` ემთხვევა დაკავშირებულ სამუშაო სივრცეს და, პროექტამდე შეზღუდული კავშირის შემთხვევაში, მისი `project_id` ემთხვევა ამ პროექტს. მისმა `sub`-მა უნდა მიუთითოს იგივე სამუშაო სივრცე, ხოლო პროექტის კავშირის შემთხვევაში — იგივე პროექტი, როგორც ამ მოთხოვნებში: `workspace:<workspace-id>:project:<project-id>:…`, რომელსაც `amp orb id-token` ნაგულისხმევად ქმნის.

კავშირის მიერ დაშვებული ყოველი ორბი იღებს CI წვდომას ანგარიშის მფლობელობაში არსებულ ყველა არსებულ და მომავალ პროექტზე, კეშის ატვირთვების ჩათვლით. ის ასევე იღებს `account:sandboxes:write` სკოუპს, რათა შექმნას <.localized_link href="/guides/features/sandboxes">სენდბოქსები</.localized_link> და მათში შეასრულოს ბრძანებები ანგარიშის წევრის მსგავსად, მაგალითად macOS სენდბოქსზე აგებისთვის Linux ორბიდან. დააკავშირეთ მხოლოდ ისეთი სამუშაო სივრცეები, რომელთა წევრებსაც ენდობით ამ წვდომას. ყურადღებით შეამოწმეთ ID: Tuist-ს არ შეუძლია დაადასტუროს, რომ თქვენ ეკუთვნით იმ სამუშაო სივრცეს, რომელსაც აკავშირებთ. თუ სამუშაო სივრცე რამდენიმე Tuist ანგარიშთან არის დაკავშირებული, ორბებმა უნდა დააყენონ `TUIST_OIDC_ACCOUNT` იმ ანგარიშზე, რომელშიც შესვლაა საჭირო; მისი Amp პროექტის გარემოში დაყენება ასევე უზრუნველყოფს, რომ შესვლა თქვენს ანგარიშზე დარჩეს მიბმული. სამუშაო სივრცის გარეთ არსებულ ნაკადებს არ აქვთ სამუშაო სივრცის იდენტობა და ვერ იყენებენ კავშირს. გათიშეთ სამუშაო სივრცე Amp ბარათიდან ახალი შესვლების შესაჩერებლად; უკვე გაცემული სესიები ძალაში რჩებიან ერთი საათის შემდეგ მათ ვადის გასვლამდე. სესიებს არ სჭირდებათ განახლების ტოკენი: როდესაც ერთ-ერთი ვადას ეწურება, ორბში არსებული CLI ქმნის ახალ Amp ტოკენს და ისევ ცვლის მას, რათა ხანგრძლივად მომუშავე ორბები დარჩნენ შესულები, სანამ სამუშაო სივრცე დაკავშირებულია.

Amp გამცემისთვის შექმნილი ნდობის პოლიტიკები, რომლებიც სამუშაო სივრცის დაკავშირებამდე შექმენით, განაგრძობენ მუშაობას, როდესაც აყენებთ `TUIST_OIDC_ACCOUNT`-ს.

### Claude Code სესიები {#claude-code-sessions}

ყოველ Claude Code ღრუბლოვან სესიას თვითმასპინძელ გარემოში აქვს იდენტობის ტოკენი, რომელსაც Anthropic აწერს ხელს (`CLAUDE_CODE_SESSION_ACCESS_TOKEN`). იმ გარემოებში, რომლებსაც <.localized_link href="/guides/features/sandboxes/claude#claude-code">Tuist Sandboxes-ზე გასაშვებად აკავშირებთ</.localized_link>, Tuist გადასცემს მას სესიას როგორც `TUIST_OIDC_TOKEN`, რათა Tuist CLI-მ და `tuist_ex` Mix ამოცანებმა თავად შეასრულონ შესვლა.

Tuist ამოწმებს Anthropic-ის ხელმოწერას და იღებს ტოკენს მხოლოდ მაშინ, როდესაც ის არის სესიის ტოკენი (`ccr:role` არის `session_worker`), რომლის გარემოც, რომელიც მითითებულია აუდიენციაში, დაკავშირებულია Tuist ანგარიშთან და ჩართულია. დაკავშირებული გარემოს ყოველ სესიას ენიჭება CI წვდომა ანგარიშის ყველა მიმდინარე და მომავალ პროექტზე, კეშის ატვირთვების ჩათვლით, და შეუძლია შექმნას და გამოიყენოს ანგარიშის სენდბოქსები, როგორც ანგარიშის წევრს. შესაბამისად, ნებისმიერს, ვისაც თქვენი Claude ორგანიზაცია აძლევს გარემოს გამოყენების უფლებას, შეუძლია გამოაქვეყნოს თქვენს კეშში და გაუშვას სენდბოქსები, მაგალითად, Mac აწყობისთვის. სესიის Tuist სესიები იწურება ერთი საათის შემდეგ ან მის იდენტობის ტოკენთან ერთად, რაც უფრო ადრე მოხდება; ტოკენი არის ის, რომლითაც სესია დაიწყო და ძალაშია ოთხი საათის განმავლობაში ნაგულისხმევად, ამიტომ ხანგრძლივი სესია კარგავს Tuist-ზე წვდომას, სანამ მისი შემდეგი შეტყობინება არ აღადგენს მას ახალ გამშვებზე. გათიშეთ ან დააკავშირეთ გარემო ახალი შესვლების შესაჩერებლად.

### სამუშაო დატვირთვის იდენტობის ნდობის პოლიტიკები {#workload-identity-trust-policies}

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

- იყოს ხელმისაწვდომი HTTPS-ით საჯარო მისამართზე. Tuist არ მიჰყვება გადამისამართებებს და არ უკავშირდება კერძო ან შიდა ქსელის მისამართებს, მათ შორის თვითმასპინძელი Tuist სერვერებიდან.
- გამოსცეს JWT-ები, ხელმოწერილი ასიმეტრიული გასაღებით, მაგალითად `RS256` ან `ES256`. ხელმოუწერელი ტოკენები და ტოკენები, ხელმოწერილი საერთო საიდუმლოთი (`HS256` და მსგავსი), უარყოფილია.
- გამოაქვეყნოს თავისი ხელმოწერის გასაღებები JSON Web Key Set-ის (JWKS) სახით ფიქსირებულ HTTPS URL-ზე. პასუხი უნდა იყოს მაქსიმუმ 64 KiB და შეიცავდეს მაქსიმუმ 20 გასაღებს.
- შეიცავდეს ვადის გასვლას (`exp`) ყოველ ტოკენში.

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

> [!NOTE]
> თვითმასპინძელი განლაგებისთვის, გამოიყენეთ მონაცემთა ბაზის მიგრაციები და განაახლეთ Tuist სერვერის ყოველი მომსახურე რეპლიკა, სანამ დააკონფიგურირებთ სამუშაო დატვირთვის იდენტობებს ან გადაიტანთ მათზე ამოცანებს. შემდეგ განაახლეთ CLI ან Elixir ინტეგრაცია ვერსიამდე, რომელიც მხარს უჭერს `TUIST_OIDC_TOKEN`-ს და `TUIST_OIDC_ACCOUNT`-ს. არსებული GitHub Actions, CircleCI და Bitrise ამოცანები განაგრძობენ რეპოზიტორიაზე დაფუძნებული ავტორიზაციის გამოყენებას და არ საჭიროებენ ანგარიშის სახელს. წარმოების ამოცანებზე გადასვლამდე, შეამოწმეთ ხანმოკლე ტოკენის გაცვლა და კეშის ოპერაცია სასურველ სამუშაო დატვირთვასთან. ახალი გაცვლების შესაჩერებლად, წაშალეთ პოლიტიკა; დაუშვით ერთ საათამდე დრო უკვე გაცემული Tuist წვდომის ტოკენების ვადის გასვლისთვის. პოლიტიკის წაშლა არ აუქმებს მაშინვე ამ ტოკენებს.

#### პოლიტიკის შექმნა {#create-a-trust-policy}

Tuist დაფლაზე, გახსენით თქვენი ანგარიშის **პარამეტრები** > **ავთენტიკაცია** და იპოვეთ **სამუშაო დატვირთვის იდენტობები** სექცია. თქვენ უნდა იყოთ ანგარიშის ადმინისტრატორი (ან პირადი ანგარიშის მფლობელი). ყოველ ანგარიშს შეიძლება ჰქონდეს მაქსიმუმ 20 პოლიტიკა. დააკონფიგურეთ იდენტობა ერთხელ ანგარიშის მასშტაბით CI წვდომისთვის; პროექტის შერჩევა არ არის საჭირო.

გამოიყენეთ გადამრთველი **სამუშაო დატვირთვის იდენტობების** გვერდით პოლიტიკის ფორმის გასახსნელად. გადამრთველი ირთვება, როდესაც ანგარიშს აქვს შენახული იდენტობები და რჩება ჩართული შენახვის შემდეგ. ის იწყება გამორთულ მდგომარეობაში იმ ანგარიშებისთვის, რომლებსაც არ აქვთ იდენტობები. სექცია ჩნდება **SCIM პროვიზინგის** ქვემოთ ორგანიზაციებისთვის. ფორმის დამალვა ინარჩუნებს თქვენს პროექტს და არ თიშავს სამუშაო დატვირთვის ავთენტიკაციას: შენახული იდენტობის ბარათები და მორგების დოკუმენტაციის ბმული რჩება ხილული. ყოველი ბარათი აჩვენებს იდენტობის სახელს, გამცემის და JWKS URL-ებს, აუდიენციას, ზუსტ JSON პრეტენზიებს, ანგარიშის მასშტაბის სფეროს და შექმნის დროს. წაშალეთ იდენტობა მის ბარათზე არსებული ქმედების გამოყენებით.

აირჩიეთ **მორგებული პროვაიდერი** ქვემოთ მოცემული ველების შესაყვანად, ან **Fly.io Machines** მათი გენერირებისთვის თქვენი ორგანიზაციის slug-ისა და რიცხვითი ორგანიზაციის და აპლიკაციის ID-ების მიხედვით. Fly შაბლონი ინარჩუნებს გენერირებულ გამცემს, JWKS URL-ს და პრეტენზიებს რედაქტირებადს **დამატებითი კონფიგურაციის** ქვეშ. შაბლონების ან დამხმარე მნიშვნელობების შეცვლა ინარჩუნებს ხელით რედაქტირებულ ველებს. თუ თქვენი გამცემი, JWKS URL ან პრეტენზიები გადაფარავს შაბლონს, Tuist აფართოებს **დამატებით კონფიგურაციას** და აჩვენებს გაფრთხილებას, რათა შეამოწმოთ პოლიტიკა, რომელიც შეინახება. გადადით უკან **მორგებულ პროვაიდერზე** Fly-ს დამხმარეების გარეშე გასაგრძელებლად. შაბლონები მხოლოდ ავსებენ კონფიგურაციას და არ ცვლიან იმას, თუ როგორ ამოწმებს Tuist ტოკენებს.

| ველი | აღწერა |
| --- | --- |
| სახელი | ლეიბლი პოლიტიკის ამოსაცნობად, უნიკალური ანგარიშის ფარგლებში. |
| გამცემის URL | ტოკენის `iss` პრეტენზია. ის უნდა ემთხვეოდეს ზუსტად, ბოლო სლეშის ჩათვლით. |
| JWKS URL | პროვაიდერის ხელმოწერის გასაღებების HTTPS URL. Tuist იყენებს ამ URL-ს პირდაპირ და არ კითხულობს პროვაიდერის OpenID Connect აღმოჩენის დოკუმენტს, ამიტომ დააკოპირეთ `jwks_uri` პროვაიდერის დოკუმენტაციიდან ან `<issuer>/.well-known/openid-configuration`-დან. |
| აუდიენცია | აუდიენცია, რომლისთვისაც უნდა იყოს გაცემული ტოკენი, ნაგულისხმევად `tuist`. ტოკენის `aud` უნდა უდრიდეს მას ან, როდესაც `aud` არის სია, შეიცავდეს მას. გამოიყენეთ მნიშვნელობა, რომელსაც მხოლოდ Tuist იღებს, რათა სხვა სერვისებისთვის გაცემული ტოკენები ვერ განმეორდეს აქ. |
| პრეტენზიები | JSON ობიექტი 1-დან 10-მდე პრეტენზიით, რომელიც ტოკენმა უნდა შეიცავდეს, მაგალითად `{"sub": "system:serviceaccount:ci:builder"}`. JSON შეყვანა შეზღუდულია 8 KiB-მდე. მნიშვნელობები უნდა იყოს სტრიქონები, ნიშნიანი 64-ბიტიანი მთელი რიცხვები ან ბულეანები, და ისინი უნდა ემთხვეოდნენ ზუსტად, მათი ტიპის ჩათვლით: `"123"` არ ემთხვევა `123`-ს. ჩადგმული ობიექტები, სიები და დროის ან ტოკენის პრეტენზიები, როგორიცაა `iss`, `aud`, `exp`, `nbf`, `iat` და `jti`, არ არის დაშვებული. |

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

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

> [!WARNING]
> გაზიარებულ იდენტობის პროვაიდერზე, მიამაგრეთ პოლიტიკა თქვენს ორგანიზაციას ან არენდატორს **და** სასურველ აპლიკაციას, პროექტს ან სერვისის ანგარიშს. ტოტის სახელი, როგორიცაა `main`, გარემო, როგორიცაა `production`, ან ზოგადი როლი მხოლოდ არ წარმოადგენს იდენტობის საზღვარს: სხვა არენდატორმა შეიძლება მიიღოს ტოკენი იგივე მნიშვნელობებით. მაგალითად, GitLab.com-ის პოლიტიკა უნდა შეიცავდეს სასურველი პროექტის სტაბილურ `project_id`-ს, არა მხოლოდ `ref`-ს. შესაბამისი ტოკენი ანიჭებს ანგარიშის მასშტაბით CI წვდომას, კეშში ჩაწერების ჩათვლით, ამიტომ პოლიტიკა, რომელიც ენდობა დაუკავშირებელ სამუშაო დატვირთვებს, შეიძლება დაუშვას კეშის მოწამვლა.

Tuist ანიჭებს წვდომას მხოლოდ იმ პოლიტიკებისთვის, რომელთა საკუთარი JWKS URL შეიცავს გასაღებს, რომელიც ხელს აწერს ტოკენს, გამომცემლის, აუდიტორიის, ვადის გასვლის, არა-ადრე დროის (60 წამამდე საათის გადახრით) და ყოველი პრეტენზიის შემოწმების შემდეგ. გაცემული ერთსაათიანი CI ტოკენი არის ანგარიშის მასშტაბით, არა პროექტების ID-ების სნეპშოტი: ის მოიცავს პროექტებს, რომლებიც შეიქმნა ან გადაეცა ანგარიშზე გაცემის შემდეგ. პროექტის ავტორიზაცია კვლავ მოითხოვს მიმდინარე ანგარიშის მფლობელობას, ამიტომ პროექტის გადაცემა აშორებს მის წვდომას ამ ანგარიშის ტოკენის ქვეშ.

#### სამუშაო დატვირთვის ავტენტიკაცია {#authenticate-a-workload}

1. მოითხოვეთ იდენტობის ტოკენი თქვენი პროვაიდერისგან პოლიტიკის აუდიტორიით.
2. დააყენეთ `TUIST_OIDC_TOKEN` ამ ტოკენზე და `TUIST_OIDC_ACCOUNT` Tuist ანგარიშის სახელზე, რომელიც ფლობს პროექტს. ანგარიში აუცილებელია ნდობის პოლიტიკის ყოველი გაცვლისთვის. ის მხოლოდ ირჩევს, სად უნდა მოხდოს ძიება და თავისთავად არაფერს ანიჭებს.
3. გაუშვით Tuist. როდესაც არ არის ხელმისაწვდომი `TUIST_TOKEN` ან მოქმედი შენახული რწმუნებულებები, CLI და Elixir ინტეგრაცია ავტომატურად ცვლის ტოკენს. `tuist auth login` და `mix tuist.login` ასრულებენ იგივე გაცვლას ცალსახად.

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

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

Tuist აკეთებს პროვაიდერის ხელმოწერის გასაღებების კეშირებას 15 წუთის განმავლობაში წარმატებული მიღების შემდეგ სპეციალურ, ზომით შეზღუდულ კეშში. ჩანაწერები შეიძლება ადრე ამოიღონ და ხელახლა მიიღონ. წარუმატებელი მიღებები არ კეშირდება. თუ თქვენი პროვაიდერი ატრიალებს გასაღებებს, მან უნდა გამოაქვეყნოს ახალი გასაღები თავის JWKS-ში ტოკენებით ხელმოწერამდე მინიმუმ 15 წუთით ადრე, რადგან ტოკენები, რომლებიც ხელმოწერილია გასაღებით, რომელიც არ არის კეშირებულ ნაკრებში, უარყოფილია, სანამ კეში არ ამოიწურება. ტოკენები გასაღების ID-ის (`kid`) გარეშე მიიღება მხოლოდ მაშინ, როდესაც JWKS შეიცავს ერთადერთ შესაბამის ხელმოწერის გასაღებს. როდესაც JWKS-ში არის გასაღების ID, ის უნდა იყოს სტრიქონი არაუმეტეს 256 ბაიტისა.

> [!NOTE]
> `TUIST_OIDC_TOKEN` არის ზოგადი ტოკენის შეყვანა, არა სერვერის ნდობის გვერდის ავლის გზა. ის უპირატესობას ანიჭებს CI პროვაიდერის აღმოჩენას და სერვერი კვლავ იღებს მხოლოდ ჩაშენებულ პროვაიდერებს და იდენტობებს შესაბამისი ნდობის პოლიტიკით. არ ჩასვათ იდენტობის ტოკენი `TUIST_TOKEN`-ში, რომელიც ელოდება Tuist რწმუნებულებას.

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

### Fly.io Machines {#flyio-machines}

[Fly.io მხარს უჭერს OIDC სამუშაო იდენტობას](https://docs.fly.io/reference/openid-connect/). Machine-ს შეუძლია მოითხოვოს მოკლე ვადით მოქმედი, ხელმოწერილი იდენტობის ტოკენი თავისი ადგილობრივი `/.fly/api` Unix სოკეტიდან, Fly API ტოკენის ან ხანგრძლივი Tuist საიდუმლოს გარეშე. Fly ტოკენები აიდენტიფიცირებენ ორგანიზაციას და აპლიკაციას, არა საწყის რეპოზიტორიას, ამიტომ გამოიყენეთ ნდობის პოლიტიკა GitHub რეპოზიტორიის დაკავშირების ნაცვლად:

1. მიიღეთ გამომცემელი (`iss`), ორგანიზაციის ID (`org_id`) და აპლიკაციის ID (`app_id`) თქვენს Fly Machine-ში გაცემული იდენტობის ტოკენიდან. გამომცემელია `https://oidc.fly.io/<organization-slug>`. გამოიყენეთ რიცხვითი ID-ები, არა ორგანიზაციის ან აპის სახელები.
2. [შექმენით ნდობის პოლიტიკა](#create-a-trust-policy) **Fly.io Machines** შაბლონის გამოყენებით და შეიყვანეთ ორგანიზაციის slug და ორივე რიცხვითი ID. ის ავსებს ქვემოთ მოცემულ მნიშვნელობებს და ინახავს ID-ებს სტრიქონებად. ასევე შეგიძლიათ შეიყვანოთ ისინი ხელით **Custom provider**-ის გამოყენებით; შეინახეთ ბრჭყალები ID-ების გარშემო პრეტენზიებში.

   | ველი | მნიშვნელობა |
   | --- | --- |
   | გამომცემლის URL | `https://oidc.fly.io/<organization-slug>` |
   | JWKS URL | `https://oidc.fly.io/<organization-slug>/.well-known/jwks` |
   | აუდიტორია | `tuist` |
   | პრეტენზიები | `{"org_id": "<organization-id>", "app_id": "<application-id>"}` |

3. Machine-ის შიგნით, დააყენეთ `TUIST_OIDC_ACCOUNT` Tuist ანგარიშის სახელზე, რომელიც ფლობს პროექტს (არა Fly ორგანიზაციის slug), მოითხოვეთ ტოკენი აუდიტორიით `tuist` და გადაეცით ის `tuist auth login`-ს `TUIST_OIDC_TOKEN`-ის გამოყენებით:

```bash
set -euo pipefail
export TUIST_OIDC_ACCOUNT="my-tuist-account"

TUIST_OIDC_TOKEN="$(curl --fail --silent --show-error \
  --unix-socket /.fly/api \
  -X POST http://localhost/v1/tokens/oidc \
  -H 'Content-Type: application/json' \
  --data '{"aud":"tuist"}')"
export TUIST_OIDC_TOKEN

tuist auth login
unset TUIST_OIDC_TOKEN
```

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

```bash
python3 - <<'PY'
import base64, json, os
payload = os.environ["TUIST_OIDC_TOKEN"].split(".")[1]
claims = json.loads(base64.urlsafe_b64decode(payload + "=" * (-len(payload) % 4)))
print(json.dumps({key: claims[key] for key in ("iss", "org_id", "app_id")}, indent=2))
PY
```

არ დაბეჭდოთ ან არ ჩააკომიტოთ თავად ტოკენი. ყოველ Machine-ს ავტორიზებულ Fly აპში შეუძლია ავტენტიკაცია Tuist ანგარიშის ყველა მიმდინარე და მომავალ პროექტზე. შექმენით ცალკე პოლიტიკა ყოველი დამატებითი აპისთვის. Fly იდენტობის ტოკენები იწურება დაახლოებით ათი წუთის შემდეგ, ამიტომ ხანგრძლივად მომუშავე Machine-ებზე მოითხოვეთ ახალი და გაუშვით `tuist auth login` ხელახლა, სანამ ერთსაათიანი Tuist სესია ამოიწურება.

### OIDC ტოკენის სკოპები {#oidc-token-scopes}

OIDC ტოკენებს ენიჭებათ `ci` სკოპების ჯგუფი. GitHub Actions-ის, CircleCI-ის და Bitrise-ისთვის, ეს უზრუნველყოფს წვდომას რეპოზიტორიასთან დაკავშირებულ ყველა პროექტზე. დაკავშირებული Amp workspace-ების, დაკავშირებული Claude Code გარემოების და სამუშაო იდენტობის ნდობის პოლიტიკებისთვის, ეს უზრუნველყოფს წვდომას შერჩეული ანგარიშის ყველა მიმდინარე და მომავალ პროექტზე, პროექტის შექმნის, პროექტის ადმინისტრირების, runner-ის ადმინისტრირების ან ანგარიშის წევრების ადმინისტრირების გაცემის გარეშე. იხილეთ [სკოპების ჯგუფები](#scope-groups) დეტალებისთვის, თუ რას მოიცავს `ci` სკოპი.

> [!TIP]
> **უსაფრთხოების სარგებელი**
>
> OIDC ავტენტიკაცია უფრო უსაფრთხოა, ვიდრე ხანგრძლივი ვადის ტოკენები, რადგან:
> - არ არის საიდუმლოები, რომლებიც უნდა შეიცვალოს ან იმართოს
> - ტოკენები მოკლე ვადითაა
> - ავტენტიკაცია მიბმულია თქვენს რეპოზიტორიის იდენტობასთან ან ცალსახად ავტორიზებულ სამუშაო იდენტობასთან


## Gradle პლაგინის ავტენტიკაცია {#gradle-plugin-authentication}

Gradle პლაგინი იყენებს Tuist CLI-ის ავტენტიკაციის მდგომარეობას და არ განსაზღვრავს ცალკე შესვლის პროცესს. ერთხელ გაიარეთ ავტენტიკაცია CLI-ით და პლაგინი ხელახლა გამოიყენებს ამ მონაცემებს.

პროექტისა და სერვერის კონფიგურაციისთვის, მათ შორის `project` და `url`, გამოიყენეთ კანონიკური <.localized_link href="/references/tuist-toml">tuist.toml მითითება</.localized_link>.

ლოკალური გამოყენებისთვის, გაუშვით:

```bash
tuist auth login
```

CI-ისთვის, გამოიყენეთ ერთ-ერთი:

- <.localized_link href="/guides/server/authentication#setting-up-oidc-authentication">OIDC ავტენტიკაცია</.localized_link> (რეკომენდებულია, როცა ხელმისაწვდომია)
- <.localized_link href="/guides/server/authentication#continuous-integration">ანგარიშის ტოკენით ავტენტიკაცია</.localized_link> `TUIST_TOKEN`-ის საშუალებით

თვითმასპინძელი Tuist სერვერებისთვის, განსაზღვრეთ სერვერის URL `tuist.toml`-ში (მაგალითად `url = "https://tuist.your-company.com"`) და გაუშვით სტანდარტული შესვლის პროცესი. URL იგივე კონფიგურაციის ფაილიდან იხსნება, რომელსაც პლაგინი იყენებს.

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

## ანგარიშის ტოკენები {#account-tokens}

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

### ანგარიშის ტოკენის შექმნა {#creating-an-account-token}

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

1. გახსენით ორგანიზაცია Tuist დაშბორდზე.
2. გადადით **პარამეტრებში** > **ტოკენები**.
3. აირჩიეთ **ტოკენის გენერირება**.
4. აირჩიეთ სახელი, ვადის გასვლის არასავალდებულო პარამეტრი, პროექტზე წვდომა და სკოპები, რომლებიც ტოკენს სჭირდება.
5. დახურვამდე დააკოპირეთ გენერირებული ტოკენის მნიშვნელობა. ტოკენის მნიშვნელობები მხოლოდ ერთხელ ჩანს.

ანგარიშის ტოკენების შექმნა ასევე შეგიძლიათ CLI-დან, რაც სასარგებლოა სკრიპტინგისთვის ან ავტომატიზაციისთვის:

```bash
tuist account tokens create account-handle \
  --scopes account:cache:write project:cache:read project:cache:write \
  --name ci-cache-token \
  --expires 1y
```

> [!IMPORTANT]
> ჩაანაცვლეთ `account-handle` იმ ანგარიშის handle-ით, რომელიც ფლობს პროექტებს, რომლებზეც ტოკენს წვდომა გსურთ. ეს შეიძლება იყოს ორგანიზაციის ანგარიში და არა აუცილებლად თქვენი პირადი ანგარიში.

ბრძანება იღებს შემდეგ პარამეტრებს:

| პარამეტრი | აღწერა |
| --- | --- |
| `--scopes` | სავალდებულო. სკოპების სია, გამოყოფილი გამოტოვებით, რომლებიც ტოკენს მიენიჭება. |
| `--name` | სავალდებულო. ტოკენის უნიკალური იდენტიფიკატორი (1-32 სიმბოლო, მხოლოდ ალფანუმერული, დეფისები და ქვეტირეები). |
| `--expires` | არასავალდებულო. როდის უნდა ამოიწუროს ტოკენმა. გამოიყენეთ ფორმატი, როგორიცაა `30d` (დღეები), `6m` (თვეები) ან `1y` (წლები). თუ არ არის მითითებული, ტოკენი არასდროს ამოიწურება. |
| `--projects` | შეზღუდეთ ტოკენი კონკრეტული პროექტების handle-ებით. თუ არ არის მითითებული, ტოკენს აქვს წვდომა ყველა პროექტზე. |

### ხელმისაწვდომი სკოპები {#available-scopes}

| სკოპი | აღწერა |
| --- | --- |
| `account:cache:read` | ანგარიშის დონეზე ქეშირებული ბინარების ჩამოტვირთვა |
| `account:cache:write` | ანგარიშის დონეზე ქეშირებული ბინარების ატვირთვა |
| `account:members:read` | ანგარიშის წევრების წაკითხვა |
| `account:members:write` | ანგარიშის წევრების მართვა |
| `account:registry:read` | Swift პაკეტების რეესტრიდან წაკითხვა |
| `account:registry:write` | Swift პაკეტების რეესტრში გამოქვეყნება |
| `account:runners:read` | runner-ის დავალებების, სამუშაო ნაკადების, პროფილებისა და ტომების წაკითხვა |
| `account:runners:write` | runner-ის პროფილების მართვა და runner-ის ტომების წაშლა |
| `account:sandboxes:write` | sandbox-ების შექმნა და მათში ბრძანებების გაშვება, როგორც ანგარიშის წევრს |
| `project:previews:read` | პრევიუების ჩამოტვირთვა |
| `project:previews:write` | პრევიუების ატვირთვა |
| `project:admin:read` | პროექტებისა და მათი პარამეტრების წაკითხვა |
| `project:admin:write` | პროექტების შექმნა, განახლება და წაშლა. პროექტის შესაქმნელად საჭიროა ტოკენი, რომელსაც აქვს წვდომა ყველა პროექტზე |
| `project:cache:read` | ქეშირებული ბინარების ჩამოტვირთვა |
| `project:cache:write` | ქეშირებული ბინარების ატვირთვა |
| `project:bundles:read` | ბანდლების ნახვა |
| `project:bundles:write` | ბანდლების ატვირთვა |
| `project:tests:read` | ტესტების შედეგების წაკითხვა |
| `project:tests:write` | ტესტების შედეგების ატვირთვა |
| `project:builds:read` | ბილდის ანალიტიკის წაკითხვა |
| `project:builds:write` | ბილდის ანალიტიკის ატვირთვა |
| `project:runs:read` | ბრძანებების გაშვებების წაკითხვა |
| `project:runs:write` | ბრძანებების გაშვებების შექმნა და განახლება |

### სკოპების ჯგუფები {#scope-groups}

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

| სკოპების ჯგუფი | შემავალი სკოპები |
| --- | --- |
| `ci` | `account:cache:write`, `project:cache:write`, `project:previews:write`, `project:bundles:write`, `project:tests:write`, `project:builds:write`, `project:runs:write` |
| `mcp` | `project:cache:read`, `project:previews:read`, `project:bundles:read`, `project:tests:read`, `project:builds:read`, `project:runs:read` |

### უწყვეტი ინტეგრაცია {#continuous-integration}

CI გარემოებისთვის, რომლებიც არ უჭერენ მხარს OIDC-ს, შექმენით ანგარიშის ტოკენი `ci` სკოპების ჯგუფით თქვენი CI სამუშაო ნაკადების ავთენტიკაციისთვის. დაფლატაზე ტოკენის გენერირებისას აირჩიეთ **CI** პრესეტი.

ასევე შეგიძლიათ შექმნათ იგივე ტოკენი CLI-დან:

```bash
tuist account tokens create account-handle --scopes ci --name ci
```

ეს ქმნის ტოკენს ყველა იმ სკოპით, რაც საჭიროა ტიპური CI ოპერაციებისთვის (ქეში, პრევიუები, ბანდლები, ტესტები, ბილდები და გაშვებები). შეინახეთ გენერირებული ტოკენი როგორც საიდუმლო თქვენს CI გარემოში და დააყენეთ ის როგორც `TUIST_TOKEN` გარემოს ცვლადი.

### ანგარიშის ტოკენების მართვა {#managing-account-tokens}

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

ანგარიშის ყველა ტოკენის სიის სანახავად:

```bash
tuist account tokens list account-handle
```

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

```bash
tuist account tokens revoke account-handle ci-cache-token
```

### ანგარიშის ტოკენების გამოყენება {#using-account-tokens}

ანგარიშის ტოკენები უნდა იყოს განსაზღვრული როგორც გარემოს ცვლადი `TUIST_TOKEN`:

```bash
export TUIST_TOKEN=your-account-token
```

> [!TIP]
> **როდის გამოვიყენოთ ანგარიშის ტოკენები**
>
> გამოიყენეთ ანგარიშის ტოკენები, როდესაც გჭირდებათ:
> - ავთენტიკაცია CI გარემოებში, რომლებიც არ უჭერენ მხარს OIDC-ს
> - ზუსტი კონტროლი იმაზე, თუ რა ოპერაციების შესრულება შეუძლია ტოკენს
> - ტოკენი, რომელსაც შეუძლია წვდომა ანგარიშში არსებულ რამდენიმე პროექტზე
> - დროით შეზღუდული ტოკენები, რომლებიც ავტომატურად ამოიწურება
