Hybrid cloud, as we covered in the previous lesson,

is a computing environment that connects an organization's on-premise

private cloud and third-party public cloud into a single infrastructure for
running the organization's applications.
Multi-cloud is a cloud adoption strategy that embraces a mix of cloud
models from different service providers, public, private, and
managed, across infrastructure, platform, or software services.
For example, a business may consume email as a service from one provider,
a CRM application from another, and infrastructure from yet another provider.
So essentially,
a hybrid multi-cloud implies you are able to leverage the best of cloud models and
services across different service providers and have your applications and
workloads working seamlessly across multiple different clouds.
Play video starting at :1:3 and follow transcript1:03
In this video, we will look at some use cases for
why a business may want to use a hybrid multi-cloud approach.
>> In this video, I want to touch on a few of those use cases for
why a business may want to to use hybrid or multi-cloud.
Let's start with the basic one, cloud scaling.
Play video starting at :1:22 and follow transcript1:22
Now, most of us are probably familiar with this.
It's one of the main reasons for adopting the cloud.
Now let's say we have a flower delivery service that is able to hit a certain
bottom line of users.
They have on premise infrastructure and it can hit a certain amount of user load.
So visualizing this here.
Throughout a calendar year, you can imagine that their load maybe goes up and
down and responds to specific holidays.
Now, to hit those peaks, they could scale up their on premise architecture,
but that's met with upfront costs and costs of upkeep.
Now instead, what they'll instead do is take advantage of cloud
that allows them to scale up in response to that load and
then automatically deprovision resources when they no longer need them.
Now, this concept is kind of general to cloud computing, not just hybrid or
multi-cloud.
But that brings me to my next topic, and
here we're going to be talking about how it can be used to build a composite cloud.
Play video starting at :2:29 and follow transcript2:29
So essentially this is going to be applications that are spread across
multiple cloud environments.
So back to the flower delivery service.
Let's say they have on premise architecture that allows them to run three
major components of their app.
So let's say they have the Web UI, they have some
billing APIs, as well as a rewards framework.
Play video starting at :2:59 and follow transcript2:59
Now let's say that this service is actually based in EU and
their European customers are happy.
But for their North American or American customers, specifically around
Veterans Day or Thanksgiving, they're noticing that the system is bogging down.
And so they decide to take advantage of a hybrid cloud or multi-cloud architecture
by composing their application across multiple cloud environments.
So, they'll take advantage of data centers in America and essentially they've
identified that although the rewards framework can stay on prem in their
European side, they want to move the billing and the UI capabilities over.
So, they'll move just those two to a cloud platform of
their choice in a North American or American data center.
This kind of allows them to scale up portions in response to, say,
American holidays while keeping their EU portions individually scaled.
So in this example, the flower delivery service is able to take advantage of
scaling at a global level by using the hybrid or multi-cloud architecture.
Next, let's talk about the airline or travel industry.
So we can first start with an example of modernization.
Play video starting at :4:19 and follow transcript4:19
Now, in the past we've seen that reservation systems may have been
difficult to work with or you might have had to call in.
But almost all all the airline companies now have a mobile application.
So most of the time, and we've actually found that it's about,
in general not just in the travel industry, but
80% of all enterprise applications are actually still on prem.
And that's likely the case in this industry as well.
So in this specific example, let's say they have a reservation system that's
running on prem, but to create new experiences for their end users,
let's say they've created a mobile application.
That mobile app, of course, has a mobile backend that's maybe running in
a public cloud and that in turn works with the reservation service.
So, again, the mobile app can hit the mobile backend and
that in turn works with the reservation capabilities.
So in this case they've modernized and new user experiences are possible.
But let's take that a step further.
Now, a source for a lot of dissatisfaction for
users is whenever their flights are delayed.
So when a flight is delayed, they may have to rebook new flights.
The solution is almost always the same.
The traveler wants to get to his destination in the easiest way possible.
So what airline industries have been doing is taking advantage
of the cloud to create maybe a recommendation feature.
So, it allows them to book new flights as soon as a delay is recommended or
as soon as a delay is incurred.
And that's going to connect up to that mobile back end service, allowing users to
be able to book flights through their phone the second a flight is delayed.
This not only improves the bottom line for the airline industry, but
leads to happier users.
So that's one way the modernization has been done.
Next, let's take it even a step further and talk about data and AI.
Play video starting at :6:11 and follow transcript6:11
For data and AI,
the airline industry has been taking advantage of lots of historical data.
So over the decades that a company has been around, let's say they
have historical data of when unplanned maintenance has happened on their airline.
In fact, 30% of all delay time in the airline industry is actually when
unplanned maintenance happens.
So by taking advantage of, let's say, machine learning or
AI capabilities, they could hook into all of the legacy data that they have,
large volumes and connect them up to machine learning and AI capabilities.
This allows airline industries to take advantage of predictive analytics and
get insights before errors or before the unplanned maintenance ever occurs.
This again improves their bottom line,
leading to happier users and a more efficient airline industry.
Now, today we talked about four major use cases for hybrid and
multi-cloud platforms.
So cloud scaling and composite cloud in the flower delivery service as well
as modernize and data and AI for the airline industry.
>> Another reason for adopting hybrid multi-cloud strategy is to prevent lock-in
to a specific vendor's cloud platform and having flexibility of being
able to move work loads from one cloud platform to another as the need arises.
In the next video, we will understand what a microservices architecture is,
its features, benefits, and use cases.
Microservices architecture is an approach in which a single application is composed
of many loosely coupled and independently deployable smaller components or services.
These services typically have their own stack running on their own containers.
They communicate with one another over a combination of APIs,
event streaming, and message brokers.
For a business, what this means is that application components can be developed
and updated more efficiently by multiple developers working independently.
Teams can use different stacks and runtime environments for different components.
Components facing too much load can be scaled independently,
reducing the waste and cost associated with having to scale entire applications.
In this video, we'll look at how microservices have shaped application development
and also look at a use case that illustrates microservices in action.
>> The way developers work to build applications is changing.
In the past, software was built as large monolithic applications
where a team of developers would take months
to construct a large application built on a common code base.
These developers would write every part of the application from start to finish.
Now, after decades of software development,
there are vast amounts of code already out there
that developers can use as the base of an application,
meaning they no longer have to create every line of code from scratch.
Cloud development platforms provide developers with an ecosystem of code
that can be easily and securely integrated into applications.
Now, instead of building one huge application on one team,
developers break into small independent teams
where they write smaller amounts of code called microservices.
Microservices break down large applications into their core functions.
For example, Search, Recommendations, Customer Ratings, or Product Catalogs.
Each is developed independently of one another,
yet work together on the Cloud development platform to create a functioning application.
A container is the distribution method for each microservice,
meaning it delivers the code where it needs to go.
Containers are plug-and-play, so if one microservice isn't working for an application,
developers can take it out and
put in a different one without disrupting how the rest of the app functions.
Check out microservices in action with Ron:
Ron is a soccer fan who uses an online streaming media service called Dream Game.
Last night, he missed watching his team play their crucial semi-final match.
Luckily, he can watch the match tonight on Dream Game.
When he logs in, he sees the most popular content among all Dream Game users.
After some searching, he finds the match he's looking for.
What he would really like is to find his game with one click.
Luckily, the Dream Game development team is using microservices to develop
a better user experience for viewers like Ron.
The first microservice is a Content Catalog
housing the millions of games that Dream Game offers.
The small team of developers organizes each piece of content
with metadata that describes them.
This metadata feeds into a second microservice: the Search Function,
which ensures that Ron's search results are captured and
compared to the Dream Game catalog.
The third microservice, Recommendations,
captures data about the most popular content among all Dream Game users.
This is what generates the homepage that Ron saw when he first logged in.
These three microservices are all in their separate containers,
ready to join the application.
But before they can work together, they have to find one another.
They do this by using something called Service Discovery,
which creates a roadmap for these and many other microservices to communicate.
When microservices find each other,
they communicate using an application programming interface or an API.
So when Ron searches for his favorite soccer team,
the Search microservice is communicating to the Content Catalog (in an API)
about what Ron is looking for.
Now back to the goal at hand: to get Ron to his soccer game with just one click.
The development team working on the Recommendations microservice is updating the code,
adding an analytics algorithm.
Using analytics, the Recommendations microservice will compare Ron's viewing
history and preferences to popular content among other users,
including soccer fans and viewers in Ron's geographical region and demographic.
Since the developers didn't need to create the code from scratch,
they are able to deploy this new functionality in a matter of days.
These updates happen behind the scenes
as the rest of the microservice containers function normally.
The next time Ron checks Dream Game, instead of just seeing the most popular or
newest content, he sees a personalized playlist that will continue to refine
itself as the system learns more about his viewing habits and preferences.
The result: Ron finds his favorite team's latest game right away.
The microservice approach lets developers quickly innovate applications in parallel
and lets users like Ron focus on the things that really interest them.
And when those interests are changing and growing faster every day,
microservices help businesses keep up and grow with their customers.

