Application Modernization Technical Conference 2019 Live Coding 12-Factor App Emily Jiang Java Champion STSM, IBM Liberty Microservice Architect, Advocate MicroProfile Architect @emilyfhjiang
Contents Basic concept of 12 factor app On stage hacking of creating 12 factor microservices using MicroProfile
12 Factors in a nut shell – A Methodologie – Best Practices – Manifesto https://12factor.net/ by Heroku
Why 12 factor? Define the contract between applications and infrastructure • Infrastructure Application
What is a Twelve-Factor App? 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). From https://12factor.net
THE FACTORS 7. Port binding Codebase 1. 8. Concurrency Dependencies 2. 9. Disposability Config 3. Backing Services 10.Dev / Prod parity 4. Build, Release, Run 5. 11.Logs Processes 6. 12.Admin Processes
How to build 12-Factor App?
MicroProfile and Kubernetes come to rescue!
Lightweight, Iterative Processes NO Reference Implementation Specs, APIs, TCKs Community Driven
MicroProfile Community ● Over a dozen vendors and Java user groups ● Around 169 individual contributors and growing ● Around a dozen independent implementations
✓ Open specifications ✓ Wide vendor support ✓ REST Client ✓ OpenAPI support Quarkus ✓ Security ✓ Fault Tolerance ✓ Configuration ✓ Metrics ✓ Health ✓ Open Tracing https://wiki.eclipse.org/MicroProfile/Implementation
MicroProfile 3.3 (Feb 2020) MicroProfile 3.2 Config 1.4 MicroProfile 3.0 Metrics 2.3 (June 2019) Fault Tolerance 2.1 Health 2.2 MicroProfile 2.1 Rest Client 1.4 MicroProfile 2.2 (Feb MicroProfile 1.4 (June 2018) Metrics 2.0 2019) MicroProfile 1.2 (Sept 2017) MicroProfile 1.3 Health Check Fault Tolerance 2.0 MicroProfile-1.1 Config 1.3 2.0 Config 1.1 OpenAPI 1.1 Fault Tolerance 1.1 Rest Client 1.3 Fault Tolerance 1.0 OpenTracing 1.3 2020 JWT 1.1 Rest Client 1.2 Health 1.0 Open Tracing-1.1 Metrics 1.0 Rest Client-1.1 JWT 1.0 2019 MicroProfile 3.2 (Nov 2019) MicroProfile 3.0 MicroProfile 2.1 (Oct MicroProfile 1.1 (August 2017) 201 2018) microProfile-1.0 8 Metrics 2.2 MicroProfile 2.0 Config 1.0 Health Check 2.1 OpenTracing 1.2 MicroProfile 2.0.1 (July 2018) MicroProfile 1.4 2017 JAX-RS 2.1 // Java EE 8 MicroProfile 1.3 (Dec 2017) CDI 2.0 // Java EE 8 MicroProfile 1.2 JSON-P 1.1 // Java EE 8 Config 1.2 JSON-B 1.0 // Java EE 8 Metrics 1.1 OpenApi 1.0 MicroProfile 1.0 (Fall 2016) OpenTracing 1.0 JAX-RS 2.0 CDI 1.2 RestClient 1.0 12 JSON-P 1.0
I. Codebase “One codebase tracked in revision control, many deploys.” Dedicate smaller teams to individual applications or microservices. • Following the discipline of single repository for an application forces • the teams to analyze the seams of their application, and identify potential monoliths that should be split off into microservices. Ø Use a single source code repository for a single application (1:1 relation). Deployment stages are different tags/branches Ø i.e. use a central git repo (external Github/GitHub Enterprise also suitable)
II. Dependencies “Explicitly declare and isolate dependencies” A cloud-native application does not rely on the pre-existence of dependencies in a deployment target. Developer Tools declare and isolate dependencies Maven and Gradle for Java • Ø Each microservice has its own dependencies declared (e.g. pom.xml)
III. Config “Store config in the environment” Ø Changing config should not need to repackage your application Ø Use Kubernetes configmaps and secrets for container services Ø Use MicroProfile Config to inject the config properties into the microservices App Password=blah
MicroProfile Config – Access configuration via Why? • Programmatically lookup Configure Microservice without – Config config =ConfigProvider.getConfig(); repacking the application config.getValue(“myProp”, String.class); How? • Via CDI Injection Specify the configuration in – @Inject configure sources @ConfigProperty(name="my.string.property") String myPropV;
IV. Backing services “Treat backing services as attached resources” Application My SQL Amazon S3 Twitter
MicroProfile REST Client A B @Dependent @RegisterRestClient @RegisterProvider(UnknownUrlExceptionMapper.class) @Path("/properties") @Inject public interface SystemClient { @RestClient @GET private SystemClient @Produces(MediaType.APPLICATION_JSON) defaultRestClient; public Properties getProperties() throws UnknownUrlException, ProcessingException; } io.openliberty.guides.inventory.client.SystemClient/mp-rest/url=http://localhost:9080/system
V. Build, release, run “Strictly separate build and run stages” Ø Source code is used in the build stage. Configuration data is added to define a release stage that can be deployed. Any changes in code or config will result in a new build/release Ø Needs to be considered in CI pipeline (e.g. Tekton)
VI. Processes “Execute the app as one or more stateless processes” Stateless and share-nothing Restful API
VII. Port binding “Export services via port binding” Ø Applications are fully self-contained and expose services only through ports. Port assignment is done by the execution environment Ø Ingress/service definition of k8s manages mapping of ports Ø Use MP Config to inject ports to microservices for chain-up invocations @Inject @ConfigProperty(name=”port”, defaultValue=“9080”) Port=80
VIII. Concurrency “Scale out via the process model” Ø Applications use processes independent from each other to scale out (allowing for load balancing) Ø To be considered in application design Ø Cloud autoscaling services: [auto]scaling built into k8s Ø Build micorservices
IX. Disposability “Maximize robustness with fast startup and graceful shutdown” Ø Processes start up fast. Ø Processes shut down gracefully when requested. Ø Processes are robust against sudden death Use MicroProfile Fault Tolerance to make it resilient Ø From “ CERN Data Centre Evolution ”
MicroProfile Fault Tolerance A solution to build a resilient microservice v Retry - @Retry v Circuit Breaker - @CircuitBreaker v Bulkhead - @Bulkhead v Time out - @Timeout v Fallback - @Fallback
X. Dev/prod parity “Keep development, staging, and production as similar as possible” Ø Development and production are as close as possible (in terms of code, people, and environments) Ø Can use Operators to deploy in repeatable manner
XI. Logs “Treat logs as event streams” Ø App writes all logs to stdout Ø Use a structured output for meaningful logs suitable for analysis. Execution environment handles routing and analysis infrastructure
XII. Admin processes “Run admin/management tasks as one-off processes” Ø Tooling: standard k8s tooling like “kubectl exec” or Kubernetes Jobs Ø Also to be considered in solution/application design Ø For example, if an application needs to migrate data into a database, place this task into a separate component instead of adding it to the main application code at startup
THE FACTORS 7. Port binding Codebase 1. 8. Concurrency Dependencies 2. 9. Disposability Config 3. Backing Services 10.Dev / Prod parity 4. Build, Release, Run 5. 11.Logs Processes 6. 12.Admin Processes
How to get started? https://start.microprofile.io/ https://appsody.dev/
12 factor app Use MicroProfile and K8s to build a microservice => 12 factor app • Infrastructure microservice
THE FACTORS 7. Port binding Codebase 1. 8. Concurrency Dependencies 2. 9. Disposability Config 3. Backing Services 10.Dev / Prod parity 4. Build, Release, Run 5. 11.Logs Processes 6. 12.Admin Processes
References https://microprofile.io • https://openliberty.io • Infrastructure https://www.12factor.net/ • microservice K8s https://kubernetes.io/ • https://appsody.dev/ • https://github.com/Emily-Jiang/qcon-12factor-app-a • https://github.com/Emily-Jiang/qcon-12factor-app-b • https://github.com/Emily-Jiang/qcon-12factor-deployment • @emilyfhjiang
Thank You Thank You @emilyfhjiang
Recommend
More recommend
