Hey, friends, did you know that Azure Arc
enabled Kubernetes has a comprehensive, extensibility model?
This model enables you to install cluster extensions and bring powerful Azure
services and capabilities to any Kubernetes cluster.
Lior Kamrat is here to show me how it works, today on Azure Friday.
[MUSIC]
Hey, friends! I'm Scott Hanselman, and it's Azure Friday.
I'm here Lior Kamrat, who's going to teach me more about Azure Arc
and the extensibility model for Azure Arc?
How are you, sir?
I'm good, Scott.
It's it's always fun to come back.
I love hanging out with you.
I learn new stuff all the time.
I was able to go and Arc-enable my own things.
But you told me when I put Azure Arc on something like my tiny Kubernetes cluster,
which would be like my tiny edge, I'm really just getting started, aren't I?
It's where the extensibility model starts, it's where the fun starts.
Right?
You know, you know, we're talking to a lot of customers, and the fact
that you can argue enabled those clusters, that's, you know, that's the first step.
That's where you're starting to see
all the fleet management capabilities, inventory, and all that.
But the extensibility model, which is what we're going to talk about,
today, that's really where the fun starts.
The extensibility model is what brings all this integration
with Azure Services to life, with Azure Arc-enabled Kubernetes.
And we also are going to talk about
what are the things that are coming with AKS in that regard.
So folks can check out the other videos that we did on Azure Arc.
But if I go and ask enable something, it means that it shows up in the Azure
portal and it looks like an Azure managed piece of, of, of Kubernetes.
But, you know,
there are things I can't do until I add these extensions right? Right.
And we talked about the notion of stretching the control plane.
We always talked about projecting resources.
And once you are enabling those clusters, this is where you can actually
go and start installing those extensions that bring those to life.
And we have couple of different types of extensions, so to speak.
And today we're going to drill into some of those.
All right, cool. Let's take a look.
So in the in the diagram that I'm showing you, this is where
kind of the split between the two types of extension starts.
We have the Azure Arc-enabled infrastructure services extensions.
This is the these are the extensions that are
basically built in into the control plane.
Right.
Azure Policy, Key Vault is another thing.
Microsoft Cloud Defender, these are the extensions that you can think of those
as, I should do this by default kind of extensions.
Right.
And the Azure Arc-enabled services extensions is
where really you're starting to integrate other Azure
services like data services, Machine Learning, App Services.
We had an episode when we talked about data services with
SQL Managed Instance and all that, but this is where the extension
model comes to life because you can actually go
install those extensions which allow you to deploy Azure
services on top of those Azure Arc enabled Kubernetes clusters.
OK, and let me ask an ignorant question.
I could just call Azure Services, couldn't I?
I could get an SDK, my application could call those Azure Services
directly, couldn't I? Just out just directly.
HTTP call REST APIs that are already available, maybe
Cognitive Services, maybe some data services, maybe call Cosmos directly.
But that's not the same as what you're describing.
Right?
Because when you are enabling those clusters
you're really doing that for the purpose of bringing Azure services
to you and not being dependent on the fact that you now need to call other Azure
services that obviously are part of our control plane, part of the cloud.
Right?
So doing something like deploying data services with, you know, a single minute
instance of Postgre or doing machine learning models at the edge
or deploying Azure functions, these are things that you can actually do
on premises or other cloud providers so it's not really the same.
It's really bringing those to you and not being dependent on what's
up there in the cloud. OK, that makes sense.
So show me your diagram again here.
Let's take a look at this.
OK, so then there's some you're just using some examples
here, like ML Services, Data Services, but there's a whole host of things
that I could bring into Azure Arc and enable services.
Right.
And what I want to do is
I want to show you a demo where we're taking a couple of those extensions and,
and really focusing on the DevOps story because it's a very interesting story.
And what they have in store
for you is a couple of extensions that I'm going to abuse today.
One extension is the GitOps or the Flux extension.
We already talked about it. We're going to take it one step further.
And the second extensions is the open service mesh extension, which is
our implementation to service mesh architecture or service mesh solution.
So we went about a couple of weeks ago, and I want to show you something very cool
with regards to how a blue-green deployment will look like
for a developer in an Azure Arc enabled Kubernetes environment.
Very cool. That's it.
All right.
So kick things off.
I'm going to start with the portal.
So as you can see here, I have three resources I have couple of
Azure Arc enabled Kubernetes clusters, and I also have an AKS cluster.
Remember that AKS cluster?
We're going to get to that towards the end of the demo because we can talk
about what we are coming with AKS and extensions.
But the first cluster that you're seeing is ArcBox-CAPI-Data.
That's cluster that is based on cluster API cluster API.
We talked about it in previous episodes.
Cluster API is really an implementation that will allow you to deploy
Kubernetes cluster
in an unmanaged fashion, but via provider's right.
So right now we are simulating an on premises
cluster using cluster API using the Azure provider.
So that means that we're able to control the deployment of the bits, deployment
of the infrastructure, of the virtual machine, the network,
everything that goes with it.
So that's the first cluster.
The second cluster is a curious renter cluster, and that cluster is simulating
an edge cluster like you just showed me with your fancy edge build out.
So that's really that cluster.
Now, these Arc enabled clusters are the one that we're going to use today.
So the first one the the K3s cluster,
if I'll go into the resource itself and here under extensions,
you will be able to see that I have a couple of extensions already deployed.
Right.
So if you remember, I shared with you that we have the infrastructure
extensions, right?
Or the infrastructure services extensions.
So you can see that I have policy insight extension.
I have Cloud Defender extension for Containers, right?
Because it is a Kubernetes cluster.
And we also have Azure Monitor for Containers.
So these three are extensions and they are infrastructure extensions.
But, if I go to the Cluster API resource
and I go to the same view extensions, you will be able to see that.
I have a few more of these
and let's just say some real estate here and I'll show you what we have
so you can see here that I have Key Vault extension.
I have the Flux extension,
which will allow us to do the GitOps process, Open Service Mesh.
And again,
the same extensions that we've seen before with Defender, Monitor, and Azure policy.
So this is where the extensibility model starts.
So like, for
example, the the secrets provider, what does that look like
to someone who's writing a cloud native application that's running on Kubernetes?
I'm going to call out to that.
And it appears as a node or it appears as something that I can call into.
Look, what value does that provide as an example?
Basically.
So the secrets provider basically is an integration with Azure Key Vault,
it will allow you to install an extension on top of the cluster.
It will deploy a bunch of pods on that cluster.
And what will happen is that it will allow you to interact
with a Key Vault infrastructure that you have deployed in Azure
and basically bring those into your Arc enabled Kubernetes clusters.
And remember, those Arc enabled Kubernetes clusters are not AKS.
They're not clusters that are deployed in Azure.
There are clusters that are deployed outside of Azure.
But you want to use Key Vault in that example against those clusters
to do some secrets and certificate management example for that.
So if I had an AKS cluster that was a fully managed cluster,
I have these things available,
but with this example, I'm getting the best of all worlds.
I have full control over my Kubernetes.
I own it, I manage it, but I can also
feel like Azure is there at the same time.
Like literally the Venn diagram gets really tight.
So I have the full control of the Kubernetes
cluster and the full power of Azure at my fingertips.
Exactly.
And this is really where Azure Arc really shines specifically with that
Azure Arc and Kubernetes, because this is how we are bringing those capabilities
and integrations outside of Azure into your own infrastructure.
And remember the notion, right, this is all about not being disruptive.
All we want is to provide you with the goodies that we have in Azure
and bring those capabilities so you'll be able to enjoy those
against your Azure Arc control clusters.
So interesting. That's what we're doing.
And you have something that's a little more of a of a demo in real course.
And of course, you know that I always come to you
and I always have demos because this is how you and I like to like to play.
So so 100%.
So what I'm going to do today,
I'm going to switch to another interface that they have here.
And what we're going to do today with this specific demo,
it's going to be very short and sweet, but very fun.
What we're going to do is we're going to simulate a blue-green deployment,
basically a very common practice in DevOps or developers
world when you want to test version one and version two of an application.
So how are we going to do that?
Basically, we're going to
jello two technologies together or two practices together.
We're going to Jello ops, right?
Which is basically the notion of listening into a git repository
and capturing changes to that repository in real time.
And at the same time, we're also going to use open service mesh.
Right?
And open service mesh is our own implementation,
our own Microsoft implementation to a service mesh technology
which holds very, you know, a lot of capabilities.
Today, what we're going to focus on is traffic splitting.
Basically, that means that we'll be able to route traffic from version one, to
version two, based on changes that we're going to make on
a git repository that the GitOps or the Flux extension will capture
and apply those changes into the deployment that we have.
And what I'm going to show you right now is how easy is it is we then
with an Arc enabled Kubernetes cluster with those two extensions.
So let's just see what we have here on the screen.
Right on the top left, we have a bookstore application.
That application basically has two versions, right?
We have version one, version two.
These are pods that are actually deployed on these cluster API
Arc enabled resource that I showed you.
And as you can see right now, all the traffic going into version one, right?
So you can see that I have this running for quite some time.
And this bookstore, they are getting pretty rich.
They already have like half a million books already sold
and you can see that version two is not getting any traffic right.
And on the left side, this is the git repository that we're going to
that we're going to use. Right.
So what you see here is basically a git repository, right?
azure-arc-jumpstart-apps,
that's the git repository that has this bookstore application.
And specifically, you can see that I have near this traffic split YAML file
and this is the YAML file that we're going to change.
We'll get to that in a second here.
I want to show you how it looks like in the portal. Right.
So this is the CAPI cluster.
Remember, we talked about that
and this is the repository that we are seeing, right?
So here we go.
This is the repository that we're talking about.
And you can see that it points to the same repository that I just showed you.
OK, so that Flux extension that we have
is listening to this repository now to just kind of seal the deal.
I want to show you how it's going to look like the change,
how it's going to look from the Kubernetes side of the house.
So what we're going to do,
we have a very simple command here that's going to monitor or we're going to
just kind of watch the logs as we are making the change.
Right. So I'll hit that.
And you can see right now that all the traffic going into version
one, there's nothing, you know, nothing fancy about that.
Now, the first thing that
we're going to do in this blue-green, blue-green deployment and practice, we're
going to first check that the version two is actually functional.
All right.
So let's go ahead and do that.
I'm going to go and I'm going to edit the file.
Obviously, in the production environment, you're going to do that
as part of a CICD process,
you know, but here we just want to kind of make things a bit faster.
So I'm going to change the traffic here to 75 and for version two to 25
that represent the percentage of traffic, the web traffic that will go through the
through the app.
OK, and I'm going to commit those changes and let's just see what happens.
You were in few seconds here, what you're going to see
is you're going to see the traffic going into version two
and you also going to see how here we're going to start
seeing version two traffic in the in the Kubernetes side of the house.
Right. The logs are going to start flushing down.
So let's just do that.
And you can see here that I'm using one of our favorite tools,
which is ZoomIt and can see here that already have version two.
Here is another version two. Here is another one.
So that represents kind of 25% of of the traffic.
And you can see here that version two is starting to get web traffic.
Now to finish that
or to or to kind of complete the blue-green process
now that we know that version two is functioning I want to switch over
and I want to do 100 or 0% to version one and 100% version two.
So we're going to go again to the to the YAML file
of the traffic of the traffic policy and I'm going to change it here to zero.
And here bookstore is going to switch into 100
and again, we're going to commit to change.
So again, same deal
in a second here, you're going to start seeing version one
stop receiving any traffic and version two picking up all the traffic.
You can see already that version one, stop responding.
It's not receiving any traffic.
And here version two is already
already receiving all the traffic.
So this is really a short and sweet demo, but it really emphasizing
a lot of the power that we were talking about here with the extensions.
Yeah, that really is a great way.
When I did it myself, it was quite manual, somewhat hacky.
This is a really a an optimized.
I could GitOps, DevOps way to do this that enables people
to to be greater than themselves.
I remember it would take an entire team to do something like this before.
And now you've codified it into this entire subsystem.
That's really cool.
So you could switch that over and then then go back to version
two and version three.
Like this could be a fundamental way that you deploy software.
Exactly. Exactly.
And you know, Scott, you know, my wife, she's also our she's a Java developer
and I'm talking to her all the time
and I'm you know, kind of we're talking about things
that they're doing in their own organization.
And those things really click because like I said,
when you have an easy way to do this type of stuff,
you can actually focus on the things that matter and not just trying
to hack your way through trying different versions of a web application.
Really.
That's so cool.
So so folks can do this now, right?
This isn't a preview of anything.
This is this this technology, the ability to do these extensions and
then put extensions together and create a flow like this is possible today?
Exactly.
So, Open Service Mesh is GA Flux is going GA pretty soon.
It's already available. You can go deploy this.
This is actually version two of the Flux
of the Flux extension that we have, which enables the get ups.
But you know, Scott, that's not the end of it.
And this is something that I really want our viewers to to pay attention to.
OK, I mentioned the fact that we have an extensibility model.
Right.
And Azure Arc is really about the unified operations between your
Kubernetes clusters that are either on the edge of the cloud on premises
and also your AKS clusters that you have deployed.
So what we wanted to do
is we wanted to provide a way to do this seamless operation.
So if I just show you the extensions on this Azure Arc
enabled Kubernetes cluster, I'm going to switch into my AKS cluster.
Remember, we started the demo with the cluster
and we said that we're going to come back to that.
So that's an AKS cluster. Same resource group.
You can see this is my Freaky Friday AKS cluster in the Azure
Friday Resource Group.
And also if I go here to the GitHub configuration, you'll be able to see that
I have you know, kind of the same GitOps configuration that we had before.
So Scott, I showed you the GitOps configuration.
Let me show you the last piece and I'm going to open Cloud Shell here.
That cloud is already configured against my Azure subscription.
And as you can see here in the command that I'm about to run,
I'm actually targeting the same cluster,
the one that we just showed that the Freaky Friday AKS Cluster.
Now, what I want to show you here is that I'm going to run a command
to query the extensions that are installed on that AKS cluster.
Right.
And the most important thing to realize here is that now
you can see that Flux extension, if I know how to draw, right?
You can see that Flux extension already installed on AKS.
Now, the reason that I'm showing you
this is because we are bringing cluster extensions to AKS.
So that really means that the concept of unified operations between Azure Arc
enabled Kubernetes clusters and AKS really
kind of makes the concept of
not being disruptive about your operations
a reality, because the people that are accountable for deploying these extensions
or governing those extensions now have the same extensibility model.
Both in AKS and the Arc enabled
Kubernetes clusters that are deployed outside of Azure.
So we're going to learn more about this because this is available right now.
This is an in preview.
This is happening. Exactly.
So the best way to go about and start working with this is going to the Azure Arc
Jumpstart Project.
And let me just open that for you.
And the Azure Arc Jumpstart Project.
We've been you know, we've been out there for a while
and we actually created a new flavor for ArcBox.
Our flagship solution
and we have everything baked in into ArcBox for DevOps.
That's the new flavor that we're coming up with.
And you'll be able to do the demo that I just showed you and play
with all these extensions and Arc enabled Kubernetes clusters
and some more, right from day one.
Absolutely brilliant. Fantastic.
I am learning all about the Azure Arc extensibility model today on Azure Friday.
Hey, thanks for watching this episode of Azure Friday.
Now I need you to like it, comment on it, tell your friends, retweet it, watch
more Azure Friday.