Serverless is an approach to computing that offloads responsibility for

common infrastructure management tasks such as scaling, scheduling,
patching, and provisioning application stacks to cloud providers allowing
developers to focus their time and effort on the code and
business logic specific to their applications or process.
Serverless doesn't mean there are no servers, only that the management of
the underlying physical or virtual servers is removed from their users.
The serverless computing environment allocates resources as needed for
the applications.
Let's look at some key attributes that distinguish serverless computing from
other compute models.
The serverless model requires no provisioning of servers,
installation of application stacks and software or
operation of the infrastructure by the developer.
Serverless computing runs code only on-demand on a per request basis,
scaling transparently with the number of requests being served.
Serverless enables end users to pay only for resources being used,
never paying for idle capacity, which is unlike virtual servers on the cloud,
where end users pay for VMs as long as they are running, even if idle.
Effectively serverless abstracts the infrastructure away from developers,
code is executed as individual functions,
where each function runs inside a stateless container.
No prior execution context is required to serve a request, and
with each new request, a new instance of the function is invoked.
Let's look at a scenario, you could, for example,
have a serverless platform between the front end of your website and
your storage layer running individual functions, the serverless app could be
translating text files and storing it in a cloud-based storage service.
Using the front end of your website, you send text files to a serverless app.
The app creates translations in different languages and then stores these
translated files in a Cloud Storage and sends you their links back to you.
Some of the key serverless computing services today include
IBM Cloud functions, which is based on Apache OpenWhisk,
AWS Lambda and Microsoft Azure functions.
It is important to note that serverless may not be the best fit for
all applications or scenarios.
You need to evaluate application characteristics and
ensure that the application is aligned to serverless architecture patterns.
Applications that qualify for a serverless architecture include some of
the following characteristics, short-running stateless functions,
seconds or minutes, seasonal workloads with varying off peak and peaks,
production volumetric data that shows too much idle time, event-based processing or
asynchronous request processing for implementing use cases.
Microservices that can be built as functions that are stateless.
Serverless architectures are well suited for use cases around, data and
event processing, IoT, microservices, and mobile back ends.
Given its inherent and automatic scaling, rapid provisioning and a pricing
model that does not change for idle time, supporting microservices architecture
has become one of the most common use cases of serverless computing today.
Serverless is well suited to working with structured text, audio,
image, and video data around tasks such as data enrichment,
transformation, validation, and cleansing, PDF processing,
audio normalization, thumbnail generation, and video transcoding.
Parallel tasks such as data search and processing and
genome processing are also well suited to be run on a serverless runtime.
Serverless is also well suited for working with all sorts of data stream ingestions,
including business data streams, IoT sensor data, log data, and
financial market data.
And finally, let's look at some challenges worth considering about serverless.
Serverless workloads are designed to scale up and down in response to workload.
But for workloads characterized by long-running processes,
managing a traditional server environment might be simpler and more cost effective.
The serverless application architecture can be vendor dependent, and
so there is a potential for vendor lock-in,
particularly involving platform capabilities such as authentication,
scaling, monitoring, or configuration management.
Because serverless architectures scale up and down in response to workload,
they also sometimes need to start up from zero to serve a new request.
For certain applications, this delay isn't much of an impact, but for something
like a low latency financial application, this delay wouldn't be acceptable.
Simply put, a cloud native application is an application developed from the outset to
to work only in the cloud environment,
or an existing app that has been refactored and reconfigured with cloud native principles.
A cloud native application consists of microservices working together as a whole
to comprise an application,
yet each can be independently scaled and iterated
through automation and orchestration processes.
These microservices are often packaged in containers,
which are executable units of software
in which the application code is packaged along with its libraries and dependencies
so that it can be run from anywhere.
The independence enables frequent, iterative improvement of cloud native applications,
without disrupting the experience of end-users.
Cloud native applications are unlike traditional, or monolithic, applications,
that are built out of one huge piece of software;
applications that tightly couple the user interface, business-logic layer, and data-layer.
Let’s take the example of how a cloud native application might be used on a travel website.
Each topic covered by the site—flights, hotels, cars, specials—is its own microservice.
Each microservice may roll out new features independent of the other microservices.
Specials and discounts can also scale out independently.
While the travel site is presented to customers as a whole, each microservice remains
independent
and can be scaled or updated as needed without affecting other services.
Whether creating a new cloud native application
or modernizing an existing application,
developers adhere to a consistent set of development principles:
Follow the microservices architectural approach
by breaking applications down to single-function microservices.
Rely on containers for maximum flexibility, scalability, and portability.
Adopt Agile methods that speed the creation and improvement process
through quick, iterative updates based on user feedback.
In this video, we’ll take a closer look at the key concepts of cloud native,
its benefits, and use cases.
Hi. I'm Andrea Crawford and I'm with IBM Cloud.
Today we're going to talk about cloud native apps.
In the heritage world, we have our lumpy, monolithic apps.
And in the new world, we have our microservices living on the cloud.
Play video starting at :2:51 and follow transcript2:51
If we take a look at this diagram here, we see we have cloud infrastructure.
This is your private, your public, and your enterprise infrastructure.
Cloud native apps apply to hybrid and multicloud situations.
We also have our scheduling and orchestration layer.
This layer is all about control planes, like our kubernetes.
We also have our application and data services layer.
This layer is all about backing services,
and being able to integrate our application code with existing services
that may be available on other clouds, or even on-premise.
We have our application runtimes:
these are what were traditionally, or conventionally, known as middleware.
And over here, well, that's where we have our cloud native apps.
This is the sweet spot right up here.
So our application code
is actually designed, built, and delivered very differently for cloud native,
than it would be for conventional, monolithic, lumpy apps over here.
So let's talk a little bit about why cloud native apps can actually leverage benefits like:
enabling innovation,
business agility,
and most importantly from a technology perspective,
the commoditization of this solution stack over here.
So as time has progressed and technologies have matured and emerged,
a lot of the services are actually being refactored lower down in this stack.
This means that core services are starting to have a lower center of gravity,
freeing up innovation at this level over here.
So, what are our use cases for when to build a cloud native app?
*Everything*
Everything that lives in the cloud should have a cloud native app design and approach.
This means our application code needs to be instrumented with things like:
standardized logging, standardized events,
and being able to match those logging and events to a standard catalog,
that multiple microservices and cloud native apps can use.
The last thing we want to do is have our development squads
have to figure out what their log and event messages should be.
Let's standardize that, because we want to be able to commoditize that as well.
We also need to have things like distributed tracing.
When we get over into the microservices world over here,
we have a lot of moving parts.
This means we're going to need to leverage services core to the system, like:
load balancing, service discovery, and routing.
These are the kinds of things that are commoditized in this layer here,
with things like Istio, and with the emergence of newer projects, like Knative.
And so, if we were to recognize the benefits for cloud native apps and to sum it all up,
we are all about enterprise and engineering at scale.
In the next video we'll take a look at DevOps.

