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 |
| Udemy | GCP Developer Professional Certification |
GCP Professional Cloud Developer Practice Test
| Whizlabs Exam Questions | GCP Cloud Developer Tests (120 Qs) |
| Udemy Practice Tests | Test your knowledge GCP Cloud Developer |
GCP Professional Cloud Developer Other Material
| Udacity (Nanodegree) | Become a Cloud Developer |
| LinkedIn Learning | Cloud 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:
Microservices
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)
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
Deploying and securing API services
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)
Deleting your data in Google Cloud Platform
Security mechanisms that protect services and resources
How Google infrastructure security layers power GCP & Services?
Security mechanisms that secure/scan application binaries and manifests
Storing and rotating application secrets and keys (e.g., Cloud KMS, HashiCorp Vault)
Secure & manage secrets using Google Cloud KMS
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
Securing service-to-service communications (e.g., service mesh, Kubernetes Network Policies, and Kubernetes namespaces)
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
Certificate-based authentication (e.g., SSL, mTLS)
Using self-managed SSL certificates
Using self-managed SSL certificates
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)
Schema design best practices Cloud Bigtable
Choosing data storage options based on use case considerations, such as:
Time-limited access to objects
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-recommended practices and documentation
Best practices for Cloud Storage
1.4 Application modernization. Considerations include:
Using managed services
Refactoring a monolith to microservices
Refactoring a monolith into microservices
Migrate a monolithic application to microservices on GKE
Designing stateless, horizontally scalable services
Horizontally scale a database backend with Cloud SQL
Google-recommended practices and documentation
Application modernization the Google Cloud way
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
Using the command-line interface (CLI), Google Cloud Console, and Cloud Shell tools
Build and launch an ASP.NET Core app from Cloud Shell
Using developer tooling (e.g., Cloud Code, Skaffold)
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
Debugging and profiling code
Measure app performance by using Cloud Profiler
2.3 Testing. Considerations include:
Unit testing
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
Creating secure container images from code
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
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 with the Admin API
Rolling deployments
Starting a basic rolling update
Canary deployments
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
Managing Kubernetes RBAC and Google Cloud IAM relationships
Configure role-based access control
Configuring Kubernetes namespaces
Kubernetes: Specifying Namespaces in YAML
Defining workload specifications (e.g., resource requirements)
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)
Cloud Functions that are invoked via HTTP
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
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
4.2 Integrating an application with compute services. Considerations include:
Implementing service discovery in GKE and Compute Engine
Service Discovery and configuration on GCP
Reading instance metadata to obtain application configuration
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
Authenticate users with Google Accounts
Authenticating to Cloud APIs with 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:
Creating API requests and handling responses
Batching requests
Restricting return data
Rate-limiting strategies and techniques
Paginating results
Caching results
Error handling (e.g., exponential backoff)
Using service accounts to make Cloud API calls
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
Diagnosing a failed Compute Engine VM startup
Sending logs from a VM to Cloud Logging
Installing the Cloud Logging agent on individual VMs
Viewing and analyzing logs
Analyze logs in real time using Fluentd and BigQuery
Inspecting resource utilization over time
5.2 Managing Google Kubernetes Engine workloads. Considerations include:
Configuring logging and monitoring
Learn about logging on Google Kubernetes Engine
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
5.3 Troubleshooting application performance. Considerations include:
Creating a monitoring dashboard
Writing custom metrics and creating log-based metrics
Using Cloud Debugger
Getting started with Google Cloud Debugger on Compute Engine
Reviewing stack traces for error analysis
Exporting logs from Google Cloud
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
Monitoring and profiling a running application
Monitor a Compute Engine virtual machine
Using documentation, forums, and Google Cloud support
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..
