Hey, friends, did you know that you can simplify your Kubernetes development
process with automated deployments for access powered by draft?
Draft takes care
of the tedious work of containerization so you can focus on developing your app.
Steve Buchanan is here to show me how it works - today
on Azure Friday.
Hey, friends.
I'm Scott Hanselman, and it's Azure Friday.
I'm here with Steve Buchanan. How's it going, sir? Good.
Thanks for having me on.
So, listen, I have been containerizing
all the things, but I have yet to throw it into AKS.
It's just a little,
little scary.
I've got the apps.
The apps are working, but it just seems like a lot of moving parts.
And I understand that there might be a solution for me.
Yeah, so
it can be a lot and intimidating to go from just code to
how do I get this app running on X?
And that's what we're going to talk about today is, is something
called automated deployments for across.
But it has been revamped and now it's powered by something called draft.
Okay draft.
And you know, everything with Kubernetes has to do with,
you know, being in a boat and ships and stuff.
So there's like a helm and charts and the draft of a ship.
I assume
they always pick a noun for that reason.
Yeah, I'm not sure of the history behind the name, but I do know that
draft was created by the same folks that created Helm.
All right. Very cool. Yeah.
The draft of a ship's hull
is the distance between the waterline and the bottom of the hull.
So presumably draft is going to get me closer to the boat
or closer to the ship, which I'm looking forward to seeing from you.
Yeah, definitely.
It'll get you closer to deploying your apps on X, Right.
So let me take you in and show you the workflow
of what this looks like and then we'll dive into a demo.
So here we have you would actually start
with your code in a GitHub repository, right?
And then you would point draft
or automated deployments in this case, add that repo.
And then the second step is automated deployments
is going to generate Docker file for you.
And so it's going to detect your language.
So if you if you wrote your app in Python
or let's say JavaScript or go or rust,
it's going to detect that and then it'll generate that Docker file for you.
And then you can go to the next step
where it will actually generate your Kubernetes manifest files for you.
So that's your deployment file and your service file.
So the service file is, is how you would access your application.
And the deployment file contains like the pods and whatnot in it, Right?
The other thing that draft does and kind of move into the next step
is it generates a connection
between an Azure.
So your resources like your Azure Container
Registry
and your resource group and your access and GitHub and it's going to create
a GitHub action workflow for you that's going to do the heavy lifting.
And so it's creating that connection between Azure and GitHub.
And then it's also going to set the permissions that are needed
and it'll create that GitHub action workflow.
And then you will need to approve a pull request.
And once you do that, it kicks off the workflow
and creates the Docker file, pushes it up to the registry
and then
deploys the Kubernetes manifest files to your AKS cluster.
So it's a pretty smooth process and you don't have to have
a ton of knowledge around like Kubernetes and how to do all those steps.
Should we dive in now and take a look at this in action?
Yeah, I definitely want to understand this
because it seems like it's generating a lot of the toil, right?
Just a little administrative trivia that's involved,
whether it be the Docker file, which I may or may not already have,
but definitely the Kubernetes manifest files and then having a convenient action
workflow is just one more thing that's automated.
And once it's done, I don't have to think about it again.
Yeah, definitely.
And two things I want to call out.
So let's say if you do have a Docker file, you can use this tool with the app
as well.
And if you want to use home charts instead of Kubernetes
manifest files, you can do that too.
All right, let's see it.
Awesome.
So let's go to my GitHub repo first.
So I have a very simple just JavaScript application.
Not much to it, right?
That's what we're going to point to.
And here is my X cluster.
And if I scroll down, you'll see something called automated deployments.
This is an public preview.
And then in here, this is where you'll actually create
what's called the workflow.
So you click on the create button and you have two options.
So if you click on this, deploy an application.
That's if you had
an app with a Docker file already, we don't have that in this demo.
So we're going to click on the containerized end deploy
and this is where it creates the Docker file
and the Kubernetes manifest files for you.
So give it a name there
and then I'm already authorized with my GitHub account.
And so it's looking at my repositories.
And then if I go in here and I
select my Java app, my JavaScript app,
which is just a little rest API, and then I can choose my branch.
And then here
you'll notice it automatically detected my language.
And if I were to click this, you'll see that I have access
to like Java, P, Python rust, etc.
Now it will automatically detect that for you, let's say,
if it got it wrong for some reason.
And you know the
the language that it needs to be, you could change that here.
Right.
And I'm going to change the port because I know my
my rest API runs on 3000.
And then here's where it generates the Docker file for you.
And so you can actually preview the file and see what it's
going to create when it creates the Docker file, right?
And then a ignore file.
And then here's where you select or create a new container registry.
So it's really simplifying this process for you.
Now, I already have a container registry, so
I don't need to create one there
and then I'm going to give my image a name
and then we go to our deployment section
and then here
we want to create a namespace because I want to plug this into a new namespace.
So I'll do that here.
And so this workflow is going to create that for me.
In my X cluster, you could see my deployment file here
and you could actually scroll through that and see what it's doing.
And here's my ACR, here's my image, my port number,
and then also your service file, right?
Which is going to create your Azure Load balancer for you.
So then you click next
and you can review the information and then you click deploy.
So here what it's doing is it's creating
any resources that need to be created in Azure.
It's setting up permissions.
It's making the connection between Azure and GitHub.
So it's actually creating the secrets over your GitHub repository
and it's basically getting everything ready.
And so it's doing a bunch of work.
And when this update's here and it's pretty fast,
then it's going to ask me to approve the poll request, right?
So here you don't have to do anything
except for come in here and approve this.
My sure that it's doing the right thing
at every entry level. Yes.
Well you can come in and double check it.
Right.
So you could actually come in here and you could check like
your action secrets to make sure it created the right stuff.
You could do the same thing in Azure.
You could go into your code repository
and you'll notice it created a manifest folder,
your Docker file, and I actually show you all of that.
But I want to point out here under our GitHub actions
that here's our workflow running, right?
So what it's doing right here
is it's building the image, it's pushing it up to the registry,
right?
If I go back here to Azure, I can actually click close here
and you'll see a status in here as well.
So you can watch it over here or you can watch it over here
in your in your GitHub repository
now that we're seeing it live too.
I just think that's so cool.
Like, I know it's obvious,
but like just going into GitHub actions and like this is not a video.
This is live, right?
And it's being pushed to that ACR that you just made.
And if it fails, right, you can see the error.
You can go make the correction and rerun it.
Let's say you got a port number wrong in your
in your Docker file or something like if it didn't match up
with what you had in your code, you could come in here and see that
and then you could go fix it and then rerun the workflow.
So to answer your question directly, Scott,
I could go over here to code and in my repository
now I have this GitHub workflows folder which has my GitHub action in it.
I have this manifest folder which has my Kubernetes deployment files in it.
Now my Docker file, like everything that I need.
Hmm. Is is there now.
Right?
And so everything is to taste right.
Like now that they're made, you can tweak them,
but the actions are already there. So they're actually going to keep running.
So you do have an automated deployment right here that isn't static.
It can be modified and changed and improved upon.
Absolutely.
And in fact, that's a really good point, because if you make changes to the code
now, all of your CIC essentially is set up here
and it's going to fire this off again and deploy those changes
to your Kubernetes cluster.
Right. So
and so now I'm back in the portal, and if I click refresh,
you'll see that this succeeded.
So now we can check out our cluster and see if this actually worked.
And like you said, we're doing this live.
So fingers crossed, right?
So there's the namespace that it created.
And if I go to work workloads,
here is my deployment
and it has my part in it, which I only have one in this scenario.
And then if I go to services and I scroll down,
here's my actual service
and my Azure load balancer, and then if I click on this IP,
here is the app, let me make this a little bit bigger
and this is just a rest API of of jokes, right? So
I'm big into dad jokes, so
I need to do me a little bit more for me
or all the way
nice.
So yeah, so we needed a
Kubernetes powered joke API for dead jokes
and that's live on the Internet right now.
And you did that in 10 minutes.
Yeah, like super easy, super, super quick.
So the goal here is to simplify the developer experience
for archaea so developers can come out and get started with access
really quick. That's great.
So we're going to go and learn more about this and like start today
so you can go out to the Microsoft,
learn documentation and just look up
automated deployments for access.
Okay, Automated deployments for Azure Kubernetes service in preview
being worked on actively, you can check out the code up at GitHub
dot com slash Azure slash draft and learn more about that.
So all the stuff that you did in the Azure portal, you could also do
potentially at the command line if it makes you happy as well.
Yeah, definitely there's command line version and then
there also is an extension for voice code.
So you could use the gooey and voice code to do what we just did here.
Very cool.
Well, thanks so much for hanging out with us today.
Thanks, Scott.
I am learning all about draft version two and how to contain,
erase my apps and deploy them to access today on Azure Friday.