Google Certified Professional Cloud Developer 2022 — Exam guide mapping

Aiming for Google Certified PCD? I recently got my PCD certificate in Apr 2021 and cool Google swags too!

Irrespective of whatever amount of preparation, a final check on whether we are good with respect to all exam guide points is something important to be ticked. Hence sharing this Cert Prep Map to Exam guide. Do check out this new 2022 exam guide mapping! Hope you find it useful to cover all your learning areas!

Disclaimer: This was curated for my own personal use. Feel free to explore beyond the recommended links, as PCD is one of the toughest exams at Google!

Exam pattern:

Questions: 60 Yeah, you read it right! Unlike other ACE/PCA exams, this is 10 more to 50!

Exam duration:

a. 120 minutes [Actual Exam time ] [ I could complete all 60 questions in 120 mins but couldn’t unfortunately revisit “marked for review” again! ]

b. Procedural time [ 15–30 mins — Depending on proctor availability and pre-checks it may vary, Account for it and keep your family informed :)]

Exam format: Multiple choice and multiple select [ No negative marking, don’t leave anything unanswered]

PCD — Exam guide mapping :

Official guide

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

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

• Microservices ( Microservices Architecture on Google App Engine, Migrating a monolithic application to microservices on Google Kubernetes Engine)
• Scaling velocity characteristics/tradeoffs of IaaS (infrastructure as a service) vs. CaaS (container as a service) vs. PaaS (platform as a service) ( About Google Cloud services)
• Geographic distribution of Google Cloud services (e.g., latency, regional services, zonal services) ( Geography and regions, Regions and Zones)
• Defining a key structure for high-write applications using Cloud Storage, Cloud Bigtable, Cloud Spanner, or Cloud SQL ( Cloud storage products, Datastore Overview)
• User session management ( Handling sessions with Firestore, Managing sessions with external identities
• Caching solutions ( Memorystore)
• Deploying and securing API services ( Cloud Endpoints)
• Loosely coupled asynchronous applications (e.g., Apache Kafka, Pub/Sub) ( Choosing the right architecture for global data distribution, Apache Kafka for GCP users: connectors for Pub/Sub, Dataflow and BigQuery)
• Graceful shutdown on platform termination ( Kubernetes best practices: terminating with grace, Stopping and starting an instance)

1.2 Designing secure applications. Considerations include:

• Implementing requirements that are relevant for applicable regulations (e.g., data wipeout) ( Google Cloud & the General Data Protection Regulation (GDPR), Data deletion on Google Cloud Platform)
• Security mechanisms that protect services and resources ( Google Infrastructure Security Design Overview)
• Security mechanisms that secure/scan application binaries and manifests ( Secrets management)
• Storing and rotating application secrets and keys (e.g., Cloud KMS, HashiCorp Vault)
• Authenticating to Google services (e.g., application default credentials, JWT, OAuth 2.0) ( Authentication overview)
• IAM roles for users/groups/service accounts ( IAM Overview)
• Securing service-to-service communications (e.g., service mesh, Kubernetes Network Policies, and Kubernetes namespaces) ( Kubernetes best practices: Organizing with Namespaces)
• Running services with least privileged access (e.g., Workload Identity) ( Workload Identity)
• Certificate-based authentication (e.g., SSL, mTLS) ( SSL certificates overview, Mutual TLS authentication)

1.3 Managing application data. Considerations include:

• Defining database schemas for Google-managed databases (e.g., Firestore, Cloud Spanner, Cloud Bigtable, Cloud SQL) ( Schema and data model, Google Cloud Databases)
• Choosing data storage options based on use case considerations, such as:

Time-limited access to objects ( Overview of access control)
Data retention requirements ( Retention policies and retention policy locks)
Structured vs. unstructured data ( Data lifecycle)
Strong vs. eventual consistency ( Balancing Strong and Eventual Consistency with Datastore)
Data volume ( Storage options)
Frequency of data access in Cloud Storage ( Storage classes)

1.4 Application modernization. Considerations include:

• Using managed services ( Managing Service Lifecycles)
• Refactoring a monolith to microservices ( Migrating a monolithic application to microservices on Google Kubernetes Engine)
• Designing stateless, horizontally scalable services ( Patterns for scalable and resilient apps)

Topic 2: Building and testing applications

2.1 Setting up your local development environment. Considerations include:

• Emulating Google Cloud services for local application development ( Using the Local Development Server)
• Creating Google Cloud projects ( Creating and managing projects)
• Using the command-line interface (CLI), Google Cloud Console, and Cloud Shell tools ( gcloud command-line tool overview, Cloud SDK, Cloud Shell)
• Using developer tooling (e.g., Cloud Code, Skaffold) ( Kubernetes development, simplified — Skaffold is now GA)

2.2 Writing efficient code. Considerations include:

• Algorithm design ( Introduction to built-in algorithms)
• Modern application patterns ( Patterns for scalable and resilient apps)
• Software development methodologies ( Twelve-factor app development on Google Cloud)
• Debugging and profiling code ( Introducing Stackdriver APM and Stackdriver Profiler)

2.3 Testing. Considerations include:

• Unit testing ( Local Unit Testing for Python 2, Testing Overview)
• Integration testing ( Continuous integration (CI))
• Performance testing ( Testing Overview, Distributed load testing using Google Kubernetes Engine)
• Load testing ( Distributed load testing using Google Kubernetes Engine)

2.4 Building. Considerations include:

• Source control management ( Cloud Source Repositories
• Creating secure container images from code ( Building Containers, Quickstart for Container Registry)
• Developing a continuous integration pipeline using services (e.g., Cloud Build, Container Registry) that construct deployment artifacts ( CI/CD on Google Cloud, Quickstart for Container Registry, Cloud Build)
• Reviewing and Improving continuous integration pipeline efficiency ( DevOps tech: Continuous integration)

Topic 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 computing environment (e.g., Compute Engine, Google Kubernetes Engine). Considerations include:

• Blue/green deployments ( Continuous delivery)
• Traffic-splitting deployments ( Splitting Traffic)
• Rolling deployments ( Rolling out updates to MIGs, Performing rolling updates)
• Canary deployments ( Automating Canary Analysis on Google Kubernetes Engine with Spinnaker)

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

• Installing an application into a virtual machine (VM) ( Quickstart using a Windows VM, Virtual machine instances)
• Managing service accounts for VMs ( Service accounts
• Bootstrapping applications ( Automatically bootstrapping GKE nodes with DaemonSets)
• Exporting application logs and metrics ( Exporting with the Logs Viewer, Cloud Monitoring metric export)
• Managing Compute Engine VM images and binaries ( Images)

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

• Deploying a containerized application to GKE ( Deploying a containerized web application)
• Managing Kubernetes RBAC and Google Cloud IAM relationships ( Access control overview)
• Configuring Kubernetes namespaces ( Kubernetes best practices: Organizing with Namespaces)
• Defining workload specifications (e.g., resource requirements) ( Workload Identity)
• Building a container image using Cloud Build ( Building container images)
• Configuring application accessibility to user traffic and other services ( Private access options for services)
• Managing container lifecycle ( Cluster architecture)
• Define Kubernetes resources and configurations ( Unify Kubernetes and GCP resources for simpler and faster deployments)

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 Storage Triggers, Pub/Sub Notifications for Cloud Storage)
• Cloud Functions that are invoked via HTTP ( HTTP Triggers)
• Securing Cloud Functions ( Securing Google Cloud Functions)

3.5 Using service accounts. Considerations include:

• Creating a service account according to the principle of least privilege ( Using IAM securely)
• Downloading and using a service account private key file ( Creating and managing service account keys)

Topic 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) ( Importing data into Cloud SQL, Replication in Cloud SQL)
• Connecting to a data store (e.g., Cloud SQL, Cloud Spanner, Firestore, Cloud Bigtable) ( Google Cloud Databases, Datastore Overview)
• Writing an application that publishes/consumes data asynchronously (e.g., from Pub/Sub) ( Writing and Responding to Pub/Sub Messages, Pub/Sub)
• Storing and retrieving objects from Cloud Storage ( Objects, Cloud Storage)

4.2 Integrating an application with compute services. Considerations include:

• Implementing service discovery in GKE and Compute Engine ( Service discovery and DNS)
• Reading instance metadata to obtain application configuration ( Storing and retrieving instance metadata, Accessing Instance Metadata)
• Authenticating users by using OAuth2.0 Web Flow and Identity Aware Proxy ( Programmatic authentication, Identity-Aware Proxy overview)
• Authenticating to Cloud APIs with Workload Identity ( Workload Identity, Introducing Workload Identity: Better authentication for your GKE applications)

4.3 Integrating Cloud APIs with applications. Considerations include:

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

Batching requests ( Batching requests)
Restricting return data ( Working with Quotas, Usage limits)
Paginating results ( Paging through table data, Paginating data with query cursors)
Caching results ( Using cached query results)
Error handling (e.g., exponential backoff) ( Truncated exponential backoff)

• Using service accounts to make Cloud API calls ( Service accounts)

Topic 5: Managing application performance monitoring

5.1 Managing Compute Engine VMs. Considerations include:

• Debugging a custom VM image using the serial port ( Interacting with the serial console, Viewing serial port output)
• Diagnosing a failed Compute Engine VM startup ( General troubleshooting)
• Sending logs from a VM to Cloud Logging ( About the Logging agent)
• Viewing and analyzing logs ( Viewing logs (Classic))
• Inspecting resource utilization over time ( Viewing usage reports, Monitoring Your API Usage)

5.2 Managing Google Kubernetes Engine workloads. Considerations include:

• Configuring logging and monitoring ( Installing Cloud Operations for GKE support, Overview of Google Cloud’s operations suite for GKE)
• Analyzing container lifecycle events (e.g., CrashLoopBackOff, ImagePullErr) ( Container Analysis)
• Viewing and analyzing logs ( Viewing logs (Classic))
• Writing and exporting custom metrics ( Creating custom metrics, Using Custom Metrics)
• Using external metrics and corresponding alerts ( Managing Alerting Policies by API, Google Cloud metrics)
• Configuring workload autoscaling ( Autoscaling groups of instances, load balancing, and scaling)

5.3 Troubleshooting application performance. Considerations include:

• Creating a monitoring dashboard ( Creating charts, Managing dashboards through the console)
• Writing custom metrics and creating log-based metrics ( Overview of logs-based metrics, Creating Counter Metrics)
• Using Cloud Debugger ( Cloud Debugger)
• Reviewing stack traces for error analysis ( Viewing errors)
• Exporting logs from Google Cloud ( Overview of logs exports, Exporting with the Logs Viewer)
• Viewing logs in the Google Cloud Console ( Viewing logs (Classic))
• Reviewing application performance (e.g., Cloud Trace, Prometheus, OpenTelemetry) ( Integrating Cloud Monitoring, Logging, and Trace with observability and alerting solutions, Cloud Trace)
• Monitoring and profiling a running application ( Cloud Profiler, Operations (formerly Stackdriver))
• Using documentation, forums, and Google Cloud support ( Community Support Overview)

Be sure to take a few minutes to explore these resources, and when you have time, dig deeper into a product that you’ve been wanting to learn more about.

I’m eager to hear your feedback on this blog with resources and your ideas for curating such similar content that will help make your learning journey a little bit easier. Share it with me on LinkedIn or do drop a comment here. Feel free to tag me, in case this Cert Prep guide helped you clear your certification! 👍

Do hit the clap button 👏👏👏 to encourage & if you feel worth investing time here. See you in my next blog. Stay safe...