These lighter-weight Java frameworks combine cloud-native flexibility with Java’s time-tested engineering, so you can write responsive code that’s easy to deploy anywhere.

Bạn đang xem: Introduction to cloud

By Peter Wayner

Contributing writer, Info
World |


The Java programming language is well into its third decade, and the language & its byte code have found a home in everything from embedded chips to lớn massive vps farms. Java"s combination of a rock-solid virtual machine và a large collection of libraries make a fertile ecosystem for writing code that runs everywhere.

One area where Java has struggled, however, is the world of servers, which often must juggle connections from thousands or even millions of users. In the early years, Java tools were among the best for creating server-side applications that enforced business ngắn gọn xúc tích for all users. Java frameworks like J2EE, Hibernate, Spring, và the basic Java servlets mã sản phẩm made it relatively easy to create strong website applications.

The technology thrived until Java
Script and Node.js appeared. Node.js garnered plenty of attention, và developers began migrating lớn the Java
Script runtime environment. There were generally two reasons: First, developers welcomed the opportunity khổng lồ run the same code on the server & a browser client. Second, Node.js servers often delivered dramatically faster throughput, thanks lớn their reactive model.

The Java ecosystem adapted lớn compete. To lớn start, some developers adopted tools lượt thích Google website Toolkit, which translates Java khổng lồ Java
Script. Next, they worked to lớn speed up Java on the server. Early Java frameworks for the server had one limitation: each incoming request was given its own thread. This was a clean way lớn organize incoming and outgoing data, but it was also taxing. Creating a thread takes thousands of bytes of overhead, which could limit the number of users each server could handle. Node.js used a different model that allowed it to lớn juggle many more users without this overhead.

More recently, Java developers have brought innovations from Node.js to the Java stack, particularly cloud-native Java frameworks. These frameworks imitate Node.js"s approach and support lightweight functions that run on cloud machines and can start & stop quickly. They dispense with extra libraries to tư vấn rapid deployment on the thinnest hệ thống instances available. Cloud-native Java frameworks are designed to support constellations of microservices that can be installed & restarted independently. They typically ship in containers like Docker or Podman for the fastest possible builds và installations.

Modern Java developers seeking a cloud-native experience have an array of options. An ideal cloud-native Java framework leverages the deep experience invested in the Java platform and its third-party libraries while adapting them lớn run faster và lighter in the cloud. Here are eight Java frameworks built from the ground up for cloud-native development and deployment. 


The creators of Micronaut wanted khổng lồ take the best parts of classic Java frameworks lượt thích Spring & Grails—such as flexible configuration và dependency injection—but strip away the heavy memory footprint và slow startup that made them less desirable for developing microservices. They carefully designed annotations that provide enough information for dependency injections without the memory-filling reflection used in older frameworks. Getting more of Micronaut"s configuration done at compile time means the code runs faster & lighter.

The framework is built to tư vấn a variety of JVM-based languages (currently, Java, Kotlin, & Groovy) and run them across various clouds. Predefined configuration files simplify deploying the server or serverless functions on all the major clouds, và there are well-written documentation pages for all the major database connections.

Micronaut"s developers also want the framework to tư vấn good development teamwork. An Http
Client implementation is bundled with the project khổng lồ simplify writing unit tests without leaving Micronaut or adding more work. These tests are often simpler và more comprehensive than the tests required for dynamic frameworks. This is, again, thanks to the work done at compile time.

Micronaut is not only for developing applications with cloud functions. The framework is general enough to support traditional roles and some desktop applications. Its tight integration with Graal
VM makes it possible khổng lồ use Micronaut khổng lồ generate native applications.


Developers who want to lớn use a well-understood mix of imperative và reactive code can turn lớn Quarkus. The Quarkus team started by anticipating the most common use cases for cloud-native development, then built the framework with examples that tư vấn those use cases with as little as zero configuration. The result is easily rolled into a container và deployed in a Kubernetes cluster.

The development team paid particular attention lớn ensuring fast boot times so Kubernetes clusters can scale up quickly. This is an ideal feature for functions that run sporadically because they can be left cold until they’re invoked.

