Google Professional-Cloud-Developer Google Certified Professional - Cloud Developer Exam Practice Test

Use local SSDs to store state.

Put a memcache layer in front of MySQL.

Move the state storage to Cloud Spanner.

Replace the MySQL instance with Cloud SQL.

Create new Cloud SQL instances in Europe and North America for testing and deployment. Provide developers with local MySQL instances to conduct testing on the application changes.

Migrate data to Bigtable. Instruct the development teams to use the Cloud SDK to emulate a local Bigtable development environment.

Move from Cloud SQL to MySQL hosted on Compute Engine. Replicate hosts across regions in the Americas and Europe. Provide developers with local MySQL instances to conduct testing on the application changes.

Migrate data to Firestore in Native mode and set up instan

Create an API key. Use the API key to interact with Google Cloud.

Use the default compute service account to interact with Google Cloud.

Create a service account for the application. Export and deploy the private key for the application. Use the service account to interact with Google Cloud.

Create a service account for the application and for each Google Cloud API used by the application. Export and deploy the private keys used by the application. Use the service account with one Google Cloud API to interact with Google Cloud.

Include unit tests in their code, and prevent deployments to QA until all tests have a passing status.

Include performance tests in their code, and prevent deployments to QA until all tests have a passing status.

Create health checks for the QA environment, and redeploy the APIs at a later time if the environment is unhealthy.

Redeploy the APIs to App Engine using Traffic Splitting. Do not move QA traffic to the new versions if errors are found.

Use Google App Engine services.

Use serverless Google Cloud Functions.

Use Knative to build and deploy serverless applications.

Use Google Kubernetes Engine for automated deployments.

Use a large Google Compute Engine cluster for deployments.

Use Google Kubernetes Engine (GKE) to run the application as a microservice. Run the MySQL database on a dedicated GKE node.

Use multiple Compute Engine instances to run MySQL to store state information. Use a Google Cloud-managed load balancer to distribute the load between instances. Use managed instance groups for scaling.

Use Memorystore to store session information and CloudSQL to store state information. Use a Google Cloud-managed load balancer to distribute the load between instances. Use managed instance groups for scaling.

Use a Cloud Storage bucket to serve the application as a static website, and use another Cloud Storage bucket to store user state information.

Migrate the database to Bigtable and use it to serve all global user traffic.

Migrate the database to Cloud Spanner and use it to serve all global user traffic.

Migrate the database to Firestore in Datastore mode and use it to serve all global user traffic.

Migrate the services to Google Kubernetes Engine and use a load balancer service to better scale the application.

Take frequent snapshots of all of the VMs.

Install the Stackdriver Logging agent on the VMs.

Install the Stackdriver Monitoring agent on the VMs.

Use Stackdriver Trace to look for performance bottlenecks.

Cloud Armor

Cloud Functions

Cloud Endpoints

Shielded Virtual Machines

Block all traffic on port 443.

Allow all traffic into the network.

Allow traffic on port 443 for a specific tag.

Allow all traffic on port 443 into the network.

Use App Engine for autoscaling.

Use Cloud Functions for autoscaling.

Use a Compute Engine cluster for the service.

Use a dedicated Compute Engine virtual machine instance for the service.

Create a service account and download its key. Use the key to authenticate to Cloud Key Management Service (KMS) to obtain the database credentials.

Create a service account and download its key. Use the key to authenticate to Cloud Key Management Service (KMS) to obtain a key used to decrypt the database credentials.

Create a service account and grant it the roles/iam.serviceAccountUser role. Impersonate as this account and authenticate using the Cloud SQL Proxy.

Grant the roles/secretmanager.secretAccessor role to the Compute Engine service account. Store and access the database credentials with the Secret Manager API.

Use the current single instance MySQL on Compute Engine and several read-only MySQL servers on

Compute Engine.

Use the current single instance MySQL on Compute Engine, and replicate the data to Cloud SQL in an

external master configuration.

Replace the current single instance MySQL instance with Cloud SQL, and configure high availability.

Replace the current single instance MySQL instance with Cloud SQL, and Google provides redundancy

without further configuration.

Create manual subnets.

Create an auto mode subnet.

