Professional Cloud Developers build scalable and highly available applications using Google-recommended practices and tools. They have experience with cloud-native applications, developer tools, managed services, and next-generation databases. Cloud Developers are also proficient with at least one general-purpose programming language and are skilled at producing meaningful metrics and logs to debug and trace code.
Try Online Exam
The Professional Cloud Developer exam assesses your ability to:
- Design highly scalable, available, reliable cloud-native applications
- Build and test applications
- Deploy applications
- Integrate Google Cloud services
- Manage application performance monitoring
Google GCP-PCD Exam Summary:
Exam Name | Google Professional Cloud Developer |
Exam Code | GCP-PCD |
Exam Price | $200 USD |
Duration | 120 minutes |
Number of Questions | 50 |
Passing Score | Pass / Fail (Approx 70%) |
Recommended Training / Books | Google Cloud training Google Cloud documentation Google Cloud solutions |
Sample Questions | Google GCP-PCD Sample Questions |
Recommended Practice | Google Cloud Platform – Professional Cloud Developer (GCP-PCD) Practice Test |
Google Professional Cloud Developer Syllabus:
Section | Objectives |
Designing highly scalable, available, and reliable cloud-native applications | |
Designing high-performing applications and APIs. Considerations include: | – Microservices – Scaling velocity characteristics/trade-offs of IaaS (infrastructure as a service) vs. CaaS (container as a service) vs. PaaS (platform as a service) – Geographic distribution of Google Cloud services (e.g., latency, regional services, zonal services) – Defining a key structure for high-write applications using Cloud Storage, Cloud Bigtable, Cloud Spanner, or Cloud SQL – User session management – Caching solutions – Deploying and securing API services – Loosely coupled asynchronous applications (e.g., Apache Kafka, Pub/Sub) – Graceful shutdown on platform termination – Google-recommended practices and documentation |
Designing secure applications. Considerations include: | – Implementing requirements that are relevant for applicable regulations (e.g., data wipeout) – Security mechanisms that protect services and resources – Security mechanisms that secure/scan application binaries and manifests – Storing and rotating application secrets and keys (e.g., Cloud KMS, HashiCorp Vault) – Authenticating to Google services (e.g., application default credentials, JSON Web Token (JWT), OAuth 2.0) – IAM roles for users/groups/service accounts – Securing service-to-service communications (e.g., service mesh, Kubernetes network policies, and Kubernetes namespaces) – Running services with least privileged access (e.g., Workload Identity) – Certificate-based authentication (e.g., SSL, mTLS) – Google-recommended practices and documentation |
Managing application data. Considerations include: |
– Defining database schemas for Google-managed databases (e.g., Firestore, Cloud Spanner, Cloud Bigtable, Cloud SQL)
– Google-recommended practices and documentation |
Application modernization. Considerations include: | – Using managed services – Refactoring a monolith to microservices – Designing stateless, horizontally scalable services – Google-recommended practices and documentation |
Building and Testing Applications | |
Setting up your local development environment. Considerations include: | – Emulating Google Cloud services for local application development – Creating Google Cloud projects – Using the command-line interface (CLI), Google Cloud Console, and Cloud Shell tools – Using developer tooling (e.g., Cloud Code, Skaffold) |
Writing efficient code. Considerations include: | – Algorithm design – Modern application patterns – Software development methodologies – Debugging and profiling code |
Testing. Considerations include: | – Unit testing – Integration testing – Performance testing – Load testing |
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 – Reviewing and improving continuous integration pipeline efficiency |
Deploying applications | |
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 – Traffic-splitting deployments – Rolling deployments – Canary deployments |
Deploying applications and services on Compute Engine. Considerations include: | – Installing an application into a virtual machine (VM) – Managing service accounts for VMs – Bootstrapping applications – Exporting application logs and metrics – Managing Compute Engine VM images and binaries |
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 – Configuring Kubernetes namespaces – Defining workload specifications (e.g., resource requirements) – Building a container image using Cloud Build – Configuring application accessibility to user traffic and other services – Managing container life cycle – Define Kubernetes resources and configurations |
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 |
Using service accounts. Considerations include: | – Creating a service account according to the principle of least privilege – Downloading and using a service account private key file |
Integrating Google Cloud Services | |
Integrating an application with Data and Storage services. Considerations include: | – Read/write data to/from various databases (e.g., SQL) – Connecting to a data store (e.g., Cloud SQL, Cloud Spanner, Firestore, Cloud Bigtable) – Writing an application that publishes/consumes data asynchronously (e.g., from Pub/Sub) – Storing and retrieving objects from Cloud Storage |
Integrating an application with compute services. Considerations include: | – Implementing service discovery in GKE and Compute Engine – Reading instance metadata to obtain application configuration – Authenticating users by using OAuth2.0 Web Flow and Identity-Aware Proxy – Authenticating to Cloud APIs with Workload Identity |
Integrating Cloud APIs with applications. Considerations include: |
– Enabling a Cloud API
– Using service accounts to make Cloud API calls |
Managing Application Performance Monitoring | |
Managing Compute Engine VMs. Considerations include: | – Debugging a custom VM image using the serial port – Diagnosing a failed Compute Engine VM startup – Sending logs from a VM to Cloud Logging – Viewing and analyzing logs – Inspecting resource utilization over time |
Managing Google Kubernetes Engine workloads. Considerations include: | – Configuring logging and monitoring – Analyzing container life cycle events (e.g., CrashLoopBackOff, ImagePullErr) – Viewing and Analyzing logs – Writing and exporting custom metrics – Using external metrics and corresponding alerts – Configuring workload autoscaling |
Troubleshooting application performance. Considerations include: | – Creating a monitoring dashboard – Writing custom metrics and creating log-based metrics – Using Cloud Debugger – Reviewing stack traces for error analysis – Exporting logs from Google Cloud – Viewing logs in the Google Cloud Console – Reviewing application performance (e.g., Cloud Trace, Prometheus, OpenTelemetry) – Monitoring and profiling a running application – Using documentation, forums, and Google Cloud support |