Google GCP-PCD (Professional Cloud Developer) Certification Exam Syllabus

GCP-PCD Dumps Questions, GCP-PCD PDF, Professional Cloud Developer Exam Questions PDF, Google GCP-PCD Dumps Free, Professional Cloud Developer Official Cert Guide PDFThe 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 Cloud 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 240 minutes
Number of Questions 50
Passing Score Pass / Fail (Approx 70%)
Recommended Training / Books Google Cloud training
Google Cloud documentation
Google Cloud solutions
Schedule Exam PEARSON VUE
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/tradeoffs of IaaS (infrastructure as a service) vs. CaaS (container as a service) vs. PaaS (platform as a service)
- Evaluating different services and technologies
- 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 applications using asynchronous Cloud Pub/Sub events
- 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 using Cloud KMS
- Authenticating to Google services (e.g., application default credentials, 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)
- Set compute/workload identity to least privileged access
- Certificate-based authentication (e.g., SSL, mTLS)
- Google-recommended practices and documentation
Managing application data. Tasks include: - Defining database schemas for Google-managed databases (e.g., Cloud Firestore, Cloud Spanner, Cloud Bigtable, Cloud SQL)
- Choosing data storage options based on use case considerations, such as:
  • Cloud Storage-signed URLs for user-uploaded content
  • Structured vs. unstructured data
  • Strong vs. eventual consistency
  • Data volume
  • Frequency of data access in Cloud Storage

- Following Google-recommended practices and documentation

Refactoring applications to migrate to Google Cloud. Tasks include: - Using managed services
- Migrating a monolith to microservices
- 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
Writing code. Considerations include: - Algorithm design
- Modern application patterns
- Efficiency
- Agile software development
- Unit testing
Testing. Considerations include: - Performance testing
- Integration testing
- Load testing
Building. Considerations include: - Creating a Cloud Source Repository and committing code to it
- Creating 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 efficacy

Deploying applications

Recommend appropriate deployment strategies for the target compute environment (Compute Engine, Google Kubernetes Engine). Strategies include: - Blue/green deployments
- Traffic-splitting deployments
- Rolling deployments
- Canary deployments
Deploying applications and services on Compute Engine. Tasks include: - Installing an application into a VM
- Modifying the VM service account
- Manually updating dependencies on a VM
- Exporting application logs and metrics
- Managing Compute Engine VM images and binaries
Deploying applications and services to Google Kubernetes Engine (GKE). Tasks include: - Deploying a containerized application to GKE
- Managing Kubernetes RBAC and Google Cloud IAM relationship
- Configuring Kubernetes namespaces and access control
- 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 lifecycle
- Define deployments, services, and pod configurations
Deploying a Cloud Function. Types include: - Cloud Functions that are triggered via an event (e.g., Cloud Pub/Sub events, Cloud Storage object change notification events)
- Cloud Functions that are invoked via HTTP
- Securing Cloud Functions
Using service accounts. Tasks include: - Creating a service account according to the principle of least privilege
- Downloading and using a service account private key file

Integrating Google Cloud Platform Services

Integrating an application with Data and Storage services. Tasks include: - Read/write data to/from various databases (e.g., SQL, JDBC)
- Connecting to a data store (e.g., Cloud SQL, Cloud Spanner, Cloud Firestore, Cloud Bigtable)
- Writing an application that publishes/consumes data asynchronously (e.g., from Cloud Pub/Sub)
- Storing and retrieving objects from Cloud Storage
- Using the command-line interface (CLI), Google Cloud Console, and Cloud Shell tools
Integrating an application with compute services. Tasks include: - Implementing service discovery in Google Kubernetes Engine and Compute Engine
- Reading instance metadata to obtain application configuration
- Authenticating users by using OAuth2.0 Web Flow and Identity Aware Proxy
- Using the command-line interface (CLI), Google Cloud Console, and Cloud Shell tools
Integrating Google Cloud APIs with applications. Tasks include: - Enabling a Google Cloud API
- Making API calls with a Cloud Client Library, the REST API, or the APIs Explorer, taking into consideration:
  • Batching requests
  • Restricting return data
  • Paginating results
  • Caching results
  • Error handling (e.g., exponential backoff)

- Using service accounts to make Google API calls

Managing Application Performance Monitoring

Managing Compute Engine VMs. Tasks include: - Debugging a custom VM image using the serial port
- Analyzing a failed Compute Engine VM startup
- Analyzing logs
- Sending logs from a VM to Cloud Monitoring
- Inspecting resource utilization over time
- Viewing syslogs from a VM
Managing Google Kubernetes Engine workloads. Tasks include: - Configuring logging and monitoring
- Analyzing container lifecycle events (e.g., CrashLoopBackOff, ImagePullErr)
- Analyzing logs
- Using external metrics and corresponding alerts
- Configuring workload autoscaling
Troubleshooting application performance. Tasks include: - Creating a monitoring dashboard
- Writing custom metrics and creating metrics from logs
- Graphing metrics
- Using Cloud Debugger
- Reviewing stack traces for error analysis
- Exporting logs from Google Cloud
- Viewing logs in the Google Cloud Console
- Profiling performance of request-response
- Profiling services
- Reviewing application performance (e.g., Cloud Trace, Prometheus, OpenCensus)
- Monitoring and profiling a running application
- Using documentation, forums, and Google support
Your rating: None Rating: 5 / 5 (1 vote)