Create multiple peered VPCs.

Provision a single instance for NAT.

Cloud Spanner

Cloud Datastore

Cloud Memorystore as a cache

Separate Cloud SQL clusters for each region

Use the Cloud Data Loss Prevention API for redaction of the review dataset.

Use the Cloud Data Loss Prevention API for de-identification of the review dataset.

Use the Cloud Natural Language Processing API for redaction of the review dataset.

Use the Cloud Natural Language Processing API for de-identification of the review dataset.

BigQuery

Cloud SQL

Cloud Spanner

Cloud Datastore

Cloud Profiler

Cloud Monitoring

Cloud Trace

Cloud Logging

Cloud VPN

Cloud Armor

Virtual Private Cloud

Cloud Identity-Aware Proxy

Increase the size of the instance class.

Change the Persistent Disk type to SSD.

Change /product-details to perform the requests in parallel.

Store the /sku-details information in a database, and replace the webservice call with a database query.

Traffic Director

Service Directory

Anthos Service Mesh

Internal HTTP(S) Load Balancing

Create a Google service account with BigQuery access. Add the JSON key to Secret Manager, and use the Go client library to access the JSON key.

Create a Google service account with BigQuery access. Add the Google service account JSON key as a Kubernetes secret, and configure the application to use this secret.

Create a Google service account with BigQuery access. Add the Google service account JSON key to Secret Manager, and use an init container to access the secret for the application to use.

Create a Google service account and a Kubernetes service account. Configure Workload Identity on the GKE cluster, and reference the Kubernetes service account on the application Deployment.

Set the asynchronous option for your requests to the API to false and omit the widget displaying the API

results when a timeout or error is encountered.

Set the asynchronous option for your request to the API to true and omit the widget displaying the API

results when a timeout or error is encountered.

Catch timeout or error exceptions from the API call and keep trying with exponential backoff until the API

response is successful.

Catch timeout or error exceptions from the API call and display the error response in the UI widget.

When creating your instances, configure a startup script using the gcloud command to determine the project name that indicates the correct environment.

In each project, configure a metadata key “environment” whose value is the environment it serves. Use your deployment tool to query the instance metadata and configure the application based on the “environment” value.

Deploy your chosen deployment tool on an instance in each project. Use a deployment job to retrieve the appropriate configuration file from your version control system, and apply the configuration when deploying the application on each instance.

During each instance launch, configure an instance custom-metadata key named “environment” whose value is the environment the instance serves. Use your deployment tool to query the instance metadata, and configure the application based on the “environment” value.

Option A

Option B

Option C

Option D

Option E

Perform a rolling deployment, and test your new application after the deployment is complete.

Perform A/B testing, and test your application periodically after the new tests are implemented.

Perform a blue/green deployment, and test your new application after the deployment is. complete.

Perform a canary deployment, and test your new application periodically after the new version is deployed.

Create a Service Directory Namespace Use API calls to register the services during deployment, and query during runtime.

Configure your microservices to use the Cloud Run Admin and Cloud Functions APIs to query for deployed Cloud Run services and Cloud Functions in the Google Cloud project.

Deploy Hashicorp Consul on a single Compute Engine Instance Register the services with Consul during deployment and query during runtime

Rename the Cloud Functions and Cloud Run services endpoints using a well-documented naming

convention

Your Memorystore for Redis instance was deployed without a public IP address.

You configured your Serverless VPC Access connector in a different region than your App Engine instance.

The firewall rule allowing a connection between App Engine and Memorystore was removed during an infrastructure update by the DevOps team.

You configured your application to use a Serverless VPC Access connector on a different subnet in a different availability zone than your App Engine instance.

Package each component in a separate container. Implement readiness and liveness probes.

Package the application in a single container. Use a process management tool to manage each component.

Package each component in a separate container. Use a script to orchestrate the launch of the components.

Package the application in a single container. Use a bash script as an entrypoint to the container, and then spawn each component as a background job.

Create an image that has cURL installed and configure cURLto run a test plan Deploy the image in a

managed instance group, and run one instance of the image for each VM.

Create an image that has cURL installed and configure cURL to run a test plan Deploy the image in an

unmanaged instance group, and run one instance of the image for each VM.

