Hello, cloud gurus and welcome to another episode of GCP this month.
I'm Mattias Andersson.
And we're going to take a look at this month's announcements,
including Managed Service for Prometheus,
several things becoming generally available,
faster container start on GKE and more. But before we do that,
I want to make sure you didn't miss what happened last month.
If you did be sure to check out our coverage of Google cloud next 2021,
where Joe Lowery,
Broadus Palmer and I recapped all of the cool stuff that got announced then,
such as Google distributed cloud, BigQuery Omni going GA,
GCP Spark support and vertex AI workbench.
But even with all that great stuff from the conference,
Google has still managed to rustle up more goodies this month.
So let's dive into those.
[Inaudible].
It's time for our quick bites.
Let's start with some things that have just become generally available.
First up cloud domains is Google's top level domain registration product in
Google cloud.
And I told you about it when it first went into preview in February,
but I am now happy to report that they've made cloud domains generally
available. And not only that,
they have also added support for importing domains.
So that limitation that I previously mentioned will limit you no more.
And of course it still supports the other stuff it used to such as DNSsec and
programmatic control.
Another thing that has become generally available is BigQuery table snapshots.
Now you can keep historical records longer than the seven days that BigQuery
time travel gives you and these snapshots are stored as deltas.
So you only get charged when data in the base table is changed or removed.
Another thing newly GA is vertex pipelines.
Google's vertex family of products is all about machine learning or ML.
And the pipeline is a serverless way to implement MLops.
So you define your pipeline using either kubeflow pipelines or TensorFlow
extended,
both open-source libraries and Google will take care of everything to turn it
into a usable model and predictions. Now in public preview,
Google Cloud Managed Service for Prometheus makes it Google's job to
manage the Prometheus stack to monitor GKE stuff, instead of ours.
A lot of people use Prometheus for Kubernetes monitoring.
So this is a very welcome service. Now,
if you are using or considering using Google's memorystore for Redis product,
you will be happy to hear that they have just added support for a read replica
in preview. You can attach up to five read replicas to each instance,
meaning that you could potentially support six times as many reads as before.
Distributed systems are complicated beasts.
So I'm quite happy about this next announcement.
Now all of the spans you log from the various parts of your system will be
connected together directly in the Cloud Logging Logs Explorer.
This makes for way easier debugging with distributed tracing like this and
who in their right mind wants debugging to be harder than it needs to be. Right?
So if you aren't already,
you need to be using structured logging for your own sanity.
There's a lot of goodness here.
So check out the blog posts I'll link about this.
Now let's drill into this month's gem. Earlier on in this episode,
I mentioned some things that just became generally available,
but there's one more that I wanted to dig into a bit deeper.
Google Kubernetes engine can now start containers up much more quickly than
before now. Google calls this feature image streaming,
and it's all about how the container image can be streamed from artifact
registry to GKE just in time as its various bits of data are needed.
In the case of a tiny little container image, this makes no difference really.
The tiny amount of data is sent all at once and GKE runs the container like
normal, but as the container grows, which definitely happens in the real world,
then this feature comes into play. About this Google writes,
Image Streaming works by mounting the container data layer in containerD using a
sophisticated network mount and backing it with multiple caching layers on the
network in memory and on disk,
your container transitions from the image pulling status to running in a couple
of seconds, regardless of container size.
Once we prepare the image streaming mount.
This effectively parallelizes the application boot with the data transfer of
required data in the container image. As a result,
you can expect to see much faster container boot times and snappier auto-scaling
and who wouldn't want that, right?
Especially because they reassure us image streaming is completely transparent.
As far as your containerized application is concerned.
Now the only catch to this and you may already have caught it if you were paying
close attention,
is that GKE image streaming relies on Google's artifact registry product.
If you're still using the older container registry,
then this may be the push you need to make the move. Well, all right.
Lots of great stuff this month, as I'm sure there will be next month too,
but between now and then, why don't you check out our A Cloud Guru Free Plan offering
where you don't even need to enter any payment information but you still get free access
to a rotating set of our high quality courses every month.
Until next time stay safe and keeping awesome cloud gurus.