Announcing Coherence 2.0 and CNC, the first open source IaC framework
All posts

Google Cloud CI CD: Best Practices

Discover the best practices for setting up efficient CI/CD pipelines with Google Cloud, including organizing source code, automating builds, managing container images, deploying to Cloud Run and GKE, ensuring security, optimizing for scalability and performance, and monitoring applications and infrastructure.

Zan Faruqui
May 16, 2023

Discover the essentials of setting up efficient Continuous Integration (CI) and Continuous Deployment (CD) pipelines with Google Cloud's CI/CD tools like Cloud Build, Cloud Deploy, and Cloud Run. This guide walks you through best practices for structuring your source code, automating builds, managing container images, deploying with confidence, and ensuring your projects are secure and scalable. Here’s a quick overview:

  • Organize Your Source Code effectively for easier management as your project grows.
  • Automate Builds with Cloud Build to save time and ensure consistency.
  • Manage Container Images securely and efficiently.
  • Deploy to Cloud Run and GKE for scalable and reliable application delivery.
  • Ensure Security by encrypting secrets, scanning images for vulnerabilities, and integrating security testing.
  • Optimize for Scalability and Performance by parallelizing builds, caching dependencies, and using Cloud Build’s worker pool.
  • Monitor and Log your applications and infrastructure to quickly identify and address issues.
  • Explore Advanced CI/CD Features in Google Cloud, including custom build steps, managing environment configurations, Infrastructure as Code with Terraform, GitOps workflows, and canary deployments.

This introduction aims to give you a concise overview of the steps and strategies for leveraging Google Cloud CI/CD tools to streamline your deployment process, enhance security, and improve scalability and performance of your applications.

Have a Google Cloud Platform Account

  • First, if you don't have a Google Cloud Platform account, you'll need to create one here.
  • Make sure you can use features like setting up Cloud Build triggers, using Cloud Source Repositories, and running Compute Engine instances. Having the role of roles/editor or roles/owner should cover it.

Understand Core Google Cloud Services

Connect to Source Code Repositories

  • Your app's code should be in a place Google Cloud can reach, like Cloud Source Repositories or GitHub.
  • Learn how to link Cloud Build with your code source so it can start builds when your code changes.

Understand CI/CD Concepts

  • Know the basics of CI/CD, such as what build triggers are, how testing works, where you can deploy your apps, and how to manage your setup and secrets.
  • Familiarize yourself with common ways to run CI/CD pipelines, like automatically pushing updates when you commit code, checking code in pull requests, and using blue-green deployments for safer releases.

With these steps, you're ready to start setting up your CI/CD pipelines using Google Cloud, keeping your projects secure and up to speed.

Best Practices for Efficient CI/CD Pipelines

1. Structuring Your Source Code Repository

To make your source code easy to handle as your project gets bigger, remember these points:

  • Organize your files based on what they do or represent, not just by file types. Put all the code, settings, and other bits for a single part of your project in one place.
  • Keep a special spot for any common code or tools your project uses.
  • Start with a services folder at the root and make a new folder inside it for each part of your service.
  • Put a README file in each folder to explain what it's for.
  • Keep the settings for different environments (like testing or live) separate, and use them as needed.

This way, everything stays neat and makes more sense as you go along.

2. Automating Builds with Cloud Build

Cloud Build lets you automatically create your project whenever you make changes:

  • Link your code repository to Cloud Build. It works with platforms like GitHub and Cloud Source Repositories.
  • Write a cloudbuild.yaml file that tells Cloud Build what to do when you update your code.
  • Set triggers to start builds automatically when you push new code or when someone merges a pull request.
  • Use different tags and options to adjust builds for different situations.

This helps you save time because you don't have to build everything by hand.

3. Efficiently Building and Managing Container Images

When working with containers, keep these tips in mind:

  • Use a building method that creates small images.
  • Keep your images in a safe place like Container Registry.
  • Check your images for any security risks.
  • Make sure only approved images are used.
  • Always use specific image versions for more reliable setups.
  • Set up a way to move images through different stages safely.