Development teams need to design, develop, deliver, and

run software as reliably and efficiently as possible.
Operations teams need to identify and resolve problems as soon as possible by
monitoring, predicting failure, managing the environment, and fixing issues.
Combining development and operations with the ability to monitor and
analyze and optimize bottlenecks gives us DevOps.
A collaborative approach where business owners, and the development, operations,
and quality assurance teams collaborate to continuously deliver software.
A DevOps approach applies agile and lean thinking principles to all stakeholders
in an organization who develop, operate, or benefit from the business's
software systems, including customers, suppliers, partners.
By extending lean principles across the software supply chain, DevOps capabilities
improve productivity through accelerated customer feedback cycles.
Unified measurements and collaboration across an enterprise, and
reduced overhead, duplication, and rework.
Using the DevOps approach, developers can produce software in short iterations
on a continuous delivery schedule of new features and bug fixes in rapid cycles.
And businesses can seize market opportunities and
reduce time to include customer feedback in their products.
The DevOps process involves continuous delivery, which is about delivering small,
well-designed, high quality increments of software to customers.
Continuous integration,
creating packaged builds of the code changes released as immutable images.
Where immutable implies that when modifications are needed,
the entire component is replaced with an upgraded version.
Continuous deployment, which involves progressing each new packaged build
through the deployment lifecycle as rapidly as possible.
Continuous monitoring with tools that help developers understand the performance and
availability of their applications even before they are deployed to production.
Delivery pipeline, which is an automated sequence of steps that involves the stages
of ideation, coding, building, deploying, managing, and continuous improvement,
which loops back to the ideation phase in the delivery pipeline.
While DevOps can apply to applications anywhere, there is especially a compelling
case for DevOps when it comes to cloud ready and cloud native applications.
With its near limitless compute power and available data and application services,
cloud computing platforms come with their own risks and challenges.
DevOps tools, practices, and processes are helping tackle some of
the complexities and challenges posed by the cloud and
allowing solutions to be delivered quickly and reliably.
Let's look at some core capabilities that DevOps provides to help building and
running applications in the cloud a lot more manageable.
DevOps best practices make it possible to programmatically provision servers,
build middleware, install application code,
and fully automate the installation process in a way that is documented,
repeatable, verifiable, and traceable.
Application deployments often involve considerable complexity.
The DevOps practices of continuous integration and
continuous deployment help create a fully automated deployment pipeline,
which is important all through the application development lifecycle.
Cloud native applications form a complex distributed system with multiple
moving parts, independent tech stacks, and rapid release cycles.
DevOps principles are essential to define how people work together to build,
deploy, and manage applications in a cloud native approach.
With the DevOps best practices of automated provisioning and
continuous deployment, developers, quality professionals, and
other stakeholders can test in low cost production-like test environments that
were previously not available, enhancing both productivity and quality.
When systems are compromised or struggling to recover from natural disasters, DevOps
best practices make it possible to rebuild these systems quickly and reliably.
DevOps provides a powerful set of principles, practices, and
tools to realize the full potential of cloud native computing as well as for
modernizing existing applications to leverage cloud benefits.
Many organizations have huge investments in existing applications
that are often siloed in legacy systems
and are very difficult and expensive to update and maintain.
Modernizing these applications can unlock great benefits for these organizations
such as accelerating their digital transformations,
enabling them to take advantage of new technologies and services,
and becoming more responsive to their customers' needs
and changing market dynamics.
Cloud computing is one of the three main ingredients in Application Modernization.
In the rest of this video we will see how,
and what else Application Modernization entails.
Hi, I'm Eric Minick, with IBM Cloud, and I want to talk about application modernization
and three huge transformations that have been going on together.
We've got three things going on, they're interrelated,
and this is what we're seeing, this change in how we're doing architecture, infrastructure,
and our ways of working - how we deliver.
And if we go back in time a little bit, we saw applications that were very monolithic,
they were running on physical servers and we used waterfall style development
where we'd have long plans and we'd say okay, this is gonna be our planning phase,
our development phase, our testing phase, and we could plan out a year as a project.
And that's really what we've gone away from.
So if we look at how most organizations are working today,
architecturally, they've got some sort of distributed architecture.
It's usually related to a service-oriented architecture;
the big buzzwords a few years ago,
but some sort of distributed architecture: we have a bunch of web services,
they're talking to each other, we've got some databases on the back end,
and then some front ends that kind of go through all that.
On an infrastructure level, they're running on some sort of a virtual machine, alright?
So, we said:
we could probably do better than having to order a new server every time we have a new
service.
Let's virtualize this stuff, and we need a little more density along the way.
And from a way of working; you know, Agile development, pretty normal--
and then trying to figure out a little bit of what happens downstream.
So this takes us up to where a lot of teams are today, but not really where they're going.
And so if we look at that next phase.
We're taking another pass at this service-oriented architecture,
and really shrinking the sizes of the services,
taking advantage of the more dynamic infrastructure we have.
And we're calling these now microservices, right?
Microservices.
So we've got a microservice architecture, so very small, very focused services,
moving away from a lot of the heavyweight XML-based communication we saw in SOA,
towards more REST-based communication, things like that.
But same idea, let's keep breaking into smaller and smaller pieces.
We have more independence of what we ship.
More rigor in saying this service needs to be independent from another service,
so I can change these things by themselves.
On the infrastructure side: Cloud.
Cloud's pretty popular.
And this could be public cloud, this could also be private cloud.
I'm painting with a very broad brush when I say cloud here.
And then from a delivery, in a way of working: we could say that DevOps is really key.
And I would include in this, approaches like site reliability engineering, SRE.
More the ways of working we have today.
Now that that's fine and interesting.
But what do these things have to do with each other?
I'd argue that what we're really seeing is modernization in
in how the applications are delivered, and how they're built--and what they are.
And while you could walk into any large enterprise today
and you'll find someone who says "We are going through a cloud transformation."
You'll often find someone who says, "Yes, I'm in charge of leading the DevOps transformation."
You'll walk into enterprise architecture, they'll say, "Yes, we are pushing microservice
architectures."
Individuals think that they're going through three separate transformations.
But they're really tied.
Right?
If I'm doing microservices, and I have new microservices all the time.
And in order to get a new microservice up and running,
I'm over here, and I have to order a new physical server,
and then rack and stack it a couple months later.
I'm not gonna get any time-to-market benefits.
The resilience benefits that I'm gonna normally look for
from microservices are gonna be modest, at best.
Microservices want cloud infrastructure. You want to be able to say,
I've got a new microservice; let me put it in a container and
just run that container right now and scale that dynamically.
Similarly, cloud really likes running microservices.
The benefits of being able to dynamically scale
are really cool when you have a lot of small things that you might need a few of or a lot of.
It's not as interesting when I've got a monolith that isn't even distributed. How do I scale that?
I get a bigger cloud server?
And then all of this is kind of, baking in this idea of speed and resiliency,
and DevOps brings that together.
The developers who have always wanted speed,
the operations people who've always wanted that resiliency.
They're going to be programming that cloud. Right?
The programmable infrastructure that cloud provides
needs operations people who understand resiliency--
but bring some of that development skill in.
And to really take advantage of these new infrastructures, the new architectures,
you need these new ways of working.
And you also are gonna say, "if this is going to give me time-to-market benefits,
 I can't be back here, and say 'Yeah, we've got a one-year project plan that we're just gonna
