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

გამოშვებები

Tuist ახალ ვერსიებს ავტომატურად აქვეყნებს, როცა ცვლილებები main შტოს ერწყმის. CLI, სერვერი და Kura ქეშ-სერვერი გამოიცემა სამი არხით (canary, release candidate, stable), რათა რეკომენდებული ინსტალაცია დარჩეს სტაბილური და ნელი; release candidate-ის შექმნა და მისი stable-ში გადაყვანა განზრახული, ყოველკვირეული ნაბიჯებია. აპლიკაცია უწყვეტად გამოიცემა (iOS აპლიკაცია მხოლოდ TestFlight-ზე ნერგება უწყვეტად, მეტი იხილეთ აქ).

მიმოხილვა#

ჩვენ ვუშვებთ ამ ძირითად კომპონენტებს:

  • Tuist CLI — ბრძანების ხაზის ინსტრუმენტი, რომელიც ვრცელდება canary, release candidate და stable არხებით
  • Tuist Server — უკანა ბოლოს სერვისები, რომლებიც ვრცელდება CLI-ის იგივე არხების მოდელით
  • Kura — ქეშ-სერვერი, რომელიც ვრცელდება CLI-ის იგივე არხების მოდელით
  • Tuist App — macOS-ისა და iOS-ის აპლიკაციები, რომლებიც უწყვეტად გამოიცემა (iOS აპლიკაცია მხოლოდ TestFlight-ზე ნერგება უწყვეტად, მეტი იხილეთ აქ)

ყოველი პუში main-ზე აქვეყნებს canary წინასწარ გამოშვებას CLI-ისთვის, სერვერისთვის და Kura-სთვის. თითოეული ამ კომპონენტის სტაბილური გამოშვება იქმნება მხოლოდ მაშინ, როცა მემღებავი პრომოციას უკეთებს შემოწმებულ release candidate-ს, ხოლო ყოველკვირეული გრაფიკი ერთდროულად უშვებს სამივე „მატარებელს“ (იხ. გამოშვების არხები). აპლიკაცია სტაბილურად გამოიცემა main-ზე ყოველი პუშისას.

როგორ მუშაობს#

1. კომიტის კონვენციები#

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

ფორმატი: type(scope): description

კომიტის ტიპები და მათი გავლენა#

ტიპი აღწერა გავლენა ვერსიაზე მაგალითი
feat ახალი ფუნქცია ან შესაძლებლობა მინორული ვერსიის მატება (x.Y.z) feat(cli): add support for Swift 6
fix შეცდომის გამოსწორება პეტჩ-ვერსიის მატება (x.y.Z) fix(app): resolve crash when opening projects
docs დოკუმენტაციის ცვლილებები გამოშვება არ ხდება docs: update installation guide
style კოდის სტილის ცვლილებები გამოშვება არ ხდება style: format code with swiftformat
refactor კოდის რეფაქტორინგი გამოშვება არ ხდება refactor(server): simplify auth logic
perf წარმადობის გაუმჯობესება პეტჩ-ვერსიის მატება perf(cli): optimize dependency resolution
test ტესტების დამატება/ცვლილება გამოშვება არ ხდება test: add unit tests for cache
chore მოვლის ამოცანები გამოშვება არ ხდება chore: update dependencies
ci CI/CD ცვლილებები გამოშვება არ ხდება ci: add workflow for releases

CLI-ისთვის ეს მატებები განსაზღვრავენ canary ვერსიას და ცვლილებათა ჟურნალის დაჯგუფებას. სტაბილური CLI ვერსიები არის მინორული ხაზები (X.Y.0), რომლებიც ხელით იქმნება, ხოლო სტაბილური პეტჩები (X.Y.Z) მოდის მხოლოდ ბექპორტებიდან, ამიტომ feat ან fix აღწევს CLI მომხმარებლებს ქვემოთ მოცემული არხების ნაკადით და არა როგორც დაუყოვნებელი სტაბილური გამოშვება.

დამრღვევი ცვლილებები#

დამრღვევი ცვლილებები იწვევს მაჟორული ვერსიის მატებას (X.0.0) და უნდა მიეთითოს კომიტის ძირითად ნაწილში:

plaintext
feat(cli): change default cache location
BREAKING CHANGE: The cache is now stored in ~/.tuist/cache instead of .tuist-cache.
Users will need to clear their old cache directory.

2. ცვლილებების აღმოჩენა#

