Professional-Cloud-Developer Questions and Answers

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.

Cloud Armor

Cloud Functions

Cloud Endpoints

Shielded Virtual Machines

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

BigQuery

Cloud SQL

Cloud Spanner

Cloud Datastore

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.

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

Create manual subnets.

Create an auto mode subnet.

Create multiple peered VPCs.

Provision a single instance for NAT.

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.

Access-Control-Allow-Origin: *

Access-Control-Allow-Origin: https://*.example.com

Access-Control-Allow-Origin: https://fn.example.com

Access-Control-Allow-origin: https://www.example.com

Create a separate dataset for each department. Create a view with an appropriate WHERE clause to

select records from a particular dataset for the specific department. Authorize this view to access records

from your Master dataset. Give employees the permission to this department-specific dataset.

Create a separate dataset for each department. Create a data pipeline for each department to copy

appropriate information from the Master dataset to the specific dataset for the department. Give employees

the permission to this department-specific dataset.

Create a dataset named Master dataset. Create a separate view for each department in the Master

dataset. Give employees access to the specific view for their department.

Create a dataset named Master dataset. Create a separate table for each department in the Master

dataset. Give employees access to the specific table for their department.

Determine whether your file system is corrupted.

Access Compute Engine as a different SSH user.

Troubleshoot firewall rules or routes on an instance.

Check whether your instance boot disk is completely full.

Check whether network traffic to or from your instance is being dropped.

Deploy a Cloud Function for each step that calls the corresponding downstream system to complete the required action.

Create a Pub/Sub topic for each step. Create a subscription for each downstream development team to subscribe to their step's topic.

Create a Pub/Sub topic for timesheet submissions. Create a subscription for each downstream development team to subscribe to the topic.

Create a timesheet microservice deployed to Google Kubernetes Engine. The microservice calls each downstream step and waits for a successful response before calling the next step.

Store the credentials in a sidecar container proxy, and use it to connect to the third-party database.

Configure a service mesh to allow or restrict traffic from the Pods in your microservice to the database.

Store the credentials in an encrypted volume mount, and associate a Persistent Volume Claim with the client Pod.

Store the credentials as a Kubernetes Secret, and use the Cloud Key Management Service plugin to handle encryption and decryption.

1) App Engine

2) Pub/Sub

3) BigQuery

4) Firestore

1) Dataflow

2) Pub/Sub

3) Firestore

4) BigQuery

1) Pub/Sub

2) Dataflow

3) BigQuery

4) Firestore

1) Pub/Sub

2) Dataflow

3) Firestore

4) BigQuery

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.

Cloud VPN

Cloud Armor

Virtual Private Cloud

Cloud Identity-Aware Proxy

Cloud Spanner

Cloud Datastore

Cloud Memorystore as a cache

Separate Cloud SQL clusters for each region

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.

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.

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.

1 Configure your Cl/CD pipeline to update the Deployment manifest file by replacing the container version with the latest version.

2 Recreate the Pods in your cluster by applying the Deployment manifest file.

3 Validate the application's performance by comparing its functionality with the previous release version and roll back if an issue arises.

1 install the Anthos Service Mesh on your GKE cluster.

2 Create two Deployments on the GKE cluster and label them with different version names.

3 Create a VirtualService with a routing rule to send a small percentage of traffic to the Deployment that references the new version of the application.

1 Create a second namespace on GKE for the new release version.

2 Create a Deployment configuration for the second namespace with the desired number of Pods.

3 Deploy new container versions in the second namespace.

4 Update the ingress configuration to route traffic to the namespace with the new container versions.

1. Implement a rolling update pattern by replacing the Pods gradually with the new release versify.

2 Validate the application's performance for the new subset of users during the rollout and roll back if an issue arises.

Pipe the content of the files to the Linux Syslog daemon.

Install a Google version of fluentd on the Compute Engine instance.

Install a Google version of collectd on the Compute Engine instance.

Using cron, schedule a job to copy the log files to Cloud Storage once a day.

App Engine backed by Cloud Storage

Compute Engine backed by Persistent Disk

Transfer Appliance backed by Cloud Filestore

Cloud Content Delivery Network (CDN) backed by Cloud Storage

Configure a GKE Ingress resource.

Configure a GKE Service resource.

Configure a GKE Ingress resource with type: LoadBalancer.

Configure a GKE Service resource with type: LoadBalancer.

Store each comment in a subcollection of the article.

Add each comment to an array property on the article.

Store each comment in a document, and add the comment’s key to an array property on the article.

Store each comment in a document, and add the comment’s key to an array property on the user profile.

Change your application s logging library to the Cloud Logging library and configure your application to export logs to Cloud Logging

Update your application to output logs in CSV format, and add the necessary metadata to the CSV.

Install the Fluent Bit agent on each of your GKE nodes, and have the agent export all logs from /var/ log.

Update your application to output logs in JSON format, and add the necessary metadata to the JSON

Cloud Run

Compute Engine with managed instance groups

Compute Engine with unmanaged instance groups

Google Kubernetes Engine using cluster autoscaling

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.

Smoke tests

Stackdriver uptime checks

Cloud Load Balancing - heath checks

Managed instance group - heath checks