The Google GCP-PCD exam preparation guide is designed to provide candidates with necessary information about the Professional Cloud Developer exam. It includes exam summary, sample questions, practice test, objectives and ways to interpret the exam objectives to enable candidates to assess the types of questions-answers that may be asked during the Google Cloud Platform - Professional Cloud Developer (GCP-PCD) exam.
It is recommended for all the candidates to refer the GCP-PCD objectives and sample questions provided in this preparation guide. The Google Professional Cloud Developer certification is mainly targeted to the candidates who want to build their career in Professinoal domain and demonstrate their expertise. We suggest you to use practice exam listed in this cert guide to get used to with exam environment and identify the knowledge areas where you need more work prior to taking the actual Google Professional Cloud Developer exam.
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-60 |
| Passing Score | Pass / Fail (Approx 70%) |
| Recommended Training / Books |
Google Cloud training Google Cloud documentation Google Cloud solutions |
| Schedule Exam | Google CertMetrics |
| 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 (33% of the exam) |
|
| Designing high-performing applications and APIs. Considerations include: |
- Microservices architecture - Choosing the appropriate platform based on the use case and requirements (e.g., IaaS [infrastructure as a service], CaaS [container as a service], PaaS [platform as a service], FaaS [function as a service]) - Application modernization (e.g., containerization) - Understanding how Google Cloud services are geographically distributed (e.g., latency, regional services, zonal services) - User session management - Caching solutions - HTTP REST versus gRPC (Google Remote Procedure Call) - Incorporating Service Control capabilities offered by API services (e.g. Apigee) - Loosely coupled asynchronous applications (e.g., Apache Kafka, Pub/Sub, Eventarc) - Instrumenting code to produce metrics, logs, and traces - Cost optimization and resource optimization - Graceful handling of errors, disasters, and scaling events |
| Designing secure applications. Considerations include: |
- Implementing data lifecycle and residency for applicable regulatory requirements - Security mechanisms that identify vulnerabilities and protect services and resources (e.g., Identity-Aware Proxy [IAP], Web Security Scanner) - Security mechanisms that secure/scan application binaries, dependencies, and manifests (e.g., Container Analysis) - Storing, accessing, and rotating application secrets and encryption keys (e.g., Secret Manager, Cloud Key Management Service) - Authenticating to Google Cloud services (e.g., application default credentials, JSON Web Token [JWT], OAuth 2.0) - End-user account management and authentication by using Identity Platform - Identity and Access Management (IAM) roles for users, groups, and service accounts - Securing service-to-service communications (e.g., service mesh, Kubernetes Network Policies, Kubernetes namespaces) - Running services with keyless and least privileged access (e.g., Workload Identity, Workload identity federation) - Certificate-based authentication (e.g., SSL, mTLS) - Supply-chain Levels for Software Artifacts (SLSA) |
| Choosing storage options for application data. Considerations include: |
- Time-limited access to objects - Data retention requirements - Structured versus unstructured data (e.g., SQL versus NoSQL) - Strong versus eventual consistency - Data volume - Data access patterns - Online transaction processing (OLTP) versus data warehousing |
Building and testing applications (26% of the exam) |
|
| Setting up your local development environment. Considerations include: |
- Emulating Google Cloud services for local application development - Using the Google Cloud console, Google Cloud SDK, Cloud Shell, and Cloud Workstations - Using developer tooling (e.g., common IDEs, Cloud Code, Skaffold) - Authenticating to Google Cloud services (e.g., Cloud SQL Auth proxy, AlloyDB Auth proxy) |
| Building. Considerations include: |
- Source control management - Creating secure container images from code - Developing a continuous integration pipeline by using services (e.g., Cloud Build, Artifact Registry) that construct deployment artifacts - Code and test build optimization |
| Testing. Considerations include: |
- Unit testing - Integration testing including the use of emulators - Performance testing - Load testing - Failure testing/chaos engineering |
Deploying applications (19% of the exam) |
|
| Adopting appropriate feature rollout strategies. Considerations include: |
- A/B testing - Feature flags - Backward compatibility - Versioning APIs (e.g., Apigee) |
| Deploying applications to a serverless computing environment. Considerations include: |
- Deploying applications from source code - Using triggers to invoke functions - Configuring event receivers (e.g., Eventarc, Pub/Sub) - Exposing and securing application APIs (e.g., Apigee) |
| Deploying applications and services to Google Kubernetes Engine (GKE). Considerations include: |
- Deploying a containerized application to GKE - Integrating Kubernetes role-based access control (RBAC) with IAM - Defining workload specifications (e.g., resource requirements) - Building a container image by using Cloud Build |
Integrating applications with Google Cloud services (22% of the exam) |
|
| Integrating applications with data and storage services. Considerations include: |
- Managing connections to datastores (e.g., Cloud SQL, Firestore, Bigtable, Cloud Storage) - Reading/writing data to or from various datastores - Writing an application that publishes or consumes data asynchronously (e.g., from Pub/Sub or streaming data sources) - Orchestrate application services with Workflows, Eventarc, Cloud Tasks, and Cloud Scheduler |
| Integrating applications with Google Cloud APIs. Considerations include: |
- Enabling Google Cloud services - Making API calls by using supported options (e.g., Cloud Client Library, REST API, or gRPC, API Explorer) taking into consideration:
- Using service accounts to make Cloud API calls |