Professional-Cloud-Developer Google Certified Professional - Cloud Developer Questions and Answers

Cloud Armor

Cloud Functions

Cloud Endpoints

Shielded Virtual Machines

Assign the Project Editor role.

Assign the Project Owner role.

Assign the Cloud SQL Client role.

Assign the Cloud SQL Editor role.

Cloud Profiler

Cloud Monitoring

Cloud Trace

Cloud Logging

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.

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.

Use Cloud SQL, and assign the roles/cloudsql.editor role to the service account.

Use Bigtable, and assign the roles/bigtable.viewer role to the service account.

Use Firestore in Native mode and assign the roles/datastore.user role to the service account.

Use Firestore in Datastore mode and assign the roles/datastore.viewer role to the service account.

Create a new service account that has Editor authority to access the resources. The deployer is given permission to get the access token.

Create a new service account that has a custom IAM role to access the resources. The deployer is given permission to get the access token.

Create a new service account that has Editor authority to access the resources. The deployer is given permission to act as the new service account.

Create a new service account that has a custom IAM role to access the resources. The deployer is given permission to act as the new service account.

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.

With an OAuth Client ID that uses the https://www.googleapis.com/auth/drive.file scope to

obtain an access token for each user.

With an OAuth Client ID with delegated domain-wide authority.

With the App Engine service account and https://www.googleapis.com/auth/drive.file scope

that generates a signed JWT.

With the App Engine service account with delegated domain-wide authority.

Create manual subnets.

Create an auto mode subnet.

Create multiple peered VPCs.

Provision a single instance for NAT.

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.

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.

Build the application in Python with Firestore as the database. Deploy the application to Cloud Run.

Build the application in C# with Firestore as the database. Deploy the application to App Engine flexible environment.

Build the application in Python with CloudSQL as the database. Deploy the application to App Engine standard environment.

Build the application in Python with Firestore as the database. Deploy the application to a Compute Engine managed instance group with autoscaling.

Add the users to their projects, assign the relevant roles to the users, and then provide the users with each relevant Project ID.

Add the users to their projects, assign the relevant roles to the users, and then provide the users with each relevant Project Number.

Create groups, add the users to their groups, assign the relevant roles to the groups, and then provide the users with each relevant Project ID.

Create groups, add the users to their groups, assign the relevant roles to the groups, and then provide the users with each relevant Project Number.

1. Enable Cloud SQL and Cloud Run in the same project.

2. Configure a private IP address for Cloud SQL. Enable private services access.

3. Create a Serverless VPC Access connector.

4. Configure Cloud Run to use the connector to connect to Cloud SQL.

1. Install PostgreSQL on a Compute Engine virtual machine (VM), and enable Cloud Run in the same project.

2. Configure a private IP address for the VM. Enable private services access.

3. Create a Serverless VPC Access connector.

4. Configure Cloud Run to use the connector to connect to the VM hosting PostgreSQL.

1. Use Cloud SQL and Cloud Run in different projects.

2. Configure a private IP address for Cloud SQL. Enable private services access.

3. Create a Serverless VPC Access connector.

4. Set up a VPN connection between the two projects. Configure Cloud Run to use the connector to connect to Cloud SQL.

1. Install PostgreSQL on a Compute Engine VM, and enable Cloud Run in different projects.

2. Configure a private IP address for the VM. Enable private services access.

3. Create a Serverless VPC Access connector.

4. Set up a VPN connection between the two projects. Configure Cloud Run to use the connector to access the VM hosting PostgreSQL

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.

Cloud VPN

Cloud Armor

Virtual Private Cloud

Cloud Identity-Aware Proxy

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.

Use canary deployment

Use blue/green deployment

Use rolling updates deployment

Use A/B testing with traffic mirroring during deployment

Use an external HTTP(S) load balancer to route a predetermined percentage of traffic to two different color

schemes of your application Analyze the results to determine whether there is a statistically significant

difference in sales.

Use an external HTTP(S) load balancer to route traffic to the original color scheme while the new deployment

is created and tested After testing is complete reroute all traffic to the new color scheme Analyze the

results to determine whether there is a statistically significant difference in sales.

Enable a feature flag that displays the new color scheme to half of all users. Monitor sales to see whether

they increase for this group of users.

Use an external HTTP(S) load balancer to mirror traffic to the new version of your application Analyze the

results to determine whether there is a statistically significant difference in sales.

Create custom metrics from the Cloud Logging logs, and use Prometheus to import the results using the Cloud Monitoring REST API.

