(lively music)
- Hey everyone, my name is Noah Wood
I'm a Product Manager for Azure Arm-Based VMs.
I'll be going through our Arm-Based VM portfolio
and some key features for them.
I'm also joined here by my colleague, Sandra,
who will take us through a demo
of how to deploy an application to these Arm VMs.
Sandra, why don't you introduce yourself?
- Hey Noah. Hey everyone. Thanks for having me.
My name is Sandra Ahlgrimm,
I'm a Cloud Advocate working for Java on Azure.
I'll be doing the demo later in the video
for deploying a Java app.
Why Java? It is very easily portable onto Arm
along with other integrated language based applications.
So we get to see how easy it is to get started
with Azure Arm-based VMs
and some of the best use cases for them.
- Thanks Sandra. So let's jump into it.
We'll start off with covering the Arm-Based VM portfolio.
as well as some key features of the VMs.
Next we'll talk about the recommended use cases
with these VMs.
And then finally we'll discuss
the state of Java ecosystem on Arm
before I hand it off to Sandra to walk us through the demo.
So these VMs are powered by
the Ampere Ultra Arm-based processor,
which is based off the Neoverse N1 architecture.
To start, we have our Dpls v5 series.
These are general purpose VMs.
So this series comes with two gigs of RAM per vCPU
with sizes up to 64 cores.
And these are going to offer great price performance
for lower memory workloads,
for example a smaller database server.
Next up we have our Dps v5 series,
which is the Arm variant of our most commonly used
general purpose D series instances.
So these VMs come with four gigs of RAM per vCPU
with sizes up to 64 cores, as well.
And they're great for a wide range of workloads
with some examples being web servers
or medium sized databases.
Finally, we have our memory optimized Eps v5 series.
These offer eight gigs of RAM per vCPU
with sizes up to 32 cores
and are great for analytics workloads or larger databases.
So all three families come with local disk options
with sizes up to 2,400 gigabytes
for the general purpose D series
and 1200 gibibytes for the memory optimized E-series.
You can find more details about the VM specifications
on the Azure Docs website under general purpose
and memory optimized VMs.
We will also display the links to the docs
at the end of the video.
So now that you understand the portfolio,
we'll jump into the key values
and characteristics of these Arm VMs.
So the value that most customers
will be able to take advantage of
is the outstanding price performance these VMs offer.
The Ampere Ultra is one of the fastest cloud grade Arm CPUs
in the space today
operating at a consistent frequency of three gigahertz.
These VMs come at a competitive price point
in the general purpose and memory optimized families,
and thanks to the Arm CPU,
these VMs also offer exceptional power efficiency
and are a great option for customers
who are interested in reducing their carbon footprint.
Now performance will vary depending on the workload
but generally some examples of scenarios
where these VMs will perform well
are with Java, Redis, or Spark.
Now the next benefit I want to highlight
is the performance at scale.
Arm VMs offer a full physical core per vCPU,
which eliminates the performance costs
associated with simultaneous multi-threaded CPU designs.
Getting the full physical core
is specifically beneficial for ScaleOut applications.
For example, a containerized application running on AKS.
So as you scale the number of containers, or processes,
running on the machine,
you will see a linear increase in performance.
Additionally, there is no CPU cost
for thread resource sharing,
which reduces tail latencies
and delivers a more consistent performance at scale.
So ScaleOut workloads
generally will be able to maximize
the price performance benefit of these VMs
thanks to the single-threaded nature of the Arm cores.
Now, as far as Azure integration goes,
these VMs will look and feel like any other Azure VM.
Management tools like the Azure portal,
Azure resource manager
and the Azure CLI will all support Arm VM deployments
and configurations with no special requirements or changes.
They also have support for key services,
like backup, virtual machine scale sets and spot VMs.
While the focus of today's video is on the virtual machines,
I should also mention that AKS customers
can get the same benefits of Arm in their AKS clusters
by creating Arm-based node pools.
Now that we've covered the main values
these Arm VMs offer to Azure customers,
let's talk about which scenarios are best suited for them.
So as I touched on earlier,
these VMs offer great price performance at scale.
So cloud-native, web-tier workloads,
like a microservice based application server,
are going to get the most
out of the price performance benefits of Arm.
Another area where we see many customers choosing Arm
is with their open source apps,
like databases or analytics engines.
These apps will require zero to no code changes
to run on Arm,
making them the fastest time-to-value option
for Azure customers.
So, let's say I have a PostgreSQL database
running in an Azure VM,
I could immediately take advantage
of the price performance benefits of Arm
by migrating that database to run on an Arm VM
with minimal to no disruptions in my application.
We're also excited to enable developers
with a native Arm environment for their CI/CD
and Dev test needs.
So scenarios like IOT development
can be much more efficient when implementing the Arm VMs
into their development pipelines and practices.
We're proud to bring the same value
to the Windows developer community
with the only Windows 11 client Arm Vms
available on the cloud today.
Taking a closer look at the workloads
customers using interpreted languages,
like Java or Python will have the easiest time
porting their workload over to the Arm architecture.
The Arm ecosystem is constantly growing
and many frameworks like .NET and GO
have full-fledged Arm support today.
Now the focus of today's demo will be on Java.
So let's dig a little bit more
into the state of Java on Arm.
Java, like other workloads,
will see great price performance at scale
with our Azure Arm offerings,
particularly in containers like with AKS.
Java on Arm is mature
with native support on Linux since 2018
with the release of Java 11.
I'll note that today's demo is going to be with Linux VMs
but we're very excited about the improvements
that we have made for Windows on Arm with Java
and JEP 388 as part of Java 16.
We're seeing many customers leverage Arm
for their Java workloads,
and we'd like to show you how easy it is
in the following demo.
So, Sandra, why don't you walk us through
what the demo will entail.
- Thanks Noah. Okay, so for the demo
we are using a Jhipster-generated app.
It has a front end using Angular,
a backend with Java in Spring
and it is connected to PostgreSQL database.
And I also changed the app a little bit
so I added a load generator to it.
It is accessible via endpoints.
And in the demo
I will put that one on my base VM image.
I am using the image gallery already for this
as we've seen that with many customers.
Like, imagine me as a developer at a company,
I have my IT team setting up
within the image gallery, my pre-baked images,
so which are secure and safe for me to use.
And then I would just take that from the portal use Git
and clone my repository there.
Deploy it there,
and when I am fine with it
and I want to hit the next stage, like the next environment,
I'm using the Azure CLI to make a new image.
And then using the compute gallery again
to deploy the new VM.
Everything will run together
and have the Postgres,
managed Postgres in this case, already there.
You could also use your own Postgres on Arm VMs as well,
but in this demo I'm going to use the managed one here.
And then I can deploy to, like, the next stage
also to another subscription here
my new VM running on Arm processors.
So I generated an application on start.jhipster.tech.
I usually went with the defaults here,
you can just check it out by yourself.
And here's my code.
So you can see in source main,
I have my Java parts and also the Angular web app.
In the Java files,
I also added the load controller
with the rest endpoint for some CPU and memory load.
I can easily start it locally
with Maven watch and with MPM start.
And now I can access my API,
access my API with /1 and then the number.
It will be multiplied by two 20 K for the iterations
and also for the bytes for some memory load.
Next step will be my deployment
towards the Azure cloud on the VMs.
Yeah, and so let's set up the architecture first.
So with this command,
image list or architecture Arm 64,
I can have a look what we already have provided here.
And then I will create the VM net
as well as the subnet and my private DNS zone.
I will also add my PostgreSQL,
PostgreSQL instance here,
and make sure those get connected.
And now I can also add the image gallery,
and for in the image definition here.
And the next step isn't working
because I first need to have a pre-baked VM
that I can copy from.
And for this one I will now head to the portal
and create it from here.
I use the standard T2PS one,
and I also download the key files here.
Once my deployment is complete, I can go to the resource.
And with the serial console I can already access my VM,
and I can clone here my repository, for instance,
with my example application.
And then I can dive into the app, just cd into it.
And then I can also bid and run it from here.
If I want to use the rest API point, for instance,
I would need a second one.
So a second serial console or SSH into the machine.
To be able to SSH into the machine
I need to add an inbound port word.
Just select the source.
Here's my IP address and the service SSH.
I can go with the normal 2020,
or to be a bit more secure,
I can use an obscure port like 8023.
Just make to sure to also change the port then
within your VM.
And you need to restart if you change the network word.
So I go on the serial console
and just change the port to be able to access it
with SSH via my local machine here.
I just save that and reset the service
and now I can SSH into the machine.
Now, I can also see that the app is here
and I can start it easily from here.
It's already built, so I don't need to do that again.
And then I can just open up another terminal window
and access my API endpoint.
I could have also seen the year running in the browser,
therefore I would have.
As we did for SSH, also open up the network port
and then I could have seen it in the browser as well.
So here you can see my CBO load
as well as the memory load.
So there was my feature request I had to develop today.
So, next step will be to bring it to the new stage.
So my CI/CD pipeline should now use the scripts
to put it to the next environment.
So I can go on, actually,
with my scripts that we provide in the deploy
with CLI, AZCLI five.
So I now got the ID of my image
and now I can create the new VM out of it.
In the same resource group.
But I could have also chosen another resource group
and also another subscription if I would want to.
It just needs to be in the same region location.
So now here I can see in the project
all the new things that got created.
Also the second release
I just called it second release, or two release.
And now I can also have a look what's inside the VM,
and as I just copied from the other one,
it should have everything I developed on the other machines
on the other VM.
So I can now have a look,
just LS and see there's the app I just cloned
and started there.
So now it's here also,
so I can go ahead and play around, or work,
with the application on the next VM.
So let's recap what we just did.
I used the Generated JHipster application.
I deployed that on a VM, I locked into that machine,
I cloned the repository there.
So my JHipster app,
I also configured it using the PostgreSQL
and then I also accessed my rest endpoints.
Then I captured this VM
to restart at the Azure Compute Gallery.
From there, I took it again.
So I load the image from the Azure Compute Gallery
and then I deployed it towards the new stage.
That could be on a different subscription or somewhere else.
And then we had a look on the new freshly created VM
and we saw that the application
so my JHipster code was already there, preconfigured,
also using the PostgreSQL.
- Thanks Sandra.
So to recap,
the Arm VMs come in three VM families,
being our general purpose Dpls v5, and Dps v5 series,
and the memory optimized Eps v5 series.
These VMs offer great price performance,
particularly for ScaleOut workloads
and offer integrated Azure support for key features.
Aside from ScaleOut workloads,
these VMs are great for open source based applications
and native Arm development,
and customers using Arm compatible frameworks
will have the easiest time
porting their workloads over to Arm.
Finally, we showed you how easy it is
to run a Java app on Arm,
which will apply for many other managed run times.
So as I mentioned earlier,
if you want to learn more about the VMs
you can visit any of the links on the screen right now.
The blog post will tell you a summary about the offerings
and the docs will tell you the specifications
for each of the VM families.
We've also included some links for Java,
including the link to the Microsoft build of the OpenJDK.
Finally, you can find VM pricing information
on the pricing website.
So that about wraps up our session today.
We hope you were able to learn a bit more
about our new Azure Arm Vms
and how easy it really is to deploy Java workloads
on them seamlessly.
Thanks everyone for tuning in
and have a great rest of your day.
(lively music)