แแแแแจแแแแแก แกแแคแฃแซแแแแแ แกแชแแแแก แจแแแแฎแแแก แแฎแแแ แแ แฅแแขแแฅแขแฃแ แ แแ แแ แแแ แแแแแฅแชแแแแแ แแก แแฃแจแแแแแก แแแขแแแแแแชแแ (Stapel แแ Dockerfile). แแฎแแแ แจแแแแฎแแแก แแ แฅแแขแแฅแขแฃแ แ แฎแกแแแก แแแแแฌแแแแแฃแแ แแกแแแแแแแแแก แแแแฎแแ แชแแแแแแแก แจแแกแแซแแแแแแแแก แแ แแแแแ แฐแแกแขแแแแ แแ แแแ แแแแแฃแ แ แแกแแแแแแแแแแแ แแแแแ แฐแแกแขแแ.
แกแแแฃแจแแแก แแแขแแแแแแชแแ แแแแชแแแก แแ แแกแแญแแ แ แแแแแแแแแแแกแแแ แแแแแก แแแฆแฌแแแแก แแขแแแแก แฎแแแแแฌแแ แแแแก แแแแแแแ แแจแแแแก แแขแแแแ แแ แคแแแแแแแก แจแแแแฌแแแแแก แแแแแแแ แแจแแแแก แแแฅแแแแแแแแแก แจแแชแแแแก แฃแคแ แ แแคแแฅแขแฃแ แแ. แแก แแแขแแแแแแชแแ แแแชแแ แแแก แแ แแแฅแขแแก แแจแแแแแแก แกแแจแฃแแแ แแ แแก werf-แแก แแแแแงแแแแแแ. แแ idle builds, แ แแแแกแแช แงแแแแ แแขแแแ แแ แกแแแแแก แฅแแจแจแ แแขแแแแแ-แจแแแแฎแแ, แแฎแแ แแแแแแแแแ แกแฌแ แแคแแแ แแ แแแ. แฃแแแขแแก แจแแแแฎแแแแแจแ, build-แแก แแแแแขแแแ แแแแก 1 แฌแแแแ แแแแแแแ แแแกแญแแ แแแแ! แแก แแกแแแ แแฎแแแ แแฃแแแแแแก แแฃแจแแแแแก แแ แแชแแกแจแ แแขแแแแแแก แแแแแแแฌแแแแแก แแ แแชแแแฃแ แแแก. werf deploy
ะธ werf run
.
แแกแแแ แแ แแแแแจแแแแแจแ แแแแแฉแแแ แกแขแ แแขแแแแ แกแฃแ แแแแแแก แจแแแแแ แกแแก แแแฎแแแแแ แแแแแจแแแแกแแแแก - แจแแแแแ แกแแ แแแคแฃแซแแแแฃแแ แขแแแแ แแแ, แ แแแแแแช แแฎแแ แฉแแ แแฃแแแ แแแแฃแแแกแฎแแแแแ แแ แแ แแแแแ แแ แ แแแแแแแแแ แแแฃแแแ.
แแแแแ แฃแคแ แ แแแขแแแฃแ แแ แแแแแแฎแแแแ werf v1.1-แแก แซแแ แแแแแ แแแแแแชแแแแ แแ แแแแแแ แแฃแแแ แแแแแงแแแ แกแแแแแแแแ แแแแแแแแก แจแแกแแฎแแ.
แ แ แจแแแชแแแแ werf v1.1-แจแ?
แแฎแแแ แแขแแแแก แแแกแแฎแแแแแแก แคแแ แแแขแ แแ แแแแแ แแแแ แฅแแจแแแแ แแขแแแแแแก แแ แฉแแแแกแแแแก
แแฎแแแ แกแแกแชแแแ แกแแฎแแแแแแก แแแแแแก แฌแแกแ. แแฎแแ แงแแแแแ แแขแแแแก แแจแแแแแ แฅแแแแก แฃแแแแแแฃแ แกแแกแชแแแ แกแแฎแแแก, แ แแแแแแช แจแแแแแแ 2 แแแฌแแแแกแแแ: แฎแแแแแฌแแ แ (แ แแแแ แช แแก แแงแ v1.0-แจแ) แแแฃแก แฃแแแแแแฃแ แ แแ แแแแแแ แแแแแขแแคแแแแขแแ แ.
แแแแแแแแแ, แกแ แฃแแ แกแชแแแแก แกแฃแ แแแแก แกแแฎแแแ แจแแแซแแแแ แแกแ แแแแแแงแฃแ แแแแแแก:
werf-stages-storage/myproject:d2c5ad3d2c9fcd9e57b50edd9cb26c32d156165eb355318cebc3412b-1582656767835
แแ แกแแแ แแแ:
werf-stages-storage/PROJECT:SIGNATURE-TIMESTAMP_MILLISEC
ะะดะตัั:
-
SIGNATURE
แแ แแก แกแแกแชแแแ แฎแแแแแฌแแ แ, แ แแแแแแช แฌแแ แแแแแแแแก แกแแกแชแแแ แจแแแแแ แกแแก แแแแแขแแคแแแแขแแ แก แแ แแแแแแแแแแฃแแแ Git-แจแ แ แแแแฅแขแแ แแแแก แแกแขแแ แแแแ, แ แแแแช แแแแแแฌแแแ แแก แจแแแแแ แกแ; -
TIMESTAMP_MILLISEC
แแ แแก แแแ แแแขแแ แแแฃแแ แฃแแแแแแฃแ แ แแแแแกแแฎแฃแแแแแก แแแแแขแแคแแแแขแแ แ, แ แแแแแแช แแฅแแแแแ แแฎแแแ แกแฃแ แแแแก แแแแแแก แแ แแก.
แฅแแจแแแแ แแขแแแแแแก แแ แฉแแแแก แแแแแ แแแแ แแแงแแ แแแ Git-แแก แแแแแแแแแแแก แฃแ แแแแ แแแแแก แจแแแแฌแแแแแก:
- แแแ แคแ แแแแแแก แแแ แแแแฃแแ แแขแแแแก แฎแแแแแฌแแ แแก.
- ะ แแขแแแแแ-แจแแแแฎแแ แแแชแแแฃแแ แฎแแแแแฌแแ แแกแแแแก แจแแแซแแแแ แแงแแก แ แแแแแแแแ แแขแแแ. Werf แแ แฉแแแก แงแแแแ แแขแแแก, แ แแแแแแช แจแแแกแแแแแแแ แฎแแแแแฌแแ แแก.
- แแฃ แแแแแแแแ แ แแขแแแ แแแแแแจแแ แแแฃแแแ Git-แแแ (git-แแ แฅแแแ, แแแ แแแแฃแแ แแขแแแ Git แแแขแฉแแแแ:
install
,beforeSetup
,setup
; แแ git-latest-patch), แจแแแแแ werf แแ แฉแแแก แแฎแแแแ แแ แแขแแแแแก, แ แแแแแแแช แแกแแชแแ แแแแ commit-แแแ, แ แแแแแแช แแ แแก แแแแแแแแ แ commit-แแก แฌแแแแแแ แ (แ แแกแแแแกแแช build แแฌแแแแแ). - แแแ แฉแแแแแ แจแแกแแคแแ แแกแ แแขแแแแแแแแ แแ แฉแแฃแแแ แแ แแ - แงแแแแแแ แซแแแแ แจแแฅแแแแก แแแ แแฆแแ.
Git-แแก แกแฎแแแแแกแฎแแ แคแแแแแแแก แกแชแแแแก แจแแแซแแแแ แฐแฅแแแแแก แแแแแ แฎแแแแแฌแแ แ. แแแแ แแ werf แฎแแแก แจแแฃแจแแแก แกแฎแแแแแกแฎแแ แคแแแแแแแแแแ แแแแแแจแแ แแแฃแแ แฅแแจแแก แแแแแงแแแแแแก แแ แคแแแแแแแแก แจแแ แแก, แแแจแแแแช แแ, แแฃ แฎแแแแแฌแแ แแแ แแแแฎแแแแ.
แแฎแแแ แแแแแ แแแแ แกแแกแชแแแ แกแแชแแแจแ แแขแแแแแแก แจแแฅแแแแกแ แแ แจแแแแฎแแแกแแแแก
แแฃ แฅแแจแแแแ แแขแแแแแแก แจแแ แฉแแแแกแแก werf แแแ แแแฃแแแแก แจแแกแแคแแ แแก แแขแแแก, แแแจแแ แแฌแงแแแ แแฎแแแ แแขแแแแก แแฌแงแแแแก แแ แแชแแกแ.
แแแแแแแแแกแฌแแแแ, แ แแ แแ แแแแ แแ แแชแแกแก (แแ แ แแ แแแข แฐแแกแขแแ) แจแแฃแซแแแ แแแแฌแงแแก แแ แแ แแ แแแแแ แแขแแแแก แแแแแ แแแแฎแแแแแแ แแ แแกแ แแ แแแแแ แแ แแก. Werf แแงแแแแแก แแแขแแแแกแขแฃแ แแแแแแแแแก แแแแแ แแแแก แแขแแแแแ-แจแแแแฎแแ แแฎแแแ แจแแแ แแแแแฃแแ แกแฃแ แแแแก แจแแแแฎแแแก แแแแแแขแจแ แแขแแแแแ-แจแแแแฎแแ. แแ แแแแ, แ แแแแกแแช แแฎแแแ แแขแแแแก แแฌแงแแแ แแแแ แแฅแแแแ, แแแ แคแแก แแแแแแแ แแขแแแแแ-แจแแแแฎแแ แแ แแแแฎแแแก แแฎแแแ แจแแแ แแแแแฃแ แกแฃแ แแแก แแฅ แแฎแแแแ แแ แจแแแแฎแแแแแจแ, แแฃ แจแแกแแแแแแกแ แกแฃแ แแแ แแฅ แแฆแแ แแ แกแแแแแก (แฎแแแแแฌแแ แแ แแ แกแฎแแ แแแ แแแแขแ แแแแ - แแฎแแแแ แแฎแแแ แแแแแ แแแแ แฅแแจแแแแ แแขแแแแแแก แแ แฉแแแแกแแแแก).
แแฎแแแ แแฌแงแแแแ แกแฃแ แแแก แแแ แแแขแแ แแแฃแแ แแฅแแก แฃแแแแแแฃแ แ แแแแแขแแคแแแแขแแ แ TIMESTAMP_MILLISEC
(แแฎแแแแ แแฎแแแ แแขแแแแก แแแกแแฎแแแแแแก แคแแ แแแขแ). แแ แจแแแแฎแแแแแจแ, แแฃ in แแขแแแแแ-แจแแแแฎแแ แแแแซแแแแแแ แจแแกแแคแแ แแกแ แกแฃแ แแแ, werf แแแแแแแแแแก แแฎแแแ แจแแแแแแแ แกแฃแ แแแก แแ แแแแแแงแแแแแก แกแฃแ แแแก แฅแแจแแแแ.
แกแฎแแ แกแแขแงแแแแแ แ แแ แแแฅแแแ: แกแฃแ แแแแก แแแแแแก แแแกแ แฃแแแแแก แแแ แแแแ แแ แแชแแกแ (แงแแแแแแ แกแฌแ แแคแ) แแแแฆแแแก แฃแคแแแแแก แจแแแแแฎแแก แแแ แแขแแแแแ แแแแ - แจแแแแฎแแ (แแ แจแแแแแ แแก แแ แแ แกแฃแ แแแ แแฅแแแแ แแแแแงแแแแแฃแแ แงแแแแ แแฌแงแแแแกแแแแก). แแแแ แแจแแแแแแแแแก แแ แแชแแกแ แแ แแกแแแแก แแแแแแแแแก แฃแคแ แ แกแฌแ แแค แแ แแชแแกแก แแแแแแแแ แ แแขแแแแก แแจแแแแแแแแแก แจแแแแแแแแก แจแแแแฎแแแจแ แแ แจแแแแแ แแจแแแแแแแแแแ แแแแแกแแแแจแ.
แแแฃแแฏแแแแกแแแฃแแ Dockerfile แจแแแฅแแแแแแก แจแแกแ แฃแแแแ
แแ แแ แแแกแแแแก, Dockerfile-แแแ แแแแแฃแแ แกแฃแ แแแแกแแแแก แแขแแแแแแก แแแแกแแแแแ แจแแแแแแ แแ แแ แแขแแแแกแแแ - dockerfile
. แฎแแแแแฌแแ แแก แแแแแแแ แแจแแแแกแแก แแแแแแแแแแแ แคแแแแแแแก แกแแแแแขแ แแแ แฏแแแ context
, แ แแแแแแช แแแแแงแแแแแฃแแ แแฅแแแแ แแฌแงแแแแก แแ แแก. แแ แแแฃแแฏแแแแกแแแแแแ, werf-แแ แ แแแฃแ แกแแฃแแแ แแแแแ แ แงแแแแ แคแแแแ แแ แแแแฆแ แกแแแแแขแ แแแ แฏแแแ แแแแแแฃแแ แคแแแแแก แแแแขแแฅแกแขแแกแ แแ แ แแแแแแก แจแแฏแแแแแแ. v1.1-แแแ แแแฌแงแแแฃแแ, werf-แก แจแแฃแซแแแ แแแแแแงแแแแก แแแแแแแแแแ แกแแแแแขแ แแแ แฏแแแแแ, แ แแแแแแแช แแแแฎแแแ Git-แแก แกแแชแแแจแ.
แแแแแ แแแแ แแคแฃแซแแแแ .dockerignore
แแ แแแแแก แคแแแแแก แฎแแก แ แแแฃแ แกแแฃแแแ แแฎแแแแ แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ. แแแ แแแแ, แฉแแแ แแแแฃแ แแแแแ แ แคแแแแฃแ แ แกแแกแขแแแแก แฌแแแแแฎแแแก แแ แแแแแ แแแแแก แแแแแแแแแแฃแแแแแก แแแแแแ context
แแ แแ แแก แแแแจแแแแแแแแแ.
แแแแแ แแแแ แแกแแแ แแแแฌแแแแก แแแฃแแแแ แแ แคแแแแแแก แแ แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ, แแแ แแฎแแแแแแแแแจแ แแฆแแแก แกแแแแแขแ แแแ แฏแแแจแ.
แแแฃแแฏแแแแกแแแฃแแ แจแแกแ แฃแแแแ แคแแแแแแแก แแแแแ แขแแกแแก
werf v1.1 แแแ แกแแแแ แแงแแแแแแ rsync แกแแ แแแ แก, แ แแแแกแแช
macOS-แแ แแแแแ แขแแก แจแแกแ แฃแแแแ แแฆแแ แจแแแแแคแแ แแแแแ Docker-แแก แแแชแฃแแแแแ แแ แแแแแ แขแ แกแ แฃแแแแแ แแแแแ แแ แแก, แ แแแแ แช Linux-แกแ แแ Windows-แจแ.
แแแแขแแแขแแ แแแคแฃแซแแแแฃแแ แขแแแแ แแแ
Werf v1.1 แแฎแแ แก แฃแญแแ แก แ.แฌ. แแแแแจแแแแก แกแฃแ แแแแก แจแแแแแ แกแแ - แจแแแแแ แกแแ แแแคแฃแซแแแแฃแแ แขแแแแ แแแ. แแแฆแแแฃแแ Docker แกแฃแ แแแแแแก แขแแแแแ แแแแแแแแแแฃแแแ แแ แกแฃแ แแแแแแก แจแแแแแ แกแแ.
แแ แซแแแแแแก แแแจแแแแแกแแก werf publish --tags-by-stages-signature
แแ werf ci-env --tagging-strategy=stages-signature
แแแแแฅแแแงแแแ แกแฃแ แแแแแ แ.แฌ แกแแกแชแแแ แฎแแแแแฌแแ แ แแแแแกแแฎแฃแแแแ. แแแแแแฃแ แกแฃแ แแแก แแแแแจแแฃแแแ แแ แกแฃแ แแแแก แแขแแแแแแก แกแแแฃแแแ แ แฎแแแแแฌแแ แ, แ แแแแแแช แแแแแแแแแแแ แแแแแ แฌแแกแแแแก แแแฎแแแแแ, แ แแแแ แช แแแแแแฃแแ แแขแแแแก แ แแแฃแแแ แฃแแ แฎแแแแแฌแแ แ แชแแแแ, แแแแ แแ แแ แแก แกแฃแ แแแแก แแแแแแ แแแแแขแแคแแแแขแแ แ.
แแแแแกแแฎแฃแแแแแก แแขแแแแแแก แฎแแแแแฌแแ แ แแแแแแแแแแฃแแแ:
- แแ แกแฃแ แแแแก แจแแแแแ แกแ;
- Git แชแแแแแแแแแแก แแกแขแแ แแ, แ แแแแช แแแแแแฌแแแ แแก แจแแแแแ แกแ.
Git แกแแชแแแจแ แงแแแแแแแแก แแ แแก แแแฉแแแแแแแแ แแแแแแแฃแแแแแแ, แ แแแแแแแช แแ แชแแแแก แแแแแกแแฎแฃแแแแแก แคแแแแแแแก แจแแแแแ แกแก. แแแแแแแแแ, แแแแแแแแแแ แแฎแแแแ แแแแแแขแแ แแแแ แแ แจแแ แฌแงแแแก แแแแแแแแแแแ, แแ แแแแแแแฃแแแแแแ, แ แแแแแแแช แชแแแแก แแ แคแแแแแแก Git-แจแ, แ แแแแแแแช แแ แแฅแแแแ แแแแแ แขแแ แแแฃแแ แกแฃแ แแแจแ.
แจแแแแแ แกแแ แแแคแฃแซแแแแฃแแ แขแแแแก แแแแแงแแแแแแกแแก, Kubernetes-แจแ แแแแแแแชแแแก แแแแแแแก แแ แแกแแญแแ แ แแแแแขแแแ แแแแก แแ แแแแแแแแ แแแแแแ แแแฃแแแ แกแฃแ แแแแก แกแแฎแแแแก แชแแแแแแแแก แแแแ, แแแจแแแแช แแ, แแฃ แกแฃแ แแแแก แจแแแแแ แกแ แแ แจแแชแแแแแ. แกแฎแแแแ แจแแ แแก, แแก แแ แแก แแ แ-แแ แแ แแแแแแ, แ แแแแแแช แฎแแแก แฃแจแแแก แแ แแ แแแแแแแชแแแก แแ แแแแแ แแแแ แแกแแ แแแกแแก แแ แ Git แกแแชแแแจแ แจแแแแฎแแแก.
แแกแแแ, แแแแขแแแขแแ แแแคแฃแซแแแแฃแแ แขแแแแ แแแ แฃแคแ แ แกแแแแแแ แแแแแก แแแแแแแ, แแแแ แ Git-แแก แขแแขแแแแ แแแแแจแแแ, แ แแแแแ แแแฆแแแฃแแ แกแฃแ แแแแแแก แจแแแแแ แกแ แแ แแ แแก แแแแแแแแแแฃแแ แแแแแ, แแฃ แ แ แแแแแแแแแแ แแแแ แจแแกแ แฃแแแแแ แแแแกแแแแแแแ CI แกแแกแขแแแแจแ แแ แแ แแ แแแแแ แคแแแแแแแก แแ แแแแแฏแแ แแแ แแแแแแแแแแแก แแฌแงแแแแกแแแแก.
แแแแจแแแแแแแแแแ: แแฆแแแแแ แแขแแแแแ-แฎแแแแแฌแแ แ - แ แแแแแแแ แแแแแ แแแแก แแ แแแแแ แแ แ แแแแแแแแแแฃแแ แกแขแ แแขแแแแ. แแก แแแแฃแแแกแฎแแแแแ แแแแแงแแแแแฃแแ แแฅแแแแ แแ แซแแแแแแจแ werf ci-env
(แแฃ แชแแแกแแฎแแ แแ แแแฃแแแแแแ แแแแแจแแแแก แกแฎแแ แกแฅแแแแก).
แจแแกแแแแก แแแแแแแ
แแแแฎแแแ แแแแแก แแฎแแ แแฅแแก แจแแกแแซแแแแแแแ แแแแแแแขแ แแแแก แแแแแแแแแแ, แแแแงแแแแก แแฃแ แแแแแก แแแแ แแ แแแฃแจแแแก แแแแแ แแแแก แแแคแแ แแแชแแแกแแแ. แแแแแขแแแฃแแแ แแแ แแแแขแ แแแ --log-quiet
, --log-verbose
, --log-debug
.
แแแแฃแแแกแฎแแแแแ, แแแแแแแแแแ แจแแแชแแแก แแแแแแแแฃแ แแแคแแ แแแชแแแก:
แกแแขแงแแแแ แ แแแแแแแแแแ แแแแแงแแแแแแกแแก (--log-verbose
) แจแแแแซแแแแ แแแฎแแ แ แแแแ แแฃแจแแแแก werf:
แแแขแแแฃแ แ แแแแแแแแแแ (--log-debug
), แแแ แแ werf แแแแแ แแแแก แแแคแแ แแแชแแแกแ, แแกแแแ แจแแแชแแแก แแแแแงแแแแแฃแแ แแแแแแแแแแแแแก แแฃแ แแแแแแก. แแแแแแแแแ, แแฅแแแ แฎแแแแแ, แแฃ แ แแแแ แฎแแแแ แฃแ แแแแ แแฅแแแแแแ Docker Registry-แแแ แแ แแกแแแ แฉแแฌแแ แแ แแแแแแแแ, แกแแแแช แแฎแแ แฏแแแ แแแแจแแแแแแแแแ แแ แ:
แจแแแแแแแ แแแแแแแ
แงแฃแ แแแฆแแแ แฅแแแแแ แแฆแฌแแ แแแ แแแ แแแแขแแแ แแแแแจแแฃแแแ v1.1 แฎแแแแแกแแฌแแแแแ แแแฎแแแแ แแ แแแ แกแแแจแ, แแแแ แ แแแแแแแ แฃแแฎแแแแก แแแแแแแแจแ. แแแแแฎแแแแแแ แแแฎแแแแ แแแขแแแแขแฃแ แ แแแแแฎแแแแแก แกแแจแฃแแแแแแ
แกแ แฃแแ แแฎแแ แแแญแแ แ Docker Registry-แแก แกแฎแแแแแกแฎแแ แแแแแ แแแแกแแแแก (แแฎแแแ)
- แแแ แกแแ: v1.1
- แแแ แแฆแแแ: แแแ แขแ
-
Issue
แแแแแแแ แแแแฎแแแ แแแแแแ แแแแแแงแแแแก แแแ แแแแฃแแ แแแแแแแแแขแแชแแ แจแแแฆแฃแแแแแแก แแแ แแจแ werf-แแก แแแแแงแแแแแแกแแก.
แแแแแแแ, แฉแแแ แแแแแแแแแแแแ แแแแแฌแงแแแขแแแแแแแแก แจแแแแแแ แแแแ แแแ, แ แแแแแกแแแแกแแช แแแแแ แแแ แกแ แฃแแ แแฎแแ แแแญแแ แแก แแแ แแแขแแแก:
- แแแแฃแแแกแฎแแแแ (แแแแแแแแแแ/แ แแแกแขแ แ)*,
- AWS ECR
- แชแแกแคแแ แ *,
- Docker Hub
- GCR*,
- GitHub แแแแแขแแแ
- GitLab Registry*,
- Harbor *,
- แแแ.
แแแแแฌแงแแแขแแแแแแแ, แ แแแแแแแช แแแแแแแ แกแ แฃแแแ แแ แแก แแฎแแ แแแญแแ แแแ werf-แแก แแแแ , แแฆแแแแจแแแแ แแแ แกแแแแแแแ. แกแฎแแแแแกแแแแก แแ แแก แแฎแแ แแแญแแ แ, แแแแ แแ แจแแแฆแฃแแแแแแ.
แแ แ แซแแ แแแแแ แแ แแแแแแแก แแแแแขแแคแแชแแ แแแ แจแแแซแแแแ:
- แแแแแแ แแ แแแแแฌแงแแแขแ แแ แฃแญแแ แก แแฎแแ แก แแแแแก แแแแฆแแแแก Docker Registry API-แแก แแแแแงแแแแแแ, แ แแช แแแแฎแแแ แแแแแแก แฃแจแแแก แฎแแแก werf-แแก แแแขแแแแขแฃแ แ แแแกแฃแคแแแแแแแก แแแแแงแแแแแแจแ. แแก แแแ แแแแแ AWS ECR, Docker Hub แแ GitHub แแแแแขแแแแกแแแแก.
- แแแแแแ แแ แแแแแฌแงแแแขแ แแ แฃแญแแ แก แแฎแแ แก แแแ แแ แฌแแแแแฃแ แฉแแแแแฃแ แกแแชแแแแแก (Docker Hub, GitHub Packages แแ Quay), แแแแ แแ แแแแฎแแแ แแแแแแ แฃแแแ แจแแฅแแแแก แแกแแแ แฎแแแแ UI แแ API (AWS ECR) แแแแแงแแแแแแ.
แฉแแแ แแแแแ แแแ แแ แแ แกแฎแแ แแ แแแแแแแแแก แแแแแญแ แแก แแแแแฌแงแแแขแแแแแแแแก แแจแแแแแฃแ แ API-แแแแก แแแแแงแแแแแแ. แแก แแแแชแแแ แแกแแแ แแแแชแแแก werf แแแแ แแชแแแก แกแ แฃแแ แชแแแแแก แแแคแแ แแแก แแแแแแฃแแ แแแแแแแแก แขแแกแขแแแแ.
แแแแแฌแแแแแฃแแ แแแแแกแแฎแฃแแแแแก แแแแแ (โ)
- แแแ แกแแ: v1.2 v1.1 (แแ แคแฃแแฅแชแแแก แแแแฎแแ แชแแแแแแแก แแ แแแ แแขแแขแ แแแแแแ แแ)
- แแแ แแฆแแแ: แแแ แขแ-แแแ แแแ แแแ แขแ
-
Issue
แแ แแ แแแกแแแแก, werf v1.0 แแ v1.1 แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแฎแแแแ แแ แ แกแแแชแแแแฃแ แฐแแกแขแแ แกแฃแ แแแแแแก แแจแแแแแแกแ แแ แแแแแฅแแแงแแแแแก แแแแ แแชแแแแแกแแแแก แแ แแแแแแแชแแแก Kubernetes-แจแ แแแแกแแแแแกแแแแแ.
werf-แแก แแแแแฌแแแแแฃแแ แแฃแจแแแแแก แจแแกแแซแแแแแแแแแแก แแแกแแฎแกแแแแแ, แ แแแแกแแช Kubernetes-แจแ แแแแแแแชแแแแแก แแแแแ แแ แแแแแแแกแแแ แแแจแแแแฃแแแ แ แแแแแแแแ แแแแแแแแฃแ แฐแแกแขแแ แแ แแก แฐแแกแขแแแ แแ แแแแฎแแแแ แแแแแแแ แแแแแแแ แแแแแก แแแแแแแแแแก แจแแ แแก (แแ แแแแแแ แแแ แแแแแแ), werf-แก แแแแแฎแแแแแ แแแแแงแแแแแแก แฃแแแ แ. Docker Registry, แ แแแแ แช แกแแกแชแแแ แแแฆแแแแ.
แแแ แ, แ แแชแ werf-แแก แแ แแแฅแขแก แฏแแ แแแแแ dapp แแ แฅแแ, แแแก แฐแฅแแแแ แแกแแแ แจแแกแแซแแแแแแแ. แแฃแแชแ, แฉแแแ แจแแแฎแแแแ แแแแ แ แแ แกแแแแแฎแแแก, แ แแแแแแแช แแแกแแแแแแแกแฌแแแแแแแแ werf-แจแ แแ แคแฃแแฅแชแแแก แแแแฎแแ แชแแแแแแแกแแก.
แจแแแแจแแแ. แแก แคแฃแแฅแชแแ แแ แแแแแฎแแแก แแแแแฅแชแแแแแ แก แแฃแจแแแแแก Kubernetes pods-แจแ, แ แแแแแ แแแแกแแแแแก แแฅแแแ แฃแแแ แแแแแแแแกแฃแคแแแแ แแแแแแแแแแฃแแแแแกแแแ แแแแแแแแ แแ Docker แกแแ แแแ แแ (Kubernetes pod-แจแ แแ แแ แแก แฌแแแแแ แแแแแแแแ แแ Docker แกแแ แแแ แแ, แ แแแแแ แแแแแ แแ แแชแแกแ แแแแแแแแ แแแแก แแแแขแแแแแ แจแ แแ werf แแ แแฅแแก แแ แแ แฃแญแแ แก แแฎแแ แก แแฃแจแแแแ Docker แกแแ แแแ แแแ แฅแกแแแจแ). Kubernetes-แแก แแแจแแแแแก แแฎแแ แแแญแแ แ แแแแฎแแ แชแแแแแแแ แชแแแแ.
GitHub Actions-แแก แแคแแชแแแแฃแ แ แแฎแแ แแแญแแ แ (แแฎแแแ)
- แแแ แกแแ: v1.1
- แแแ แแฆแแแ: แแแ แขแ
-
Issue
แแแงแแแแ werf แแแแฃแแแแขแแชแแ (แกแแฅแชแแแแ แแแแแจแแแแ ะธ แฃแฎแแแแซแฆแแแแแแแแก), แแกแแแ แแคแแชแแแแฃแ แ GitHub Action werf-แแแ แแฃแจแแแแแกแแแแก.
แแแ แแ แแแแกแ, แแแ แกแแจแฃแแแแแแก แแแกแชแแแก แแแ แคแก แแแฃแจแแแก แแคแแแแ แฃแ แแแ แแแแแแแแแ.
แแแแฎแแแ แแแแแก แฃแ แแแแ แแฅแแแแแแแก แแแฅแแแแแแ CI แกแแกแขแแแแกแแแ แแแคแฃแซแแแแฃแแ แแฅแแแแ แแขแแแแขแแแแก แแแแแแแกแแแแแ pull-แแก แแแแฎแแแแแแแ แแแ แแแแฃแแ แแแฅแแแแแแแแแก แแแกแแฌแงแแแแ แแแแแแแชแแแก แจแแกแแฅแแแแแแ/แแแกแแจแแแแแ.
แแแแแแแชแแแแแก แแแแแแฃแ แ แแแแแแแแ แแแ แแ แแแแแแแกแแแ werf-แแ (โ)
- แแแ แกแแ: v1.1
- แแแ แแฆแแแ: แแแแแแ แ-แแแแแ แแแแ แแแ แแแ
-
Issue
แแแแแแ แ แแแแแแแ แแแแแฆแฌแแแ แแ แแแแ แแแแคแแแฃแ แแชแแแก แแแแแแแชแแแแแก แแแแแแแแแแกแแแแก, แ แแแแ แช แแแแแแฃแ แแ, แแกแ แฌแแ แแแแแแจแ, แ แแฃแแ แแแฅแแแแแแแแแก แแแ แแจแ, แแแ แแ.
werf-แก แแกแแแ แแแแแฎแแแแแ แแฃแจแแแแแก แ แแแแแ, แ แแแแแจแแช แแแกแแฎแแ แฎแแแแแ แแฅแแแแ แแแแแแแชแแแก แแแแแก แ แแแแฅแขแแ แแแ แแ แแงแแกแแแ แ แแแแแฎแแแฃแ แแแแก แแแฆแแแ แแแจแแแแฃแแ แแแแแแแชแแแแแ แแแแแ แแแแกแแแแก.
แแแกแฃแคแแแแแแแก แแฎแแแ แแแแแ แแแแ (แแฎแแแ)
- แแแ แกแแ: v1.1
- แแแ แแฆแแแ: แแแ แแแ
-
Issue
แแแแแแแแ แ แแแ แกแแแจแ werf v1.1 แแ แแชแแแฃแ แแจแ cleanup
แแ แแ แแก แแแแแแแแกแฌแแแแแฃแแ แกแฃแ แแแแแแก แแแฌแแแแแ แแแแขแแแขแแ แแแคแฃแซแแแแฃแแ แแแแแก แกแฅแแแแกแแแแก - แแก แกแฃแ แแแแแ แแแแ แแแแแแ.
แแกแแแ, werf-แแก แแแแแแแแแแแ แแแ แกแแ (v1.0 แแ v1.1) แแงแแแแแก แกแฎแแแแแกแฎแแ แแแฌแแแแแแก แแแแแขแแแแก แแแแแ แแแแก แกแฅแแแแแแ แแแแแฅแแแงแแแแฃแแ แกแฃแ แแแแแแกแแแแก: Git branch, Git tag แแ Git commit.
แแแแแแแแแแก แกแฃแ แแแแแแก แแแฌแแแแแแก แแฎแแแ แแแแแ แแแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ Git-แจแ แฉแแแแแแแแก แแกแขแแ แแแแ, แ แแแแแแช แแแแ แแแแแแแฃแแแ แขแแแแก แงแแแแ แกแฅแแแแกแแแแก:
- แจแแแแแฎแแ แแ แแฃแแแขแแก N1 แแแแแกแแฎแฃแแแแแแ, แ แแแแแแแช แแแแแแจแแ แแแฃแแแ N2-แแก แฃแแฎแแแก แฉแแแแ แแแแแแแ แแแแแแฃแแ git HEAD-แแกแแแแก (แขแแขแแแ แแ แขแแแแแ).
- แจแแแแแฎแแ แแ แแฃแแแขแแก N1 แแขแแแแก แกแฃแ แแแแแ, แ แแแแแแแช แแแแแแจแแ แแแฃแแแ N2-แแก แฃแแฎแแแก แแแกแ แฃแแแแแแแแ แแแแแแฃแแ git HEAD-แแกแแแแก (แขแแขแแแ แแ แขแแแแแ).
- แจแแแแแฎแแ แงแแแแ แกแฃแ แแแ, แ แแแแแแช แแแแแแงแแแแแ Kubernetes-แแก แแแแกแขแแ แฃแ แ แแกแฃแ แกแแแจแ (แแแแคแแแฃแ แแชแแแก แคแแแแแก แงแแแแ kube แแแแขแแฅแกแขแ แแ แกแแฎแแแแ แกแแแ แชแ แแแกแแแแแ แแแฃแแแ; แจแแแแซแแแแ แจแแแฆแฃแแแ แแก แฅแชแแแ แกแแแชแแแแฃแ แ แแแ แแแแขแแแแ).
- แจแแแแแฎแแ แงแแแแ แกแฃแ แแแ, แ แแแแแแช แแแแแแงแแแแแ แ แแกแฃแ แกแแก แแแแคแแแฃแ แแชแแแก แแแแแคแแกแขแแแจแ, แ แแแแแแแช แจแแแแฎแฃแแแ Helm-แแก แแแแแจแแแแแแจแ.
- แกแฃแ แแแ แจแแแซแแแแ แฌแแแจแแแแก, แแฃ แแก แแ แแ แแก แแกแแชแแ แแแฃแแ git-แแก แ แแแแแแแ HEAD-แแแ (แแแแแแแแแ, แแแแขแแ, แ แแ แแแแแ แจแแกแแแแแแกแ HEAD แฌแแแจแแแ) แแ แแ แแแแแแงแแแแแ แแฃแแแ แแแขแแก แแแแกแขแแ แจแ แแ Helm-แแก แแแแแจแแแแแแจแ แแ แชแแ แ แแแแแคแแกแขแจแ.
แแแ แแแแแฃแ แ แแแแแกแแฎแฃแแแแแก แแแแแ (โ)
- แแแ แกแแ: v1.1
- แแแ แแฆแแแ: แแแแแแ แ-แแแแแ แแแแ แแแ แแแ*
werf-แแก แแแแแแแแแแแ แแแ แกแแ แแแ แแแแแก แแฆแฌแแ แแ แกแฃแ แแแแแกแ แแ แแ แขแแคแแฅแขแแแก werf.yaml
, แแแแแแแแแแ แแแแ. แแฃแชแแแแแแแแ แกแฃแ แแแแแแกแ แแ แแ แขแแคแแฅแขแแแแก แแแแแฃแแแแแแแแ แแขแแแแแแก แแฌแงแแแแก แแ แแชแแกแแก แแแ แแแแแแแแแ, แแกแแแ แแแกแแฎแแ แฎแแแแแ แแ แแแคแแ แแแชแแฃแแ แจแแแแแแก แฃแแ แฃแแแแแงแแคแ.
* แจแแแแจแแแ: แแแแ แแแแแแแแชแแแ แแแแแฌแแแแแฃแแ แแกแแแแแแแก แแแแฎแแ แชแแแแแแแก แแแแ แแแแ แแ แแแ แแขแแขแแก แแแแ, แ แแช แแแแแแขแแแก แฐแแ แแแแแขแแแฃแ แแแกแจแขแแแแ แแแแก แจแแกแแซแแแแแแแแแก, แแกแแแ werf-แแก แแแแแงแแแแแแก GitHub Actions-แแ. แแแ แแแแแฃแ แ แจแแแ แแแ แแ แแก แแแขแแแแแแชแแแก แจแแแแแแ แแแแแฏแ, แ แแแแแแช แฃแแ แฃแแแแแงแแคแก แแแ แขแแแแแฃแ แแแกแจแขแแแฃแ แแแแก แแ แแ แแ แแแฅแขแแก แแฌแงแแแแกแแก.
แแแแแกแแแ Helm 3-แแ (โ)
- แแแ แกแแ: v1.2
- แแแ แแฆแแแ: แแแแแ แแแแ-แแแ แขแ แแแแกแ*
แแแแชแแแก แแแแ แแชแแแก แแฎแแ แแแแแแแก แแแแแแ
* แจแแแแจแแแ: Helm 3-แแ แแแแแ แแแ werf-แก แแ แแแแแแขแแแก แแแแจแแแแแแแแ แคแฃแแฅแชแแแแก, แ แแแแแ Helm 3-แแก แงแแแแ แซแแ แแแแแ แแแฎแแกแแแแแแแแ (3-แแแแก แจแแ แฌแงแแ แแ แขแแแแ แแก แแแ แแจแ) แฃแแแ แแแแแ แแแแแ werf-แจแ. แฃแคแ แ แแแขแแช, werf-แก แแฅแแก
Jsonnet Kubernetes-แแก แแแแคแแแฃแ แแชแแแก แแฆแฌแแ แแกแแแแก (โ)
- แแแ แกแแ: v1.2
- แแแ แแฆแแแ: แแแแแแ แ-แแแแแ แแแแ แแแ แแแ-แแแแกแ
Werf แแฎแแ แก แแแฃแญแแ แก Kubernetes-แแก แแแแคแแแฃแ แแชแแแก แแฆแฌแแ แแแแแแแก Jsonnet แคแแ แแแขแจแ. แแแแแแ แแฃแแแ, werf แแแ แฉแแแ Helm-แแแ แแแแกแแแแแ แแ แแฅแแแแ แแฆแฌแแ แแก แคแแ แแแขแแก แแ แฉแแแแแ.
แแแแแแ แแก แแ แแก, แ แแ Go แจแแแแแแแแก, แแแแ แ แแแแแแแแแก แแแ แแ, แแแฆแแแ แจแแกแแแแก แแแ แแแ แ แแฅแแก แแ แแ แจแแแแแแแแแก แแแแแก แแแแแแแช แแแ แแแแแแ.
แแกแแแ แแแแแฎแแแแแ Kubernetes-แแก แแแแคแแแฃแ แแชแแแก แแฆแฌแแ แแก แกแฎแแ แกแแกแขแแแแแแก (แแแแแแแแแ, Kustomize) แแแแแ แแแแก แจแแกแแซแแแแแแแ.
แแฃแจแแแแ Kubernetes-แจแ (โ)
- แแแ แกแแ: v1.2
- แแแแแแ: แแแ แแแ-แแแแกแ แแแแกแ-แแแแแกแ
แแแแแแ: แแแ แฌแแฃแแแแ, แ แแ แกแฃแ แแแแแ แแแแแฃแแแ แแ แแแแแแแชแแ แแแฌแแแแแฃแแแ Kubernetes-แแก แแแ แแแแแแแแแ. แแแแ. แแฎแแแ แกแฃแ แแแแแแก แแแแแ, แแแแแฅแแแงแแแแ, แแแฌแแแแแ แแ แแแแแแแกแแแ แจแแกแแซแแแแแแแ แแแ แแแแแ Kubernetes pods-แแแ.
แแ แจแแกแแซแแแแแแแแก แแแแกแแฎแแ แชแแแแแแแแ, แฏแแ แฃแแแ แจแแซแแแ แแแแแฌแแแแแฃแแ แกแฃแ แแแแแแก แจแแฅแแแ (แแฎ. แแฃแแฅแขแ แแแแแ).
แแก แแกแแแ แแแแแฎแแแก แแจแแแแแแแก แแแแ แแชแแฃแแ แ แแแแแแก แแฎแแ แแแญแแ แแก Docker แกแแ แแแ แแก แแแ แแจแ (แแแฃ Kaniko-แก แแกแแแแกแ build แแ build แแแแฎแแแ แแแแแแ แกแแแ แชแแจแ).
Werf แแฎแแ แก แแแฃแญแแ แก Kubernetes-แแ แแจแแแแแแแแแก แแ แ แแฎแแแแ Dockerfile-แแ, แแ แแแแ Stapel-แแก แแจแแแแแแแแแแ แแ แแแ แแแแแขแแแแแ แ แแแแแกแขแ แฃแฅแชแแแ แแ Ansible-แแ.
แแแแแฏแ แฆแแ แแแแแแแแ แแแแกแแแ
แฉแแแ แแแแงแแแ แก แฉแแแแ แกแแแแแแแแแแ (
แกแฃแ แแฎแแแฎแแแก แแแแแฌแงแแ แแแแแกแแแ
-
แแแแฃแแแแขแแชแแ แแ แกแแแขแ ; -
แขแแกแขแแ แแแ ; -
แจแแชแแแแแแ แแ แชแฃแแ UX ; -
1.1 .
แแแแ แ แกแแแฃแจแแ แแแแแแแ แกแแแแแฎแแแแ:
- แแแแฆแแแฃแแแ แจแแฃแกแแแแแแแแ.
- แแ แกแแแฃแแแแ แแแงแแแแแแแ แแ แแแแ แคแแ แแแขแจแ, แกแแแแแ แแกแ แ แแแแแแแแแก แแแขแแแแแแแ แแ แแแขแแแแแแ.
- แแแแแแขแ แแฎแแแ แกแแแแแฎแแแ แแแแแแแแ แแ แฌแแแแแแแแแแแแ.
แ แแแแ แฉแแ แแแ แแแ แกแแ v1.1
แแแ แกแแ แแแแแแแ แฎแแแแแกแแฌแแแแแแ
source $(multiwerf use 1.1 ea)
werf COMMAND ...
แแแกแแแแ
แแฎแแแ แแขแแแแก แจแแแแฎแแแก แแ แฅแแขแแฅแขแฃแ แ แแ แแจแแแแแแแแแก แแแขแแแแแแชแแ Stapel แแ Dockerfile แแจแแแแแแแแแกแแแแก แฎแกแแแก แแแแแฌแแแแแฃแแ แแ แแแ แแแแแฃแ แ แแแแกแขแ แฃแฅแชแแแแแก แแแแฎแแ แชแแแแแแแก แจแแกแแซแแแแแแแแก werf-แจแ. แแก แคแฃแแฅแชแแแแ แแแแ แแแแแฉแแแแแ แแแแแ v1.1 แแแแแจแแแแแจแ แแ แแแขแแแแขแฃแ แแ แแแฎแแแแ แฎแแแแแกแแฌแแแแแ แแแขแแแแขแฃแ แ แแแแแฎแแแแแก แแแฅแแแแแแแก แแแจแแแแแแ (แแแแฎแแแ แแแแแแแกแแแแก
แแ แแแแแชแแแแจแ แแแแแขแแแฃแแแ แแแแแก แกแขแ แแขแแแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ แกแฃแ แแแแก แแแแขแแแขแแ - แจแแแแแ แกแแ แแแคแฃแซแแแแฃแแ แขแแแแ แแแ, แ แแแแแแช แแแฎแแ แแแแฃแแแกแฎแแแแ แกแขแ แแขแแแแ. แแแแแแ แ แแ แซแแแแแแก แแฃแ แแแแ แแกแแแ แแแแแแฃแจแแแแแฃแแแ: werf build
, werf publish
, werf deploy
, werf dismiss
, werf cleanup
.
แจแแแแแแ แแแแจแแแแแแแแแ แแแแแฏแ แแ แแก แแแแแฌแแแแแฃแแ แจแแแ แแแแแแก แแแแแขแแแ. แแแแแฌแแแแแฃแแ แแแแกแขแ แฃแฅแชแแแแ แฃแคแ แ แแ แแแ แแขแแขแฃแแ แแแฎแแ, แแแแ แ แแแ แแแแแฃแ แ แแแแกแขแ แฃแฅแชแแแแ v1.0-แแก แจแแแแแ, แ แแแแแ แแกแแแ แแแข แแแแจแแแแแแแแก แแแแญแแแแ werf-แก: แแแแแแ แแแแก แแแ แขแแแแแฃแ แ แแแกแจแขแแแแ แแแ แแ แแคแแแแ แฃแแ แแจแแแแแแแแแก แแฎแแ แแแญแแ แ แกแฎแแแแแกแฎแแ CI/CD แกแแกแขแแแแแจแ, แแกแแแ GitHub Actions-แแก แแคแแชแแแแฃแ แ แแฎแแ แแแญแแ แแก แจแแกแแซแแแแแแแ. . แแแแขแแ, แแแ แแแแแฃแ แ แจแแแ แแแแแแก แแแแฎแแ แชแแแแแแแก แแแแแแ แแแแแแแแชแแแ. แแฃแแชแ, แฉแแแ แแแฃแจแแแแ, แ แแ แแ แแแ แจแแกแแซแแแแแแแ แ แแช แจแแแซแแแแ แแแแ แแแแแแฎแแ แชแแแแแ.
แแแฐแงแแแแ แกแแแฎแแแแแก! แแ แแ แแแแแแแฌแงแแแ แแแแกแขแฃแแ แแ
PS
แแกแแแ แฌแแแแแแฎแแ แฉแแแแก แแแแแแ:
- ยซ
แฌแแ แแแแแแแแแ werf 1.0 stable: แ แ แแแแจแแ แ แแฅแแก GitOps-แก, แกแขแแขแฃแกแก แแ แแแแแแแก ยป - ยซ
werf - แฉแแแแ แแแกแขแ แฃแแแแขแ CI / CD-แกแแแแก Kubernetes-แจแ (แแแแแฎแแแแ แแ แแแแแ แแแแแ แแจแ) "; - แฉแแแแฌแแ แแแแก แกแแ แแ แแแ แคแจแ แแแแแแชแแแแแก แจแแกแแฎแแ:
- ยซ
3-แแฎแ แแแ แจแแ แฌแงแแ werf-แแแ: แแแแแแแแแ แแฃแแแ แแแขแแกแจแ Helm-แแ โแกแขแแ แแแแแแแโ "; - ยซ
Werf-แแก แแแแแงแแแแแ แ แแฃแแ Helm แกแฅแแแแแแก แจแแกแแฅแแแแแแ "; - ยซ
แแแแแ แแแแก แแ แแฃแแขแแ แแแแก แแฎแแ แแแญแแ แ werf-แจแ แแ แ แ แแแแจแแ แ แแฅแแก แแแก Docker Registry-แก "; - ยซ
แแฎแแ แแฅแแแ แจแแแแซแแแแ แจแแฅแแแแ Docker แกแฃแ แแแแแ werf-แจแ แฉแแแฃแแแแ แแแ Dockerfile-แแก แแแแแงแแแแแแ ".
- ยซ
แฌแงแแ แ: www.habr.com