execute.'"
I need to be able to be more agile, and adapt in my planning and my responsiveness to the
business.
I need to better wire up my applications so they can be more easily monitored and more
resilient.
We have to have the application in a way that,
it knows when one of these services is failing, and we can spin up another.
So this is really, for me, fascinating, that you walk into these organizations everywhere,
and they're undergoing these three different transformations.
But they're always doing them together.
And when they don't - it doesn't quite work.
So you've got these three transformations going on at once.
And you'll hear us talk a lot about application modernization.
See it written across the top here?
When I think of application modernization, I think it's just this.
It's this transformation right here;
going from these kind of monoliths, or service-oriented architectures,
to microservices;
adopting Cloud;
modernizing our ways of working towards DevOps and SRE.
That's AppMod.
It's a really exciting time.
And it's really great when you're able to go after it in a holistic fashion.

Harnessing the Power of DevOps on Cloud

Platforms
Introduction:

Organizations strive to deliver software solutions swiftly, reliably, and efficiently in our ever-
evolving digital landscape. DevOps, a collaborative approach that unifies software
development and operations, has emerged as a significant change. This topic will explain the
essence of DevOps, explore its benefits when applied to cloud platforms, and provide real-
world use cases that demonstrate its transformative capabilities on popular cloud providers
such as AWS, Azure, GCP, and IBM Cloud.

