GCP Professional Cloud Developer Exam Study Guide

GCP Professional Cloud Developer Prep.

Preparing for the GCP Professional Cloud Developer exam? Don’t know where to start? This post is the GCP Professional Cloud Developer Certification Study Guide (with links to each objective in the exam domain).

I have curated a detailed list of articles from the Google documentation and other blogs for each objective of the Google Cloud Platform Professional Cloud Developer exam. Please share the post within your circles so it helps them to prepare for the exam.

GCP Professional Cloud Developer Course

Pluralsight (Learning Path)Develop Applications with Google Cloud
Coursera (Specialization)Google Cloud Design, Develop apps
UdemyGCP Developer Professional Certification

GCP Professional Cloud Developer Practice Test

Whizlabs Exam QuestionsGCP Cloud Developer Tests (120 Qs)
Udemy Practice TestsTest your knowledge GCP Cloud Developer

GCP Professional Cloud Developer Other Material

Udacity (Nanodegree)Become a Cloud Developer
LinkedIn LearningCloud developer (Learning Path)
Amazon e-book (PDF)Google Cloud Developer Exam Guide

Check out all the other GCP certificate study guides

Full Disclosure: Some of the links in this post are affiliate links. I receive a commission when you purchase through them.

Section 1: Designing highly scalable, available, and reliable cloud-native applications

1.1 Designing high-performing applications and APIs. Considerations include:


What is Microservices architecture?

Microservices architecture on Google App Engine

Microservices on GCP simplified

Scaling velocity characteristics/trade-offs of IaaS (infrastructure as a service) vs. CaaS (container as a service) vs. PaaS (platform as a service)

A “Hello, world” web application on GCP

Geographic distribution of Google Cloud services (e.g., latency, regional services, zonal services)

Geography and regions

Global, regional, and zonal resources

Defining a key structure for high-write applications using Cloud Storage, Cloud Bigtable, Cloud Spanner, or Cloud SQL

Schema design best practices in Cloud Bigtable

Schema design best practices in Cloud Spanner

User session management

Managing sessions with external identities

Caching solutions

Caching data with Memorystore

Deploying and securing API services

Deploying the API backend

Securing an API key

Loosely coupled asynchronous applications (e.g., Apache Kafka, Pub/Sub)

Loose coupling and improved developer agility

Use Pub/Sub as a cloud monitoring notification channel

Graceful shutdown on platform termination

Graceful shutdowns on Cloud Run

Kubernetes: Terminating with grace

Google-recommended practices and documentation

Best practices for enterprise organizations

1.2 Designing secure applications. Considerations include:

Implementing requirements that are relevant for applicable regulations (e.g., data wipeout)

Data deletion on Google Cloud

Deleting your data in Google Cloud Platform

Security mechanisms that protect services and resources

How Google infrastructure security layers power GCP & Services?

GCP security services

Security mechanisms that secure/scan application binaries and manifests

Container scanning

Storing and rotating application secrets and keys (e.g., Cloud KMS, HashiCorp Vault)

Secure & manage secrets using Google Cloud KMS

Google Cloud Secrets engine

Authenticating to Google services (e.g., application default credentials, JSON Web Token (JWT), OAuth 2.0)

Authenticating as a service account

gcloud auth application-default

Google Cloud application default credentials

Authentication between services

Using OAuth 2.0 for server-to-server applications

IAM roles for users/groups/service accounts

Understanding roles

Service account user role

Securing service-to-service communications (e.g., service mesh, Kubernetes Network Policies, and Kubernetes namespaces)

About Anthos Service Mesh

Creating a network policy

Kubernetes best practices: Specifying Namespaces in YAML

Running services with least privileged access (e.g., Workload Identity)

Workload Identity: Better authentication for your GKE apps

Workload identity federation

Certificate-based authentication (e.g., SSL, mTLS)

SSL certificates overview

Using self-managed SSL certificates

Using self-managed SSL certificates

Mutual TLS authentication

Google-recommended practices and documentation

Cloud security best practices center

1.3 Managing application data. Considerations include:

Defining database schemas for Google-managed databases (e.g., Firestore, Cloud Spanner, Cloud Bigtable, Cloud SQL)

Data model Firestore

Schema and data model

Schema design best practices Cloud Bigtable

Manage databases Cloud SQL

Choosing data storage options based on use case considerations, such as:

Time-limited access to objects

Configuring temporary access

Data retention requirements

Retention policies and retention policy locks

Structured vs. unstructured data

Structured vs. unstructured data

Strong vs. eventual consistency

