Google Professional-Cloud-Developer Dumps

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.

Create manual subnets.

Create an auto mode subnet.

Create multiple peered VPCs.

Provision a single instance for NAT.

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

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.

Cloud Armor

Cloud Functions

Cloud Endpoints

Shielded Virtual Machines

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.

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.

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.

Cloud VPN

Cloud Armor

Virtual Private Cloud

Cloud Identity-Aware Proxy

Cloud Profiler

Cloud Monitoring

Cloud Trace

Cloud Logging

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.

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.

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.

Cloud Spanner

Cloud Datastore

Cloud Memorystore as a cache

Separate Cloud SQL clusters for each region

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

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.

Use the service account attached to the GKE node.

Enable Workload Identity in the cluster via the gcloud command-line tool.

Access the Google service account keys from a secret management service.

Store the Google service account keys in a central secret management service.

Use gcloud to bind the Kubernetes service account and the Google service account using roles/iam.workloadIdentity.

Write to Cloud Spanner using Cloud Client Libraries.

Write to Cloud Spanner using Google API Client Libraries

Write to Cloud Spanner using a custom gRPC client library.

Write to Cloud Spanner using a third-party HTTP client library.

Deploy the third-party solution as a DaemonSet

Modify your container image to include the monitoring software

Use SSH to connect to the GKE node, and install the software manually

Deploy the third-party solution using Terraform and deploy the logging Pod as a Kubernetes Deployment

Embed the appropriate database connection string in the image. Create a different image for each environment.

When creating the Compute Engine instance, add a tag with the name of the database to be connected. In your application, query the Compute Engine API to pull the tags for the current instance, and use the tag to construct the appropriate database connection string.

When creating the Compute Engine instance, create a metadata item with a key of “DATABASE” and a value for the appropriate database connection string. In your application, read the “DATABASE” environment variable, and use the value to connect to the appropriate database.

When creating the Compute Engine instance, create a metadata item with a key of “DATABASE” and a value for the appropriate database connection string. In your application, query the metadata server for the “DATABASE” value, and use the value to connect to the appropriate database.

Using Identity and Access Management (IAM), grant the Viewer IAM role on the cluster project to the other team.

Create a new GKE cluster. Using Identity and Access Management (IAM), grant the Editor role on the cluster project to the other team.

Create a new namespace in the existing cluster. Using Identity and Access Management (IAM), grant the Editor role on the cluster project to the other team.

Create a new namespace in the existing cluster. Using Kubernetes role-based access control (RBAC), grant the Admin role on the new namespace to the other team.

Create one Pub/Sub topic. Create one pull subscription to allow the audit services to share the messages.

Create one Pub/Sub topic. Create one pull subscription per audit service instance to allow the services to share the messages.

Create one Pub/Sub topic. Create one push subscription with the endpoint pointing to a load balancer in front of the audit services.

Create one Pub/Sub topic per authentication service. Create one pull subscription per topic to be used by one audit service.

Create one Pub/Sub topic per authentication service. Create one push subscription per topic, with the endpoint pointing to one audit service.

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

Blue/green deployment

Canary deployment

Rolling deployment

Recreate deployment

Trigger a Spinnaker pipeline configured as an A/B test of your new code and, if it is successful, deploy the container to production.

Trigger a Spinnaker pipeline configured as a canary test of your new code and, if it is successful, deploy the container to production.

Trigger another Cloud Build job that uses the Kubernetes CLI tools to deploy your new container to your GKE cluster, where you can perform a canary test.

Trigger another Cloud Build job that uses the Kubernetes CLI tools to deploy your new container to your GKE cluster, where you can perform a shadow test.

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 an Ingress that uses the API's URL to route requests to the appropriate backend.

Leverage a Service Discovery system, and connect to the backend specified by the request.

Use multiple clusters, and use DNS entries to route requests to separate versioned backends.

Combine multiple versions in the same service, and then specify the API version in the POST request.

Set the Max Surge to 100%.

Set the Update mode to Opportunistic.

Set the Maximum Unavailable to 100%.

Set the Minimum Wait time to 0 seconds.

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”

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.

Firestore in Native mode

Cloud Storage using an object read

Cloud SQL using a SQL SELECT statement

Firestore in Datastore mode using a global query

Store and retrieve the file contents using Compute Engine instance metadata.

Output the file contents to a file in /workspace. Read from the same /workspace file in the subsequent build step.

Use gsutil to output the file contents to a Cloud Storage object. Read from the same object in the subsequent build step.

Add a build argument that runs an HTTP POST via curl to a separate web server to persist the value in one builder. Use an HTTP GET via curl from the subsequent build step to read the value.

Configure the appropriate service accounts, and use Workload Identity to run the pods.

Store the application credentials as Kubernetes Secrets, and expose them as environment variables.

Configure the appropriate routing rules, and use a VPC-native cluster to directly connect to the database.

Store the application credentials using Cloud Key Management Service, and retrieve them whenever a database connection is made.

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.

Set a retention policy on the bucket with a period of 7 years.

Use IAM Conditions to provide access to objects 7 years after the object creation date.

Enable Object Versioning to prevent objects from being accidentally deleted for 7 years after object creation.

Create an object lifecycle policy on the bucket that moves objects from Standard Storage to Archive Storage after 3 years.

Implement a Cloud Function that checks the age of each object in the bucket and moves the objects older than 3 years to a second bucket with the Archive Storage class. Use Cloud Scheduler to trigger the Cloud Function on a daily schedule.