Cloud Deploy with Cloud Run

Google Cloud Deploy is a service to continuously deploy to Google Cloud Application runtimes. It has supported Google Kubernetes Engine(GKE) so far, and now is starting to support Cloud Run. This post is about a quick trial of this new and exciting support in Cloud Deploy.

It may be simpler to explore the entire sample which is available in my github repo here — https://github.com/bijukunjummen/clouddeploy-cloudrun-sample

End to end Flow

The sample attempts to do the following:

A Cloud Build based build first builds an image. This image is handed over to Cloud Deploy which deploys to Cloud Run. A “dev” and “prod” target is simulated by the Cloud Run applications having names prefixed with the environment name.

Building an image

There are way too many ways to build a container image, my personal favorite is the excellent Google jib tool which requires a simple plugin to be in place to create AND publish a container image. Once an image is created, the next task is to get the tagged image name for use with say a Kubernetes deployment manifest.

Skaffold does a great job of orchestrating these two steps, creating an image and rendering the application runtime manifests with the image locations. Since the deployment is to a Cloud Run environment, the manifest looks something like this:

Now, manifest for each target environment may look a little different, so for eg in my case the application name targeted towards dev environment has a “dev-” prefix and for prod environment has a “prod-” prefix. This is where another tool called Kustomize fits in.

Kustomize is fairly intuitive, it expresses the variations for each environment as a patch file, so for eg, in my case where I want to prefix the name of the application in the dev environment with a “dev-”, the Kustomize configuration looks something like this:

So now we have 3 tools:

1. For building an image — Google Jib
2. Generating the manifests based on environment — Kustomize
3. Rending the image name in the manifests — Skaffold

Skaffold does a great job of wiring all the tools together, and looks something like this for my example:

Deploying the Image

Let’s come to the topic of the post, about deploying this image to Cloud Run using Cloud Deploy. Cloud Deploy uses a configuration file to describe where the image needs to be deployed, which is Cloud Run in this instance and how the deployment needs to be promoted across environments. The environments are referred to as “targets” and look like this in my configuration:

They point to the project and region for the Cloud Run service.

Next is the configuration to describe how the pipeline will take the application through the targets:

This simply shows that application will be first deployed to the “dev” target and then promoted to the “prod” target after approval.

The “profiles” in the each of the stages show the profile that will be activated in skaffold, which simply determines which overlay of kustomize will be used to create the manifest.

That covers the entire Cloud Deploy configuration. The next step once the configuration file is ready is to create the deployment pipeline, which is done using a command which looks like this:

gcloud deploy apply --file=clouddeploy.yaml --region=us-west1

and registers the pipeline with Cloud Deploy service.

So just to quickly recap,

• I now have the image built by Cloud Build,
• the manifests generated using skaffold, kustomize, and
• a pipeline registered with Cloud Deploy

the next step is to trigger the pipeline for the image and the artifacts, which is done through another command, which is hooked up to Cloud Build:

gcloud deploy releases create release-$SHORT_SHA --delivery-pipeline clouddeploy-cloudrun-sample --region us-west1 --build-artifacts artifacts.json

This would trigger the deploy to the different Cloud Run targets — “dev” in my case to start with:

Once deployed, I have a shiny Cloud Run app all ready to accept requests!

This can now be promoted to my “prod” target with a manual approval process:

Conclusion

Cloud Deploy’s support for Cloud Run works great, it takes a familiar tooling with Skaffold typically meant for Kubernetes manifests and uses it cleverly for Cloud Run deployment flows. I look forward to more capabilities in Cloud Deploy with support for Blue/Green, Canary deployment models.

Originally published at http://www.java-allandsundry.com.