What is DevOps?

DevOps is an approach that fosters collaboration between development and operations teams,
streamlining the entire software delivery lifecycle. By promoting a culture of collaboration,
automation, and continuous feedback, DevOps enables organizations to deliver software
products more efficiently and reliably.

The DevOps Process:

To better understand the DevOps process, let's explore its key components:

● Continuous Integration (CI): Developers integrate their code changes into a shared
repository frequently, ensuring early detection of integration issues. Version control systems
like Git and Subversion support this process.
● Continuous Delivery (CD): Continuous delivery ensures that code changes are
always in a state that can be released immediately. This state allows organizations to deploy
software anytime with minimal manual intervention. Tools like Jenkins and Bamboo
facilitate the automation of build, test, and deployment processes.
● Continuous Deployment (CDep): Continuous deployment takes automation
further, enabling organizations to automatically deploy software changes into production
environments after passing the necessary tests.
● Continuous Monitoring (CM): Continuous monitoring provides real-time insights
into application and infrastructure performance, allowing organizations to detect issues
promptly and take proactive measures. Tools like Prometheus and ELK Stack are commonly
used for monitoring in DevOps.

Benefits of DevOps on Cloud Platforms:

Implementing DevOps practices on cloud platforms offers several significant advantages:

● Scalability and Flexibility: Cloud platforms provide the scalability and flexibility
required for DevOps workflows. Organizations can leverage cloud resources to scale
infrastructure dynamically, accommodate varying workloads, and optimize resource
utilization based on demand.
● Rapid Provisioning and Deployment: DevOps on the cloud facilitates rapid
provisioning and deployment of infrastructure and applications. Cloud services offer pre-
configured environments, automated provisioning, and deployment pipelines, enabling faster
time-to-market and reducing manual effort.
● Cost Optimization: Cloud-based DevOps enables cost optimization by leveraging the
pay-as-you-go model. Organizations can scale resources up or down based on demand,
eliminating the need for upfront infrastructure investments, and reducing operational costs.
● Collaboration and Team Efficiency: DevOps practices on the cloud foster
collaboration and enhance team efficiency. Cloud platforms provide centralized repositories,
version control systems, and collaboration tools that facilitate seamless communication and
shared code repositories, enabling effective collaboration across teams.
● Continuous Integration and Delivery: Cloud services seamlessly integrate with
popular DevOps tools, enabling continuous integration and delivery (CI/CD). This
automation streamlines build, test, and deployment processes, reducing errors and facilitating
faster, more reliable software releases.