Balancing strong and eventual consistency

Data volume
Frequency of data access in Cloud Storage

Your Google Cloud database options, explained

Google Cloud Storage options

Google-recommended practices and documentation

Best practices for Cloud Storage

1.4 Application modernization. Considerations include:

Using managed services

Managed services providers

Refactoring a monolith to microservices

Refactoring a monolith into microservices

Migrate a monolithic application to microservices on GKE

Designing stateless, horizontally scalable services

Aim for statelessness

Horizontally scale a database backend with Cloud SQL

Google-recommended practices and documentation

Application modernization the Google Cloud way

GCP Professional Cloud Developer

Amazon link (affiliate)

Section 2: Building and testing applications

2.1 Setting up your local development environment. Considerations include:

Emulating Google Cloud services for local application development

Emulating GCP services for local app development

Creating Google Cloud projects

Creating and managing projects

Creating your project

Using the command-line interface (CLI), Google Cloud Console, and Cloud Shell tools

gcloud CLI overview

Cloud console

Build and launch an ASP.NET Core app from Cloud Shell

Using developer tooling (e.g., Cloud Code, Skaffold)

Cloud Code overview

Skaffold, the Kubernetes build automation tool

Using Skaffold in Google Cloud Deploy

2.2 Writing efficient code. Considerations include:

Algorithm design

Tips & Tricks of Google Cloud Functions

Modern application patterns

Patterns for scalable and resilient apps

Software development methodologies

Build cloud applications

Debugging and profiling code

Debugging in production

Measure app performance by using Cloud Profiler

2.3 Testing. Considerations include:

Unit testing

Developing unit tests

Integration testing

Continuous integration testing with Cloud Build

Performance testing

Distributed load testing using Google Kubernetes Engine

Load testing

Load testing and monitoring AI Platform models

2.4 Building. Considerations include:

Source control management

DevOps tech: Version control

Creating secure container images from code

Building container images

Building container images

Developing a continuous integration pipeline using services (e.g., Cloud Build, Container Registry) that construct deployment artifacts

Cloud Build: Create a CI/CD Pipeline

Using Container Registry with Google Cloud

Set up a CI/CD pipeline for your data processing workflow

Reviewing and improving continuous integration pipeline efficiency

Pipeline efficiency

Section 3: Deploying applications

3.1 Recommend appropriate deployment strategies using the appropriate tools (e.g., Cloud Build, Spinnaker, Tekton, Anthos Configuration Manager) for the target compute environment (e.g., Compute Engine, Google Kubernetes Engine). Considerations include:

Blue/green deployments

Perform a blue/green deployment

Reduce deployment risks with Blue-Green deployments

Traffic-splitting deployments

Splitting traffic

Splitting traffic with the Admin API

Rolling deployments

Performing rolling updates

Starting a basic rolling update

Canary deployments

Creating a canary deployment

3.2 Deploying applications and services on Compute Engine. Considerations include:

Installing an application into a virtual machine (VM)

Getting started with .NET on Compute Engine

Managing service accounts for VMs

Creating service accounts for instances

Bootstrapping applications

A better way to bootstrap MongoDB on GCP

Exporting application logs and metrics

Export logs from Google Cloud Logging to BigQuery

Cloud monitoring metric export

Managing Compute Engine VM images and binaries

Image management best practices

3.3 Deploying applications and services to Google Kubernetes Engine (GKE). Considerations include:

Deploying a containerized application to GKE

Deploying to GKE

Managing Kubernetes RBAC and Google Cloud IAM relationships

Configure role-based access control

Access control

Configuring Kubernetes namespaces

Kubernetes: Specifying Namespaces in YAML

Defining workload specifications (e.g., resource requirements)

Use workload identity

Building a container image using Cloud Build

Build a Docker image with Cloud Build

Configuring application accessibility to user traffic and other services

Enabling accessibility features

Managing container life cycle

Lifecycle of a container on Cloud Run

Define Kubernetes resources and configurations

Understanding cluster resource usage

Configure cluster access for kubectl

3.4 Deploying a Cloud Function. Considerations include:

Cloud Functions that are triggered via an event from Google Cloud services (e.g., Pub/Sub, Cloud Storage objects)

Google Cloud pub/sub triggers

Google Cloud Storage triggers

Cloud Functions that are invoked via HTTP

HTTP triggers

Securing Cloud Functions

Securing cloud functions

3.5 Using service accounts. Considerations include:

Creating a service account according to the principle of least privilege

Least privilege for Cloud Functions using Cloud IAM

Downloading and using a service account private key file

