Google Practice Questions, Discussions & Exam Topics by our Authors
Your organization is building an application powered by generative AI that uses sensitive internal data lo train the AI model. The application is built using Vertex AI, which is generally available in your region. You must ensure Google does not use your sensitive data when tunin...Let’s carefully analyze this step by step. The scenario is: you have sensitive internal data and you want to build a generative AI application on Vertex AI, but you do not want Google to use your data to tune public models, because that could risk sharing sensitive info. --- Option A: Do not use Vertex AI for sensitive data. Use only public data with minimal privacy requirements. Analysis: This is a very conservative approach: it avoids any risk of exposing sensitive data. Key factor: It restricts you from using sensitive internal data altogether. When suitable: Only if you cannot risk any data being used in training. Why not ideal here: You do want to use sensitive internal data for your application, so avoiding Vertex AI entirely defeats the purpose. ✅ Rejected: Too restrictive; not practical if your app requires sensitive data. --- Option B: Encrypt your data by using customer-managed encryption keys (CMEK) to have full control over encryption key access. Analysis: CMEK ensures you control the encryption keys, so data at rest is encrypted with your key. Key factor: This protects data from unauthorized access, but does not prevent Google from using the data to tune public models. CMEK is about storage and access, not about AI model tuning policies. When suitable: When you want full encryption control for compliance and data security. Why not enough here: The requirement specifically asks that Google not use your data for tuning, which CMEK alone cannot guarantee. ✅ Rejected: Protects encryption but does not prevent y... Author: Sara · Last updated Jun 8, 2026 |
Your organization is deploying a new web application on Compute Engine and needs robust perimeter security. You need to protect the application from common web attacks, including SQL injection and cross-site scripting (XSS), while al...Let's analyze the scenario carefully. The requirements are: Deploy a web application on Compute Engine. Ensure robust perimeter security. Protect against common web attacks (SQL injection, XSS). Control network traffic based on source IP and user identity. We’ll go option by option. --- Option A: > Implement Cloud Load Balancing and Cloud DNS. Set up Cloud CDN to cache content and mitigate some DDoS attacks. Configure Cloud Armor to provide layer 7 protection. Pros: Cloud Armor can protect against layer 7 attacks (e.g., SQL injection, XSS). Cloud CDN + Cloud Load Balancing helps mitigate DDoS. Cons: This option does not include identity-based access control. Firewall or IAM integration for controlling access by specific users is missing. Conclusion: Not suitable because it only addresses web attacks and DDoS, but not user-based access control. --- Option B: > Deploy Cloud Armor with its default WAF rules enabled. Configure network firewall rules on the Compute Engine instances to control all traffic based on source IP addresses. Use Cloud IAM to manage which users have roles granting access to the web application. Pros: Cloud Armor provides WAF protection (SQLi, XSS). Network firewall rules control source IP addresses. Cloud IAM can assign roles to users. Cons: IAM roles are for managing GCP resource access, not access to the web application itself. This does not provide user-level access to the application; users could still access it from the web if IP is allowed. Conclusion: Better than A, but IAM cannot enforce web app access; so it does not fully meet the requirement for user identity–based access control. --- Option C: > Use Google Cloud Armor with pre-configured WAF rules to filter malicious traffic. Implement VPC Service Controls to creat... Author: Zain · Last updated Jun 8, 2026 |
Your company is in a regulated industry that requires low overhead encryption using private connectivity from on-premises data centers to Google Cloud. You need to establish connecti...Let’s carefully analyze this GCP networking scenario step by step. Key requirements from your description: 1. Regulated industry → Needs encryption. 2. Low overhead encryption → Prefer hardware or network-level encryption rather than software VPNs that could add CPU load. 3. Private connectivity from on-premises to GCP → Avoid public internet; want private, dedicated links. 4. High availability across multiple regions → Need redundancy and multi-region support. Now, let’s go through each option: --- Option A: Two pairs of HA VPNs using IPSec Pros: Provides encrypted connectivity over the public internet. High Availability (HA) VPNs support redundancy. Cons: Traffic goes over the internet, not private dedicated connections. Higher latency and lower throughput compared to Cloud Interconnect. “Low overhead encryption” requirement is partially met (software-based IPSec adds CPU overhead). Scenario fit: Useful for encrypted internet VPN connections, but not ideal for high-throughput private connectivity. ✅ Reject: Doesn’t meet private, high-performance, low-overhead requirement. --- Option B: Cloud Interconnect with MACSec encryption Pros: Dedicated private connections (Cloud Interconnect) → very low latency, high throughput. MACSec provides hardware-level link encryption, which is low overhead. Can set up redundant connections across multiple regions for high availability. Cons: Slightly more expensive than VPN. Scenario fit: Perfect for regulated industries needing private, encrypted, high-availability, low-overhead connectivity. ✅ Fits all r... Author: Emma · Last updated Jun 8, 2026 |
You manage the security logs within your cloud environment. You have configured a continuous export of security logs to Cloud Storage buckets for long-term retention. You need to provide auditors the ability to analyze the logs that were export...Let’s carefully evaluate each option based on cost-effectiveness, ease of implementation, and auditor access in GCP: --- A) Use a VM instance to download the data from Cloud Storage. Provide the auditors access to the VM and allow them to install their preferred analytics toolset. Pros: Flexible — auditors can use any tool they like. Cons: Operational overhead: You need to maintain the VM, manage OS, security, and updates. Not cost-effective: Running a VM 24/7 or even on-demand could be more expensive than serverless solutions. Security risk: Giving auditors direct VM access can expose your environment to unnecessary risks. Scenario when this could be used: If auditors require a very specific toolset that cannot run on GCP services. But in most cases, this is overkill and inefficient. Verdict: ❌ Not cost-effective or quick to implement. --- B) Use the data in the Cloud Storage bucket as an external table in BigQuery. Provide the auditors access to the BigQuery dataset. Pros: Cost-effective: BigQuery allows querying external tables directly from Cloud Storage without importing all data. Quick to implement: No need to move or transform data; auditors can immediately query logs using SQL. Secure: You can control access at the dataset/table level. Scalable: Handles large volumes of logs efficiently. Cons: Slightly slower queries compared to fully loaded BigQuery tables, but usually acceptable for audits. Scenario when this is ideal: When you need auditors to analyze large log datasets without moving or managing infrastructure. Verdict: ✅ Best balance of cost, speed, and security. --- C) Use Dataflow to import the data from Cloud ... Author: Benjamin · Last updated Jun 8, 2026 |
Your organization currently uses a third-party identity provider (IdP) that only requires a username and password for authentication. You need to enforce 2-step verifi...Let’s carefully break this down. The question is about enforcing 2-step verification (2SV) for Super admins in GCP Cloud Identity while the organization currently uses a third-party IdP that only requires username and password. We need to reason through the options carefully. --- Option A: Create an organizational unit (OU) for Super admins, and enable 2SV within Cloud Identity for the OU. Analysis: Cloud Identity allows you to enforce 2SV per OU, but this only works if Cloud Identity is the authentication source. In this scenario, authentication is delegated to a third-party IdP, which only uses username and password. Therefore, enabling 2SV within Cloud Identity will not be enforced, because the actual login goes through the third-party IdP. Verdict: ❌ Not applicable here. Works only when Cloud Identity handles authentication directly. --- Option B: Collaborate with the third-party IdP to enable 2SV for Super admins while maintaining the current Cloud Identity configuration. Analysis: Since the IdP handles authentication, any 2SV enforcement must happen at the IdP level. This ensures that Super admins authenticate with 2SV before reaching Cloud Identity. Key factor: IdP is authoritative for login. Enforcing 2SV in Cloud Identity alone won’t work because login bypasses it. Verdict: ✅ Correct. Thi... Author: ElectricLionX · Last updated Jun 8, 2026 |
Your organization has a hybrid cloud environment with a data center connected to Google Cloud through a dedicated Cloud Interconnect connection. You need to configure private access from your on-premises hosts to Google APIs, specific...Let’s carefully analyze the scenario and the options. The goal is: Environment: Hybrid cloud (on-premises + GCP) connected via Dedicated Cloud Interconnect. Requirement: Private access from on-premises hosts to Google APIs (Cloud Storage, BigQuery) without using the public internet. We’ll evaluate each option with reasoning. --- Option A: Configure Shared VPC to extend your Google Cloud VPC network to your on-premises environment. Use Private Google Access to access Google APIs. Shared VPC: This is a GCP construct that allows multiple projects to share a single VPC network. It does not extend directly to on-premises—on-premises hosts cannot automatically “join” a Shared VPC. Private Google Access (PGA): Normally used for VM instances in a VPC without external IPs to access Google APIs privately. PGA alone does not work for on-premises hosts. Conclusion: This is not suitable for direct on-premises hosts, unless you route them through a GCP VM or VPN, which is not mentioned. ✅ Rejected. --- Option B: Establish VPC peering between your on-premises network and your Google Cloud VPC network. Configure Cloud Firewall rules to allow traffic to Google API IP ranges. VPC peering: Works between two GCP VPCs, not for on-premises networks. Firewall rules: Allowing traffic to Google API IP ranges would require sending traffic over the public internet if you’re on-prem. Key factor: The requirement explicitly states no public internet exposure. Conclusion... Author: Emily · Last updated Jun 8, 2026 |
A batch job running on Compute Engine needs temporary write access to a Cloud Storage bucket. You want the batch job to use the minimum per...Let's carefully analyze this GCP scenario. The goal is: A batch job running on Compute Engine Needs temporary write access to a Cloud Storage bucket Use minimum permissions necessary We'll go through each option, consider security, principle of least privilege, and suitability: --- Option A: Create a service account with full Cloud Storage administrator permissions. Assign the service account to the Compute Engine instance. Pros: The job will have full access to the bucket. Cons: This violates principle of least privilege, because the batch job only needs to write objects, not manage buckets or delete objects. Full admin is overly broad, so it’s not ideal for security. Scenario use: When the job truly needs full control over all objects and buckets (rare). Verdict: ❌ Not minimal permissions, so reject. --- Option B: Create a service account and embed a long-lived service account key file that has write permissions specified directly in the batch job script. Pros: Works technically. Cons: Long-lived keys are a major security risk (can be leaked). Embedding them in scripts goes against best practices. Temporary, short-lived credentials are preferred. Scenario use: Only if running outside GCP and no other auth option exists. Verdict: ❌ Security risk; not recommended. --- Option C: Create a service account with the storage.objectCreator r... Author: Oscar · Last updated Jun 8, 2026 |
You want to upload files from an on-premises virtual machine to Google Cloud Storage as part of a data migration. These files will be consumed by Cloud DataPro...To upload files from an on-premises virtual machine to Google Cloud Storage as part of a data migration, the most appropriate command is A) gsutil cp [LOCAL_OBJECT] gs://[DESTINATION_BUCKET_NAME]/. Reasoning: 1. gsutil cp [LOCAL_OBJECT] gs://[DESTINATION_BUCKET_NAME]/ - Key Factor: `gsutil` is a command-line tool designed for interacting with Google Cloud Storage. It is commonly used for uploading, downloading, and managing files in Google Cloud Storage buckets. - Usage: This command directly copies files from the local machine to a Google Cloud Storage bucket, which is exactly what we want to do when migrating data to Cloud Storage. It's optimized for working with cloud storage resources. - Why Selected: It's the most straightforward and reliable way to upload files to Google Cloud Storage from an on-premises virtual machine. 2. gcloud cp [LOCAL_OBJECT] gs://[DESTINATION_BUCKET_NAME]/ - Key Factor: While `gcloud` is a Google Cloud command-line interface, it does not have a `cp` (copy) command for uploading files to Cloud Storage. `gcloud` is generally used for managing Google Cloud resources like Compute Engine instances, clusters, and Dataproc configurations, but not for file operations on Cloud Storage. - Why Rejected: The `gcloud` command does not support file upload to Google Cloud Storage in this manner. The `gcloud` command would be used in contexts like managing projects, configurations, or deployments, but not specifically for file copying. 3. hadoop fs cp [LOCAL_OB... Author: Daniel · Last updated Jul 4, 2026 |
You migrated your applications to Google Cloud Platform and kept your existing monitoring platform. You now find that your notification system...To address the issue of a slow notification system for time-critical problems, the best option is C) Use Stackdriver to capture and alert on logs, then ship them to your existing platform. Reasoning: 1. C) Use Stackdriver to capture and alert on logs, then ship them to your existing platform - Key Factor: Stackdriver (now called Google Cloud Operations suite) offers integrated monitoring, logging, and alerting. By configuring Stackdriver to capture logs and generate alerts, you can leverage its fast and reliable notification system. Once the alerts are generated in Stackdriver, you can then ship those alerts to your existing monitoring platform to ensure you continue using your current system but with the improved performance of Stackdriver’s alerting mechanisms. - Why Selected: This option allows you to retain your existing monitoring platform while improving the alerting speed. Stackdriver can provide real-time alerts, and integrating it with your existing platform ensures that you can make use of its quick notification system without completely abandoning your current setup. 2. A) Replace your entire monitoring platform with Stackdriver - Key Factor: While Stackdriver is an excellent tool for monitoring and alerting in Google Cloud, replacing your entire monitoring platform might be an overkill, especially if you want to avoid disruption to your current system and maintain the customizations and workflows you already have. - Why Rejected: This option involves significant changes and potential downtime or reconfiguration, which could be... Author: Daniel · Last updated Jul 4, 2026 |
You are planning to migrate a MySQL database to the managed Cloud SQL database for Google Cloud. You have Compute Engine virtual machine instances that will connect with this Cloud SQL instance. You do not want to white...To ensure your Compute Engine virtual machine instances can connect to the Cloud SQL instance without the need to whitelist IP addresses, the most appropriate choice is A) Enable private IP for the Cloud SQL instance. Reasoning: 1. A) Enable private IP for the Cloud SQL instance - Key Factor: By enabling private IP for the Cloud SQL instance, you establish a connection over Google's internal network rather than the public internet. This eliminates the need to whitelist IP addresses, as the communication between the Compute Engine instances and the Cloud SQL instance occurs within Google's secure internal network. - Why Selected: This option aligns perfectly with the requirement to avoid whitelisting IPs. It uses Google Cloud's private networking capabilities to allow seamless, secure communication without exposing the database to the public internet. 2. B) Whitelist a project to access Cloud SQL, and add Compute Engine instances in the whitelisted project - Key Factor: This solution still involves manually whitelisting IP addresses, which contradicts the requirement of avoiding IP whitelisting. - Why Rejected: This method introduces the need for managing whitelists, which is specifically what you are trying to avoid. While this solution may work, it does not solve the core requirement of not using IP whitelisting. 3. C) Create a role in Cloud SQL that allows access to the database from external instances,... Author: Vivaan · Last updated Jul 4, 2026 |
You have deployed an HTTP(s) Load Balancer with the gcloud commands shown below. Health checks to port 80 on the Compute Engine virtual machine instance are failing and no traffic is sent ...To resolve the issue of health checks failing on port 80 for the Compute Engine virtual machine instance behind the HTTP(s) Load Balancer, the correct solution involves ensuring that the firewall rules allow the load balancer's health check traffic to reach the instances. Reasoning: 1. C) gcloud compute firewall-rules create allow-lb --network load-balancer --allow tcp --source-ranges 130.211.0.0/22,35.191.0.0/16 --direction INGRESS - Key Factor: This command creates a firewall rule to allow incoming traffic (INGRESS) to your instance from the IP ranges used by Google Cloud's HTTP(S) Load Balancer health checks (`130.211.0.0/22` and `35.191.0.0/16`). This is crucial because the health check traffic must be allowed to reach your instances on port 80 for the health checks to succeed. - Why Selected: The health checks from the Load Balancer need to be able to reach the backend instances. This rule ensures that traffic from the Load Balancer's IP ranges is allowed to reach the backend instance on the correct port (port 80). 2. A) gcloud compute instances add-access-config ${NAME}-backend-instance-1 - Key Factor: This command adds an external IP to the Compute Engine instance. While this could help if you want the instance to be externally accessible, it doesn’t address the health check problem specifically. The issue here is likely related to internal networking and firewall rules, not the lack of an external IP. - Why Rejected: The problem described seems to be with internal communication from the Load Balancer to the instance, not with external access. Therefore, this... Author: Noah · Last updated Jul 4, 2026 |
Your website is deployed on Compute Engine. Your marketing team wants to test conversion rates between 3 different...To test conversion rates between 3 different website designs, the most suitable option is A) Deploy the website on App Engine and use traffic splitting. Reasoning: 1. A) Deploy the website on App Engine and use traffic splitting - Key Factor: App Engine supports traffic splitting, which allows you to split incoming traffic across different versions of the same service. You can deploy the same website as different versions, each with a different design, and then use traffic splitting to distribute traffic between these versions. This approach makes it easy to test different designs under controlled conditions and monitor their conversion rates without changing infrastructure or deploying multiple services. - Why Selected: This is the simplest, most effective way to perform A/B or multivariate testing of your website designs. App Engine is designed for web application hosting and provides features like traffic splitting, which is ideal for testing purposes. Additionally, App Engine automatically handles scaling and routing of traffic. 2. B) Deploy the website on App Engine as three separate services - Key Factor: While it’s possible to deploy different website designs as separate services, managing traffic between multiple services can be more complex and unnecessary for this use case. You would need to configure multiple services and manually manage traffic distribution, making it less efficient than using traffic splitting. - Why Rejected: This approach adds unnecessary complexity by deploying separate services for each version of the website. For simple A/B testing, traffic splitting within a single service is much more efficient and easier to manage. 3. C) Dep... Author: Stella · Last updated Jul 4, 2026 |
You need to copy directory local-scripts and all of its contents from your local workstation to a Compute Engine virtu...To copy the `local-scripts` directory from your local workstation to a Compute Engine virtual machine instance, the most appropriate command would be option C, `gcloud compute scp`. Here's the reasoning: A) gsutil cp --project=... -r ~/local-scripts/ gcp-instance-name:~/server-scripts/ --zone=... - Rejected Reason: The `gsutil` command is used for interacting with Google Cloud Storage (GCS), not directly for transferring files to or from Compute Engine instances. This would be useful for copying files between Google Cloud Storage buckets and virtual machines, but it is not appropriate for copying directly between your local workstation and a VM instance. It doesn't support direct copying from your local machine to a VM. B) gsutil cp --project=... -R ~/local-scripts/ gcp-instance-name:~/server-scripts/ --zone=... - Rejected Reason: Like option A, `gsutil` is primarily for Google Cloud Storage operations, and while `-R` is a valid flag for recursion, the main issue is that `gsutil` cannot be used directly for transferring files from a local machine to a Compute Engine instance. This command would only work if you're copying from or to a GCS bucket. C) gcloud compute scp --project=... --recurse ~/local-scripts/ gcp-instance-name:~/server-scripts/ --zone=...... Author: ElectricLionX · Last updated Jul 4, 2026 |
You are deploying your application to a Compute Engine virtual machine instance with the Stackdriver Monitoring Agent installed. Your application is a unix process on the instance. You want to be alerted if the unix process has not run for at least 5 minutes. You...To monitor whether a Unix process on a Compute Engine virtual machine instance has not run for at least 5 minutes, option C: Metric absence is the most appropriate alert condition. Here's a detailed explanation of why this option is selected and why the others are rejected: A) Uptime check - Rejected Reason: Uptime checks are typically used to monitor the availability of external endpoints, such as HTTP or TCP services, to verify whether the system or application is online and reachable. Since the application is a Unix process and not necessarily a web service, this type of check would not be suitable for detecting the status of a specific process. Additionally, uptime checks don't monitor process status—they focus on network availability, not internal application states. B) Process health - Rejected Reason: Process health checks are used to determine if specific processes on a system are running. However, since you cannot modify the application to generate logs or metrics, you cannot configure a health check based on process output or internal status. Process health typically requires the application to emit some form of metric or log, which is not possible in this case. C) Metric absence - Selected Reason: Metric absence is the ideal condition when you cannot modify the application to produce specific metrics. This alert condition is triggered when a particular metric is absen... Author: John · Last updated Jul 4, 2026 |
You have two tables in an ANSI-SQL compliant database with identical columns that you need to quickly combine into a single table, removi...To combine two tables into a single table while removing duplicate rows from the result set, option C: Use the UNION operator in SQL is the most appropriate choice. Here's the reasoning for selecting this option and why the others are rejected: A) Use the JOIN operator in SQL to combine the tables - Rejected Reason: The `JOIN` operator is used to combine rows from two or more tables based on a related column, typically through an equality condition (like matching a foreign key with a primary key). However, in your case, the tables have identical columns, and the task is simply to combine them while removing duplicates. A `JOIN` is not suitable for this purpose because it requires a specific matching condition (e.g., matching rows from both tables based on a shared column), which is not necessary in this case. It also won't remove duplicates automatically unless specifically specified. B) Use nested WITH statements to combine the tables - Rejected Reason: `WITH` statements are typically used to define temporary result sets (Common Table Expressions or CTEs) that can be referenced within the main query. While you could technically use `WITH` to define two temporary tables for combining the data, it is not the most straightforward or efficient way to remove duplicates. The `WITH` clause itself does not perform any duplication removal; you'd still need to use a method like `UNION` or `DISTINCT` to remove duplicates, making this approach... Author: Sophia Clark · Last updated Jul 4, 2026 |
You have an application deployed in production. When a new version is deployed, some issues don't arise until the application receives traffic from users in production. You want to reduce both the...To reduce both the impact and the number of users affected when deploying a new version of an application, option B: Canary deployment is the most appropriate strategy. Here’s the reasoning for selecting this option and why the others are rejected: A) Blue/green deployment - Rejected Reason: Blue/green deployment involves running two identical production environments (blue and green). The "blue" environment is the current production environment, and the "green" environment is the new version of the application. Once the green environment is tested and ready, the traffic is switched from blue to green all at once. While this approach provides a quick rollback strategy and minimizes downtime, it does not allow for gradual traffic shift. If there are issues with the new version, they might impact all users once the switch is made. It doesn't help in minimizing the number of affected users or in identifying issues in small increments before they affect the entire user base. B) Canary deployment - Selected Reason: In a canary deployment, a small subset of users (the "canaries") are routed to the new version of the application first. This allows you to monitor the new version under real traffic conditions and catch potential issues with only a small number of users affected. If the canary users encounter issues, you can quickly roll back the deployment or fix problems before rolling the new version out to the entire user base. This method reduces the risk and impact on users while still allowing you to test the new version in a production environment. It provides a gradual and controlled release, minimizing the number of affected users and giving you the opportunity to address issues early. ... Author: Amelia · Last updated Jul 4, 2026 |
Your company wants to expand their users outside the United States for their popular application. The company wants to ensure 99.999% availability of the database for their application and also wants to minimize the rea...To ensure 99.999% availability of the database and minimize read latency for global users, the best options are A: Create a multi-regional Cloud Spanner instance with "nam-asia-eur1" configuration and B: Create a multi-regional Cloud Spanner instance with "nam3" configuration. Here's the reasoning behind the selection and rejection of the other options: A) Create a multi-regional Cloud Spanner instance with "nam-asia-eur1" configuration - Selected Reason: Cloud Spanner is a fully managed relational database that supports multi-region configurations. Using a multi-regional instance ensures that your application can have replicas in multiple regions, improving both availability and read latency. The "nam-asia-eur1" configuration is designed to provide a multi-regional setup that includes regions in North America, Asia, and Europe, ensuring that users across different geographical locations have access to a nearby replica. This setup helps achieve both high availability (99.999%) and low-latency read access for users worldwide. B) Create a multi-regional Cloud Spanner instance with "nam3" configuration - Selected Reason: The "nam3" configuration provides another multi-regional setup for Cloud Spanner, specifically designed to replicate data across three regions in North America. This configuration also helps with high availability and low latency for users in different regions. Given that the company wants to expand its user base outside of the United States, having regions across North America in the "nam3" configuration will still offer significant benefits for global reach and availability. C) Create a cluster with at least 3 Spanner nodes - Rejected Reason: While having multiple Spanner nodes is important for performance and fault tolerance, this action alone doesn't guarantee the high availability or low latency needed for a globally distributed application. The number of nodes is important for scalability and performance but does not directly address global availability and read latency. A multi-regi... Author: Max · Last updated Jul 4, 2026 |
You need to migrate an internal file upload API with an enforced 500-MB file size limit to App Engin...To migrate an internal file upload API with a 500-MB file size limit to Google App Engine, we need to choose the most effective approach considering factors such as scalability, security, simplicity, and the fact that Google Cloud has specific guidelines for file uploads to App Engine. Let’s review the options: A) Use FTP to upload files FTP (File Transfer Protocol) is not a recommended method for cloud-based file uploads, particularly on Google Cloud platforms. Google App Engine doesn’t natively support FTP, and using FTP doesn’t align with modern cloud-native best practices, such as scalability and secure file handling. FTP lacks the security mechanisms that modern cloud services offer. Additionally, FTP could face issues with performance and scalability under high loads. - Rejection Reason: Not compatible with App Engine, lacks scalability, and modern security features. B) Use CPanel to upload files CPanel is typically used for managing web hosting and is often associated with traditional hosting providers. It is not meant for cloud environments like Google App Engine. Google App Engine doesn’t use CPanel for management, so this option is not feasible for your file upload API. - Rejection Reason: Not applicable to App Engine; it's used for traditional hosting environments, not scalable cloud infrastructure. C) Use signed URLs to upload files Signed URLs provide a secure way to upload files directly to Google Cloud Storage (GCS) from the client side, bypassing the App Engine server entirely. This is a highly scalable and efficient method, as it allows clients to upload large files directly to GCS. The server simply generates a signed URL that gives the client temporary access to upload to a specific GCS bucket. This r... Author: Elizabeth · Last updated Jul 4, 2026 |
You are planning to deploy your application in a Google Kubernetes Engine (GKE) cluster. The application exposes an HTTP-based health check at /healthz. You want to use this health check endpoint to determine whether traffic should be routed to the pod ...To configure a health check in your Google Kubernetes Engine (GKE) cluster and use the `/healthz` endpoint to determine whether traffic should be routed to your pod by the load balancer, you need to include a health check configuration in your Pod's specification. There are two primary types of health checks in Kubernetes: liveness probes and readiness probes. For this scenario, a readiness probe is typically used to check whether the application is ready to serve traffic. Let’s review the options based on the Kubernetes health check configuration: Key points: - Readiness probe is used to determine whether the pod is ready to handle traffic. - Liveness probe checks if the pod is still running and should be restarted if it fails. - The health check will use the `/healthz` HTTP endpoint to determine the pod's status. Code Example Breakdown: Here are the possible snippets you might see in the configuration. (Note: The snippets are not provided, but I'll describe what a typical health check might look like and why one would be selected over another.) Common Kubernetes Readiness Probe Configuration (for health check): ```yaml readinessProbe: httpGet: path: /healthz port: 8080 initialDelaySeconds: 5 periodSeconds: 10 failureThreshold: 3 successThreshold: 1 ``` Explanation: - httpGet: The `httpGet` action is used to send an HTTP request to the `/healthz` endpoint. - path: The path is `/healthz`, which corresponds to the health check endpoint exposed by your application. - port: The port number where your application is running. In this case, `8080` is just an example. - initialDelaySeconds: The time in seconds to wait before performing the first probe after the container has... Author: Alexander · Last updated Jul 4, 2026 |
Your teammate has asked you to review the code below. Its purpose is to efficiently add a large number of small rows to a BigQuery table....To efficiently add a large number of small rows to a BigQuery table, it's important to consider BigQuery's optimal performance patterns for handling inserts and large datasets. Let’s review each option and how it compares based on BigQuery best practices. A) Include multiple rows with each request This option is a good improvement over inserting rows individually. Instead of making a separate insert request for each row, you can batch multiple rows into each request. This reduces the overhead of making multiple HTTP requests and improves performance by sending fewer, larger requests to BigQuery. - Advantages: Reduces the number of API requests, improves throughput. - How it works: BigQuery supports batching multiple rows into a single insert request. This reduces the number of individual insert operations and is much more efficient than inserting rows one at a time. - Reason for selection: It is a straightforward optimization for handling a large number of small rows in a single request, thus improving performance and efficiency. B) Perform the inserts in parallel by creating multiple threads Parallelizing the inserts by creating multiple threads may seem like a good idea, but it’s typically not the best option for BigQuery. BigQuery is designed to handle large volumes of data efficiently, and while threading could theoretically improve performance, managing many parallel requests could introduce complexity and potentially lead to rate limits or throttling on the API. - Disadvantages: Parallelizing the requests could cause issues with API rate limits, making it harder to manage and potentially leading to throttling. - Performance Impact: Parallelism could cause additional overhead and might not provide as much benefit as batching the inserts. C) Write each row to a Cloud Storage object, then... Author: MysticJaguar44 · Last updated Jul 4, 2026 |
You are developing a JPEG image-resizing API hosted on Google Kubernetes Engine (GKE). Callers of the service will exist within the same GKE cluster. You want client...To enable clients within the same Google Kubernetes Engine (GKE) cluster to get the IP address of the service, you should use a GKE service because Kubernetes services provide internal DNS resolution and routing capabilities, making them the most appropriate solution in this case. Let's review each option: A) Define a GKE Service. Clients should use the name of the A record in Cloud DNS to find the service's cluster IP address. While it's true that Kubernetes internally uses DNS resolution for services, using Cloud DNS to resolve the A record for the service is not ideal. Cloud DNS is typically used for external, public DNS resolution and not for internal service discovery within the cluster. Kubernetes provides its own internal DNS system for services, so using Cloud DNS here is unnecessary and adds complexity. - Disadvantages: Introducing Cloud DNS adds unnecessary complexity for internal service discovery when Kubernetes provides native service discovery. B) Define a GKE Service. Clients should use the service name in the URL to connect to the service. This is the correct approach. When you define a Kubernetes Service in GKE, it automatically creates a DNS record for that service in the internal DNS system. Clients within the same GKE cluster can directly access the service by using the service name (e.g., `service-name.default.svc.cluster.local`). This allows clients to resolve and access the service without needing to know its IP address, as Kubernetes handles the internal DNS resolution. - Advantages: - Simple and native to Kubernetes. - No need to manually manage IP addresses; the service name resolves automatically to the se... Author: Ella · Last updated Jul 4, 2026 |
You are using Cloud Build to build and test application source code stored in Cloud Source Repositories. The build process requires a build tool no...When building and testing application source code in Cloud Build and you require a build tool that is not available in the Cloud Build environment, the best approach is to ensure the build tool is available within the build environment. Let’s evaluate each option to determine which is the most efficient and appropriate solution. A) Download the binary from the internet during the build process This option involves downloading the required binary each time a build is triggered. While this may work, it introduces additional overhead during the build process (i.e., downloading the binary every time), which can increase build time. Additionally, relying on an external source for the binary can introduce points of failure, such as network issues or the binary becoming unavailable. - Disadvantages: - Can slow down build times due to downloading the binary on every build. - Uncertainty around availability or versioning of the binary from the external source. - Adds extra complexity and risk if the binary source becomes unavailable or the download fails. B) Build a custom cloud builder image and reference the image in your build steps This is the most suitable solution. Cloud Build allows you to create custom build environments by building your own Docker images, which can include any required build tools or binaries that are not available in the default Cloud Build environment. You can package your build tool in this custom image, ensuring that it is available during every build, and avoid repetitive downloads or reliance on external sources. - Advantages: - Custom image allows you to fully control the build environment and ensure the necessary build tools are always available. - Improves build reliability and speed since the build tools are already included in the custom image. - Supports a clean, isolated environment for the build process. - Can be reused across multiple builds. - Why it’s selected: This option give... Author: Rahul · Last updated Jul 4, 2026 |
You are deploying your application to a Compute Engine virtual machine instance. Your application is configured to write its log files to disk. You want to view the logs in Sta...To send your application logs to Stackdriver Logging without modifying the application code, we need to consider the options that allow us to collect and send the logs to Stackdriver while keeping the application code unchanged. Here’s a breakdown of each option: A) Install the Stackdriver Logging Agent and configure it to send the application logs - Explanation: The Stackdriver Logging Agent can be installed on the virtual machine (VM). Once installed, the agent automatically collects logs from log files (in the specified directories) and sends them to Stackdriver Logging without any need for application code changes. - Why it's selected: This option does not require any changes to the application code. The agent can be configured to monitor log file locations where your application writes its logs, and it sends those logs to Stackdriver Logging. - Key factors: It allows seamless integration without touching the application code, making it ideal when logs are written to disk by an application but need to be aggregated centrally in Stackdriver Logging. B) Use a Stackdriver Logging Library to log directly from the application to Stackdriver Logging - Explanation: The Stackdriver Logging Library would be used within the application code to send logs directly to Stackdriver Logging. However, this would require changing the... Author: Isabella · Last updated Jul 4, 2026 |
Your service adds text to images that it reads from Cloud Storage. During busy times of the year, requests to Cloud Storage fail with an HTTP 429 "To...When you are encountering HTTP 429 "Too Many Requests" errors from Cloud Storage, it indicates that you are hitting rate limits or quotas, and the service is throttling your requests. Here’s a breakdown of each option and the rationale for selecting the most appropriate one: A) Add a cache-control header to the objects - Explanation: The `Cache-Control` header is used to define caching policies for HTTP responses. It can improve performance by instructing clients or intermediate proxies to cache the content for a specified duration. However, this doesn't address the underlying issue of rate-limiting for Cloud Storage requests. - Why it’s rejected: This option is not relevant to the problem at hand. The HTTP 429 error is caused by rate-limiting of requests, and adding cache headers will not resolve issues with too many requests being sent to Cloud Storage. B) Request a quota increase from the GCP Console - Explanation: A quota increase request can be used if you are consistently hitting your rate limits. However, quota increases are typically intended for more long-term, predictable needs, and might not be the best immediate solution if the traffic spikes are temporary or seasonal (as is the case with busy times of the year). - Why it’s rejected: While requesting a quota increase could potentially help, it is a more static solution and may not address short-term surges in traffic effectively. Additionally, GCP rate limits may still apply, and an increase in quota doesn’t guara... Author: FrozenWolf2022 · Last updated Jul 4, 2026 |
You are building an API that will be used by Android and iOS apps. The API must: * Support HTTPs * Minimize bandwidth cost * Integrate ea...When selecting an API architecture for an application that will be used by Android and iOS apps, it's important to consider factors such as support for HTTPS, bandwidth optimization, and ease of integration with mobile applications. Let’s break down each option: A) RESTful APIs - Explanation: RESTful APIs are widely used for mobile apps and web services. They support HTTPS for secure communication and use standard HTTP methods (GET, POST, PUT, DELETE), making them easy to implement and integrate with both Android and iOS applications. REST is also lightweight and typically easier to use for mobile developers, as it can return data in JSON format, which is natively supported by both platforms. - Why it’s selected: RESTful APIs are well-suited for mobile applications because they are widely supported, efficient, and easy to implement. They also allow for bandwidth optimization by using HTTP compression and response caching. REST is a proven architecture for mobile app APIs, making it a natural choice. B) MQTT for APIs - Explanation: MQTT (Message Queuing Telemetry Transport) is a lightweight messaging protocol designed for low-bandwidth, high-latency networks. It is typically used for IoT (Internet of Things) applications, where small, real-time messages need to be sent between devices. While it can work with mobile apps, it is generally not used for typical RESTful API services like those needed for fetching or manipulating data in standard mobile applications. - Why it’s rejected: MQTT is more suitable for real-time messaging and IoT use cases rather than traditional API endpoints for mobile apps. While it minimizes bandwidth, it isn’t as flexible or widely supported as REST for integrating with mobile apps that require standard CRUD operations or data exchanges... Author: Sophia Clark · Last updated Jul 4, 2026 |
Your application takes an input from a user and publishes it to the user's contacts. This input is stored in a table in Cloud Spanner. Your application is more sensitive to latency and less sensitive ...In this scenario, the key factors to consider are latency and consistency, with a preference for low latency over strong consistency. Let’s break down the options: A) Perform Read-Only transactions - Explanation: Read-only transactions in Cloud Spanner provide a way to read data without modifying it, ensuring transactional consistency. However, read-only transactions can be more expensive in terms of latency due to the need for coordination across distributed nodes, especially when global consistency is required. - Why it’s rejected: Since the application is more sensitive to latency than to consistency, a read-only transaction (which ensures consistency) is not the best choice. It may involve additional overhead compared to simpler methods like stale reads. B) Perform stale reads using single-read methods - Explanation: Stale reads allow for reading data that might be slightly out-of-date, providing a significant reduction in latency since the system does not need to perform a full consistency check. Cloud Spanner supports stale reads using single-read methods, which is ideal for situations where low latency is more important than having up-to-the-moment data. This option is appropriate when eventual consistency is acceptable, and data staleness is tolerable. - Why it’s selected: This is the best approach for the given scenario because it minimizes latency while acknowled... Author: Rahul · Last updated Jul 4, 2026 |
Your application is deployed in a Google Kubernetes Engine (GKE) cluster. When a new version of your application is released, your CI/CD tool updates the spec.template.spec.containers[0].image value to reference the Docker image of your new application version. When the Deployment object applies the change, you want to deploy at least 1 replica of the ...In this scenario, you are deploying a new version of your application in a Google Kubernetes Engine (GKE) cluster and want to ensure that at least one replica of the new version is deployed and healthy before old replicas are terminated. The Deployment strategy and its settings control how new replicas are rolled out and how old ones are managed. Let’s break down each option to find the best solution: A) Set the Deployment strategy to RollingUpdate with maxSurge set to 0, maxUnavailable set to 1 - Explanation: In this configuration, `RollingUpdate` strategy is used, which allows for gradual updates of the deployment. The key parameters here are: - `maxSurge: 0`: This means no extra pods will be created above the desired replica count. - `maxUnavailable: 1`: This means 1 pod can be taken down at any given time during the update. - Why it's rejected: With `maxSurge: 0`, no new pods can be added until the old pods are fully terminated and unavailable. This could cause downtime, which contradicts the goal of keeping at least one replica of the new version running and healthy before the old ones are deleted. B) Set the Deployment strategy to RollingUpdate with maxSurge set to 1, maxUnavailable set to 0 - Explanation: Here, `RollingUpdate` is used with: - `maxSurge: 1`: This allows one extra replica to be created above the desired count during the update. - `maxUnavailable: 0`: This means no pods can be taken down during the update. - Why it's selected: This configuration ensures that at ... Author: Emily · Last updated Jul 4, 2026 |
You plan to make a simple HTML application available on the internet. This site keeps information about FAQs for your application. The application is static and contains images, HTML, CSS, and Javascript. You want to make...To determine the best option for making your static HTML application available on the internet, we need to consider the following factors: 1. Simplicity and Ease of Setup The application is static (HTML, CSS, JS, and images) and doesn't require complex server-side processing. Therefore, we should prioritize options that minimize setup complexity. 2. Scalability and Maintenance We want to ensure that the solution scales well as user traffic increases and requires minimal ongoing maintenance, especially if the application is expected to grow or have high availability. 3. Cost Efficiency Since the application is static, it doesn’t require heavy resources. We should consider low-cost options that offer good performance without overpaying for unnecessary infrastructure. 4. Overhead and Flexibility Some options involve more configuration and resource management, whereas others are fully managed, reducing the operational overhead. Analysis of Each Option: A) Upload your application to Cloud Storage: - Pros: Cloud Storage is designed to serve static files, including HTML, CSS, JS, and images, with minimal setup. It’s cost-effective for static content and provides built-in scalability. There is minimal maintenance as Google handles scaling and uptime. - Cons: Limited to serving static content. It doesn't support complex back-end logic or dynamic processing, but for this case (static content), it's more than sufficient. - Ideal Scenario: If the application is entirely static and doesn't require server-side logic or complex interactions, Cloud Storage is an excellent option. B) Upload your application to an App Engine environment: - Pros: App Engine is a fully managed platform that can automatically scale your app. It's ideal for applications that require both static and dynamic content or backend logic. - Cons: Slightly more overhead than Cloud Storage because you need to configure an app within the App Engine environment. It might be ove... Author: Elijah · Last updated Jul 4, 2026 |
Your company has deployed a new API to App Engine Standard environment. During testing, the API is not behaving as expected. You want to monitor the application over time to diagnose the problem withi...To diagnose an issue with your application code deployed to the App Engine Standard environment, it's essential to select a tool that can help you monitor and debug the application without requiring a redeployment. Let's break down each option: 1. A) Stackdriver Trace - What it does: Stackdriver Trace is primarily used to collect and analyze the latency of your application, tracking the time it takes for requests to flow through different parts of your application. - Pros: It’s great for understanding performance bottlenecks, especially for latency issues. - Cons: It focuses on performance (latency) and doesn’t give in-depth insight into application logic or bugs. It’s not ideal for tracking application behavior or diagnosing errors in the code directly. - Ideal Scenario: Use Stackdriver Trace when you need to monitor latency or performance issues, but it isn’t the right tool for diagnosing incorrect application behavior. 2. B) Stackdriver Monitoring - What it does: Stackdriver Monitoring helps you collect metrics and create dashboards about your application’s health, availability, and resource usage. It can alert you to performance issues or resource constraints. - Pros: Provides a good overview of your application’s status, including uptime and resource consumption. - Cons: It is mostly focused on high-level metrics (e.g., CPU usage, memory, request counts) rather than providing detailed insights into the code behavior or errors within the application. - Ideal Scenario: Use Stackdriver Monitoring when you need high-level operational metrics, but it is not as useful for debugging specific application code issues or behavior. 3. C) Stackdriver Debug Snapshots - What it does: Stackdriver Debug Snapshots allows you to take snapshots of your application’s state at specific points in time while it is running, without redeploying it. It can show you the current values of ... Author: IceDragon2023 · Last updated Jul 4, 2026 |
You want to use the Stackdriver Logging Agent to send an application's log file to Stackdriver from a Compute Engine virtual machine instance. After i...To use the Stackdriver Logging Agent to send an application's log file from a Compute Engine virtual machine instance to Stackdriver (now part of Google Cloud Operations suite), the first thing you need to do is configure the agent to correctly capture and send logs. Here's a breakdown of each option and its relevance: 1. A) Enable the Error Reporting API on the project: - What it does: Enabling the Error Reporting API helps track errors that occur in your application, such as exceptions or crashes, and organizes them for visibility in Google Cloud. - Pros: It's useful for catching and reporting errors in your application, but not directly related to configuring the Stackdriver Logging Agent. - Cons: This option isn't the first step after installing the Stackdriver Logging Agent. It's more relevant for monitoring errors and exceptions. - Ideal Scenario: Use this option if you want to specifically track errors in your application logs after you have set up the logging agent. However, it's not the immediate next step for log collection. 2. B) Grant the instance full access to all Cloud APIs: - What it does: Granting the instance full access to all Cloud APIs gives it broad permissions to access Google Cloud resources, such as storage, databases, and other services. - Pros: This might be required for some actions in certain use cases, especially for accessing multiple resources. - Cons: It's an overly broad permission and isn't specifically required to send logs to Stackdriver. Typically, the instance only needs the Logging API and Cloud IAM permissions necessary for logging purposes. - Ideal Scenario: Use this option if you want to give the instance wide-ranging access to Google Cloud services, but for logging, a more restricted access role would suffice. It's not necessary for setting up the logging agent initially. 3. C) Configure the application log file as a custom source: - What it does: This option involves confi... Author: VioletCheetah55 · Last updated Jul 4, 2026 |
Your company has a BigQuery data mart that provides analytics information to hundreds of employees. One user of wants to run jobs without interrupting important workloads. This user isn't concerned about the time it takes to run these jobs. You want to fulfi...To fulfill the user's request while minimizing cost and effort, let's evaluate each option and its suitability: 1. A) Ask the user to run the jobs as batch jobs: - What it does: Batch jobs in BigQuery allow users to run long-running queries without occupying resources that could interrupt real-time, interactive workloads. - Pros: Batch jobs are cheaper than interactive queries because they use fewer resources and are processed at off-peak times. They do not affect important workloads as they run asynchronously and independently. - Cons: The user may have to wait longer for their results, but since the user is not concerned about time, this is not a drawback. - Ideal Scenario: This is a cost-effective and straightforward solution, especially when a user does not require immediate results. It ensures that resource consumption is minimized during busy times and doesn't affect other important workloads. 2. B) Create a separate project for the user to run jobs: - What it does: Creating a separate project isolates the user's workloads, which could prevent interference with important workloads in the main project. - Pros: It provides complete isolation between workloads, which could be useful if the user’s jobs are resource-intensive. - Cons: This introduces unnecessary complexity, requiring the creation and management of an additional project, potentially leading to higher administrative overhead and cost. It's also likely overkill for the user's needs, especially if they are not concerned with job time and just want to avoid interrupting workloads. - Ideal Scenario: This could be suitable if the user's jobs are resource-heavy and could significantly affect performance, but it’s more complex than necessary in this case. 3. C) Add the user as a job.user role in the existing project: - What it does: The job.user role allows users to submit and manage jobs in BigQuery but does not affect the way jobs are execute... Author: David · Last updated Jul 4, 2026 |
You want to notify on-call engineers about a service degradation in production while minimizing deve...To notify on-call engineers about a service degradation while minimizing development time, let's evaluate each option: 1. A) Use Cloud Function to monitor resources and raise alerts: - What it does: Cloud Functions can be triggered by events and can run custom code to monitor resources. It can be used to raise alerts, but it would require custom logic to determine when service degradation occurs. - Pros: Flexible and can be customized to respond to specific conditions. Good for complex or highly tailored use cases. - Cons: This requires development effort to implement the monitoring, create the function, and ensure it correctly handles various types of service degradation. This is more time-consuming than using an out-of-the-box monitoring solution. - Ideal Scenario: Use Cloud Functions if you need highly customized alerts or if your monitoring logic requires complex, bespoke code. However, for a quick and simple solution, it is overkill. 2. B) Use Cloud Pub/Sub to monitor resources and raise alerts: - What it does: Cloud Pub/Sub is a messaging service that can be used to send messages to subscribers, such as notifying on-call engineers. It can integrate with other services, but like Cloud Functions, it requires additional components to monitor resources and detect service degradation. - Pros: Good for building scalable, event-driven systems. Once set up, it’s reliable for delivering notifications. - Cons: Like Cloud Functions, it requires extra development effort. You would need to integrate it with monitoring tools or custom code to detect degradation and trigger alerts. - Ideal Scenario: Cloud Pub/Sub is more suited for building complex, distributed systems where you need to decouple services and notify multiple subscribers. It's not the simplest solution for a quick alert setup. 3. C) Use Stackdriver Error Reporting to capture errors and raise alerts: - What it does: Stackdriver Error Reporting automatically collects and aggregates errors from your application, notifying you when there is a spike in errors. It’s particularly useful for identifying and responding to application... Author: Noah · Last updated Jul 4, 2026 |
You are writing a single-page web application with a user-interface that communicates with a third-party API for content using XMLHttpRequest. The data displayed on the UI by the API results is less critical than other data displayed on the same web page, so it is acceptable for some requests to not have the API data displayed in the UI. However, calls made to the API should not ...To select the best option for your scenario, we need to carefully consider the performance, user experience, and handling of errors in your web application. Let’s break down each option: Option A: 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. - Why it is not ideal: - Setting the asynchronous option to false (synchronous request) would block the entire browser’s UI thread while waiting for the API response. This would delay the rendering of other critical parts of the page. - Since the API data is less critical, blocking the UI would negatively affect the user experience. - Synchronous requests are generally discouraged in web development due to their negative impact on performance. Option B: 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. - Why this option is ideal: - By setting the asynchronous option to true, the API call is made in the background without blocking the main UI thread. This allows the rest of the page to load and render quickly. - Omitting the widget on timeout or error is acceptable since the API data is not critical to the functionality of the page. - This approach ensures better performance and user experience, especially when there are failures or delays in the API response. ... Author: Emma · Last updated Jul 4, 2026 |
You are creating a web application that runs in a Compute Engine instance and writes a file to any user's Google Drive. You need to configure the applic...Let's analyze each option in the context of the application, which runs in a Compute Engine instance and writes a file to any user's Google Drive. The focus is on authentication and authorization to interact with the Google Drive API. Option A: Use an OAuth Client ID that uses the https://www.googleapis.com/auth/drive.file scope to obtain an access token for each user. - Why it might be suitable: - OAuth Client ID with the `https://www.googleapis.com/auth/drive.file` scope allows the application to obtain access tokens for individual users, giving them the ability to access their Google Drive specifically for creating or modifying files. - This option is ideal for applications that need access to the user's Google Drive and where users are required to authenticate themselves individually (via OAuth consent). - The key point here is that the application will prompt users for authentication and authorization, which fits scenarios where you want to interact directly with a user's Google Drive. - Why this might not be the best option: - If the goal is to write to any user's Google Drive without requiring each user to individually authenticate, this would require each user to go through the OAuth flow, which is cumbersome and not necessary for all cases. - In scenarios where the application needs broader access or doesn't want users to manually authenticate each time, this approach may not be sufficient. Option B: Use an OAuth Client ID with delegated domain-wide authority. - Why it might not be ideal: - Delegated domain-wide authority is typically used for service accounts in Google Workspace environments, where an administrator grants the service account access to user data across an organization. - This is suitable when your app needs to act on behalf of users in a domain (e.g., within an enterprise setting), but not ideal for a Compute Engine application that writes to any user's Google Drive. - In ... Author: Zara · Last updated Jul 4, 2026 |
You are creating a Google Kubernetes Engine (GKE) cluster and run this command: The command fails with the error: ...To resolve the issue with the GKE cluster creation, we need to consider the most likely cause of the failure, which could be related to quota limits in Google Cloud Platform (GCP). Let’s analyze each option: Option A: Request additional GKE quota in the GCP Console. - Why it might not be ideal: - GKE quota typically refers to specific limits associated with GKE services (e.g., number of clusters, regional clusters, etc.). If the issue is related to insufficient resources (such as CPU, memory, or other specific quotas) for running the cluster, it is more likely a Compute Engine resource issue (as GKE uses Compute Engine resources for nodes). - If the issue is not related to GKE-specific services, requesting additional GKE quota won’t resolve the problem. Option B: Request additional Compute Engine quota in the GCP Console. - Why this is a good option: - GKE clusters use Compute Engine instances (VMs) for the nodes. If you receive an error during the creation of the GKE cluster related to insufficient resources, such as a lack of CPU, memory, or disk resources, it’s most likely a Compute Engine quota issue. - Requesting Compute Engine quota (which could include vCPUs, memory, or other resources) can directly address the issue by increasing the limits for resources required to spin up the cluster. - This option is commonly used if you’re hitting quota limits on specific resources necessary for running GKE nodes. Opt... Author: Elijah · Last updated Jul 4, 2026 |
You are parsing a log file that contains three columns: a timestamp, an account number (a string), and a transaction amount (a number). You want to calculate the sum of all transaction amount...To efficiently calculate the sum of all transaction amounts for each unique account number, let’s analyze each data structure option: Option A: A linked list - Why it's not ideal: - Linked lists are sequential data structures where each element points to the next. While they can store data, they don't provide efficient random access or quick lookup times. - To calculate the sum for each unique account number, you would need to traverse the entire list repeatedly for each unique account number. This results in inefficient lookups, making the solution slower compared to more specialized data structures. - Linked lists are not optimized for storing data that requires fast access by a key (in this case, account numbers). Option B: A hash table - Why this is ideal: - A hash table (or hash map) is a data structure that stores key-value pairs and allows for efficient lookups, insertions, and updates, all in constant time on average (O(1)). - In this case, the account number would be the key, and the value would be the cumulative sum of transaction amounts for that account number. - With a hash table, you can efficiently add transaction amounts to the corresponding account number without needing to traverse through the entire data structure. - This is the most efficient option for this task since it allows fast lookups and updates for each account number. Option C: A t... Author: IronLion88 · Last updated Jul 4, 2026 |
Your company has a BigQuery dataset named "Master" that keeps information about employee travel and expenses. This information is organized by employee department. That means employees should only be able to view information for their department. You want t...To enforce the requirement where employees should only be able to view information for their department with the minimum steps, we need to consider security, simplicity, and scalability in managing access to the data. Let’s break down each option: Option A: 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. - Why it's not ideal: - While separating datasets by department might make sense for organizing data, creating separate views to manage access introduces unnecessary complexity. - This approach requires a separate dataset for each department and views that need to be created, maintained, and authorized for each department, leading to extra administrative overhead. - If the number of departments is large, this approach would require managing multiple datasets and views, which can be cumbersome and harder to scale. Option B: 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. - Why it's not ideal: - This option involves duplicating data into separate datasets for each department, which introduces redundancy and requires maintenance for data consistency. - Data pipelines need to be set up and managed to copy data from the "Master" dataset into department-specific datasets, increasing complexity and operational overhead. - The duplication of data also results in a higher storage cost and makes the system harder to manage in the long run. Option C: Create a dataset named Master dataset. Create a separate view for e... Author: Madison · Last updated Jul 4, 2026 |
You have an application in production. It is deployed on Compute Engine virtual machine instances controlled by a managed instance group. Traffic is routed to the instances via a HTTP(s) load balancer. Your users are unable to access your application. You want to imp...In this scenario, you're looking for a monitoring technique that will alert you when the application becomes unavailable. Let's analyze each option based on the situation: A) Smoke Tests - Description: Smoke tests are basic tests run on the application to check if it is functioning as expected. These tests typically ensure that essential parts of the application (like endpoints, user interfaces, or key functionality) are working correctly. - Why Not Chosen: Smoke tests can be useful but are typically used for initial checks in a development or staging environment to test whether basic functionality is available. While they can be part of an overall monitoring strategy, they are not designed to continuously monitor an application in production and may not trigger alerts in a timely fashion or on a granular level for production applications. Furthermore, setting them up for every endpoint in a production environment can be cumbersome. - Key Limitation: Not designed for continuous availability monitoring in production environments. B) Stackdriver Uptime Checks - Description: Stackdriver (now part of Google Cloud Operations Suite) uptime checks are specifically designed to monitor the availability of your application or service. These checks test whether your service is reachable over HTTP, HTTPS, or TCP. You can set up alerts based on response times or failures. - Why Chosen: This is the most suitable choice because uptime checks allow you to monitor the availability of your application or specific endpoints, and they can trigger alerts if the service is unavailable. This is a dedicated service for availability monitoring and is well-integrated into Google Cloud, which helps in quickly detecting issues with the application’s availability. - Key Strength: Provides monitoring specifically for availability, integrates easily with other Google Cloud services, and allows you to define alerting criteria when your application is unavailable. C) Cloud Load Balancing - Health Checks - Description: Cloud Load Balancing health checks monitor the health of backend servic... Author: Sofia · Last updated Jul 4, 2026 |
You are load testing your server application. During the first 30 seconds, you observe that a previously inactive Cloud Storage bucket is now servicing 2000 write requests per second and 7500 read requests per second. Your application is now receiving intermittent 5xx and 429 HTTP responses from the Cloud S...In this scenario, you're dealing with high request rates to a Cloud Storage bucket that was previously inactive. As a result, you're seeing 5xx (server errors) and 429 (Too Many Requests) HTTP responses from the Cloud Storage JSON API, indicating that the API is overwhelmed by the rapid spike in requests. To address this, let's analyze each option: A) Distribute the uploads across a large number of individual storage buckets - Description: This approach would involve splitting your data across multiple storage buckets to distribute the load more evenly. - Why Not Chosen: While this could technically spread the load, it doesn't address the root cause of the problem, which is the rapid rate of requests hitting a single bucket. Cloud Storage has a global rate limit for its API, and creating more buckets doesn't necessarily prevent the API from hitting its overall rate limits. Additionally, managing a large number of buckets could become cumbersome and add complexity to your architecture. - Key Limitation: Does not directly solve the issue of handling high request rates; might introduce unnecessary complexity. B) Use the XML API instead of the JSON API for interfacing with Cloud Storage - Description: The XML API is an older interface for Cloud Storage and can handle certain types of requests differently than the JSON API. - Why Not Chosen: This approach does not address the root cause of the issue either. Both the XML and JSON APIs are subject to the same rate limits on Google Cloud Storage. Switching to the XML API might give slight variations in performance, but it’s unlikely to prevent the 429 or 5xx errors, as the issue is primarily about the rate of requests and the bucket's ability to handle them. - Key Limitation: Switching APIs is unlikely to solve the rate-limiting problem. C) Pass the HTTP response codes back to clients that are invoking the uploads from your application - Description: This option suggests passing back the HTTP error codes (such as 5xx or 429) to clients that are making the requests. - Why Not Chosen: This option only helps your clients understand the failure (e.g., via error handling), but it doesn't mitigate or resol... Author: Emma · Last updated Jul 4, 2026 |
Your application is controlled by a managed instance group. You want to share a large read-only data set between all the instances in the managed instance group. You want to ensure that each instance can start quickly and can access the data set via its fi...In this scenario, you're trying to share a large read-only dataset across instances in a managed instance group with quick access, low latency, and minimal cost. Let's evaluate each option carefully: A) Move the data to a Cloud Storage bucket, and mount the bucket on the filesystem using Cloud Storage FUSE - Description: Cloud Storage FUSE allows you to mount a Cloud Storage bucket as a filesystem on a Compute Engine instance. - Why Not Chosen: While this solution could work, it introduces significant latency. Cloud Storage is designed for object storage, and using it as a mounted filesystem can cause slower access times compared to local or persistent storage, especially for large datasets. Furthermore, Cloud Storage FUSE is not as fast as other options when it comes to filesystem-like access, especially when instances need low-latency access to data. - Key Limitation: Higher latency than alternatives, not optimal for scenarios requiring low-latency access. B) Move the data to a Cloud Storage bucket, and copy the data to the boot disk of the instance via a startup script - Description: You would copy the dataset from Cloud Storage to each instance’s boot disk during startup, ensuring each instance has local access to the data. - Why Not Chosen: While this approach ensures local access to data, it could be inefficient for large datasets. Every instance would need to download the data during startup, which would increase startup time and network bandwidth usage. Additionally, this can be costly and slow, particularly for large datasets or frequent instance restarts. - Key Limitation: Inefficient for large datasets, as each instance would repeatedly copy the data on startup. C) Move the data to a Compute Engine persistent disk, and attach the disk in read-only mode to multiple Compute Engine virtual machine instances - Description: Persistent disks are a great solution for sharing data across multiple instances. By attaching a single persistent disk in read-only mode, you can ensure low-latency access for all instances in the managed instance group. - Why Chosen: Persistent disks are designed to be shared across multiple instances, especiall... Author: Evelyn · Last updated Jul 4, 2026 |
You are developing an HTTP API hosted on a Compute Engine virtual machine instance that needs to be invoked by multiple clients within the same Virtual Private Cloud (VPC). You want...In this scenario, you are developing an HTTP API hosted on a Compute Engine virtual machine (VM) instance, and you want clients within the same Virtual Private Cloud (VPC) to be able to access it with its IP address. Let’s evaluate the options based on your requirements: A) Reserve a static external IP address and assign it to an HTTP(S) load balancing service's forwarding rule. Clients should use this IP address to connect to the service. - Description: This option involves using an external IP address associated with a load balancer that directs traffic to your VM instance. - Why Not Chosen: While this option would allow clients to access the service, it is primarily meant for clients outside the VPC or when you need to expose the API publicly to the internet. Since your clients are within the same VPC, this approach is unnecessarily complex and could introduce additional costs and latency due to the use of a load balancer and an external IP address. Also, it doesn’t directly address the need for clients to access the API within the VPC. - Key Limitation: Not necessary for internal access between clients in the same VPC, and it introduces overhead. B) Reserve a static external IP address and assign it to an HTTP(S) load balancing service's forwarding rule. Then, define an A record in Cloud DNS. Clients should use the name of the A record to connect to the service. - Description: This approach uses an external static IP address with a load balancer and also defines an A record in Cloud DNS for clients to access the service using a domain name. - Why Not Chosen: This is similar to option A, and it’s even more complicated because it introduces the need for DNS configuration. Furthermore, it’s overkill for internal communication within a VPC. Clients should ideally connect to the API directly using internal mechanisms within the VPC without relying on external DNS and IP addresses. - Key Limitation: Unnecessary complexity for internal clients and not ideal for internal communication in a VPC. C) Ensure that clients use Compute Engine internal DNS by connecting to the instance name with the URL https://[INSTANCE_NAME].[... Author: Ahmed97 · Last updated Jul 4, 2026 |
Your application is logging to Stackdriver. You want to get the count of all requests on all /api/al...In this scenario, you want to count all requests to `/api/alpha/` endpoints from your application’s logs in Stackdriver. Let’s evaluate each option based on how well it aligns with this requirement. A) Add a Stackdriver counter metric for path:/api/alpha/. - Description: This option suggests creating a custom Stackdriver metric that counts requests to the `/api/alpha/` path. - Why Not Chosen: This solution may not fully meet your requirement. The path `/api/alpha/` might be too specific. You’re interested in counting all requests under the `/api/alpha/` endpoint, which can include various sub-paths (e.g., `/api/alpha/1`, `/api/alpha/2`, etc.). If you limit the counter to `/api/alpha/` without accounting for wildcard paths, it will miss any requests to subpaths of `/api/alpha/`. - Key Limitation: Too restrictive as it doesn’t account for the wildcard pattern ``. B) Add a Stackdriver counter metric for endpoint:/api/alpha/. - Description: This option suggests creating a custom Stackdriver metric that counts requests matching `/api/alpha/`. - Why Chosen: This is the best solution. By creating a counter metric that matches `/api/alpha/`, you can directly capture all requests to the `/api/alpha` endpoint and its subpaths, as the wildcard `` can match any path under `/api/alpha/`. This will provide an accurate count of all requests for any endpoint starting with `/api/alpha/`. - Key Strength: It directly targets your requirement by handling wildcard paths and provides a clear count for all related requests. C) Export the logs to Cloud Storage and count lines matching /api/alpha. - Description: This option involves exporting logs to Cloud Storage and then performing custom processing to count lines that matc... Author: NebulaEagle11 · Last updated Jul 4, 2026 |
You want to re-architect a monolithic application so that it follows a microservices model. You want to accomplish this efficiently while minimizing the imp...When transitioning from a monolithic architecture to a microservices model, several factors must be considered: minimizing business disruption, managing complexity, maintaining operational efficiency, and reducing risk. Let's evaluate each approach: A) Deploy the application to Compute Engine and turn on autoscaling. This option involves scaling the existing monolithic application using cloud resources like Compute Engine with autoscaling. However, it doesn't address the core problem of transitioning to a microservices model. It might improve performance, but it doesn't evolve the system to microservices, and would not be a true architectural change. Why rejected: This is not a valid approach for transitioning to microservices, as it only focuses on scaling the monolith rather than re-architecting it. B) Replace the application's features with appropriate microservices in phases. This is a more gradual approach where you replace individual monolithic features with microservices over time. The advantage of this method is that you can decompose the monolith without a full rewrite, and the business can continue to operate with minimal disruption. It also allows testing and validating microservices incrementally. Why selected: This is often the most efficient way to transform a monolithic system into microservices while minimizing risk and operational impact. It reduces the complexity of a complete refactor and allows for incremental changes. Teams can focus on one service at a time, testing and learning from each change. This approach also provides flexibility to roll back or iterate if issues arise during the migration. C) Refactor the monolithic application with appropriate microservices in a single effort and deploy it. This involves refactoring the entire application into microservices all... Author: Emma · Last updated Jul 4, 2026 |
Your existing application keeps user state information in a single MySQL database. This state information is very user-specific and depends heavily on how long a user has been using an application. The MySQL database is causing chall...To address the issue where user-specific state information is being stored in a single MySQL database, and maintaining and enhancing the schema has become challenging, we need to evaluate the most suitable storage option based on factors like scalability, flexibility, and ease of schema management. A) Cloud SQL (MySQL) Cloud SQL is a managed relational database service that supports MySQL, PostgreSQL, and SQL Server. While it provides managed infrastructure for MySQL databases, it still relies on traditional relational database principles. Given that the user state information is highly specific and dependent on user data patterns (and the schema is becoming hard to manage), a relational model like MySQL may struggle to scale efficiently for a highly dynamic, user-specific workload, especially when schema changes are frequent or complex. Why rejected: Cloud SQL (MySQL) is still a relational database, so managing user-specific state in such a schema-heavy way can become complex as the number of users grows. The relational nature doesn't necessarily fit the need for flexible schema evolution in this case. B) Cloud Storage Cloud Storage is designed to store large amounts of unstructured data such as files, media, backups, or archives. While it offers scalability and reliability, it is not designed for structured data with frequent queries or relationships like user state information that needs efficient querying, updating, and managing specific user data. Why rejected: Cloud Storage is not suitable for managing user-specific, dynamic state information. It is not optimized for use cases requiring complex querying or schema evolution. C) Cloud Spanner Cloud Spanner is a horizontally scalable relational database that offers global distribution and strong consistency. It’s designed for applications that require relational database capabilities (like ACID transactions) at scale. However, Cloud Sp... Author: Layla · Last updated Jul 4, 2026 |
You are building a new API. You want to minimize the cost of storing and reduce the latency of serving...To minimize the cost of storing and reduce the latency of serving images, it's important to choose an architecture that efficiently stores images while also ensuring that they can be quickly retrieved by users, regardless of location. Let’s evaluate each option based on key factors like storage cost, latency, scalability, and performance. A) App Engine backed by Cloud Storage App Engine is a Platform-as-a-Service (PaaS) solution that allows you to deploy applications without managing the underlying infrastructure. Cloud Storage is an object storage service designed to store large amounts of unstructured data like images. However, App Engine might not be the most efficient solution for serving images since it’s optimized for web applications and APIs rather than large file serving. While Cloud Storage offers low-cost storage, the combination of App Engine and Cloud Storage might introduce unnecessary overhead in terms of infrastructure management and latency for serving large numbers of images. Why rejected: Although Cloud Storage is a good choice for storing images, App Engine is not the most cost-effective or latency-optimized solution for serving them at scale. It's better suited for web application logic rather than large-scale, low-latency image serving. B) Compute Engine backed by Persistent Disk Compute Engine offers virtual machines (VMs) with flexible configurations, and Persistent Disk provides durable block storage. While this setup offers complete control over the infrastructure, it comes with higher operational overhead, as you would need to manage the VMs, scale them, and optimize the system for serving images. Additionally, Persistent Disk is typically more expensive than Cloud Storage and not optimized for serving static assets like images at scale. Why rejected: This solution involves unnecessary complexity for serving static content (images), with higher operational costs and more management overhead compared to specialized storage and serving solutions. It is more suitable for applications requiring custom processing or computing power, rather than efficient content delivery. C) Transfer Appliance backed by Cloud Filestore The Transfer ... Author: Leah Davis · Last updated Jul 4, 2026 |
Your company's development teams want to use Cloud Build in their projects to build and push Docker images to Container Registry. The operations team requires all Docker images to be published to a centralize...When selecting an architecture to ensure Docker images are securely and centrally managed by the operations team while being built by the development teams, we need to consider factors like security, maintainability, and ease of management. Let’s evaluate each option: A) Use Container Registry to create a registry in each development team's project. Configure the Cloud Build build to push the Docker image to the project's registry. Grant the operations team access to each development team's registry. This option involves creating separate Container Registries for each development team, with access granted to the operations team. While this approach might provide each team with control over their own registry, it does not fully centralize the image management, which is a key requirement from the operations team's perspective. Managing multiple registries can lead to inconsistent access control, monitoring, and auditing, and may increase the complexity of the infrastructure. Why rejected: It does not fully centralize image management, which is important for the operations team. Managing multiple registries increases the complexity and potential security risks. B) Create a separate project for the operations team that has Container Registry configured. Assign appropriate permissions to the Cloud Build service account in each developer team's project to allow access to the operation team's registry. This option allows the operations team to have a centralized Container Registry in a separate project, and Cloud Build can push images to this registry by assigning appropriate permissions to the Cloud Build service accounts in each development team's project. This approach centralizes the image storage and management in the operations team's project, which meets the security and management requirements. Permissions can be carefully controlled, ensuring that the operations team can manage the images while allowing developers to push images without requiring access to the operations team's project directly. Why selected: This is a clean solution that meets all requirements: centralizing the registry, securely managing access, and allowing developers to push images. It is easy to manage and provides better control over the registry while reducing complexity. C) Create a separate project for the operations team that has Container Registry configured. Create a Service Account for each development tea... Author: Aria · Last updated Jul 4, 2026 |
You are planning to deploy your application in a Google Kubernetes Engine (GKE) cluster. Your application can scale horizontally, and each instance of your application needs to have a stabl...When deploying an application that requires horizontal scaling with a stable network identity and its own persistent disk, we need to choose the appropriate Google Kubernetes Engine (GKE) object that provides both statefulness and scalability. Let’s evaluate each option: A) Deployment A Deployment is used to manage stateless applications that scale horizontally by creating and managing replicas of Pods. However, Deployments are not suited for applications that require persistent storage or stable network identities for each Pod instance. Deployments automatically assign random names to Pods, and each replica might not maintain a consistent network identity. Why rejected: A Deployment does not provide stable network identities or persistent storage, which are required by the application in this scenario. It is best for stateless applications, where individual Pod persistence is not necessary. B) StatefulSet A StatefulSet is specifically designed for managing stateful applications. It provides several key features that are needed in this case: - Stable network identity: StatefulSets assign stable, unique DNS names to each Pod, so each Pod in the StatefulSet can be accessed using a predictable network identity (e.g., `pod-name-0`, `pod-name-1`). - Persistent storage: StatefulSets automatically provision persistent volumes (PVs) for each Pod, ensuring each instance has its own persistent disk that is tied to the specific Pod, even if it is rescheduled or restarted. - Scaling and state management: StatefulSets allow for scaling horizontally while maintaining statef... Author: Matthew · Last updated Jul 4, 2026 |
You are using Cloud Build to build a Docker image. You need to modify the build to execute unit and run integration tests. When there is a failure, you want the build history ...To address the requirements of executing unit and integration tests in the Cloud Build process and ensuring that the build history clearly shows the stage at which the build failed, we must consider several factors such as visibility, granularity of steps, and ease of debugging. Option A: Add RUN commands in the Dockerfile to execute unit and integration tests. - Explanation: Adding `RUN` commands in the Dockerfile will execute unit and integration tests during the Docker image build process. While this approach may work for simple test execution, it mixes the application build process with testing. This approach is less ideal because: - Granularity: The Dockerfile is focused on building the image, not on separating test execution. It may not give clear visibility into which specific step of the test process failed. - Debugging: If a test fails, it's not immediately obvious which step in the build process failed (e.g., image build or test execution). Rejected: This option is rejected due to poor visibility and lack of clear step separation for tests in the build logs. Option B: Create a Cloud Build build config file with a single build step to compile unit and integration tests. - Explanation: This approach involves creating a single build step that compiles and executes both unit and integration tests. While this might work, it also consolidates all testing into a single step. This has limitations: - Visibility: It doesn’t allow you to see which specific test type (unit or integration) failed. Since both tests are executed in one step, pinpointing failures can be difficult. - Separation of Concerns: It lacks the clear separation between different stages of testing, making it harder to debug and isolate issues. Rejected: This approach doesn't provide enough clarity about which part of the build (... Author: Ava · Last updated Jul 4, 2026 |
Your code is running on Cloud Functions in project A. It is supposed to write an object in a Cloud Storage bucket owned by project B. However, the write call is failing w...In this scenario, the error "403 Forbidden" occurs because the Cloud Function in Project A is attempting to write an object to a Cloud Storage bucket in Project B but lacks the necessary permissions. To resolve this, we need to ensure that the appropriate permissions are granted to the service account used by the Cloud Function in Project A. Let's analyze each option: Option A: Grant your user account the roles/storage.objectCreator role for the Cloud Storage bucket. - Explanation: The error is related to the permissions of the service account used by the Cloud Function (not your user account). This option would grant permissions to your user account, but since it's the service account running the function that needs the permissions, this is not the right solution. - Rejected: This option doesn't address the service account's lack of permission to access the bucket. Option B: Grant your user account the roles/iam.serviceAccountUser role for the [email protected] service account. - Explanation: This option grants your user account the `iam.serviceAccountUser` role for the service account `[email protected]`. While this might help if your user needs to interact with the service account, it does not address the fundamental issue: the service account itself needs permissions to write to the Cloud Storage bucket. - Rejected: This is not the correct option because the issue is with the service account's ... Author: Aria · Last updated Jul 4, 2026 |
Case study - This is a case study. Case studies are not timed separately. You can use as much exam time as you would like to complete each case. However, there may be additional case studies and sections on this exam. You must manage your time to ensure that you are able to complete all questions included on this exam in the time provided. To answer the questions included in a case study, you will need to reference information that is provided in the case study. Case studies might contain exhibits and other resources that provide more information about the scenario that is described in the case study. Each question is independent of the other questions in this case study. At the end of this case study, a review screen will appear. This screen allows you to review your answers and to make changes before you move to the next section of the exam. After you begin a new section, you cannot return to this section. To start the case study - To display the first question in this case study, click the Next button. Use the buttons in the left pane to explore the content of the case study before you answer the questions. Clicking these buttons displays information such as business requirements, existing environment, and problem statements. If the case study has an All Information tab, note that the information displayed is identical to the information displayed on the subsequent t...To address the problem where HipLocal's .NET-based authentication service fails under intermittent load, the solution should focus on scalability, flexibility, and performance to meet the company's growing demand. Let's evaluate each option based on the requirements and context provided. Option A: Use App Engine for autoscaling. - Explanation: Google App Engine is a fully managed platform that automatically scales applications based on incoming traffic. It supports multiple programming languages, including .NET through custom runtimes. App Engine handles scaling automatically, which aligns well with HipLocal's requirement for elastic scaling. - Benefits: - Serverless: Automatically scales with demand, which is perfect for handling intermittent load spikes. - Reduced Infrastructure Management: HipLocal wants to reduce infrastructure management, and App Engine abstracts away much of the management overhead. - Google-Recommended Practices: App Engine aligns with Google’s best practices for cloud computing. - Drawbacks: App Engine's environment can be restrictive in terms of custom configurations or dependencies for legacy .NET applications, although this can be mitigated using custom runtimes. Option B: Use Cloud Functions for autoscaling. - Explanation: Cloud Functions is a serverless execution environment that is event-driven and scales automatically based on the number of incoming events. It’s great for handling small, stateless workloads that scale quickly. - Benefits: - Serverless: It fits the requirement for elastic scaling without the need to manage infrastructure. - Cost-Effective: It charges based on actual usage, which is good for workloads with unpredictable traffic patterns. - Drawbacks: - Not Ideal for .NET: Cloud Functions doesn’t natively support .NET, making it challenging to use for a .NET-based authentication service. - Cold Starts: For some workloads, Cloud Functions can experience cold starts, which could be a problem for a service like authentication that requires fast response times. Option C: Use a Compute Engine cluster for... Author: Liam · Last updated Jul 4, 2026 |