DevOps Use Cases on Cloud Platforms

Let's explore real-world use cases that highlight the benefits of DevOps on different cloud
platforms:

● DevOps on Amazon Web Services (AWS): Organizations leveraging DevOps

on AWS can take advantage of services such as AWS CodePipeline for CI/CD pipelines,
AWS Elastic Beanstalk for simplified application deployment, and AWS Lambda for
serverless computing. This use case enables seamless scalability, efficient resource
management, and rapid delivery of software solutions.
● DevOps on Microsoft Azure: DevOps on Azure empowers organizations with
services like Azure DevOps for collaboration, Azure Kubernetes Service (AKS) for container
orchestration, and Azure Functions for serverless computing. Organizations can achieve
 automated deployments, efficient scaling, and improved application performance by
leveraging these services.
● DevOps on Google Cloud Platform (GCP): DevOps on GCP offers services
such as Cloud Build for CI/CD pipelines, Google Kubernetes Engine (GKE) for container
management, and Cloud Functions for serverless computing. This use case enables
organizations to automate infrastructure provisioning, manage complex containerized
applications effectively and optimize resource utilization.
● DevOps on IBM Cloud: DevOps on IBM Cloud provides services like IBM
Continuous Delivery for automated deployments, IBM Kubernetes Service (IKS) for
container orchestration, and IBM Functions for serverless computing. These use cases allow
organizations to achieve streamlined software delivery, efficient infrastructure management,
and seamless scaling on the IBM Cloud platform.

