ALEXIS MOUSSINE-POUCHKINE:
Serverless is much more than a buzzword. And in this episode
of "GCP Essentials," you'll understand how
Google Cloud Platform makes serverless work for you. [MUSIC PLAYING] If you look back, most of the
early days of Google Cloud focused on what could be called
a serverless offering, as we've implemented and offered
products with this fundamental principle. You give us your code. We do the rest. There are no servers to manage
and no cluster to set up, provision, or upgrade. In addition, the
infrastructure autoscales to meet the load demand,
and you are only billed for the resources consumed. As a developer building
web apps, mobile APIs, or back-end services,
this is your ability to focus on the business
logic of your apps. GCP offers a number
of different products to help you accomplish
exactly what you need. Let's take a look. Functions as a Service, or
FaaS, is a very popular approach to serverless compute. Developers write
a piece of code-- a function-- that is
triggered on an event or on an incoming HTTP request. This function code can talk to
a database and to other services before it generates
itself another event or simply sends a response back. Google Cloud Functions supports
multiple programming languages, such as Python, Node.js,
Go, Java, and more to come, and these can be used with
a large set of libraries and frameworks. Simply deploy your
function along with its list of dependencies,
which will be resolved directly in the cloud, and
configure the event that will trigger its execution. This can be an HTTP
event, of course, but also a file upload to
a Cloud Storage bucket, data changing in a
database, a message being posted to a
pub/sub queue or topic, or several other events. Functions can be assigned deploy
time environment variables. They can be deployed to
any and multiple regions from a single project,
and they support up to several gigabytes of memory. Functions can also be configured
with specific security constraints, such as
least privilege access with per function identity. You can even use the Compute
metadata server to fetch identity tokens at runtime. Cloud Functions are billed
by the number of invocations, the compute time, and the
outgoing network, or egress, with free first 2 million
invocations every month. Cloud Functions are
probably the easiest way to access one of the many
powerful GCP services, from machine learning APIs to
other storage and processing solutions that have been used
by customers to implement everything from
glue code to fully fledged microservices-based
applications. Now, as a developer,
you may want even more freedom in the
languages and frameworks that you use. And most importantly,
you may rather want to hand over a carefully
crafted Docker container image instead of source code. Cloud Run is here to offer you
a true serverless experience, if a stateless HTTP
container image is what you'd like to use. Simply build the image,
upload it to Cloud Registry, and create a Cloud Run
service using that container. Your app is now deployed
and running in the cloud. And you can forget about
provisioning or managing servers. Cloud Run does that for you. It automatically and
quickly scales up and down based on your incoming traffic,
and even scales down to zero. You pay only for the resources
that your app uses down to the nearest
100th millisecond. Because Cloud Run is
built with Knative, you can use it with your own
Kubernetes Engine cluster, too. With Cloud Run on GKE,
you can build and deploy apps to your own
Kubernetes cluster with the same easy
experience and benefits. Whether running on
GKE or not, Cloud Run supports deploying multiple
services in a single GCP project, either in
multiple regions or in specific namespaces
when running in a GKE cluster. Each service exposes
a unique endpoint. Each service deployment
creates a revision, and requests are
automatically routed as soon as possible to the latest
healthy service revision. Finally, each revision
receiving requests is automatically
scaled to the number of container instances needed
to handle all these requests. Note that a given
container instance can receive multiple
requests at the same time. With the concurrency
setting, you can set the maximum
number of requests that can be sent in parallel
to a given container instance. Cloud Run essentially
gives you the flexibility of modern container-based
development with all the benefits of a
fully serverless environment, autoscaling to your
application's needs. If you are building an
entire web application with multiple services
and would still like to deploy source code while
preserving all the serverless benefits, you should check
out Google App Engine. App Engine has
recently celebrated its 10th anniversary,
and is where you'll find Google Cloud
Platform's serverless routes. App Engine is a
managed platform that lets you pick a language
you're most comfortable with. Simply run gcloud app
deploy, and App Engine will take care of
uploading your code and running it on
Google's infrastructure. The second-generation App Engine
runtimes, available for Java, Node, PHP, Go, and Python, offer
a truly idiomatic experience with the ability to use any
language API and any framework with read/write file system
access and with isolation provided by gVisor-- a powerful open-source
sandbox technology. App Engine applications
can be built using multiple
services, each of which can use different languages and
can be scaled independently. Each service can offer
multiple versions, all active at the same time,
and it is trivial for you to set up staged rollouts or A/B
testing across these versions with traffic splitting. App Engine takes out-of-the-box
tooling one step further with full app performance
management tools available, such as live debugging
of production apps, tracing of requests
flowing across your system, and even CPU and heap
profiling of your app. Google App Engine is a mature
serverless platform and not your father's
platform as a service. Modern and more
advanced applications can be written with a
combination of Cloud Functions, App Engine, and Cloud Run. And both Cloud Pub/Sub
and Cloud Tasks are popular and
elegant solutions for integrating these
different parts, or even simply to combine
multiple functions. Cloud Pub/Sub is a simple,
reliable, and scalable event system, offering
many-to-many asynchronous messaging that nicely decouples
senders and receivers. It supports
at-least-once delivery and is global by default with
no infrastructure to manage. Just publish and consume
up to hundreds of millions of messages per second. Cloud Tasks, on the other
hand, offers a dispatch system to manage the execution of large
numbers of distributed tasks. It is ideal for one-to-one
asynchronous messaging and comes with rate
limit controls. Finally, Cloud Scheduler is a
fully managed cron job service, enabling you to
schedule tasks that are invoked through HTTPS
endpoints, Cloud Pub/Sub topics, or App
Engine applications. It's remarkably simple and yet
incredibly powerful to use. Check it out. All of these solutions
briefly discussed here are fully
managed and monitored. Logging and error reporting
are just built in. With GCP serverless, you give us
your code in whichever artifact you prefer-- a function, an application,
or a container image-- and we'll run it for you. Consider taking free codelabs
linked in the description below to explore these products,
and look forward to upcoming episodes and more overviews. If you liked this video, please
like, subscribe, comment, and share. See you soon for another
"GCP Essentials" video. [MUSIC PLAYING]
