[MUSIC PLAYING]
WILLIAM DENNISS: I'm William Denniss, a product manager
for GKE Autopilot.
I'm excited to introduce a new mode of operation
for Google Kubernetes Engine that we think you will like.
If you're new to Kubernetes, it's the industry-standard way
to deploy and manage application containers,
making it efficient to develop and publish
internet-based applications.
GKE was the first managed Kubernetes service
to the market over five years ago and remains the most
scalable and reliable platform, with an industry-leading
15,000-node capability.
And it's brought to you by a team that
makes more technical contributions to the Kubernetes
project than any other company.
Kubernetes gives you a container application platform
on which to run your services.
But what does it actually take to run this platform?
There's quite a lot of aspects, from the control plane,
provisioning, and management, to worker node
creation and patching.
Since its launch, GKE has taken care of most of these elements
for you.
But there are a couple of things that were still
your responsibility, like configuring and managing
node pools.
We figured out what you really care
about most is running your own applications and services
on GKE, and not the configuring and monitoring of the computer
they run on.
So we looked at what more we could do to help.
That's why I'm happy to introduce
GKE Autopilot, a new mode of operation for GKE.
With Autopilot, the node configuration and management
is now our responsibility, as well,
so you can focus more on your own applications and services
that run on top.
With Autopilot, everything is autoprovisioned.
All you need to do is name the cluster, pick a region,
set the network, and deploy your workload with Kubernetes.
And once things are provisioned, Google
is responsible for managing the nodes and keeping them running.
When it comes to the bill, you pay for pods and not VMs.
Let me drill into each of these a little further.
I mentioned that with Autopilot, we have
autoprovisioned everything.
What this means in practice is that your pod and deployment
configuration is also the complete cluster specification.
We provision compute resources based on the resource
needs you specify in your pod spec.
There's minimal cluster setup, with no need
to figure out what size and shape of nodes
should be provided for your workloads.
We also apply all the latest security best practices
automatically.
You've already been able to offload many cluster
operational responsibilities to Google,
and now this applies to nodes, as well.
And since we're now managing the nodes,
they're more locked down, which also
serves to prevent accidental or intentional modifications that
can cause issues.
Even with us managing everything,
you can still use features like maintenance windows and pod
disruption budgets to govern how and when updates occur.
In fact, we're so confident of our management
of this new platform, that we're offering a pod-level SLA
in GKE for the first time.
This SLA offers three nines of uptime for pods
running in multiple zones.
The other major difference is how you're billed.
Since you now specify your resources at a pod level,
that's how you're billed, as well.
Your pods are billed per second for vCPU, memory, and disk
resource requests.
System components, the operating system overhead,
and, most importantly, unused capacity,
is no longer your concern.
Once you scale a workload down, the associated charges
cease immediately.
GKE's free tier includes Autopilot,
giving you one free zone or Autopilot cluster.
So you can give it a try and just pay for the pods
you deploy.
Despite being fully managed, GKE Autopilot
is still GKE and supports nearly the full gamut
of workload capabilities.
Workloads requiring StatefulSet and even DaemonSet
are supported at launch, and more support is on the roadmap.
We think you shouldn't have to compromise
when it comes to your Kubernetes application platform
and built Autopilot with that in mind.
From the outset, we said to ourselves
that Autopilot is GKE, and we want you to hold us to that.
Popular administrative workloads from our partners,
in areas like logging and monitoring,
are either supported now or on the roadmap.
Basically, the only workloads we don't
expect to be compatible with this new mode of operation
are custom administrative workloads that
might be used for low-level node management tasks,
exactly the kind of thing which we hope
won't be needed in Autopilot.
And one more thing--
we've actually been running a private preview
for a few months, and I'm pleased to announce
that Autopilot is launching as generally available and ready
for your production workloads.
With that, I'd like to take you through a quick demo of what
Autopilot can do.
[MUSIC PLAYING]
To create an Autopilot cluster, all you need to do
is give it a name, pick your favorite region,
and set the network, if you have any particular networking
requirements.
In my case, I'll leave the network as the default Public
cluster and click Create.
Creation takes a couple of minutes,
so let me switch to one I've created earlier.
To connect to this cluster, I click the Connect button
and copy the connection command to my clipboard.
Now, from the command line, I'll paste that command
to authenticate kubectl so it can access the cluster.
The demo I'm going to deploy today
is from the GKE sample repository.
So let's clone that repository from GitHub
and change into the sample directory.
Finally, I'm going to apply the Kubernetes configuration
of the guestbook sample.
Now, this sample consists of a PHP frontend
with a Redis backend.
If you've deployed Redis before, you'll
be aware it does have a few resource requirements.
In the past, you may have had to configure your node pools
to ensure that they have enough capacity.
But with Autopilot, we do that for you.
This takes about a minute to provision,
so I'm just going to skip ahead.
[MUSIC PLAYING]
Let's go ahead and grab the IP address of this sample
application and check it out.
So I pasted that IP address into my browser, loaded it up,
and I can give it a quick test.
And that was Autopilot.
With the introduction of Autopilot,
GKE is now available in two modes of operation, standard
and Autopilot.
Standard is the experience that we've
been building since the launch of GKE,
where you have full control over the nodes
with the ability to finetune things
to your heart's content--
for example, running custom administrative workloads--
and even tweaking the node operating system itself.
Autopilot is a hands-off, fully-managed solution
that empowers you to focus on your workloads
while we take care of the rest.
Both modes of operation are generally available and fully
supported by Google Cloud, so please choose whichever
best suits your needs.
To learn more about Autopilot, please follow this link
to g.co/autopilot.
[MUSIC PLAYING]