Conclusion
When combined with cloud platforms, DevOps empowers organizations to streamline
software delivery, enhance collaboration, and leverage scalable resources. By implementing
DevOps on popular cloud providers such as AWS, Azure, GCP, and IBM Cloud,
organizations can accelerate their software delivery cycles, reduce time-to-market, and adapt
to changing business needs effectively. It is a winning combination that enables organizations
to stay competitive in today's fast-paced digital landscape

Welcome to Cloud Computing: Emerging Trends and Technologies - Expert Viewpoints.

in this video, we will listen to several cloud application professionals
discuss trends and technologies in cloud computing.
Play video starting at ::21 and follow transcript0:21
>> The top three trends that I see coming in the next couple of years
are as follows.
First, is this idea of a hybrid cloud,
as IBM has predicted, a lot of companies and clients will move
from a single cloud provider to multiple cloud providers.
That could be multiple public clouds or a public cloud and on-premise private cloud.
Second, I see this big surge of edge computing
becoming more prominent in cloud computing.
Now the terms may seem quite different from each other and disjointed, but
in many sense the cloud computing will go on the edge.
The numbers state that quite overwhelmingly,
there are 75 billion devices that are supposed to come up online by 2075.
And the edge computing,
in order to be able to communicate between devices and back to the server,
is going to be very crucial.
And lastly, it's the usage of machine learning and artificial intelligence
to make decisions for us in the cloud computing space.
So, these are my top three trends that I see coming in the next couple of years.
>> So one of the emerging trends in cloud computing is serverless
and that's the area of cloud computing where,
all you need to do is give the cloud your application logic.
And that means you don't need to patch any servers,
you don't need to manage the high availability of your infrastructure,
you don't have to put in multiple availability zones.
The cloud provider takes care of all of those operational issues for you
and all you do is give it the code and it runs it on demand.
So, every time you have an event triggered,
let's say it's a voice assistant, and every time you talk to it,
it triggers a cloud function-- that is what serverless is.
And so, developers love it because with serverless,
you don't need to do all the undifferentiated work,
the work that does not make your app unique.
You can focus on the logic that makes your app unique.
>> So in terms of emerging technologies, one of the big ones is cloud native,
cloud native architecture.
And that includes the trend towards microservices,
basically dividing up monolithic applications,
what would have been monolithic legacy applications into granular microservices.
And this affords a whole range of advantages.
Another one is containers and container orchestration systems and most notably,
the Docker and Kubernetes technologies.
Another is serverless services, where
some functional code can be spun up with very low latency
without the need to manage any virtual servers.
And the term cloud native architecture really
encompasses some combination of all of these,
in terms of emerging trends...
>> So I'd like to discuss a couple trends I see all the time in cloud computing right now.
First of all, we have serverless computing, and that's the idea that
you don't have to worry about anything
other than writing the code for your application.
You don't need to know "are you deploying Kubernetes?"
"Do you need to know IP addresses?" "Is this Linux?" Nothing.
and I really see this as the future because
you don't want to have to worry about how it's deployed,
managing RAM, managing CPU, any of that stuff;
you just want to create code.
And the easier that it is to get your code from written to deployed and running well,
the better, and it's a win for everybody.
>> Another area that's emerging in cloud technology is DevOps
and with DevOps, you have the developers a lot more integrated with operations.
So you've got a CICD pipeline where the developers can push their own code and
see it live on the servers or the serverless functions.
And DevOps is a term that has a lot of different definitions.
One definition I've enjoyed hearing is
that it means the developers are talking with operations and vice versa,
that there's a dialogue going on.
And it's not just how it was in the past where the developers hand over the code,
but the developers really see the lifecycle through to it being maintained in production.
>> In terms of emerging trends,
we're seeing comprehensive cloud services for building data pipelines,
data science in general, and artificial intelligence services.
And specifically,
we're seeing low-level AI services to build AI solutions from the ground up,
along with higher level pre-trained AI solutions
for things like image recognition, speech applications, just to name a few.
Another whole area of advancement is in the area of cybersecurity,
it's obvious that cybersecurity is something that we have to be constantly aware of
and improving all the time.
And we're seeing a constant stream of improvements to secure
your network perimeter, compute resources, and data in the cloud.
>> Another emerging trend in cloud computing is application modernization.
So, with cloud providers coming out with
all these amazing services that do a lot of things for you,
the companies are thinking, "Wait a second,
the cloud provider is doing certain features of our application better than we are."
"And instead of continuing to maintain that part of our application ourselves,
let's rewrite the application to take advantage of these cloud native services."
For example, there are services now that do transcription or image recognition.
And rather than, have your own...
inference and training servers that you manage, and
use open source machine learning models that you host,
and you train those models on data that you give it--
Don't do any of that!
Just drop the images in an...
image recognition service of a cloud provider,
and you're not managing any service-- you just get the data.