แแแแฌแงแแ แกแแฃแแแแแกแ DevOps แแแกแขแ แฃแแแแขแแแแก แแแแแงแแแแแ แแฆแแกแแ!
DevOps แ แแแแแฃแชแแแ แกแแแแแแแ แแแแชแแ แแกแแคแแแ แแ DevOps แแแกแขแ แฃแแแแขแแแ แฌแแ แแแฃแแแแแแแ แแแแฃแแแ แฃแแ แแแฎแแ. แกแแแกแแฎแฃแ แแก แชแแแแแ
DevOps แแแแแแแแแแแ แแแแชแแแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแแแแแแ แแแแก แแแแ แกแแกแแชแแชแฎแแ แชแแแแก, แแแแขแแ แแ แแคแแกแแแแแแแแก แจแแฃแซแแแแ แแแ แฉแแแ แกแฎแแแแแกแฎแแ แฎแแแกแแฌแงแแแแแแแ. แแแแ แแ, แ แแแแ แช แแแแแฎแกแแแแแแ, แแ แช แแ แแ แแแกแขแ แฃแแแแขแ แแ แจแแแซแแแแ แแแฎแแแก แฃแแแแแ แกแแแฃแ แ แแแกแขแ แฃแแแแขแ แงแแแแแกแแแแก. แแฃแแชแ, แแแแแแ แแ แแแแแฌแงแแแขแ แแแแแแแแแแก แคแฃแแฅแชแแแแแก แแกแแ แคแแ แแ แกแแแฅแขแ แก, แ แแ แแแ แจแแฃแซแแแแ แแแฃแแแแแแแแแ แแแแฅแแแก แแแแแกแแแแ แแแแชแแแแก.
แแแแแ แแแแงแแ DevOps แแแกแขแ แฃแแแแขแแแ แแแขแแแแ แแแแแ แแ แจแแแแแแ แแ แแกแแแ แแแแแแแแแก:
- แแแกแขแ แฃแแแแขแแแแก แแแแแแแแ แแแ แแ แจแแฅแแแ
- แขแแกแขแแก แแแขแแแแขแแแแชแแแก แแแกแขแ แฃแแแแขแแแ
- แแแกแขแ แฃแแแแขแแแ แแแแแแแแแแก แแ แแแแแแแแแกแแแแก
- แแแจแแแแแก แฎแแแกแแฌแงแแแแ
- แแแแแแจแ แแแแแแแก แแแกแขแ แฃแแแแขแแแ.
แฌแแ แแแขแแแฃแแ แแ แแแแแ แแแฃแแ แแแแฎแแ แชแแแแแแ
แแแกแขแ แฃแแแแขแแแแก แแแแแแแแ แแแ แแ แจแแฅแแแ
แแก แแ แแก CI/CD แแแแกแแแแแแก แแแกแขแแก แกแแคแฃแซแแแแ. แงแแแแแคแแ แ แกแฌแแ แแ แแฅแแแแ แแฌแงแแแ! แแ แแแขแแแแ แแแก แกแแฃแแแแแกแ แฎแแแกแแฌแงแแแแก แจแแฃแซแแแแ แแ แแแแแ แแแแแแแแก แแแแแแแก แแแ แแแ แแ แกแฎแแ แแ แแแฃแฅแขแแแแแ แแแ แขแแแแ แแแขแแแ แแ แแแ.
แแแแแแแแ แแแแก แกแแกแแชแแชแฎแแ แชแแแแแก แแ แแขแแแแ แแ แกแแแแแก แแแกแขแ แฃแแแแขแแแแก แกแแแ แฏแแฃแคแ:
- แแแ แกแแแก แแแแขแ แแแแก แกแแกแขแแแ (SCM)
- แฃแฌแงแแแขแ แแแขแแแ แแชแแ (CI)
- แฒแแแแชแแแแ แแแ แแแ
GIT-แก แแฅแแก แแแแแแแแ แแแแแชแแแแแแ 2020 แฌแแแก, แแแแขแแ แแฅแแแแก SCM แฎแแแกแแฌแงแแก แฃแแแ แฐแฅแแแแแก GIT-แแก แฃแฌแงแแแขแ แแฎแแ แแแญแแ แ. CI-แกแแแแก แฌแแแแแแ แแแแ แแแแขแแแแแ แแก แแแแแแ แแแฃแ แแแ แแแแจแ build-แแแแก แจแแกแ แฃแแแแแกแ แแ แแแจแแแแแก แจแแกแแซแแแแแแแ. แ แแช แจแแแฎแแแ แแแแแชแแแแ แแแแแฏแแแแขแก, แแก แแแแแฎแแแก แแแแแชแแแแ แแแแแก แกแฅแแแแจแ แชแแแแแแแแแแก แจแแขแแแแก แฃแแแ แก แแ แแแแแชแแแแ แแแแแก แจแแแแ แฉแฃแแแแแก แแแแแแแชแแแก แแแ แกแแแก แแแฎแแแแแ.
SCM + CI แแแกแขแ แฃแแแแขแ #1
แแแแแ แฏแแแแฃแแ: GitLab แแ GitLab-CI
2020 แฌแแแก DevOps แชแแแแแก แกแแฃแแแแแกแ แแแกแขแ แฃแแแแขแ แฃแแแแแ แแ แแก GitLab แแ แแก แแฃแชแแแแแแแ แแแแแ แซแแแแแก แแแแแแชแแแแแก แแแแแ แแแแก แฃแแฎแแแแก แแแแแแแแจแ.
GitLab-แแก แแแแแแ แ แคแฃแแฅแชแแแ แฃแแ แฃแแแแแงแแก Git แกแแชแแแแก แแแแคแแ แขแฃแแ แแแ แแแ. แแแ แแแขแแ แคแแแกแ แแแขแฃแแชแแฃแ แ แแ แแแ แขแแแ แแแแแกแแงแแแแแแแแ. GitLab แแแแแแแแแ แงแแแแแคแแ แก, แ แแช แแญแแ แแแแแ แฃแคแแกแ แแแ แกแแแจแ แแ แแแแแก แ แแแแ แช SaaS แแ on-prem (แแฅแแแแ แ แแกแฃแ แกแแแแก แแแแแงแแแแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแกแแแแซแแแแแกแแแแก).
แแ แชแแ แ แกแฎแแ SCM แแแกแขแ แฃแแแแขแก แแ แแแแแฃแงแแแแแแ แฃแฌแงแแแขแ แแแขแแแ แแชแแ (CI) แแแ แแแแแ แแฅแแแแก แกแแชแแแจแ แแ GitLab แแแแก แแแแ แฎแแแแ แแแแแแแก. GitLab-CI-แแก แแแแแกแแงแแแแแแแ, แแฅแแแ แฃแแแ แแแแแแขแแ .gitlab-ci.yml แคแแแแ แแฅแแแแก แฌแงแแ แแก แแแแแก แซแแ แจแ แแ แแ แแแฅแขแจแ แแแแแกแแแแ แ แชแแแแแแแ แแแแแแฌแแแแก แแแฅแแแแแแแแก แแฃแกแขแแ แแฅแแแ แแแแ แแแแแแแแฃแแแ แแแงแ แแแแแแ. GitLab แแ GitLab-CI แแแแกแแฎแฃแ แแแฃแแแ แแ แแแ แแฆแแแ แแแฃแแ แแแแแ แแแแ แฃแฌแงแแแขแ แแแขแแแ แแชแแแก แกแคแแ แแจแ (CI-as-code).
แซแแ แแแแแ แกแแ แแแแแแ
- แกแแแแแแแแแ - แแ แแแฃแฅแขแ แแแแแ แแ 2013 แฌแแแแแ แแ แแก; แกแขแแแแแฃแ แ; แแแ แแแ แแฎแแ แแแญแแ แแแ.
- แฆแแ แฌแงแแ แ - GitLab-แแก แฃแคแแกแ แแแ แกแแ แแ แแฆแฃแแแแก แซแแ แแแแ แคแฃแแฅแชแแแแแ แแแแก, แ แแแแแแช แกแญแแ แแแแ แแแแแแแแ แแแแก แแฃแแแแแก. แคแแกแแแแ แแแแกแแฎแฃแ แแแแก แแแแแขแแแ แฃแแ แฃแแแแแงแแคแก แแแแแขแแแแ แกแแกแแ แแแแแ แคแฃแแฅแชแแแแก แกแฎแแแแแกแฎแแ แแแแแกแ แแ แกแแญแแ แแแแแแแก แแแแแแแแแแแกแแแแก.
- Engrained CI - แแแแแ แแ แแ แชแแ แ แกแฎแแ แแแกแขแ แฃแแแแขแก แแ แแฅแแก แฉแแจแแแแแฃแแ แฃแฌแงแแแขแ แแแขแแแ แแชแแ แแแ แแแแแ SCM-แจแ, แ แแแแ แแชแแ GitLab-CI. Docker-แแก แแแแแงแแแแแ แฃแแ แฃแแแแแงแแคแก แฃแแ แแแแแแแ แแแแแแ แแแฃแ แแแแแแแแแแก, แฎแแแ แฉแแจแแแแแฃแแ แแแแแ แแจแแแ แแแแแ แแแแก แแแ แขแแแก. แฉแแแ แแ แแแญแแ แแแแ แแแแแแแฅแกแฃแ แ แแแขแแแ แแชแแ แแ แแ แแแแแ แแแกแขแ แฃแแแแขแแก แแแ แแแ แแ แแแ แแฃแแแ.
- แจแแฃแแฆแฃแแแแ แแแขแแแ แแชแแแแ - GitLab แฃแแ แฃแแแแแงแแคแก แแฅแแแแแแแก แกแแญแแ แ แงแแแแ DevOps แฎแแแกแแฌแงแแก แแแ แขแแ แแแขแแแ แแชแแแก. แแก แฃแแ แฃแแแแแงแแคแก, แ แแ แแแแแแแแ แแแแกแ แแ แขแแฅแแแแฃแ แ แแฃแแแแแก แฐแฅแแแแแ แแแคแแ แแแชแแแก แแ แแ แฌแงแแ แ แแแแ แแแแแงแแแแแแก แจแแกแแฎแแ แแแแแกแแแแ แแแ แแแแจแ.
แแแแแฃแ แแแขแแแ
แแแแแฌแแแแแแ แแแแฆแ แแ แซแแแแจแ, แแแแ แแ แแ แแแแแ
แแ แแแขแแแแ แแแจแ แแ แแก แกแฎแแ แแแแฃแแแ แฃแแ แฎแแแกแแฌแงแแแแ, แแแแ แแ แแกแแแ แแ แแ แแแ แแกแแแแแ แแแ แแ, แ แแแแ แช GitLab. แแ แแแแขแแ:
GitHub โ แแก แแ แแก แจแแกแแแแจแแแแ SaaS แแแ แกแแแก แแแแขแ แแแแก แกแแกแขแแแ แแชแแ แ แแแแแแแแแแแกแแแแก แแ แแแแแแแแ แแแแก แแแ แแฃแแ แแขแแแแแแกแแแแก. แแแแ แแแแแแแแแแแกแแแแก, แ แแแแแแแกแแแแกแแช แแแแจแแแแแแแแแแ IP แแแกแแแแ แแแแแก แจแแแแ แฉแฃแแแแ แกแแแฃแแแ แฅแกแแแจแ, GitHub-แแก แแ แแแแแ แแ แแแแแกแแแแแ แแงแ .OVA แแแ แขแฃแแแฃแ แ แแแแฅแแแ แแแฆแแแ แฎแแแแแกแแฌแแแแแแแแก แกแแกแขแแแแแแก แแฎแแ แแแญแแ แแก แแแ แแจแ. แแก แแ แแฃแแแแก แฌแแแแกแฌแแ แแแแแแก, แแแ แแ แแแแกแ, .OVA แแแแแฃแแแแแแแ แแฎแแแแ แกแแจแฃแแแ แแแแแก แแแแแแกแแกแแแแก, แฌแแแแแฆแแแแ แจแแแแฎแแแแแจแ แกแแ แแแ แ แฃแแ แแแแ แแแแ แแ แฃแคแ แ แแแแ แแแขแแแ แแแแ. GitHub Actions-แแก (แฃแแแแแกแแแแ แแ แแแแ แแ แฏแแ แแแแแ แแ แ แแ แแ แแแ แกแแแจแ) แแ CI-as-code แแแแแแแแแ แแแจแแแแก, แ แแ แแฅแแแ แฃแแแ แแแ แฉแแแ แชแแแแ CI แแแกแขแ แฃแแแแขแ แแ แจแแแแแ แแแ แแแ แแก แแแขแแแ แแชแแ. แแแแแแแก, GitHub แแแแ แแ แฃแคแ แ แซแแแ แแ, แแแแ แ GitLab-แแก แ แแแแแแแ แแแ แกแแ.
Jenkins โ แแแฃแฎแแแแแแ แแแแกแ, แ แแ แฏแแแแแแกแ แแแแฃแแแกแฎแแแแแ แแแแแแแ แกแขแแแแแ แขแแ แฃแฌแงแแแขแ แแแขแแแ แแชแแแก แแแกแขแ แฃแแแแขแแแก แจแแ แแก, แแแก แงแแแแแแแแก แแ แฐแฅแแแแ แแแ แกแแแก แแแแขแ แแแแก แจแแกแแซแแแแแแแแแ. แแแแแแแก, แ แแ แแฅแแแ แแงแแแแแ Jenkins-แก แแแฃแก แ แแแแ แกแแฎแแก SCM แฎแแแกแแฌแงแแก. แซแแแแแ แ แแฃแแแ, แ แแแแกแแช GitLab-แก แจแแฃแซแแแ แแ แแแแก แแแแแแแแ. แกแแจแฃแแแ UX แแแแแแแ แแ แแ แแก แจแแกแแคแแ แแกแ แแแแแแแแ แแแ แแแ แแแแแแแชแแแกแแแแก แแ แกแแกแฃแ แแแแก แขแแแแแก.
BitBucket/Bamboo โ แแ แฃแแแ แแแฆแแแ แ แแก แแแขแแแแขแฃแ แแแแแ แชแฎแแแฃแแแ: แ แแขแแ แแ แแก แแ แ แแแกแขแ แฃแแแแขแ, แ แแชแ GitLab แงแแแแแคแแ แก แกแ แฃแแแแ แแแแแฃแแแแแแแแ แแแแแแแก. BitBucket Cloud แแฎแแ แก แฃแญแแ แก GitLab-CI / GitHub Action แคแฃแแฅแชแแแแแ แแแแก, แแแแ แแ แกแขแแ แขแแแแ แแแ แแแแแแแแแก แแ แจแแฃแซแแแ แแแกแ แแแ แขแแแแ แแแแฎแแ แชแแแแแแ. Prem BitBucket แกแแ แแแ แ BitBucket แแแแกแแแแแแแกแแช แแ แแ แฃแญแแ แก แแฎแแ แก!
#1 แแแแแชแแแแ แแแ แแแแก แแแกแขแ แฃแแแแขแ
แแแแแ แฏแแแแฃแแ: FlywayDB
แแแ แแแแแแแชแแแก แจแแแฃแจแแแแแแกแแก, แ แแแแ แช แฌแแกแ, แแ แแแแญแแแ แแแแจแแแแแแแ แแแแแชแแแแ แแแแแก แแแขแแแแขแแแแชแแแก. แแแแแแแชแแแก แแฎแแแ แแแ แกแแแแแกแแแแก แแแแแชแแแแ แแแแแก แกแฅแแแแก แชแแแแแแแแแแก แแแแแแแแแแก แแแแ แแแแแ แแแแแก. แกแฅแแแแก แชแแแแแแแแแ แฎแจแแ แแ แแฌแแแแก แกแแแขแแแแก แแ แชแฎแ แแแแแแก แแแแแขแแแแก แแ แแแแแ แฅแแแแแก. แแฃ แแแแแแแชแแแก แแแ แกแแ แแ แแแแฎแแแแ แกแฅแแแแก แแแ แกแแแก, แแแแแแแชแแ แจแแแซแแแแ แแแแ แแฃแแ แแงแแก. แแแ แแ แแแแกแ, แแแแแชแแแแ แแแแแก แชแแแแแแแแแแก แแแ แแแ แแแแแแแชแแแก แแแแแฎแแแแแกแแก แจแแแซแแแแ แแงแแก แ แแฃแแ, แ แแแแแ แแ แกแแแแแก แแ แ แแแแกแฎแแแแแแฃแแ แกแแกแขแแแ. FlyWayDB แแแแแ แแแก แงแแแแ แแ แแ แแแแแแแก.
แซแแ แแแแแ แกแแ แแแแแแ
- แแแแแชแแแแ แแแแแก แแแ แกแแแ แแแ - Flyway แแแซแแแแ แกแแจแฃแแแแแแก แจแแฅแแแแ แแแแแชแแแแ แแแแแก แแแ แกแแแแ, แแแแแงแฃแ แ แแแแแแแ แแแแแชแแแแ แแแแแก แแแแ แแชแแแก แแ แแแ แขแแแแ แแแแแแขแแแแ แแ แแแแแ แฃแแแ แกแฅแแแแก แชแแแแแแแแแ แแแแแขแแแแแ แฎแแแกแแฌแงแแก แแแ แแจแ.
- Binary แแ Embedded - แฉแแแ แจแแแแแซแแแ แแแแ แฉแแแ Flyway-แแก แแแจแแแแ แแแแแแแชแแแก แแแฌแแแแ แแ แแ แแแแแ แจแแกแ แฃแแแแแแ. Flyway แแแแฌแแแแก แแแ แกแแแแแก แแแแกแแแแแแแแก แแแจแแแแแกแแก แแ แแฌแงแแแก แจแแกแแแแแแก แแแแ แแชแแแก, แแแแแชแแแแ แแแแแชแแแแ แแ แแแแแแแชแแแก แแแ แกแแแแแก แกแแแฅแ แแแแแแชแแแก. cmd แฎแแแแก ad-hoc แแ แซแแแแแแก แแแจแแแแแ, แฉแแแ แแแซแแแแ แแแฅแแแแแแแก แแ แกแแแฃแ แแแแแชแแแแ แแแแแแก แแแแแ แแแแแแแชแแแก แแฆแแแแแแก แแแ แแจแ.
แแแแแฃแ แแแขแแแ
แแแแแฌแแแแแแ แแแแฆแ แแ แซแแแแจแ, แแแแ แแ แแ แแแแแ
แแ แกแคแแ แแจแ แแแแ แ แแแกแขแ แฃแแแแขแ แแ แแ แแก. แแแแแ แจแแแฎแแแแ แแแแแแ แ แแแแแแแก:
LiquiBase - Liquibase แฐแแแแก FlywayDB-แก. แแกแฃแ แก แแแแแงแแแ แแก Flyway-แแก แแแแแ, แแฃ แฉแแแก แแฃแแแจแ แแงแแแก แแแแแ Liquibase-แแก แแแขแ แแแแแชแแแแแแแ.
แคแแแแแ แ - แแฃแจแแแแก แแฎแแแแ แแแแขแแแแแ แแ แแแคแฃแซแแแแฃแ แแแแแแแชแแแแแ. แแแแขแแแแแ แแ แแแฃแแ แแแแแชแแแแ แแแแแแแก แฌแแ แแแขแแแแ แแแกแแจแแแแแ, แงแแแแแคแแ แ แแแแแแฃแ แแ แฃแแแ แแงแแก แแแแแแแแแ. แแ แแแ แฉแแแ แแแแแแงแแแแ RDS (Relational Database Service) แแแแแชแแแแ แแแแแแแกแแแแก แแ แแ แแแ แฉแแแ แแแแจแแแแแแแแแ แแแคแแ แแแชแแแก แจแแแแฎแแแก แแแแขแแแแแ แจแ.
แขแแกแขแแก แแแขแแแแขแแแแชแแแก แแแกแขแ แฃแแแแขแแแ
แแแแแฌแงแแ แขแแกแขแแก แแแขแแแแขแแแแชแแแก แฎแแแกแแฌแงแแแแแก แแแแฎแแแแ แขแแกแขแแ แแแแก แแแ แแแแแแก แกแแคแฃแซแแแแแ แแแแ แแแแกแแคแแแแชแแแ.
แขแแกแขแแ แแแแก แแแ แแแแแแก (แขแแกแขแแแก) แแฅแแก 4 แแแแ:
- แแ แแแฃแแ แขแแกแขแแแ - แแก แแ แแก แแแแแ แแแขแแแแขแฃแ แ แขแแกแขแแ แแแแก แแ แแชแแกแแก แกแแคแฃแซแแแแ. แกแฎแแ แขแแแแก แขแแกแขแแแแแ แจแแแแ แแแแ แแแขแ แแ แแแฃแแ แขแแกแขแแแ แฃแแแ แแงแแก. แแแแแแแแแ แแแ แฌแแ แแ แแ แแฌแแ แแแแแแ แแ แแแฃแแแแแก แขแแกแขแแแก, แ แแแ แแแ แฌแแฃแแแแแ, แ แแ แแแแแแแชแแแก แแแฌแแแ (แชแแแแแแแ แ แแแแ แช "แแ แแแฃแแ") แจแแแกแแแแแแแ แแแก แแแแแแแก แแ แแฅแชแแแ แแกแ, แ แแแแ แช แแแกแแแแแแแแแ.
- แแแแแแแแแขแแก แขแแกแขแแแ - แแแแแแแแแขแแก แขแแกแขแแ แแแแก แแแแแแ แ แแแแแแแ แจแแแแแฌแแแก แขแแกแขแแก แแแแแฅแขแแก แจแแแแแแแ/แแแแแแแแแแ แฅแชแแแ. แฉแแแ แฃแแแ แแแแ แฌแแฃแแแแ, แ แแ แขแแกแขแแก แแแแแฅแขแแก แคแฃแแฅแชแแแแแ แแแ แกแฌแแ แแ แแ แแก แแแแแ แแแแ แกแแแชแแคแแแแชแแแก แแแฎแแแแแ.
- แแแขแแแ แแชแแแก แขแแกแขแแแ - แขแแกแขแแ แแแแก แขแแแ, แ แแแแแจแแช แแแแแแแแฃแแแฃแ แ แแ แแแ แแแฃแแ แแแแฃแแแแ แแแแ แแแแแแแฃแแแ แแ แขแแกแขแแ แแแ แฎแแแแ แฏแแฃแคแฃแ แแ.
- แแแแแแแ แแแแแแแ แขแแกแขแแแ - แแก แแแแแฏแ แแแแแกแแแแแ แแแกแแแแแแ. แฉแแแ แแแแแแ แแแแแ แแแแ แแแแแแแชแแแก แแ แแ แฌแแฃแแแแแแ, แ แแ แแก แคแฃแแฅแชแแแแแ แแแก แแกแ, แ แแแแ แช แแแแแแแแแ แแงแ.
แแแแแแแแ แแ แแแฃแแแก แขแแกแขแแแ แแ แแแแแแแแแขแแแแก แขแแกแขแแ แแแ แฎแแ แชแแแแแแแ แแฎแแแแ แแแแแแแแแ แแแแก แแแแ แแ แฎแจแแ แแ แแ แแแ แแแแ แแแแก แแแแก แกแแแชแแคแแแฃแ แแ, แฉแแแ แแ แจแแแแคแแกแแแ แแ แแแกแขแ แฃแแแแขแแแก DevOps แแแแแแแกแแแแก.
#1 แแแขแแแ แแชแแแก แขแแกแขแแ แแแแก แแแกแขแ แฃแแแแขแ
แแแแแ แฏแแแแฃแแ: แแแขแ แ
แแแขแ แ แแแ แแแแแแแก แกแแแชแแคแแแแชแแแแแกแ แแ แขแแกแขแแ แแแแก แแแแฃแแแแขแแชแแแก แแ แ แชแแชแฎแแ แแแแฃแแแแขแจแ. แกแแแชแแคแแแแชแแแแ แงแแแแแแแแก แแแแแฎแแแแฃแแแ, แ แแแแแ แแกแแแ แแแขแแแแขแฃแ แแ แจแแแแฌแแแแแ แแแขแ แแก แแแแ . แแฃ แแกแฃแ แ แจแแฅแแแแ แแแขแแแแขแฃแ แ แขแแกแขแแ แแแแก แฉแแ แฉแ แแฃแแแแแ แแ แแแแฌแงแแ แแแแฎแแแ แแแแแก แฅแชแแแ แแแ แแแแแแแชแแแจแ, แแแจแแ Selenium WebDriver Java แแ Cucumber BDD แแ แแก แจแแกแแแแจแแแแ แแแ Cucumber-แแก แแ แแแฅแขแจแ แจแแกแแกแฌแแแแแ แแ แแแแแ แแแแกแแแแก.
แซแแ แแแแแ แกแแ แแแแแแ
- BDD แแแแแแแ (Behavior Driven Development - โแแแแแแแแ แแแ แฅแชแแแแก แแแจแแแแแแโ แแแแกแฎแแแแแแแ โแขแแกแขแแ แแ แแแแขแแ แแแฃแแ แแแแแแแแ แแแแกโ แแแแแแแแกแ) - แแแขแ แ แจแแฅแแแแแแ BDD แขแแกแขแแ แแแแกแแแแก, แแก แแแแแแแแ แแแแแ แจแแแฅแแแ แกแฌแแ แแ แแ แแแแชแแแแกแแแแก.
- แชแแชแฎแแแ แแแแฃแแแแขแแชแแ - แแแแฃแแแแขแแชแแ แงแแแแแแแแก แขแแแแแแแ! แแแแแแแแ แแฅแแแแ แขแแกแขแแแ แแแแแก แกแแฎแแ แแ แแก แแแฌแแ แแแ, Cucumber แแแแฌแแแแก แแแขแแแแขแฃแ แแ แแแแแ แแ แแแฃแ แแแแฃแแแแขแแชแแแก, แ แแแ แแแ แฌแแฃแแแแก, แ แแ แขแแกแขแแแ แแ แแแแฃแแแแขแแชแแ แกแแแฅแ แแแแแแแฃแแแ.
- แแฎแแ แแแญแแ แ - แฉแแแ แจแแแแแซแแแ แแแแ แฉแแแ แแ แแแแแ แแแกแขแ แฃแแแแขแแแแ, แแแแ แแ Cucumber-แก แแฅแแก แกแแญแแ แ แคแแแแแกแฃแ แ แ แแกแฃแ แกแแแ แแ แแแ แแแ แแ แแแแแแแแฃแแ แแฎแแ แแแญแแ แแก แกแแกแขแแแ, แ แแแ แแแแฎแแแ แแก แแแแฎแแแ แแแแแแก แแแแแกแแแแ แ แแฃแ แกแแขแฃแแชแแแจแ.
แแแแแฃแ แแแขแแแ
แแแแแฌแแแแแแ แแแแฆแ แแ แซแแแแจแ, แแแแ แแ แแ แแแแแ
แกแฎแแ แฉแแ แฉแแแแกแ แแ แขแแฅแแแแแแแฃแ แแแกแขแ แฃแแแแขแแแก แจแแ แแก, แแฎแแแแ แแแขแ แ แจแแแซแแแแ แฉแแแแแแแแก แฃแแแแแ แกแแแฃแ แแแแแฌแงแแแขแแ.
แแแแแแแ แแแแแแแ แขแแกแขแแ แแแแก แแแกแขแ แฃแแแแขแแแ
แแแแแแแ แแแแแแแ แขแแกแขแแ แแแแก แฉแแขแแ แแแแกแแก, แแฅแแแ แฃแแแ แแแแแแฎแแแแแ แงแฃแ แแแฆแแแ แแ แแแแแแ แแฃแแฅแขแแ:
- แคแฃแแฅแชแแฃแ แ แขแแกแขแแ แแแ
- แกแขแ แแกแแก แขแแกแขแแ แแแ.
แคแฃแแฅแชแแแแแแฃแ แ แขแแกแขแแ แแแแกแแก แฉแแแ แแแแแฌแแแแ, แฎแแแแ แแฃ แแ แ แงแแแแแคแแ แ, แ แแช แแแแแแ. แแแแแแแแแ, แ แแแแกแแช แแแฌแแแแฃแแแ แฉแแแ SPA-แก (แแ แแแแแ แแแแแ แแแแแแแชแแ) แแแ แแแแฃแ แแแแแแแขแแแแ, แแแแกแแ แคแแ แแแแก แแ แแแ แฉแแ โแแแแแแแแโ, แแแแแชแแแแ แแแแแจแ แแแแแฉแแแแแ แแ แแแ แแแแ แฉแแแแแ แจแแขแงแแแแแแแ โแฌแแ แแแขแแแ!โ.
แฉแแแแแแแก แแกแแแ แแแแจแแแแแแแแแแ แจแแแแแแฌแแแ, แ แแ แแ แแ แแ แแแแแ แกแชแแแแ แแก แแฅแแแ แแแแฎแแแ แแแแแแแก แแแ แแแแฃแแ แ แแแแแแแแ แจแแแซแแแแ แแแแฃแจแแแแแก แจแแชแแแแแแแก แแแ แแจแ.
แแ 2 แขแแแแก แขแแกแขแแ แแแแก แแ แแ แกแแแแแ แแแแจแแแแแแแแแ แแแแแ แแฅแแแแ แแฅแแแแก CI/CD แแแแกแแแแแจแ.
#1 แแแแแแแ แแแแแแแ แขแแกแขแแ แแแแก แแแกแขแ แฃแแแแขแ. แคแฃแแฅแชแแฃแ แ แขแแกแขแแ แแแ
แแแแแ แฏแแแแฃแแ: SoapUI Pro
SoapUI แแแแ แฎแแแแ แแ แแก API แขแแกแขแแ แแแแก แกแแแ แชแแจแ, แแแก แจแแแแแ, แ แแช SOAP แแแคแฃแซแแแแฃแแ แแแ แกแแ แแแกแแแ แกแขแแแแแ แขแ แแงแ. แแแฃแฎแแแแแแ แแแแกแ, แ แแ แฉแแแ แแฆแแ แแฅแแแแ แแฎแแ SOAP แกแแ แแแกแแแก แแ แฎแแแกแแฌแงแแก แกแแฎแแแ แแ แจแแชแแแแแ, แแก แแ แแแจแแแแก แ แแ แแก แแ แแแแแแแแ แแ. SoapUI แฃแแ แฃแแแแแงแแคแก แจแแกแแแแจแแแ แฉแแ แฉแแก แแแขแแแแขแฃแ แ backend แคแฃแแฅแชแแฃแ แ แขแแกแขแแแแก แจแแกแแฅแแแแแแ. แขแแกแขแแแ แแแแแแแ แจแแแซแแแแ แแแแ แแแแแแแก แฃแฌแงแแแขแ แแแขแแแ แแชแแแก แแแกแขแ แฃแแแแขแแแแแ แแ แแแแแงแแแแแฃแ แแฅแแแก แ แแแแ แช CI/CD แแแแกแแแแแแก แแแฌแแแ.
แซแแ แแแแแ แกแแ แแแแแแ
- แแแขแแแฃแ แ แแแแฃแแแแขแแชแแ - SoapUI แกแแแแแแ แแแแ แฎแแแแ แแ แกแแแแแก แแแแแ แแ, แแแแขแแ แแ แแก แแแแ แ แแแแแแ แ แแกแฃแ แกแ, แ แแแแแแช แแแแแฎแแแ แแแแ แแแแแแ, แแฃ แ แแแแ แแแแงแแแแ แขแแกแขแแแ.
- แแแแแงแแแแแแก แกแแแแ แขแแแ - แแแฃแฎแแแแแแ แแแแกแ, แ แแ แฎแแแกแแฌแงแ แแฎแแ แก แฃแญแแ แก แแ แแแแ แแ แแขแแแแแก API-แแแแก แจแแกแแแแฌแแแแแแ, SoapUI-แแก แแ แกแแแแแแก แกแแแ แแ แแแขแแ แคแแแกแ แแ แแแแแ แกแแ แแแกแแกแแแแก แแแแแแแแแก แขแแกแขแแแแก แฌแแ แแก.
แแแแแฃแ แแแขแแแ
แแแแแฌแแแแแแ แแแแฆแ แแ แซแแแแจแ, แแแแ แแ แแ แแแแแ
แกแแแแแ แแแแแ แแ แแ แจแแกแแแแจแแแแ แแแกแขแ แฃแแแแขแแ แแ แฏแแฃแคแจแ. แแแ แฉแแแ แแแแแแงแแแแ แแแ, แแฃ แแฅแแแ แแจแแแแแ แแ แแแ แแแแ Java-แแ แแแคแฃแซแแแแฃแ แแแแแแแชแแแก. แแฃแแชแ, แแฃ แแฅแแแ แแจแแแแแ แกแ แฃแ แแแ แแแแแแแชแแแก แแ แแแแแ แขแแฅแแแแแแแแ, แแก แจแแแซแแแแ แแแฎแแแก แแ แแกแแกแฃแ แแแแ Java แแแแแแแแแขแแแแกแแแแก.
#1 แแแแแแแ แแแแแแแ แขแแกแขแแ แแแแก แแแกแขแ แฃแแแแขแ. แกแขแ แแกแแก แขแแกแขแแ แแแ
แแแแแ แฏแแแแฃแแ: LoadRunner
แแแแแแ แขแแแ: แ แแแแกแแช แแฅแแแแ แแแแแแแชแแแก แงแแแแ แแแแแแแขแแก แขแแกแขแแ แแแแก แแ แ แแแแแแแ, แแฎแแแแ LoadRunner-แก แจแแฃแซแแแ แแแแแแแแแก แจแแกแ แฃแแแแ. แแแแฎ, แแแแแแแ แซแแแ แ แแ แ แแฃแแแ, แแแแ แแ LoadRunner แแ แแแแแ แแ แแแกแขแ แฃแแแแขแแ, แ แแแแแแช แแ, แ แแแแ แช แขแแฅแแแแฃแ แแ แฅแแขแแฅแขแแ แก, แกแ แฃแ แแแแแแก แแแซแแแแก, แ แแ แแฎแแแ แแแแ แแแฃแจแแแแแก แแฅแกแขแ แแแแแฃแ แแแขแแแ แแแแก แแแ แแแแแจแ. แแกแแแ, แแ แแคแแฅแ แแ, แ แแ แแ แแ LoadRunner-แแก แฎแแแจแ แฉแแแแแแแก แแแแแแแแแ แฃแแ แแฃแแแแแ แแ แแ แ แขแแกแขแแ แแแแก แแฃแแแแแ.
แซแแ แแแแแ แกแแ แแแแแแ
- แแ แชแแแ แแแแฃแแแแขแแชแแ - LoadRunner แกแแแแแแ แแแแ แฎแแแแ แแ แกแแแแแก แแแแแ แแ, แแแแขแแ แแ แแก แแแแ แ แแแแแแ แ แแกแฃแ แกแ, แ แแแแแแช แแแแแฎแแแ แแแแ แแแแแแ, แ แแแแ แแแแงแแแแ แแแขแแแ แแแแก แขแแกแขแแแ.
- แแ แแขแแแแแแก แแฎแแ แแแญแแ แ - Load Runner แแฎแแ แก แฃแญแแ แก แงแแแแแคแแ แก ODBC-แแแ AJAX-แแแ, HTTPS-แแแ แแ แแแแแกแแแแ แกแฎแแ แแ แแขแ แแแแแแฃแ แแ แแขแแแแแแแแ, แ แแแแแกแแช แจแแแซแแแแ แแแแแแงแแแแก แแฅแแแแ แแแแแแแชแแ. แฉแแแ แแชแแแแแแ แแ แแแแแแแงแแแแ แแ แแแแแ แแแกแขแ แฃแแแแขแ แแแขแแแ แแแแก แขแแกแขแแ แแแแกแแแแก, แ แแแแแ แแก แแฎแแแแ แแ แแฃแแแแก แแ แแชแแกแก.
แแแแแฃแ แแแขแแแ
แแแแแฌแแแแแแ แแแแฆแ แแ แซแแแแจแ, แแแแ แแ แแ แแแแแ
แแกแแ แแ แแกแแ, แแ แแ แกแแแแแก แแแแ แ แฃแแแแแ แกแแแฃแ แ แแแกแขแ แฃแแแแขแ แแ แกแคแแ แแจแ, แแแแขแแ แกแแฃแแแแแกแ แแแแแกแแแแแ แแ แแก แแก, แ แแแแแแช แแแฃแจแแแแแก แแแแแกแแแแ แแแ แแแแจแ, แแแแแกแแแแ แ แขแแฅแแแแแแแแ.
แแแแแแแแแแก แฎแแแกแแฌแงแแแแ
แแแแแแแแแแก แแแกแขแ แฃแแแแขแแแ แแแแแ แแแแแแแแ แแแแก แงแแแแแแ แแแแแแแแ แแแกแแแแแ แแกแแแฅแขแแ. แแแแ แแชแแฃแแ แแฃแแแแกแแแแก, แแแแแแแชแแแก แแแแแกแ แแ แคแฃแแฅแชแแแแแแฃแ แแแแก แฆแ แแ แแแแแแแก แแแ แแจแ, แ แแฃแแแ แแกแแแ แแแกแขแ แฃแแแแขแแแแก แแแแแงแแแแแ. แแแแแแแแแ แแแแกแแแแก, แแแแแแแแแแก แแแแแฏแแแแขแ แแฎแแแ แแแกแฃแฎแแกแแแแแแแแแ, แแแแขแแ แแแ แฏแแ แแ แแฅแแ แกแแแแแ แแกแ แแแแแชแแแแแแ แแกแแ แแแกแขแ แฃแแแแขแแแแแ แแฃแจแแแแแกแแแแก.
แฃแแแ แแแแแก แงแแแแแกแ, แแแแแ แแแแงแแ แแแแแแแแแแก แงแแแแ แแแกแขแ แฃแแแแขแ แกแแ แฅแแแแแขแแแแ แแแ:
- แแ แขแแคแแฅแขแแแแก แแแ แแแ
- แแแแคแแแฃแ แแชแแแก แแแ แแแ
- ะดะตะฟะปะพะน.
#1 แแ แขแแคแแฅแขแแก แแแ แแแแก แแแกแขแ แฃแแแแขแ
แแแแแ แฏแแแแฃแแ: Nexus
Nexus-แแก แแ แขแแคแแฅแขแแก แกแแชแแแ แแฎแแ แก แฃแญแแ แก แแแแฅแแแก แงแแแแ แซแแ แแแแ แขแแฅแแแแแแแแก, Java-แแแ NPM-แแแ แแ Docker-แแแ. แฉแแแ แจแแแแแซแแแ แแแแแแแงแแแแ แแก แแแกแขแ แฃแแแแขแ แฉแแแ แแแแ แแแแแงแแแแแฃแแ แงแแแแ แแ แขแแคแแฅแขแแก แจแแกแแแแฎแแ. แแแกแขแแแชแแฃแ แ แแแแแขแแก แแแแแฏแแ แแแแก แแ แแฅแกแแ แแแ แแกแแแ แแแแจแแแแแแแแแ แแฉแฅแแ แแแก CI build แแ แแชแแกแก, แ แแช แแแแแขแแแก แฃแคแ แ แฎแแแแแกแแฌแแแแแก แฎแแแก แแจแแแแแแแแแกแแแแก. แแแแแ แแ แแ แฃแแแ แแขแแกแแแ แแ แแก แ แแแแแแแแ แแ แแแ แแแฃแ แแ แแแฅแขแจแ แแแแแงแแแแแฃแแ แงแแแแ แแแแแขแแก แกแ แฃแแ แฎแแแแแก แจแแกแแซแแแแแแแ, แแแแแแแแแก แกแแฎแแคแแแ แฆแแ แแแแแก แแแแแขแแแ (แแแ แจแแฃแซแแแแ แจแแขแแแแก แแแฅแขแแ แแก แ แแแ แจแแแกแ แฃแแแ).
แซแแ แแแแแ แกแแ แแแแแแ
- แขแแฅแแแแฃแ แ แแฎแแ แแแญแแ แ - แกแแแแ แแ แแแฃแฅแขแ; แแแ แแแ แแฎแแ แแแญแแ แแแ.
- แฆแแ แฌแงแแ แ - แฃแคแแกแ แแแ แกแแ แแ แแฆแฃแแแแก แซแแ แแแแ แคแฃแแฅแชแแแแแ แแแแก, แ แแแแแแช แกแญแแ แแแแ แแแแแแแแ แแแแก แแฃแแแแแก.
#1 แแแแคแแแฃแ แแชแแแก แแแ แแแแก แแแกแขแ แฃแแแแขแ
แแแแแ แฏแแแแฃแแ: แจแแฃแซแแแแแแแ
Ansible แแแแแ แแ แแ แแ แแแ แขแแแ แแแแแแแก แแแแ: แแแฅแแแแฅแแแแแก แแ แแฅแแแ. แแแ แ แแกแแแแกแ แแแกแขแ แฃแแแแขแแแ แแ แแแแขแแ แแแฃแแ แแงแ แแแแคแแแฃแ แแชแแแก แแแแแแแ แแแแแก แแแ แแแแแ. แแแจแแแแแกแแก, แแกแแแ แฎแแแกแแฌแงแ, แกแแกแฃแ แแแแ แแแแคแแแฃแ แแชแแแก แแแฆแแแแก แจแแแแแ, แจแแแชแแแแ แจแแแกแฌแแ แแก แแแแแแแแ แ แแแแแแแชแแแก แแแแคแแแฃแ แแชแแ. แแฎแแแ แแแแแแแแ แแ แแฎแแแแ แแแฅแแแแฅแแแแแก แแ แแฅแแแ แแแแแแแแแขแแแแ แฌแแ แแแแแแแแแ. แแแแแก แแฎแแแ แแแ แกแแแแ แแ แแก แแ แขแแคแแฅแขแแแ, แ แแแแแแแช แแแแแแแแแฃแแแ แแ แกแแแฃแแแก แฉแแกแแแแชแแแแแแแ. แแก แจแแแซแแแแ แฉแแแแแแแแก แแ แแแแแ แแคแแแแ แฃแ, แแแแแแแแแแแ แแแ แแแแ.
แซแแ แแแแแ แกแแ แแแแแแ
- แแแฅแแแแฅแแแแแก แแแ แแจแ - Playbook แแแจแแแแฃแแแ แแแแแแแแแแก แแแแ แแขแแแแ แแ แจแแกแ แฃแแแแฃแแแ แกแแแแแแ แกแแ แแแ แแแแ. แแ แแ แแญแแ แแแแ แคแแฅแ แ แแแกแขแแแชแแฃแ แ แแแแแฅแขแแก แแแแแแแ แแแแแแ แแกแแแ แฎแแแกแแฌแงแแก แแแแแงแแแแแแ, แ แแแแ แแช แแ แแก Packer, แ แแแ แจแแแฅแแแแก แแแแแแแแแฃแแ แแแแแฅแขแแแ.
- แฆแแ แฌแงแแ แ - CentOS-แแก แแกแแแแกแแ, Ansible-แกแแช แแฎแแ แก แฃแญแแ แก RedHat. แแก แฎแแแก แฃแฌแงแแแก แกแแแแแแแแแแแก แจแแแแ แฉแฃแแแแแก แแ แฃแแ แฃแแแแแงแแคแก แแแฆแแแ แฎแแ แแกแฎแแก, แแแแแแแ แแแแแกแแงแแแแแแ แแแแฃแแแแก.
- แขแแกแขแแ แแแ แแแแแแฃแแแ (Ansible แฉแแ แฉแ) - แแแแแแแแ แแแแคแแแฃแ แแชแแแก แแแ แแแ แแ แแก แแแแ, แแกแแแ แ แแแแ แช แงแแแแแคแแ แ, แขแแกแขแแ แแแ แแฃแชแแแแแแแแ. Molecule-แแก Ansible แ แแแฃแ แ แขแแกแขแแ แแแแก แฉแแ แฉแ แแฃแจแแแแก แฃแแแแแแ, แ แแช แฃแแ แฃแแแแแงแแคแก, แ แแ แแแแคแแแฃแ แแชแแ แแ แแก แแแแแ แฎแแ แแกแฎแแก แแ แแแฐแงแแแแ แแแแแ CI/CD แแแแกแแแแแก, แ แแแแ แช แแแแแชแฎแแแแก แแแแ.
- YAML - แกแฎแแ แแแกแขแ แฃแแแแขแแแแแ แจแแแแ แแแแ, YAML แฃแคแ แ แแแแแแ แแแกแแแแแแ. แแแแแแแแ แแแแคแแแฃแ แแชแแแก แแแแแฏแแแแขแ, แ แแแแ แช แฌแแกแ, แแฎแแแ แแแแแฌแแแแแ แแแแแแแก, แแแแช แแฎแแ แชแแแแแแก DevOps แแ แแฅแขแแแแก, แกแแแแ แขแแแ แแแกแ แแแแแ แแ.
แแแแแฃแ แแแขแแแ
แแแแแฌแแแแแแ แแแแฆแ แแ แซแแแแจแ, แแแแ แแ แแ แแแแแ
OpsCode แจแแค โ แแแแแฌแงแ แฉแแแ DevOps แแแ แแแ แ, แ แแแแ แช แแฃแแแแแ แแฃแแ แฌแแแแแแแก แจแแแฅแแแแแ. แ แ แแฅแแ แฃแแแ, แ แฃแแ แแ แจแแค-แแแแ แแฃแแ แฉแแแแแแก แซแแแแแ แซแแแ แคแแกแแ, แแแแ แแ แแกแแแ แฃแแ แแแแ แแ แฌแงแแแขแแ แแแแแแแแ แแแ แแแฅแแแแฅแแแแแก แแ แแฅแแแ, แฆแ แฃแแแแแแแ แแแแแแแชแแแแแก แแ แแแแแแแแก. OpsCode Chef แแ แแก แจแแกแแแแจแแแแ แแแกแขแ แฃแแแแขแ แฃแคแ แ แขแ แแแแชแแฃแแ แแแแแแแชแแแแแกแแแแก, แแแแ แแ แแ แกแขแแขแแแจแ แฉแแแ แแ แแแแขแแ แแแฃแแ แแแ แ แแแแแแแแแ.
แแแฏแแแแแ โ แแแฏแแแแก แแ แแกแแ แแก แฐแงแแแแ แแแแ แ แแฃแแจแแแแขแแแแแ แ, แแแแกแแแฃแแ แแแแ แจแแค-แแแแ แแฃแแแแ แแ แแแกแแแแแแ แจแแแแ แแแแ. แแก แจแแกแแแแจแแแแแ แแแแ แแขแฃแ แแกแแแ แแฃแจแแแแแกแแแแก, แแแแ แแ แแ แแแแฉแแแ แแแแแแแแ แแแ แแแแคแแแฃแ แแชแแแก แแแ แแแแก แแฎแแ แแแญแแ แ แแแ แแแแแแแชแแแกแแแแก.
แแแแแแแแแแก แแแกแขแ แฃแแแแขแ #1
แแแแแ แฏแแแแฃแแ: Terraform
Terraform แฌแงแแแขแก แแฅแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแแก แกแแฎแแ แแฆแฌแแ แแก แแ แแแแแแแก, แฅแกแแแแก แแแแแแแแแขแแแแแแ แกแ แฃแแ แกแแ แแแ แแก แกแฃแ แแแแแแแแ. แแ แแ แแแฃแฅแขแแ แแแแ แแแ แแแแแ แ แแแกแ แแแแแแแแ แแแแ แแแแแจแแแแแแแ, แแแแแแ แแแแฃแแแ แจแแฅแแแแแ แแ แแกแแแ แซแแแแ แ แกแแแแแแแแแแแ แแแแแฃแแ, แ แแ แแฅแแแ แแฃแชแแแแแแแ แแแแฆแแแ แแแฎแแแ แแแแก แแแแแแแแแแก แแแแแกแแแแ แกแชแแแแ แจแ. แแแแแกแแแแ แ แขแแแแก แแแ แแแแก แแฎแแ แแแญแแ แแก แฃแแแ แ (แจแแแแแแจแ, แฆแ แฃแแแแจแ แแ แกแฎแแแแแ) แจแแฃแแแ แแแแแแ. แแแแแแแก, แฃแแฎแแแกแ แแแ แกแแ แฃแแ แฃแแแแแงแแคแก HCL-แจแ แแแแแ แแแแแแฃแ แ แคแฃแแฅแชแแแแแกแ แแ แแแแกแแแแก แแแ แแแฌแแแก, แ แแแแ แช แแแแแกแแแแ แ แกแฎแแ แขแ แแแแชแแฃแแ แแ แแแ แแแแ แแแแก แแแ, แ แแช แแแแแแแแแก แแแแแแแแแ แแแก Terraform-แก แกแฌแ แแคแแ แแ แแแ แขแแแแ แแฆแกแแฅแแแแแ.
แซแแ แแแแแ แกแแ แแแแแแ
- แแแ แแแ แแแแแกแขแแแ - Terraform แแงแแแแแก แคแฃแแฅแชแแแแก, แ แแแแแแแช แแแฅแแแแแแก แ แแแแ แช แแแขแแ แคแแแกแ แแฅแแแแก Terraform แแแแก, แงแแแแ API-แก แแ แจแแแ แแแแแแแก แจแแ แแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแ แแแแแแแ แแแ แแแแฃแแแแแชแแแกแแแแก. แแก แแแจแแแแก, แ แแ แแ แแแแแฃแคแแแแ แแฎแแแแ แแ แ แแแกแขแ แฃแแแแขแก แแ แจแแแแแ แงแแแแแแ แจแแแแซแแแ แแฃแจแแแแ.
- แฆแแ แฌแงแแ แ - แฃแคแแกแ แแแกแขแ แฃแแแแขแแแแก แแแแแ แชแฎแแแ แ แแฃแแแ! แกแแแแแแแแแแแก แแฎแแ แแแญแแ แ แฃแแแฆแแแก แแแแแแ.
แแแแแฃแ แแแขแแแ
แแแแแฌแแแแแแ แแแแฆแ แแ แซแแแแจแ, แแแแ แแ แแ แแแแแ
AWS แฆแ แฃแแแแก แคแแ แแแ แแแ โ แแแจแแแแช แแ, แแฃ แแฎแแแแ AWS แฆแ แฃแแแแแแ แแแ แแแแจแ แแฃแจแแแแ, แแฅแแแแ แจแแแแแแ แกแแแฃแจแแ แจแแแซแแแแ แแแแแแงแแแแก แกแฎแแ แแแกแขแ แฃแแแแขแ. แแแแแ แแฅแแแแ แแ แแแกแ แแ แแแแ แแแแก แแแแแแแ แแฎแแแแ แแ แ แแแแขแคแแ แแแแ แแ แแก แจแแ แกแแญแแ แแขแแแ แแแแแฌแงแแแขแแแแแ. แแแ แแ แแแแกแ, แแแแ แ แแฎแแแ AWS แกแแ แแแกแ แฎแจแแ แแ แฎแแแแแกแแฌแแแแแแ Terraform แแแแฃแแแก แกแแฎแแ, แกแแแแ แแกแแแ แฎแแแแแกแแฌแแแแแ แแฅแแแแ CloudFormation-แจแ.
แแแจแแแแแก แฎแแแกแแฌแงแแแแ
แแแแแกแแแแ แ แแแแแแแแ แแแแก แแ แแแฅแขแแก แกแแแแแแ แแแแแแแ แแแแแแแชแแแก แฌแแ แแแแแแจแ แแแจแแแแ. DevOps-แแก แกแแแงแแ แแจแ แฉแแแ แแแกแฃแ แก แกแ แฃแแแ แแแชแแแแ แฉแแแแก แแแ แแแแกแแแ แแแแแแจแแ แแแฃแแ แงแแแแ แจแแกแแซแแ แแ แแแแแแแก แจแแกแแฎแแ แแ แแกแแแ แแแแแแ แแแแแแฃแแแแแ แแแแแงแแแแแ แฎแแแแ แฉแแ แแแ. แแแจแแแแแก แแแกแขแ แฃแแแแขแแแแก แกแฌแแ แ แแแแ แแแแก แแ แฉแแแ แแฃแชแแแแแแแแ แแแแแแแชแแแก แแแแแแแแ แแแแก แแแ แแแแแก แแแกแแฆแฌแแแแ.
แแแจแแแแแก แแแกแขแ แฃแแแแขแแแแก แฅแแแแแขแแแแ แแแแ:
- X-as-a-service (XaaS)
- แแ แแแกแขแ แแ แแแ
- แแแแแขแแ แแแแ
- แญแ แแก.
X-tool-as-a-service #1
แแแแแ แฏแแแแฃแแ: Amazon แแแ แกแแ แแแกแแแ
Amazon แงแแแแแแแแก แแงแ แแแแแ แ แฆแ แฃแแแแแแแ แขแแฅแแแแแแแแแแก แกแคแแ แแจแ, แแแแ แแ แแก แแ แฉแแ แแแแ: แแแแแแแแแ แแแแกแแแแก แแฎแแแ แกแแ แแแกแแแแก แแ แแแแแคแแ แแแแแแ แแแแแแกแแแแญแ แแแแ. แแแแขแแแแ แแแแแกแแแแ แ แขแแฅแแแแแแแ แแ แจแแแแแแ AWS-แจแ แแ แแก แแจแแแแแแ แแ แแแจแแแแฃแแ แแฅแแแแ. แฎแแแกแแฌแงแแก แฆแแ แแแฃแแแแ แกแแแแแแ แแแแแแ แฃแแแ: แจแแแแแ แแ แแแ แแฅแแแแก แกแแแฃแแแ แแแแแชแแแแ แชแแแขแ แจแ แแฆแญแฃแ แแแแแแแก แแฌแงแแแแก, แแแ แแแแกแ แแ แจแแแแ แฉแฃแแแแแก. แฃแคแแกแ แแแ แกแแ แกแแจแฃแแแแแแก แแแซแแแแ แฉแแแขแแ แแ แแฅแกแแแ แแแแแขแแแ แแ แแแแฆแแ แกแฌแแ แ แแแแแฌแงแแแขแแแแแ แคแฃแแแก แแแฎแแ แฏแแแแแ.
แซแแ แแแแแ แกแแ แแแแแแ
- แแแแ แชแแแแแ - แแฃ แแแฅแแ AWS-แจแ แแแแแแแชแแแแแก แจแแฅแแแแก แแแแแชแแแแแแ, แจแแแแซแแแแ แแแแแกแแแแ แแแแแแแก แแแฃแจแแแ. แแแแแแกแแแก แฃแงแแแ แ AWS แแ แกแขแแ แขแแแแแ แแกแแแ แแคแแกแแแแ แแแก แแแแแ แฆแแ แแแฃแแแแแก.
- แฃแคแแกแ แแแ แกแแ แแ แแก แแแ แแแแช แแแแจแแแแแแแแแ แคแแฅแขแแ แ, แ แแแแแแช แแแแแกแฎแแแแแแก AWS-แก แแแแแขแแแแแแกแแแ. แแแแ แแแแแชแแ แแชแแแ แกแแ แแแกแ แแ แแแแฎแแ แ แแแแ แแฃแจแแแแก, แกแแแแ แงแแแแแก แแแแแฌแงแแแขแแแแแแก แแแแแฆแแ, แแ แแแแแ แแแแกแแแแ แแแแแ แแก แแแฎแแ แฏแแ แแ แแกแแญแแ แแแ. แฃแคแแกแ แแแ แกแแ แงแแแแแแแแก แกแแแแแ แแกแแ แฉแแแแแแก แแแแแกแแแแ แ แแแแชแแคแชแแแก แจแแกแแแแฌแแแแแแ.
แแแแแฃแ แแแขแแแ
แแแแแฌแแแแแแ แแแแฆแ แแ แซแแแแจแ, แแแแ แแ แแ แแแแแ
Azure โAzure-แแ แแแแ แแแ แแแแแ แ แแแ แแแแ แแแแแกแแแแแแ แแ แแก แแแกแแคแแกแแแแแแ. แแฃแแชแ, แแแแกแฎแแแแแแฃแแแแแก แกแฃแ แแแแแ แแแแแแฌแแแ แกแแ แแแกแแแแก แฃแชแแแฃแ แ แกแแฎแแแแแ, แ แแช แฎแจแแ แแ แแ แแฃแแแแก แกแแฅแแแก. แ แแก แแแจแแแแก "แแแแแแแแก แจแแแแฎแแ"? แแ แแแฃแฎแแแแแแ แแแแกแ, แ แแ .NET แแแแ แฃแแแแแกแแ แแฃแจแแแแก Microsoft-แแก แแแแกแแกแขแแแแจแ, แแแแแแแแ แกแแแแ แแฃแแแ, แ แแ แแฅแแแ แแแแแแงแแแแแ แแฎแแแแ .NET-แก แแฅแแแแ แแแแแแแชแแแก แงแแแแ แแแแแแแแแขแแกแแแแก.
Heroku โ แแแ แแกแแ แแก แแแแฃแจแแแแแ แ แแแแแก แแแ แแ แแแ แแแ แแ แแแฅแขแแกแ แฐแแ แแแฃแแ, แกแแแแแแแแแแกแ แแ แแแแญแแแ แแแแแแแก แแแแแแ แแแแแก แแแแ, แแแแขแแ แแแแแแแแแแแ แแ แฃแแแ แแแแแแงแแแแ แแแ แ แแแแ แช แแแแขแคแแ แแ. Heroku แจแแกแแแแจแแแแแ แแแแแแ แ แแฆแแชแแก แแแแแแกแขแ แแ แแแแกแแแแก, แแแแ แแ แแ แแฅแขแแแฃแแ แแแแแงแแแแแแกแแแแก - "แแ แ, แแแแแแแ!"
#1 แกแแแ แแแกแขแ แ แแแกแขแ แฃแแแแขแ
แแแแแ แฏแแแแฃแแ: openshift
แแฅแแแ แแแแแ แแงแแแแแ Docker-แก แแ แกแฎแแ แแแแขแแแแแ แแแก แแฅแแแแ แแแแแแแชแแแก แแแกแขแแจแ. แกแแ แแแ แแก แแแ แแจแ แแ แแแ แแแแแ แจแแกแแแแจแแแแแ, แแแแ แแ แแกแแแ แจแแแซแแแแ แแ แแแแ แแแก แงแแแแ แแ แฅแแขแแฅแขแฃแ แแก. แกแแแ แแแกแขแ แ แแแแขแคแแ แแแก แแแ แแจแ แแแแขแแแแแ แแแแก แแแจแแแแ แฃแแ แแแแ แแ แแแฃแจแแแแแก. Kubernetes Core (K8s) แจแแฃแแแ แแแแแแ แฃแกแแคแ แแฎแแแแแกแ แแ แฎแแแกแแฌแงแแแแแก แแแแแกแแแ แแกแแ. OpenShift แแ แแก แแ แแแแแ แแ Kubernetes-แแ แแแคแฃแซแแแแฃแแ แแแแขแคแแ แแ, แ แแแแแกแแช แจแแฃแซแแแ Source2Image-แแก แจแแแ แแแแแ, แแฎแแ แก แฃแญแแ แก แแแขแแแแขแฃแ แแแแแแแแแแก แแแแแแจแ แแ แแฎแแ แก แฃแญแแ แก แแแแแแแแแแก แแ แแแแแขแแ แแแแก. OpenShift แจแแแซแแแแ แแแจแแแแฃแแ แแงแแก on-prem, แฆแ แฃแแแแจแ, แแ on-prem แแ แฆแ แฃแแแแจแ แแ แแแ แแฃแแแ.
แซแแ แแแแแ แกแแ แแแแแแ
- แฉแแแแแขแแแแแฃแแ แฃแกแแคแ แแฎแแแแ - K8s แฃแกแแคแ แแฎแแแแแก แแแ แแแแก แจแแแซแแแแ แแแกแญแแ แแแก แแแฌแแแแแ แฎแแ แแกแฎแ. แงแแแแ แแแขแแแ แแแ แแแ แฃแแแ แแงแแก แแแแแ แแแฃแแ แแ แแแแแแแแกแฌแแแแแฃแแ! แแแแฃแแแกแฎแแแแแ แฉแแจแแแแแฃแแ แฃแกแแคแ แแฎแแแแแก แแแฅแแแแแแแแ OpenShift-แแ แแ แแแแแก แขแแแ แแก แแแแแแแแแ แแแก แแ แฃแแ แฃแแแแแงแแคแก แฃแคแ แ แฃแกแแคแ แแฎแ แแแแขแคแแ แแแก แแแแแแแชแแแแแกแแแแก.
- All-in-one แแแแแฌแงแแแขแ - แซแแ แแแแแ K8-แแแแกแแแ แแแแกแฎแแแแแแแ, แ แแแแแแแช แแแแฃแแแกแฎแแแแแ แแ แจแแแชแแแก แแแขแแแ แแแแก แแแแแแแแกแแแแก แแแกแขแ แฃแแแแขแแแก, OpenShift-แก แแฅแแก แแก แงแแแแแคแแ แ. แแ แจแแแแซแแแ แแแกแ แแแแแงแแแแแ แแแแขแแแแแ แแแแก แจแแกแแฅแแแแแแ แแ แฐแแกแขแแแแแกแแแแก, CI/CD แแแกแขแ แฃแแแแขแแแแก แแแกแแจแแแแแ, แแแ แ แแ แแชแแกแแแแก แแแ แแแแกแแแแก, แแแกแแฆแแแแแแก แแแ แแแแกแแแแก แแ แแ แแแแแ แกแฎแแ. แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแแแฎแแแ แแแแแก แแ แแคแแแฃแแ แแแขแแ แคแแแกแ แฏแแ แแแแแ แจแแ แก แแ แแก แกแ แฃแแงแแคแแแแกแแแ, API-แแ แแแคแฃแซแแแแฃแแ แแแแแแแ แแแจแแแแก, แ แแ แงแแแแแคแแ แ แจแแแซแแแแ แแฆแฌแแ แแแ แแงแแก แกแแ แแแขแจแ. K8-แแแแก แกแฎแแ GUI-แแแแกแแแ แแแแกแฎแแแแแแแ, OpenShift แแแแแแแแแก Kubernetes-แแก แกแแคแฃแซแแแแแแก แกแฌแแแแแก. แแฅแแแ แแ แช แแ แแญแแ แแแแแ แแแแแแแแก แแฆแแแ!
แแแแแฃแ แแแขแแแ
แแแแแฌแแแแแแ แแแแฆแ แแ แซแแแแจแ, แแแแ แแ แแ แแแแแ
แแแแแ แแก แแ แแแ โ Docker Swarm แชแแแแแแแ K8-แแแแก แแแแแ แขแแแแแแก แแแแ แ แ แแแแกแแแ แแแแแก แแแฆแฌแแแแ. แแก แจแแกแแแแจแแแแแ แแชแแ แ แแแแแแแชแแแแแกแแแแก, แแแแ แแ แกแแฌแแ แแแก แแแแแแแชแแแแแกแแแแก แแก แฃแแ แแแแ แแ แแฃแจแแแแก. แแแ แแ แแแแกแ, แแแแแฌแงแแแขแแแแแแแ, แ แแแแ แแชแแ AWS ECS, แแกแแแแก แแแแแแแแก แแงแแแแแก, แแแแ แแ แแแแ แขแแแแแก แแฃแจแแแแแก แกแฎแแ แกแแ แแแกแแแแแ, แ แแแแแแแแแแช แแกแแแ แจแแแแซแแแ แฃแ แแแแ แแแแ (Lambda, IAM แแ แ.แจ.).
แแแแแขแแ แแแแแก แแแกแขแ แฃแแแแขแ #1
แแแแแ แฏแแแแฃแแ: แแฎแแแ แ แแแแฅแแแ
New Relic-แแก แแแ แแฃแแแ แแแแแจแแแแแแแ แแแ แแแ แแแแแแแแก แแ แแ แ แแ - APM (Application Performance Monitoring) แแแแแขแแ แแแแ. แแฎแแ แแก แแ แแก แกแ แฃแแคแแกแแแแแ แแแแแขแแ แแแแแก แแแกแขแ แฃแแแแขแ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแขแ แแแแ แกแแ แแแ แแก, แแแแขแแแแแ แแก, แแแแแชแแแแ แแแแแก แแฃแจแแแแ, แกแแแแแแ แแแแฎแแแ แแแแแก แแแแแชแแแแแแแก แแแแแขแแ แแแแ แแ, แ แ แแฅแแ แฃแแแ, แแแแแแแชแแแก แแฃแจแแแแแก แแแแแขแแ แแแแ.
แซแแ แแแแแ แกแแ แแแแแแ
- แแแแแงแแแแแแก แกแแแแ แขแแแ - แ แแแแกแแช แแแฃแจแแแแแ แกแแกแขแแแแแแก แแแแแแ แแ, แแแงแแแแแแ แแแแแขแแ แแแแแก แแแแ แแแกแขแ แฃแแแแขแก, แแแแ แแ แแ แแกแแแแก แจแแแฎแแแแ แแ แแกแแแ แแแ แขแแแ แแ แแแ แขแแแ แแแแแกแแงแแแแแแแ, แ แแแแ แช New Relic. แแก แแ แแก SaaS, แแกแ แ แแ แแฅแแแ แแ แแญแแ แแแแแ แแแกแ แแแงแแแแแ.
- แแแแแแแ แแแแแแแ แฎแแแแแแแแ - แกแฎแแ แฎแแแกแแฌแงแแแแ แชแแแแแแแ แแแแแแแขแ แแแแ แแฅแแแแ แแแแแแแชแแแก แแ แแ แแแแแ แแขแฃแแ แแแแแแแขแ. แแแแแแแแแ, แแ แแชแแกแแ แแก แแแแแงแแแแแแก แแ แฅแกแแแแก แขแ แแคแแแแก แแแขแ แแแ, แแแแ แแ แแก แงแแแแแคแแ แ แกแ แฃแแงแแคแแแแ แฃแแแ แแงแแก แแแแแขแแ แแแแ, แ แแ แแแแแแแชแแแ แกแฌแแ แแ แแแฃแจแแแก. New Relic แแแซแแแแ แจแแกแแซแแแแแแแแก แจแแแ แแแแ แงแแแแ แแฅแแแแ แแแแแชแแแแแ, แ แแแ แแแแฆแแ แงแแแแแกแแแแชแแแแ แฎแแแแ แแแแแ, แแฃ แ แ แฎแแแแ.
แแแแแฃแ แแแขแแแ
แแแแแฌแแแแแแ แแแแฆแ แแ แซแแแแจแ, แแแแ แแ แแ แแแแแ
แแแแฅแกแ โ แฉแแแ แแแ แแแแ แแ แกแแงแแแ แแแ แแแแแขแแ แแแแแก แกแแกแขแแแ, แแแแ แแ แแก แฌแแ แกแฃแแจแ แแแ แฉแ แฆแ แฃแแแแแแแ แขแแฅแแแแแแแแแแก แแแแแแแแ แแแแก แแแแแแแแแแก แแแแ แแ APM แแแแแแแชแแแก แจแแกแ แฃแแแแแก แแแแแขแแ แแแแแก แกแคแแ แแจแ. Zabbix แฏแแ แแแแแ แแแ แแแ แแแแแแแก แกแแ แแแ แแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แขแ แแแแชแแฃแ แแแแแขแแ แแแแก, แแแแ แแ แแก แแกแแ.
แแแแแชแแแแ แซแแฆแแ โ แแแแแแขแแ แแ แแแแขแแ แแแฃแแ แแแแแแแชแแแก แกแแฌแแ แแแ แแแ แแแแก แแแ แแแแก แแ แแชแแกแแ แแ แแ แ แแแแแ แแแแแ. DevOps แแฃแแแแแแแ แแ แแแ, แ แแแแแแแช แฉแแ แแฃแแแ แแ แแแ แแแแแแแแแ แแแแแ, แฉแแแ แแ แฃแแแ แแแแแงแ แแแแ แ แแฃแ แแแแแกแแงแแแแแแ แแแกแขแ แฃแแแแขแแแก แฃแแแฆแแแกแ แแแแแก แแฎแแ แแแญแแ แแก แฃแแ แฃแแแแแกแแงแแคแแ.
แแฃแ แแแแแก แแแกแขแ แฃแแแแขแ #1
แแแแแ แฏแแแแฃแแ: แแแฆแ แแแแแแ
Splunk-แแแ แแแแแฃแ แแแชแแ แ แแฃแแแ! แแแแ แฎแแแก แแแแแแแแแแแจแ แแก แ แฉแแแ แแแแแ แ แฎแ-แขแงแแก แฌแแ แแแแแแจแ แแ แแแ แซแแแแแก แแแแก แกแฎแแแแแ แฃแแแแแกแแ. On-prem แแ SaaS แจแแแแแแแแแแแแ, แจแแแแซแแแแ แแแแแแงแแแแ Splunk แงแแแแแแ. แแแแ แแแแฃแกแ แแ แแก แแแกแ แคแแกแ: Splunk แฏแแ แแแแแ แซแแแ แแ!
แซแแ แแแแแ แกแแ แแแแแแ
- แแแแญแแแ แแแแแแ - แแแแแแกแแแก แฃแงแแแ แ Splunk แแ แแแแแแแแแแก แแฅแแ แคแฃแแ แแแกแ แจแแกแแซแแแแ.
- แแแฃแฎแแแแแแ แแแแกแ, แ แแ แกแขแแ แขแแแแแ แฎแแ แฏแแแแก แแแแแฆแแฃแ แแแแก แชแแแแแแแ, แแแแ แ แคแฃแแฅแชแแแก แแแแแญแ แ แจแแกแแซแแแแแแแ แฆแแ แแแแแก แแแแแแแแแแก แฌแงแแแแแแ.
- แจแแแแ แฉแฃแแแแแก แฃแแแ แ - แแแ แขแแแแ แ แแ แแแฅแแแ, Splunk แแฃแจแแแแก แแ แแแ แแแ แแแแแแแก. แแแก แแแแฉแแแ แแ แแแแแ แแแแฃแแแกแฎแแแแ แแแ แแแแขแ แ แแ แคแฃแแฅแชแแ, แ แแแแแแช แแแแ แแ แแก แแแแแกแแงแแแแแแแ. แแ แแ แแก แกแแญแแ แ แแ แแแก แแแแแ แแแ แแแแฃแแแแขแแชแแแก แฌแแแแแฎแแแจแ แแ แชแแแแแแ, แ แแ Splunk-แแ แแแฃแจแแแก แแ แแแแจแแคแ แแก แ แแแแ.
แแแแแฃแ แแแขแแแ
แแแแแฌแแแแแแ แแแแฆแ แแ แซแแแแจแ, แแแแ แแ แแ แแแแแ
ELK Stack (ElasticSearch, LogStash แแ Kibana) โแ แแแแ แช แฉแแแก, แแก แฎแแแกแแฌแงแแแแ แคแแแแ แแขแแ, แ แแแแแ แแแแ แแแแแกแแงแแแแแแแ แฆแแแซแแแก แแแงแแแแแช แแ แแ แแญแแ แแแแแ.โ แแฃแแชแ, แ แแแแ แช แแฃแ แแแแแแแก แแแแ แแแ แแแ แแแแ แแ แแแ แขแแ แแแแแชแฎแแแแแแก แ แแแแแแแแ แแแ แแแแ, แแฃแจแแแแ แฃแคแ แ แแ แฃแคแ แ แ แแฃแแ แฎแแแแ. Splunk-แแแ แจแแแแ แแแแ, ELK Stack-แแ แแ แแแแ แแ แแแขแ แแ แ แแแแฎแแ แฏแ แแแกแขแ แฃแแแแขแแแแก แแแงแแแแแแแแ แแแแแกแแแแ แ แแแคแแก แจแแฅแแแแแแ, แแแแ แ แแแแกแแ แแฅแแแแ.
แแแแแแจแ แแแแแแแก แแแกแขแ แฃแแแแขแแแ
DevOps, แฃแแแ แแแแแก แงแแแแแกแ, แแฎแแแ แแ แแแแแแแชแแแก แแฃแแขแฃแ แแก แจแแชแแแแก. แแแแแกแแแแ แ แฎแแแกแแฌแงแแก แงแแแแ แแ แจแแชแแแแก แแแแแแแแ แ แแ แแฅแขแแแแก แแ แ แฆแแแแจแ, แแแแ แแ แแแก แแแแแแแแแ แจแแฃแซแแแ แฌแแแฎแแแแกแแก แแแแแแจแ แแแแแแ แแ แฃแ แแแแ แแฅแแแแแแแก แแฎแแแ แแแแแ.
แแแแแแจแ แแแแแแแก แแแกแขแ แฃแแแแขแแแแก แฅแแแแแขแแแแ แแแแ:
- แแแแแแแแแก แแแแแงแฃแ แแก แแแแแแแ
- ChatOps
- แแแแฃแแแแขแแชแแ.
#1 แกแแแแแฎแแก แแแแแแแแแแก แแแกแขแ แฃแแแแขแ
แแแแแ แฏแแแแฃแแ: Jira
แฏแแ แ แแแแ แฉแฃแแแแก แแแแแ แแก แแแแแชแแแก, แแฃแแชแ แแแแแฃแ แแแชแแ แแ แกแคแแ แแจแ แแแ แแแแ. Jira-แก แฌแแ แแแฃแแแแแแแ แแแฅแแแแแแ แกแแจแฃแแแแแแก แแซแแแแก แแแแแแแแ แแแแกแ แแ แขแแฅแแแแฃแ แ แแฃแแแแแก แแแ แแแ แแ แแแฅแขแแก แกแแแฃแจแแแแแ แแ แกแแ แแแขแแก แแแแชแแแแแ. แฉแแจแแแแแฃแแ แกแขแแแแแ แขแแแ Agile แขแแ แแแแแแแแแแก แแแแแงแแแแแแ แแแแแแแแแก แแฃแจแแแแแก แขแ แแแแชแแฃแแ แแแแแแแแ แฃแคแ แ แแคแแฅแขแฃแ แแ แแชแแกแแแแ แแแแแกแแแแก.
แซแแ แแแแแ แกแแ แแแแแแ
- แแแแฃแแแ แแแ - แแกแแแ แ แแแแ แช แแแแ แ แกแฎแแ แแแกแขแ แฃแแแแขแ, Jira แแแแแแงแแแแแ แแแแฅแแแก แงแแแแแแ. แแชแแ แ แแฃแแแแแ แแงแแแแแแ แฃแคแ แ แแแค, แฃแคแ แ แฎแแแแแกแแฌแแแแ แแแ แกแแแก แแ แแฆแแแแ แงแแแแแคแแ แก, แ แแช แแแ แกแญแแ แแแแแ, แฎแแแ แแแ แแแแแแแแแแก แจแแฃแซแแแแ แฃแคแ แ แซแแแ แ แแแชแแแแแแก แจแแซแแแ.
- แแแขแแแ แแชแแแแ - แฏแแ แ แแแแแแ แแ แแแแแก แกแคแแ แแจแ. แแก แคแแฅแขแ แแ แแ แแแฃแฅแขแแก แกแฌแ แแคแ แแแแแแแแ แแแ แแแแแแแ แแแแแก แแแแก, แ แแ แกแฎแแ แแแแแแแแแแ แแ แฉแแแแ Jira-แก แกแแแฃแแแ แ แแแขแแแ แแชแแแก แจแแกแแฅแแแแแแ, แ แแแแช แแแแ แแแก แฎแแแกแแฌแงแแก แฆแแ แแแฃแแแแแก. แฉแแแ แจแแแแแซแแแ แแแแแแ แแแแแแ Jira แแ แกแขแแขแแแจแ แฉแแแแแแแแ แงแแแแ แแแกแขแ แฃแแแแขแแแ, แแชแแ แ แแแแคแแแฃแ แแชแแแ.
แแแแแฃแ แแแขแแแ
แแแแแฌแแแแแแ แแแแฆแ แแ แซแแแแจแ, แแแแ แแ แแ แแแแแ
Trello โ Trello-แ แกแฌแ แแคแแ แแแแแแแ แแแแฃแแแ แแแ แแแกแ แฃแคแแกแ Kanban แแแกแขแ แฃแแแแขแแก แฌแงแแแแแแ. แแฃแแชแ, แแแก แจแแแแแ แ แแช แแ แแชแแกแแแ แแแกแจแขแแแฃแ แแแแ แแ แแแแแแ แแแแแแแแแแแ แแแแกแแแแ แแแแแฎแแแแ, Trello-แก แแแแแแแชแแ, แซแแแแ แแ แแแฎแกแแแแแ แแแฃแญแแ แแแแ.
Pivotal Tracker โ แแ แฎแแแกแแฌแงแแก แแแแ แคแแแ แแแงแแแ, แ แแชแ แกแขแแ แขแแแจแ แแแฃแจแแแแแ. แแแแกแแแ, Pivotal Tracker แฃแคแ แ แแแขแแ แแ แแก แแ แแแแขแแ แแแฃแแ แแ แแแฃแฅแขแแก แแแแแฏแแแแขแแ, แแแแ แ แขแแฅแแแแฃแ แแแแชแแแแแแ. แแแฃแฎแแแแแแ แแแแกแ, แ แแ แฏแแ แแจแ แแ แแแฃแฅแขแแก แแแแแฏแแแแขแ แชแแขแ แฃแคแ แ แ แแฃแแแ, แแก แแแแแช แจแแแซแแแแ แแฅ แแแแฎแแ แชแแแแแแก แแแแแขแแแแแ แฎแแแกแแฌแงแแก แแแแแงแแแแแแก แแแ แแจแ.
ChatOps แแแกแขแ แฃแแแแขแ #1
แแแแแ แฏแแแแฃแแ: MatterMost
แแแแแแ แขแแแ: แแแแแ แงแแแแแแ แแแแ แกแแฃแ แแ แแแ แจแแแแแแก แฉแแแก แแ แฉแแแแแจแ แแ แแก แแแ แแ แแแแแแแ! MatterMost-แแ แแแแฃแแแ แแแ แแแแแแแ แฌแแแ แฎแแแกแแฌแงแแแแแแแ แกแแฃแแแแแกแแก แแฆแแแแ, แแแแ แแ แแแแ แแ แแแแ แแแงแแแแแแ. แแก แซแแแแแ แแแแจแแแแแแแแแแ แแแแแแแแแแแกแแแแก: MatterMost แแแซแแแแ แกแแจแฃแแแแแแก แแแแแขแ แแแแ แแฅแแแแ แแแแแชแแแแแ แแ แแกแแแ แแแฎแแแ แแแแ แแแแ แแแขแแแ แแ แแแ แแแกแขแ แฃแแแแขแแแแแ, แ แแแแแแแช แแฃแจแแแแแ แแแแแแแแ แแแแ. แฉแแแ แแฆแแ แแแญแแ แแแแ แแแกแแแ firewall-แแก แแแ แแ แกแแแฃแจแแ แฉแแแแแแก แจแแกแแแแฌแแแแแแ.
แซแแ แแแแแ แกแแ แแแแแแ
- แฆแแ แฌแงแแ แ โ MatterMost-แแก แฆแแ แแแแแก แแแ แกแแ แแจแแแแแแ แแ แแฃแจแแแแก แ แแแแ แช แกแแจแฃแแแ, แแกแแแ แแแแ แแฃแแแแแแกแแแแก. Slack-แแก แฃแคแแกแ แแแแแแกแแแ แแแแกแฎแแแแแแแ, แ แแแแแแช แฌแแจแแแก แแฅแแแแก แจแแขแงแแแแแแแแแแก แแกแขแแ แแแก, แกแแแฃแแแ แ แกแแ แแแ แแก แแแจแแแแ แแแจแแแแก, แ แแ แแแแฎแแแ แแฅแแแแก แงแแแแ แแแแแชแแแก.
- แแแขแแแ แแชแแแแ - แแแแแแแแ API แแแแฅแแแก 100% แแแคแฃแซแแแแฃแแแ Slack API-แแ, แแแแฅแแแก แงแแแแ Slack แแแขแแแ แแชแแแก แแแแแงแแแแแ แจแแกแแซแแแแแแแ แแแ แแแแแ MatterMost-แแแ.
แแแแแฃแ แแแขแแแ
แแแแแฌแแแแแแ แแแแฆแ แแ แซแแแแจแ, แแแแ แแ แแ แแแแแ
Slack โ แกแแแแ แแแแแ แแ, แแแแ แแ แแก แแแญแแแ แแกแ แแแแแแ แแแแ, แ แแ แแแแแแแก แซแแแแ แแแแฌแงแแก. แแฎแแแแแแแ แแแแแแกแแก แแแแแฆแแฃแ แแแแแ แคแแแ, แ แแแแแแช แแ แแแแแก แแแ แซแแ แแแแ แฆแแ แแแฃแแแแแก: Slack-แแ แฃแกแแกแงแแแแแ แฃแแ แฃแแแแแงแ แกแแ แแแกแแแ; แฃแคแแกแ แแแ แกแแแก แงแแแแแแ แแแแจแแแแแแแแแ แแแแฃแกแ แแ แแก แฉแแขแแก แแกแขแแ แแแก แฌแแจแแ.
Microsoft แแฃแแแแแ โ แกแชแแแแ Microsoft-แแก แแ แแแฃแฅแขแแก แแแขแแแ แแ แแแ แแแกแจแ, แ แแแแแแช แแ แแแฃแแแแแก Microsoft-แก... แฌแแ แแแขแแแแแก แแแกแฃแ แแแแ! แแก แแ แแก แงแแแแแคแแ แ, แ แแช แแ แฃแแแ แแแฅแแ แแ แฎแแแกแแฌแงแแก แจแแกแแฎแแ!
แแแแฃแแแแขแแชแแแก แแแกแขแ แฃแแแแขแ #1
แแแแแ แฏแแแแฃแแ: แจแแกแแ แแแแแแ
แฎแแ แแกแฎแแก แขแแฅแแแแฃแ แ แแแแฃแแแแขแแชแแแก แจแแฅแแแ แแ แจแแแแ แฉแฃแแแแ แ แแฃแแ แแ แแชแแกแแ, แแแฃแฎแแแแแแ แแแแกแ, แแฃ แ แ แแแกแขแ แฃแแแแขแก แแงแแแแแ. แแแฃแฎแแแแแแ แแแแกแ, แ แแ แชแแขแ แฎแแแก แฌแแ แแแแแ แแ แจแแแแแแแ แแ แแแแแ SaaS แแแแฃแแแแขแแชแแแก แแแกแขแ แฃแแแแขแ, แแแแแญแแ แแแแ แขแแฅแแแแฃแ แ แแแแฃแแแแขแแชแแแก แจแแแแฎแแ แแแกแแแก แแ แแขแแแฃแแ แแแแแแแชแแแแแก แจแแกแแฎแแ แแแกแแแ แแฎแแ แแก. แกแแกแฃแ แแแแแ แแแแแชแแแแแแก แแ แแแแฃแแแแขแแแแก แจแแแแฎแแ แแ แแแแ แแ แแกแ แฌแงแแแขแก Confluence.
แซแแ แแแแแ แกแแ แแแแแแ
- แแแ แขแแแ แแฃแจแแแแ - แแแแแฃแแแแแแแแ แฎแแแกแแฌแงแแแแแก แฃแแแขแแกแแแ แจแแแซแแแแ แแงแแก แชแแขแ แ แแฃแแ แแแงแแแแแ แแ แคแฃแแฅแชแแแแแ แแแ แแ แกแแญแแ แแแแก แแแ แแแแฃแ แชแแแแแก แจแแกแแแแ แฉแฃแแแแแแ. Confluence Server แแจแแแแแแ แแ แแฃแจแแแแก 10 แแ 10,000 แแแแฎแแแ แแแแแกแแแแก.
- แแแแแแแขแแแ - แแแแแแ Confluence-แก แแแแแแ, แแแแแแแ แแแแแกแแงแแแแแแแ แแแแแแแชแแแกแแแแก แแ แแแแฅแแแก แงแแแแแคแ แแกแแแแก แแแแแแแขแแก แแแแแขแแแแก แจแแกแแซแแแแแแแแกแแแแก, แฎแกแแแก แแแแแก แแกแแแแก แแแขแแแชแแแแก.
แแแแแฃแ แแแขแแแ
แแแแแฌแแแแแแ แแแแฆแ แแ แซแแแแจแ, แแแแ แแ แแ แแแแแ
แฌแแแแแแฎแแ แแแแฃแแแแขแแแ โ แแแแแ แแ แฆแแ แแแแแกแแแแก, แแแแ แแ แแ แช แแคแแฅแ แแ แแฅ แแ แแขแแแฃแแ แชแแแแแก แจแแแแฎแแแแ.
แแแ แแแแฃแแ - แจแแกแแแแจแแแแแ แแแแแก แแแแฃแแแแขแแชแแแกแแแแก, แแแแ แแ แ แแฃแแแ แแ แฅแแขแแฅแขแฃแ แแก, แแ แแชแแกแแแแก แแ แกแฎแแ แขแแแแก แแแแฃแแแแขแแชแแแก แแแแแฅแแแงแแแแ MarkDown-แแก แกแแแชแแคแแแฃแ แ แคแแ แแแขแแ แแแแก แแแแ.
Jekyll โ แขแแฅแแแแฃแ แ แชแแแแแก แแแแฃแแแแขแแ แแแแกแแก, แแ แแแแแ แจแแแฅแแแ แแฎแแแ แกแขแแขแแแฃแ แ แกแแแขแ, แ แแแแแแช แแแแแแแแแแ แงแแแแ แฏแแ แแ, แ แแชแ แแฅแแแแ แชแแแแแแแ. Confluence-แแก แแแ แขแแแ แแแ แกแแแแแก แแแแขแ แแแแก แกแแกแขแแแ แแแแจแแแแแแแแแ แแแแ แขแแแแแก แจแแแ แแแแฃแแแแขแแชแแแก.
แจแแแฏแแแแแก
แแแแแ แแ แคแแฅแขแแฃแ แแ แแกแแแแ DevOps แแแกแขแ แฃแแแแขแแ, แ แแช แแ แแฃแแแแก แแแแก แชแแแแแก, แแฃ แ แแแแแ แฃแแแ แแแแแแงแแแแ แแ แ แแแแก แฃแแแ แแแแฎแแ แชแแแแแแก. แแแฐแงแแแแ แแ แแแ แขแแ แกแแฎแแแแซแฆแแแแแแแก DevOps แแแกแขแ แฃแแแแขแแแแก แแ แฉแแแแกแแแแก แกแ แฃแแ CI/CD แแแแกแแแแแแกแแแแก.
แแแ แฌแแฃแแแแ, แ แแ แจแแแ แฉแแแ แแแกแขแ แฃแแแแขแแแ แฎแฃแแแแ แแแขแแแแ แแแแแ:
- แแแกแขแ แฃแแแแขแแแแก แแแแแแแแ แแแ แแ แจแแฅแแแ
- แขแแกแขแแก แแแขแแแแขแแแแชแแแก แแแกแขแ แฃแแแแขแแแ
- แแแแแแแแแแก แฎแแแกแแฌแงแแแแ
- แแแจแแแแแก แฎแแแกแแฌแงแแแแ
- แแแแแแจแ แแแแแแแก แแแกแขแ แฃแแแแขแแแ.
แแแแแแ แ แ แแแแแแแแแชแแ: แงแแแแแคแ แแก แแแขแแแแขแแแแชแแ!
แแแแแแแ แแแ แจแแแแ แแก!
แฌแงแแ แ: www.habr.com