ავტორიზაცია
სერვერთან ურთიერთობისთვის CLI-მ მოთხოვნები უნდა დააავტოროს bearer ავტორიზაციის გამოყენებით. CLI მხარდაჭერილია როგორც მომხმარებლის, ასევე ანგარიშის სახელით ავტორიზაციას, ან OIDC ტოკენის გამოყენებით.
მომხმარებლის სახელით#
როდესაც CLI-ს იყენებთ თქვენს კომპიუტერზე ლოკალურად, გირჩევთ ავტორიზაცია მოახდინოთ მომხმარებლის სახელით. მომხმარებლის სახელით ავტორიზაციისთვის უნდა გაუშვათ შემდეგი ბრძანება:
tuist auth login
ბრძანება გაგიყვანთ ვებზე დაფუძნებულ ავტორიზაციის პროცესში. ავტორიზაციის შემდეგ CLI შეინახავს ხანგრძლივი ვადის განახლების ტოკენს და მოკლე ვადის წვდომის ტოკენს ~/.config/tuist/credentials საქაღალდეში. ამ საქაღალდის თითოეული ფაილი წარმოადგენს დომენს, რომლის მიმართაც მოახდინეთ ავტორიზაცია; ნაგულისხმევად ეს უნდა იყოს tuist.dev.json. ამ საქაღალდეში შენახული ინფორმაცია მგრძნობიარეა, ამიტომ აუცილებლად შეინახეთ ის უსაფრთხოდ.
CLI ავტომატურად მოიძიებს სერთიფიკატებს სერვერთან მოთხოვნების შესრულებისას. თუ წვდომის ტოკენი ვადაგასულია, CLI გამოიყენებს განახლების ტოკენს ახალი წვდომის ტოკენის მისაღებად.
თუ თქვენი ორგანიზაცია იყენებს ერთჯერად შესვლას (SSO), ბრაუზერში აირჩიეთ საწარმოს შესვლის ვარიანტი და შეიყვანეთ სამუშაო ელფოსტის მისამართი. Tuist-ს შეუძლია პროვაიდერის პოვნა თქვენი არსებული ორგანიზაციის წევრობიდან ან დადასტურებული შესვლის ელფოსტის დომენიდან.
OIDC ტოკენები#
CI გარემოებისთვის, რომლებიც მხარს უჭერენ OpenID Connect-ს (OIDC), Tuist-ს შეუძლია ავტომატური ავტორიზაცია ხანგრძლივი ვადის საიდუმლოების მართვის საჭიროების გარეშე. მხარდაჭერილ CI გარემოში გაშვებისას CLI ავტომატურად აღმოაჩენს OIDC ტოკენის პროვაიდერს და ცვლის CI-ს მიერ მოწოდებულ ტოკენს Tuist-ის წვდომის ტოკენზე.
მხარდაჭერილი პროვაიდერები#
Tuist ცნობს ამ CI პროვაიდერებს და რეპოზიტორიის კავშირის მეშვეობით მათ ტოკენებს პროექტებს უკავშირებს:
- GitHub Actions
- CircleCI
- Bitrise
Amp-ის ორბები ავტორიზდება Amp სამუშაო სივრცეების მეშვეობით, რომლებსაც თქვენს Tuist ანგარიშს უკავშირებთ, ხოლო Claude Code სესიები — Claude Code გარემოების მეშვეობით, რომლებსაც Tuist Sandboxes-ზე გასაშვებად უკავშირებთ.
ნებისმიერი სხვა იდენტობის პროვაიდერი, რომელიც გასცემს OpenID Connect ტოკენებს, შეუძლია ავტორიზაცია სამუშაო დატვირთვის იდენტობის ნდობის პოლიტიკის მეშვეობით, რომელსაც ერთხელ აკონფიგურირებთ თქვენი ანგარიშის ყველა არსებული და მომავალი პროექტისთვის, მაგალითად Fly.io Machines.
OIDC ავტორიზაციის დაყენება#
GitHub Actions-ის, CircleCI-ის და Bitrise-ისთვის:
-
დააკავშირეთ თქვენი რეპოზიტორია Tuist-თან: მიჰყევით GitHub ინტეგრაციის სახელმძღვანელოს, რათა დააკავშიროთ თქვენი GitHub რეპოზიტორია თქვენს Tuist პროექტთან.
-
მიანიჭეთ იდენტობის ტოკენი: GitHub Actions-ში მიანიჭეთ ჯობს
permissions: id-token: write; CircleCI-სა და Bitrise-ში ჩართეთ OIDC პროექტისთვის. Tuist 4.218.0-დან, როდესაც CLI არ არის შესული დაTUIST_TOKENარ არის დაყენებული, ის აღმოაჩენს CI გარემოს და პირველ მოთხოვნაზე ცვლის იდენტობის ტოკენს, ამიტომ შესვლის ეტაპი არ არის საჭირო. ადრეულ ვერსიებს სჭირდებათ ჯერtuist auth login, და შეგიძლიათ მაინც გაუშვათ ის, რათა ცალსახად შეხვიდეთ და ადრე დაფიქსირდეთ შეცდომა, თუ გაცვლა უარყოფილია.
პროვაიდერის სპეციფიკური კონფიგურაციის მაგალითებისთვის იხილეთ უწყვეტი ინტეგრაციის სახელმძღვანელო.
Amp ორბები#
Amp-ის ორბებს შეუძლიათ შექმნან OIDC ტოკენები, რომლებიც აიდენტიფიცირებენ მათ Amp სამუშაო სივრცეს. ერთხელ დააკავშირეთ სამუშაო სივრცე თქვენს Tuist ანგარიშთან და Tuist CLI და ამ სამუშაო სივრცის ნებისმიერ ორბში არსებული tuist_ex Mix ამოცანები თავად შევლენ, შენახული ტოკენის ან შესვლის ეტაპის გარეშე:
- იპოვეთ ID-ები: სამუშაო სივრცის ნაკადში, რომელიც ორბში მუშაობს, გაუშვით
echo $AMP_WORKSPACE_ID $AMP_PROJECT_ID. - თქვენს Tuist ანგარიშში გახსენით პარამეტრები → ინტეგრაციები, Amp ბარათზე აირჩიეთ სამუშაო სივრცის დაკავშირება და ჩასვით სამუშაო სივრცის ID. თუ მხოლოდ ერთი Amp პროექტის ორბების დაშვება გსურთ, ასევე ჩასვით მისი პროექტის ID. უნდა იყოთ ანგარიშის ადმინისტრატორი ან მფლობელი.
- გამოიყენეთ Tuist ამ სამუშაო სივრცის ორბებში. როდესაც ის არ არის შესული, CLI ან Mix ამოცანა აღმოაჩენს ორბს, ქმნის ტოკენს
amp orb id-token --audience https://tuist.dev-ით და ცვლის მას Tuist სესიაზე.tuist auth loginდაmix tuist.loginაკეთებენ იგივე გაცვლას ცალსახად.
ისევე, როგორც Amp-ის 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 სკოუპს, რათა შექმნას სენდბოქსები და მათში შეასრულოს ბრძანებები ანგარიშის წევრის მსგავსად, მაგალითად macOS სენდბოქსზე აგებისთვის Linux ორბიდან. დააკავშირეთ მხოლოდ ისეთი სამუშაო სივრცეები, რომელთა წევრებსაც ენდობით ამ წვდომას. ყურადღებით შეამოწმეთ ID: Tuist-ს არ შეუძლია დაადასტუროს, რომ თქვენ ეკუთვნით იმ სამუშაო სივრცეს, რომელსაც აკავშირებთ. თუ სამუშაო სივრცე რამდენიმე Tuist ანგარიშთან არის დაკავშირებული, ორბებმა უნდა დააყენონ TUIST_OIDC_ACCOUNT იმ ანგარიშზე, რომელშიც შესვლაა საჭირო; მისი Amp პროექტის გარემოში დაყენება ასევე უზრუნველყოფს, რომ შესვლა თქვენს ანგარიშზე დარჩეს მიბმული. სამუშაო სივრცის გარეთ არსებულ ნაკადებს არ აქვთ სამუშაო სივრცის იდენტობა და ვერ იყენებენ კავშირს. გათიშეთ სამუშაო სივრცე Amp ბარათიდან ახალი შესვლების შესაჩერებლად; უკვე გაცემული სესიები ძალაში რჩებიან ერთი საათის შემდეგ მათ ვადის გასვლამდე. სესიებს არ სჭირდებათ განახლების ტოკენი: როდესაც ერთ-ერთი ვადას ეწურება, ორბში არსებული CLI ქმნის ახალ Amp ტოკენს და ისევ ცვლის მას, რათა ხანგრძლივად მომუშავე ორბები დარჩნენ შესულები, სანამ სამუშაო სივრცე დაკავშირებულია.
Amp გამცემისთვის შექმნილი ნდობის პოლიტიკები, რომლებიც სამუშაო სივრცის დაკავშირებამდე შექმენით, განაგრძობენ მუშაობას, როდესაც აყენებთ TUIST_OIDC_ACCOUNT-ს.
Claude Code სესიები#
ყოველ Claude Code ღრუბლოვან სესიას თვითმასპინძელ გარემოში აქვს იდენტობის ტოკენი, რომელსაც Anthropic აწერს ხელს (CLAUDE_CODE_SESSION_ACCESS_TOKEN). იმ გარემოებში, რომლებსაც Tuist Sandboxes-ზე გასაშვებად აკავშირებთ, Tuist გადასცემს მას სესიას როგორც TUIST_OIDC_TOKEN, რათა Tuist CLI-მ და tuist_ex Mix ამოცანებმა თავად შეასრულონ შესვლა.
Tuist ამოწმებს Anthropic-ის ხელმოწერას და იღებს ტოკენს მხოლოდ მაშინ, როდესაც ის არის სესიის ტოკენი (ccr:role არის session_worker), რომლის გარემოც, რომელიც მითითებულია აუდიენციაში, დაკავშირებულია Tuist ანგარიშთან და ჩართულია. დაკავშირებული გარემოს ყოველ სესიას ენიჭება CI წვდომა ანგარიშის ყველა მიმდინარე და მომავალ პროექტზე, კეშის ატვირთვების ჩათვლით, და შეუძლია შექმნას და გამოიყენოს ანგარიშის სენდბოქსები, როგორც ანგარიშის წევრს. შესაბამისად, ნებისმიერს, ვისაც თქვენი Claude ორგანიზაცია აძლევს გარემოს გამოყენების უფლებას, შეუძლია გამოაქვეყნოს თქვენს კეშში და გაუშვას სენდბოქსები, მაგალითად, Mac აწყობისთვის. სესიის Tuist სესიები იწურება ერთი საათის შემდეგ ან მის იდენტობის ტოკენთან ერთად, რაც უფრო ადრე მოხდება; ტოკენი არის ის, რომლითაც სესია დაიწყო და ძალაშია ოთხი საათის განმავლობაში ნაგულისხმევად, ამიტომ ხანგრძლივი სესია კარგავს Tuist-ზე წვდომას, სანამ მისი შემდეგი შეტყობინება არ აღადგენს მას ახალ გამშვებზე. გათიშეთ ან დააკავშირეთ გარემო ახალი შესვლების შესაჩერებლად.
სამუშაო დატვირთვის იდენტობის ნდობის პოლიტიკები#
ნდობის პოლიტიკა საშუალებას აძლევს სხვა იდენტობის პროვაიდერის სამუშაო დატვირთვებს, როგორიცაა განლაგების პლატფორმა, 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 გამცემები შენახულია ზემოთ აღწერილი რეპოზიტორიაზე დაფუძნებული ნაკადისთვის და არ შეიძლება გამოყენებულ იქნას ნდობის პოლიტიკაში.
თვითმასპინძელი განლაგებისთვის, გამოიყენეთ მონაცემთა ბაზის მიგრაციები და განაახლეთ Tuist სერვერის ყოველი მომსახურე რეპლიკა, სანამ დააკონფიგურირებთ სამუშაო დატვირთვის იდენტობებს ან გადაიტანთ მათზე ამოცანებს. შემდეგ განაახლეთ CLI ან Elixir ინტეგრაცია ვერსიამდე, რომელიც მხარს უჭერს TUIST_OIDC_TOKEN-ს და TUIST_OIDC_ACCOUNT-ს. არსებული GitHub Actions, CircleCI და Bitrise ამოცანები განაგრძობენ რეპოზიტორიაზე დაფუძნებული ავტორიზაციის გამოყენებას და არ საჭიროებენ ანგარიშის სახელს. წარმოების ამოცანებზე გადასვლამდე, შეამოწმეთ ხანმოკლე ტოკენის გაცვლა და კეშის ოპერაცია სასურველ სამუშაო დატვირთვასთან. ახალი გაცვლების შესაჩერებლად, წაშალეთ პოლიტიკა; დაუშვით ერთ საათამდე დრო უკვე გაცემული Tuist წვდომის ტოკენების ვადის გასვლისთვის. პოლიტიკის წაშლა არ აუქმებს მაშინვე ამ ტოკენებს.
პოლიტიკის შექმნა#
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-ებს სახელების ნაცვლად, რომლებიც შეიძლება გადაერქვათ ან ხელახლა დარეგისტრირდეს წაშლის შემდეგ.
გაზიარებულ იდენტობის პროვაიდერზე, მიამაგრეთ პოლიტიკა თქვენს ორგანიზაციას ან არენდატორს და სასურველ აპლიკაციას, პროექტს ან სერვისის ანგარიშს. ტოტის სახელი, როგორიცაა main, გარემო, როგორიცაა production, ან ზოგადი როლი მხოლოდ არ წარმოადგენს იდენტობის საზღვარს: სხვა არენდატორმა შეიძლება მიიღოს ტოკენი იგივე მნიშვნელობებით. მაგალითად, GitLab.com-ის პოლიტიკა უნდა შეიცავდეს სასურველი პროექტის სტაბილურ project_id-ს, არა მხოლოდ ref-ს. შესაბამისი ტოკენი ანიჭებს ანგარიშის მასშტაბით CI წვდომას, კეშში ჩაწერების ჩათვლით, ამიტომ პოლიტიკა, რომელიც ენდობა დაუკავშირებელ სამუშაო დატვირთვებს, შეიძლება დაუშვას კეშის მოწამვლა.
Tuist ანიჭებს წვდომას მხოლოდ იმ პოლიტიკებისთვის, რომელთა საკუთარი JWKS URL შეიცავს გასაღებს, რომელიც ხელს აწერს ტოკენს, გამომცემლის, აუდიტორიის, ვადის გასვლის, არა-ადრე დროის (60 წამამდე საათის გადახრით) და ყოველი პრეტენზიის შემოწმების შემდეგ. გაცემული ერთსაათიანი CI ტოკენი არის ანგარიშის მასშტაბით, არა პროექტების ID-ების სნეპშოტი: ის მოიცავს პროექტებს, რომლებიც შეიქმნა ან გადაეცა ანგარიშზე გაცემის შემდეგ. პროექტის ავტორიზაცია კვლავ მოითხოვს მიმდინარე ანგარიშის მფლობელობას, ამიტომ პროექტის გადაცემა აშორებს მის წვდომას ამ ანგარიშის ტოკენის ქვეშ.
სამუშაო დატვირთვის ავტენტიკაცია#
- მოითხოვეთ იდენტობის ტოკენი თქვენი პროვაიდერისგან პოლიტიკის აუდიტორიით.
- დააყენეთ
TUIST_OIDC_TOKENამ ტოკენზე დაTUIST_OIDC_ACCOUNTTuist ანგარიშის სახელზე, რომელიც ფლობს პროექტს. ანგარიში აუცილებელია ნდობის პოლიტიკის ყოველი გაცვლისთვის. ის მხოლოდ ირჩევს, სად უნდა მოხდოს ძიება და თავისთავად არაფერს ანიჭებს. - გაუშვით 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 ბაიტისა.
TUIST_OIDC_TOKEN არის ზოგადი ტოკენის შეყვანა, არა სერვერის ნდობის გვერდის ავლის გზა. ის უპირატესობას ანიჭებს CI პროვაიდერის აღმოჩენას და სერვერი კვლავ იღებს მხოლოდ ჩაშენებულ პროვაიდერებს და იდენტობებს შესაბამისი ნდობის პოლიტიკით. არ ჩასვათ იდენტობის ტოკენი TUIST_TOKEN-ში, რომელიც ელოდება Tuist რწმუნებულებას.
თუ გაცვლა ვერ ხერხდება, შეამოწმეთ, რომ გამომცემელი, აუდიტორია და პოლიტიკის ყოველი პრეტენზია ზუსტად ემთხვევა ტოკენს, რომ JWKS URL ემსახურება გასაღებს, რომელიც ხელს აწერს ტოკენს, რომ პოლიტიკა არ არის წაშლილი და რომ TUIST_OIDC_ACCOUNT ასახელებს ანგარიშს, რომელიც ფლობს პროექტს. იმის თავიდან ასაცილებლად, რომელი იდენტობებია სანდო, Tuist აბრუნებს იგივე შეცდომას ამ ყველა შემთხვევისთვის.
Fly.io Machines#
Fly.io მხარს უჭერს OIDC სამუშაო იდენტობას. Machine-ს შეუძლია მოითხოვოს მოკლე ვადით მოქმედი, ხელმოწერილი იდენტობის ტოკენი თავისი ადგილობრივი /.fly/api Unix სოკეტიდან, Fly API ტოკენის ან ხანგრძლივი Tuist საიდუმლოს გარეშე. Fly ტოკენები აიდენტიფიცირებენ ორგანიზაციას და აპლიკაციას, არა საწყის რეპოზიტორიას, ამიტომ გამოიყენეთ ნდობის პოლიტიკა GitHub რეპოზიტორიის დაკავშირების ნაცვლად:
-
მიიღეთ გამომცემელი (
iss), ორგანიზაციის ID (org_id) და აპლიკაციის ID (app_id) თქვენს Fly Machine-ში გაცემული იდენტობის ტოკენიდან. გამომცემელიაhttps://oidc.fly.io/<organization-slug>. გამოიყენეთ რიცხვითი ID-ები, არა ორგანიზაციის ან აპის სახელები. -
შექმენით ნდობის პოლიტიკა 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>"} -
Machine-ის შიგნით, დააყენეთ
TUIST_OIDC_ACCOUNTTuist ანგარიშის სახელზე, რომელიც ფლობს პროექტს (არა Fly ორგანიზაციის slug), მოითხოვეთ ტოკენი აუდიტორიითtuistდა გადაეცით ისtuist auth login-სTUIST_OIDC_TOKEN-ის გამოყენებით:
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 ცალკე ამოწმებს ხელმოწერას ავტენტიკაციის დროს:
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 ტოკენებს ენიჭებათ ci სკოპების ჯგუფი. GitHub Actions-ის, CircleCI-ის და Bitrise-ისთვის, ეს უზრუნველყოფს წვდომას რეპოზიტორიასთან დაკავშირებულ ყველა პროექტზე. დაკავშირებული Amp workspace-ების, დაკავშირებული Claude Code გარემოების და სამუშაო იდენტობის ნდობის პოლიტიკებისთვის, ეს უზრუნველყოფს წვდომას შერჩეული ანგარიშის ყველა მიმდინარე და მომავალ პროექტზე, პროექტის შექმნის, პროექტის ადმინისტრირების, runner-ის ადმინისტრირების ან ანგარიშის წევრების ადმინისტრირების გაცემის გარეშე. იხილეთ სკოპების ჯგუფები დეტალებისთვის, თუ რას მოიცავს ci სკოპი.
OIDC ავტენტიკაცია უფრო უსაფრთხოა, ვიდრე ხანგრძლივი ვადის ტოკენები, რადგან:
- არ არის საიდუმლოები, რომლებიც უნდა შეიცვალოს ან იმართოს
- ტოკენები მოკლე ვადითაა
- ავტენტიკაცია მიბმულია თქვენს რეპოზიტორიის იდენტობასთან ან ცალსახად ავტორიზებულ სამუშაო იდენტობასთან
Gradle პლაგინის ავტენტიკაცია#
Gradle პლაგინი იყენებს Tuist CLI-ის ავტენტიკაციის მდგომარეობას და არ განსაზღვრავს ცალკე შესვლის პროცესს. ერთხელ გაიარეთ ავტენტიკაცია CLI-ით და პლაგინი ხელახლა გამოიყენებს ამ მონაცემებს.
პროექტისა და სერვერის კონფიგურაციისთვის, მათ შორის project და url, გამოიყენეთ კანონიკური tuist.toml მითითება.
ლოკალური გამოყენებისთვის, გაუშვით:
tuist auth login
CI-ისთვის, გამოიყენეთ ერთ-ერთი:
- OIDC ავტენტიკაცია (რეკომენდებულია, როცა ხელმისაწვდომია)
- ანგარიშის ტოკენით ავტენტიკაცია
TUIST_TOKEN-ის საშუალებით
თვითმასპინძელი Tuist სერვერებისთვის, განსაზღვრეთ სერვერის URL tuist.toml-ში (მაგალითად url = "https://tuist.your-company.com") და გაუშვით სტანდარტული შესვლის პროცესი. URL იგივე კონფიგურაციის ფაილიდან იხსნება, რომელსაც პლაგინი იყენებს.
ავტენტიკაციის კონფიგურაციის შემდეგ, ჩვეულებრივად გაუშვით თქვენი Gradle ქეშირების ბრძანებები და დავალებები.
ანგარიშის ტოკენები#
CI გარემოებისთვის, რომლებიც არ უჭერენ მხარს OIDC-ს, ან როცა საჭიროა ნებართვებზე ზუსტი კონტროლი, შეგიძლიათ გამოიყენოთ ანგარიშის ტოკენები. ანგარიშის ტოკენები საშუალებას გაძლევთ ზუსტად მიუთითოთ, თუ რომელ სკოპებსა და პროექტებზე აქვს ტოკენს წვდომა.
ანგარიშის ტოკენის შექმნა#
ანგარიშის ტოკენის შექმნის ყველაზე მარტივი გზა დაშბორდიდანაა:
- გახსენით ორგანიზაცია Tuist დაშბორდზე.
- გადადით პარამეტრებში > ტოკენები.
- აირჩიეთ ტოკენის გენერირება.
- აირჩიეთ სახელი, ვადის გასვლის არასავალდებულო პარამეტრი, პროექტზე წვდომა და სკოპები, რომლებიც ტოკენს სჭირდება.
- დახურვამდე დააკოპირეთ გენერირებული ტოკენის მნიშვნელობა. ტოკენის მნიშვნელობები მხოლოდ ერთხელ ჩანს.
ანგარიშის ტოკენების შექმნა ასევე შეგიძლიათ CLI-დან, რაც სასარგებლოა სკრიპტინგისთვის ან ავტომატიზაციისთვის:
tuist account tokens create account-handle \
--scopes account:cache:write project:cache:read project:cache:write \
--name ci-cache-token \
--expires 1y
ჩაანაცვლეთ account-handle იმ ანგარიშის handle-ით, რომელიც ფლობს პროექტებს, რომლებზეც ტოკენს წვდომა გსურთ. ეს შეიძლება იყოს ორგანიზაციის ანგარიში და არა აუცილებლად თქვენი პირადი ანგარიში.
ბრძანება იღებს შემდეგ პარამეტრებს:
| პარამეტრი | აღწერა |
|---|---|
--scopes |
სავალდებულო. სკოპების სია, გამოყოფილი გამოტოვებით, რომლებიც ტოკენს მიენიჭება. |
--name |
სავალდებულო. ტოკენის უნიკალური იდენტიფიკატორი (1-32 სიმბოლო, მხოლოდ ალფანუმერული, დეფისები და ქვეტირეები). |
--expires |
არასავალდებულო. როდის უნდა ამოიწუროს ტოკენმა. გამოიყენეთ ფორმატი, როგორიცაა 30d (დღეები), 6m (თვეები) ან 1y (წლები). თუ არ არის მითითებული, ტოკენი არასდროს ამოიწურება. |
--projects |
შეზღუდეთ ტოკენი კონკრეტული პროექტების handle-ებით. თუ არ არის მითითებული, ტოკენს აქვს წვდომა ყველა პროექტზე. |
ხელმისაწვდომი სკოპები#
| სკოპი | აღწერა |
|---|---|
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 |
ბრძანებების გაშვებების შექმნა და განახლება |
სკოპების ჯგუფები#
სკოპების ჯგუფები მოხერხებულად გთავაზობთ რამდენიმე დაკავშირებული სკოპის მინიჭებას ერთი იდენტიფიკატორით. როდესაც იყენებთ სკოპების ჯგუფს, ის ავტომატურად ფართოვდება და მოიცავს ყველა ინდივიდუალურ სკოპს, რომელიც მასში შედის.
| სკოპების ჯგუფი | შემავალი სკოპები |
|---|---|
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 |
უწყვეტი ინტეგრაცია#
CI გარემოებისთვის, რომლებიც არ უჭერენ მხარს OIDC-ს, შექმენით ანგარიშის ტოკენი ci სკოპების ჯგუფით თქვენი CI სამუშაო ნაკადების ავთენტიკაციისთვის. დაფლატაზე ტოკენის გენერირებისას აირჩიეთ CI პრესეტი.
ასევე შეგიძლიათ შექმნათ იგივე ტოკენი CLI-დან:
tuist account tokens create account-handle --scopes ci --name ci
ეს ქმნის ტოკენს ყველა იმ სკოპით, რაც საჭიროა ტიპური CI ოპერაციებისთვის (ქეში, პრევიუები, ბანდლები, ტესტები, ბილდები და გაშვებები). შეინახეთ გენერირებული ტოკენი როგორც საიდუმლო თქვენს CI გარემოში და დააყენეთ ის როგორც TUIST_TOKEN გარემოს ცვლადი.
ანგარიშის ტოკენების მართვა#
გახსენით პარამეტრები > ტოკენები ანგარიშის დაფლატაზე, რათა ნახოთ ანგარიშის ტოკენები, შეამოწმოთ ტოკენის სკოპები და პროექტებზე წვდომა, ასევე გააუქმოთ ტოკენები როტაციის დროს.
ანგარიშის ყველა ტოკენის სიის სანახავად:
tuist account tokens list account-handle
ტოკენის სახელით გასაუქმებლად:
tuist account tokens revoke account-handle ci-cache-token
ანგარიშის ტოკენების გამოყენება#
ანგარიშის ტოკენები უნდა იყოს განსაზღვრული როგორც გარემოს ცვლადი TUIST_TOKEN:
export TUIST_TOKEN=your-account-token
გამოიყენეთ ანგარიშის ტოკენები, როდესაც გჭირდებათ:
- ავთენტიკაცია CI გარემოებში, რომლებიც არ უჭერენ მხარს OIDC-ს
- ზუსტი კონტროლი იმაზე, თუ რა ოპერაციების შესრულება შეუძლია ტოკენს
- ტოკენი, რომელსაც შეუძლია წვდომა ანგარიშში არსებულ რამდენიმე პროექტზე
- დროით შეზღუდული ტოკენები, რომლებიც ავტომატურად ამოიწურება