From 3b2e5f15a45d9455795052ebb7d375bb019c56d3 Mon Sep 17 00:00:00 2001 From: Catur Wirawan Wijiutomo Date: Tue, 27 Dec 2022 21:57:39 +0700 Subject: [PATCH 01/14] first factor app translation in Indonesia --- content/id/codebase.md | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 content/id/codebase.md diff --git a/content/id/codebase.md b/content/id/codebase.md new file mode 100644 index 000000000..c16193897 --- /dev/null +++ b/content/id/codebase.md @@ -0,0 +1,19 @@ +## I. codebase +### Satu codebase dilacak dalam kendali revisi, banyak deploy + +Sebuah duabelas-faktor app selalu terlacak dalam sebuah sistem kendali revisi, semacam [Git](http://git-scm.com/), [Mercurial](https://www.mercurial-scm.org/), atau [Subversion](http://subversion.apache.org/). sebuah salinan dari basis data pelacakan versi dikenal sebagai *code repository* atau hanya *repo*. + +suatu *codebase* adalah sebuah repo (dalam sebuah sistem kendali revisi terpusat seperti Suberversion), atau dari set repo yang berbagai sebuat akar commit (dalam sebuah sistem kendali revisi terpisah seperti Git). + +![satu codebase terpetakan ke banyak terapan](/images/codebase-deploys.png) + +selalu ada korelasi satu ke satu antara codebase dan app. + +* Jika ada banyak codebase, maka itu bukanlah sebuah app -- itu adalah sistem terdistribusi. Setiap komponen dalam sebuah sistem terdistribusi adalah sebuah app, dan setiap app tersebut dapat secara individual comply dengan duabelas-faktor. +* app berbeda yang berbagi kode yang sama adalah sebuah pelanggaran dari duabelas-faktor. solusi untuk persoalan ini dengan menerapkan kode yang dipakai app berbeda tersebut ke dalam libraries yang diikutkan melalui [manajer dependency](./dependencies). + +Hanya ada satu codebase per app, namun akan ada banyak penerapan dari sebuah app. sebuah *deploy* adalah instansiasi berjalan dari sebuah app. Hal ini umum diterapkan sebuah situs produksi dan di satu atau beberapa situs percobaan. Tambahan lain, setiap developer memiliki sebuah salinan dari app yang berjalan di lingkyungan pengembangan lokal masing-masing, setiap dari itu dapat dianggap sebagai sebuah deploy. + +Codebase sama untuk seluruh deploy, walaupun terdapat versi berbeda yang aktif di setiap deploy. contohnya, seorang developer mungkin memiliki beberapa commit yang belum terdeploy untuk percobaan; percobaan memiliki beberapa commit yang tidak ter-deploy untuk produksi. Tetapi semua berbagi codebase yang sama, sehingga dapat diartikan teridentifikasi sebgai deloy yang berbeda dari sebuah app yang sama. + + From 8ed99e14ad6b2accfe7d03495353b53cddb332f1 Mon Sep 17 00:00:00 2001 From: Catur Wirawan Wijiutomo Date: Tue, 27 Dec 2022 22:23:48 +0700 Subject: [PATCH 02/14] Fakto kedua diterjemahkan --- content/id/dependencies.md | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 content/id/dependencies.md diff --git a/content/id/dependencies.md b/content/id/dependencies.md new file mode 100644 index 000000000..d0d0e171b --- /dev/null +++ b/content/id/dependencies.md @@ -0,0 +1,12 @@ +## II. Dependencies +### Secara eksplisit mendeklarasi dan mengisolasi dependencies + +Kebanyakan bahasa pemrograman menyediakan suatu sistem paket untuk menyebarkan library pendukung, seperti [CPAN](http://www.cpan.org/) untuk Perl atau [Rubygems](http://rubygems.org/) untuk Ruby. Library diinstall melalui sebuah sistem pemaketan yang dapat diinstall memenuhi-sistem (disebut juga "site packages") atau terbatas ke dalam suatu direktori yang terdapat app (disebut juga sebagai "vendoring" atau "bundling"). + +**suatu duabelas-faktor ap ptidak pernah bergantung pada paket yang memenuhi-sistem.** app tersebut mendeklarasikan semua dependecies, secara komplit dan pasti, melalui sebuah wujud *deklarasi dependency* . lebih jauh pula, Hal ini menggunakan sebuah kakas *isolasi dependency* selama eksekusi untuk memastikan bahwa tidak terdapat dependency implisit "bocor" dari system sekitar. spesifikasi dependency secara penuh dan eksplisit diaplikasi secara seragam untuk produksi dan pengembangan. + +sebagai contoh, [Bundler](https://bundler.io/) untuk Ruby menyediakan format wujud `Gemfile` untuk deklarasi dependency dan `bundel-exec` untuk isolasi dependency. Pada Python terdapat dua kakas terpisah untuk langkah -- [Pip](http://www.pip-installer.org/en/latest/) yang digunakan untuk deklrasai dan [Virtualenv](http://www.virtualenv.org/en/latest/) untuk isolasi. Bahkan C memiliki [Autoconf](http://www.gnu.org/s/autoconf/) untuk deklarasi dependency, dan sambungan statik yang disediakan untuk isolasi dependency. Apapun kakas berantai yang digunakan, deklarasi dependency dan isolasinya harus digunakan bersama -- hanya satu dari keduanya tidak cukup untuk memenuhi keduabelas-faktor. + +Salah satu keuntungan dari deklarasi dependency yang eksplisit adalah menyederhanakan setup untuk developers yang baru. developer baru dapat memperoleh codebase app ke dalam mesin pengembangan mereka, dengan hanya membutuhkan runtime bahasa pemrograman dan manajer dependency yang terpasang sebagai prasyarat. Mereka akan mampu untuk menset up semua yang dibutuhkan untuk menjalankan kode app dengan *build command* yang deterministik. sebagai contoh, build command untuk Ruby/Bundler adalah `bundle-install`, sedangkan untuk Clojure/[Leiningen](https://github.com/technomancy/leiningen#readme) adalah`lein deps`. + +Duabelas-faktor app juga tidak bergantung pada eksitensi implisit dari suatu kakas pada system. contohnya tidak menggunakan ImageMagick atau `curl`. walaupun di sistem kebanyakan kakas ini ada, tidak ada garansi bahwa mereka akan selalu ada di semua sistem yang app tersebut akan berjalan di masa depan, atau apakah versi dari sistem di masa depan akan kompatibel dengan app. jika app memerlukan penggunaan kakas sistem, tool itu harus divendorkan ke dalam app. From f8c9f08a2e9311ba7446f269e96156d09e0d96c9 Mon Sep 17 00:00:00 2001 From: Catur Wirawan Wijiutomo Date: Wed, 28 Dec 2022 11:48:55 +0700 Subject: [PATCH 03/14] Faktor ketiga --- content/id/config.md | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 content/id/config.md diff --git a/content/id/config.md b/content/id/config.md new file mode 100644 index 000000000..a7c2b465c --- /dev/null +++ b/content/id/config.md @@ -0,0 +1,24 @@ +## III. Konfig +### Simpan konfig di Environment + +Konfig milik suatu app merupakan segalamnya yang akan berbeda setiap [deploys](./codebase)(staging, production, developer environments, dll). Hal ini termasuk : + +* Resource yang menangani basisdata, memcached, dan lainnya [backing services](./backing-services) +* kredensila ke layanan eksternal seperti Amazon S3 atau Twitter +* Setiap nilai per deploy seperti hostname untuk deploy + +App seringkali menyimpan konfig sebagai konstan di kode. Hal ini merupakan pelanggaran dari duabelas-faktor, yang membutuhkan **pemisahan tegas untuk konfig dari kode**. konfig secara substantif beragam untuk semua deploy, sedangkan kode tidak. + +Sebuah tes litmus untuk mengetahui apakah sebuah app memiliki konfig yang telah dikeluarkan dari kode dengan cara jika codebase bisa dijadikan open source saat itu juga, tanpa membuka kredensial apa pun. + +Catatan untuk definisi "config" **tidak** termasuk konfig internal aplikasi, seperti `config/routes.rb` di rails atau or bagaimana [modul kode tersambung](http://docs.spring.io/spring/docs/current/spring-framework-reference/html/beans.html) pada [Spring](http://spring.io/). Tipe config yang tidak bervariasi untuk deploy, sehingga lebih baik dilakukan di dalam kode. + +pendekatan lain untuk konfig adlaah menggunakan file konfig yang tidak dimasukkan ke dalan kendali revisi, seperti `config/database.yml` pada Rails. Hal ini merupakan peningkatan besar daripada menggunakan constant yang dimasukkan ke dalam repo kode, namun memiliki kelemahan: mudah untuk memasukan file konfig ke repo; ada kecenderungan untuk file konfig tersebar di berbagai tempat dengan berbagai format, membuat hal tersebut sulit untuk melihat dan mengatur semua konfig di satu tempat. lebih jauh lagi, format seringkali spesifik untuk bahasa pemrograman dan framework tertentu. + + +**Dua belas-faktor app menyimpan konfig dalam *variable Environment*** (sering disingakt *env vars* atau *env*). Evn vars mudah untuk diubah diantara deploy tanpa harus mengubah kode; tidak seperti file konfig, ada sedikit kesempatan untuk dimasukkan tidak sengaja ke kode; tidak seperti file custom konfig, atau mekanisme konfig lain seperti Java System Properties, mereka bersifat agnostik untuk bahasa pemrograman dan sistem operasi. + +Aspek lain dari manajemen konfig adalah grouping, seringkali app menjatah sekumpulan konfig ke dalam grup bernama (disebut juga "environments") dinamakan untuk deploy spesifik, seperti `development`, `test`, dan `production` environments dalam Rails. Metode ini tidak meningkat dengan bersih: saat deploy dari app tercipat, nama environment baru dibutuhkan, seperti `staging` or `qa`. saat proyek tumbuh lebih jauh, developer mungkin menambahkan enviroments spesial seperti `joes-staging`, yang berdamapak pada ledakan kombinatorail dari konfig yang membuat pengaturan deploy dari app sangat rapuh. + +Di Dua belas-faktor app, env vars adalah kontrol granular, setiap dari itu ortogonal ke env vars lain. Mereka tidak di-grup bersama seperti "environments", namun diatur secara independen untuk setiap deploy. model ini meningkat cepat saat app secara alamiah membesar ke deploy yang lebih banyak dalam daur hidupnya. + From 08dcdef0418569c2a06215c5de81f8f4d48ed390 Mon Sep 17 00:00:00 2001 From: Catur Wirawan Wijiutomo Date: Wed, 28 Dec 2022 12:25:29 +0700 Subject: [PATCH 04/14] faktor keempat --- content/id/backing-services.md | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 content/id/backing-services.md diff --git a/content/id/backing-services.md b/content/id/backing-services.md new file mode 100644 index 000000000..165a095f9 --- /dev/null +++ b/content/id/backing-services.md @@ -0,0 +1,15 @@ +## IV. Layanan beking +### Perlakukan layanan beking sebagai sumber daya menempel + +Sebuah *Layanan beking* adalah layanan yang app makan melalui jaraingan sebgai bagian dari operasi normalnya. contoh pengikutan datastore (seperti[MySQL](http://dev.mysql.com/) atau [CouchDB](http://couchdb.apache.org/)), sistem layanan/antrian (seperti [RabbitMQ](http://www.rabbitmq.com/) atau [Beanstalkd](https://beanstalkd.github.io)), layanan untuk email keluar (seperti[Postfix](http://www.postfix.org/)), dan sistem cache (seperti [Memcached](http://memcached.org/)). + +Layanan beking seperti basisdata diatur secara tradisional oleh system administrator yang sama yang menerapkan app runtime. Layanan ini bisa ditambah secara lokal, app juga dapat memilki layanan yang disediakan oleh pihak ketiga. contoh Layanan SMTP (seperti[Postmark](http://postmarkapp.com/)), Layanan pengumpulan metrik (seperti [New Relic](http://newrelic.com/) atau [Loggly](http://www.loggly.com/)), layanan aset binary (seperti [Amazon S3](http://aws.amazon.com/s3/)), dan even layanan API untuk konsumen (seperti[Twitter](http://dev.twitter.com/), [Google Maps](https://developers.google.com/maps/), atau [Last.fm](http://www.last.fm/api)). + +**kode untuk duabelas faktor app tidak membedakan antara layanan lokal dan pihak ketiga** untuk aplikasi, kedaunya merupakan sumberdaya menempel, diakses menggunakan URL atau locator/kredensial lain yang disimpan di [config](./config). sebuah [deploy](./codebase) dari duabelas faktor app harus dapat menukar local mysql database dengan pihak ketiga (seperti [Amazon RDS](http://aws.amazon.com/rds/)) tanpa perubahan di kode app. sehingga server SMTP lokal dapat ditukar dengan layanan SMTP pihak ketiga (seperti postmark) tanpa perubahan kode. di kedua kasus, hanya pengatur sumber daya pada konfig yang perlu diubah. + +setiap layanan beking yang berbeda merupakan *sumber daya*. contohnya, sebuah basis data MySQL adalah sebuah sumber daya; dua database (digunakan untuk sharding di layer aplikasi) dianggap sebagai dua sumber daya yang berbeda. dua belas faktor app memperlakukan kedua basis data sebagai *sumber daya menempel*, yang mengindikasi loose coupling ke tempat deploy yang menempel. + +A production deploy attached to four backing services. + +Sumber daya dapat ditempel and dilepas dari deploy semaunya. contohnya jika basis data berlaku aneh karena masalah hardware, administrator app akan membuat server basis data baru yang berisi restore dari backup paling baru. basis data produksi saat ini dapat dilepas dan basis data baru ditempel -- semuanya tanpa perubahan kode. + From 29ca5781ee4d0168f70d51dbc29e685087160dc1 Mon Sep 17 00:00:00 2001 From: Catur Wirawan Wijiutomo Date: Wed, 28 Dec 2022 22:34:44 +0700 Subject: [PATCH 05/14] fix bagian 4 dan faktor kelima --- content/id/backing-services.md | 8 ++++---- content/id/build-release-run.md | 20 ++++++++++++++++++++ 2 files changed, 24 insertions(+), 4 deletions(-) create mode 100644 content/id/build-release-run.md diff --git a/content/id/backing-services.md b/content/id/backing-services.md index 165a095f9..f4c7a4a27 100644 --- a/content/id/backing-services.md +++ b/content/id/backing-services.md @@ -1,15 +1,15 @@ ## IV. Layanan beking ### Perlakukan layanan beking sebagai sumber daya menempel -Sebuah *Layanan beking* adalah layanan yang app makan melalui jaraingan sebgai bagian dari operasi normalnya. contoh pengikutan datastore (seperti[MySQL](http://dev.mysql.com/) atau [CouchDB](http://couchdb.apache.org/)), sistem layanan/antrian (seperti [RabbitMQ](http://www.rabbitmq.com/) atau [Beanstalkd](https://beanstalkd.github.io)), layanan untuk email keluar (seperti[Postfix](http://www.postfix.org/)), dan sistem cache (seperti [Memcached](http://memcached.org/)). +Sebuah *Layanan beking* adalah layanan yang app makan melalui jaringan sebgai bagian dari operasi normalnya. contoh pemuatan datastore (seperti[MySQL](http://dev.mysql.com/) atau [CouchDB](http://couchdb.apache.org/)), sistem layanan/antrian (seperti [RabbitMQ](http://www.rabbitmq.com/) atau [Beanstalkd](https://beanstalkd.github.io)), layanan untuk email keluar (seperti[Postfix](http://www.postfix.org/)), dan sistem cache (seperti [Memcached](http://memcached.org/)). Layanan beking seperti basisdata diatur secara tradisional oleh system administrator yang sama yang menerapkan app runtime. Layanan ini bisa ditambah secara lokal, app juga dapat memilki layanan yang disediakan oleh pihak ketiga. contoh Layanan SMTP (seperti[Postmark](http://postmarkapp.com/)), Layanan pengumpulan metrik (seperti [New Relic](http://newrelic.com/) atau [Loggly](http://www.loggly.com/)), layanan aset binary (seperti [Amazon S3](http://aws.amazon.com/s3/)), dan even layanan API untuk konsumen (seperti[Twitter](http://dev.twitter.com/), [Google Maps](https://developers.google.com/maps/), atau [Last.fm](http://www.last.fm/api)). -**kode untuk duabelas faktor app tidak membedakan antara layanan lokal dan pihak ketiga** untuk aplikasi, kedaunya merupakan sumberdaya menempel, diakses menggunakan URL atau locator/kredensial lain yang disimpan di [config](./config). sebuah [deploy](./codebase) dari duabelas faktor app harus dapat menukar local mysql database dengan pihak ketiga (seperti [Amazon RDS](http://aws.amazon.com/rds/)) tanpa perubahan di kode app. sehingga server SMTP lokal dapat ditukar dengan layanan SMTP pihak ketiga (seperti postmark) tanpa perubahan kode. di kedua kasus, hanya pengatur sumber daya pada konfig yang perlu diubah. +**kode untuk duabelas faktor app tidak membedakan antara layanan lokal dan pihak ketiga** untuk aplikasi, kedaunya merupakan sumberdaya menempel, diakses menggunakan URL atau locator/kredensial lain yang disimpan di [config](./config). sebuah [deploy](./codebase) dari duabelas faktor app harus dapat menukar local mysql database dengan pihak ketiga (seperti [Amazon RDS](http://aws.amazon.com/rds/)) tanpa perubahan di kode app. sehingga server SMTP lokal dapat ditukar dengan layanan SMTP pihak ketiga (seperti postmark) tanpa perubahan kode. di kedua kasus, hanya handle sumber daya pada konfig yang perlu diubah. -setiap layanan beking yang berbeda merupakan *sumber daya*. contohnya, sebuah basis data MySQL adalah sebuah sumber daya; dua database (digunakan untuk sharding di layer aplikasi) dianggap sebagai dua sumber daya yang berbeda. dua belas faktor app memperlakukan kedua basis data sebagai *sumber daya menempel*, yang mengindikasi loose coupling ke tempat deploy yang menempel. +Setiap layanan beking yang berbeda merupakan *sumber daya*. contohnya, sebuah basis data MySQL adalah sebuah sumber daya; dua database (digunakan untuk sharding di layer aplikasi) dianggap sebagai dua sumber daya yang berbeda. dua belas faktor app memperlakukan kedua basis data sebagai *sumber daya menempel*, yang mengindikasi loose coupling ke tempat deploy yang menempel. -A production deploy attached to four backing services. +Penerapan produksi yang dilampirkan ke empat layanan beking. Sumber daya dapat ditempel and dilepas dari deploy semaunya. contohnya jika basis data berlaku aneh karena masalah hardware, administrator app akan membuat server basis data baru yang berisi restore dari backup paling baru. basis data produksi saat ini dapat dilepas dan basis data baru ditempel -- semuanya tanpa perubahan kode. diff --git a/content/id/build-release-run.md b/content/id/build-release-run.md new file mode 100644 index 000000000..093efdae1 --- /dev/null +++ b/content/id/build-release-run.md @@ -0,0 +1,20 @@ +## V. Build, release, run +### Pisahkan dengan ketat antara tahap build dan run + +A [codebase](./codebase) ditransformasikan ke dalam deploy (non-development) melalui tiga tahap: + +* *tahap build* adalah transformasi yang mengkonversi sebuah repo kode ke sebuah bundel executable yang disebut sebagai sebuah *build* menggunakan sebuah versi dari code yang dicommit spesifik oleh proses deployment, tahap build mengambil vendors [dependencies](./dependencies) dfan mengkompilasi binaries dan asset. +* *tahap release* mengambil build yang diproduksi pada tahap build dan mengkombinasikan dengan deploy [config](./config). yang menghasilkan *release* yang terdiri dari build dan config dan siap untuk diekekusi pada lingkungan eksekusi. +* *tahap run* (disebut juga sebagai "runtime") menjalankan app pada lingkungan eksekusi, dengan men-launch beberapa set dari [processes](./processes) app dari release terpilih. + +![kode menjadi sebuah build, yang dikombinasikan dengan config untuk menciptakan sebuah release](/images/release.png) + + +**duabelas faktor app menggunakan pemisahan ketat antara build, release, dan run** sebagai contoh, tidak mungkin untuk membaut perubahan pada kode saat runtime, karena tidak ada cara untuk menularkan perubahan tersebut seperti di tahap build. + +kakas deployment biasanya menyediakan kakas manajamen, yang sering digunakan adalah kemampuan untuk kemabli ke release sebelumnya. sebagai contoh, kakas [Capistrano](https://github.com/capistrano/capistrano/wiki) menyimpan releqase ke dalam sebuah subdirectory bernama `releases`, yang mana release saat ini adalah symlink ke direktori release saat ini. perintah `rollback` membuat hal tersebut mudah untuk kembali ke release sebelumnya. + +Setiap release harus memiliki ID release yang unik, seperti timestamp dari release (seperti `2011-04-06-20:32:17`) atau angka yang meningkat (seperti `v100`). release adalah jurnal yang hanya bisa ditambah dan release tidak bisa diubah sekali itu diciptakan. perubahan harus menciptakan release yang baru. + +Build diinisiasi oleh developer app setiap kali kode baru dideploy. eksekusi runtime, kontransya, dapat terjadi otomatis dalam beberapa kasus misalkan seperti pada reboot server, atau process crash saat direstart oleh process manager, tahap run sebisa mungkin terdiri dari bagian bergerak sesedikit mungkin, karena persoalan yang mencegah app dari berjalan normal dapat terjadi di tengah malam saat tidak ada developer yang dapat hadir. tahap build dapat menjadi lebih kompleks, karena error selalu ada di foreground untuk developer yang melakukan deploy. + From d8395b78c247a935fa2b1d43e687f2aa6522a549 Mon Sep 17 00:00:00 2001 From: Catur Wirawan Wijiutomo Date: Wed, 28 Dec 2022 22:58:54 +0700 Subject: [PATCH 06/14] faktor ke 6 --- content/id/processes.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 content/id/processes.md diff --git a/content/id/processes.md b/content/id/processes.md new file mode 100644 index 000000000..5b6d2bfa0 --- /dev/null +++ b/content/id/processes.md @@ -0,0 +1,14 @@ +## VI. Proses +### Eksekusi app sebagai satu proses atau lebih yang nirstatus + +App dieksekusi dalam lingkungan ekeskusi sebagai satu *proses* atau lebih. + +Dalam kasus sederhana, kode adalah script yang berdiri sendiri, lingkungan eksekusi adalah developer laptop dengan runtime bahasa pemrograman yang terpasang, dan proses dilaunch melalui command line (sebagai contoh, `python my_script.py`). di sisi lain dari spektrum, suatu deploy produksi sebuah app rumit mungkin menggunakan banyak [tipe proses, yang diinstansiasi ke dalam 0 atau lebih proses yang berjalan](./concurrency). + +** proses dua belas faktor nirstatus dan [tidak berbagi apapun](http://en.wikipedia.org/wiki/Shared_nothing_architecture).** setiap data yang perlu untuk bertahan harus disimpan dalam [layanan beking](./backing-services) yang berstatus, umumnya sebuah basisdata. + +ruang memori dari filesystem dari proses dapat digunakan sebagai awal, cache transaksi tunggal. sebagai contoh mengunduh suatu file bear, mengoperasikannya, dan menyimpan hasil dari operasi dalam basisdata. duabelas faktor app tidak pernah megnasumsikan apapun yang di-cache di memori atau disk akan tersedia pada request di masa yang akan datang atau job -- dengan proses yang banyak dari setiap tipe berjalan, ada kesempatan yang besar bahwa request di masa yang akan datang akan dilayani oleh proses yang berbeda. Bahkan saat hanya menjalankan satu proses, sebuah restart (ditrigger oleh code deploy, perubahan konfig, ataua relokasi proses oleh lingkungan eksekusi ke lokasi fisik yang berbeda) akan mengahpus semua state lokal (contoh, memori dan filesystem) + +Pemaket asset seperti [django-assetpackager](http://code.google.com/p/django-assetpackager/) menggunakan filesystem sebagai cache untuk asset yang terkompilasi. duabelas faktor app lebih memilih untuk mengkompilasi selama [tahap build](/build-release-run). pemaket asset seperti [Jammit](http://documentcloud.github.com/jammit/) dan [Rails asset pipeline](http://ryanbigg.com/guides/asset_pipeline.html) dapat dikonfigurasi untuk memaket asset selama tahap build + +Beberapa sistem web bergantung pada ["sticky sessions"](http://en.wikipedia.org/wiki/Load_balancing_%28computing%29#Persistence) -- yang merupakan, men-cache user sessipn data pada memori dari proses app dan berharap request di masa akan datang dari visitor yang sama akan diroute ke proses yang sama. sticky session adlaah pelanggaran untuk duabelas faktor dan tidak boleh digunakan atau bergantung padanya. session state data adalah kandidat baik untuk datastore yang menyediakan time-expiration seperti [Memcached](http://memcached.org/) or [Redis](http://redis.io/). From 911fa1f176e9425f1007870e76a31490da6eb31b Mon Sep 17 00:00:00 2001 From: Catur Wirawan Wijiutomo Date: Thu, 29 Dec 2022 09:19:33 +0700 Subject: [PATCH 07/14] Faktor ke 7 --- content/id/port-binding.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 content/id/port-binding.md diff --git a/content/id/port-binding.md b/content/id/port-binding.md new file mode 100644 index 000000000..bc2910ae9 --- /dev/null +++ b/content/id/port-binding.md @@ -0,0 +1,14 @@ +## VII. Ikatan port +### Ekspor layanan melalui ikatan port + +aplikasi web seringkali dieksekusi dalam sebuah kontainer webserver. contohnya, aplikasi PHP berjalan sebagai modul dalam [Apache HTTPD](http://httpd.apache.org/),atau aplikasi Java berjalan dalam [Tomcat](http://tomcat.apache.org/). + +**duabelas faktor app terkontain tunggal secara komplit** dan tidak bergantung pada injeksi runtime dari sebuah webserver ke dalam lingkungan eksekusi untuk menciptakan layanan web. web app **mengeskpor HTTP sebagai sebuah layanan dengan mengikat port** dan mendengarkan request yang datang ke port tersebut. + +Pada lingkungan pengembangan lokal, developer mengunjungi URL layanan seperti `http://localhost:5000/` untuk mengakses layanan yang diekspor oleh app. pada deployment, layer routing menagnani permintaan routing dari hostname publik ke web proses yang terikat port. + +Hal ini umumnya diimplementasi menggunakan [dependency declaration](./dependencies) ke sebuah library webserver di app, seperti [Tornado](http://www.tornadoweb.org/) untuk Python, [Thin](http://code.macournoyer.com/thin/) untuk Ruby, atau [Jetty](http://www.eclipse.org/jetty/) untuk Java dan bahasa pemrograman berbasis JVM. ini terjadi seluruhanya di *user space* yang berada dalam jangkauan kode aplikasi. kontarak dengan lingkungan eksekusi adalah pengikatan port untuk melayani permintaan. + +HTTP tidak hanya layanan yang dapat diekspor ke ikatan port. hampir semua jenis software server dapat dijalankan melalui ikatan ke sebuah port dan menunggu permintaan masukan. contohnya [ejabberd](http://www.ejabberd.im/) (speaking [XMPP](http://xmpp.org/)), dan [Redis](http://redis.io/) (speaking the [Redis protocol](http://redis.io/topics/protocol)). + +Catatan bahwa pendekatan ikatan port berarti satu app dapat menjadi [beking layanan](./backing-services) untuk app lain, dengan menyediakan URL ke beking sebagai penanganan sumber daya pada [config](./config) untuk app yang memakai. From f92105085fc2260254d9d1fe4ecfefbb5b8aaf17 Mon Sep 17 00:00:00 2001 From: Catur Wirawan Wijiutomo Date: Thu, 29 Dec 2022 09:47:03 +0700 Subject: [PATCH 08/14] faktor ke 8 --- content/id/concurrency.md | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 content/id/concurrency.md diff --git a/content/id/concurrency.md b/content/id/concurrency.md new file mode 100644 index 000000000..d2625368b --- /dev/null +++ b/content/id/concurrency.md @@ -0,0 +1,17 @@ +## VIII. Konkurensi +### Meningkat melalui model proses + +Suatu program komputer, sekali dijalankan, akan direpresentasikan dengan satu atau lebih proses. aplikasi web telah menjadi salah satu variasi dari bentuk eksekusi proses, contohnya proses PHP berjalan sebagai proses anak dari Apache, dimulai sesui permintaan berdasarkan kebutuhan volume request. Proses Java menggunakan pendekatan yang berbeda, dengan JVM menyediakan proses besar yang me-reserve suatu large block dari system resource (CPU dan memory ) pada startup, dengan konkurensi diatur secara internal melalui thread. di kedua kasus, proses yang berjalan hanya minimal terlihat ke developer dari app. + +![skala diekspresikan dengan proses yang berjalan, workload yang berbeda-beda diekspresikan dengan tipe proses.] +(/images/process-types.png) + +**Pada dua belas faktor app, proses merupakan masyarakat kelas satu** proses pada dua belas faktor app merujuk pada [the unix process model for running service daemons](https://adam.herokuapp.com/past/2011/5/9/applying_the_unix_process_model_to_web_apps/). Menggunakan model ini developer dapat mengarstik app untuk menangani workload yang beragam dengan men-assign setiap tipe dari pekerjaan ke sebuah *tipe proses*. contohnya, permintaan HTTP dapat ditangani dengan sebuah proses web, dan task yang berjalan panjang di latar belakang oleh proses pekerja. + +ini tidak mengeluarkan proses individual dari menangani multiplexing internal, melalui thread dalan runtime VM, atau model async/event yagn ditemukan pada kakas seperti [EventMachine](https://github.com/eventmachine/eventmachine), [Twisted](http://twistedmatrix.com/trac/), atau [Node.js](http://nodejs.org/). namun setiap VM individual dapat tumbuh sangat besar (skala vertical), sehingga aplikasi harus dapat mengembang ke banyak proses berjalan di banyak mesin fisik. + +Model proses benar bersrinar ketika saat untuk meningkat. [share-nothing, horizontally partitionable nature of twelve-factor app processes](./processes) berarti menambah konkurensi tambahan sebagai operasi yang sederhana dan dapat diandalkan. array dari tipe proses dan nomor dari proses tiap tipe yang disebut sebagai *process formation*. + +dua belas faktor app proses [Seharusnya tidak akan pernah daemonize](http://dustin.github.com/2010/02/28/running-processes.html) atau menulis PID files. sebaliknya, bergantung pada proses manager di sistem operasi (seperti [systemd](https://www.freedesktop.org/wiki/Software/systemd/), manajer proses tersebar pada cloud platform, atau kakas seperti [Foreman](http://blog.daviddollar.org/2011/05/06/introducing-foreman.html) pada pengembangan) untuk mengatur [output streams](./logs), merespon proses yang crash, dan menagani restart dan shutdown yang diinisiasi user. + + From 05758b46a29f83856cda75c1a779686cd0dd143c Mon Sep 17 00:00:00 2001 From: Catur Wirawan Wijiutomo Date: Thu, 29 Dec 2022 13:46:10 +0700 Subject: [PATCH 09/14] Faktor ke 9 --- content/id/disposability.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 content/id/disposability.md diff --git a/content/id/disposability.md b/content/id/disposability.md new file mode 100644 index 000000000..38dfd5051 --- /dev/null +++ b/content/id/disposability.md @@ -0,0 +1,14 @@ +## IX. Sekali Pakai +### Maksimalkan kekokohan dengan startup cepat dan shutdown yang anggun + +**[procss](./processes) dua belas faktor app adalah *sekali pakai*, artinya dapat dimulai dan dihentikan seketika.** hal ini menfasilitasi peningkatan elastis, deployment cepat untuk [code](./codebase) atau perubahan [config](./config), dan kekokohan dari deploy produksi. + +proses harus berusaha untuk **meminimalkan waktu startup**. idealnya, sebuah proses akan memakan beberapa detik dari waktu launch diekskeusi hingga proses bangun dan siap untuk menerima request atau pekerajan. waktu startup yang singkat menyediakan kelincahan lebih untuk proses [release](./build-release-run) dan meningkat; dan membantu kekekohan, karena manajer proses dapat lebih mudah untuk memindahkan proses ke mesin fisik baru ketika terjamin. + +proses **shut down secara anggun ketika menerima sinyal [SIGTERM](http://en.wikipedia.org/wiki/SIGTERM)** dari manajer proses. untuk proses web, shutdown anggun diperoleh dengan berhenti mendengar di port layanan (yang akan menolak request baru), memungkinkan request saat ini untuk selesai, dan exit. secara implisit di mocel ini HTTP request adalah pendek (tidak lebih dari beberapa detik(, atau pada kasus long polling, klien harus secara seamlessly berusaha untuk rekoneksi ketika koneksi hilang. + +untuk proses worker, shutdown anggun diperoleh dengan mengembalikan pekerjaan saat ini ke antrian kerja. sebagai contoh, pada [RabbitMQ](http://www.rabbitmq.com/) worker mengirim [`NACK`] (http://www.rabbitmq.com/amqp-0-9-1-quickref.html#basic.nack); pada [Beanstalkd](https://beanstalkd.github.io), job dikembalikan ke antrian secara otomatais ketiak seuat worker terputus. sistem lock seperti [Delayed Job](https://github.com/collectiveidea/delayed_job#readme) perlu memastikan untuk melepas lock dari catatan job. secara implisit di model ini semua job [reentrant](http://en.wikipedia.org/wiki/Reentrant_%28subroutine%29), yang diperoleh dengan membungkus hasil ke dalam sebuah transaksi, atau membuat operasi [idempotent](http://en.wikipedia.org/wiki/Idempotence). + +Proses juga harus **kokoh terhadap kematian tiba-tiba**, pada kasus kegagalan hardware. walaupun hal ini jarnag terjadi dibandingkan shutdown dengan `SIGTERM`, hal ini masih dapat terjadi. Pendekatan yang diekomenadia adlaah menggunakan antiran backend kokoh, seperti Beanstalkd, yang mengembalikan job ke antrian ketika klien terputus atau time out. bagaimana pun, duabelas faktor app dirancang untuk menangani terminasi yang tidak terdiduga dan tidak anggun. [Crash-only design](http://lwn.net/Articles/191059/) ambil konsep ini untuk [logical conclusion](http://docs.couchdb.org/en/latest/intro/overview.html). + + From 98f5cd23de0ee49d556c90e4e5ce4011f74ec4ab Mon Sep 17 00:00:00 2001 From: Catur Wirawan Wijiutomo Date: Thu, 29 Dec 2022 20:08:52 +0700 Subject: [PATCH 10/14] faktor ke 10 --- content/id/dev-prod-parity.md | 80 +++++++++++++++++++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100644 content/id/dev-prod-parity.md diff --git a/content/id/dev-prod-parity.md b/content/id/dev-prod-parity.md new file mode 100644 index 000000000..8af1d4a17 --- /dev/null +++ b/content/id/dev-prod-parity.md @@ -0,0 +1,80 @@ +## X. keseimbangan Dev/prod +### Jaga Development, Pengujian, dan produksi semirip mungkin + +Secara historis, terdapat jurang antara development ( seorang developer mengedir di sebuah local [deploy](./codebase) dari app) dan produksi (sebuah deploy berjalan dari app yang diakses oleh end user). gap ini termanifest di tiga area : +* ** jurang waktu ** : seorang developer membutuhkan waktu kerja berhari-hari, berminggu-minggu, atau bahkan berbulan-bulan untuk mencapai produksi +* ** jurang personel ** : Developers menulis kode, enjiner operasi mendeploy kode tersebut. +* ** jurang kakas ** : developer mungkin menggunakan stack seperti Nginx, SQLite, dan OS X, sedangkan produksi mendeploy dengan Apache, MySQL, dan Linux. + +**app dua belas faktor didesain untuk [continuous deployment](http://avc.com/2011/02/continuous-deployment/) dengan membuat jurang antara development dan produksi kecil. ** dengan melihat tiga jurang yang disebutkan sebelumnya " + +* membuat jurang waktu kecil : seorang developer mungkin menulis dan mendeploy dalam hitungan jam dan bahkan menit kemudian. +* membuat jurang personal kecil : seorang developer menulis kode dengan secara dekat ikut dalam deploy dan melihat perubahan perilaku kode di produksi. +* membuat jurang kakas kecil : jaga development dan produksi semirip mungkin. + + +Rangkuman hal di atas ke dalam tabel : + + + + + + + + + + + + + + + + + + + + + + +
App tradisionalApp dua belas faktor
Waktu antar deployMingguJam
Code authors vs code deployersOrang yang berbedaorang yang sama
Dev vs production environmentsBerbedasemirip mungkin
+ +[Layanan beking](./backing-services), seperti basis data app, sistem antrian, atau cache, adalah satu area di mana keseimbangan dev/prod penting. banyak bahasa pemrograman menyediakan libraries yang menyederhanakan akses ke layanan beking, termasuk *adapters* untuk tipe layanan yang berbeda. beberapa contohanya ada di tabel berikut. + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TipeBahasa pemrogramanLibraryAdapters
basis dataRuby/RailsActiveRecordMySQL, PostgreSQL, SQLite
AntrianPython/DjangoCeleryRabbitMQ, Beanstalkd, Redis
CacheRuby/RailsActiveSupport::CacheMemory, filesystem, Memcached
+ +Developers seringkali menemukan godaan untuk menggunakan layanan bkeing yang ringan pada lingkungan lokal, sembari layanan beking yang lebih serius dan kokoh akan digunakan di produksi. sebagai contoh, menggunakan SQLite lokal dan postgresql di produlsi; atau local process memory untuk caching di development dan memcached di produksi. + +** dua belas faktor developer menahan godaan untuk menggunakan layanan beking yang berbeda antara development dan produksi** bahkan ketika adapters secara teoritis mengabstraksi perbedaan layanan beking. perebdaan antara layanan beking berarti terdapat ketidakkompatibel tumbuh, menyebabkan kode yang berjalan dan lolos tes pada development atau pengujian akan gagal di produksi. tipe error ini menciptakan firksi yang mengurangi continuous deployment. harga dari friksi ini dan hambatan dari continuous deployment akan sangat tinggi ketika ikut menghitung agregat selama masa hidup dari aplikasi. + +layanan lokal ringan semakin tidak menarik. layanan beking modern seperti memcached, postgresql, dan RabbitMQ tidak sulit untuk dipasang, untungnya sudah disediakan sistem packaging modern, seperti such as [Homebrew](http://mxcl.github.com/homebrew/) dan [apt-get](https://help.ubuntu.com/community/AptGet/Howto). terdapat alternatif pula untuk provisioning seperti [Chef](http://www.opscode.com/chef/) dan [Puppet](http://docs.puppetlabs.com/) yang dikombinasikan dengan lingkungan virtual ringan [Docker](https://www.docker.com/) dan [Vagrant](http://vagrantup.com/) yang dapat berjalan di lingkungan lokal yang memungkinkan developer memperoleh lingkungan pengembangan yang mendekati lingkungan produksi. biaya untuk memasang dan menggunakan sistem ini lebih rendah dibandingkan dengan keuntungan dari keseimbangan dev/prod dan continuous deployment. + +adapters untuk layanan beking yang berbeda masih digunakan, karena mereka membuat port ke layanan beking baru relatif tidak sulit. tapi semua deploy dari app (developer environments, staging, production) harus menggunakan layanan beking dengan tipe dan versi yang sama. + + From b0e6e4b123c039738a15c064464cafc6b1422873 Mon Sep 17 00:00:00 2001 From: Catur Wirawan Wijiutomo Date: Tue, 17 Jan 2023 22:29:31 +0700 Subject: [PATCH 11/14] faktor ke 11 --- content/id/logs.md | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 content/id/logs.md diff --git a/content/id/logs.md b/content/id/logs.md new file mode 100644 index 000000000..4e392178d --- /dev/null +++ b/content/id/logs.md @@ -0,0 +1,16 @@ +## XI. Logs +### Perlakukan logs sebagai aliran event + +*Logs* menyediakan kemampuan melihat perilaku dari app yg sedang berjalan. di lingkungan berbasis server umumnya di tulis ke suatu file pada disk (a "logfile"); tapi hanya dapat sebuah format output. + +Logs adalah aliran [stream](https://adam.herokuapp.com/past/2011/4/1/logs_are_streams_not_files/) dari kumpulan, even berurutan berdasarakan waktu dikumpulkan ke aliran output dari semua proses berjalan dan layanan beking. log dalam bentuk mentah umumnya sebuah format tesk dengan satu even setiap line (walaupun backtrace dari eksepsi mungkin berbentuk beberapa line). logs tidak memiliki awal atau akhir yg pasti, tapi mengalir secara kontinu selama app beroperasi. + +**Sebuah app 12 faktor tidak pernah memikirkan dengan routing atau penyimpanan dari aliran output** sudah seharusnya tidak mencoba untuk menulis atau mengatur logdile. sebaliknya, setiap proses yg berjalan menulis event aliran masing2, tidak dibuffer ke `stdout`. saat pengembangan lokal, developer akan menampilkan aliran ini ke foreground dari terminal mereka untuk meng-observe perilaku app. + +Pada staging atau deploy produksi, setiap aliran proses akan meng-capture oleh lingkungan eksekusi, dikumpulkan bersama dengan semua stream dari app, dan di route ke satu atau lebih destinasi akhir untuk menampilkan dan arsip jangka panjang. tujuan arsip tidak terlihat atau dapat dikonfigurasi dari app, sebaliknya diatur sepenuhnya oleh lingkungan eksekusi. router log open source (seperti [Logplex](https://github.com/heroku/logplex) and [Fluentd](https://github.com/fluent/fluentd)) tersedia untuk tujuan ini. + +Aliran event untuk sebuah app dapat dirutekan ke sebuah file, atau ditonton melalui tail realtime dari sebuah termninal. secara signifikan, aliran dapat dikirim ke sistem log indexing dan analysis seperti [Splunk](http://www.splunk.com/), atau sistem gudang data general purpose seperti [Hadoop/Hive](http://hive.apache.org/). sistem ini memungkinkan kekuatan dan fleksibilitas untuk mengintrospeksi perilaku app setiap waktu, termasuk: + +* Menemukan peristiwa tertentu di masa lalu. +* Grafik tren skala besar (seperti permintaan per menit). +* Peringatan aktif menurut heuristik yang ditentukan pengguna (seperti peringatan ketika jumlah kesalahan per menit melebihi ambang batas tertentu). From 83077b12c3c9933bc806936ca5ddfc28104b097d Mon Sep 17 00:00:00 2001 From: Catur Wirawan Wijiutomo Date: Tue, 17 Jan 2023 22:35:54 +0700 Subject: [PATCH 12/14] faktor ke 12 --- content/id/admin-processes.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 content/id/admin-processes.md diff --git a/content/id/admin-processes.md b/content/id/admin-processes.md new file mode 100644 index 000000000..a313513d4 --- /dev/null +++ b/content/id/admin-processes.md @@ -0,0 +1,14 @@ +## XII. Proses administrasi +### Jalankan administrasi/manajemen sebagai proses satu kali + +[Formasi proses](./concurrency) adalah larik proses yang digunakan untuk melakukan bisnis reguler aplikasi (seperti menangani permintaan web) saat dijalankan. Secara terpisah, pengembang sering kali ingin melakukan tugas administratif atau pemeliharaan satu kali untuk aplikasi, seperti: + +* Menjalankan migrasi basis data (misal. `manage.py migrate` di Django, `rake db:migrate` di Rails). +* Menjalankan konsol (juga dikenal sebagai shell [REPL](http://en.wikipedia.org/wiki/Read-eval-print_loop)) untuk menjalankan kode arbitrer atau memeriksa model aplikasi terhadap database langsung. Sebagian besar bahasa menyediakan REPL dengan menjalankan juru bahasa tanpa argumen apa pun (misal. `python` atau `perl`) atau dalam beberapa kasus memiliki perintah terpisah (misal. `irb` untuk Ruby, `rails console` untuk Rails). +* Menjalankan skrip satu kali yang dilakukan ke dalam repo aplikasi (misal. `php scripts/fix_bad_records.php`). + +Proses admin satu kali harus dijalankan di lingkungan yang identik dengan [proses yang berjalan lama](./proses) reguler aplikasi. Mereka menjalankan [release](./build-release-run), menggunakan [codebase](./basis kode) dan [config](./config) yang sama dengan proses apa pun yang dijalankan terhadap rilis itu. Kode admin harus dikirimkan bersama kode aplikasi untuk menghindari masalah sinkronisasi. + +Teknik [dependency isolation](./dependensi) yang sama harus digunakan pada semua jenis proses. Misalnya, jika proses web Ruby menggunakan perintah `bundle exec thin start`, maka migrasi basis data harus menggunakan `bundle exec rake db:migrate`. Demikian pula, program Python yang menggunakan Virtualenv harus menggunakan `bin/python` vendor untuk menjalankan server web Tornado dan proses admin `manage.py` apa pun. + +Dua belas faktor sangat menyukai bahasa yang menyediakan shell REPL di luar kotak, dan yang membuatnya mudah untuk menjalankan skrip satu kali. Dalam penerapan lokal, pengembang menjalankan proses admin satu kali dengan perintah shell langsung di dalam direktori checkout aplikasi. Dalam penerapan produksi, pengembang dapat menggunakan ssh atau mekanisme eksekusi perintah jarak jauh lainnya yang disediakan oleh lingkungan eksekusi penerapan tersebut untuk menjalankan proses tersebut. From 00f3464d0595beb88d7d02c505b8fa20988665e2 Mon Sep 17 00:00:00 2001 From: Catur Wirawan Wijiutomo Date: Tue, 17 Jan 2023 22:43:10 +0700 Subject: [PATCH 13/14] add others info docs --- content/id/intro.md | 12 ++++++++++++ content/id/toc.md | 38 ++++++++++++++++++++++++++++++++++++++ content/id/who.md | 4 ++++ 3 files changed, 54 insertions(+) create mode 100644 content/id/intro.md create mode 100644 content/id/toc.md create mode 100644 content/id/who.md diff --git a/content/id/intro.md b/content/id/intro.md new file mode 100644 index 000000000..0f9b1ffd3 --- /dev/null +++ b/content/id/intro.md @@ -0,0 +1,12 @@ +Pendahuluan +============ + +Di era modern, perangkat lunak umumnya dikirimkan sebagai layanan: disebut *aplikasi web*, atau *perangkat lunak sebagai layanan*. Aplikasi dua belas faktor adalah metodologi untuk membuat aplikasi perangkat lunak sebagai layanan yang: + +* Gunakan format **deklaratif** untuk otomatisasi penyiapan, untuk meminimalkan waktu dan biaya bagi pengembang baru yang bergabung dengan proyek; +* Memiliki **kontrak bersih** dengan sistem operasi yang mendasarinya, menawarkan **portabilitas maksimum** antara lingkungan eksekusi; +* Cocok untuk **penyebaran** pada **platform cloud** modern, meniadakan kebutuhan akan server dan administrasi sistem; +* **Meminimalkan divergensi** antara pengembangan dan produksi, memungkinkan **penerapan berkelanjutan** untuk kelincahan maksimum; +* Dan dapat **meningkatkan** tanpa perubahan signifikan pada perkakas, arsitektur, atau praktik pengembangan. + +Metodologi dua belas faktor dapat diterapkan pada aplikasi yang ditulis dalam bahasa pemrograman apa pun, dan yang menggunakan kombinasi layanan pendukung apa pun (database, antrean, cache memori, dll). \ No newline at end of file diff --git a/content/id/toc.md b/content/id/toc.md new file mode 100644 index 000000000..665461842 --- /dev/null +++ b/content/id/toc.md @@ -0,0 +1,38 @@ +The Twelve Factors +================== + +## [I. Codebase](./codebase) +### Satu basis kode dilacak dalam kontrol revisi, banyak penerapan + +## [II. Dependencies](./dependencies) +### Deklarasikan dan isolasi dependensi secara eksplisit + +## [III. Config](./config) +### Simpan konfigurasi di lingkungan + +## [IV. Backing services](./backing-services) +### Perlakukan layanan pendukung sebagai sumber daya terlampir + +## [V. Build, release, run](./build-release-run) +### Tahap build dan run yang terpisah secara ketat + +## [VI. Processes](./processes) +### Jalankan aplikasi sebagai satu atau beberapa proses tanpa kewarganegaraan + +## [VII. Port binding](./port-binding) +### Layanan ekspor melalui pengikatan port + +## [VIII. Concurrency](./concurrency) +### Skalakan melalui model proses + +## [IX. Disposability](./disposability) +### Maksimalkan kekokohan dengan pengaktifan cepat dan pematian yang lancar + +## [X. Dev/prod parity](./dev-prod-parity) +### Pertahankan pengembangan, pementasan, dan produksi semirip mungkin + +## [XI. Logs](./logs) +### Perlakukan log sebagai aliran peristiwa + +## [XII. Admin processes](./admin-processes) +### Jalankan tugas admin/manajemen sebagai proses satu kali diff --git a/content/id/who.md b/content/id/who.md new file mode 100644 index 000000000..c6b5ffded --- /dev/null +++ b/content/id/who.md @@ -0,0 +1,4 @@ +Siapa yang harus membaca dokumen ini? +============================== + +Setiap pengembang membangun aplikasi yang dijalankan sebagai layanan. Insinyur operasi yang menerapkan atau mengelola aplikasi semacam itu. \ No newline at end of file From c56660e270cf2db84a2a7f24a3fbc6c61439acd9 Mon Sep 17 00:00:00 2001 From: Catur Wirawan Wijiutomo Date: Tue, 17 Jan 2023 22:45:38 +0700 Subject: [PATCH 14/14] ketinggalan background.md --- content/id/background.md | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 content/id/background.md diff --git a/content/id/background.md b/content/id/background.md new file mode 100644 index 000000000..532973d2a --- /dev/null +++ b/content/id/background.md @@ -0,0 +1,8 @@ +Latar belakang +========== + +Kontributor dokumen ini telah terlibat langsung dalam pengembangan dan penerapan ratusan aplikasi, dan secara tidak langsung menyaksikan pengembangan, pengoperasian, dan penskalaan ratusan ribu aplikasi melalui pekerjaan kami di platform Heroku. + +Dokumen ini menyatukan semua pengalaman dan pengamatan kami pada berbagai macam aplikasi perangkat lunak sebagai layanan di alam liar. Ini adalah triangulasi praktik ideal untuk pengembangan aplikasi, memberikan perhatian khusus pada dinamika pertumbuhan organik aplikasi dari waktu ke waktu, dinamika kolaborasi antara pengembang yang mengerjakan basis kode aplikasi, dan menghindari biaya erosi perangkat lunak. + +Motivasi kami adalah untuk meningkatkan kesadaran akan beberapa masalah sistemik yang telah kami lihat dalam pengembangan aplikasi modern, untuk menyediakan kosa kata bersama untuk membahas masalah tersebut, dan untuk menawarkan serangkaian solusi konseptual yang luas untuk masalah tersebut dengan terminologi yang menyertainya. Formatnya terinspirasi dari buku Martin Fowler *Pola Arsitektur Aplikasi Perusahaan* dan *Refactoring*. \ No newline at end of file