These steps help keep your container images safe and easy to track.

4. Deploying to Cloud Run and GKE

Cloud Run

Cloud Run is a simple way to run container apps without worrying about servers:

  • It adjusts automatically depending on how busy your app is.
  • You can slowly introduce changes to see how they perform.
  • Split your user traffic to test different versions.
  • Keep an eye on how your service is doing.

Google Kubernetes Engine

For managing apps with GKE:

  • Use tools like Terraform to set up your infrastructure.
  • Have different environments for development, testing, and live.
  • Use GitOps to keep your configurations up to date.
  • Watch your spending and how much you're using.

Automating how you send out your apps to GKE and Cloud Run makes things faster and simpler.

Security Practices

Keeping your code and software safe is super important, especially when you're constantly updating things. Here are some straightforward ways to make sure your projects are secure:

Encrypt Secrets and Manage Access

  • Always encrypt sensitive stuff like passwords or secret keys. Use tools like Secret Manager to keep them safe.
  • Give the least amount of access needed to the accounts that run your CI/CD jobs. This means they can only touch what they absolutely need to.
  • Turn on two-step verification for extra security on your code repositories and cloud accounts.

Scan Images for Vulnerabilities

  • Set up your Cloud Build to check for security issues in your container images with tools like Trivy. If it finds big problems, don't let the build pass.
  • Think about using Binary Authorization to make sure only safe, checked images get to production.

Integrate Security Testing

  • Include tests for security weaknesses early in your process. Use tools to look for vulnerabilities in your code and infrastructure.
  • If these tests find serious issues, stop the build from going any further.

Practice Defense in Depth

  • Use multiple security layers everywhere – in your pipeline, the infrastructure, and in the software itself. Prepare as if attacks are going to happen.
  • Techniques like blue-green deployments and using the least privilege can help make your system tougher to breach.

Monitor and Audit Everything

  • Keep track of all actions and changes in your pipeline and infrastructure. Send these logs to a system that can analyze them.
  • Set up alerts for any weird activity and regularly check your logs to stay on top of security.

By adding these security steps into your Google Cloud CI/CD pipelines, you can keep your software updates rolling out smoothly and safely, knowing you've got strong protections in place.

Scalability and Performance Optimization

When your CI/CD pipelines and setup start to grow, it's important to make sure everything still runs smoothly and can handle more work. Here's how to keep things efficient even as they get bigger:

Parallelizing Builds

  • Break up your build process so multiple steps happen at the same time. This means doing things like testing, making artifacts, and pushing images all at once, which can save a lot of time.
  • In your cloudbuild.yaml, there's a concurrency setting you can use to control how many jobs run at once. If too many run at the same time, it might be too much for your system.
  • If you have a lot of tests, split them into different groups that can run at the same time. This can make the whole testing process faster.

Caching Dependencies Between Builds

  • Keep track of things like dependencies and compiled stuff from previous successful builds.
  • Put a step early in your build to check if you can use stuff that's already been made, so you don't have to start from scratch every time.
  • This can make your builds go faster because you're not redoing work.

Scaling Cloud Build Worker Pool

  • You start with 200 workers in Cloud Build, but you can ask for more if you need them.
  • Keep an eye on how long builds take to see if more workers would help spread out the work.
  • Having more workers can help reduce waiting time for builds to start when there's a lot going on.

Optimizing Container Builds

  • Use a special way of building containers that keeps the final image size small. Only move the really important parts from the building stage to the final image.
  • Skip any packages you don't need and use small base images like Distroless and Alpine.
  • Buildpacks can also help make your container builds better suited to what your app needs without extra stuff.

Horizontal Scaling and Load Balancing

  • Add more resources side by side to handle more traffic without slowing down.
  • Use services like Cloud Run and Cloud Load Balancing that automatically adjust to handle more users.
  • Set rules for when to add more resources based on things like how much traffic you're getting or how much CPU you're using.

Following these tips can help keep your CI/CD pipelines quick and ready to grow. Always be on the lookout for slow spots to fix.

