Google Google Cloud Architect Professional Exam Prep
Google Cloud Certified - Professional Cloud Architect (Page 8 )

Updated On: 15-Sep-2026

A development manager is building a new application. He asks you to review his requirements and identify what cloud technologies he can use to meet them. The application must: 1. Be based on open-source technology for cloud portability 2. Dynamically scale compute capacity based on demand 3. Support continuous software delivery 4. Run multiple segregated copies of the same application stack 5. Deploy application bundles using dynamic templates 6. Route network traffic to specific services based on URL Which combination of technologies will meet all of his requirements?

  1. Google Kubernetes Engine, Jenkins, and Helm
  2. Google Kubernetes Engine and Cloud Load Balancing
  3. Google Kubernetes Engine and Cloud Deployment Manager
  4. Google Kubernetes Engine, Jenkins, and Cloud Load Balancing

Answer(s): A

Explanation:

The correct answer is A because it provides a comprehensive solution that addresses all the stated requirements. Google Kubernetes Engine (GKE) leverages open-source Kubernetes, fulfilling the portability mandate. GKE's inherent capabilities automatically scale compute resources based on demand, handling dynamic workloads effectively. Jenkins, a widely adopted open-source CI/CD tool, facilitates continuous software delivery pipelines. Kubernetes namespaces within GKE enable the creation of isolated application environments, supporting multiple segregated instances of the application stack. Helm, a package manager for Kubernetes, allows for the deployment of application bundles using reusable charts and dynamic templates.
While GKE doesn't directly handle URL-based traffic routing, this can be achieved within the Kubernetes context using Ingress controllers, often configured with specialized add-ons like NGINX Ingress.
Option B is incorrect as it lacks the tooling for CI/CD and dynamic template deployments. Option C is inadequate because Cloud Deployment Manager lacks support for dynamic traffic routing and CI/CD pipelines. Option D omits Helm, which is crucial for managing application bundles with dynamic templates. Therefore, the combination of GKE, Jenkins, and Helm offers the most complete solution by addressing all functional needs.
Here are authoritative links for further research:
Google Kubernetes Engine: https://cloud.google.com/kubernetes-engine Jenkins: https://www.jenkins.io/ Helm: https://helm.sh/
Kubernetes Ingress: https://kubernetes.io/docs/concepts/services-networking/ingress/



You have created several pre-emptible Linux virtual machine instances using Google Compute Engine. You want to properly shut down your application before the virtual machines are preempted.
What should you do?

  1. Create a shutdown script named k99.shutdown in the /etc/rc.6.d/ directory
  2. Create a shutdown script registered as a xinetd service in Linux and configure a Stackdriver endpoint check to call the service
  3. Create a shutdown script and use it as the value for a new metadata entry with the key shutdown-script in the Cloud Platform Console when you create the new virtual machine instance
  4. Create a shutdown script, registered as a xinetd service in Linux, and use the gcloud compute instances add-metadata command to specify the service URL as the value for a new metadata entry with the key shutdown-script-url

Answer(s): C

Explanation:

The correct answer is C. Google Compute Engine allows you to specify a shutdown script that executes when a virtual machine instance is about to be terminated, including during preemption. This is achieved by using instance metadata. The metadata key shutdown-script accepts the script's content as its value.
When the instance is preempted or shut down, the script defined in this metadata entry is executed, allowing for graceful shutdown procedures like saving application state, closing connections, or sending notifications. Option A is incorrect because the described location is not used for Compute Engine specific shutdown scripts, instead it's a location for runlevel scripts, which are unrelated to the shutdown event caused by GCE. Options B and D are also incorrect; while xinetd can manage services, it is not the standard method to implement a shutdown script for GCP preemptible VMs. Furthermore, the shutdown-script-url metadata key refers to a URL containing the script not the URL of a service. Instead, shutdown-script directly takes the script's content. Using metadata is the prescribed and supported way to execute scripts during the GCE shutdown process. Metadata is a flexible mechanism to configure instances; it is a simple approach and it's directly integrated into the Compute Engine infrastructure.
Further research can be done here: https://cloud.google.com/compute/docs/metadata/startup-shutdown-scriptshttps://cloud.google.com/compute/docs/instances/preemptible



