(uplifting music)
- Hi, everyone.
Welcome to the Hybrid Cloud and Edge digital event.
My name is your Lior Kamrat,
and I'm a Principal Product Manager
as part of the Azure Arc platform team.
I have my friend with me, Sarah,
Sarah, how you doing?
- Hey, I'm doing well, Lior.
Yeah, I'm Sarah Cooley,
I'm a Program Manager
on the AKS on-premises team.
- So, Sarah,
today we're here to talk about
everything that is Azure Arc, Hybrid,
how everything fits together.
That's part of this entire day
that we are having.
But specifically you and I,
we wanted to talk about something
that is very focused around,
how do we actually addressing
hybrid application development patterns
in the world of Hybrid and Azure Arc.
So Sarah, really to kick us off,
walk me through the vision,
how we are actually looking at this?
- [Sarah] Of course,
in order to run an app up successfully,
part of development,
and part of growing the application
is going to be having the right ecosystem of tools
to run in a hybrid way,
with all of the right integrated services
and infrastructure to to support that app
and development patterns.
So, we're going to be talking a lot
about our end to end hybrid stack
across Azure, Azure Arc,
and our on-premise solutions,
so that you can run your app
and develop it continuously at scale,
and keep it going through day two.
- All right.
So I think Sarah,
this is really an interesting space,
and Arc and Hybrid in general,
and everything that is HCI as part of it,
it's really a big topic,
there is a lot of ground to cover.
So I think that this old notion
of hybrid implication development patterns
is really interesting because
it really shows how everything,
all these building blocks are fitting together.
So,
I wanna really to talk to the audience about,
for a second,
and level set about about Azure Arc,
and what this is all about.
So, Azure Arc, if you're thinking about this,
Azure Arc is really about
stretching our control plane,
stretching our control plane means
that we are taking the operating system of Azure,
Azure resource manager,
and bringing that or stretching that
to your own environment.
Now, Azure Arc is really
kind of a bidirectional thing.
If you're thinking about that,
we have Azure Arc enabled infrastructure,
which is all about projecting resources
or IT assets
that are deployed outside of Azure,
and bring those into Azure,
so those assets can be either servers
or SQL servers or Kubernetes clusters,
which is something that we're gonna talk about
today a lot.
And also Azure Arc enabled services,
so those Azure Arc enabled services
are really about taking those services
that we have today in Azure,
and being able to deploy those
on top of Kubernetes clusters that are deployed
outside of Azure.
So that's the really bidirectional aspect of Azure Arc,
and what we wanna talk about today
is about
how do you take those services
and harvest the power
of platform as a service solutions,
like Azure Arc enabled SQL managed instance,
or key vault integrations,
or Kubernetes clusters,
and how do you actually take those
and leveraging those
to your application development patterns.
So, Sarah, that's what we're gonna talk about
today, right?
- [Sarah] Sure is!
- [Lior] Okay, so,
to really start diving into the architecture,
Sarah talk to me for a second
about the first building block
that we need to take under consideration.
- [Sarah] Yeah, so for better or worse
everything gets to start with an infrastructure layer
because all of this stuff needs somewhere to run.
So, looking at picking the on-premise infrastructure
or the cloud infrastructure
that's actually going to be running Kubernetes,
we have a ton of options.
So, I work on AKs on-prem,
so I'm particularly fond of AKS on HDI
and Windows server,
however Arc supports any CNCF Kubernetes solution.
So you can run, even AKS in the cloud
if you wanted to,
but GKE, EKS, EKS Anywhere, OpenShift Tanzu,
lots of options today.
And one of the things that's nice
about having an integrated stack,
as I said, I work on AKS on-prem,
we've helped simplify a lot of that deployment
and day two management experience,
especially on a multi-node cluster
to make it so that your infrastructure
can kind of disappear into the background.
Ideally in a perfect world
you would never need to think about this layer,
so it's nice being able to have
a quick deployment experience,
easy update experiences,
as well as some prorated services
and single provider solution support.
We also do version matching with Kubernetes in AKS,
so that you have a really slick, validated,
end to end cloud, hybrid experience.
But you are going to need to start
by picking your favorite infrastructure
or whatever you have running Kubernetes today,
and then you get to connect that to Arc.
- [Lior] So Sarah,
I mean, the connection to Arc
which is Azure Arc enabled Kubernetes,
that we're seeing here,
that's really kind of the start
of building this foundation
towards a hybrid application pattern, right?
Because we talked about the notion of having,
okay, you can pick and choose
whatever Kubernetes distribution that may be,
we have the validation program
just to make sure that we are getting
our stamp of approval on top of those distribution.
So, why do I need to start
with Azure Arc enabled Kubernetes?
Why is it so important for me to think about that
as I'm starting to think about my development pattern?
- [Sarah] Yeah.
So we started this this demo,
or this walkthrough,
talking a little bit about how
Arc lets you stretch things from on-premise,
your application, out into the cloud.
Also it lets you move from the cloud to on-premise,
so what Arc enabled Kubernetes does
is it makes it so you can connect
your Kubernetes target clusters to Azure,
and easily integrate Azure solutions,
like Azure CueBall, Azure Monitor,
if you are using something
like our Azure container registry,
take those,
those are the facts that you're using
to support your application in the cloud,
and make sure that you can use them on-premise as well
in a way that's compatible and consistent.
So we find that it's really, really important
to be able to always rely on GitHub
and GitOps, for end to end development.
So the Azure Arc
and connecting your clusters to Arc
is a layer that gives you that consistency
between the cloud and on-prem,
or another multi-cloud vendor
no matter where you're running.
So wherever that Kubernetes cluster is running
by connecting it to Arc,
you have a consistent set of experiences
for those target clusters,
no matter where they are running.
- [Lior] Okay, so shifting gears,
we wanna talk today
about why is it so important for us
to think about hybrid application development patterns
in the context of Azure Arc?
So you mentioned GitOps
and before we're gonna touch on GitOps,
which is very important in that sense,
we wanted to take a simple application
and maybe just kind of go through a journey
when it comes to that simple application.
So, in this example,
we have a bookstore application,
this is a critical application
that is designed to be deployed
in multiple retail locations
as part of an organization development cycle.
So that bookstore application
in this example, is a microservices application
that is written in distributed fashion,
specifically in this case, in goal language.
And that's the first building block
when it comes to your application, right?
Because, okay, so this is what I'm about to deploy.
Now, what I wanna talk about here, Sarah,
is how does that fit into the notion
of Azure Arc,
and the notion of hybrid application patterns?
So really to start thinking about this,
I'm showing here the first extension
which is the flux cluster extension.
Now, I wanna also take a step back, Sarah,
and just kinda explain to our viewers
that there is something called the Azure Arc
extensibility model, right?
And that extensibility model is very important
because that extensibility model
allow us to install different extensions
for different purposes,
on top of those Azure Arc enabled
Kubernetes clusters, right?
And the way that we are doing this is
by basically creating this relationship
between a certain technology, right?
In this case, I'm showing GitOps,
which we're gonna talk about in a second here,
and into our application,
how does that fit into that application universe?
Okay?
So the flux cluster extension for GitOps,
that's the block when it comes to our application.
So let's talk about, for a second about,
what is really GitOps in the sense
of our application,
and start connecting the dots.
So the first thing that you want to think about
in this concept of hybrid application development pattern,
is the fact that, like you mentioned, Sarah,
you have a Git repository, right?
And that doesn't have to be on GitHub,
it can be on big bucket or can be on-premises.
Like it doesn't really matter, right?
But at the end of the day
you have a GitHub repository,
sorry, a Git repository,
in this case, we're showing GitHub just as an example,
that is acting as the source of truth, right?
That source of truth really holds
how the application is gonna look like
in a Kubernetes environment.
Now, because we Arc enabled that Kubernetes cluster,
and again, it can be any Kubernetes distribution
that may be,
that is sitting on-premises
or in a multi-cloud environment.
That Kubernetes environment is now connected
to our Git repository via that flux extension, right?
So in the back end, we're deploying those operators,
and basically that extension is now listening
to that Git repository.
Now, what is happening also
is that once the flux operator
is starting to listen to that Git repository,
at that point what we can do is
we can basically deploy the application at scale
because now the extension knows that,
"Hey this is how the application should look like
and please go ahead and deploy that."
So that's the flux operator
that is initiating that process.
So now that the application is deployed
and it's reflecting what is currently in
the Git repository
with the same configuration, security, our back,
everything that's got to do with that.
Now, the second piece that I want to bring up,
again, we're talking about development patterns, right?
So a lot of the time in development patterns
we're also talking about,
"Okay, so how do I actually test versioning
in my application?"
So another good extension,
again, remember we're talking about
the extensibility model here
in the context of this development pattern, right?
So another good extension to bring up
is the open service mesh or OSM cluster extension.
That extension is basically our own implementation
to a service mesh technology,
and service mesh technology is bringing a lot to the table.
So what I want to emphasize here is
one capability that is part of service mesh architecture
and that's really the notion of versioning,
or blue green traffic routing.
So, we can think about the situation
where we have the application
but now we wanna test version two of the application.
So as part of the GitOps process,
we already deployed the application,
that's version one,
that's the source of truth,
but now we wanna test version two
and we wanna see how it behaves
when we're starting to route traffic
towards that application.
So, using the open service mesh cluster extension,
we can also leverage GitOps
as part of that,
so you can start see, Sarah,
how things are jello-ing,
starting to merge together, okay?
So what we're doing,
as part of that,
we are also basically targeting
that Git repository also for a traffic policy
basically, YAML file,
that will basically define
how we wanna manipulate the traffic
that goes into that application.
So the way to do that is
via that policy,
and we are defining, okay,
a certain amount of, or X amount of traffic
will go via percentage, right?
Will go into version one,
and the second piece will go into version two,
or the rest of the traffic will go into version two.
So, what we're doing is
we're testing the functionality of version two,
and as a developer or as a DevOps engineer,
you can control,
"Okay, so now that I know that version two
is functioning,
I'm gonna route the rest of the traffic
into that application."
So you can start seeing
how things are starting to jello
in the sense of this hybrid application pattern.
The third piece, Sarah,
that I wanted to talk to you about
is secrets management.
And how does that look like?
So secrets management is also a concept
that is very much,
everyone aware of that,
everyone knows that it's there,
everyone knows that security is important,
there's nothing new under the thunder.
But here's another extension
that we're bringing to the table,
which is the Azure Key Vault extension, or AKV.
That cluster extension,
again, deployed and installed in the same way
that we installed the other extensions,
is responsible for secrets and certificates,
and secrets management via key vault.
So again,
the bookstore application can now
basically use that extension,
or harvest the technology
that that extension is bringing to the table,
and use that for certificate and secrets management
as part of the process,
and everything is happening automatically
because the extension is already there,
it's already configured against the Azure Key Vault
that is in the environment,
and that's it, you know?
All the developer needs to do
is to make sure that the application
is actually targeting that Key Vault
and being able to pull those secrets.
So that's the third extension,
and the fourth piece that I wanna bring in, Sarah,
before we were talking about,
how does that fit together into the hybrid story, right?
What is it that is so unique about this?
Is the Azure Arc data services cluster extension.
So Azure Arc enabled data services
is one of our hero offerings
when it comes to the Azure Arc portfolio,
Azure is a set of technologies,
data services is a big part of that.
And what we're able to do with that
is we're able to bring data services
into your own environment.
So Sarah, you talked about the notion of having
multiple Kubernetes clusters and all that.
So, the power of that extension
is really being able to allow the developer
to deploy either SQL managed instance,
or possible SQL on top of those Kubernetes clusters,
that again are not deployed in Azure.
Now, once you have that,
once you have those deployed on the cluster,
what can happen is that you can use,
or the developer can use, in this application
the data services as the backend for the data
that is part of the overall application structure
and architecture.
So in this case
we're showing Azure Arc enabled SQL managed instance,
and as the backend database,
which is used by the application.
So Sarah, I talked a lot about,
the pattern that we're seeing here,
what I wanna ask you here, Sarah,
is how do we wanna think about
how everything fits together?
Because we're talking a lot about unified operations,
so talk to me about that for a second.
- Yeah, and thank you for walking through
all of the app patterns,
because at the end of the day
that's what folks really care about.
So once you've gone through
and you have your Kubernetes cluster,
and you're tying all of the requirements
you have to be able to do
development on your application
together with Azure Key Vault,
and open service mesh,
and using traffic policy
to be able to iterate on the app,
as you go through that story
it's all unified with a single control plane experience
that gives you unified governance,
and unified management
through a combination of Arc
and all of the tools available
as part of that tool chain.
To me, this unified operations management
is especially interesting and important
when you look at Azure Policy and Azure Monitor,
because as you have your app running
and growing over time,
you can use a DR back to manage policies
so that your administrators
have a set of things that they can do,
and your developers don't necessarily need
to be blocked on administrators,
because you have the right roles and permissions
to maintain a unified secure environment
through the lifetime of your application.
Diving a little bit back now,
as we're talking a bit more
about the continuous deployed app life cycle,
as you grow and scale,
this is really where you start seeing
the value of having something like
AKS on-premises
or using Arc enabled Kubernetes,
because then you're going to have
a tightly managed application
with real roles and permissions,
so they're held together through a DR back
and Azure Policy, Azure Monitor.
So you can use tools like Lighthouse,
to make sure that you are continuously monitoring
and maintaining security across your application,
even while developers are continuing
to iterate, while also being able to scale your solutions.
So you have auto scale
and the ability to increase the size
of those workloads,
as you need to allow your application to grow
and be maintained at scale.
So I really love this unified control plane,
as you can see and monitor and manage your app with,
as I said Azure Monitor, Azure Policy,
our back via Lighthouse,
so that's role based access controls
enforced to be a Lighthouse.
And using Azure Defender for Kubernetes,
to continuously maintain security
way beyond the first day
and deployment of the application.
So that's really exciting to me
because in some ways,
once an app is deployed
it's easy to be like,
"Great, we've done our jobs."
But then you have to be able to grow and maintain that.
So, it's really a nice end to end hybrid story
for folks who are looking for a solution
that they can grow and maintain over time
past day one, too.
- So, Sarah, thank you for walking me through this.
As I know that you're involved with many customers,
and so am I,
and talking about this stuff,
and trying to understand how
our customers are actually using
this type of technology.
And I really like the notion
that you brought that is the Azure Policy,
because that really brings the scale game
right into reality.
You know, at the end of the day,
we can deploy all these extensions
and we can show all these patterns,
but the scale is really
where everything clicks.
It's where you wanna show that we can do this,
not just for one or two Azure Arc enabled
Kubernetes clusters,
but we wanna show how we can do this at scale.
- Yeah, you really don't want to need to re-architect
your app as it grows.
Ideally, you deploy an app and it would be successful,
and you're going to be continuously growing that
and continuously maintaining that.
And all of these tools reduce friction,
they make it possible to,
without needing to go through a major overhaul,
maintain and grow that application over time.
So, I'm really excited about it,
about the entire end to end structure,
and I hope you are, too!
- So Sarah, thank you so much
for joining me for this great session.
We like to keep it short and sweet,
we love for those sessions to be right on point.
And thank you so much for helping me
delivering that message,
and thank you so much for our viewers
as part of this "Hybrid Cloud and Edge"
digital event.
Sarah, thank you so much for joining me.
- Thank you for having me,
happy development.
- Bye, everyone.
(motivating music)