One of the project"s goals is to embrace & extend many existing standards & libraries that are common in the Java community. For example, JAX-RS annotations define the REST endpoints. The configuration begins with Eclipse Micro
Profile. Quarkus"s development team also integrated more than 50 standard libraries, so there’s a good chance you’ll recognize the thiết kế patterns in certain cases.

You can use the basic Quarkus framework for a variety of services. Starting with Quarkus 2.8, Quarkus" developers are gently encouraging the RESTeasy Reactive model. It is the standard option if you are starting a new project, but you don’t have khổng lồ use it. RESTeasy Reactive offers a simpler, non-blocking structure và patterns. Instead of assigning one thread khổng lồ each request, a mix of non-blocking threads handles all the I/O and invokes your code when needed.

Quarkus also embraces a wide range of deployment options. While it"s said to lớn be “container first," it can run on bare metal. There’s also a built-in configuration option called Funqy that simplifies creating the functions accepted by AWS Lambda, Azure Functions, Knative, and a few other options.

Spring Cloud Functions

Java developers are well-acquainted with the Spring framework because it’s been the foundation for many projects for around two decades. Spring"s developers decide khổng lồ create a new version that’s better suited for cloud deployment, as well as some other roles. The functions in Spring Cloud Functions are meant khổng lồ be easily redeployed to a variety of tasks like web services, stream processing, or background work. 

The Spring Cloud Functions framework continues many of the same philosophical traditions pioneered by Spring. Cloud functions in this framework support a reactive or imperative style, as well as a hybrid mixture of both.

Supporting a wide variety of options is a big goal for the project. There are adapters that shoehorn the functions into AWS Lambda, Microsoft Azure, Apache Open
Whisk, Google Cloud Platform, & a few other common cloud function environments. There are also adapters for major streaming frameworks lượt thích Apache Kafka, Solace, và Rabbit
MQ, as well as the standalone option Spring Cloud Stream. Packaging & deployment is heavily automated so you can concentrate on developing the functions themselves.

The Spring Cloud Functions development team also worked hard lớn handle many of the common pitfalls và challenges of cloud deployment. Spring Cloud Skipper can be used to juggle deployments across multiple clouds. Spring Cloud Sleuth helps with debugging by tracing data flows. Spring Cloud Security manages many of the chores for securing an application so that only the right people can execute the functions. There are several dozen different subprojects alone.

The project is a very good foundation for distributing business applications through a variety of platforms. Once your application ngắn gọn xúc tích is encapsulated into a Cloud Function POJO, it can find a home working in dozens of different roles.


The creators of Vert.x wanted lớn create a very fast framework by simplifying the event loop và optimizing the connection with the database. Vert.x has a single event loop lượt thích Node.js, which allows it lớn juggle multiple connections as the events arrive. It also takes advantage of Java’s threading mã sản phẩm to process events with multiple threads in a pool, which may run on multiple cores if they’re available.

The structure is also planned to lớn simplify creating the pipeline to lớn process an sự kiện stream. It borrows constructs lượt thích promises & futures to lớn avoid messy code with layered callbacks. The asynchronous options help produce clean, readable code filled with simple chains of method invocations as the events move along the sự kiện bus.

The Vert.x development team not dogmatic about their vision. They often say that Vert.x is a toolkit not a framework. The code is modular so you can pick và choose which features khổng lồ use and assemble an architecture that fits your application. Programmers who want more of an imperative structure instead of a reactive one can find support for Kotlin’s coroutines.

This project is part of the Eclipse ecosystem. A variety of versions and options offer plenty of freedom. The Vert.x application generator, for instance, will produce either Java or Kotlin code with dozens of potential dependencies lượt thích template engines or API support.

Eclipse Micro

The Eclipse team created the Micro
Profile project as a way khổng lồ adapt Jakarta EE lớn run smaller constellations of microservices. It strips out some of the larger platform"s overhead while bundling together libraries that are pretty much standard for many microservice architectures.

The approach is most attractive for developers who might be migrating code from larger, older Java EE or Jakarta EE projects. Much of the configuration & architecture remain the same. In many cases, the adjustments are minor. But the design encourages the kind of decisions that make it simpler lớn create lighter weight, faster code. Some developers use Micro
Profile as a stepping stone on the way khổng lồ more modern cloud-native frameworks.


