In today's fast-paced development cycle, automation is not just a luxury but a necessity. Integrating DevOps tools like with cloud platforms such as Google Cloud Platform (GCP) can significantly streamline application deployment processes. This guide aims to walk you through the steps to set up a seamless deployment pipeline using for your applications on GCP, ensuring faster delivery and consistent deployments.


Setting up CI/CD Pipeline

Before we get started with this guide, install the GCP GKE Pulumi Py workflow from: If you don't have access to the repository, kindly contact us at [email protected]

The repo includes a complete IaC for deploying infrastructure over GCP: Kubernetes, Container Registry, Database Clusters, Load Balancers, and Project Resource Management, all built using Python + Pulumi +

Build Pipelines locally, and Set up your Infrastructure with the CLI

  • In your terminal, enter the ops build . command and select the sample-app-gcr-pipeline. This ops build . command will build your GKE ad GCP workflow, your Docker image from your Dockerfile, and the set of files located in the specified path you created in your source code.

  • When the image is built, it's going to create an image ID and successfully tag it in your console.
  • Next, you need to build and set up the infrastructure that will deploy each resource to GCP using the Pulumi Python framework. Set up your infrastructure using ops run -b . This will provision your stack using Pulumi
  • Select setup Infrastructure over GCP
  • Select your environment, and install the dependencies and services required for your build.
  • After configuring and setting up your GCP infrastructure, you can configure your sample app and set up CI/CD pipelines on it. Your sample app CI/CD config will be configured in the ops.yml file.
version: "1"
  - name: sample-expressjs-pipeline-gcp-gke-pulumi-pyf:0.1.1
    description: Build and Publish an image in a GCPContainer Registry
        - DEBIAN_FRONTEND=noninteractive
        - STACK_TYPE=gcp-gke-pulumi-py
        - ORG=cto-ai
        - GH_ORG=workflows-sh
        - REPO=sample-expressjs-gcp-gke-pulumi-py
        - BIN_LOCATION=/tmp/tools
        - GITHUB_TOKEN
        - PULUMI_TOKEN
      - "github:workflows-sh/sample-gcp-gke-pulumi-py:pull_request.opened"
      - "github:workflows-sh/sample-gcp-gke-pulumi-py:pull_request.synchronize"
      - "github:workflows-sh/sample-gcp-gke-pulumi-py:pull_request.merged"
      - name: sample-expressjs-build-gcp-gke-pulumi-py
        description: Build step for sample-expressjs-gcp-gke-pulumi-py
          - git
          - unzip
          - wget
          - tar
          - mkdir -p $BIN_LOCATION
          - export PATH=$PATH:$BIN_LOCATION
          - ls -asl $BIN_LOCATION

CI/CD Pipeline Explanation

  • version: Specifies the version of the CI/CD configuration. It's set to 1.
  • pipelines: A list of pipelines that are defined in this configuration.

Within the pipelines:

  • name: The name of the pipeline: sample-expressjs-pipeline-gcp-gke-pulumi-pyf:0.1.1.
  • description: A brief description indicating that the pipeline is designed to "Build and Publish an image in a GCP Container Registry."
  • env: Environment variables that will be available during the execution of the pipeline.
  • DEBIAN_FRONTEND=noninteractive: This is often used in Dockerfiles for Debian/Ubuntu-based images to ensure that package installations don't ask interactive questions.
  • STACK_TYPE=gcp-gke-pulumi-py: Indicates the stack type being used is gcp-gke-pulumi-py.
  • ORG=cto-ai: The organization is set to cto-ai.
  • GH_ORG=workflows-sh: The GitHub organization for this pipeline is workflows-sh.
  • REPO=sample-expressjs-gcp-gke-pulumi-py: The repository name.
  • BIN_LOCATION=/tmp/tools: Binary location directory.
  • GITHUB_TOKEN: A secret token for GitHub authentication.PULUMI_TOKEN: A secret token for Pulumi, an infrastructure as code tool.
  • events: Events that trigger this pipeline:
  • pull_request.opened: When a pull request is opened in the specified GitHub repository.
  • pull_request.synchronize: When new commits are pushed to the pull request.
  • pull_request.merged: When the pull request is merged.

Building and Publishing Your Workflow

When you are done, you can build and publish your workflow to the CTO registry using the ops build . and ops publish . commands. When the workflow is built, you can trigger your pipelines using the event triggers configured in your ops.yml file, and you can also view your Pipeline logs in GitHub and the dashboard.

Setting up your first pipeline for deployment to Google Cloud Platform (GCP) offers several significant benefits:

  • Automated Deployments: Automating the deployment process reduces human errors, ensures consistent deployments, and speeds up the software delivery process.
  • Integrated Toolchains: By combining with GCP, you're bridging two powerful platforms, allowing for integrated DevOps practices that utilize the strengths of both.
  • Scalability: GCP, being a cloud platform, provides scalability options that can be easily managed and triggered through pipelines, ensuring that your application can handle varying loads.
  • Efficiency: Automation pipelines reduce the manual overhead in the deployment process. This means faster iterations, quicker releases, and reduced time to market for features and bug fixes.

Conclusion provides a seamless experience for automating complex workflows. By integrating it with GCP, we can simplify the deployment process, reduce human errors, and speed up software delivery. With the foundational knowledge from this guide, you can further customize and expand your workflows to cater to various GCP scenarios and application needs.