Monitoring and Logging

Keeping an eye on your apps and recording what happens is super important for making sure they run smoothly, quickly, and safely. By watching over certain metrics and logs, teams can spot problems early, figure things out faster, and make their apps work better.

Importance of Monitoring and Logging

Here's why keeping track of everything matters:

  • Spot problems fast - By watching things in real-time, you can catch issues early and fix them before they get big.

  • Find out what went wrong - Having detailed records of what your system and apps have been doing makes it easier to understand why something didn't work.

  • Make things run better - Seeing how your app uses resources can help you find and fix slow parts.

  • Stay on the right side of the law - Keeping logs of certain actions helps with security and following rules.

  • Don't waste money - Watching how much you're using helps you not pay for more than you need.

  • Make smart choices - Looking at trends and how your app is used can guide your plans and improvements.

Utilizing Google Cloud's Monitoring and Logging Tools

Google Cloud has some great tools for keeping an eye on things and keeping records:


  • Cloud Monitoring - Tracks how much you're using and the health of your app, and lets you know if something's off.

  • Cloud Debugger - Lets you peek into a running app to spot issues without stopping it.

  • Cloud Trace - Helps you figure out why your app might be slow by looking at where time is being spent.


  • Cloud Logging - Keeps and lets you look through records of what your app and system have been doing.

  • Cloud Audit Logs - Keeps track of who did what, which is great for security and rules.

  • Cloud Error Reporting - Finds and groups errors in your app so you can fix them.

Best Practices

  • Add monitoring and logging to your app - Make sure your app can track its own health and keep logs right from the start.

  • Use tags - Tags help organize and find metrics, logs, and resources easier.

  • Make your own dashboards - Create screens that show your most important metrics and logs the way you like.

  • Set up alerts - Get notified quickly about important or urgent issues.

  • Think about storage - Decide how long to keep logs and metrics in a way that makes sense cost-wise.

  • Keep checking - Regularly look through your logs with tools like BigQuery to spot patterns or issues and find ways to improve.

By sticking to these simple practices for monitoring and logging on Google Cloud, teams can keep their apps running well, safely, and without wasting resources.


Advanced CI/CD Features in Google Cloud

Custom Build Steps

Cloud Build lets you add your own steps to the build process:

  • You can use the steps section in cloudbuild.yaml to run your own scripts, install software, and do more during the build.
  • Add steps for security checks, integration tests, or updating docs.
  • Create your own images with tools like Packer that have everything set up the way you need.
  • You can also add tools like Terraform, Ansible, Puppet, Chef, or Jenkins into your build steps.

Adding your own steps ensures your builds do exactly what you need.

Managing Environment Configurations

It's normal to have different settings for development, staging, and production:

  • Keep your environment configs in a folder named env in your repo.
  • In cloudbuild.yaml, use substitutions to use the right settings for each environment.
  • With Config Connector, your configs can automatically update in Cloud Runtime Config.
  • Config Connector can also help switch settings when moving services between environments.

Having separate settings for each environment helps avoid mix-ups and makes management easier.

Infrastructure as Code with Terraform

Terraform allows you to manage your infrastructure with code:

  • Write down your infrastructure setup, like GCP projects and Kubernetes clusters, in Terraform files.
  • Keep these files in your repo so everyone can work on them together.
  • Use Terraform in your CI/CD pipelines to create and take down environments as needed.
  • This helps make sure your environments stay consistent and saves resources.

This method keeps your setup tidy and efficient.

GitOps Workflows

GitOps means using Git to manage your infrastructure and apps:

  • Store your desired setups in Git as code.
  • An automated process makes sure your actual setup matches what's in Git.
  • Make changes through merge requests and let CI/CD pipelines handle the updates.
  • It's great for managing Kubernetes setups, infrastructure, and app configurations.

GitOps makes management simpler by using Git, something many are already familiar with.

Canary Deployments