Your organization has a 3-tier web application deployed in the same network on Google Cloud Platform. Each tier (web, API, and database) scales independently of the others. Network traffic should flow through the web to the API tier and then on to the database tier. Traffic should not flow between the web and the database tier. How should you configure the network?

  1. Add each tier to a different subnetwork
  2. Set up software based firewalls on individual VMs
  3. Add tags to each tier and set up routes to allow the desired traffic flow
  4. Add tags to each tier and set up firewall rules to allow the desired traffic flow

Answer(s): D

Explanation:

The correct answer is D. Add tags to each tier and set up firewall rules to allow the desired traffic flow.
Here's the justification:
Option D leverages Google Cloud Platform's (GCP) firewall capabilities and network tagging, which is the recommended and most efficient approach for controlling traffic flow between different tiers of an application within a single network. Applying tags to each tier (web, API, and database) allows us to identify and differentiate instances belonging to each tier. Then, firewall rules are configured using these tags as source and target specifications, allowing us to define precisely which traffic is permitted between the layers. In this specific case, the firewall rules would allow traffic from the web tier to the API tier and from the API tier to the database tier, while explicitly blocking any direct communication between the web and database tier. This provides the necessary isolation and controlled access for the application's security and functionality. This method uses a declarative approach, making it more manageable and scalable compared to other methods.
Option A, using different subnetworks for each tier, would add unnecessary complexity. Subnetworks are primarily for IP address management, not for fine-grained traffic control within a network.
While subnetworks can provide isolation, they don't directly allow for granular control at the level of individual instances like firewall rules do within the same network. Moreover, subnetworks do not have built-in mechanisms for traffic management.
Option B, using software-based firewalls on individual VMs, would be cumbersome and prone to inconsistencies. Managing firewalls on each VM is an operational overhead and can lead to configuration errors. It's better to rely on GCP's central firewall service which offers ease of management, better performance, and greater overall reliability.
Option C, using tags and routes, is not the appropriate method for controlling traffic flow between different tiers in GCP. Routes primarily concern themselves with where traffic should be sent, not what traffic should be permitted.
While you can specify route tags, it's not a standard security practice and doesn't provide filtering capabilities at the layer that firewalls do.
Authoritative Links:
VPC Firewall rules overview: https://cloud.google.com/vpc/docs/firewalls Using network tags: https://cloud.google.com/vpc/docs/using-tags Virtual Private Cloud (VPC) overview: https://cloud.google.com/vpc/docs/



Your development team has installed a new Linux kernel module on the batch servers in Google Compute Engine (GCE) virtual machines (VMs) to speed up the nightly batch process. Two days after the installation, 50% of the batch servers failed the nightly batch run. You want to collect details on the failure to pass back to the development team.
Which three actions should you take? (Choose three.)

  1. Use Stackdriver Logging to search for the module log entries
  2. Read the debug GCE Activity log using the API or Cloud Console
  3. Use gcloud or Cloud Console to connect to the serial console and observe the logs
  4. Identify whether a live migration event of the failed server occurred, using in the activity log
  5. Adjust the Google Stackdriver timeline to match the failure time, and observe the batch server metrics
  6. Export a debug VM into an image, and run the image on a local server where kernel log messages will be displayed on the native screen

Answer(s): A,C,E

Explanation:

The correct answer is ACE. Here's a detailed justification:

