แกแฌแ แแคแแ แแฆแแแแฉแแแ แแแแแแแแ แกแแแแฃแแแแแแแแ
แ แแแแ แช แฉแแแก, แแชแแ แ แจแแชแแแแแ แกแแ แแแคแแแแขแแแแก แจแแแแฎแแแแแ แแแแแชแแแ แกแแแ แแ แกแแชแแแจแ. แแฃแแชแ, แจแแแแแแแ แจแแแซแแแแ แกแแ แแแแฃแแ แแงแแก. แแแก แจแแแแแ แ แแช แแแแแแแกแฎแแแแ แแแแฆแแแก แแฅแแแแก แแแ แแแก แแ API แแแกแแฆแแแก, แแก แแแฆแแแก แแฅแแแแก แแแแแ แแจแก, แแแแแแแแแก แแฅแแแ แแ แแแแแแงแแแแแก แแฅแแแแก แคแฃแแก แแแฆแแแแฃแ แแ. แแแ แแ แแแแกแ, แจแแกแแซแแแแแแแ แแแแแแแก แแคแแฅแขแ: แแ แ แแแแแ แแจแแ แฌแแแแแ แฎแกแแแก แกแฎแแแแแ แฌแแแแแแก. แคแกแแแแแ แแแฆแแแแ, แแแแขแแ แซแแแแ แแแแจแแแแแแแแแแ แแแแแแแแ แกแแแแฃแแแแแแแก แจแแกแแฎแแ แ แแช แจแแแซแแแแ แแแแ แแแแแแ.
แแ แแแแแจแแแแแจแ แฉแแแ แฌแแ แแแแแแแแแ แแแ แแแแขแก แ แแแแ แช แฉแแแแ SAST แคแฃแแฅแชแแแแแ แแแแก แแแฌแแแ. แแแแแแฃแแ แฉแแแแแ แแแกแแแแแ แแแฃแแแ CI/CD แกแแแฃแจแแแจแ แกแแแแฃแแแแแแแกแแแแก. แแ แกแแแแแก แกแแแแฃแแแ - แแ แแแแแแแแแ แ แแฆแแแก แแแคแ แแฎแแแแแแก แจแแ แฌแงแแแก แแแแฎแแแแแจแ. แแก แแแแฃแฅแแแแก แแแแแแฃแ แ แฌแแฃแแแแแแ แกแแแแแแแก แแแแแแแ แแ แฅแแแแก แแฎแแแก.
แชแแแแแแแแแแก แกแแแแแแแ แแแ แแแแก แฃแแ แฃแแแแแงแแคแ
แ แแช แฃแคแ แ แแแ แแแแ แแ แฃแคแ แ แ แแฃแแ แฎแแแแ, แฃแคแ แ แ แแฃแแ แฎแแแแ แแ แแแแแแแชแแแก แกแฎแแแแแกแฎแแ แแแฌแแแแแก แจแแ แแก แแแแแแแแแแ แฃแแแแแก แจแแแแ แฉแฃแแแแ. แ แแช แฃแคแ แ แแแขแ แแแแฎแแแ แแแแแแ แแแแแแแชแแแกแ แแ แ แแช แฃแคแ แ แแแฆแแแแ แจแแแแกแแแแแ, แแแ แฃแคแ แ แกแแ แแแแฃแแ แแฅแแแแ แแ แแกแฌแแ แ แแ แกแแฎแแคแแแ แแแแแก แจแแ แฌแงแแแก แจแแแแแแแ. แแ แแแแแ แแ แแแแแแแชแแแกแแแแก, แแแแแก แจแแ แฌแงแแแแแ แกแแแแแแแ แแแแฎแแแแแก แแ แแชแแกแแก แฃแแ แฃแแแแแงแแคแ แแแแชแ แ แแแแฎแแแแแ, แ แแแแแ แ แแกแแแแ แซแแแแแ แแแฆแแแแ.
GitLab 11.9 แแแซแแแแ แแแข แแแแขแ แแแก แแ แฃแคแ แ แแคแแฅแขแฃแ แกแขแ แฃแฅแขแฃแ แแก, แฌแงแแแแแแ . แแแ แ, แแแแแ แแแแก แแแกแแฆแแแแ, แแฎแแแแ แแแแแแแแแก แแ แฏแแฃแคแแก แแแแแขแแคแแชแแ แแแ แแงแ แกแแญแแ แ (แ แแแแแก แแแแแแฃแ แฌแแแ แก แจแแแซแแ แแแแแ แแแแก แแแชแแแ). แแฎแแ แจแแแแซแแแแ แแแแแแขแแ แแ แแแแแ แฌแแกแ แแกแ, แ แแ แจแแ แฌแงแแแก แแแแฎแแแแ แแแแแฎแแแก แแแแแ แแแแก แแแแแ แแขแฃแแ แแแ แแแแกแแแ แแ แแฃแแแแช แแแแแ แแขแฃแแ แฏแแฃแคแแก แ แแแแแแแแ แฌแแแ แแกแแแ. แแแ แแ แแแแกแ, Code Owners แคแฃแแฅแชแแ แแแขแแแ แแ แแแฃแแแ แกแแแแแแ แแแ แฌแแกแแแจแ, แ แแช แแแแแแแแแก แแแแแ แแแแก แแแแชแแแ แแแ แแก แแแแแขแแคแแชแแ แแแแก.
แแก แกแแจแฃแแแแแแก แแซแแแแก แแ แแแแแแแชแแแแก แแแแแฎแแ แชแแแแแ แแแแแฌแงแแแขแแก แแแแแแแฅแกแฃแ แ แแ แแชแแกแแแ แแ แจแแแแแ แฉแฃแแแ แแ แแ GitLab แแแแแแแชแแแก แกแแแแ แขแแแ, แกแแแแช แกแแแแแฎแแแ, แแแแ, แแแแกแแแแแแแ แแ แแแแแขแแ แแแแแก แแแแแชแแแแแ แฎแแแฃแแ แแ แฎแแแแแกแแฌแแแแแแ แแแแแฌแงแแแขแแแแแแก แแแกแแฆแแแแ แแ แแแแแฌแงแแแขแแก แแ แแชแแกแแก แแแกแแฉแฅแแ แแแแแ.
ChatOps แแฎแแ แฆแแ แฌแงแแ แแ
GitLab ChatOps แแ แแก แแซแแแแ แ แแแขแแแแขแแแแชแแแก แแแกแขแ แฃแแแแขแ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแฃแจแแแ แแแแแกแแแแ แ CI/CD แกแแแฃแจแแ แแ แแแแซแแแ แแแกแ แกแขแแขแฃแกแ แแแ แแแแแ แฉแแขแแก แแแแแจแ, แ แแแแ แแชแแ Slack แแ Mattermost. , ChatOps แแงแ GitLab Ultimate แแแแแฌแแ แแก แแแฌแแแ. แแแคแฃแซแแแแฃแแ ะธ , แฉแแแ แฎแแแแแฎแแ แคแฃแแฅแชแแแแก แฅแแแแแ แแแแแแแขแแแ แแ แแ แแกแแ แแก แแแแแ.
ChatOps-แแก แจแแแแฎแแแแแจแ, แฉแแแ แแแแฎแแแแ, แ แแ แแก แคแฃแแฅแชแแแแแแแแ แจแแแซแแแแ แแงแแก แงแแแแแกแแแแก แกแแกแแ แแแแแ แแ แ แแ แกแแแแแแแแแแแก แแแแแฌแแแแแแ แจแแฃแซแแแ แแแแแ แคแฃแแฅแชแแแก แกแแ แแแแแแก.
GitLab 11.9-แจแ แฉแแแ , แแ แแแ แแแแ, แแก แแฎแแ แแแแแกแฃแคแแแ แแ แแก แฎแแแแแกแแฌแแแแแ แแแแแกแแงแแแแแแแ แแแแแแแ แแฃแ GitLab Core-แจแ แแ GitLab.com-แแ แแ แฆแแแ แกแแแแแแแแแแแกแแแแก.
แแ แแแแ แแ แฃแคแ แ!
แแ แแแแแจแแแแแจแ แฃแแแ แแแ แจแแกแแแแจแแแแ แคแฃแแฅแชแแแ แฎแแแแแกแแฌแแแแแ, แแแ. , ะธ , - แ แแ แฉแแแ แแแฃแแแแแแแ แแแแฃแแแแแแ แแแ แจแแกแแฎแแ!
แงแแแแแแ แฆแแ แแแฃแแ แแแแแแจแ แแแแแ () แแก แแแ แแฆแแแ แแแฃแแแ แแแ แกแแ แแแแ แแฃแแขแแก แแแแ ()
แแแ แกแแแ แแฃแแแแแแ แแแแฎแแแ แแแแแ GitLab แแแแฃแแแแขแแชแแแก แแแฃแแฏแแแแกแแแแจแ. แแก แฉแแแแ แแแแฃแแแแขแแแแก แฎแแ แแกแฎแแกแ แแ แแแแแงแแแแแแแแแแก แแแกแแฃแแฏแแแแกแแแแแ. Domo arigato [แแแแ แแแแแแแ (แแแแแแฃแ แ) - แแแแฎแ. แแแ แกแแ, แฉแแแ แแฃแแฌแ แคแแแแ แแแคแแกแแแ แแแก!
แซแแ แแแแแ แคแฃแแฅแชแแแแ แแแแแขแแแฃแแแ GitLab 11.9 แแแแแจแแแแแจแ
แกแแแแฃแแแแแแแกแ แแ แ แฌแแฃแแแแแแ แกแแแแแแแแก แแฆแแแฉแแแ แกแแชแแแจแ
(ULTIMATE, GOLD)
แแแแแแแแแ แแแ แแแแฏแแ แฃแแแแแแแ แแแ แชแแแแแแ แกแแแแฃแแแแแแแก แแ แ แฌแแฃแแแแแแ แกแแแแแแแก แแแกแขแแแชแแฃแ แกแแชแแแแแจแ. แแฃ แกแฎแแ แแแแแแแแแแก แแฅแแ แฌแแแแแ แแ แฌแงแแ แแแ, แแ แแฃ แแ แแแฅแขแ แกแแฏแแ แแ, แแแจแแ แกแแแกแแขแแฃแ แ แแแคแแ แแแชแแ แแแแแฅแแแงแแแแแ แแ แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแแแแแแกแฎแแแแแแแก แแแแ แ แแกแฃแ แกแแแแ แฌแแแแแแกแแแแแก, แ แแแแ แแชแแ แแแแแแแแแแก แแแ แแแ.
GitLab 11.9-แก แแฅแแก แแฎแแแ แขแแกแขแ - "แกแแแแฃแแแ แแแแแแแแแ". แแก แแกแแแแแ แแแก แกแแชแแแแก แจแแแแแแกแก, แแซแแแก API แแแกแแฆแแแแแก แแ แกแฎแแ แแแคแแ แแแชแแแก, แ แแแแแแช แแ แฃแแแ แแงแแก แแฅ. GitLab แแฉแแแแแแก แจแแแแแแแก SAST แแแแแ แแจแจแ Merge Request แแแฏแแขแจแ, แแแแกแแแแแแก แแแแแ แแจแแแกแ แแ แฃแกแแคแ แแฎแแแแแก แแแคแแแจแ.
แแฃ แฃแแแ แฉแแ แแแ SAST แแฅแแแแ แแแแแแแชแแแกแแแแก, แแแจแแ แแ แแคแ แแก แแแแแแแแ แแ แแญแแ แแแแแ, แฃแแ แแแแ แแกแแ แแแแแแ แแ แแฎแแแ แคแฃแแฅแชแแแ. แแก แแกแแแ แจแแแแก แแแแคแแแฃแ แแชแแแจแ แแแแฃแแแกแฎแแแแ.
แแแแ แแแแแแแแก แแแแฎแแแแแแแก แแแแแญแ แแก แฌแแกแแแ
(PREMIUM, ULTIMATE, SILVER, GOLD)
แแแแแแแก แแแแฎแแแแ แงแแแแ แฌแแ แแแขแแแฃแแ แแ แแแฅแขแแก แแฃแชแแแแแแแ แแแแแแแขแแ, แแแแ แแ แงแแแแแแแแก แแ แแ แแก แแแแแแ, แแแ แฃแแแ แแแแแฎแแแแก แชแแแแแแแแแ. แฎแจแแ แแ แกแแกแฃแ แแแแแ แแงแแแแแ แแแแแแฎแแแแแแแแ แกแฎแแแแแกแฎแแ แแฃแแแแแแ: แแแแแแแแ แแแแก แแฃแแแ, แแแแฎแแแ แแแแแก แแแแแชแแแแแแแก แแฃแแแ, แฌแแ แแแแแแก แแฃแแแ.
แแแแแ แแแแก แฌแแกแแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแแฃแแฏแแแแกแแ แแแแแก แแแแฎแแแแแจแ แฉแแ แแฃแ แแแแแแแแแแก แจแแ แแก แฃแ แแแแ แแฅแแแแแแแก แแ แแชแแกแ แแแขแแ แแแแแฃแแ แแแแแขแแแชแแแแแแแก แฌแ แแก แแ แแแแแ แแแแแแก แแแแแแแแฃแ แ แ แแแแแแแแแก แแแแกแแแฆแแ แแ. แ แแแแแฃแชแแแก แฌแแกแแแ แแแฉแแแแแแแ แจแแ แฌแงแแแก แแแแฎแแแแแก แแแฏแแขแจแ, แแกแ แ แแ แแฅแแแ แจแแแแซแแแแ แกแฌแ แแคแแ แแแแแจแแแ แจแแแแแแ แแแแแแฎแแแแแแ.
GitLab 11.8-แจแ แแแแแ แแแแก แฌแแกแแแ แแแแฃแแแกแฎแแแแแ แแแแแ แแฃแแ แแงแ. GitLab 11.9-แแแ แแแฌแงแแแฃแแ, แแกแแแ แฎแแแแแกแแฌแแแแแแ แแแแฃแแแกแฎแแแแแ. GitLab 11.3-แจแ แฉแแแ แจแแแแแแฆแแ แแก แแแ แแแแขแ แแ แแแฅแขแแก แคแแ แแแแแจแ แแแแแแแแฃแแแฃแ แแแแแแแ แแแกแฃแฎแแกแแแแแแแ แแฃแแแแก แฌแแแ แแแแก แแแแแขแแคแแชแแ แแแ. Code Owners แคแฃแแฅแชแแ แแแขแแแ แแ แแแฃแแแ แแแแแ แแแแก แฌแแกแแแจแ, แแกแ แ แแ แแฅแแแ แงแแแแแแแแก แจแแแแซแแแแ แกแฌแ แแคแแ แแแแแแ แจแแกแแคแแ แแกแ แแแแแแแแแแ แชแแแแแแแแแแก แแแแแกแแฎแแแแ.
ChatOps-แแก แแแแแขแแแ Core-แแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
แแแแแแแแ แแแแแ แฌแแ แแแแแแแแแ GitLab Ultimate 10.6-แจแ, ChatOps แแแแแแแแ GitLab Core-แจแ. GitLab ChatOps แแแแแแแแแ GitLab CI แกแแแฃแจแแแแแแก แแแจแแแแแก แจแแกแแซแแแแแแแแก Slack-แแก แกแแจแฃแแแแแแ แคแฃแแฅแชแแแก แแแแแงแแแแแแ .
แฉแแแ แแแฆแแแ แฆแแ แฌแงแแ แแก แแ แแแฎแแกแแแแแแแแก แจแแกแแแแแแกแแ . แแแกแ แฃแคแ แ แฎแจแแ แแ แแแแแงแแแแแแ, แกแแแแแแแแแแ แแแข แฌแแแแแก แจแแแขแแแก.
แคแฃแแฅแชแแแก แแแ แแแแขแ แแแแก แแฃแแแขแ
(PREMIUM, ULTIMATE, SILVER, GOLD)
แแแแ แแชแแแแ, แ แแแแ แแชแแ แคแฃแแฅแชแแแแแก แแแ แแแแขแ แแแแก แแแแแขแแแ, แฌแแจแแ แแ แจแแชแแแ, แแฎแแ แฃแแแ แแแ แแแแกแขแ แแ แแแฃแแแ GitLab แแฃแแแขแแก แแฃแ แแแแจแ, แแกแ แ แแ แแฅแแแ แจแแแแซแแแแ แแแฎแแ แ แ แจแแแชแแแแ แแ แ แแแแก. แแแฎแแ แแแแ แแ แแ แฃแแแ แแแฎแแ แ แ แจแแแชแแแแ แแ แแแแ แแ แแก? แแ แฃแแ แแแแ แฃแแแ แจแแแแแฌแแแ แ แแแแ แจแแแชแแแแ แคแฃแแฅแชแแแก แแแ แแแแขแ แแแ แแฃแแแขแแก แคแแ แแแแแจแ? แแฎแแ แแแแก แแแแแแแแ แซแแแแแ แแแแแแแ.
แจแแ แฌแงแแแก แแแแฎแแแแแก แแแฃแชแแแแแแแก แแแแแ แแแ
(ULTIMATE, GOLD)
แแแแแก แแแฃแชแแแแแแแก แกแฌแ แแคแแ แแแกแแแแแ แแแแแ, แแ แแชแแกแ แแแ แขแแแ แฃแแแ แแงแแก. แแแแจแแแแแแแแแแ แฃแกแแคแ แแฎแแแแแก แแแขแฉแแแแก แแแแแ แขแแแแแ, แ แแช แกแแจแฃแแแแแแก แแแกแชแแแก แแแแแแแแแ แแแก แงแฃแ แแแฆแแแ แแแแแแฎแแแแแ แแแแแแแ แแแกแฃแฎแแกแแแแแแแแแแแ. GitLab 11.7-แจแ แฉแแแ , แแแแ แแ แฃแแแ แแแแแแฌแแ แแแแงแ, แแแแแแฃแ แแ แแแแแงแแแแแฃแแ แแ แจแแแแแ แแแกแขแแแชแแฃแ แกแแชแแแจแ แแแแแขแแแ.
GitLab 11.9-แจแ แแก แแ แแชแแกแ แแแขแแแแขแแแแ แแแฃแแแ. แจแแแกแฌแแ แแ แแแฃแชแแแแแแ GitLab แแแ แแแขแแ แคแแแกแแแแ แแแฃแกแแแแแแ. แจแแ แฌแงแแแก แแแแฎแแแแ แแฅแแแแแ แฃแจแฃแแแแ แแแฃแชแแแแแแแก แแแคแแ แแแชแแแก แคแแแฏแ แแแแ แแ แแก แแฎแแแ แคแแแแแแ แฃแแแ แจแแแชแแแก แแแแแกแฌแแ แแแแก. แแ แแแแแแแก แแแแแญแ แแก แจแแแแฌแแแแแก แจแแแแแ, แแแแแแขแแ แจแแกแฌแแ แแแ แแแแ แแแแแแแก แคแแแแแแจแ, แแฃ แแแแกแแแแแ แฌแแกแ แแแจแแ.
แแแแขแแแแแ แแก แกแแแแแ แแแแก แจแแแแแแแแก แฉแแแแแแ แฏแแฃแคแแก แฃแกแแคแ แแฎแแแแแก แแแแแแจแ
(ULTIMATE, GOLD)
แแฃแแแแก แฃแกแแคแ แแฎแแแแแก แแแคแ แกแแจแฃแแแแแแก แแซแแแแก แแฃแแแแแก แคแแแฃแกแแ แแแ แแแแฎแแแแแ แแแแแแแแ แแฃแจแแแแแกแแแแก แงแแแแแแ แแแแจแแแแแแแแ แกแแแแแฎแแแแ, แ แแช แฃแแ แฃแแแแแงแแคแก แงแแแแ แแแขแแแชแแฃแ แ แแแฃแชแแแแแแแก แแแแคแแ, แแแขแแแฃแ แแแแแฎแแแแแก, แ แแแแช แจแแแซแแแแ แแแแแแแ แแแแฎแแแแแก แแแแแแแชแแแแแ. แแแแขแแ แแแแจแแแแแแแแแแ, แ แแ แแแคแ แจแแแชแแแแแก แงแแแแ แกแแญแแ แ แแแคแแ แแแชแแแก แแ แ แแแแแแแก แแ แกแแจแฃแแแแแแก แแซแแแแก แแแแฎแแแ แแแแแแก แจแแแแ แแแแ แแแแแชแแแแแ แแแฃแชแแแแแแแก แแฆแแแคแฎแแ แแแแ.
GitLab 11.9-แจแ แแแแขแแแแแ แแก แกแแแแแ แแแแก แจแแแแแแแ แแแแแแขแ แกแแแแคแแ แแแชแแ แแแคแแก, แแแ แแ แแ แกแแแฃแแ SAST แแ แแแแแแแแแแฃแแแแแก แกแแแแแ แแแแก แจแแแแแแแแกแ. แแฎแแ แแแแแ แแแแแฎแแแแ แแ แ แแแแแแแแ, แแ แแแแแแแก แฌแงแแ แแก แแแฃแฎแแแแแแ.
CI/CD แจแแแแแแแแ แฃแกแแคแ แแฎแแแแแก แกแแแฃแจแแแแแแกแแแแก
(ULTIMATE, GOLD)
GitLab-แแก แฃแกแแคแ แแฎแแแแแก แแแฎแแกแแแแแแแแแ แซแแแแแ แกแฌแ แแคแแ แแแแแ แแแแ แแ แกแแญแแ แแแแก แแฃแแแแ แแแแแฎแแแแแแก แแฅแแแแ แแแแแก แแคแแฅแขแฃแ แ แแ แฃแกแแคแ แแฎแ แจแแกแแแแ แฉแฃแแแแแแ. แกแแแฃแจแแแก แแแคแแแแชแแแก แจแแชแแแ แ แแฃแแแ, แ แแแแกแแช แแฅแแแ แแแ แแแแ แแ แแแแ แแ แแแฅแขแก. แฉแแแ แแกแแแ แแแแกแแแก, แ แแ แแ แแแแก แแ แกแฃแ แก GitLab-แแก แฃแแฎแแแกแ แแแ แกแแแก แแแแแงแแแแแแก แ แแกแแแก แแแฆแแแ แแกแ, แ แแ แแ แแงแแก แแแ แฌแแฃแแแแฃแแ, แ แแ แแแ แกแ แฃแแแ แแแแกแแแแแแ GitLab-แแก แแแแแแแแแแ แแแแแแแแแแ.
แกแฌแแ แแ แแ แแแแแแแ, แฉแแแ แจแแแแแแฆแแ GitLab 11.7-แจแ แกแแแฃแจแแแแแแก แแแแกแแแฆแแ แแก แแฎแแแ แแแฅแแแแแแ. .
GitLab 11.9-แแแ แแแฌแงแแแฃแแ, แฉแแแ แจแแแแแแแแแแแแ แฉแแจแแแแแฃแ แจแแแแแแแแก แฃแกแแคแ แแฎแแแแแก แงแแแแ แกแแแฃแจแแแกแแแแก: แแแแแแแแแ, sast ะธ dependency_scanning, - แแแแกแแแแแแ GitLab-แแก แจแแกแแแแแแก แแแ แกแแแกแแแ.
แฉแแ แแแ แแกแแแ แแแ แแแแแ แแฅแแแแก แแแแคแแแฃแ แแชแแแจแ แแ แแกแแแ แแแแแฎแแแแแ แกแแกแขแแแแกแแแ, แ แแแแกแแช แแแแแแฎแแแแ GitLab-แแก แแฎแแ แแแ แกแแแก. แแแแกแแแแแแก แแแแคแแแฃแ แแชแแแแ แแ แแชแแแแแ.
แฃแกแแคแ แแฎแแแแแก แกแแแฃแจแแแแแแก แแแแกแแแฆแแ แแก แแฎแแแ แแแ แแคแแชแแแแฃแ แแ แแ แแ แฃแญแแ แก แแฎแแ แก แกแฎแแ แฌแแแ แกแแแฃแจแแแก แแแแแแ แขแแแแแก แแ แแแแแก แคแ แแแแแแขแแแก. แแฅแแแ แฃแแแ แแแแแแฎแแแ แแฅแแแแ แแแแแแ แขแแแ แ แแช แจแแแซแแแแ แแแแ, แแฎแแแ แกแแแแแแซแ แกแแขแงแแแก แแแแแกแแงแแแแแแแ
template. แแแแแกแแแแ แ แกแฎแแ แกแแแขแแฅแกแแก แแฎแแ แแแญแแ แ แจแแแซแแแแ แฌแแแจแแแแก GitLab 12.0-แจแ แแ แกแฎแแ แแแแแแแ แแแแแจแแแแแแจแ.
แกแฎแแ แแแฃแแฏแแแแกแแแแแ GitLab 11.9-แจแ
แแแกแฃแฎแ แแแแแแขแแ แแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
GitLab-แก แแฅแแก แแแกแแฃแกแแ แแแแแแแ. แแฅแแแแ แแ แแแแแแ แแแแแแขแแ แก แแแแฌแแ แก แแแแแแแแแ แฃแแแ แแแแแแฌแงแแแขแ, แกแฃแ แแ แแฃ แแ แ แแแกแแฃแกแแ.
แฉแแแ แจแแแแแกแฃแแฃแฅแแ แแก แจแแแฆแฃแแแ. แแแแฆแแ แแแแแกแแแแ แ แแแแแแขแแ แ GitLab-แจแ (แกแแแแแฎแแแแ, แจแแ แฌแงแแแก แแแแฎแแแแแแแ แแ แแแแกแแแแ) แแ แฃแแแกแฃแฎแแ แแแก, แ แแแแช แแแแฌแงแแ แแแกแแฃแกแแ. แแ แแแแ แแฃแแแแแ แฃแคแ แ แแ แแแแแแแแฃแแแ แฃแ แแแแ แแแแแ.
แแ แแแฅแขแแก แจแแแแแแแแ .NET, Go, iOS แแ แแแแ แแแแแกแแแแก
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
แแแแกแแแแแก, แ แแ แแแแฎแแแ แแแแแแก แแแฃแแแแแแแ แแฎแแแ แแ แแแฅแขแแแแก แจแแฅแแแ, แฉแแแ แแแแแแแแแ แ แแแแแแแแ แแฎแแ แแ แแแฅแขแแก แจแแแแแแก:
- แแแฌแงแแแแแ , แ แแแแแแช แแแแชแแแก แกแแแแแแกแ แแแแแแแชแแแก CI-แแ.
- แแแ แจแแแแแแ, แ แแแแแแช แแแ แแแแแแแก แแ GitLab CI/CD.
- แแแแแแ GitLab-แจแ แกแแฌแงแแกแ แแแ แกแแแแแแแแชแแแกแแแแก. แแแแแแแแแกแฌแแแแ, แ แแ แแแแก แแแแ, แ แแ iOS แแแแแแแก แกแญแแ แแแแ แแแแแงแแคแแแ MacOS runner, แแฅแแแ แแแแแฌแแแ แแแแฌแแแแ แแฅแแแแ แกแแแฃแแแ แ build แกแแ แแแ แ, แแฃ แแกแฃแ แ แแแกแ แแแแแงแแแแแ GitLab CI/CD-แแแ แแ แแแ.
- แแแแคแแแฃแ แแ แแแฃแแแ Netlify-แแแ แแฃแจแแแแแกแแแแก.
แแแแแฎแแแแ แแแแแ แแแ แจแแ แฌแงแแแก แแแแฎแแแแแแแก แแแแแก แแคแแแแแแแแแกแแแ
(PREMIUM, ULTIMATE, SILVER, GOLD)
แงแแแแแแแแก แแ แแ แแก แชแฎแแแ, แแแ แแแขแแแชแแแก แแแแ แแแแแแแแก แแแแฎแแแแแก.
GitLab แแฎแแ แแฎแแ แก แฃแญแแ แก แแแแ แแแแแแแแก แแแแฎแแแแแก แแแแขแแแชแแแแก แแแแก แแแฎแแแแแ, แแฃ แ แ แคแแแแแแก แชแแแแก แแแแฎแแแแ, แแแแแงแแแแแแ . แแแแแก แแคแแแแแแแแก แแแแญแแแแ แคแแแแ แ.แฌ CODEOWNERS, แคแแ แแแขแ แแกแแแแกแแ gitattributes.
แแแแแแขแ แแแแแก แแคแแแแแแแแแก แแแขแแแแขแฃแ แแ แแแแแญแแแแก แแฎแแ แแแญแแ แ, แ แแแแ แช แแแ แแแ, แ แแแแแแแช แแแกแฃแฎแแกแแแแแแแแ แแ แแแ แแแแ แแแแแแแแก แแแแฎแแแแแก แแแแขแแแชแแแแแ .
แคแแแแแแแก แแแแแขแแแ Web IDE-แจแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
แแฎแแ, แคแแแแแก แแ แแแ แแฅแขแแ แแแก แแแแแ แฅแแแแแก แจแแแแแ, แจแแแแซแแแแ แแแแแแขแแแแ แแแ แแแ IDE-แแแ แกแแชแแแจแ แแฎแแแ แแแแแแแก แแแกแฌแแ แแ.
แขแแแแแ แแแแแแฃแ แ แแแแแแแแแแ แแแแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
GitLab แขแแแแแ แฌแแ แแแฃแแแแแแแ แแ แแแแแแฎแ แแแแ แแ แแฃแแแแแ แแฃแแแแแแ แแแฃแแแแแ แแแ แแฎแแ แแแแแงแแแแแแก. แจแแกแแแแแแกแแ, แแแแฎแแแ แแแแแแ แฎแจแแ แแ แฃแแแขแแแแ แแแแ แขแแแก แแ แแแแแแแก, แจแแ แฌแงแแแก แแแแฎแแแแแก แแ แแแแแแก.
GitLab 11.9-แจแ แฉแแแ แชแแขแแแ แแแแแแแ แขแแแแ แแขแแแแขแแแแก แแแแแงแแแแแ. แกแแแแแฎแแแแก, แจแแ แฌแงแแแก แแแแฎแแแแแแแกแ แแ แแแแแฃแ แแแแกแแแแก, แแแแ แแแแ แแแแจแ แแแแแกแแฎแฃแแ แแขแแแแขแแแ แแแแแแแแแฃแแแ แแแแแแฃแ แ แแแแแแแแแแ แแแแ. แแก แแกแแแ แแฎแแแ แแ แแแแแฅแขแแแแก แกแแแก แแแฎแแแก.
แกแฌแ แแคแ แแแแแแขแแ แแแ แแแแชแแแแก แแแฎแแแแแ แแแฅแแแแแแแแแก แแแคแแแขแแ แแกแแก
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
แฉแแแ แแฎแแแฎแแ แจแแแแแแฆแแ แคแฃแแฅแชแแ, แ แแแแแแช แแแแฎแแแ แแแแแแก แกแแจแฃแแแแแแก แแซแแแแก แแแคแแแขแ แแ แแฅแขแแแแแแก แแ แฎแ แแแแชแแแแแแก, แแแแฎแแแแแแแก แแ แแแแกแแก แจแแ แฌแงแแแก แแแฎแแแแแ, แ แแช แแแ แกแแจแฃแแแแแแก แแซแแแแก แแแแชแแแขแ แแ แแแแ แแฎแแแแ แแแแแแขแแ แแแแ แแ แกแแกแขแแแแก แจแแแแจแแแแแแ. แแก แแแ แแแแขแ แ แจแแแแฎแฃแแแ แกแแกแขแแแแก แแแแแแฃแแ แแแแฎแแแ แแแแแกแแแแก แแ แจแแแซแแแแ แแแฎแแแก, แ แแ แแแแฎแแแ แแแแแแ แแแ แแแแชแแแแแแ แแก, แ แแ แกแแแแแฎแแก แแแฎแแแกแแก แ แแแแแแแแ แแฆแแก แจแแแแแ แแแแแแฎแแแก แแแคแแแขแ แฃแ แแ แฎแก. แแก แแ แซแแแแก, แ แแ แแแแแแขแแ แก แแแ แขแแแแแก.
แฉแแแ แแแแแฃแแฏแแแแกแแ แแก แฃแ แแแแ แแฅแแแแแแ. แแฎแแ แแแแฎแแแ แแแแแแก แจแแฃแซแแแแ แกแฌแ แแคแแ แแแแแแ แแแ แแกแแ แ แแแแแแ, แ แแแแแแช แแแ แกแแจแฃแแแแแแก แแซแแแแก แแแขแแแแ แแแแแแขแแ แแแ แแ แฎแแก แแแแ แแแฌแแแจแ แแแแแฎแแแแแก แแแ แแจแ. แแก แแฎแแแ แแแแชแแแแแก, แจแแ แฌแงแแแก แแแแฎแแแแแแกแ แแ แแแแกแแแก.
แแแแจแแแก แแแแกแแก แ แแแแก แจแแชแแแ
(ULTIMATE, GOLD)
แชแแขแ แฎแแแก แฌแแ แแแแแแฃแจแแแ , แ แแแแแแแช แแแแกแแก แแแแกแแแแก แแแแแงแแแแแแก แกแแจแฃแแแแแแก แแซแแแแ (แแแแกแแก แแแแจแแฃแ แ แแแแชแแแแแแก แแแ แแ).
แแฎแแ แแฅแแแ แจแแแแซแแแแ แแแแแแฌแงแแ แแแแจแแแ แแแแกแแแแก แแแแแแแแแแ แแแ, แฃแแ แแแแ แแแแแแแ แแแแ แแ แฉแแแแจแแแแแ, แแกแแแ แ แแแแ แช แแแแจแแแ แกแแแแแฎแแแแก แจแแแแฎแแแแแจแ. แแฃแแแแแก แจแแฃแซแแแแ แแแแแแงแแแแ แฌแแกแ แแแ แแ แแแ แแขแแขแแแแก แแกแแฎแแแ แแ แกแแแฃแจแแแก แจแแกแ แฃแแแแแก แแแแแแแแแแ แแแแ.
แแแ แแแแฃแแ แแแแ แแ แฅแแแแ แกแแกแขแแแแก แจแแขแงแแแแแแแแแ แแแแแ แแ แแแคแแกแขแแแ
(CORE, STARTER, PREMIUM, ULTIMATE)
แฉแแแ แแแ แ แแแแแแแขแแ แคแฃแแฅแชแแ, แ แแแแแแช แกแแจแฃแแแแแแก แแซแแแแก แแแ แแแแฃแแ แกแแแแฃแ แแก แแ แฅแแแแ แแแแแแขแแขแฃแแ แจแแขแงแแแแแแแแแ แแแแแฉแแแแก GitLab-แแก แงแแแแ แแแแ แแแ. แแก แแแแแแ แแฅแแ แแแฆแแแฃแแ แแ แแฃแแแแแ แแงแแแแแแ แแแก แแแแจแแแแแแแแแ แแแคแแ แแแชแแแก แแแกแแแแแ แแแแแ, แ แแแแ แแชแแ แกแแกแขแแแแก แจแแขแงแแแแแแแแแ, แ แแแแแแแช แแแแแแจแแ แแแฃแแแ แแแ GitLab แแแแแแแแแแ.
แฉแแแ แแฆแคแ แแแแแแแแฃแแ แแแ แ แแ แคแฃแแฅแชแแแก Core-แจแ แจแแแแขแแแแ, แ แแแ แแแแแ แฃแคแ แ แแแขแแ แแแแแแแแแ แจแแซแแแก แแแกแ แแแแแงแแแแแ. แแแ แแ แแแแกแ, แฉแแแ แกแแจแฃแแแแแแก แแซแแแแก แแแแฎแแแ แแแแแแก แกแฃแ แแแแแกแแแแแ แแฉแแแแแ แแ แแ แแ แแแแแ แจแแขแงแแแแแแแแแ GitLab-แแก แแแจแแแแแแ แแแแแแแแแ แงแแแแ แแแคแแกแขแแจแ แแแแฎแแแ แแแแแก แกแฎแแ GitLab-แแก แจแแฎแแแแก แฌแแ แขแแแจแ แแแแแแแแแแ แฃแแแแแกแแแแก.
แแแคแแแขแแ แ แแแแคแแแแแชแแแแฃแ แ แแแแชแแแแแแก แแแฎแแแแแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
แแแแคแแแแแชแแแแฃแ แ แกแแแแแฎแแแ แแ แแก แกแแกแแ แแแแแ แแแกแขแ แฃแแแแขแ แแฃแแแแแแกแแแแก, แ แแแ แฉแแ แแแ แแแ แซแ แแแกแแฃแกแแแแ แกแแแกแแขแแฃแ แแแแแแแ แฆแแ แแ แแแฅแขแแก แคแแ แแแแแจแ. แแแ แซแแ, แแกแแแ แแแแแแฃแ แแ แฃแกแแคแ แแฎแแแแแก แแแฃแชแแแแแแแแ แแฃแจแแแแแกแแแแก. แแฅแแแแ แแแ แซแแแแแแ แ แแแแชแแแแแแก แแแ แแแ แแแแแแ แแ แแงแ.
GitLab 11.9-แจแ GitLab-แแก แกแแแแแฎแแแแก แกแแ แแฎแแ แแแคแแแขแ แฃแแแ แแแ แซแแแแแแ แ แแ แแ แแกแแแกแแขแแฃแ แ แกแแแแแฎแแแแ. แแก แแกแแแ แแฎแแแ แแแแชแแแแแแก แซแแแแแก API-แแก แแแแแงแแแแแแ.
แแแแแแแ แ แแแแ แข แจแแแแแแก แจแแขแแแแแ แฌแแแแแแกแแแแก)!
Knative แแแแแแแก แ แแแแฅแขแแ แแแ แแแแแแแแแแก แจแแแแแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
Knative-แแก แแแกแขแแแแชแแแกแแก แแแ แแแแฃแแ แแแแแแแก แแแแแแแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแแแกแแฎแฃแ แแ แกแฎแแแแแกแฎแแ แกแแ แแแ แแก แแแ แแจแ แแแแแแแชแแแแก/แคแฃแแฅแชแแแแก แฃแแแแแแฃแ แ แแแแ แฌแแ แขแแแแแแ.
Kubernetes-แแก แแแขแแแ แแชแแ GitLab-แจแ แแฎแแ แแแซแแแแ แกแแจแฃแแแแแแก แจแแชแแแแแ/แแแแแฎแแแ แแแแฎแแแ แแแแแก แแแแแแ Kubernetes แแแแกแขแแ แจแ Knative-แแก แแแแแแแแแแก แจแแแแแ.
Kubernetes CA แกแแ แแแคแแแแขแแก แคแแ แแแขแแก แจแแแแฌแแแแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
แแ แกแแแฃแแ Kubernetes แแแแกแขแแ แแก แแแแแขแแแแกแแก, GitLab แแฎแแ แแแแฌแแแแก, แ แแ แจแแงแแแแแแ CA แกแแ แแแคแแแแขแ แแ แแก แแแฅแแแแ PEM แคแแ แแแขแจแ. แแก แแแแแ แแชแฎแแแก แแแขแแแชแแฃแ แจแแชแแแแแแก Kubernetes-แแก แแแขแแแ แแชแแแกแแแ แแแแแแจแแ แแแแ.
แแแแ แแแแแแแแก แแแแฎแแแแแก แจแแแแ แแแแก แแ แแแ แแแแก แแแคแแ แแแแแ แแแแ แคแแแแแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
แจแแ แฌแงแแแก แแแแฎแแแแแก แชแแแแแแแแแแก แแแฎแแแกแแก, แแฎแแ แจแแแแซแแแแ แแแแคแแ แแแแแ diff แฃแขแแแแขแ แแแแ แคแแแแแ, แ แแแ แแฉแแแแแ แแแแแ แคแแแแ แแแขแ แแแแขแแฅแกแขแแกแแแแก แแ แแแขแแแแ แแแแแแขแแ แแแ แฃแชแแแแ แฎแแแแแแ.
แจแแแกแ แฃแแแ แแแแแ แแขแฃแแ แกแแแฃแจแแแแแ แจแแ แฌแงแแแก แแแแฎแแแแแแแก แกแแคแฃแซแแแแแ แแฎแแแแ แแแจแแ, แ แแแแกแแช แแแ แแแแฃแแ แคแแแแแแ แแชแแแแแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
GitLab 11.6-แแ แแแแแแขแ แแแแกแแแฆแแ แแก แจแแกแแซแแแแแแแ แแแแกแแแแแแก แกแแแฃแจแแแแแแกแแแแก, แ แแแ แแแแฎแแแ แแแแแแก แจแแแซแแแ แแแแแ แแขแฃแแ แแแแชแแแแแแก แจแแกแ แฃแแแแ แแฎแแแแ แจแแ แฌแงแแแก แแแแฎแแแแแก แจแแฅแแแแกแแก.
แแฎแแ แฉแแแ แแแคแแ แแแแแแ แแ แคแฃแแฅแชแแแก: แแแแแขแแแฃแแแ แแแแจแแ แแก แแแแแแ แแ แแแแฎแแแ แแแแแแก แจแแฃแซแแแแ แจแแแกแ แฃแแแ แแแแแ แแขแฃแแ แกแแแฃแจแแแแแ แแฎแแแแ แจแแ แฌแงแแแก แแแแฎแแแแแแแกแแแแก แแ แแฎแแแแ แแแจแแ, แ แแแแกแแช แแแ แแแแฃแแ แคแแแแแแ แจแแแชแแแแแ.
แแแแแแแ แฐแแ แแแฃแแ แกแแขแแก แฌแแแแแแกแแแแก ()!
GitLab-แแก แแแขแแแแขแฃแ แ แแแแแขแแ แแแแ Grafana-แ
(CORE, STARTER, PREMIUM, ULTIMATE)
Grafana แแฎแแ แจแแแแก แฉแแแแก Omnibus แแแแแขแจแ, แ แแช แแแแแแแแแแก แแแแก แแแแแแแก, แแฃ แ แแแแ แคแฃแแฅแชแแแแแ แแแก แแฅแแแแ แแแแแแแแแ แ.
แแแ แแแแ grafana['enable'] = true ะฒ gitlab.rbแแ Grafana แฎแแแแแกแแฌแแแแแ แแฅแแแแ แจแแแแแ แแแกแแแแ แแแ: https://your.gitlab.instance/-/grafana. แฃแแฎแแแแก แแแแแแแแจแ แฉแแแแช "แงแฃแแแแแ".
แแฎแแแแ แแแ แแแแแแ แแแแกแแแ epics-แแก แแแแ แแแแ แแแแจแ
(ULTIMATE, GOLD)
แชแแขแ แฎแแแก แฌแแ แฌแแ แแแแแแแแแแ , แแแแกแแก แแแแกแแแแก แแแแแงแแแแแแก แกแแจแฃแแแแแแก แแซแแแแ.
GitLab 11.9-แจแ แฉแแแ แแแแแแแ แขแแแแ แแ แฃแ แแแแ แแแแแก แแแฎแแ. แแฎแแ แแฅแแแ แจแแแแซแแแแ แแฎแแแแ แแ แ แแฎแแแแ แแแชแแแฃแแ แแแแกแแก แแแแ แแแแกแ, แแ แแแแ แแแแแ แแแแแฃแ แ แฎแ แแแแ แแแแ แแแแจแ แแแ แฏแแแแ. แแฅแแแ แฎแแแแแ, แแแฎแฃแ แฃแแแ แแฃ แแ แ แแก แแแแกแแแ แแ แจแแแแซแแแแ แแแ แแแแแ แแแแแแ แฌแแกแแแ.
แแฎแแแ แแแแแแแแแก แแแฃแแ แแแแแขแแแแแ แแ แแแฎแฃแ แฃแแ แแแแชแแแแแแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
GitLab-แจแ แจแแแแซแแแแ แแแ แขแแแแ แแแแแแขแแแแ แกแแแแแฎแ แกแฎแแ แแ แแแฅแขแจแ แแแแ แแแแ แแแแแก แแ แกแฌแ แแคแ แแแฅแแแแแแแก แแแแแงแแแแแแ. แแฃแแแกแแแจแ แแ แกแแแฃแแ แแแแแแแแ แแฎแฃแ แแแ แแ แกแแแแแแ แแ แแแฅแขแจแ แแฅแแแแแ แแฎแแแ แแแแแแแแ แงแแแแ แแแแแแแ แแแฃแแ แแแแแชแแแแ, แกแแกแขแแแแก แจแแแแจแแแแแแกแ แแ แแแแ แแแแ แแแแแก แแขแ แแแฃแขแแแแก แฉแแแแแแ. แแก แจแแกแแแแจแแแแ แแแแกแแแแ.
แแแแก แแแแแแแแกแฌแแแแแแ, แ แแ แแ แกแแแแแก แกแแกแขแแแฃแ แ แจแแแแจแแแ แแแแแแแแแแแแแก แจแแกแแฎแแ, แแแแฎแแแ แแแแแแ แแแฎแฃแ แฃแแ แแแแแแแแแก แแแฎแแแกแแก แแแแแแแแ แแ แแแ แฎแแแแแแแ, แ แแ แแแแชแแแ แแแแฎแฃแ แ แแแแแแแแแแแแแก แแแแ.
แแ แแแแแจแแแแแ แฉแแแ แแแแแแ แแฎแกแแแ แแแฎแฃแ แฃแแ แแแแ แแก แแแแ แแแก แแแแแ แแ แกแแแฃแ แฎแแขแฃแแแก, แ แแ แแก แแแแแขแแแแแแ แแ แแกแแแ แฉแแแ แแแแ แแฎแแแ แแแแ แแก แฉแแจแแแแแฃแ แแแฃแแก, แ แแแ แแแแแกแแแแ แก, แแแแช แซแแแ แแแแแชแแแแก แจแแแซแแแแ แกแฌแ แแคแแ แจแแซแแแก แแแแแแแชแแ แแฎแแแแ.
YouTrack แแแขแแแ แแชแแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
GitLab แแแขแแแ แแ แแแแ แแ แแแแแ แแแ แ แกแแแแแฎแแแแก แแแแแแแแแแก แกแแกแขแแแแแแแ, แ แแช แแแแแแแแแก แแฃแแแแแก GitLab-แแก แแแแแงแแแแแแก แกแฎแแ แคแฃแแฅแชแแแแแกแแแแก, แฎแแแ แแ แแแแแแแแแก แแแ แแแแก แแ แฉแแฃแแ แแแกแขแ แฃแแแแขแแก แจแแแแ แฉแฃแแแแแ.
แแ แแแแแชแแแแจแ แฉแแแ แแแแแแแขแแ YouTrack-แแก แแแขแแแ แแชแแแก แจแแกแแซแแแแแแแ JetBrains-แแแ.
แแแแแแ แแแแแแแ แแแแแแฃแฎแแแแ แแแขแแฃ แแแฃแฉแแแก แจแแขแแแแแ แฌแแแแแแกแแแแก ()!
แจแแ แฌแงแแแก แแแแฎแแแแแก แคแแแแแก แฎแแก แแแแแก แจแแชแแแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
แจแแ แฌแงแแแก แแแแฎแแแแแก แชแแแแแแแแแแก แแแฎแแแกแแก, แแฎแแ แจแแแแซแแแแ แคแแแแแก แฎแแก แแแแแก แจแแชแแแ, แ แแแ แแฉแแแแแ แคแแแแแก แแ แซแแแ แกแแฎแแแแแ แแ แแแแแแแ แกแแแ แชแ แแแขแแ แ แแแ แแแแแแ.
แแแแแแแ แแแแ แแแแแแแแแก แแแแแแแ
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD)
แแแคแแแ แซแแแแแ แกแแกแแ แแแแแแ แแ แแฃแแแแแ แฅแแแแแ แแ แแแแ แแแคแก แแแแแแฃแแ แแ แแแฅแขแแกแ แแ แฏแแฃแคแแกแแแแก. แฉแแแ แแฎแแแฎแแ แแแแแแแขแแ แกแแซแแแแ แแแแ, แ แแแ แกแฌแ แแคแแ แแแแคแแแขแ แแ แงแแแแ แแแแแแ, แ แแแแแแช แแฅแแแ แแแแแขแแ แแกแแแ.
GitLab 11.9-แจแ แฉแแแ แแกแแแ แจแแแแแแฆแแ แกแแฅแชแแ แแแแ แฉแแแแกแแจแแแ แกแแแจแ. แแ แแแแ แแฅแแแ แจแแแแซแแแแ แกแฌแ แแคแแ แแแแแฎแแแแแ แแ แแแแแแแแแ, แ แแแแแแแแแแช แแฎแแแฎแแ แแฅแแแแแ แแแขแแ แแฅแชแแ.
แแแแแแแแแ แแแแก แจแแกแแซแแแแแแแ แจแแฅแแแแ แแแชแฃแแ แคแแแแแแแแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
แแแชแฃแแ แคแแแแแแแแ แฎแแแก แฃแจแแแแ แแแแแฃแแแฌแแแแแแ แแแแแก แแแแแขแแแแก แแ แแแแ แแแแแแแแก. แแฃแแชแ, แแฃ แแ แแแแก แแฅแแก แฃแคแแแแ แแแแแแขแแแแก แแแชแฃแแ แขแแขแแแ, แแแจแแ แแแ แแแแ แจแแซแแแแก แจแแฅแแแแก แแฎแแแ แแแชแฃแแ แคแแแแแแ: แแแแแแแแแ, แแแแแจแแแแแก แคแแแแแแ.
GitLab 11.9-แจแ แแแแแแแแแ แแแก แจแแฃแซแแแแ แจแแฅแแแแ แแแชแฃแแ แคแแแแแแแแ แฃแแแ แแแชแฃแแ แคแแแแแแแแแแแ GitLab-แแก แแ API-แแก แแแจแแแแแแ. แแฎแแแ แแแชแฃแแ แคแแแแแแแก แแแแแกแแขแแแแ Git-แแก แแแแแงแแแแแ แฏแแ แแแแแ แจแแแฆแฃแแฃแแแ แแฎแแแ แแแชแฃแแ แคแแแแแแแแแก แจแแแแฎแแแแแ แจแแฅแแแแก แแแแแแแ แแกแแชแแแแแแแ.
Git Object Deduplication Open Forks-แแกแแแแก (แแแขแ)
(CORE, STARTER, PREMIUM, ULTIMATE)
Forking แกแแจแฃแแแแแแก แแซแแแแก แแแแแกแแแแ แก, แฌแแแแแ แจแแแขแแแแก แฆแแ แแแแแก แแ แแแฅแขแแแจแ: แฉแแฌแแ แแก แแแแแ แแแแก แแแ แแจแ, แฃแแ แแแแ แกแแชแแแแก แแฎแแ แแ แแแฅแขแจแ แแแแแ แแแแ. แฎแจแแ แแ แฉแแแแแแ Git แกแแชแแแแแแก แกแ แฃแแ แแกแแแแแก แจแแแแฎแแ แแ แแแคแแฅแขแฃแ แแ. แแฎแแ Git-แแแ แแ แแแ alternatives แฉแแแแแแแ แแแแแ แแแแ แกแแแ แแ แแแแแฅแขแแแก แซแแ แแแแแ แแ แแแฅแขแแกแแแ แแแแแฅแขแแแแก แแฃแแจแ, แ แแแ แจแแแชแแ แแแก แแแกแแแก แจแแแแฎแแแก แแแแฎแแแแแแ.
Fork แแแแแฅแขแแแแก แแฃแแแแ แแฅแแแแแ แแฎแแแแ แฆแแ แแ แแแฅแขแแแแกแแแแก, แ แแแแกแแช แฉแแ แแฃแแแ แฐแแจแแ แแแฃแแ แแแฎแกแแแ แแแ. แแแแแฅแขแแก แแฃแแแแ แฉแแ แแฃแแแ แคแฃแแฅแชแแแก แแแ แแแแขแ แแก แแแแแงแแแแแแ object_pools.
แแแแแญแแแฃแแ แแแแแขแแแชแแแแแแแก แแแแ แจแแ แฌแงแแแก แแแแฎแแแแแแแก แกแแแก แแแคแแแขแแ แ
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD)
แแแแแก แแแแฎแแแแ แฉแแแฃแแแแ แแแ แแ แแฅแขแแแแ แแแแแกแแแแ แ แฌแแ แแแขแแแฃแแ แแ แแแฅแขแแกแแแแก, แแแแ แแ แแแแแแฎแแแแแแแกแแแแก แจแแแซแแแแ แ แแฃแแ แแงแแก แจแแ แฌแงแแแก แแแแฎแแแแแแแก แแแแแงแฃแ แแก แแแแแแแ.
GitLab 11.9-แจแ แจแแ แฌแงแแแก แแแแฎแแแแแแแก แกแแ แแคแแแขแ แแแ แแแแแจแแฃแแ แแแแแขแแแชแแแแแก แแแแ . แแ แแแแ แแฅแแแ แจแแแแซแแแแ แแแแแแ แจแแ แฌแงแแแก แแแแฎแแแแแแ แแแแแขแแแฃแแ แแฅแแแ, แ แแแแ แช แแแแแแฎแแแแแแ.
แแแแแแแ แแแแแแ แแแฉแแ แขแก แแแกแ แฌแแแแแแกแแแแก ()!
แแแแกแแฎแแแแแแ แจแแแแแแ แแ แฌแแแ แคแแแแแก แจแแ แฌแงแแแก แแแแฎแแแแแจแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
แแแแ แแแแแแแแก แแแแฎแแแแแจแ แชแแแแแแแแแแก แแแฎแแแกแแก, แจแแแแซแแแแ แกแฌแ แแคแแ แแแแแฎแแแแแ แคแแแแแแก แจแแ แแก แแแแแงแแแแแแ ]แแ j แจแแแแแ แคแแแแแ แแแแแกแแกแแแแแแ แแ [ แแ k แฌแแแ แคแแแแแ แแแแแกแแกแแแแแแ.
แแแแแ แขแแแแแ .gitlab-ci.yml แฃแกแแ แแแ แ แแ แแแฅแขแแแแกแแแแก
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
แแแแแฃแแแ แคแฃแแฅแชแแแแแ แแแแแ GitLab CI, แกแแ แแแ แแก แจแแแแแแ gitlab-ci.yml แแแแจแแแแแแแแแ แแแแแ แขแแแแ. แแแแแแแ แแแแแจแแแแแแจแ แแฎแแแ แคแฃแแฅแชแแแแแก แแแกแแแแ แแแ, แแฅแแแ แแ แแญแแ แแแแแ แแ แคแแแแจแ แชแแแแแแแแแแก แจแแขแแแ.
แจแแงแแแแแก แฐแแกแขแแก แกแแฎแแแแก แแฎแแ แแแญแแ แ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
Kubernetes Ingress แแแแขแ แแแแ แแก แแแงแแแแแแกแแก, แแแแแแ แแ แแแแขแคแแ แแ แฃแแ แฃแแแแแ IP แแแกแแแแ แแก (แแแแแแแแแ, Google-แแก GKE), แแแแ แแ แแกแแ DNS แกแแฎแแแก (แแแแแแแแแ, AWS-แแก EKS).
แฉแแแแ Kubernetes แแแขแแแ แแชแแ แแฎแแ แแฎแแ แก แฃแญแแ แก แแ แแแ แขแแแแก แกแแแแแแ แฌแแ แขแแแก แกแแฅแชแแแจแ แแแแแกแแขแแแแ clusters แแ แแแฅแขแ.
แแแแแแแ แแแ แแ แฃแแแแ แก แแแกแ แฌแแแแแแกแแแแก ()!
JupyterHub-แแก แจแแกแแแแก แฌแแแแแแก แจแแแฆแฃแแแ แแฎแแแแ แแฃแแแแก/แแ แแแฅแขแแก แฌแแแ แแแแกแแแแก
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
JupyterHub-แแก แแแแแ แแแ GitLab-แแก Kubernetes-แแก แแแขแแแ แแชแแแก แแแแแงแแแแแแ แแ แแก แแแแ แแแ Jupyter Notebook-แแแแก แจแแกแแแแ แฉแฃแแแแแแ แแ แแแแแงแแแแแแกแแแแก แแแ แแฃแแแแแจแ. แแกแแแ แกแแกแแ แแแแแแ แแแแแ แฌแแแแแแก แแแแขแ แแแ แแแแคแแแแแชแแแแฃแ แ แแ แแแ แกแแแแแฃแ แ แแแแแชแแแแแแก แแแแแชแแแแกแแก.
GitLab 11.9-แจแ, Kubernetes-แแก แแแจแแแแแแ แแแแแแแแแฃแ JupyterHub แแแกแขแแแชแแแแจแ แจแแกแแแแก แจแแกแแซแแแแแแแ แจแแแแแคแแ แแแแแ แแฎแแแแ แแ แแแฅแขแแก แฌแแแ แแแแ, แ แแแแแแกแแช แแฅแแ แแแแแแแแแ แฃแแ แฌแแแแแ (แฏแแฃแคแแก แแ แแ แแแฅแขแแก แแแจแแแแแแ).
แแแแแแแคแแแฃแ แแ แแ แแ แแแก แแแแแแแแแ แฃแกแแคแ แแฎแแแแแก แแแแแแแก แกแฅแแแแแแกแแแแก
(ULTIMATE, GOLD)
แแฃแแแแก แฃแกแแคแ แแฎแแแแแก แกแแแแคแแ แแแชแแ แแแคแ แจแแแชแแแก แแแฃแชแแแแแแแก แ แฃแแแก แแฃแแแแก แแ แแแฅแขแแแแก แฃแกแแคแ แแฎแแแแแก แแแแแแแแแแแ แกแขแแขแฃแกแแก แแแแแฎแแแแแก แฃแแ แฃแแแแแกแแงแแคแแ. แแก แซแแแแแ แกแแกแแ แแแแแแ แฃแกแแคแ แแฎแแแแแก แแแ แแฅแขแแ แแแแกแแแแก, แ แแแ แแแแงแแแแ แแ แแชแแกแแแ แแ แแแแแแ, แแฃ แ แแแแ แแฃแจแแแแก แแฃแแแ.
GitLab 11.9-แจแ แแฎแแ แจแแแแซแแแแ แแแ แฉแแแ แแ แแแก แแแแแแแแแ แแ แแแฃแชแแแแแแแก แ แฃแฅแแกแแแแก. แแแแฃแแแกแฎแแแแแ, แแก แแ แแก แแแแ 90 แแฆแ, แแแแ แแ แแฅแแแ แจแแแแซแแแแ แแแแงแแแแ แแแขแแ แแแแ 60 แแ 30 แแฆแแแ, แ แแช แแแแแแแแแแฃแแแ แแฅแแแแแแแก แกแแญแแ แ แแแขแแแแแแก แแแแแแ.
แแก แแ แแแแฅแแแแแแก แแ แแชแฎแแแแแแแ แแ แกแแแจแ แแ แกแแแฃแ แแแแแชแแแแแแ, แแฎแแแแ แแแแแ แแแแจแ แแแแแกแแฎแฃแ แแแแแชแแแแแแ.
แขแแแแแแกแแแแก แแแขแแแแขแฃแ แ DevOps-แแก แแแแแแก แกแแแฃแจแแแก แแแแแขแแแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
Auto DevOps-แแก แแจแแแแแแก แแแแแฏแ แฅแแแแก แแฅแแแแ แแแแแแแชแแแก build-แก แแฅแแแแ Heroku แแ แแแฅแขแแก แแ buildpack-แแก Dockerfile-แแก แแแแแงแแแแแแ.
GitLab 11.9-แจแ, แแแฆแแแฃแ Docker แกแฃแ แแแก, แ แแแแแแช แฉแแจแแแแแฃแแแ แขแแแแแแก แแแแกแแแแแจแ, แแแกแแฎแแแแแฃแแแ แแกแ, แ แแแแ แช แขแ แแแแชแแฃแแ แกแฃแ แแแแแแก แกแแฎแแแแแ, SHA commit-แแก แแแชแแแแ tag commit-แแก แแแแแงแแแแแแ.
แแแแแแแ แแแ แแ แฃแแแแ แก แแแกแ แฌแแแแแแกแแแแก!
แแแแแแฎแแแ Code Climate แแแ แกแแ 0.83.0
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD)
แแแขแแแแ แแงแแแแแก แ แแแ แจแแแแแฌแแแ, แ แแแแ แแแฅแแแแแแก แชแแแแแแแแแ แแฅแแแแ แแแแแกแ แแ แแ แแแฅแขแแก แแแแแแแ แแแแแแ.
GitLab 11.9-แจแ แฉแแแ แแแแแแแฎแแแ แซแ แแแ แฃแแฎแแแก แแแ แกแแแแแ () แแแแแขแแแแแ แแแแกแ แแ แกแขแแขแแแฃแ แ แแแแแแแแก แแฎแแ แแแญแแ แแก แฃแแแ แแขแแกแแแแแแก แฃแแ แฃแแแแแงแแคแ GitLab Code Quality-แแกแแแแก.
แแแแแแแ GitLab Core แแฃแแแแก แฌแแแ แก แขแแแฃแแ แแแแฃแฉแแก แจแแขแแแแแ แฌแแแแแแกแแแแก ()!
แแแขแ แแแแก แแแแแแแก แแแกแจแขแแแแ แแแ แแ แแแแแฎแแแแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
แจแแกแ แฃแแแแแก แแแแแแแแแแแก แแแแแแแแแแแกแแก แฎแจแแ แแ แกแแกแแ แแแแแแ แแแแแ แแขแฃแแ แแแขแ แแแแก แชแแแแแฃแแ แแแฌแแแแแแก แฃแคแ แ แแแขแแแฃแ แแ แแแแแแแแแ แแแ.
GitLab 11.9-แแ แแแแฎแแแ แแแแแแก แจแแแซแแแแแ แแแแแแแแ แชแแแแแฃแแ แแ แแแก แแแ แแแแแแ แแแขแ แแแแก แแแแแแจแ, แแแแแแฎแแแแ แแแแแ แแ แแแก แแแแแแแแแจแ แแ แแแแแแแ แแแฃแแ แฃแแแแแ แกแแฌแงแแกแ แแ แแแก แแแขแแ แแแแแก แฎแแแก. แแก แกแแจแฃแแแแแแก แแแซแแแแ แกแฌแ แแคแแ แแ แแแ แขแแแแ แแแแแแแแแแแ แแฅแแแแแแแก แกแแญแแ แ แแแแแแแแแ.
SAST TypeScript-แแกแแแแก
(ULTIMATE, GOLD)
แแ แแก แจแแแแ แแแแ แแฎแแแ แแ แแแ แแแแ แแแแก แแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ .
GitLab 11.9-แจแ, แกแขแแขแแแฃแ แ แแแแแแแชแแแก แฃแกแแคแ แแฎแแแแแก แขแแกแขแแ แแแ (SAST) แแแแแแแแแแก แแ แแฆแแแแฉแแแก แแแฃแชแแแแแแแก TypeScript แแแแจแ, แแฉแแแแแแก แแแ แจแแ แฌแงแแแก แแแแฎแแแแแก แแแฏแแขแจแ, แแแแกแแแแแแก แแแแแแ แแ แฃแกแแคแ แแฎแแแแแก แกแแแแคแแ แแแชแแ แแแคแแจแ. แแแแแแแแ แ แกแแแฃแจแแแก แแแแแแ แขแแแ sast แจแแชแแแ แแ แแ แแก แกแแญแแ แ แแ แแก แแกแแแ แแแขแแแแขแฃแ แแ แจแแแแก .
SAST แแ แแแแแแแแฃแแ Maven แแ แแแฅแขแแแแกแแแแก
(ULTIMATE, GOLD)
Maven แแ แแแฅแขแแแ แฎแจแแ แแ แแ แแแแแแแแฃแแแ แแแแแแแแ แแแแก แแแแแแ แแ แ แกแแชแแแจแ. แแแ แ, GitLab-แก แแ แจแแแซแแ แกแฌแแ แแ แกแแแแแ แแแ แแกแแแ แแ แแแฅแขแแแ แแ แแแแแแแแแ แแแ แแ แฃแกแแคแ แแฎแแแแแก แกแแแชแแแแแกแขแแแ แแ แแฆแแแแแแ แแแฌแงแแแแแแแแก แจแแกแแฎแแ แแแฎแกแแแแแแแก.
GitLab 11.9 แแแแแแแแแ แแแคแแ แแแแแฃแ แแฎแแ แแแญแแ แแก SAST แคแฃแแฅแชแแแกแแแแก แแ แแแแแ แแขแฃแแ แแ แแแฅแขแแก แแแแคแแแฃแ แแชแแแกแแแแก, แ แแช แฃแแ แฃแแแแแงแแคแก แแแแ แแแฃแชแแแแแแแก แจแแกแแแแฌแแแแแแ. แแแแแแแแขแแ แแแแก แแแฅแแแแแแแก แฌแงแแแแแแ, แแแแคแแแฃแ แแชแแ แแแแแกแแแฆแแ แแแ แแแขแแแแขแฃแ แแ แแ แแฅแแแ แแ แแญแแ แแแแแ แแ แแคแ แแก แจแแชแแแ แแ แแแแแแแแฃแแ Maven แแแแแแแชแแแแแก แจแแแแแแแแก แกแแแแฎแแแแ. แฉแแแฃแแแแแกแแแแแ , แแกแแแแกแ แแแฃแแฏแแแแกแแแแแ แแกแแแ แฎแแแแแกแแฌแแแแแแ แจแแแแแ .
GitLab Runner 11.9
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
แแฆแแก แฉแแแ แแกแแแ แแแแแแแฅแแแงแแแ GitLab Runner 11.9! GitLab Runner แแ แแก แฆแแ แแแแแก แแ แแแฅแขแ แแ แแแแแแงแแแแแ CI/CD แกแแแฃแจแแแแแแก แแแกแแจแแแแแ แแ แจแแแแแแแแก GitLab-แจแ แแแแแแแแแกแแแแก.
แฅแแแแแ แแแชแแแฃแแแ แ แแแแแแแแ แชแแแแแแแ GitLab Runner 11.9-แจแ:
- .
- ะธ .
- ... แแแแแแ .
- แแฎแแ แแแญแแ แแกแแแแก , แ แแแแแแช แแแแแฉแแแแแ GitLab 11.10-แจแ.
- .
- .
- แแ แแแแแ แกแแ แแแขแแก แแแแแขแแแ - แแแ แจแแ แแก ะธ -แแแจแ.
- .
- .
- .
แชแแแแแแแแแแก แกแ แฃแแ แกแแ แจแแแแซแแแแ แแฎแแแแ GitLab Runner แชแแแแแแแแแแก แแฃแ แแแแจแ: .
GitLab แกแฅแแแแก แแแฃแแฏแแแแกแแแ
(CORE, STARTER, PREMIUM, ULTIMATE)
แจแแแแแแ แแแฃแแฏแแแแกแแแแแ แแแแฎแแ แชแแแแแ GitLab แฉแแ แขแจแ:
- แแแแแขแแแฃแแแ แแฎแแ แแแญแแ แ Google Cloud Memorystor-แแกแแแแก.
- Cron แกแแแฃแจแแ แแแ แแแแขแ แแแ , แแแแแแแแ แแแ แ แแแแแแแแ แกแแ แแแกแ แแงแแแแแก.
- แ แแแกแขแ แ แแแแแฎแแแ 2.7.1 แแแ แกแแแแแ.
- แแแแแขแแแฃแแแ แแฎแแแ แแแ แแแแขแ แ, แ แแแ GitLab แ แแแกแขแ แ แแงแแก แแแแกแแแแแ Docker แแแ แกแแแแแแ 1.10-แแแ. แแแกแแแฅแขแแฃแ แแแแแ, แแแแแแกแขแแแแ แแ
registry.compatibility.schema1.enabled: true.
แจแแกแ แฃแแแแแก แแแฃแแฏแแแแกแแแ
(CORE, STARTER, PREMIUM, ULTIMATE, แฃแคแแกแ, แแ แแแฏแแ, แแแ แชแฎแแ, แแฅแ แ)
แฉแแแ แแแแ แซแแแแแ GitLab-แแก แแฃแจแแแแแก แแแฃแแฏแแแแกแแแแก GitLab-แแก แงแแแแ แแแแแก แงแแแแ แแแแแจแแแแแ. แแฅ แแ แแก แ แแแแแแแแ แแแฃแแฏแแแแกแแแ GitLab 11.9-แจแ:
- .
- .
- .
- .
แแแแแแฃแกแแก แแแฃแแฏแแแแกแแแ
(CORE, STARTER, PREMIUM, ULTIMATE)
GitLab 11.9 แแแแชแแแก แจแแแแแ Omnibus แแแฃแแฏแแแแกแแแแก:
- GitLab 11.9 แแแแชแแแก , , แ แแแแแก แฃแแฎแแแกแ แแแแแจแแแแ แแแแชแแแก MFA Team Edition-แแกแแแแก, แแแแแกแแฎแฃแแแแแก แแแฃแแฏแแแแกแแแฃแ แจแแกแ แฃแแแแแก แแ แกแฎแแ. แแก แแแ แกแแ แแกแแแ แแแแชแแแก ; แ แแแแแแแแแ แแแฃแแแ แแแแแฎแแแแ.
- แแแแแขแแแฃแแแ แแฎแแแ แแแ แแแแขแ แ, แ แแแ GitLab แ แแแกแขแ แ แแงแแก แแแแกแแแแแ Docker แแแ แกแแแแแแ 1.10-แแแ. แแแกแแแฅแขแแฃแ แแแแแ, แแแแแแกแขแแแแ แแ
registry['compatibility_schema1_enabled'] = true ะฒ gitlab.rb. - GitLab แ แแแกแขแ แ แแฎแแ แแฎแแ แชแแแแแแก แแ แแแแแแก แแแขแ แแแแก แแฅแกแแแ แขแก แแ แแแขแแแแขแฃแ แแ แแแแแขแ แแแแแก แจแแแแแแแแแก .
- แแแแแขแแแฃแแแ Google Cloud Memorystor-แแก แแฎแแ แแแญแแ แ, แ แแแแแแช แแแแแฎแแแก .
opensslแแแแแฎแแแแฃแแแ แแแ แกแแ 1.0.2r,nginx- 1.14.2 แแแ แกแแแแแ,python- 3.4.9 แแแ แกแแแแแ,jemalloc- 5.1.0 แแแ แกแแแแแ,docutils- 0.13.1 แแแ แกแแแแแ,gitlab-monitor- 3.2.0 แแแ แกแแแแแ.
แแแซแแแแแแฃแแ แคแฃแแฅแชแแแแ
GitLab Geo แฃแแ แฃแแแแแงแแคแก แฐแแจแแ แแแฃแ แจแแแแฎแแแก GitLab 12.0-แจแ
แกแแญแแ แแ GitLab Geo แแแแ แแ แแแแแซแแแแ แแแแแฃแ แแแชแแแก (แ แแกแแก แแแแแแแ แแแแแก) แจแแกแแแกแฃแแฃแฅแแแแแ. แแก แแฆแแแแจแแ แฅ .
GitLab-แจแ แฉแแแ แแแแแแแขแแ แแก แแแแฎแแแแ Geo แแแแฃแแแแขแแชแแแจแ: .
GitLab-แจแ sudo gitlab-rake gitlab: geo: check แแแแฌแแแแก, แฉแแ แแฃแแแ แแฃ แแ แ แฐแแจแแ แแแฃแแ แแแฎแกแแแ แแแ แแ แงแแแแ แแ แแแฅแขแแก แแแแ แแชแแ. แฒกแ. . แแฃ แแงแแแแแ Geo-แก, แแแฎแแแ, แแแฃแจแแแ แแก แจแแแแฌแแแแ แแ แแแแแแขแแแแ แ แแช แจแแแซแแแแ แแแแ.
GitLab-แจแ แแฃแแแแแแ แแแแแจแฃแแ แแแคแ แแฎแแแแแ แแแแแฉแแแแแ แแแแ แแแ Admin Area โบ Geo โบ Nodesแแฃ แแแแแแฆแแแจแแฃแแ แจแแแแฌแแแแแแ แแแฃแจแแแแแแแ.
GitLab-แจแ Geo แแแแแแงแแแแแก แฐแแจแแ แแแฃแแ แจแแแแฎแแแก แแแแฎแแแแแแก. แฒกแ. .
แฌแแจแแแก แแแ แแฆแ: 22 2019 แแแแแกแก,
แฐแแแฉแแขแแก แแแขแแแ แแชแแ
แฐแแแฉแแข . แแแ แแ แแแแกแ, 11.9 แแแ แกแแแจแ .
แฌแแจแแแก แแแ แแฆแ: 22 2019 แแแ แขแ,
CentOS 6 แแฎแแ แแแญแแ แ GitLab Runner-แแกแแแแก Docker แจแแแกแ แฃแแแแแแก แแแแแงแแแแแแ
GitLab Runner แแ แฃแญแแ แก แแฎแแ แก CentOS 6-แก GitLab 11.9-แแ Docker-แแก แแแแแงแแแแแแกแแก. แแก แแ แแก Docker core แแแแแแแแแแแก แแแแแฎแแแแแก แจแแแแแ, แ แแแแแแช แแฆแแ แฃแญแแ แก แแฎแแ แก CentOS 6. แแแแแขแแแแแ แแแคแแ แแแชแแแกแแแแก แแฎ. .
แฌแแจแแแก แแแ แแฆแ: 22 2019 แแแ แขแ,
GitLab Runner-แแก แแแซแแแแแแฃแแ แแแแแก แแแแแแแแ
Gitlab 11.9-แแก แแแแแแแ แแแแแ, GitLab Runner แแงแแแแแก แกแแชแแแแก แแแแแแ แแแ/แแแแแซแแฎแแแ. แแแแแแแ GitLab Runner แแแแแแงแแแแแก แซแแแ แแแแแแก, แแฃ แแฎแแแ แแ แแ แแก แแฎแแ แแแญแแ แแแ.
GitLab 11.0-แจแ แฉแแแ แจแแแชแแแแแ แแแขแ แแแแก แกแแ แแแ แแก แแแแคแแแฃแ แแชแแแก แแแ แแแแแแ GitLab Runner-แแกแแแแก. metrics_server แกแแกแแ แแแแแแ แแแแฎแกแแแแ listen_address GitLab 12.0-แจแ. แแฎแแแแ แแแขแ แแแขแแแ แแฅ . แแ แแแขแ แแแขแแแ แจแ .
11.3 แแแ แกแแแจแ GitLab Runner-แแ แแแแฌแงแ แแฎแแ แแแญแแ แ , แ แแแแช แแแแแแฌแแแ แแฎแแแ แแแ แแแแขแ แแแ . In แแแชแแแฃแแแ แชแแแแแแแแแแก แชแฎแ แแแ แแ แแแกแขแ แฃแฅแชแแแแ แแฎแแ แแแแคแแแฃแ แแชแแแแ แแแแแกแแแแกแแแแก. แแฎแแแแ แแแขแ แแแขแแแ แแฅ .
แแก แแแแแแแแ แแฆแแ แแ แแก แฎแแแแแกแแฌแแแแแ GitLab 12.0-แจแ. แ แแแแ แช แแแแฎแแแ แแแแแก, แแฅแแแ แแ แแญแแ แแแแแ แแ แแคแ แแก แจแแชแแแ, แแแ แแ แแแแกแ, แ แแ แแแ แฌแแฃแแแแ, แ แแ แแฅแแแแ GitLab แแแกแขแแแชแแ แแฃแจแแแแก 11.9+ แแแ แกแแแแ GitLab Runner 12.0-แแ แแแแแฎแแแแแกแแก.
แฌแแจแแแก แแแ แแฆแ: 22 2019 แแแแแกแก,
GitLab Runner-แแกแแแแก แจแแกแแแแก แฌแแ แขแแแแก แคแฃแแฅแชแแแกแแแแก แแแซแแแแแแฃแแ แแแ แแแแขแ แ
11.4 GitLab Runner แจแแแแแฅแแก แคแฃแแฅแชแแแก แแแ แแแแขแ แก แแ แแแแแแแแแก แแแแแกแแญแ แแแแ, แ แแแแ แแชแแ ะธ .
GitLab 12.0-แจแ แฉแแแ แแแแแแแแ แกแฌแแ แฅแชแแแแแ, แแแแฅแแก แคแฃแแฅแชแแแก แแแ แแแแขแ แ แแแแแ แแฃแแแ. แแฎแแแแ แแแขแ แแแขแแแ แแฅ .
แฌแแจแแแก แแแ แแฆแ: 22 2019 แแแแแกแก,
แแแแฃแฅแกแแก แแแกแขแ แแแฃแชแแแก แแฎแแ แแแญแแ แ แแแซแแแแแแฃแแแ แแ แแฆแฌแแแก EOL-แก GitLab Runner-แแกแแแแก
Linux-แแก แแแแแแ แแ แแแกแขแ แแแฃแชแแ, แ แแแแแแแแแช แจแแกแแซแแแแแแแ GitLab Runner-แแก แแแงแแแแแ, แแแกแแฎแฃแ แแแแแ แแแแแก แแแแแแก.
GitLab 12.0-แจแ GitLab Runner แแฆแแ แแแแแ แชแแแแแก แแแแแขแแแก Linux-แแก แแแกแขแ แแแฃแชแแแแแ. แแแกแขแ แแแฃแชแแแแแก แกแ แฃแแ แกแแ, แ แแแแแแแช แแฆแแ แแ แแก แแฎแแ แแแญแแ แแแ, แจแแแแซแแแแ แแฎแแแแ แฉแแแแก แกแแแขแแ . แแแแแแแ แฎแแแแแ แแ แแแก () แแแกแแแแก !
แฌแแจแแแก แแแ แแฆแ: 22 2019 แแแแแกแก,
แซแแแแ GitLab Runner Helper แแ แซแแแแแแแแก แฌแแจแแ
แ แแแแ แช แฉแแแแ แแฎแแ แแแญแแ แแก แซแแแแกแฎแแแแแก แแแฌแแแ แแซแฃแแแแฃแแ แแแฎแแ แแแแขแแแแแแแ แ แแแแแแแแ แซแแแแ แแ แซแแแแแ, แ แแแแแแช แแแแแแงแแแแแ .
GitLab 12.0-แจแ GitLab Runner แแแจแแแแฃแแแ แแฎแแแ แแ แซแแแแแแแแก แแแแแงแแแแแแ. แแก แแแแแแแแก แแฎแแแแก แแฎแแแแ แแแแฎแแแ แแแแแแแ, แ แแแแแแแช แฃแแฃแแแแแแงแแคแแ . แแฎแแแแ แแแขแ แแแขแแแ แแฅ .
แฌแแจแแแก แแแ แแฆแ: 22 2019 แแแแแกแก,
แแแแแแแแแ แแแก แจแแฃแซแแแแ แฌแแจแแแแ Git แขแแแแแ GitLab 11.10-แจแ
Git แขแแแแแแก แแแ แกแแแก แจแแแแจแแแแแแก แฌแแจแแ แแ แ แแแแฅแขแแ แแแ แแแฃแแแจแแแ แคแแแแแแแแจแ แแกแขแแ แแฃแแแ แจแแแแแคแแ แแแแแแแ แแฎแแแแ .
แแแแแแแแ แแแแแแแแแ แแแก แจแแฃแซแแแแ แขแแแแแแก แแแแแขแแแ แแ แแแฃแชแแแแ แคแแแแแแแแแก แจแแชแแแ แแ แฌแแจแแ, แแแแแแแแแ แแแก แฃแแแ แจแแแซแแแ Git แขแแแแแแก แฌแแจแแ. GitLab-แจแ 11.10 แฉแแแแก แแแแแ แแแแแแก แแแแแแจแ, แ แแแ แแแแแฃแแฏแแแแกแแ แกแแแฃแจแแ แแแแแแ แแ แแแแแฎแแแ แแ แแแแแแแแแ แแแก แฃแแแ แแ แแคแแฅแขแฃแ แแ แแแแแแงแแแแ แขแแแแแ.
แแฃ แแกแฃแ แ แจแแแแแ แฉแฃแแแ แแก แจแแแฆแฃแแแ แแคแแแแแแแแแกแแแแก แแ แแคแแแแแแแแแกแแแแก, แแแแแแงแแแแ .
แฌแแจแแแก แแแ แแฆแ: 22 แแแ แแแ 2019 แฅแแแแฅแ
Prometheus 1.x แแฎแแ แแแญแแ แ Omnibus GitLab-แจแ
แแแฌแงแแแฃแแ GitLab-แแ , Prometheus 1.0-แแก แฉแแจแแแแแฃแแ แแแ แกแแ แแแแฆแแแฃแแแ Omnibus GitLab-แแแ. . แแฃแแชแ, แแแขแ แแแแก แคแแ แแแขแ แแ แแ แแก แแแแกแแแแแ 1.0 แแแ แกแแแกแแแ. แแ แกแแแฃแแ แแแ แกแแแแ แจแแแซแแแแ แแแแแฎแแแแก 2.0-แแแ แแ, แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ, แแแแแชแแแแ แแแแแชแแแ .
GitLab แแแ แกแแแจแ Prometheus 2.0 แแแขแแแแขแฃแ แแ แแแแแกแขแแแแ แแแแ, แแฃ แแแแแฎแแแแ แฃแแแ แแแแแกแขแแแแ แแแฃแแ แแ แแ แแก. Prometheus 1.0-แแก แแแแแชแแแแแ แแแแแแ แแแแ, แ แแแแแ... แแ แแขแแแแ.
แฌแแจแแแก แแแ แแฆแ: 22 2019 แแแแแกแก,
TLS v1.1
แแแฌแงแแแฃแแ GitLab-แแ แฃแกแแคแ แแฎแแแแแก แแแกแแฃแแฏแแแแกแแแแแ. แแก แแแแแ แแแก แฃแแแ แแ แแ แแแแแแแก, แแแ แจแแ แแก Heartbleed-แก แแ GitLab PCI DSS 3.1-แก แฎแแแก แแแแกแแแแแ.
แแแฃแงแแแแแแแแ แแแแแ แแแ TLS v1.1, แแแแงแแแแ nginx['ssl_protocols'] = "TLSv1.2" ะฒ gitlab.rband แแ แแแแฅแแชแ gitlab-ctl reconfigure.
แฌแแจแแแก แแแ แแฆแ: 22 2019 แแแแแกแก,
OpenShift แจแแแแแแ GitLab-แแก แแแกแขแแแแชแแแกแแแแก
แแคแแชแแแแฃแ แ โ แ แแแแแแแแแแฃแแ แแแแแแ Kubernetes-แแ GitLab-แแก แแแกแแจแแแแแ, แแแ แจแแ แแก .
GitLab-แแก แแแกแขแแแแชแแ แแแซแแแแแแฃแแแ แแ แแฆแแ แแฅแแแแ แแฎแแ แแแญแแ แแแ .
แฌแแจแแแก แแแ แแฆแ: 22 2019 แแแแแกแก,
แฃแกแแคแ แแฎแแแแแก แกแแแฃแจแแแแแแก แฌแแแ แแแแแแ แขแแแแแ
แจแแกแแแแแแ แกแแแฃแจแแแก แแแแแกแแแแ แ แฌแแแ แแแคแแแแชแแ แแแซแแแแแแแ แแ แฌแแแจแแแแ GitLab 12.0 แแ แฃแคแ แ แแแแแ.
แแแแแแฎแแแ แแฅแแแแ แกแแแฃแจแแแก แแแแแแ แขแแแแแ, แ แแ แแแแแแงแแแแ แแฎแแแ แกแแแขแแฅแกแ แแ แแกแแ แแแแแแ GitLab-แแก แแแแ แแแฌแแแแแฃแแ แฃแกแแคแ แแฎแแแแแก แงแแแแ แแฎแแแ แคแฃแแฅแชแแแ.
แฌแแจแแแก แแแ แแฆแ: 22 แฌแแแก 2019 แแแแแกแ
แกแแกแขแแแแก แแแคแแ แแแชแแแก แแแแงแแคแแแแแ แแแแแแแกแขแ แแชแแฃแ แแแแแแจแ
GitLab แฌแแ แแแแแแแแแ แแแคแแ แแแชแแแก แแฅแแแแ GitLab แแแกแขแแแชแแแก แจแแกแแฎแแ admin/system_info, แแแแ แแ แแก แแแคแแ แแแชแแ แจแแแซแแแแ แแ แแงแแก แแฃแกแขแ.
แฉแแแ แแแแแแแกแขแ แแชแแฃแแ แแแแแแ GitLab 12.0-แจแ แแ แฉแแแ แแแ แฉแแแ แแแแแแงแแแแ .
แฌแแจแแแก แแแ แแฆแ: 22 2019 แแแแแกแก,
แฌแงแแ แ: www.habr.com