Export the Cloud Logging logs and the Prometheus metrics to Cloud Bigtable. Run a query to join the results, and analyze in Google Data Studio.

Export the Cloud Logging logs and stream the Prometheus metrics to BigQuery. Run a recurring query to join the results, and send notifications using Cloud Tasks.

Export the Prometheus metrics and use Cloud Monitoring to view them as external metrics. Configure Cloud Monitoring to create log-based metrics from the logs, and correlate them with the Prometheus data.

Cloud Spanner

Cloud Datastore

Cloud Memorystore as a cache

Separate Cloud SQL clusters for each region

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 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

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

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.

Add the label “AUTOSCALE” to the instance group template.

Decrease the cool-down period for instances added to the group.

Increase the target CPU usage for the instance group autoscaler.

Decrease the target CPU usage for the instance group autoscaler.

Remove the health-check for individual VMs in the instance group.

Use Stackdriver Monitoring to plot slot usage.

Use Stackdriver Trace to plot API execution time.

Use Stackdriver Trace to plot query execution time.

Use Stackdriver Monitoring to plot query execution times.

Directly persist each POST request’s JSON data into Datastore.

Transform the POST request’s JSON data, and stream it into BigQuery.

Transform the POST request’s JSON data, and store it in a regional Cloud SQL cluster.

Persist each POST request’s JSON data as an individual file within Cloud Storage, with the file name containing the request identifier.

Request additional GKE quota is the GCP Console.

Request additional Compute Engine quota in the GCP Console.

Open a support case to request additional GKE quotA.

Decouple services in the cluster, and rewrite new clusters to function with fewer cores.

Bind the user identity to the pubsub.publisher and pubsub.subscriber roles at the resource level.

Grant the user identity the pubsub.publisher and pubsub.subscriber roles at the project level.

Grant the user identity a custom role that contains the pubsub.topics.create and pubsub.subscriptions.create permissions.

Configure the application to run as a service account that has the pubsub.publisher and pubsub.subscriber roles.

Create a service to publish messages, and deploy the Pub/Sub emulator. Generate random content in the publishing service, and publish to the emulator.

Create a service to publish messages to your application. Collect the messages from Pub/Sub in production, and replay them through the publishing service.

Create a service to publish messages, and deploy the Pub/Sub emulator. Collect the messages from Pub/Sub in production, and publish them to the emulator.

Create a service to publish messages, and deploy the Pub/Sub emulator. Publish a standard set of testing messages from the publishing service to the emulator.

Use BigQuery federated queries to query data from Cloud Storage.

Create a dataset in the EU region that will keep information about EU users only.

Create a Cloud Storage bucket in the EU region to store information for EU users only.

Re-upload your data using to a Cloud Dataflow pipeline by filtering your user records out.

Use DML statements in BigQuery to update/delete user records based on their requests.

Host the application on Compute Engine, and configure Cloud Endpoints for your application.

Host the application on Google Kubernetes Engine and use Identity-Aware Proxy (IAP) with Cloud Load Balancing and Google-managed certificates.

Host the application on Google Kubernetes Engine, and deploy an NGINX Ingress Controller to handle authentication.

Host the application on Google Kubernetes Engine, and deploy cert-manager to manage SSL certificates.

Configure your Cloud Run service with a Cloud SQL connection.

Configure your Cloud Run service to use a Serverless VPC Access connector

Configure your application to use the Cloud SQL Java connector

Configure your application to connect to an instance of the Cloud SQL Auth proxy

Deployment

StatefulSet

ReplicaSet

ReplicaController

A linked list

A hash table

A two-dimensional array

A comma-delimited string

Use global HTTP(S) Load Balancing with managed SSL certificates to protect your services

Deploy open source Istio in your GKE cluster, and enable mTLS in your Service Mesh

Install cert-manager on GKE to automatically renew the SSL certificates.

Install Anthos Service Mesh, and enable mTLS in your Service Mesh.

Specify the resource limits and requests in the object specifications.

Create a namespace for each team, and attach resource quotas to each namespace.

Create a LimitRange to specify the default compute resource requirements for each namespace.

Create a Kubernetes service account (KSA) for each application, and assign each KSA to the namespace.

Use the Anthos Policy Controller to enforce label annotations on all namespaces. Use taints and tolerations to allow resource sharing for namespaces.

gsutil cp --project “my-gcp-project” -r ~/local-scripts/ gcp-instance-name:~/

server-scripts/ --zone “us-east1-b”