Managing service account keys

Creating and managing service account keys

Section 4: Integrating Google Cloud services

4.1 Integrating an application with data and storage services. Considerations include:

Read/write data to/from various databases (e.g., SQL)

Reading from a SQL Server table

Connecting to a data store (e.g., Cloud SQL, Cloud Spanner, Firestore, Cloud Bigtable)

Connect using a database client from a Compute Engine

Writing an application that publishes/consumes data asynchronously (e.g., from Pub/Sub)

Subscribe with asynchronous pull

Storing and retrieving objects from Cloud Storage

Initiate a resumable upload

GET Object | Cloud Storage

4.2 Integrating an application with compute services. Considerations include:

Implementing service discovery in GKE and Compute Engine

Service discovery and DNS

Service discovery

Service Discovery and configuration on GCP

Reading instance metadata to obtain application configuration

About VM metadata

Accessing instance metadata

Authenticating users by using OAuth2.0 Web Flow and Identity-Aware Proxy

Using OAuth 2.0 for Web Server Applications

Using OAuth 2.0 to access Google APIs

Identity-aware proxy overview

Authenticate users with Google Accounts

Authenticating to Cloud APIs with Workload Identity

Use Workload identity

4.3 Integrating Cloud APIs with applications. Considerations include:

Enabling a Cloud API

Enabling an API in your Google Cloud project

Making API calls using supported options (e.g., Cloud Client Library, REST API or gRPC, APIs Explorer) taking into consideration:

Cloud client libraries

Creating API requests and handling responses

gRPC overview

APIs Explorer overview

Batching requests

Batching requests

Restricting return data

API rate limits

Rate-limiting strategies and techniques

Paginating results

List pagination

Paging through table data

Caching results

Using cached query results

Error handling (e.g., exponential backoff)

Implementing exponential backoff

Retry strategy

Using service accounts to make Cloud API calls

Making an authorized API call

Section 5: Managing application performance monitoring

5.1 Managing Compute Engine VMs. Considerations include:

Debugging a custom VM image using the serial port

Troubleshooting using the serial console

Viewing serial port output

Diagnosing a failed Compute Engine VM startup

Troubleshooting VM start up

Sending logs from a VM to Cloud Logging

Installing the Cloud Logging agent on individual VMs

Viewing and analyzing logs

Viewing activity logs

Analyze logs in real time using Fluentd and BigQuery

Inspecting resource utilization over time

Viewing usage reports

5.2 Managing Google Kubernetes Engine workloads. Considerations include:

Configuring logging and monitoring

Learn about logging on Google Kubernetes Engine

Observing your GKE clusters

Analyzing container life cycle events (e.g., CrashLoopBackOff, ImagePullErr)


ImagePullBackoff error from Google Kubernetes Engine

Viewing and analyzing logs

Analyze your GKE and GCE logging

Writing and exporting custom metrics

Create custom metrics with the API

Custom metrics exporter deployment

Using external metrics and corresponding alerts

External metrics for autoscaling workloads

Configuring workload autoscaling

Autoscaling a cluster

Cluster autoscaler

5.3 Troubleshooting application performance. Considerations include:

Creating a monitoring dashboard

Dashboards and charts

Manage custom dashboards

Writing custom metrics and creating log-based metrics

Custom metrics

Log-based metrics overview

Using Cloud Debugger

Getting started with Google Cloud Debugger on Compute Engine

Reviewing stack traces for error analysis

View errors

Exporting logs from Google Cloud

Configure and manage sinks

Export logs from Google Cloud Logging

Viewing logs in the Google Cloud Console

Viewing logs in the Legacy Logs Viewer

Reviewing application performance (e.g., Cloud Trace, Prometheus, OpenTelemetry)

Trace app latency by using Cloud Trace

Using Prometheus

Go and OpenTelemetry

Monitoring and profiling a running application

Monitor a Compute Engine virtual machine

Using documentation, forums, and Google Cloud support

Google Cloud documentation

Discuss Google Cloud

Support Hub

This brings us to the end of the GCP Professional Cloud Developer Study Guide.

What do you think? Let me know in the comments section if I have missed out on anything. Also, I love to hear from you about how your preparation is going on!

In case you are preparing for other GCP certification exams, check out the GCP study guide for those exams.

Receive Updates on CGP Cloud Developer Exam

Want to be notified as soon as I post? Subscribe to the RSS feed / leave your email address in the subscribe section. Share the article to your social networks with the below links so it can benefit others..

Share the GCP Cloud Developer Study Guide

You may also like