Deploy a distributed load testing framework on a private Google Kubernetes Engine Cluster Deploy

additional Pods as needed to initiate more traffic and support the number of concurrent users.

Download the container image of a distributed load testing framework on Cloud Shell Sequentially start

several instances of the container on Cloud Shell to increase the load on the API.

Create a table named Customers. Add an Array field in a table that will hold phone numbers for the customer.

Create a table named Customers. Create a table named Phones. Add a CustomerId field in the Phones table to find the CustomerId from a phone number.

Create a table named Customers. Add an Array field in a table that will hold phone numbers for the customer. Create a secondary index on the Array field.

Create a table named Customers as a parent table. Create a table named Phones, and interleave this table into the Customer table. Create an index on the phone number field in the Phones table.

Create two jobs: one that checks whether the container can connect to the database, and another that runs the shutdown script if the Pod is failing.

Create the Deployment with a livenessProbe for the container that will fail if the container can't connect to the database. Configure a Prestop lifecycle handler that runs the shutdown script if the container is failing.

Create the Deployment with a PostStart lifecycle handler that checks the service availability. Configure a PreStop lifecycle handler that runs the shutdown script if the container is failing.

Create the Deployment with an initContainer that checks the service availability. Configure a Prestop lifecycle handler that runs the shutdown script if the Pod is failing.

gsutil test –o output.json gs://my-bucket

gsutil perfdiag –o output.json gs://my-bucket

gcloud compute scp example-instance:~/test-data –o output.json gs://my-bucket

gcloud services test –o output.json gs://my-bucket

Use the JOIN operator in SQL to combine the tables.

Use nested WITH statements to combine the tables.

Use the UNION operator in SQL to combine the tables.

Use the UNION ALL operator in SQL to combine the tables.

Store the logs in a Cloud Storage bucket with bucket lock turned on.

Store the logs in a Cloud Storage bucket with a 3-year retention period.

Store the logs in Cloud Logging as custom logs with a custom retention period.

Store the logs in a Cloud Storage bucket with a 1-year retention period. After 1 year, move the logs to another bucket with a 2-year retention period.

Develop the microservice code in the same programming language used by the microservice caller.

Create an API contract agreement between the microservice implementation and microservice caller.

Require asynchronous communications between all microservice implementations and microservice callers.

Ensure that sufficient instances of the microservice are running to accommodate the performance requirements.

Implement a versioning scheme to permit future changes that could be incompatible with the current interface.

The use of 64-bit numeric types for 32-bit numbers.

The use of the STRING data type for arbitrary-precision values.

The use of Version 1 UUIDs as primary keys that increase monotonically.

The use of LIKE instead of STARTS_WITH keyword for parameterized SQL queries.

Build a test harness to generate requests and deploy it to Cloud Run. Analyze the VPC Flow Logs using Cloud Logging.

Create a Google Kubernetes Engine cluster running the Locust or JMeter images to dynamically generate load tests. Analyze the results using Cloud Trace.

Create a Cloud Task to generate a test load. Use Cloud Scheduler to run 60,000 Cloud Task transactions per minute for 10 minutes. Analyze the results using Cloud Monitoring.

Create a Compute Engine instance that uses a LAMP stack image from the Marketplace, and use Apache Bench to generate load tests against the service. Analyze the results using Cloud Trace.

Distribute your workload evenly using a multi-zonal node pool.

Distribute your workload evenly using multiple zonal node pools.

Use cluster autoscaler to resize the number of nodes in the node pool, and use a Horizontal Pod Autoscaler to scale the workload.

Create a managed instance group for Compute Engine with the cluster nodes. Configure autoscaling rules for the managed instance group.

Create alerting policies in Cloud Monitoring based on GKE CPU and memory utilization. Ask an on-duty engineer to scale the workload by executing a script when CPU and memory usage exceed predefined thresholds.

Enable Application-layer Secrets on the GKE cluster to protect the cluster.

Deploy a namespace per tenant and use Network Policies in each blog deployment.

Use GKE Audit Logging to identify malicious containers and delete them on discovery.

Build a custom image of the blogging software and use Binary Authorization to prevent untrusted image deployments.