[MUSIC PLAYING]
KATHARINA PROBST: Hi.
I'm Katherine Probst.
I am a tech lead and manager on the Google Compute Engine team.
Why don't you introduce yourselves?
SARAH NYQUIST: Hi, I'm Sarah, and I
am an intern on the Google Compute Engine Team.
ASHLIE MARTINEZ: I'm Ashlie, and I'm also
an intern on the Compute Engine team.
KATHARINA PROBST: And we're joined here today by Ryan.
Why don't you introduce yourself, too.
RYAN COLEMAN: Hi.
I'm Ryan Coleman, product manager
for the Puppet Forge at Puppet Labs.
KATHARINA PROBST: Excellent.
So today we're going to talk a little bit about how
Google Compute Engine and Puppet Labs
can actually work together to make great things happen.
We want to jump right in and show you a demo,
and Sarah will describe a little bit what the demo will do.
SARAH NYQUIST: So in this demo, we're
going to create four Google Compute Engine
instances with Puppet.
And we're going to install Apache on them, which
will make web pages for each of them,
and it will have a load balancer that will allow HTTP traffic
to go between those web pages.
KATHARINA PROBST: OK.
Let's do it.
ASHLIE MARTINEZ: So to start off with,
we're going to do puppet cert list -all on our master
node that has Puppet Enterprise installed on it.
And as you can see, there's no managed Puppet nodes
on this master.
So now that we know there's no managed nodes,
we're going to apply our manifest file.
And what our manifest is going to do
is it's going to create persistent disks
and instances-- virtual machines in Google Compute
Engine-- and those virtual machines
are going to have Puppet installed on them,
as well as Apache.
We're also going to create a forwarding rule so that we
can direct traffic to our new instances,
and a load balancer that will direct all the traffic that we
point at the forwarding rule across those four instances.
KATHARINA PROBST: Great.
So let's take a little bit of a look at the manifest itself,
and maybe Ryan can help walk us through a little bit of what
this does.
RYAN COLEMAN: Thank you.
So what we're looking at here is Puppet's language, the Puppet
DSL.
And Puppet is all about managing the end state of a machine
that you want to manage.
So you're not setting up a script
in terms of actions that you'd like to complete.
You're telling Puppet how you would like the system
to be configured at the end the day,
and Puppet takes care of all the details in between.
So Puppet can manage everything at the very atomic level,
whether it's a file that you're managing
on your machine, a service that you'd
like enabled, a package you'd like installed.
And that translates to Google Compute Engine module as well.
And so what we're using here for our demo
is several resources that describe a firewall that I'd
like to provision, a health check, target
pool, and forwarding rule that make up the load
balancer we're using for the demo.
And then further down on the page,
we actually have the Google Compute disk and instances
that are running up it and running our operating
systems to provide the demo.
And so this is a very readable, executable documentation
that you can hand to someone else
to describe exactly how things are going to be configured
when Puppet gets a hold of it.
We've managed the Puppet Forge in Google Compute Engine,
and we, in fact, use this module to describe how the Puppet
Forge instances are configured.
And we use the Google Compute load balancer
to split traffic between different zones.
And so we can hand this to someone
who gets started on our team, and they
can take a look at instances and disks
and resources that look just like this, describing
how the Puppet Forge is deployed.
And then they can go down a level deeper
and see how the service is managed
at the very high level and all the way down to the ground
on the individual units that we're
managing on a Puppet node.
And to me, that's one of the best
things about this combination.
KATHARINA PROBST: Yeah, that makes perfect sense.
And under the hood, the way this is implemented, actually,
is it uses Google Compute Engine's public API.
So anybody can call the public API,
and it allows you to do things like you mentioned-- set up
disks, create disks, create instances, set up
forwarding rules, and so forth.
Let's switch back to the demo and see how we're doing there.
So as you can see, the demo is still running.
So let's back up a little bit and just talk a little bit more
generally.
We've already heard a little bit about Puppet.
Let's talk a little bit more about what Google Compute
Engine is and what it does.
I've already mentioned that we have a public API that
allows you to create instances and create disks,
so that already alludes to the fact
that Google Compute Engine is Google's infrastructure
as a service offering.
So we have compute.
We have storage.
So all of the nodes can have disks associated with them,
and that is network storage.
We also have things like networking provisions,
such as the load balancer that we keep hearing about.
And I'm actually super excited to talk about the load balancer
because it is very fast, and it is actually also
consistently fast.
It requires no warm up time.
You don't have to manage any nodes or anything.
It just works.
You set up your forwarding rules,
and you start sending traffic there.
And it can handle a lot of traffic.
It looks like our demo has finished, so why don't we
see what we've created now with Puppet and Google Compute
Engine.
ASHLIE MARTINEZ: So first, what we have to do
is we have to get the IP address of our forwarding rule
so that we can actually send traffic to it.
If we just send traffic to our instance's IPs,
it won't be balanced across all of the instances, which
is why we need this IP address.
KATHARINA PROBST: That's right.
So we are going to, as Ashlie mentioned, we're
going to be sending traffic to that external IP address that
represents a forwarding rule, and then
our load balancer that I keep talking about
will balance the traffic between the nodes.
And as you can see here, with our Puppet manifest,
we've actually installed Apache in a customized web
page on each of the nodes.
And the traffic is balanced between them,
as you can see it bouncing around.
Let's switch back to the slides.
And Ryan, why don't you say a little bit more
about what your experience has been
in working with Puppet and Compute Engine together.
RYAN COLEMAN: Yeah, thank you.
So I think that the demo sort of demonstrates
how these things get put together.
And whenever you describe the instances
that you're going to manage with Google Compute Engine,
we'll automatically build out either a Puppet open source
or Puppet Enterprise master and agent
that you can immediately get started
managing the infrastructure you want on Google Compute Engine.
KATHARINA PROBST: Excellent.
So if you'd like to find out more, on this particular slide,
here are some links that you can follow.
We have a link to the demo where you can find out a little bit
more of the demo we've just shown you,
and it should give you enough information
to actually reproduce it for yourself.
We have some Docs that give you a little bit more information
as well.
And then you can go off and also learn more
about Google Cloud Platform and Puppet Labs,
and hopefully use them both together
in a very productive way.
That's it from here today.
So thank you for watching, and enjoy
using Puppet in Google Cloud Platform.
Bye.
RYAN COLEMAN: Thank you.