Welcome to Cloud Native Applications. After watching this video, you will be able to:
Describe the difference between monolithic
applications and cloud native applications, List the layers of the cloud native stack,
and Discuss the benefits of cloud native applications.
Traditional monolithic applications are built out of one piece of software; applications
that tightly couple the user interface, business-logic layer, and data layer.
They rely on load balancing and stateful applications to spread user workloads across multiple servers,
which makes them difficult to scale and can result in a poor user experience if there
are server outages. A cloud native application consists of microservices
working together to comprise an easily scalable application.
These microservices are frequently packaged in containers, which are executable software
units that contain the application code, libraries, and dependencies.
This enables the use of microservices from any location.
In modern software development, the software is often delivered as a service.
Software is centrally hosted and accessed through the internet.
This software is frequently referred to as a web app or software-as-a-service, abbreviated
to SaaS. You have likely used a variety of web apps
within the last day! When you use the internet to book reservations
or file taxes, you interact with a web app. The twelve-factor app methodology is suited
for these types of applications. The twelve-factor app methodology enables developers
to create more efficient SaaS applications. Microservices are not a requirement for twelve-factor apps.
However, microservices are frequently used in conjunction with the twelve-factor
application methodology. In a cloud native app, the application code
is designed, built, and delivered very differently than it would be for conventional, monolithic apps.
Examining the cloud native solution stack
will help you to understand where each part of the cloud app development takes place and
how it relates to other parts. Here are the layers of the cloud native solution
stack: The cloud infrastructure layer defines the
environment. You can develop cloud native apps for public,
private, hybrid, and multi-cloud environments. The scheduling and orchestration layer is
all about control planes like Kubernetes, Istio, and Knative.
The application and data services layer are all about backing services and integrating
application code with existing services available on other clouds or on-premise.
The application runtimes are traditionally or conventionally known as middleware, and
The Application Code layer holds the cloud native apps.
So, what are the use cases for when to build a cloud native app?
Well, everything! Everything in the cloud should have a cloud
native app design and approach. This means that application code needs to
be instrumented with things like: Standardized logging
Standardized events A standard catalog that multiple microservices
and cloud native apps can use to match that logging and events, and
Standardized tracing for microservices Everything standardized is something that
development teams don’t have to do themselves. They can buy into a commoditized system.
How is it that cloud native apps can leverage benefits like enabling innovation, business
agility, and, most importantly—the commoditization of the cloud native solution stack?
As time has passed and technologies have matured and emerged, many services are being refactored
lower down in this stack. Core services can rely on standardized services,
freeing up time and resources for innovation at the application code layer.
The benefits of this commoditized stack for cloud native apps are the provision of enterprise
and engineering at scale so that Cloud App developers can focus on the functionality
of their app, not its support system. In this video, you have learned:
Monolithic apps are often stateful and rely on load balancing; they can be hard to scale.
With monolithic apps, outages can result in poor user experience.
Cloud native apps use microservices that work together and can be individually scaled, and
The cloud native stack defines how to develop cloud native apps and the relationships between
components and services.