>> Thank you for joining us today.
My name is Subodh Bhargava,
and I'm joined here with Vinicius.
We are Senior Program Managers in Microsoft working
with a new product offering called AKS on Azure Stack HCI.
You are probably familiar with Azure Kubernetes Service,
also known as AKS,
which is a fully managed Kubernetes service in Azure Cloud.
Azure Stack HCI is an Azure service that
provides a hybrid hyper-converged infrastructure for on-premises.
Now we are introducing a new service
called AKS on Azure Stack HCI.
AKS HCI for short.
This allows you to run AKS on Azure stack HCI on-premises.
It's a turnkey Kubernetes solutions,
fully supported by Microsoft.
AKS HCI shares a consistent user experience,
and terminology with AKS.
Any apps that work on AKS can work seamlessly on AKS-HCI.
It has a native integration with Azure Arc,
Azure Monitor and other Azure technologies,
and it shares a common code base with AKS.
It's super easy to deploy and use.
Windows users can use
a simple GUI available through Windows Admin Center,
or PowerShell scripts what deployment,
and Azure users can use Azure portal for
management through Azure Arc.
You can run both Linux and Windows
containerized workloads on the same Kubernetes cluster.
No more creating different silos.
Last but not the least,
AKS HCI is secured by default.
What that means is, the container hosts for Linux and
Windows containers are hardened and serviced by Microsoft,
and have automated patching and update mechanism in place.
Core Kubernetes platform is
secured through certificate authentication,
cert rotation and management, and encryption.
This is all integrated into
Microsoft security ecosystem with
support for Active Directory identities.
In terms of when to use AKS HCI,
we are seeing three main use cases where
customers are finding it really compelling.
The first is modernized traditional Windows applications.
We also call it lift and shift,
where you take a traditional Windows applications running in a VM,
you containerize it, and then you run it on Kubernetes.
Our second very popular use case is, of course,
running Cloud native applications and
managing Cloud native applications on Kubernetes.
This could be Linux or Windows apps.
AKS HCI, finally, it also
serves as a great platform to host and run
Microsoft first-party applications and services like
Arc-enabled data services, and Azure IoT.
With that let me hand it over to Vinicius,
who's going to talk more about the first use case I talked,
which is how do you modernize
the Windows application running in a VM,
containerize it, and then seamlessly deploy it on AKS-HCI.
>> Thanks Subodh. Before we dive into the demo itself,
let's just recap that the demo today is going to be focused
on modernizing your existing application on Windows server,
running a legacy system like a virtual machine on 2012 R2,
through a Windows container running on AKS on HCI.
With that, let's take a look at our work environment.
What we have here is Windows Admin Center,
and as you can see we have multiple virtual machines,
and one of those are actually a deployment of Azure Stack HCI.
I have multiple virtual machines running on
top of these Azure Stack HCI.
If I look at the inventory,
you can see that I have actually a mix
of legacy systems like the Vini Beer VM,
that actually hosts the application
that we're going to talk about today.
We also have the settle VMs that are actually,
the deployment of our AKS on HCI.
This actually shows the flexibility of Azure Stack HCI,
you can deploy legacy systems like virtual machines,
or your existing applications,
as well as AKS on HCI on the same hardware.
They'll happen to buy,
or purchase new hardware.
With that said, let's take a look at
this Windows Server 2012 virtual VM.
Here I'm connecting to this server.
As you can see, again,
Windows Server 2012 R2,
this is a IIS deployment
and we have the Vini Beer application deployed here.
Pretty standard but straight forward,
but basically what this application is,
let's go back to our browser,
is a application that
helps people that are home brewing their beer.
Basically what you do is,
in the process of brewing your beer at home,
you need to add sugar to your beer,
in order to ferment and generate CO_2.
Depending on the style of the beer that you're producing,
so for example, hefeweizen,
let's say that the temperature at my place is
75 degrees Fahrenheit and I'm producing five gallons of beer,
the application is going to tell me,
these type of sugars,
how much should I add and get grams, ounces, or cups.
As you can see the application is up and running.
I'm targeting the Vini Beer VM,
which is exactly the same VM that
I mentioned and showed you in a second.
Everything's good. It's working.
However, we want to modernize this,
so we have a more modern deployment where we can scale up,
scale down, we can move these
between environments, and so on and so on.
Now let's take a look back at our virtual machine.
It's important to understand that when you deploy a container,
you need an asset on which
the container can be built with your application itself.
There are multiple ways you can do that.
You can extract the application from a running server,
or you can have the source code from your developers.
In our case we do not have the source code anymore,
we don't have any developers around.
In fact, I as the ops person or the IT Pro,
I'm responsible for extracting this from the running server,
and putting it in a container.
If you don't know where to start,
that's where Windows Admin Center comes in,
and helps you with the process.
Let's take a look.
Here I have,
again, our Vini Beer application.
I can right-click and use
Web Deploy to extract the application from the server.
I can select what are the things I want to extract,
in this case I want to extract everything,
both the application configuration itself,
as well as the file system content.
As you can see all the files in
the folder structure are going to be exported.
Next, I have the parameters,
that actually are going to be used in the destination server,
in our case, the container itself,
and I can add new parameters if I want to.
Let's say, for example, that after containerizing my application,
I want to connect with different SQL database.
This is where I would change
the connection string to the database,
or I could add the new one even,
so when the container is deployed,
it's talking to a new SQL server database.
I'm not going to do that today.
Next, we have the place where we are going to extract the file.
Web Deploy generates a zip file that
you can use to import on the new server,
in our case, again, the Windows Container.
Since I did this process already,
I'm going to cancel here.
I'm going to minimize this server,
and go back to our folder structure in
the server to show that I have a Vini Beer web deployed file.
If I open this file just to show you
all the configuration is here,
the content for the website is also here.
I can go back to the folder.
Keep it here.
Let's go take a look now at another Windows Admin Center tool.
What you see here is the images tab on
the containers extension and I'm targeting a container host.
This extension has been recently updated to include
a feature that actually helps you
in containerizing your application.
All I had to do here is click the Create New.
I have multiple options here,
but the application type up
until now is only for web applications.
We'll be adding more options in the future.
The application source tab that we've talked about
can be either a folder for aesthetic web application,
it can be a Visual Studio Solution,
in case you have a developer around
and you have the Visual Studio Solution files,
or it can be a Web Deploy,
just like we exported from the running server.
I'm going to select this option.
When I browse for that file,
I'm going to select the folder that I just showed you,
and the zip file that we looked at.
Next, we are going to,
what is the framework version?
On a Windows container you can containerize
really old stuff like .NET Framework 2.0, for example,
but then you would have to change,
for the .NET Framework 3.5 here,
on which we can support the 2.0 version.
In our case, the 4.8 will work just fine.
We'll use that.
Next, if your application requires any additional scripts to run,
like for example, a PowerShell script,
you can use that here and we'll add that to your Dockerfile.
Next we are going to say what is the image name,
I'm going to type vinibeerwd for Web Deploy.
I'm going to say this is the version 5.
I ran this process many times,
so version 5 is fine.
As you can see the Dockerfile was created for me down here.
The nice thing about this is that,
it has all the knowledge that
Microsoft has for our best practices and
everything for running a Dockerfile
to build a new Windows container.
You don't have to do anything here.
You could, you can actually edit by hand,
but everything is done for you inside of Windows Admin Center.
I'm going to click "Build".
While the image
is built in the background,
let me go ahead and use the one that I have build previously.
I'm going to select this one, and click "Push".
I'm going to change here to Azure Container Registry.
As you can see, this check is formed by
subscriptions and then I can
select which subscription I want to use.
Under that subscription I have multiple registry.
Then as the image is pushed to the Azure Container Registry,
one thing you should notice here is that
the registry that you are going to be used,
is necessary in case you want to
use your container image in multiple hosts.
Since our AKS on HCI will be using multiple hosts,
we want to have that image available
in a central location like a registry,
in our case, Azure Container Registry, or ACR.
The nodes on AKS on HCI,
can go to the registry,
pull the image, and then use it locally.
Now the image was pushed,
as you saw the green successful notification.
We can start the process of deploying
the application itself on our Kubernetes node.
Let's go back here to our Inventory tab
and talk about this nodes that you saw here.
This our AKS on HCI nodes
that are actually supporting our Kubernetes deployment.
As you probably know,
every Kubernetes deployment will use a a YAML file to describe how
your application actually operate,
and then how Kubernetes should
deploy your application in terms of number of replicas,
what container image to use, and so on and so on.
This is the YAML file that I grabbed from the AKS docs.
You can go there and see the sample of YAML file.
What I did was I put that file to include my application.
You'll see the naming convention here is using Vini Beer.
The image that I'm using is from that registry that we just used.
In this case I'm using this version of the image.
I have some information here
on how much CPU and memory we're going to use.
But then another important part about AKS on HCI
is we have to authenticate against our registry.
This registry is protected,
so not everybody can see the images in there.
In our case, we are using Kubernetes Secrets.
I'm going to show that when we connect to the Kubernetes cluster,
and we are calling this configuration
here that was created previously in
order to authenticate and use the URL for our Container Registry,
the username and password
so we can authenticate against a registry.
Next, the other thing that you see here in this other block of
code is the service that is going to be created
in order to create a load balancer that opens the port 80 for
our container to respond to the external connections.
Very well. I have this YAML file ready to go now.
I'm going to minimize this,
and I'm going to switch now to PowerShell to use kubectl.
Kubectl is the connection that we have to our AKS on HCI cluster,
as well as AKS.
What I'm going to do here is I'm going to check on the nodes.
You can see that the nodes that I have here
are the same that we saw back in
Windows Admin Center and the Virtual Machines
running our AKS cluster.
What we have here is we have a master node running a Linux VM,
and then we have three other nodes,
one Linux and two window server worker nodes.
Next, let me show you the secrets that I mentioned.
Previously what I did was,
I passed on to this secret here our
dockerfile configuration JSON file.
What this is is basically using,
as I mentioned before, the URL,
the username and the password to authenticate
against our ACR registry.
Now to show you that we don't have
anything deployed to this cluster,
I'm going to run the kubectl get pods,
and nothing returns on this case and then for the services,
you can see that I only have
the Kubernetes Services with the cluster IP,
which is the standard configuration on Kubernetes.
Now, what I'm going to do is I'm going to use kubectl
to apply this configuration using the file
that we based on
before but I just showed to the Vini Beer YAML file.
Let's run this.
As you can see,
both the deployment as well as the service were created.
If we look at the get pods option now,
you can see that I have one pod.
I requested one and one is ready.
The status of that pod is running.
Node restores the age,
the IP address that was given and then
as you can see from the nodes from above,
we have these allocated to this node.
Let's take a look at the service so we can
see the IP address that was allocated,
and you can see that Vini Beer service is now here.
That is a load balancer as I specify on the YAML file,
and I have an external IP address.
This is the IP address that is going to be
used to connect to the application.
Let's go back to the web browser.
I'm going to type the IP address plus the path to
our application and you will see that
the application is running exactly the same way.
If I do the same process that I did before,
75 degrees Fahrenheit and then five gallons of beer,
the results show up exactly the same way.
Now, one of the things that I mentioned is AKS on HCI
allows you to quickly scale because it's the Kubernetes model.
In order to do that,
let's just finalize a demo by changing
the number of replicas here to two,
I'm going to save this file,
go back to our PowerShell,
run this command again to redeploy this YAML file.
Now if we run the option should get pods,
as you can see we have
another pod with the status container creating.
If I run the command again,
as you can see, is now running.
I hope that gave you a good idea
on how the process of modernizing your application works.
Just to recap what we did.
We started at a Windows Server 2012 Virtual VM,
where we looked at the IIS deployment with
the Vini Beer application and we used
Web Deploy to extract the application.
Next, we use the zip file generated by Web Deploy in
Windows Admin Center to go and create
a new Windows container image that has our application.
Windows Admin Center actually generated a dockerfile for us,
so we didn't have to actually write that.
Next, we pushed the image to Azure Container Registry,
which is a central location where all the container host can
access the image and pull
that image to use as part of the Kubernetes deployment.
With the image on the registry,
we could create a YAML file that pull that container image and
also describes how our application
works in terms of replica and everything else.
With the YAML file we went ahead and use kubectl
to apply the configuration into our AKS on HCI cluster.
Then we looked at the application work in exactly the same way.
We also showed how to easily scale that application
up using your containers by
just specifying the new replica number.
With that said, I hope you liked
the demo and back to you Subodh.
>> Thanks, Vinicius. That was great.
I loved to see the scenario where customers can reuse
their existing Azure Kubernetes infrastructure not
only to run legacy applications,
but also reuse the same infrastructure to run AKS HCI,
a Kubernetes Service on-premises.
With that, let me move on
to some resources that we'd love to share with you.
First called a Product Page.
Second is a sign-up for public preview.
We would love for you guys to sign up and
provide us feedback on where we are with the product,
help us that the product
direction and understand your user scenarios better.
Then finally, there's technical documentation that you
can also browse on Azure.com.
With that, we'd like to thank you for
your time today for attending the session,
and we hope you have a great rest of your day.
[MUSIC]