gsutil cp --project “my-gcp-project” -R ~/local-scripts/ gcp-instance-name:~/

server-scripts/ --zone “us-east1-b”

gcloud compute scp --project “my-gcp-project” --recurse ~/local-scripts/ gcpinstance-

name:~/server-scripts/ --zone “us-east1-b”

gcloud compute mv --project “my-gcp-project” --recurse ~/local-scripts/ gcpinstance-

name:~/server-scripts/ --zone “us-east1-b”

Store the session information in Pub/Sub, and store the shopping cart information in Cloud SQL.

Store the shopping cart information in a file on Cloud Storage where the filename is the SESSION ID.

Store the session and shopping cart information in a MySQL database running on multiple Compute Engine instances.

Store the session information in Memorystore for Redis or Memorystore for Memcached, and store the shopping cart information in Firestore.

Use FTP to upload files.

Use CPanel to upload files.

Use signed URLs to upload files.

Change the API to be a multipart file upload API.

Build a new Docker container that examines the files in /workspace and then checks and adds a copyright for each source file. Changed files are explicitly committed back to the source repository.

Build a new Docker container that examines the files in /workspace and then checks and adds a copyright for each source file. Changed files do not need to be committed back to the source repository.

Build a new Docker container that examines the files in a Cloud Storage bucket and then checks and adds a copyright for each source file. Changed files are written back to the Cloud Storage bucket.

Build a new Docker container that examines the files in a Cloud Storage bucket and then checks and adds a copyright for each source file. Changed files are explicitly committed back to the source repository.

Migrate your data stored in Hadoop to BigQuery. Change your jobs to source their information from BigQuery instead of the on-premises Hadoop environment.

Create Compute Engine instances with HDD instead of SSD to save costs. Then perform a full migration of your existing environment into the new one in Compute Engine instances.

Create a Cloud Dataproc cluster on Google Cloud Platform, and then migrate your Hadoop environment to the new Cloud Dataproc cluster. Move your HDFS data into larger HDD disks to save on storage costs.

Create a Cloud Dataproc cluster on Google Cloud Platform, and then migrate your Hadoop code objects to the new cluster. Move your data to Cloud Storage and leverage the Cloud Dataproc connector to run jobs on that data.

Use Cloud Logging to check for error logs, and reduce Spanner processing units by small increments until you find the minimum capacity required.

Use Cloud Trace to monitor the requests per sec of incoming requests to Spanner, and reduce Spanner processing units by small increments until you find the minimum capacity required.

Use Cloud Monitoring to monitor the CPU utilization, and reduce Spanner processing units by small increments until you find the minimum capacity required.

Use Snapshot Debugger to check for application errors, and reduce Spanner processing units by small increments until you find the minimum capacity required.

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.

Option A

Option B

Option C

Option D

Create a Cloud Storage bucket in each region, and create a Cloud Run service of the payment processing application in each region.

Create a Cloud Storage bucket in each region, and create three Cloud Run services of the payment processing application in the Singapore region.

Create three Cloud Storage buckets in the Asia multi-region, and create three Cloud Run services of the payment processing application in the Singapore region.

Create three Cloud Storage buckets in the Asia multi-region, and create three Cloud Run revisions of the payment processing application in the Singapore region.

Push your source code to Artifact Registry.

Submit a Cloud Build job to push the image.

Use the pack build command with pack CLI.

Include the --source flag with the gcloud run deploy CLI command.

Include the --platform=kubernetes flag with the gcloud run deploy CLI command.

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.

Wait 10 minutes, then verify that Trace captures those types of requests automatically.

Write a custom script that sends this type of request repeatedly from your dev project.

Use the Trace API to apply custom attributes to the trace.

Add the X-Cloud-Trace-Context header to the request with the appropriate parameters.

Store user data on a Cloud Shell home disk and log in at least every 120 days to prevent its deletion

Store user data on a persistent disk in a Compute Engine instance

Store user data m BigQuery tables

Store user data in a Cloud Storage bucket

Use the gsutil utility to copy files from within the Docker container at startup, and start the service using an ENTRYPOINT script.

Create a PersistentVolumeClaim on the GKE cluster. Access the configuration files from the volume, and start the service using an ENTRYPOINT script.

Use the COPY statement in the Dockerfile to load the configuration into the container image. Verify that the configuration is available, and start the service using an ENTRYPOINT script.

Add a startup script to the GKE instance group to mount the NFS share at node startup. Copy the configuration files into the container, and start the service using an ENTRYPOINT script.