A: Use Stackdriver Logging to search for the module log entries: Kernel modules often generate logs related to their activities and potential issues. Stackdriver Logging provides a centralized platform to collect and analyze logs from various sources, including GCE VMs. Searching for log entries associated with the new kernel module within the relevant timeframe can pinpoint the cause of the failures. This allows the team to identify specific errors, warnings, or other anomalies related to the custom module. https://cloud.google.com/logging/docs/
C: Use gcloud or Cloud Console to connect to the serial console and observe the logs: The serial console captures boot-up logs and console outputs from the GCE VM. Connecting to the serial console via gcloud or the Cloud Console allows examination of early boot messages which might not be captured by Stackdriver logs. This is crucial for diagnosing kernel-level issues as they often occur before the logging agent starts. Specifically, observing kernel panics or loading errors specific to the new module can reveal insights about the module's initial state. https://cloud.google.com/compute/docs/instances/view-serial-console
E: Adjust the Google Stackdriver timeline to match the failure time, and observe the batch server metrics: By analyzing metrics related to CPU utilization, memory, network, and disk I/O using Stackdriver Monitoring, you can establish whether there are any resource constraints or performance bottlenecks that may have contributed to the server failures. Correlating these metrics with the time of failure can help identify patterns and determine if the new module is causing excessive resource consumption, leading to instability. https://cloud.google.com/monitoring/docs/
Why other options are incorrect:
B: Read the debug GCE Activity log using the API or Cloud Console: The GCE Activity log mainly records API calls and management operations (like instance creation, deletion, etc.) rather than operational details of the VMs. It wouldn't contain specific information about a failing kernel module. https://cloud.google.com/resource-manager/docs/audit-logging D. Identify whether a live migration event of the failed server occurred, using in the activity log: Live migrations are transparent to the application, and it is very unlikely that a live migration would be a direct cause for kernel module failure, so checking if live migration took place, won't help in debugging the kernel failure. F. Export a debug VM into an image, and run the image on a local server where kernel log messages will be displayed on the native screen: While potentially useful in an extensive debugging scenario, it is not required in this case. Exporting the VM is a time-consuming process and does not provide quicker feedback than checking the serial console and Stackdriver logs.



Your company wants to try out the cloud with low risk. They want to archive approximately 100 TB of their log data to the cloud and test the analytics features available to them there, while also retaining that data as a long-term disaster recovery backup.
Which two steps should you take? (Choose two.)

  1. Load logs into Google BigQuery
  2. Load logs into Google Cloud SQL
  3. Import logs into Google Stackdriver
  4. Insert logs into Google Cloud Bigtable
  5. Upload log files into Google Cloud Storage

Answer(s): A,E

Explanation:

The correct answer is AE. Here's a detailed justification:

A: Load logs into Google BigQuery: BigQuery is Google Cloud's fully managed, serverless data warehouse optimized for large-scale analytics. Loading the 100 TB of log data into BigQuery directly addresses the company's need to "test the analytics features." BigQuery's columnar storage and SQL interface make it ideal for querying and analyzing large datasets like logs. The data can be easily explored and used to gain insights without the overhead of managing servers. This aligns with the requirement for "trying out the cloud with low risk" since it's a managed service. BigQuery also offers cost-effective storage for large volumes of data.
E: Upload log files into Google Cloud Storage: Cloud Storage is Google Cloud's scalable and durable object storage service. It's a suitable place to "archive" the log data, serving as a long-term backup for disaster recovery. Cloud Storage offers different storage classes (e.g., Nearline, Coldline, Archive) that can be selected based on data access frequency to optimize cost. Storing the logs in Cloud Storage ensures that they are safely stored and can be retrieved when necessary, fulfilling the disaster recovery requirement. It is also cost effective and readily integrated with other google cloud services.
Why other options are not correct:
B: Load logs into Google Cloud SQL: Cloud SQL is a managed relational database service, which isn't suited for the unstructured, large-scale data of log files. It's optimized for transactional workloads, not analytics on huge datasets. C. Import logs into Google Stackdriver: Stackdriver (now Google Cloud Logging and Monitoring) is primarily for operational logging and monitoring, not long-term storage or analytical processing of large volumes of historical log data. D. Insert logs into Google Cloud Bigtable: Bigtable is a NoSQL database for extremely large, high-throughput workloads.
While powerful, it's not ideal for the company's needs in this scenario. It doesn't offer SQL querying and is less suitable for general-purpose analytics compared to BigQuery.
In summary, using Cloud Storage for archiving and BigQuery for analytics provides the most direct and efficient way to address the specific needs of the company, ensuring cost-effectiveness and low risk experimentation in the cloud.
Authoritative Links:
Google BigQuery: https://cloud.google.com/bigquery Google Cloud Storage: https://cloud.google.com/storage



Viewing page 8 of 98
Viewing questions 36 - 40 out of 480 questions


Post your Comments and Discuss Google Google Cloud Architect Professional exam prep with other Community members:

AI Tutor AI Tutor 👋 I’m here to help!