A Professional Cloud Developer builds scalable and highly available applications using Google-recommended tools and best practices. This individual has experience with cloud-native applications, developer tools, managed services, and next-generation databases. A Professional Cloud Developer also has proficiency with at least one general-purpose programming language and instruments their code to produce metrics, logs, and traces.
The exam is 2 hours long and costs $200.
Exam Content & Outline – What Will You Be Tested On?
The exam does not directly assess coding skill. It focuses on your ability to leverage Google Cloud services and recommended practices in order to build, test, deploy, and manage scalable and highly available applications. If you are proficient in at least one general purpose coding language, you should be able to interpret any questions with code snippets.
There are FIVE main crucial capabilities that the exam will test you on:
- Designing highly scalable, available, and reliable cloud-native applications
- Building and testing applications
- Deploying applications
- Integrating Google Cloud services
- Managing deployed applications
Let’s look at each of these in more detail and find out what exactly to study in order to be certified as a Google Professional Cloud Developer.
Designing Highly Scalable, Available, and Reliable Cloud-Native Applications
This section tests your ability to write code that is high-performing and secure from attacks. Various methods and practices exist today that make code perform up to or beyond their standards. You should have experience in writing code to fully grasp the material in this section and others.
- Designing high-performing applications and APIs
- Microservices
- Scaling velocity characteristics/trade-offs of IaaS, CaaS, PaaS, and FaaS
- Understanding how Google Cloud services are geographically distributed (e.g. latency, regional services, zonal services)
- User session management
- Caching solutions
- HTTP REST vs. gRPC
- Designing API services with API Gateway and Cloud Endpoints
- Loosely coupled asynchronous applications (e.g. Apache Kafka, Pub/Sub, Eventarc)
- Instrumenting code to produce metrics, logs, and traces
- Graceful shutdown of applications on platform termination
- Writing fault-tolerant code
- Designing secure applications
- Implementing data lifecycle and residency requirements relevant for applicable regulations
- Security mechanisms that protect services and resources
- Security mechanisms that secure/scan application binaries and manifests
- Storing, accessing, and rotating application secrets and keys (e.g. Secret Manager, Cloud KMS)
- Authenticating to Google Cloud services (e.g. application default credentials, JWT, OAuth 2.0)
- End-user account management and authentication using Identity Platform
- IAM roles for users, groups, and service accounts
- Securing service-to-service communications (e.g. service mesh, Kubernetes Network Policies, K8s namespaces)
- Running services with least privileged access (e.g. Workload Identity)
- Certificate-based authentication (e.g. SSL, mTLS)
- Managing application data
- Defining database schemas for Google-managed databases (e.g. Firestore, Spanner, Bigtable, SQL)
- Defining a data storage key structure for high-write applications
- Choosing data storage options based on use case considerations
- Time-limited access to objects
- Data retention requirements
- Structured vs. unstructured data
- Strong vs. eventual consistency
- Data volume
- Data access patterns
- Online transaction processing (OLTP) vs. data warehousing
Building and Testing Applications
This section is all about providing the developer a proper environment in which to build and test the application code.
- Setting up your local development environment
- Emulating Google Cloud services for local application development
- Using the Google Cloud Console, SDK, and Cloud Shell tools
- Using developer tooling (e.g. Cloud Code, Skaffold)
- Building
- Source control management
- Creating secure container images from code
- Developing a continuous integration pipeline using services (e.g., Cloud Build, Artifact Registry) that contruct deployment artifacts
- Code and test build optimization
- Testing
- Unit testing (e.g. emulators)
- Integration testing
- Performance testing
- Load testing
- Failure testing/chaos engineering
Deploying Applications
Now that your code is fully tested, it’s time to release it into the wild. The process of doing so is more complicated than it sounds, and this section will test you exactly on that.
- Adopting appropriate feature rollout strategies
- A/B testing
- Feature flags
- Backward compatibility
- Deploying applications to a serverless computing environment
- Sizing and scaling serverless environments
- Deploying from source code
- Invocation via triggers
- Configuring event receivers
- Exposing and securing application APIs (e.g. API Gateway, Cloud Endpoints)
- Deploying applications and services to Google Kubernetes Engine (GKE)
- Deploying a containerized application to GKE
- Integrating Kubernetes RBAC with Identity and Access Management (IAM)
- 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 lifecycle
Integrating Google Cloud Services
Google Cloud Platform offers a wide array of services you can use to beef up your application. You will be tested on your knowledge of various services that you can integrate with your application.
- Integrating an application with data and storage services
- Managing connections to data stores (e.g. Cloud SQL, Spanner, Filestore, Bigtable, Cloud Storage)
- Reading/writing data to/from various data stores
- Writing an application that publishes/consumes data asynchronously (e.g. from Pub/Sub)
- Integrating an application with compute services
- Using service discovery (e.g. Service Directory)
- Reading instance metadata to obtain application configuration
- Graceful application startup and shutdown
- Integrating Cloud APIs with applications
- Enabling a Cloud API
- Making API calls using supported options (e.g. Cloud Client Library, REST API or gRPC, API Explorer)
- Batching requests
- Restricting return data
- Paginating results
- Caching results
- Error handling (e.g. exponential backoff)
- Using service accounts to make Cloud API calls
Managing Deployed Applications
Once your application is out in the wild, you will need to find a way to keep it under close watch in case things don’t go as planned. This section forces you to learn about the various ways to keep your application in check while providing you some visibility into logs.
- Managing cloud compute services (e.g. GKE, serverless)
- Analyzing lifecycle events
- Using external metrics and corresponding alerts
- Configuring workload autoscaling
- Troubleshooting applications
- Using Debugger
- Using Cloud Logging
- Using Cloud Monitoring
- Using Cloud Profiler
- Using Cloud Trace
- Using Error Reporting
- Using documentation, forums, and Google Cloud support