თითოეული კომპონენტი იყენებს git cliff-ს, რათა:

  • გაანალიზოს კომიტები ბოლო გამოშვების შემდეგ
  • გაფილტროს კომიტები სკოპის მიხედვით (cli, app, server)
  • დაადგინოს, არის თუ არა გამოსაქვეყნებელი ცვლილებები
  • ავტომატურად შექმნას ცვლილებათა ჟურნალები

3. გამოშვების პაიპლაინი#

როდესაც აღმოჩნდება გამოსაქვეყნებელი ცვლილებები:

  1. ვერსიის გამოთვლა: პაიპლაინი განსაზღვრავს მომდევნო ვერსიის ნომერს
  2. ცვლილებათა ჟურნალის გენერაცია: git cliff ქმნის ცვლილებათა ჟურნალს კომიტების შეტყობინებებიდან
  3. აწყობის პროცესი: კომპონენტი აიწყობა და ტესტირდება
  4. არტეფაქტების გენერაცია: მზადდება გამოშვებისთვის სპეციფიკური რესურსები, როგორიცაა CLI ბანდლები, საკონტროლო ჯამები და tuist.spec.json CLI სპეციფიკაცია, რომელიც გენერირდება tuist --experimental-dump-help-დან
  5. გამოშვების შექმნა: იქმნება GitHub გამოშვება არტეფაქტებით
  6. გავრცელება: განახლებები ეგზავნება პაკეტების მენეჯერებს (მაგ., Homebrew CLI-ისთვის)

აპისთვის ეს წარმოქმნის სტაბილურ გამოშვებას ყოველ შერწყმაზე. CLI-ის, სერვერისა და Kura-სთვის, ეს იგივე ავტომატური პაიპლაინი წარმოქმნის მხოლოდ canary პრერელიზს; რელიზ კანდიდატები და სტაბილური გამოშვებები იჭრება ყოველკვირეულ რელიზ ტრენზე (იხ. გამოშვების არხები).

4. სკოპის ფილტრაცია#

თითოეული კომპონენტი გამოიცემა მხოლოდ მაშინ, როდესაც მას აქვს შესაბამისი ცვლილებები:

  • CLI: კომიტები (cli) სკოპით ან სკოპის გარეშე
  • App: კომიტები (app) სკოპით
  • Server: კომიტები (server) სკოპით

გამოშვების არხები#

CLI, სერვერი და Kura არ გადაჰყავთ სტაბილურ გამოშვებაზე main-ში ყოველი push-ის დროს. თითოეული მათგანი გადის სამი არხის მეშვეობით, რათა რეკომენდებული ინსტალაცია დარჩეს სტაბილური და ნელა მოძრავი, ხოლო ადრეული მომხმარებლები ინარჩუნებენ კომიტზე დაფუძნებულ აწყობებს. მომხმარებლისთვის ხელმისაწვდომი დოკუმენტაცია განთავსებულია CLI გამოშვების არხებზე და სერვერის გამოშვების არხებზე; ეს სექცია არის მემaintainer-ის ინსტრუქცია.

თითოეული კომპონენტი იყენებს ერთსა და იმავე სამ არხს:

არხი ვერსია იჭრება
Canary X.Y.0-canary.N ავტომატურად, კომპონენტთან დაკავშირებული ყოველი push-ის დროს main-ში (<component>-release.yml; Kura-სთვის, გამოძახებულია server-production-deployment.yml-ით, როდესაც kura/ შეიცვალა)
რელიზ კანდიდატი X.Y.0-rc.N ყოველ ორშაბათს, ან ხელით, releases/<component>-<major>.<minor>.x ბრენჩზე (<component>-rc.yml)
სტაბილური X.Y.Z ყოველ ორშაბათს, ან ხელით, გაჟღენთილი RC-ის პრომოუშენით (<component>-promote.yml); პეტჩები <component>-backport.yml-ის მეშვეობით

Canary და RC აწყობები ქვეყნდება როგორც GitHub პრერელიზები (არასდროს მონიშნული როგორც "Latest", არასდროს გადაადგილებს :latest-ს GHCR-ზე, არასდროს ეგზავნება Homebrew-ში CLI-ისთვის), ამიტომ პაკეტების მენეჯერები და სურათების რეზოლვერები მათ იღებენ მხოლოდ ცალსახა opt-in-ის შემთხვევაში. Canary ყოველთვის ისახავს მიზნად შემდეგ გამოუქვეყნებელ მინორულ ვერსიას: ერთხელ RC ხაზის ჩამოჭრის შემდეგ, main-ის canary გადადის შემდეგ მინორულ ვერსიაზე.

