Are you over 18 and want to see adult content?
More Annotations
A complete backup of https://parikh.net
Are you over 18 and want to see adult content?
A complete backup of https://cremadescalvosotelo.com
Are you over 18 and want to see adult content?
A complete backup of https://odchudzaniezjve.pl
Are you over 18 and want to see adult content?
A complete backup of https://goodforum.net
Are you over 18 and want to see adult content?
A complete backup of https://bdsmstreak.com
Are you over 18 and want to see adult content?
A complete backup of https://eanlibya.com
Are you over 18 and want to see adult content?
A complete backup of https://spinlock.co.uk
Are you over 18 and want to see adult content?
A complete backup of https://coloring2print.com
Are you over 18 and want to see adult content?
A complete backup of https://wfns.org
Are you over 18 and want to see adult content?
A complete backup of https://oeaw.ac.at
Are you over 18 and want to see adult content?
A complete backup of https://spicesofindia.co.uk
Are you over 18 and want to see adult content?
A complete backup of https://backagent.net
Are you over 18 and want to see adult content?
Favourite Annotations
A complete backup of kemo-electronic.cz
Are you over 18 and want to see adult content?
A complete backup of indietheaternow.com
Are you over 18 and want to see adult content?
A complete backup of best-cooler.reviews
Are you over 18 and want to see adult content?
A complete backup of livinglutheran.org
Are you over 18 and want to see adult content?
A complete backup of 60secondspaydayloans.com
Are you over 18 and want to see adult content?
A complete backup of huis-hypotheek.nl
Are you over 18 and want to see adult content?
A complete backup of daswoprlaretor.ga
Are you over 18 and want to see adult content?
Text
administrative or
THE TWELVE-FACTOR APP V. Build, release, run Strictly separate build and run stages. A codebase is transformed into a (non-development) deploy through three stages:. The build stage is a transform which converts a code repo into an executable bundle known as a build.Using a version of the code at a commit specified by the deployment process, the build stage fetches vendors dependencies and compiles binaries and assets. THE TWELVE-FACTOR APP II. Dependencies Explicitly declare and isolate dependencies. Most programming languages offer a packaging system for distributing support libraries, such as CPAN for Perl or Rubygems for Ruby. Libraries installed through a packaging system can be installed system-wide (known as “site packages”) or scoped into the directory containing the app (known as “vendoring” or“bundling”).
THE TWELVE-FACTOR APP IV. Backing services Treat backing services as attached resources. A backing service is any service the app consumes over the network as part of its normal operation. Examples include datastores (such as MySQL or CouchDB), messaging/queueing systems (such as RabbitMQ or Beanstalkd), SMTP services for outbound email (such as Postfix), and caching systems (such as Memcached). THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE III. Configuration Stockez la configuration dans l’environnement. La configuration d’une application est tout ce qui est susceptible de varier entre des déploiements (validation, production, environnement de développement, etc.). Cela inclut : Les ressources gérées par la base de données, Memcached, ou tout autre service de stockage; Les identifiants pour des services externes, tel qu THE TWELVE-FACTOR APP Introduction. In the modern era, software is commonly delivered as a service: called web apps, or software-as-a-service.The twelve-factor app is a methodology for THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE Introduction. À l’époque actuelle, les logiciels sont régulièrement délivrés en tant que services : on les appelle des applications web (web apps), ou logiciels en tant que service (software-as-a-service).L’application 12 facteurs est une méthodologie pour concevoir des logiciels en THE TWELVE-FACTOR APP VI. Processes Execute the app as one or more stateless processes. The app is executed in the execution environment as one or more processes.. In the simplest case, the code is a stand-alone script, the execution environment is a developer’s local laptop with an installed language runtime, and the process is launched via the command line (for example, python my_script.py). THE TWELVE-FACTOR APP VIII. Concurrency Scale out via the process model. Any computer program, once run, is represented by one or more processes. Web apps have taken a variety of process-execution forms. THE TWELVE-FACTOR APP IX. Disposability Maximize robustness with fast startup and graceful shutdown. The twelve-factor app’s processes are disposable, meaning they can be started or stopped at a moment’s notice. This facilitates fast elastic scaling, rapid deployment of code or config changes, and robustness of production deploys.. Processes should strive to minimize startup time. THE TWELVE-FACTOR APP XII. Admin processes Run admin/management tasks as one-off processes. The process formation is the array of processes that are used to do the app’s regular business (such as handling web requests) as it runs. Separately, developers will often wish to do one-offadministrative or
THE TWELVE-FACTOR APP V. Build, release, run Strictly separate build and run stages. A codebase is transformed into a (non-development) deploy through three stages:. The build stage is a transform which converts a code repo into an executable bundle known as a build.Using a version of the code at a commit specified by the deployment process, the build stage fetches vendors dependencies and compiles binaries and assets. THE TWELVE-FACTOR APP II. Dependencies Explicitly declare and isolate dependencies. Most programming languages offer a packaging system for distributing support libraries, such as CPAN for Perl or Rubygems for Ruby. Libraries installed through a packaging system can be installed system-wide (known as “site packages”) or scoped into the directory containing the app (known as “vendoring” or“bundling”).
THE TWELVE-FACTOR APP IV. Backing services Treat backing services as attached resources. A backing service is any service the app consumes over the network as part of its normal operation. Examples include datastores (such as MySQL or CouchDB), messaging/queueing systems (such as RabbitMQ or Beanstalkd), SMTP services for outbound email (such as Postfix), and caching systems (such as Memcached). THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE III. Configuration Stockez la configuration dans l’environnement. La configuration d’une application est tout ce qui est susceptible de varier entre des déploiements (validation, production, environnement de développement, etc.). Cela inclut : Les ressources gérées par la base de données, Memcached, ou tout autre service de stockage; Les identifiants pour des services externes, tel qu THE TWELVE-FACTOR APP Introduction. In the modern era, software is commonly delivered as a service: called web apps, or software-as-a-service.The twelve-factor app is a methodology for THE TWELVE-FACTOR APP VIII. Concurrency Scale out via the process model. Any computer program, once run, is represented by one or more processes. Web apps have taken a variety of process-execution forms. THE TWELVE-FACTOR APP III. Config Store config in the environment. An app’s config is everything that is likely to vary between deploys (staging, production, developer environments, etc). This includes: Resource handles to the database, Memcached, and other backing services;Credentials
THE TWELVE-FACTOR APP I. Codebase One codebase tracked in revision control, many deploys. A twelve-factor app is always tracked in a version control system, such as Git, Mercurial, or Subversion.A copy of the revision tracking database is known as a code repository, often shortened to code repo or just repo.. A codebase is any single repo (in a centralized revision control system like Subversion), or any set of THE TWELVE-FACTOR APP X. Dev/prod parity Keep development, staging, and production as similar as possible. Historically, there have been substantial gaps between development (a developer making live edits to a local deploy of the app) and production (a running deploy of the app accessed by end users). These gaps manifest in THE TWELVE-FACTOR APP IX. Disposability Maximize robustness with fast startup and graceful shutdown. The twelve-factor app’s processes are disposable, meaning they can be started or stopped at a moment’s notice. This facilitates fast elastic scaling, rapid deployment of code or config changes, and robustness of production deploys.. Processes should strive to minimize startup time. THE TWELVE-FACTOR APP V. Build, release, run Strictly separate build and run stages. A codebase is transformed into a (non-development) deploy through three stages:. The build stage is a transform which converts a code repo into an executable bundle known as a build.Using a version of the code at a commit specified by the deployment process, the build stage fetches vendors dependencies and compiles binaries and assets. THE TWELVE-FACTOR APP VII. Port binding Export services via port binding. Web apps are sometimes executed inside a webserver container. For example, PHP apps might run as a module inside Apache HTTPD, or Java apps might run inside Tomcat.. The twelve-factor app is completely self-contained and does not rely on runtime injection of a webserver into the execution environment to create a web-facing service. THE TWELVE-FACTOR APP ĐÂY LÀ BẢN DỊCH.TRANSLATE THIS PAGE Giới thiệu. Ngày nay, phần mềm thường được chuyển giao như là một dịch vụ: còn được gọi là các ứng dụng web, hay phần mềm-như-một-dịch vụ (software-as-a-service).Ứng dụng 12-hệ số là một phương pháp để xây dựng các ứng dụng phần mềm-như-một-dịch vụ với các tiêu chí sau: THE TWELVE-FACTOR APP ĐÂY LÀ BẢN DỊCH.TRANSLATE THIS PAGE Dịch vụ hỗ trợ, như là cơ sở dữ liệu của ứng dụng, hệ thống hàng đợi hoặc bộ đệm, là nơi m thường có sự khác biệt giữa môi trường phát triển và vận hành.Rất nhiều ngôn ngữ cung cấp các thư viện, bao gồm nhiều mô phỏng của các loại dịch vụ khác nhau được cung cấp để làm đơn giản hoá THE TWELVE-FACTOR APPV. BUILD, RELEASE, RUNIII. CONFIGCODEBASEIX. DISPOSABILITYVIII. CONCURRENCYII. DEPENDENCIES The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, THE TWELVE-FACTOR APP VI. Processes Execute the app as one or more stateless processes. The app is executed in the execution environment as one or more processes.. In the simplest case, the code is a stand-alone script, the execution environment is a developer’s local laptop with an installed language runtime, and the process is launched via the command line (for example, python my_script.py). THE TWELVE-FACTOR APP V. Build, release, run Strictly separate build and run stages. A codebase is transformed into a (non-development) deploy through three stages:. The build stage is a transform which converts a code repo into an executable bundle known as a build.Using a version of the code at a commit specified by the deployment process, the build stage fetches vendors dependencies and compiles binaries and assets. THE TWELVE-FACTOR APP The twelve-factor app stores config in environment variables (often shortened to env vars or env ). Env vars are easy to change between deploys without changing any code; unlike config files, there is little chance of them being checked into the code repo accidentally; and unlike custom config files, or other config mechanisms such asJava
THE TWELVE-FACTOR APP A twelve-factor app never concerns itself with routing or storage of its output stream. It should not attempt to write to or manage logfiles. Instead, each running process writes its event stream, unbuffered, to stdout. During local development, the developer will view this stream in the foreground of their terminal to observe theapp’s behavior.
THE TWELVE-FACTOR APP II. Dependencies Explicitly declare and isolate dependencies. Most programming languages offer a packaging system for distributing support libraries, such as CPAN for Perl or Rubygems for Ruby. Libraries installed through a packaging system can be installed system-wide (known as “site packages”) or scoped into the directory containing the app (known as “vendoring” or“bundling”).
THE TWELVE-FACTOR APP IV. Backing services Treat backing services as attached resources. A backing service is any service the app consumes over the network as part of its normal operation. Examples include datastores (such as MySQL or CouchDB), messaging/queueing systems (such as RabbitMQ or Beanstalkd), SMTP services for outbound email (such as Postfix), and caching systems (such as Memcached). THE TWELVE-FACTOR APP The twelve-factor app is designed for continuous deployment by keeping the gap between development and production small. Looking at the three gaps described above: Make the time gap small: a developer may write code and have it deployed hours or even just minutes later. THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE Introduction. À l’époque actuelle, les logiciels sont régulièrement délivrés en tant que services : on les appelle des applications web (web apps), ou logiciels en tant que service (software-as-a-service).L’application 12 facteurs est une méthodologie pour concevoir des logiciels en THE TWELVE-FACTOR APP VII. Port binding Export services via port binding. Web apps are sometimes executed inside a webserver container. For example, PHP apps might run as a module inside Apache HTTPD, or Java apps might run inside Tomcat.. The twelve-factor app is completely self-contained and does not rely on runtime injection of a webserver into the execution environment to create a web-facing service. THE TWELVE-FACTOR APPV. BUILD, RELEASE, RUNIII. CONFIGCODEBASEIX. DISPOSABILITYVIII. CONCURRENCYII. DEPENDENCIES The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, THE TWELVE-FACTOR APP VI. Processes Execute the app as one or more stateless processes. The app is executed in the execution environment as one or more processes.. In the simplest case, the code is a stand-alone script, the execution environment is a developer’s local laptop with an installed language runtime, and the process is launched via the command line (for example, python my_script.py). THE TWELVE-FACTOR APP V. Build, release, run Strictly separate build and run stages. A codebase is transformed into a (non-development) deploy through three stages:. The build stage is a transform which converts a code repo into an executable bundle known as a build.Using a version of the code at a commit specified by the deployment process, the build stage fetches vendors dependencies and compiles binaries and assets. THE TWELVE-FACTOR APP The twelve-factor app stores config in environment variables (often shortened to env vars or env ). Env vars are easy to change between deploys without changing any code; unlike config files, there is little chance of them being checked into the code repo accidentally; and unlike custom config files, or other config mechanisms such asJava
THE TWELVE-FACTOR APP A twelve-factor app never concerns itself with routing or storage of its output stream. It should not attempt to write to or manage logfiles. Instead, each running process writes its event stream, unbuffered, to stdout. During local development, the developer will view this stream in the foreground of their terminal to observe theapp’s behavior.
THE TWELVE-FACTOR APP II. Dependencies Explicitly declare and isolate dependencies. Most programming languages offer a packaging system for distributing support libraries, such as CPAN for Perl or Rubygems for Ruby. Libraries installed through a packaging system can be installed system-wide (known as “site packages”) or scoped into the directory containing the app (known as “vendoring” or“bundling”).
THE TWELVE-FACTOR APP IV. Backing services Treat backing services as attached resources. A backing service is any service the app consumes over the network as part of its normal operation. Examples include datastores (such as MySQL or CouchDB), messaging/queueing systems (such as RabbitMQ or Beanstalkd), SMTP services for outbound email (such as Postfix), and caching systems (such as Memcached). THE TWELVE-FACTOR APP The twelve-factor app is designed for continuous deployment by keeping the gap between development and production small. Looking at the three gaps described above: Make the time gap small: a developer may write code and have it deployed hours or even just minutes later. THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE Introduction. À l’époque actuelle, les logiciels sont régulièrement délivrés en tant que services : on les appelle des applications web (web apps), ou logiciels en tant que service (software-as-a-service).L’application 12 facteurs est une méthodologie pour concevoir des logiciels en THE TWELVE-FACTOR APP VII. Port binding Export services via port binding. Web apps are sometimes executed inside a webserver container. For example, PHP apps might run as a module inside Apache HTTPD, or Java apps might run inside Tomcat.. The twelve-factor app is completely self-contained and does not rely on runtime injection of a webserver into the execution environment to create a web-facing service. THE TWELVE-FACTOR APP VI. Processes Execute the app as one or more stateless processes. The app is executed in the execution environment as one or more processes.. In the simplest case, the code is a stand-alone script, the execution environment is a developer’s local laptop with an installed language runtime, and the process is launched via the command line (for example, python my_script.py). THE TWELVE-FACTOR APP III. Config Store config in the environment. An app’s config is everything that is likely to vary between deploys (staging, production, developer environments, etc). This includes: Resource handles to the database, Memcached, and other backing services;Credentials
THE TWELVE-FACTOR APP The share-nothing, horizontally partitionable nature of twelve-factor app processes means that adding more concurrency is a simple and reliable operation. The array of process types and number of processes of each type is known as the process formation. Twelve-factor app processes should never daemonize or write PID files. THE TWELVE-FACTOR APP A twelve-factor app never concerns itself with routing or storage of its output stream. It should not attempt to write to or manage logfiles. Instead, each running process writes its event stream, unbuffered, to stdout. During local development, the developer will view this stream in the foreground of their terminal to observe theapp’s behavior.
THE TWELVE-FACTOR APP I. Codebase One codebase tracked in revision control, many deploys. A twelve-factor app is always tracked in a version control system, such as Git, Mercurial, or Subversion.A copy of the revision tracking database is known as a code repository, often shortened to code repo or just repo.. A codebase is any single repo (in a centralized revision control system like Subversion), or any set of THE TWELVE-FACTOR APP IX. Disposability Maximize robustness with fast startup and graceful shutdown. The twelve-factor app’s processes are disposable, meaning they can be started or stopped at a moment’s notice. This facilitates fast elastic scaling, rapid deployment of code or config changes, and robustness of production deploys.. Processes should strive to minimize startup time. THE TWELVE-FACTOR APP XII. Admin processes Run admin/management tasks as one-off processes. The process formation is the array of processes that are used to do the app’s regular business (such as handling web requests) as it runs. Separately, developers will often wish to do one-offadministrative or
THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE III. Configuration Stockez la configuration dans l’environnement. La configuration d’une application est tout ce qui est susceptible de varier entre des déploiements (validation, production, environnement de développement, etc.). Cela inclut : Les ressources gérées par la base de données, Memcached, ou tout autre service de stockage; Les identifiants pour des services externes, tel qu THE TWELVE-FACTOR APP ĐÂY LÀ BẢN DỊCH.TRANSLATE THIS PAGE Giới thiệu. Ngày nay, phần mềm thường được chuyển giao như là một dịch vụ: còn được gọi là các ứng dụng web, hay phần mềm-như-một-dịch vụ (software-as-a-service).Ứng dụng 12-hệ số là một phương pháp để xây dựng các ứng dụng phần mềm-như-một-dịch vụ với các tiêu chí sau: THE TWELVE-FACTOR APP (TRADUCCIÓN DE LA VERSIÓN …TRANSLATE THISPAGE
Introducción. En estos tiempos, el software se está distribuyendo como un servicio: se le denomina web apps, o software as a service (SaaS). “The twelve-factor app” es una metodología para construir aplicaciones SaaS que: Usan formatos declarativos para la automatización de la configuración, para minimizar el tiempo y elcoste que
THE TWELVE-FACTOR APPV. BUILD, RELEASE, RUNIII. CONFIGCODEBASEIX. DISPOSABILITYVIII. CONCURRENCYII. DEPENDENCIES The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, THE TWELVE-FACTOR APP VI. Processes Execute the app as one or more stateless processes. The app is executed in the execution environment as one or more processes.. In the simplest case, the code is a stand-alone script, the execution environment is a developer’s local laptop with an installed language runtime, and the process is launched via the command line (for example, python my_script.py). THE TWELVE-FACTOR APP V. Build, release, run Strictly separate build and run stages. A codebase is transformed into a (non-development) deploy through three stages:. The build stage is a transform which converts a code repo into an executable bundle known as a build.Using a version of the code at a commit specified by the deployment process, the build stage fetches vendors dependencies and compiles binaries and assets. THE TWELVE-FACTOR APP The twelve-factor app stores config in environment variables (often shortened to env vars or env ). Env vars are easy to change between deploys without changing any code; unlike config files, there is little chance of them being checked into the code repo accidentally; and unlike custom config files, or other config mechanisms such asJava
THE TWELVE-FACTOR APP IV. Backing services Treat backing services as attached resources. A backing service is any service the app consumes over the network as part of its normal operation. Examples include datastores (such as MySQL or CouchDB), messaging/queueing systems (such as RabbitMQ or Beanstalkd), SMTP services for outbound email (such as Postfix), and caching systems (such as Memcached). THE TWELVE-FACTOR APP The twelve-factor app is designed for continuous deployment by keeping the gap between development and production small. Looking at the three gaps described above: Make the time gap small: a developer may write code and have it deployed hours or even just minutes later. THE TWELVE-FACTOR APP II. Dependencies Explicitly declare and isolate dependencies. Most programming languages offer a packaging system for distributing support libraries, such as CPAN for Perl or Rubygems for Ruby. Libraries installed through a packaging system can be installed system-wide (known as “site packages”) or scoped into the directory containing the app (known as “vendoring” or“bundling”).
THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE Introduction. À l’époque actuelle, les logiciels sont régulièrement délivrés en tant que services : on les appelle des applications web (web apps), ou logiciels en tant que service (software-as-a-service).L’application 12 facteurs est une méthodologie pour concevoir des logiciels en THE TWELVE-FACTOR APP (简体中文)TRANSLATE THIS PAGE A methodology for building modern, scalable, maintainable software-as-a-service apps. THE TWELVE-FACTOR APP (TRADUCCIÓN DE LA VERSIÓN …TRANSLATE THISPAGE
Introducción. En estos tiempos, el software se está distribuyendo como un servicio: se le denomina web apps, o software as a service (SaaS). “The twelve-factor app” es una metodología para construir aplicaciones SaaS que: Usan formatos declarativos para la automatización de la configuración, para minimizar el tiempo y elcoste que
THE TWELVE-FACTOR APPV. BUILD, RELEASE, RUNIII. CONFIGCODEBASEIX. DISPOSABILITYVIII. CONCURRENCYII. DEPENDENCIES The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, THE TWELVE-FACTOR APP VI. Processes Execute the app as one or more stateless processes. The app is executed in the execution environment as one or more processes.. In the simplest case, the code is a stand-alone script, the execution environment is a developer’s local laptop with an installed language runtime, and the process is launched via the command line (for example, python my_script.py). THE TWELVE-FACTOR APP V. Build, release, run Strictly separate build and run stages. A codebase is transformed into a (non-development) deploy through three stages:. The build stage is a transform which converts a code repo into an executable bundle known as a build.Using a version of the code at a commit specified by the deployment process, the build stage fetches vendors dependencies and compiles binaries and assets. THE TWELVE-FACTOR APP The twelve-factor app stores config in environment variables (often shortened to env vars or env ). Env vars are easy to change between deploys without changing any code; unlike config files, there is little chance of them being checked into the code repo accidentally; and unlike custom config files, or other config mechanisms such asJava
THE TWELVE-FACTOR APP IV. Backing services Treat backing services as attached resources. A backing service is any service the app consumes over the network as part of its normal operation. Examples include datastores (such as MySQL or CouchDB), messaging/queueing systems (such as RabbitMQ or Beanstalkd), SMTP services for outbound email (such as Postfix), and caching systems (such as Memcached). THE TWELVE-FACTOR APP The twelve-factor app is designed for continuous deployment by keeping the gap between development and production small. Looking at the three gaps described above: Make the time gap small: a developer may write code and have it deployed hours or even just minutes later. THE TWELVE-FACTOR APP II. Dependencies Explicitly declare and isolate dependencies. Most programming languages offer a packaging system for distributing support libraries, such as CPAN for Perl or Rubygems for Ruby. Libraries installed through a packaging system can be installed system-wide (known as “site packages”) or scoped into the directory containing the app (known as “vendoring” or“bundling”).
THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE Introduction. À l’époque actuelle, les logiciels sont régulièrement délivrés en tant que services : on les appelle des applications web (web apps), ou logiciels en tant que service (software-as-a-service).L’application 12 facteurs est une méthodologie pour concevoir des logiciels en THE TWELVE-FACTOR APP (简体中文)TRANSLATE THIS PAGE A methodology for building modern, scalable, maintainable software-as-a-service apps. THE TWELVE-FACTOR APP (TRADUCCIÓN DE LA VERSIÓN …TRANSLATE THISPAGE
Introducción. En estos tiempos, el software se está distribuyendo como un servicio: se le denomina web apps, o software as a service (SaaS). “The twelve-factor app” es una metodología para construir aplicaciones SaaS que: Usan formatos declarativos para la automatización de la configuración, para minimizar el tiempo y elcoste que
THE TWELVE-FACTOR APP VI. Processes Execute the app as one or more stateless processes. The app is executed in the execution environment as one or more processes.. In the simplest case, the code is a stand-alone script, the execution environment is a developer’s local laptop with an installed language runtime, and the process is launched via the command line (for example, python my_script.py). THE TWELVE-FACTOR APP III. Config Store config in the environment. An app’s config is everything that is likely to vary between deploys (staging, production, developer environments, etc). This includes: Resource handles to the database, Memcached, and other backing services;Credentials
THE TWELVE-FACTOR APP The share-nothing, horizontally partitionable nature of twelve-factor app processes means that adding more concurrency is a simple and reliable operation. The array of process types and number of processes of each type is known as the process formation. Twelve-factor app processes should never daemonize or write PID files. THE TWELVE-FACTOR APP A twelve-factor app never concerns itself with routing or storage of its output stream. It should not attempt to write to or manage logfiles. Instead, each running process writes its event stream, unbuffered, to stdout. During local development, the developer will view this stream in the foreground of their terminal to observe theapp’s behavior.
THE TWELVE-FACTOR APP IX. Disposability Maximize robustness with fast startup and graceful shutdown. The twelve-factor app’s processes are disposable, meaning they can be started or stopped at a moment’s notice. This facilitates fast elastic scaling, rapid deployment of code or config changes, and robustness of production deploys.. Processes should strive to minimize startup time. THE TWELVE-FACTOR APP XII. Admin processes Run admin/management tasks as one-off processes. The process formation is the array of processes that are used to do the app’s regular business (such as handling web requests) as it runs. Separately, developers will often wish to do one-offadministrative or
THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE Une application 12 facteurs est toujours suivie dans un système de contrôle de version, tel que Git, Mercurial, ou Subversion. Une copie de la base de données de suivi des révisions est appelée dépôt de code, souvent raccourci en dépôt. Le terme anglais code repository, raccourci en repository et repo est également utilisé. THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE III. Configuration Stockez la configuration dans l’environnement. La configuration d’une application est tout ce qui est susceptible de varier entre des déploiements (validation, production, environnement de développement, etc.). Cela inclut : Les ressources gérées par la base de données, Memcached, ou tout autre service de stockage; Les identifiants pour des services externes, tel qu THE TWELVE-FACTOR APP (TRADUCCIÓN DE LA VERSIÓN …TRANSLATE THISPAGE
Introducción. En estos tiempos, el software se está distribuyendo como un servicio: se le denomina web apps, o software as a service (SaaS). “The twelve-factor app” es una metodología para construir aplicaciones SaaS que: Usan formatos declarativos para la automatización de la configuración, para minimizar el tiempo y elcoste que
THE TWELVE-FACTOR APP ĐÂY LÀ BẢN DỊCH.TRANSLATE THIS PAGE Giới thiệu. Ngày nay, phần mềm thường được chuyển giao như là một dịch vụ: còn được gọi là các ứng dụng web, hay phần mềm-như-một-dịch vụ (software-as-a-service).Ứng dụng 12-hệ số là một phương pháp để xây dựng các ứng dụng phần mềm-như-một-dịch vụ với các tiêu chí sau: THE TWELVE-FACTOR APPV. BUILD, RELEASE, RUNIII. CONFIGCODEBASEIX. DISPOSABILITYVIII. CONCURRENCYII. DEPENDENCIES The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, THE TWELVE-FACTOR APP The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, offering maximum portability between execution environments; Are suitable for deployment THE TWELVE-FACTOR APP VI. Processes Execute the app as one or more stateless processes. The app is executed in the execution environment as one or more processes.. In the simplest case, the code is a stand-alone script, the execution environment is a developer’s local laptop with an installed language runtime, and the process is launched via the command line (for example, python my_script.py). THE TWELVE-FACTOR APP The twelve-factor app stores config in environment variables (often shortened to env vars or env ). Env vars are easy to change between deploys without changing any code; unlike config files, there is little chance of them being checked into the code repo accidentally; and unlike custom config files, or other config mechanisms such asJava
THE TWELVE-FACTOR APP The share-nothing, horizontally partitionable nature of twelve-factor app processes means that adding more concurrency is a simple and reliable operation. The array of process types and number of processes of each type is known as the process formation. Twelve-factor app processes should never daemonize or write PID files. THE TWELVE-FACTOR APP V. Build, release, run Strictly separate build and run stages. A codebase is transformed into a (non-development) deploy through three stages:. The build stage is a transform which converts a code repo into an executable bundle known as a build.Using a version of the code at a commit specified by the deployment process, the build stage fetches vendors dependencies and compiles binaries and assets. THE TWELVE-FACTOR APP A twelve-factor app never concerns itself with routing or storage of its output stream. It should not attempt to write to or manage logfiles. Instead, each running process writes its event stream, unbuffered, to stdout. During local development, the developer will view this stream in the foreground of their terminal to observe theapp’s behavior.
THE TWELVE-FACTOR APP II. Dependencies Explicitly declare and isolate dependencies. Most programming languages offer a packaging system for distributing support libraries, such as CPAN for Perl or Rubygems for Ruby. Libraries installed through a packaging system can be installed system-wide (known as “site packages”) or scoped into the directory containing the app (known as “vendoring” or“bundling”).
THE TWELVE-FACTOR APP IV. Backing services Treat backing services as attached resources. A backing service is any service the app consumes over the network as part of its normal operation. Examples include datastores (such as MySQL or CouchDB), messaging/queueing systems (such as RabbitMQ or Beanstalkd), SMTP services for outbound email (such as Postfix), and caching systems (such as Memcached). THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE Introduction. À l’époque actuelle, les logiciels sont régulièrement délivrés en tant que services : on les appelle des applications web (web apps), ou logiciels en tant que service (software-as-a-service).L’application 12 facteurs est une méthodologie pour concevoir des logiciels en THE TWELVE-FACTOR APPV. BUILD, RELEASE, RUNIII. CONFIGCODEBASEIX. DISPOSABILITYVIII. CONCURRENCYII. DEPENDENCIES The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, THE TWELVE-FACTOR APP The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, offering maximum portability between execution environments; Are suitable for deployment THE TWELVE-FACTOR APP VI. Processes Execute the app as one or more stateless processes. The app is executed in the execution environment as one or more processes.. In the simplest case, the code is a stand-alone script, the execution environment is a developer’s local laptop with an installed language runtime, and the process is launched via the command line (for example, python my_script.py). THE TWELVE-FACTOR APP The twelve-factor app stores config in environment variables (often shortened to env vars or env ). Env vars are easy to change between deploys without changing any code; unlike config files, there is little chance of them being checked into the code repo accidentally; and unlike custom config files, or other config mechanisms such asJava
THE TWELVE-FACTOR APP The share-nothing, horizontally partitionable nature of twelve-factor app processes means that adding more concurrency is a simple and reliable operation. The array of process types and number of processes of each type is known as the process formation. Twelve-factor app processes should never daemonize or write PID files. THE TWELVE-FACTOR APP V. Build, release, run Strictly separate build and run stages. A codebase is transformed into a (non-development) deploy through three stages:. The build stage is a transform which converts a code repo into an executable bundle known as a build.Using a version of the code at a commit specified by the deployment process, the build stage fetches vendors dependencies and compiles binaries and assets. THE TWELVE-FACTOR APP A twelve-factor app never concerns itself with routing or storage of its output stream. It should not attempt to write to or manage logfiles. Instead, each running process writes its event stream, unbuffered, to stdout. During local development, the developer will view this stream in the foreground of their terminal to observe theapp’s behavior.
THE TWELVE-FACTOR APP II. Dependencies Explicitly declare and isolate dependencies. Most programming languages offer a packaging system for distributing support libraries, such as CPAN for Perl or Rubygems for Ruby. Libraries installed through a packaging system can be installed system-wide (known as “site packages”) or scoped into the directory containing the app (known as “vendoring” or“bundling”).
THE TWELVE-FACTOR APP IV. Backing services Treat backing services as attached resources. A backing service is any service the app consumes over the network as part of its normal operation. Examples include datastores (such as MySQL or CouchDB), messaging/queueing systems (such as RabbitMQ or Beanstalkd), SMTP services for outbound email (such as Postfix), and caching systems (such as Memcached). THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE Introduction. À l’époque actuelle, les logiciels sont régulièrement délivrés en tant que services : on les appelle des applications web (web apps), ou logiciels en tant que service (software-as-a-service).L’application 12 facteurs est une méthodologie pour concevoir des logiciels en THE TWELVE-FACTOR APP The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, offering maximum portability between execution environments; Are suitable for deployment THE TWELVE-FACTOR APP The share-nothing, horizontally partitionable nature of twelve-factor app processes means that adding more concurrency is a simple and reliable operation. The array of process types and number of processes of each type is known as the process formation. Twelve-factor app processes should never daemonize or write PID files. THE TWELVE-FACTOR APP IX. Disposability Maximize robustness with fast startup and graceful shutdown. The twelve-factor app’s processes are disposable, meaning they can be started or stopped at a moment’s notice. This facilitates fast elastic scaling, rapid deployment of code or config changes, and robustness of production deploys.. Processes should strive to minimize startup time. THE TWELVE-FACTOR APP A twelve-factor app never concerns itself with routing or storage of its output stream. It should not attempt to write to or manage logfiles. Instead, each running process writes its event stream, unbuffered, to stdout. During local development, the developer will view this stream in the foreground of their terminal to observe theapp’s behavior.
THE TWELVE-FACTOR APP I. Codebase One codebase tracked in revision control, many deploys. A twelve-factor app is always tracked in a version control system, such as Git, Mercurial, or Subversion.A copy of the revision tracking database is known as a code repository, often shortened to code repo or just repo.. A codebase is any single repo (in a centralized revision control system like Subversion), or any set of THE TWELVE-FACTOR APP XII. Admin processes Run admin/management tasks as one-off processes. The process formation is the array of processes that are used to do the app’s regular business (such as handling web requests) as it runs. Separately, developers will often wish to do one-offadministrative or
THE TWELVE-FACTOR APP (TRADUZIDO)TRANSLATE THIS PAGE São adequados para implantação em modernas plataformas em nuvem, evitando a necessidade por servidores e administração do sistema; Minimizam a divergência entre desenvolvimento e produção, permitindo a implantação contínua para máxima agilidade; E podem escalar sem significativas mudanças em ferramentas, arquiteturas, oupráticas
THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE Une application 12 facteurs est toujours suivie dans un système de contrôle de version, tel que Git, Mercurial, ou Subversion. Une copie de la base de données de suivi des révisions est appelée dépôt de code, souvent raccourci en dépôt. Le terme anglais code repository, raccourci en repository et repo est également utilisé. THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE III. Configuration Stockez la configuration dans l’environnement. La configuration d’une application est tout ce qui est susceptible de varier entre des déploiements (validation, production, environnement de développement, etc.). Cela inclut : Les ressources gérées par la base de données, Memcached, ou tout autre service de stockage; Les identifiants pour des services externes, tel qu THE TWELVE-FACTOR APP (TRADUCCIÓN DE LA VERSIÓN …TRANSLATE THISPAGE
Introducción. En estos tiempos, el software se está distribuyendo como un servicio: se le denomina web apps, o software as a service (SaaS). “The twelve-factor app” es una metodología para construir aplicaciones SaaS que: Usan formatos declarativos para la automatización de la configuración, para minimizar el tiempo y elcoste que
THE TWELVE-FACTOR APPV. BUILD, RELEASE, RUNIII. CONFIGCODEBASEIX. DISPOSABILITYVIII. CONCURRENCYII. DEPENDENCIES The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, THE TWELVE-FACTOR APP The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, offering maximum portability between execution environments; Are suitable for deployment THE TWELVE-FACTOR APP VI. Processes Execute the app as one or more stateless processes. The app is executed in the execution environment as one or more processes.. In the simplest case, the code is a stand-alone script, the execution environment is a developer’s local laptop with an installed language runtime, and the process is launched via the command line (for example, python my_script.py). THE TWELVE-FACTOR APP The twelve-factor app stores config in environment variables (often shortened to env vars or env ). Env vars are easy to change between deploys without changing any code; unlike config files, there is little chance of them being checked into the code repo accidentally; and unlike custom config files, or other config mechanisms such asJava
THE TWELVE-FACTOR APP The share-nothing, horizontally partitionable nature of twelve-factor app processes means that adding more concurrency is a simple and reliable operation. The array of process types and number of processes of each type is known as the process formation. Twelve-factor app processes should never daemonize or write PID files. THE TWELVE-FACTOR APP V. Build, release, run Strictly separate build and run stages. A codebase is transformed into a (non-development) deploy through three stages:. The build stage is a transform which converts a code repo into an executable bundle known as a build.Using a version of the code at a commit specified by the deployment process, the build stage fetches vendors dependencies and compiles binaries and assets. THE TWELVE-FACTOR APP A twelve-factor app never concerns itself with routing or storage of its output stream. It should not attempt to write to or manage logfiles. Instead, each running process writes its event stream, unbuffered, to stdout. During local development, the developer will view this stream in the foreground of their terminal to observe theapp’s behavior.
THE TWELVE-FACTOR APP II. Dependencies Explicitly declare and isolate dependencies. Most programming languages offer a packaging system for distributing support libraries, such as CPAN for Perl or Rubygems for Ruby. Libraries installed through a packaging system can be installed system-wide (known as “site packages”) or scoped into the directory containing the app (known as “vendoring” or“bundling”).
THE TWELVE-FACTOR APP IV. Backing services Treat backing services as attached resources. A backing service is any service the app consumes over the network as part of its normal operation. Examples include datastores (such as MySQL or CouchDB), messaging/queueing systems (such as RabbitMQ or Beanstalkd), SMTP services for outbound email (such as Postfix), and caching systems (such as Memcached). THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGETHE TWELVE FACTOR APP PDF12 FACTOR APP METHODOLOGY12 FACTOR APPLICATIONSTHE TWELVE FACTORSTWELVE FACTOR APP Introduction. À l’époque actuelle, les logiciels sont régulièrement délivrés en tant que services : on les appelle des applications web (web apps), ou logiciels en tant que service (software-as-a-service).L’application 12 facteurs est une méthodologie pour concevoir des logiciels en THE TWELVE-FACTOR APPV. BUILD, RELEASE, RUNIII. CONFIGCODEBASEIX. DISPOSABILITYVIII. CONCURRENCYII. DEPENDENCIES The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, THE TWELVE-FACTOR APP The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, offering maximum portability between execution environments; Are suitable for deployment THE TWELVE-FACTOR APP VI. Processes Execute the app as one or more stateless processes. The app is executed in the execution environment as one or more processes.. In the simplest case, the code is a stand-alone script, the execution environment is a developer’s local laptop with an installed language runtime, and the process is launched via the command line (for example, python my_script.py). THE TWELVE-FACTOR APP The twelve-factor app stores config in environment variables (often shortened to env vars or env ). Env vars are easy to change between deploys without changing any code; unlike config files, there is little chance of them being checked into the code repo accidentally; and unlike custom config files, or other config mechanisms such asJava
THE TWELVE-FACTOR APP The share-nothing, horizontally partitionable nature of twelve-factor app processes means that adding more concurrency is a simple and reliable operation. The array of process types and number of processes of each type is known as the process formation. Twelve-factor app processes should never daemonize or write PID files. THE TWELVE-FACTOR APP V. Build, release, run Strictly separate build and run stages. A codebase is transformed into a (non-development) deploy through three stages:. The build stage is a transform which converts a code repo into an executable bundle known as a build.Using a version of the code at a commit specified by the deployment process, the build stage fetches vendors dependencies and compiles binaries and assets. THE TWELVE-FACTOR APP A twelve-factor app never concerns itself with routing or storage of its output stream. It should not attempt to write to or manage logfiles. Instead, each running process writes its event stream, unbuffered, to stdout. During local development, the developer will view this stream in the foreground of their terminal to observe theapp’s behavior.
THE TWELVE-FACTOR APP II. Dependencies Explicitly declare and isolate dependencies. Most programming languages offer a packaging system for distributing support libraries, such as CPAN for Perl or Rubygems for Ruby. Libraries installed through a packaging system can be installed system-wide (known as “site packages”) or scoped into the directory containing the app (known as “vendoring” or“bundling”).
THE TWELVE-FACTOR APP IV. Backing services Treat backing services as attached resources. A backing service is any service the app consumes over the network as part of its normal operation. Examples include datastores (such as MySQL or CouchDB), messaging/queueing systems (such as RabbitMQ or Beanstalkd), SMTP services for outbound email (such as Postfix), and caching systems (such as Memcached). THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGETHE TWELVE FACTOR APP PDF12 FACTOR APP METHODOLOGY12 FACTOR APPLICATIONSTHE TWELVE FACTORSTWELVE FACTOR APP Introduction. À l’époque actuelle, les logiciels sont régulièrement délivrés en tant que services : on les appelle des applications web (web apps), ou logiciels en tant que service (software-as-a-service).L’application 12 facteurs est une méthodologie pour concevoir des logiciels en THE TWELVE-FACTOR APP The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, offering maximum portability between execution environments; Are suitable for deployment THE TWELVE-FACTOR APP The share-nothing, horizontally partitionable nature of twelve-factor app processes means that adding more concurrency is a simple and reliable operation. The array of process types and number of processes of each type is known as the process formation. Twelve-factor app processes should never daemonize or write PID files. THE TWELVE-FACTOR APP IX. Disposability Maximize robustness with fast startup and graceful shutdown. The twelve-factor app’s processes are disposable, meaning they can be started or stopped at a moment’s notice. This facilitates fast elastic scaling, rapid deployment of code or config changes, and robustness of production deploys.. Processes should strive to minimize startup time. THE TWELVE-FACTOR APP A twelve-factor app never concerns itself with routing or storage of its output stream. It should not attempt to write to or manage logfiles. Instead, each running process writes its event stream, unbuffered, to stdout. During local development, the developer will view this stream in the foreground of their terminal to observe theapp’s behavior.
THE TWELVE-FACTOR APP I. Codebase One codebase tracked in revision control, many deploys. A twelve-factor app is always tracked in a version control system, such as Git, Mercurial, or Subversion.A copy of the revision tracking database is known as a code repository, often shortened to code repo or just repo.. A codebase is any single repo (in a centralized revision control system like Subversion), or any set of THE TWELVE-FACTOR APP XII. Admin processes Run admin/management tasks as one-off processes. The process formation is the array of processes that are used to do the app’s regular business (such as handling web requests) as it runs. Separately, developers will often wish to do one-offadministrative or
THE TWELVE-FACTOR APP (TRADUZIDO)TRANSLATE THIS PAGE São adequados para implantação em modernas plataformas em nuvem, evitando a necessidade por servidores e administração do sistema; Minimizam a divergência entre desenvolvimento e produção, permitindo a implantação contínua para máxima agilidade; E podem escalar sem significativas mudanças em ferramentas, arquiteturas, oupráticas
THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE Une application 12 facteurs est toujours suivie dans un système de contrôle de version, tel que Git, Mercurial, ou Subversion. Une copie de la base de données de suivi des révisions est appelée dépôt de code, souvent raccourci en dépôt. Le terme anglais code repository, raccourci en repository et repo est également utilisé. THE TWELVE-FACTOR APP CE TEXTE EST UNE TRADUCTIONTRANSLATE THIS PAGE III. Configuration Stockez la configuration dans l’environnement. La configuration d’une application est tout ce qui est susceptible de varier entre des déploiements (validation, production, environnement de développement, etc.). Cela inclut : Les ressources gérées par la base de données, Memcached, ou tout autre service de stockage; Les identifiants pour des services externes, tel qu THE TWELVE-FACTOR APP (TRADUCCIÓN DE LA VERSIÓN …TRANSLATE THISPAGE
Introducción. En estos tiempos, el software se está distribuyendo como un servicio: se le denomina web apps, o software as a service (SaaS). “The twelve-factor app” es una metodología para construir aplicaciones SaaS que: Usan formatos declarativos para la automatización de la configuración, para minimizar el tiempo y elcoste que
THE TWELVE-FACTOR APPINTRODUCTION
In the modern era, software is commonly delivered as a service: called _web apps_, or _software-as-a-service_. The twelve-factor app is a methodology for building software-as-a-service apps that: * Use DECLARATIVE formats for setup automation, to minimize time and cost for new developers joining the project; * Have a CLEAN CONTRACT with the underlying operating system, offering MAXIMUM PORTABILITY between execution environments; * Are suitable for DEPLOYMENT on modern CLOUD PLATFORMS, obviating the need for servers and systems administration; * MINIMIZE DIVERGENCE between development and production, enabling CONTINUOUS DEPLOYMENT for maximum agility; * And can SCALE UP without significant changes to tooling, architecture, or development practices. The twelve-factor methodology can be applied to apps written in any programming language, and which use any combination of backing services (database, queue, memory cache, etc).BACKGROUND
The contributors to this document have been directly involved in the development and deployment of hundreds of apps, and indirectly witnessed the development, operation, and scaling of hundreds of thousands of apps via our work on the Herokuplatform.
This document synthesizes all of our experience and observations on a wide variety of software-as-a-service apps in the wild. It is a triangulation on ideal practices for app development, paying particular attention to the dynamics of the organic growth of an app over time, the dynamics of collaboration between developers working on the app’s codebase, and avoiding the cost of software erosion.
Our motivation is to raise awareness of some systemic problems we’ve seen in modern application development, to provide a shared vocabulary for discussing those problems, and to offer a set of broad conceptual solutions to those problems with accompanying terminology. The format is inspired by Martin Fowler’s books _Patterns of Enterprise Application Architecture_
and _Refactoring
_.
WHO SHOULD READ THIS DOCUMENT? Any developer building applications which run as a service. Ops engineers who deploy or manage such applications.THE TWELVE FACTORS
I. CODEBASE
ONE CODEBASE TRACKED IN REVISION CONTROL, MANY DEPLOYSII. DEPENDENCIES
EXPLICITLY DECLARE AND ISOLATE DEPENDENCIESIII. CONFIG
STORE CONFIG IN THE ENVIRONMENT IV. BACKING SERVICES TREAT BACKING SERVICES AS ATTACHED RESOURCES V. BUILD, RELEASE, RUN STRICTLY SEPARATE BUILD AND RUN STAGESVI. PROCESSES
EXECUTE THE APP AS ONE OR MORE STATELESS PROCESSESVII. PORT BINDING
EXPORT SERVICES VIA PORT BINDINGVIII. CONCURRENCY
SCALE OUT VIA THE PROCESS MODELIX. DISPOSABILITY
MAXIMIZE ROBUSTNESS WITH FAST STARTUP AND GRACEFUL SHUTDOWNX. DEV/PROD PARITY
KEEP DEVELOPMENT, STAGING, AND PRODUCTION AS SIMILAR AS POSSIBLEXI. LOGS
TREAT LOGS AS EVENT STREAMS XII. ADMIN PROCESSES RUN ADMIN/MANAGEMENT TASKS AS ONE-OFF PROCESSES Español (es) | Русский (ru) | Brazilian Portuguese (pt_br) | Ελληνικά (el) | 日本語 (ja) | Turkish (tr) | Tiếng Việt (vi) | English (en) | Italiano (it) | Polski (pl) | Українська (uk) | ภาษาไทย (th) | Deutsch (de) | Slovensky (sk) | Français (fr) | 简体中文 (zh_cn) | 한국어 (ko) Written by Adam WigginsLast updated 2017
Sourcecode
Download ePub Book
Privacy Policy
Details
Copyright © 2024 ArchiveBay.com. All rights reserved. Terms of Use | Privacy Policy | DMCA | 2021 | Feedback | Advertising | RSS 2.0