Some developers have a natural affection for older, well-tested modules and they’ll enjoy Dropwizard. Dropwizard"s development team has always emphasized words lượt thích stable and mature. They collected modules for database connections lượt thích Hibernate and mixed in frameworks for form & other standard website application components. Dropwizard also streamlines dependency injection and runtime maintenance processes such as configuration and logging.

Dropwizard is a favorite for teams working to revise and extend an existing application. The structure is compatible with the older, mature approaches because it is built upon them.

Starter frameworks for cloud platforms

Sometimes, there’s no need for something complex or elaborate. All of the clouds maintain basic examples that are good places lớn start writing simple functions. They’re mainly designed to tư vấn very simple decisions và help developers start up quickly.

As an example, Google Cloud Platform"s development team open-sourced their basic framework for Java functions that run in its function-as-a-service (Faa
S). The code built using it is meant lớn integrate quickly with GCP"s standard triggers although it can also run successfully on any local machine.

Microsoft also open-sourced its framework for Java. The model includes several routines for simplifying data transfers like a library for translating JSON data into & out of Java POJOs. If the function trigger supplies metadata with the invocation, the framework handles it directly.

Both of these frameworks let you accomplish many simple chores by just writing a single class with a single function. More complicated projects may want to lớn merge this basic tool with some of the other frameworks I"ve described. These are just starting points, but sometimes that’s enough.

The term cloud native refers to lớn the concept of building & running applications khổng lồ take advantage of the distributed computing offered by the cloud delivery model. Cloud native apps are designed và built lớn exploit the scale, elasticity, resiliency, và flexibility the cloud provides.

As defined by the Cloud Native Computing Foundation (CNCF), Cloud native technologies empower organizations to lớn build and run scalable applications in public, private, & hybrid clouds. Features such as containers, service meshes, microservices, immutable infrastructure, and declarative application programming interfaces (APIs) best illustrate this approach.

These features enable loosely coupled systems that are resilient, manageable, & observable. They allow engineers khổng lồ make high-impact changes frequently and with minimal effort.


The modern landscape of complex applications—with users expecting continuous innovation coupled with unparalleled responsiveness—requires business systems to lớn be more strategic and increasingly flexible. Cloud native is all about moving fast while also remaining agile.

Cloud native services empower modern application development using technologies such as Kubernetes, Docker, serverless functions, APIs, and Kafka. Industry-leading cloud providers enable cloud tooling và services so that developers can reduce operational tasks & build applications faster. Cloud native services give developers a comprehensive, standards-based platform for building, deploying, and managing cloud native applications such as microservices and serverless functions.

Use cloud native services lớn deliver amazing software

Discover how you can harness the full potential of cloud native lớn build resilient, manageable, and scalable modern cloud apps quickly & easily.


The move to cloud native technologies has permanently altered software development và business models by making it possible lớn maximize customer experiences across an organization’s platform. Not long ago, the IT infrastructure of many organizations was “cloud friendly”. IT teams that move to the cloud are putting themselves at a sharp competitive disadvantage if they don’t maximize their investment by also creating cloud native applications. For your company khổng lồ survive while also differentiating itself from its competitors, adjusting & iterating quickly is a business necessity—and a cloud infrastructure has the elasticity & on-demand capabilities khổng lồ transition any business to cloud native.

Cloud Native Computing Foundation (CNCF)

The CNCF was formed in năm ngoái in response lớn the abundance of organizations and services adopting cloud native systems. A project created by the Linux Foundation, the CNCF is an xuất hiện source software foundation that promotes the adoption of cloud native technologies. CNCF has more than 400 members, including public cloud providers, enterprise software companies, and technology startups. Microsoft,, VMware, hãng sản xuất intel are some of the Platinum members of CNCF.

The CNCF exists to ensure that cloud native công nghệ is accessible, available, and reliable. It fosters a community that’s dedicated khổng lồ projects such as Kubernetes, Prometheus, and Core
DNS, while supporting organizations that build sustainable environments that orchestrate containers within a microservice architecture.

