and more important, A lot of efforts have been put together to make Java more Cloud native • Smaller footprint (Memory and CPU) • Faster Startup • Optimized for short-lived processes • Imperative and Reactive • Supporting cloud dev models (Serverless and Microservices) • Kubernetes native • Fat Jars and Native Executable
runtime process Due to the multi-step execution process described above, a java program is independent of the target operating system. However, because of the same, the execution time is way more than a similar program written in a compiled platform-dependent program ClassLoader loads the main class and all dependencies. Remember Dependency resolution happens at the byte code level
heavily rely on DI applying patterns like dynamic proxies and IoC. What does this mean? Developers declaratively specify what should happen and the implementation makes sure it does. - Dependency resolution happens at runtime that results in heavy lifting and long start up time. - Is there a chance that dependency resolution fails? Yes, what is the impact? Application will not start “very famous class not found exception” - JEE have CDI specs - Context and dependency injection - and Weld provides the reference implementation and It is integrated in most Application servers if not all. Weld • All beans are discovered at startup • Proxies are dynamically generated • Extensive use of reflection • Expensive to start http://cdi-spec.org/ http://weld.cdi-spec.org/
by a process without SWAP Java Heap Metaspace Direct Code Internal • Startup overhead ◦ # of classes, bytecode, JIT • Memory overhead ◦ # of classes, metadata, compilation The hidden truth about Java Classes are indexed, Metadata about annotation is created, injections and dependency resolution happens. This all is waste of memory and time.
is very small and lightweight Supersonic because it is fast with unbeatable ignition time Supported on OpenJDK and GraalVM 8 QUARK: elementary particle (subatomic) / US: hardest thing in computer science Whats is Quarkus?
annotation scanning, XML parsing, resolving dependencies, declares which classes need reflection at runtime and generates static proxies to avoid reflection, and more is pre-computed. Quarkus can also use GraalVM to generate native executables using native-image. This has two direct benefits: faster startup time and lower memory consumption. 10 How does It work? Augmentation Augmentation Jandex Parse any descriptors and read annotations, but should not attempt to load any application classes Gizmo Generating bytecode Where is the value? OOOK! Take This Scenario While XML parsers are required to parse descriptors and configuration files in other frameworks, in Quarkus The only reason that a Quarkus application should load an XML parser is if the user is using XML in their application. Any XML parsing of configuration should be done in the Augmentation phase.
build time, to keep the resulting application as small and fast as possible Runtime should only contain classes that are needed to actually run the application. 11 Quarkus Core Philosophy Fast Ignition Min footprint
CDI ◦ Injecting bean into another ◦ Injecting configuration ◦ Injecting resources to a component • CDI is built on the concept of "loose coupling, strong typing", meaning that beans are loosely coupled, but in a strongly-typed way. • CDI is built on the concept of "loose coupling, strong typing", meaning that beans are loosely coupled, but in a strongly-typed way. • CDI is also bringing interceptors, decorators and events to DI. • Quarkus is based on a CDI implementation called ArC • ArC doesn’t fully implement CDI, only most commonly used subset of the specification is implemented.
oriented dependency injection based on CDI 2.0 • Beans and proxies generated at build time • Removing Unused Beans (In standard CDI, all beans are retained by the container no matter whether they’re needed or not) • Minimal reflection (private members only) • Startup is very fast ArC plus integration runtime consist of 72 classes and occupies ~ 140 KB in jars. Weld 3.1.1 (CDI Reference Implementation) core is roughly 1200 classes and approx. 2 MB jar. In other words, ArC runtime takes approx. 7% of the Weld runtime in terms of number of classes and jar footprint. ArC Supported features https://quarkus.io/guides/cdi-reference#supported_features
• Executable (Runnable) Jar ◦ It is an executable JAR, not an Uber-JAR ◦ Quarkus copies all the dependencies into the target/lib directory ◦ Jar MANIFEST.MF contains Class-Path pointing to all jars under target/lib directory ◦ Jar MANIFEST.MF contains Main-Class: io.quarkus.runner.GeneratedMain ClassA.java ClassB.java application.properties ClassA.class ClassB.class application.properties Application runnable jar ClassA.class ClassB.class application.properties Class-Path MANIFEST.MF Main-Class
to ahead-of-time compile Java code to a standalone executable, called a native image. This executable includes the application classes, classes from its dependencies, runtime library classes, and statically linked native code from JDK. It does not run on the Java VM. Install GraalVM native-image builder tool for your OS $ {GRAALVM_HOME}/bin/gu install native-image Build your binary executable (native image) using maven Quarkus plugin $ mvn package -Pnative Run your Executable
generated • Dockerfile.jvm: To containerize the application using the generated JAR • Dockerfile.native: To containerize the application using the native executable For Openshift deployment Use the magic of S2I $ mvn clean package -Dquarkus.kubernetes.deploy=true Add -Dquarkus.kubernetes-client.trust-certs=true to accept self-signed certs Isn’t it easy!!! But What is happening? Deploy on Openshift
to have multiple configurations in the same file and to select them via a profile name. By default, Quarkus has three profiles, although it is possible to create your own and use as many as you like. The built-in profiles are: • dev: Activated when in development mode (when running mvn quarkus:dev). • test: Activated when running tests. • prod: The default profile when not running in development or test mode. The syntax is %{profile}.config.key=value in the application.properties file. For example %dev.quarkus.mongodb.connection-string = mongodb://localhost:27017/persons If profile is omitted, then the property works for all Then, you set the system variable depending on your needs: • Use mvn -Dquarkus.profile=staging quarkus:dev if you are developing, • Or java -Dquarkus.profile=staging -jar profiles-1.0-runner.jar if you are running your executable JAR. 22 Profiles Some Quarkus Profile Configuration Properties
• Fit into Knative serverless • Superfast boot time, low footprint (GraalVM native image) • Operator-driven service lifecycle management • Leveraging / integrating many other (cloud) technologies • Variety of developer tools • GUI Process designer • Swagger docs VSCode
solution with following components 1. Physicians: physician profile service connecting to Mongodb 2. Cases: case request service connecting to Postgresql 3. bp: kogito based business process service 4. Composite: a simple composite service using proxy and microgateway design patterns 5. UI: AngularJS
k8saraby
ishikawa_satoru
naoki_0531
bgpat
shin1x1
minorun365
murashotaro
kzsuzuki
ysakotch
yabakokobayashi
fnifni
kutsushitaneko
maruto
hatefulcrawdad
tammielis
michaelherold
paigeccino
tammyeverts
danielanewman
chrislema
stephaniewalter
marktimemedia
eileencodes
davidbonilla
sergeychernyshev
