Replace your entire monitoring platform with Stackdriver.

Install the Stackdriver agents on your Compute Engine instances.

Use Stackdriver to capture and alert on logs, then ship them to your existing platform.

Migrate some traffic back to your old platform and perform AB testing on the two platforms concurrently.

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.

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.

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.

Cloud Profiler

Cloud Monitoring

Cloud Trace

Cloud Logging

Cloud Armor

Cloud Functions

Cloud Endpoints

Shielded Virtual Machines

Cloud VPN

Cloud Armor

Virtual Private Cloud

Cloud Identity-Aware Proxy

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.

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

Create manual subnets.

Create an auto mode subnet.

Create multiple peered VPCs.

Provision a single instance for NAT.

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.

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.

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.

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.

Cloud Amor

Stackdriver Debugger

Cloud Security Scanner

Stackdriver Error Reporting

Create a custom jndex over the products

Modify the query that returns the product list using cursors with limits

Modify the Cloud Run configuration to increase the memory limits

Modify the query that returns the product list using integer offsets

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.

Use Cloud Code to develop applications.

Use the Cloud Shell integrated Code Editor to edit code and configuration files.

Use a Cloud Notebook instance to ingest and process data and deploy models.

Use Cloud Shell to manage your infrastructure and applications from the command line.

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.

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.

BigQuery

Cloud SQL

Cloud Spanner

Cloud Datastore

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 the HBase API, Redis API, and MySQL connection to retrieve database lists. Combine the results, and then apply the filter to display the results

Use the HBase API, Redis API, and MySQL connection to retrieve database lists. Filter the results individually, and then combine them to display the results

Run gcloud bigtable instances list, gcloud redis instances list, and gcloud sql databases list. Use a filter within the application, and then display the results

Run gcloud bigtable instances list, gcloud redis instances list, and gcloud sql databases list. Use --filter flag with each command, and then display the results

Create a new feature branch, and ask the build team to rebuild the image.

Shut down the deployed virtual machine, export the disk, and then mount the disk locally to access the boot logs.

Install Packer locally, build the Compute Engine image locally, and then run it in your personal Google Cloud project.

Check Compute Engine OS logs using the serial port, and check the Cloud Logging logs to confirm access to the serial port.

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.

Write a shutdown script that uses inter-process signals to notify the application process to disconnect from the database.

Write a shutdown script that broadcasts a message to all signed-in users that the Compute Engine instance is going down and instructs them to save current work and sign out.

Write a shutdown script that writes a file in a location that is being polled by the application once every five minutes. After the file is read, the application disconnects from the database.

Write a shutdown script that publishes a message to the Pub/Sub topic announcing that a shutdown is in progress. After the application reads the message, it disconnects from the database.

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.

Deploy the website on App Engine and use traffic splitting.

Deploy the website on App Engine as three separate services.

Deploy the website on Cloud Functions and use traffic splitting.

Deploy the website on Cloud Functions as three separate functions.

Change the application to accept images directly and store them in the database that stores other user information.

Change the application to create signed URLs for Cloud Storage. Transfer these signed URLs to the client application to upload images to Cloud Storage.

Set up a web server on GCP to accept user images and create a file store to keep uploaded files. Change the application to retrieve images from the file store.

Create a separate bucket for each user in Cloud Storage. Assign a separate service account to allow write access on each bucket. Transfer service account credentials to the client application based on user information. The application uses this service account to upload images to Cloud Storage.