An organization’s journey to cloud native can be daunting, but in the end, it can be a worthwhile one. This journey is about more than just re-architecting applications—it’s about changing your company’s structure và culture, & ultimately moving your company forward. Using the CNCF Trail Map, enterprises can adopt cloud native technologies incrementally. As expected, progression along the “trail” requires adoption of more-complex software lớn deliver microservices, serverless functions, event-based streams, and other types of cloud native apps.

Cloud native applications—or native cloud applications(NCAs)—are programs designed for a cloud computing architecture.They have many benefits.

Independence: Their architecture makes it possible tobuild cloud native applications independently of each other. Thismeans you also can manage và deploy them individually.Resiliency: A well-designed cloud native applicationis able to survive & stay online even in the event of aninfrastructure outage.Standards-based: For interoperability & workloadportability, cloud native services are often based on mở cửa source andstandards based technology. This helps reduce vendor lock-in andresults in increased portability.Business agility: Cloud native applications enableflexible deployment options across the network, and are also smallerthan traditional apps, which makes them easier to develop, deploy, anditerate.Automation: Cloud native applications use Dev
Opsautomations features and enable continuous delivery and deployment ofsoftware changes that get released on a regular basis. Additionally,developers can use methodologies like blue-green and canarydeployments lớn make improvements lớn the apps without any disruption tothe user experience.No downtime: Thanks lớn container orchestrators suchas Kubernetes, you can deploy a software update with essentially zerodowntime.

What does it mean for a technology to be cloud native?

Cloud native applications are independent services, packaged asself-contained, lightweight containers that are portable and can bescaled (in or out) rapidly based on the demand. By encapsulatingeverything into a container (such as a Docker container), you isolatethe application & its dependencies from the underlying infrastructure.This allows you lớn deploy that containerized application in anyenvironment that has the container runtime engine. What’simportant about
Kubernetescontainer orchestrations is that they manage the lifecycle of thecontainers. Cloud native apps are often delivered via a Dev
Ops pipelinethat includes continuous integration and continuous delivery (CI/CD)toolchains. CI/CD pipelines are important for automating the building,testing, & deployment of cloud native applications.

Cloud native architectureconcerns the thiết kế of applications or services that were madespecifically khổng lồ exist in the cloud, rather than in a more traditionalon-premises infrastructure. A successful cloud native architectureneeds to be easy lớn maintain & supported by a next-generation cloud,while also being cost efficient and self-healing. Compared to lớn legacysystems, cloud native architectures have a greater level offlexibility, without having lớn rely on physical servers.

This is where microservices và serverless functions can play a largeand important role. Microservices are the vi xử lý core of cloud nativeapplication architecture, & they have become a key tool forcompanies that are making the move to the cloud. Microservices arrangean application into multiple, independent services, each of whichserves a specific function. Many software companies take advantage ofmicroservices because they support Dev
Ops, enable flexibility, andimprove scalability, while also reducing costs. Cloud nativemicroservices communicate with each other via APIs and useevent-driven architecture, which serves to lớn enhance the overallperformance of each application. Cloud Native services followthe CNCF trail maps to help simplify the journey & make it easier forcompanies lớn start building, deploying, và managing modern cloudnative applications.



The term serverless functions describes anarchitecture style that focuses on increasing developers’productivity. A serverless application lets you write code on aplatform that functions as a service (Faa
S) using event-drivenarchitectures và various backend-as-a-service (Baa
S) models. Thiseliminates the need to worry about provisioning, patching, scaling,security, high availability, và so forth. With Faa
S platforms, suchas Functions, applications are broken up into small pieces ofcode (nanoservices), which are dynamically scheduled and run on demandwhen triggered by an event. The advantage of this approach is thatcode is called & executed only when needed, và you pay only for theresources used during the execution duration. This differs from aclassic server approach, in which applications are loaded into aserver và spend most of their time idle, waiting for requests. Thus,in serverless computing, you pay only for computing resources youactually use, rather than paying for idle resources.