Canary deployments introduce new releases to just a few users first:

  • Send a little bit of traffic to the new version to see how it does.
  • Cloud Run makes it easy to split traffic this way.
  • If everything works well, slowly send more traffic to the new version.
  • If there are problems, quickly go back to the older version.

This approach makes updating less risky.

Using these advanced features can really improve your Google Cloud CI/CD pipelines.


Getting your CI/CD pipelines right with Google Cloud might seem a bit complex at first, but sticking to these guidelines can make things much smoother.

Here's a quick recap:

  • Keep your code organized and start using tools like Cloud Build and Container Registry from the get-go. This lays down a strong base.
  • Make sure to automate your builds, scan your images for security issues, limit who can access production, and keep a close eye on everything. Starting with security in mind is key.
  • Speed things up with jobs that run at the same time, save time by reusing work from previous builds, and use auto-scaling to handle more work when needed. Keep an eye on how things are running to spot and fix slow spots.
  • Write down a lot of logs, set up alerts, and check on things often. This helps you keep improving.
  • Look into extra features like adding your own steps to the build process, managing your setup with code using Terraform, and trying out canary deployments. These can make managing everything a bit easier.

The best approach is to start simple and build from there. As your project grows, think about what changes could help your team work better. And it's okay to try new things. The tools are designed to change and grow with you.

By following the advice from Google, teams can really change how they develop software. The time and effort saved are great, but the real win is how much more you can do and how much better your work can be in the long run.


Here are some handy guides and tools from Google Cloud to help you with your CI/CD pipeline setup:

Cloud Build Documentation

Container and Kubernetes Resources

Infrastructure as Code Tools

Example Configurations

Basic cloudbuild.yaml


- name: ''
  args: ['build', '-t', '$PROJECT_ID/my-image', '.']

- name: ''
  args: ['push', '$PROJECT_ID/my-image']
- name: ''
  args: ['run', '--image', '$PROJECT_ID/my-image', '--cluster', 'my-cluster', '--location', 'us-central1-a', 'my-app']

- '$PROJECT_ID/my-image'

Build triggering on GitHub push

  - github

  - ...

These examples show some basic ways to set up CI/CD with Cloud Build. For more detailed examples and help, check out the documentation.

What are the best practices for cicd?

Here are some important tips for CI/CD:

  • Regularly update your code to get feedback quickly and fix things early.
  • Make container images once and then use them in different places without changing them.
  • Use the same pipeline setup across projects to avoid doing the same work twice.
  • Start with security in mind by checking for vulnerabilities and managing who can do what.
  • Make testing a big part of every stage to catch issues.
  • Speed up your builds by using caching, running jobs at the same time, and making your images as small as possible.
  • Set up testing environments quickly when you need them.
  • Pick tools that fit well with your team's needs.

What CI CD tool is used in Google?

Google Cloud has its own tools like Cloud Build, Cloud Deploy, and Cloud Run for deploying apps. You can also use other popular tools like Jenkins or GitLab CI with Google Cloud for more options and to use Google's powerful infrastructure.

Which is a best practice for continuous integration?

Good practices for continuous integration include:

  • Set up pipelines for quick changes.
  • Follow guidelines for making good container images.
  • Test your images thoroughly for any problems.
  • Put security checks early in your process.
  • Use GitOps to manage your setups and apps more easily.
  • Move images through different environments without changing them.
  • Try out canary releases for safer updates.

What is the difference between Google Cloud build and Jenkins?

Google Cloud Build and Jenkins differ mainly in:

  • Where they run: Cloud Build is managed by Google Cloud, and Jenkins is something you set up yourself.
  • Infrastructure: Cloud Build scales automatically, but with Jenkins, you need to set up your own servers.
  • How they're set up: Cloud Build uses YAML files, while Jenkins has its own setup language and plugins.
  • Cost: Cloud Build charges based on use, and Jenkins is free but you manage it yourself.
  • Help and support: Cloud Build comes with support from Google, but Jenkins has a community for help.

Basically, Cloud Build takes care of a lot of the setup for you, while Jenkins gives you more control to customize things.

Related posts