Hosted Tuist არ ელოდება სტაბილურ ტრენს: სერვერი დეპლოიდება კომიტის მიხედვით, ხოლო hosted canary და პროდაქშენი მუშაობენ უახლეს Kura canary-ზე. დეპლოის კასკადი აქვეყნებს ამ canary-ს მის დეპლოიმდე, ამიტომ kura-release.yml-ს არ აქვს საკუთარი ტრიგერი. ცვლილებები მხოლოდ Kura-ს გამოშვების ინსტრუმენტებში (mise/tasks/kura/**, kura-*.yml workflow-ები) არ იწვევენ canary-ს ჩამოჭრას.

თქვენ არასდროს ირჩევთ ვერსიის ნომრებს ხელით. თითოეული არხის მომდევნო ვერსია გამოყვანილია არსებული git ტეგებიდან mise/tasks/<component>/release/channel-version.sh-ის მიერ, რომელსაც ქვემოთ მოცემული workflow-ები იძახებენ.

გამოშვების ბრენჩები დაყოფილია კომპონენტების მიხედვით (releases/server-X.Y.x, releases/kura-X.Y.x, releases/X.Y.x CLI-ისთვის), რათა სამი კომპონენტის ხაზები არასდროს შეეჯახონ ერთსა და იმავე მინორულ ვერსიაზე.

ყოველკვირეული განრიგი#

ყოველ ორშაბათს 06:00 UTC-ზე, სამი კომპონენტის პრომოუშენის ჯობები მუშაობენ სინქრონულად: CLI Promote to Stable, Server Promote to Stable და Kura Promote to Stable. თითოეული ახდენს უახლესი RC ხაზის პრომოუშენს, რომელიც ჯერ არ არის სტაბილური, რაც ჩვეულებრივ არის წინა ორშაბათს ჩამოჭრილი ხაზი. თუ ასეთი ხაზი არ არსებობს, ეს ჯობი არაფერს აქვეყნებს.

როდესაც პრომოუშენი სრულდება, შედეგის მიუხედავად, მისი შესაბამისი რელიზ კანდიდატი workflow (cli-rc.yml, server-rc.yml, kura-rc.yml) იწყება workflow_run-ის მეშვეობით და ჭრის შემდეგ ხაზს main-დან.

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

რელიზ კანდიდატის ჩამოჭრა#

ახალი ხაზის ჩამოჭრა ყოველკვირეული განრიგის გარეთ (ჩაანაცვლეთ ქვემოთ კომპონენტის workflow-ის სახელი):

  1. გაუშვით <Component> Release Candidate workflow (მაგალითად, server-rc.yml) ცარიელი branch შეყვანით.
  2. ის აქვეყნებს X.Y.0-rc.1 და, წარმატების შემდეგ, ქმნის დაცულ releases/<component>-X.Y.x ბრენჩს აგებულ კომიტზე.

კრიტიკული ფიქსის ან რეგრესიის soaking ხაზში შესატანად, ჩამოირთვით ის PR-ის მეშვეობით გამოშვების ბრენჩზე (იგივე ნაკადი, რაც backport-ებისთვის; CI არასდროს აკეთებს cherry-pick-ს), შემდეგ გაიმეორეთ RC:

  1. გადადით releases/<component>-X.Y.x-დან, გააკეთეთ ფიქსის cherry-pick, გახსენით PR უკან გამოშვების ბრენჩში, მოაგვარეთ ნებისმიერი კონფლიქტი და შეუერთეთ.
  2. კვლავ გაუშვით Release Candidate workflow branch=releases/<component>-X.Y.x-ით. ის აქვეყნებს X.Y.0-rc.(N+1) ბრენჩის HEAD-დან.

Soaking ხაზი არის ფუნქციებით გაყინული: მასზე მხოლოდ კრიტიკული ფიქსები და რეგრესიები ხვდება.

სტაბილურზე პრომოუშენი#

ხაზის პრომოუშენისთვის ყოველკვირეული განრიგის გარეთ, მისი RC-ის სუფთად soaking-ის შემდეგ:

  1. გაუშვით <Component> Promote to Stable workflow (მაგალითად, server-promote.yml) branch=releases/<component>-X.Y.x-ით.
  2. ის აქვეყნებს semver-ტეგირებულ იმიჯს make_latest=true-ით, გადააქვს GHCR :latest ტეგი და GitHub-ის „Latest“ მაჩვენებელი. CLI ასევე აახლებს Homebrew ფორმულას.

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

ფიქსების backport-ირება სტაბილურ ხაზზე#

როდესაც ხაზი სტაბილურია, პატჩების გამოსაქვეყნებლად გამოიყენეთ მხოლოდ CLI-სთვის განკუთვნილი Backport Release workflow (cli-backport.yml): ჩამოირთვით ფიქსი releases/X.Y.x-ზე PR-ის მეშვეობით, შემდეგ გაუშვით workflow ამ ბრენჩით X.Y.(Z+1)-ის ჩამოჭრისთვის. Backport-ები არასდროს გადააადგილებენ „Latest“ მაჩვენებელს ან Homebrew ფორმულას. ერთდროულად ორი ხაზი ნარჩუნდება: მიმდინარე ხაზი იღებს რეგრესიებს და უსაფრთხოების ფიქსებს, წინა ხაზი კი მხოლოდ კრიტიკულ და უსაფრთხოების ფიქსებს. სხვა ბაგ-ფიქსები არ backport-ირდება და შემდეგ მინორულ ვერსიაში გამოიცემა.

სერვერისა და Kura-სთვის გამოიყენეთ Server Backport Release (server-backport.yml) ან Kura Backport Release (kura-backport.yml). პრომოუშენი აქვეყნებს მხოლოდ RC-ის X.Y.0-ს; მას არ შეუძლია უკვე სტაბილური ხაზის პატჩირება.

  1. დაიწყეთ შერჩეული X.Y ხაზის უახლესი გამოქვეყნებული სტაბილური კომპონენტის ტეგიდან და გახსენით ქირურგიული ფიქსის PR მის არსებულ releases/server-X.Y.x ან releases/kura-X.Y.x ბრენჩში. უფრო ახალი მინორული ან მაჟორული გამოშვება არ ხელს უშლის შენარჩუნებული ხაზის პატჩირებას. არ შეურიოთ ძირითადი ბრენჩის არარელევანტური ცვლილებები.
  2. გადახედეთ და შეუერთეთ წყაროს PR. ჩამოიტანეთ დისტანციური გამოშვების ბრენჩი და დაადასტურეთ მისი საბოლოო შეერთებული tip, კომპონენტის მხარდაჭერილი პლატფორმებისა და TLS დადებითი/უარყოფითი კონტროლების ჩათვლით. წინასწარი შეერთების თავის წარმატება არ ნიშნავს სხვა squash ან merge კომიტის დადასტურებას.
  3. ცალკეული გამოქვეყნების ნებართვით, გაუშვით შესაბამისი backport workflow main-დან, source_sha-ის დაყენებით ზუსტად იმ დადასტურებულ შეერთებულ tip-ზე და base_tag-ის დაყენებით მიმდინარე სტაბილურ ტეგზე, როგორიცაა [email protected] ან [email protected]. workflow გამოიყვანს X.Y.(Z+1)-ს; ოპერატორები არ ირჩევენ მინორულ აწევას ან არ აკეთებენ canary შიგთავსის პრომოუშენს.

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

Backport-ები იყენებენ არსებულ მულტი-პლატფორმულ გამომქვეყნებლებს GitHub-ის „Latest“ მაჩვენებლის ან GHCR :latest-ის გადაადგილების გარეშე. გამოქვეყნება გამოყოფილია hosted განლაგებისგან: ეს workflows არ აკეთებენ hosted სერვერის ან Kura ფლოტის პრომოუშენს, არ ავლიან canary მიღებას ან არ ადასტურებენ ინსტალირებულ runtime-ს. აგების დამხმარეები და Dockerfile-ები კვლავ მოდიან შერჩეული სტაბილური წყაროდან. კონტროლები არის გამოქვეყნების კარიბჭეები, არა უკრედენტიანი აგების ჯობები; აგებებს შეუძლიათ ატვირთონ დაუტეგავი იმიჯის digest-ები საბოლოო კარიბჭემდე. იმიჯისა და GitHub-ზე გამოქვეყნება არ არის ატომური: თუ გვიანდელი კარიბჭე ვერ ხერხდება იმიჯის ტეგის გამოქვეყნების შემდეგ, შეამოწმეთ ნაწილობრივი გამოშვება და შეინარჩუნეთ მისი საწყისი წყარო და არტეფაქტები. არასდროს ჩაანაცვლოთ არსებული გამოშვება ან გამოიყენოთ სხვა ბაიტები მისი ტეგის ქვეშ.

კარგი კომიტის შეტყობინებების წერა#

ვინაიდან კომიტის შეტყობინებები პირდაპირ გავლენას ახდენენ გამოშვების შენიშვნებზე, მნიშვნელოვანია ნათელი, აღმწერი შეტყობინებების წერა:

გააკეთეთ:#

  • გამოიყენეთ აწმყო დრო: „add feature“ და არა „added feature“
  • იყავით მოკლე, მაგრამ აღმწერი
  • ჩართეთ სკოპი, როდესაც ცვლილებები კომპონენტის სპეციფიკურია
  • მიუთითეთ issues, როდესაც შესაბამისია: fix(cli): resolve build cache issue (#1234)

არ გააკეთოთ:#

  • არ გამოიყენოთ ბუნდოვანი შეტყობინებები, როგორიცაა „fix bug“ ან „update code“
  • არ შეურიოთ მრავალი არარელევანტური ცვლილება ერთ კომიტში
  • არ დაგავიწყდეთ breaking change ინფორმაციის ჩართვა

Breaking changes#

Breaking changes-ისთვის, ჩართეთ BREAKING CHANGE: კომიტის სხეულში:

plaintext
feat(cli): change cache directory structure
BREAKING CHANGE: Cache files are now stored in a new directory structure.
Users need to clear their cache after updating.

გამოშვების workflows#

CLI-ს, სერვერსა და Kura-ს თითოეულს აქვს არხების workflow-ების საკუთარი ნაკრები, იგივე სტრუქტურის მიხედვით:

  • <component>-release.yml - აქვეყნებს canary-ს main-ზე ყოველი კომპონენტის შემხები push-ისას (Kura-ს არის ხელახლა გამოყენებადი workflow, რომელსაც server-production-deployment.yml იძახებს, როდესაც kura/ იცვლება)
  • <component>-rc.yml - ჭრის რელიზ კანდიდატს ყოველ ორშაბათს (workflow_run-ის მეშვეობით პრომოუშენის შემდეგ), ან ხელით ჭრის ან აუმჯობესებს ერთს
  • <component>-promote.yml - აკეთებს მოლოდინში მყოფი RC-ის პრომოუშენს სტაბილურზე ყოველ ორშაბათს 06:00 UTC-ზე, ან ხელით აკეთებს soaked RC-ის პრომოუშენს
  • <component>-build-publish.yml - საერთო აგებისა და გამოქვეყნების პაიპლაინი, რომელსაც ზემოთ ჩამოთვლილი სამი იძახებს

CLI-ს, სერვერსა და Kura-ს ასევე აქვთ <component>-backport.yml სტაბილურ ხაზზე პატჩების ჩამოჭრისთვის. კომპონენტის ყველა workflow სერიალიზდება ერთი <component>-publish concurrency ჯგუფის მეშვეობით, რათა ვერსიის ამოხსნა და ტეგირება არასდროს შეჯახდეს. Kura არის გამონაკლისი: მისი canary იყენებს kura-canary-publish-ს, ხოლო მისი RC, პრომოუშენი და backport იყენებენ kura-stable-publish-ს, რათა ხანგრძლივმა სტაბილურმა აგებამ არ შეაფერხოს განლაგების კასკადი. ტეგის სივრცეები განცალკევებულია, ამიტომ ორი ჯგუფი არ შეეჯახება.

Helm-ის ჩარტი და ინფრასტრუქტურული სურათები (CAPI operator, runners controller, xcresult processor image, linux runner image და ა.შ.) კვლავ გამოიცემა .github/workflows/server-production-deployment.yml-ის მეშვეობით. ის ეშვება main-ზე push-ებისას და ახორციელებს canary → მიღების ტესტები → პროდაქშენი კასკადს ჰოსტინგზე განლაგებისთვის, ასევე აქვეყნებს ამ ინფრასტრუქტურულ კომპონენტებს მათი ცვლილებისას. აპლიკაციას, ქეშს, Gradle პლაგინს, skills-ს, Noora-სა და დამოუკიდებელ ინფრასტრუქტურულ კონტროლერებს თითოეულს აქვს საკუთარი *-release.yml workflow. ყველა მათგანი იზიარებს ცვლილებების აღმოჩენას: mise/tasks/release/components.json აცხადებს თითოეული კომპონენტის ტეგის პრეფიქსსა და include ბილიკებს, ხოლო git cliff შესაბამის კომიტებს რელიზის შენიშვნებად გარდაქმნის.

CLI-ის აგება (cli-build-publish.yml) ასევე ქმნის და აქვეყნებს tuist.spec.json არტეფაქტს (tuist --experimental-dump-help-დან გენერირებულს), რათა downstream ინსტრუმენტებმა შეძლონ ბრძანების ინტერფეისის მოხმარება.

რელიზების მონიტორინგი#

რელიზების მონიტორინგი შეგიძლიათ შემდეგი გზებით:

  • GitHub Releases გვერდი
  • GitHub Actions ტაბი workflow გაშვებებისთვის
  • Changelog ფაილები თითოეული კომპონენტის დირექტორიაში

სარგებელი#

უწყვეტი გამოშვების ეს მიდგომა უზრუნველყოფს:

  • სწრაფი მიწოდება: ცვლილებები მომხმარებლებს შერწყმისთანავე აღწევს
  • შეფერხებების შემცირება: არ არის საჭირო ხელით გამოშვების ლოდინი
  • ნათელი კომუნიკაცია: ავტომატური changelog-ები კომიტის შეტყობინებებიდან
  • თანმიმდევრული პროცესი: იგივე გამოშვების ნაკადი ყველა კომპონენტისთვის
  • ხარისხის უზრუნველყოფა: გამოიცემა მხოლოდ ტესტირებული ცვლილებები

პრობლემების გადაჭრა#

თუ გამოშვება ვერ მოხერხდა:

  1. შეამოწმეთ GitHub Actions ლოგები წარუმატებელი workflow-სთვის
  2. დარწმუნდით, რომ თქვენი კომიტის შეტყობინებები მიჰყვებიან კონვენციურ ფორმატს
  3. დაადასტურეთ, რომ ყველა ტესტი გადის
  4. შეამოწმეთ, რომ კომპონენტი წარმატებით აგდება

სასწრაფო გამოსწორებებისთვის, რომლებსაც საჭიროებს დაუყოვნებელი გამოშვება:

  1. დარწმუნდით, რომ თქვენს კომიტს აქვს ნათელი სკოუპი
  2. შერწყმის შემდეგ, აკონტროლეთ გამოშვების workflow
  3. სერვერის ან აპლიკაციისთვის, გამოსწორება შემდეგ push-ზე გამოიცემა; საჭიროების შემთხვევაში, გაააქტიურეთ ხელით გამოშვება
  4. CLI-ისთვის, გამოსწორება ავტომატურად ხვდება canary-ზე. სტაბილურ მომხმარებლებთან მისატანად, გააკეთეთ მისი backport შენარჩუნებულ სტაბილურ ხაზ(ებ)ზე (იხილეთ გამოსწორებების backport-ი სტაბილურ ხაზზე)

App Store-ის გამოშვება#

მიუხედავად იმისა, რომ CLI და სერვერი მიჰყვებიან ზემოთ აღწერილ უწყვეტ გამოშვების პროცესს, iOS აპლიკაცია არის გამონაკლისი Apple-ის App Store-ის გადახედვის პროცესის გამო:

  • ხელით გამოშვებები: iOS აპლიკაციის გამოშვებები მოითხოვს ხელით წარდგენას App Store-ში
  • გადახედვის დაყოვნებები: თითოეული გამოშვება უნდა გაიაროს Apple-ის გადახედვის პროცესი, რასაც 1-7 დღე შეიძლება დასჭირდეს
  • ჯგუფური ცვლილებები: მრავალი ცვლილება ჩვეულებრივ ერთად იკვრება თითოეულ iOS გამოშვებაში
  • TestFlight: ბეტა ვერსიები შეიძლება გავრცელდეს TestFlight-ის მეშვეობით App Store-ში გამოშვებამდე
  • გამოშვების შენიშვნები: უნდა დაიწეროს სპეციფიკურად App Store-ის სახელმძღვანელო მითითებებისთვის

iOS აპლიკაცია კვლავ მიჰყვება იგივე კომიტის კონვენციებს და იყენებს git cliff-ს changelog-ის გენერაციისთვის, მაგრამ მომხმარებლებთან რეალური გამოშვება ხდება ნაკლებად ხშირი, ხელით გრაფიკით.