>> Hello, this is Lara Rubbelke
and today on Azure Friday,
I have Kith Merkur with me from
JFrog and we're going to see
some great things that you've been
developing that work with AKS.
>> That's right.
>> So, can you talk to me
about who you are and what you do.
>> Absolutely. Thanks for having me here.
So, I used to work at Microsoft,
so it's great to be back here
in Building 25 in Redmond Campus.
I worked at Google for a little bit,
and I worked on the Kubernetes project
there as a Project Manager.
And now I'm leading the ecosystem
and the partnerships at JFrog.
And if you don't know JFrog, you may be.
>> Please do, yes.
>> I know you are very familiar with one.
JFrog is best known for
our flagship product that's called Artifactory.
>> Right.
>> Artifactory is a package management,
binary repository for
all the different types of software,
all little pieces that make up server applications,
we store it there, make it really easy for
people to go from code to the cloud.
>> So, it's a repository.
>> Yes.
>> For your Kubernetes' assets,
your container's assets, I should say.
>> More than just the containers.
So, Azure has the Azure Container Registry
which lets you store all the Docker images.
Inside of those Docker images,
you actually have different languages
and binary that are being used.
So, you can think about the different languages: Java,
PHP, node, et cetera,.NET, you get.
These different pieces can be
stored in Artifactory and then when you
build through your continuous delivery pipeline,
can push the container images
into ACR and then deploy them to AKS.
And that's exactly what I'm going to show today.
>> Fantastic. Why don't you walk
through what you've put together.
>> Sure thanks. So, this is kind of a high level picture.
We've got the flow from that Code to Cloud.
So, developers today are using
GitHub quite a bit for development
and using Git for resource control.
So, they're writing their software,
they're storing it in Git in the programming language.
Then it goes through some sort of
transformation and process to be built into
a computer readable or computer runnable code
in binary basically.
And they can also combine those binary with
third party packages they get from
NPM or other central repositories.
Artifactory stores all those pieces in
one system and also lets you cache them so that if
something like an outage like
that teapot outage we saw recently happens,
it doesn't break your belt, okay?
>> Okay.
>> Once you've got that in Artifactory,
then you can push it into the Cloud,
cache it in ACR and then deploy it to AKS,
or to wherever else you want to run.
Some people still run VMs not just containers.
So, we support that as well.
>> Great.
>> Yeah.
>> Great. So, let's see what you put.
>> Well, I have one more slide I want to show you too.
I'm just drilling down on the containers store
because we can go even more specific on that.
We've been talking about
Artifactory as a Kubernetes Registry.
Now, a lot of people think of needing
a Docker Registry for
the Kubernetes application where
they store the containers.
So, this is really the the end-to-end picture.
Your containerized application that you're running in
Kubernetes is going to have
an operating system and the related packages.
Is going to have the programming languages.
It's going to have your application.
It's going to be wrapped up in Docker containers.
And then finally put into the Helm Chart,
so this describe the micro services.
All these different pieces is what
you need for Kubernetes Registry,
and that's the role that Artifactory you can
play in a full containerized set up.
Now I can show you a little demo.
>> Okay.
>> Ready for the demo now?
>> Yes.
>> Okay. Let me see if I can get it to work.
So, I'm going to take
the perspective of kind of a DevOps engineer if you will.
So, really kind of focusing on what's the infrastructure,
the CI/CD infrastructure to get
from a developer who's building an application,
help them get their app to production.
So, I'm not going to write an app here,
I've got a very, very basic app.
But you can imagine to kind of supporting
a whole team of developers that
have different application needs.
So, it's a very simple app,
and this is just an HTML file.
This is if it all works.
So, remember this for later, we're going to see this
actually deployed onto AKS.
So, I've got all my code here in GitHub,
and we've got a nice little example
of the Kubernetes app.
This is actually a Java app.
It's going to use Gradle for the build,
and it's going to use a Tomcat to display it.
We've got some instructions of how to get
the Kubernetes cluster set up
in AKS and a few other things.
So, if you want to follow along,
you can go on to github.com/jfrogtraining,
you can find this example.
I've also got Jenkins pipeline setup here,
and I'm going to just go ahead and kick this off
because it's going to need a minute to run.
The first step in the process that we're
doing is we're actually taking the application code,
and we're going to build that using Gradle.
And it's just a simple Jenkins job written in Groovy.
We have got the code over here in Adam.
I'm using Adam today which is the IEE,
it's actually made by GitHub.
So, the first thing
to notice in this pipeline is that the step one,
we're using the Artifactory server,
and we're using the Artifactory plugins for Jenkins
to make it super easy to build and
resolve the dependencies that my job application
has against the other libraries.
So, I'm not having to find all the source code,
I just use the plugin, helps to resolve my dependencies.
And that's the step we're running right now.
Once that's done, which might take a second, okay.
Once that's done,
we're going to go ahead and do the second step.
I'm kind of running this manually
just for the purposes of a demo.
>> Right.
>> In real life,
this would happen kind of behind the scenes.
I would have pull requests and it would
have just kicked off,
and then magical, and everything else.
So, once that is done,
I'm going to go ahead and run the second step which is
to create a base image for the Docker.
So, when we're using Docker,
we are usually taking
an application that is
owned by the application developer,
and we're going to use other dependencies and
pre-built images that are
usually managed by a different team.
They're kind of making sure you're not bringing
in libraries you don't want,
maybe vulnerable libraries,
and you can kind of manage those.
So, you'll have a base image,
and you'll rely on that base image,
and then produce an application
that you can actually deploy into production.
So, what I'm doing right now is I'm just
building a base image that has
the basic of dependencies of the job application.
So, we hop back over to the code here.
And you can see this is another Gradle thing.
Again, we're using Artifactory,
and we're using the Artifactory plug-in
for Jenkins to produce the Java and Tomcat base image.
So, there's a build stage in here.
We also have a test stage because testing is
good. We also are using.
>> Our test in production, right?
>> What's that?
>> You're not going to test in production?
>> We will monitor in production,
but we'll also test it continuously.
I should also point out here,
we have a stage for X-rays.
We have another product that does security scanning.
Basically, it looks at application code
and finds vulnerabilities,
lets you know about them,
kicks off some different workflows.
So, and then let me show you.
Well, that's running. This is going to
run for a second. Let me show you an Artifactory.
We can actually find some of
the build information actually in Artifactory itself.
This is the Artifactory UI.
See it's JFrog Artifactory right on it.
And this is deployed on an Azure.
In fact, there's a really easy way to get started.
You can run Artifactory as a SaaS Service on Azure.
So, you can just go and get it up and running.
It will be on Azure behind the scenes,
you can also deploy it onto
AKS itself if you want. So, it really simple.
>> So, you can discover this by just going
straight to Azure saying,
''add new'', ''do a search for JFrog'',
and it will pop up the option for Artifactory?
>> This is exactly right too.
>> So, it's all integrated right within the portal.
>> That's right.
So, if you go and say the easiest way is to
Bing for Artifactory Azure,
and you can find all the different ways to get started.
>> Okay.
>> Very straightforward. The Build Browsers
are really powerful part of Artifactory.
We will look at all
the different artifacts that are here.
There's a ton of different types.
You can see that there's like we've mentioned Bower,
Docker, there's Gradle, Helm,
all these different types that are in here.
But I want to look at the builds because I'm
producing Jenkins built and you can see here,
the builds are actually,
these are the different stages that were listed in
the Jenkins UI when we saw the Jenkins pipeline.
And I'm going to check on it make sure it's,
oh, it's almost done.
And we go click in on this,
we can look at for example the Docker
image that was already produced and
we can see all the different build versions
of the Docker container.
Now that I'm here,
I can see all the different stuff.
I can see the environment variables
from the machine when it was built.
I can see the issues related if there are any.
I can see what Open Source licenses it's using.
I can see the diff of it.
I can see the release history.
And what's really cool is
to be able compare with the previous build.
>> Right.
>> Now, I was saying this before. So I can look at
comparing 46 versus 44,
and I'll be able to see there're actually the changes in
that relative to the other build.
You can see all the different layers,
you can see all the dependencies,
all the different pieces that make up this artifact.
Okay. Yeah. So, here you can see the diff,
these three things were updated
in this version. All right, cool.
So, now and we've created.
Oh, come on, one minute left.
So close. We're going to have that pushed.
This is now where we're pushing it into ACR.
The next step which I'm going to go
ahead and kick off because
it doesn't have a dependency on it,
is we're going to actually create Helm Chart. Okay?
>> Okay.
>> So, Helm as you may know,
is a open source project.
It's a package manager for Kubernetes.
It actually was just recently promoted to be
a top level Cognitive Computing Foundation project
which is really exciting for the Helm team.
>> That is.
>> And a bunch of Microsoft people work on that.
So, if I look at the code for what we're doing here,
we're taking the Helm,
we have a Helm Chart template.
In the build process,
we're going to replace some of the values in the template
with the specific outputs from
the build. So, we have a build number.
>> Okay.
>> We're going to replace that in the Helm Chart.
So, now this Helm Chart we're going to
produce this new one.
It's about this particular run.
So, next time we run it,
we get a new set of numbers that we won't accidentally
release the run container images. Okay.
>> And that integrates then with
the Artifactory where Artifactory can
gather all of the information that you're. Okay great.
>> Yeah. You've got it exactly right.
So, we're pulling all this info
from Artifactory in the Jenkins pipeline,
and then that's giving us a bunch of
new artifacts that we are ready to deploy.
But we can trace it all the way back to
GitHub which is really the important thing.
So, now we got a Helm Chart,
and that refers to those Docker images.
That's already done. So, we're almost ready to push
the big red button actually
to do the final deployment to AKS.
Now, before I do that,
I just want to go back to the step five, okay.
Before I do that, I want to show you I've got
my Microsoft Azure dashboard up and running here.
I've also got the command line over here.
I just realized it kind of ignoring the command line
but a lot of
this stuff can be done from the command line as well.
So, for example, I
can browse resources that
I currently have running in the AKS.
I can see the Kubernetes cluster that's
running right now in Azure, that's loading up.
So, this is actually deployed on Azure right now.
This is my cluster that's running.
So, I can see that
which is great because we have this Kubernetes UI.
It's the same on every cloud,
same on-prem, same on your laptop.
So, you get a really consistent view
which is one of the great things about Kubernetes.
And then in the dashboard,
I can see I've got my ACR repository right here.
I've got my repository that's got,
I really like this UI by the way. I think it's very cool.
I can see my Docker app right there.
All the different versions that I've published into ACR.
And this is actual what we're going to deploy.
Now, one really cool part about
having ACR and AKS together,
even though I'm using Helm and I'm using
these other package types
and different repositories types,
ACR is kind of co-located with
AKS and AKS and ACR are adding new regions all the time.
So, when I'm thinking about my application
globally across the whole Azure planet,
having all of the docker images close
to AKS that means that when I go to deploy,
it should very fast. Okay.
>> Right.
>> And be able to do it at scale which I think
is a really cool use case that brings together
both Artifactory and ACR into the whole container store.
So, here we go.
I'm going to push the button,
and we're going to deploy the app,
and we're going to get a nice message.
>> All right.
>> Okay. Do you want to do the honors.
Can you just clip it there?
>> Sure.
>> Let's see it. Okay. So, this
is just going to take a second and if it works,
then when we load up this Web page,
we should see a nice message.
Let me go back and get the URL
for the web page it's going to deploy.
Got it right here. So, we just need to wait
until it's done deploying and then we'll be
able to push it in through second.
>> So, you started from scratch.
>> Yes.
>> You built a new application
and you want to walk
through those steps that we just went through.
>> Sure.
>> So, just to sum up.
>> Yeah it is perfect. So, first
up we have an app that we got from one of our developers.
>> Right.
>> It happened to be a Java app, but it could have
been in any language.NET or whatever.
>> Yeah.
>> We set them up in Jenkins so that they could get
a continuous delivery pipeline from Code to Cloud.
>> Right.
>> We ran through a bunch of steps,
number one, building the app.
Two, getting a base image with all my dependencies.
Three, getting
a product ready Docker images ready to deploy.
We generated a Helm Chart for that build with
the specific build numbers
that we needed in order to deploy it.
And then we just finally pushed it out
to ACR and we're going to deploy it to AKS.
>> Okay.
>> And it looks like it's done.
So, we should see hopefully a nice message.
There we go, it worked. All right.
>> That's great.
>> That's the demo.
>> That's great. Well, thank you very much.
Where can people learn more about JFrog and Artifactory?
>> So, jfrog.com is a great place to go.
We have a ton of content about how to
use JFrog Artifactory with Azure, with Kubernetes.
We have a bunch of blogs we're producing all the time.
So, there's a lot of good information out there,
tons of stuff of GitHub too.
>> And this is all available today?
>> That's right, it's all available today.
>> That's great. Thank you very much.
>> Thank you.
>> This is Lara Rubbelke, and today on Azure Friday,
I was talking Kith Merkur about JFrog and Artifactory.