Cloud-native services are at the vi xử lý core of digital innovations and are key to advanced analytics, thiết bị di động apps, và chatbots. Dev
Ops practices remove most of the management tasks associated with building, operating, và maintaining a complex software platform. Software development, deployment, & testing activities reside in the cloud & can be expanded or contracted at will. Shifting applications, Dev
Ops, và workloads lớn a cloud native architecture is integral khổng lồ keeping your business competitive.

What is Kubernetes?’s cloud native services drive modern cloud native application development by using standards-based technologies such as Kubernetes, Docker, serverless functions, APIs, & Kafka. Often described as the “operating system for the cloud,” Kubernetes is an xuất hiện source platform for managing clusters of containerized applications and services. The key components of Kubernetes are clusters, nodes, & the control plane. Clusters contain nodes. Each node comprises a phối of at least one worker machine. The nodes host pods that contain elements of the deployed application. The control plane manages nodes and pods in the cluster, often across many computers, for resiliency & high availability. provides the cloud tooling and automation necessary for these services so that development teams can reduce operational tasks và quickly build applications. Cloud native services run on Cloud Infrastructure (OCI), which offers a standards-based platform with higher performance và lower cost compared khổng lồ other cloud providers. By taking advantage of services based on mở cửa source and open standards, OCI makes it possible for developers to lớn run applications on any cloud or on-premises environment without refactoring—which gives them more freedom to lớn focus on building and innovating.

Container Registry

OCI Container Registry is an mở cửa standards–based, Docker registry service for securely storing and sharing container images. Engineers can easily push & pull Docker images with the familiar Docker command line interface (CLI) and API. To support container lifecycles, Container Registry works with’s Container Engine for Kubernetes, OCI Identity and Access Management, Visual Builder Studio, và third-party developer & Dev
Ops tools.


OCI Notifications is a highly available, low-latency publish/subscribe (pub/sub) service that sends alerts and messages lớn Cloud Functions, email, SMS, và message delivery partners, including Slack, Pager
Duty, và Service
Now. The service integrates with OCI Identity and Access Management for secure access and delivers each message, even during traffic bursts. Notifications help you build cloud native applications that are scalable and reliable.


The OCI Streaming service is a real-time, serverless, Apache Kafka-compatible sự kiện streaming platform for developers và data scientists. This managed-event streaming service ingests, stores, and processes real-time streaming data at scale. It reduces lock-in via full compatibility with widely used and xuất hiện source Kafka APIs.

Container Engine

Container Engine for Kubernetes (OKE) is an container orchestration service that can reduce the time and cost to lớn build modern cloud native applications. Unlike most other vendors, OCI provides Container Engine for Kubernetes as a không tính phí service that runs on higher-performance, lower-cost compute shapes. Dev
Ops engineers can use unmodified, xuất hiện source Kubernetes for application workload portability and to simplify operations with automatic updates & patching.

Functions Cloud Functions is a serverless platform that lets developers create, run, và scale applications without managing any infrastructure—it also integrates with OCI, platform services & Saa
S applications. Because Functions is based on the open source Fn Project, developers can create applications that can be easily ported lớn other cloud và on-premises environments. Code based on Functions typically runs for short durations, & customers pay only for the resources they use.


Why make the transition lớn cloud native for your enterprise?

Does cloud native application development truly deliver apps that are that much better than traditionally developed apps? Yes. The benefits to cloud native apps are clear: cloud native apps can scale because their functions are broken into microservices and they allow for individual management. & since they are agnostic lớn their cloud infrastructure, cloud native apps can run in a highly distributed manner, maintaining independence và allocating resources based on the application needs. Cloud native applications have become a key way khổng lồ increase business strategy and value, because they can provide a consistent experience across private, public, và hybrid clouds. They allow your organization to take full advantage of cloud computing by running responsive và reliable cloud native apps that are scalable và reduce risk.

Find out why developers are excited about using cloud native technologies to create the next generation of applications—and run them anywhere.

Xem thêm: Cách Thiết Lập Font Chữ Mặc Định Font Chữ Trong Excel 2010 2003 (Chỉnh Cỡ Chữ

Cloud native developer events

Learn to lớn build, observe, và manage modern applications such as microservices and serverless functions using Docker containers, Kubernetes, Terraform, and other cloud native technologies.