CCNA Analysing and Optimising Technical and Business Processes Questions

Flat-rate pricing with slot reservations provisions dedicated query-processing capacity for a fixed monthly fee, decoupling cost from query volume. This satisfies the stem's requirement for predictable spend under concurrent workloads, unlike on-demand pricing, which scales with bytes processed.

A managed instance group with preemptible VMs plus periodic checkpointing preserves completed work to persistent storage, so an interrupted job resumes from the last checkpoint rather than restarting. This maintains preemptible cost savings while satisfying the reliability requirement.

Creating a read replica offloads read traffic from the primary instance, improving read performance. Cloud SQL read replicas are asynchronously replicated, which may introduce slight replication lag, but for many read-heavy workloads, this is acceptable. The application can be configured to direct read queries to the replica, reducing load on the primary and improving response times. This approach maintains data consistency for reads that can tolerate eventual consistency.

Partitioning on transaction_date enables partition pruning for date filters, clustering on customer_id co-locates rows for that filter, and dropping the unused materialized view removes its storage and refresh costs. Together these cut bytes scanned, the dominant BigQuery cost driver.

Active Assist applies Google Cloud's recommender engine to analyse usage telemetry and surface rightsizing recommendations, directly satisfying the stem's requirement for spend analysis plus resource optimisation guidance. It covers idle resource detection, committed use discounts and machine-type adjustments natively, unlike generic billing exports or third-party cost tools that lack built-in recommendation logic.

Instance schedules let you define recurring start and stop times for managed instance groups, so the VMs are not billed outside the transcode window. This directly reduces compute cost without manual intervention, and the schedule is managed centrally in Compute Engine, meeting the low operational effort requirement for a predictable monthly workload.

Blameless postmortems must produce concrete follow-up actions, not just narrative. Actionable recommendations that prevent recurrence close the loop between incident analysis and reliability improvement, satisfying the SRE requirement that postmortems drive measurable change rather than assign fault.

A stateful MIG allows you to preserve instance names, persistent disks, and metadata when instances are recreated or restarted. This ensures that each instance maintains its unique identity and persistent storage. It is designed for stateful workloads and supports autohealing and updates without losing state. This directly meets the requirements for identity and data persistence.

Cloud CDN caches HTTP(S) load balancer responses at Google's globally distributed edge points of presence, serving repeat requests close to users. This directly reduces round-trip latency for worldwide users, the stated constraint, without changing the existing Compute Engine backend.

Cloud Budget alerts let you set a monthly spend threshold scoped to a billing account or project and trigger notifications when actual or forecast spend exceeds it. This directly satisfies the stem's requirement for a spending limit with threshold-based alerts, which Compute Engine quotas cannot provide.

Preemptible VMs offer up to 80% discounts versus standard instances, directly meeting the 60–90% cost-reduction constraint. They suit interruption-tolerant batch analytics because Compute Engine terminates them after 24 hours maximum, with 30-second preemption notice. This makes them the cheapest option for workloads that can checkpoint and resume.

Anthos Service Mesh (ASM) provides automatic distributed tracing and service-level metrics without requiring application code changes. It uses sidecar proxies to capture telemetry and integrates with Cloud Trace and Cloud Monitoring. This meets the requirement for visibility into service latency without modifying code, making it the correct solution.

Migrate for Compute Engine performs automated lift-and-shift replication of on-premises VM disks to Compute Engine, continuously syncing changes so cutover downtime is minimal. This satisfies the incremental disk replication and low-downtime constraints for the 50 VMs without manual rebuilds.

Increasing vCPUs scales the primary instance vertically, allowing it to handle more read queries concurrently, improving throughput without application modification.

Preemptible VMs suit this fault-tolerant nightly batch job because they cost up to 80% less than standard instances, and the workload already tolerates restarts. The 24-hour maximum lifetime exceeds the 4-hour runtime, so forced preemption risk is acceptable, satisfying the cost-reduction constraint without disrupting analytics.

Kubernetes Network Policies allow you to define ingress and egress rules for pods, enforcing communication only with specified services. GKE supports network policy logging, which provides visibility into allowed and denied traffic. This meets the requirement without modifying application code, as policies are applied at the network layer.

Committed use discounts (CUDs) provide up to 57% discount for a 1-year commitment on Compute Engine resources. Since the workload is predictable and runs 24/7 for at least 12 months, purchasing a commitment for the exact resources used is the most cost-effective option. It does not affect performance or availability because the resources remain dedicated to your project.

GKE cost allocation uses a combination of resource requests and actual usage to distribute cluster costs to namespaces, and you can apply labels to namespaces for team attribution. This requires no application changes and provides accurate chargeback data in Cloud Billing. It also supports budget alerts by label, enabling proactive governance.

Cache invalidation removes specific cached objects from Cloud CDN edge servers, forcing subsequent requests to fetch fresh content from the origin. This directly satisfies the stem's requirement to purge a critical fix immediately without altering the URL, unlike versioned deployments which rely on new URLs to bypass cached entries.

Binary Authorization is a deploy-time security control that ensures only trusted container images are deployed on GKE. By configuring a policy that requires an attestation from the security team's attestor, only images that have been scanned and approved can be admitted. This enforcement happens at the cluster level without changing the CI/CD pipeline.

Cloud Monitoring allows you to define SLOs based on latency distributions, set a performance goal (e.g., 99% of requests under 200 ms), and create alerting policies based on error budget burn rates. This directly meets the requirement to measure the proportion and alert on rapid consumption.

Partitioning splits the table by date or timestamp, so a query with a date filter prunes irrelevant partitions and scans only the matching ones. This reduces bytes processed, lowering cost and improving performance versus full table scans.

Autoscaling adjusts the number of VM instances in the group based on load, so you pay only for what you need. Setting a lower minimum reduces cost during low-traffic periods, while the autoscaler adds instances when CPU or other metrics rise, preserving performance during peaks. This directly addresses the low average utilization without manual intervention.

A global external Application Load Balancer provides a single anycast IP and routes each user to the closest healthy backend based on latency and health. By deploying the stateless API in multiple regions behind this load balancer, users in each geography are served from a nearby region, reducing latency without code changes. This is the standard global serving pattern in Google Cloud.

Power, cooling, and physical security are ongoing operational costs rarely captured in on-premises hardware quotes, so including them gives a truer TCO comparison against Google Cloud's consumption pricing, where the provider absorbs these facilities costs.

This directly addresses the overprovisioning by scaling the number of instances to match demand and using a smaller machine type that fits actual CPU usage. It maintains availability because the managed instance group can span zones and replace unhealthy instances, and it does not require application changes since the app is stateless.

A multi-cloud CSPM tool can provide a single pane of glass to define, monitor, and enforce security policies across Google Cloud and other providers. It can detect and remediate misconfigurations like public storage buckets consistently. This meets the requirement for centralized management across multiple clouds.

Preemptible VMs cost substantially less than standard instances but can be terminated at any time with a 30-second warning. Because the nightly batch job is resilient to interruptions and restarts from checkpoints, this pricing model satisfies the stem's cost-reduction goal without risking data loss.

Database Migration Service performs continuous replication from the on-premises PostgreSQL source to Cloud SQL, keeping downtime to a minimum during cutover. Its built-in schema conversion handles incompatible objects automatically, satisfying the automated conversion requirement for the 5 TB migration.

Database Migration Service performs continuous, log-based replication from the on-premises MySQL 5.6 source to Cloud SQL, keeping the target synchronised until cutover. This satisfies the minimal-downtime constraint, since only a brief final promotion is needed rather than a full dump-and-restore outage.

Separate projects enforce isolation. Developers have editor in dev (can deploy and test) but only viewer in prod (cannot modify). Cloud Build uses a dedicated service account with least privilege to deploy to production, ensuring developers cannot directly modify prod. This meets separation of duties and least privilege while enabling CI/CD through automation.

Preemptible VMs suit fault-tolerant batch jobs because they cost up to 80% less than standard instances, though Compute Engine may terminate them within 24 hours. Since the nightly analytics workloads can be interrupted without harm, this discount directly satisfies the finance team's cost-reduction constraint.

Object Lifecycle Management transitions objects between storage classes and deletes them based on age conditions, applied automatically without manual intervention. Setting Nearline at 90 days and deletion at 1095 days matches both the cost-reduction and three-year retention requirements for the infrequently accessed videos.

Transfer Appliance bypasses the 100 Mbps network constraint entirely by shipping encrypted physical hardware, making it far faster than any online transfer for 500 TB. Its suitability for infrequently accessed archival data matches the stem's access pattern, whereas Storage Transfer Service or gsutil would take months over the limited link.

PgBouncer pools and reuses backend PostgreSQL connections, so frequent open/close cycles from developers hit the pooler rather than Cloud SQL directly. This satisfies the no-code-changes constraint because applications connect to PgBouncer's endpoint transparently, while transaction pooling cuts the per-connection authentication and process-fork overhead that caused the bottleneck.

Slot reservations, billed as flat-rate capacity, provision a fixed number of slots for a committed period, so cost stays constant regardless of query volume. This satisfies the predictable monthly cost requirement, matching the steady 500-slot workload without on-demand per-query charges.

Recommender, part of Active Assist, analyses Compute Engine utilisation metrics and generates rightsizing recommendations for underutilised instances. It automatically computes the optimal machine type or tier, directly satisfying the requirement to reduce cost through sizing guidance.

Cloud Monitoring's SLO monitoring allows you to define service level objectives based on metrics. For latency, you can use a distribution cut on a histogram metric to specify the threshold (200 ms) and calculate the ratio of good requests to total requests over a rolling window. This provides automated tracking, error budget calculation, and alerting.

Reversing the timestamp places the newest reading first within each sensor's contiguous row range, so a time-range scan reads sequential rows without hotspots. Prefixing sensor_id keeps each sensor's data co-located, matching the access pattern exactly.

Cloud Monitoring alerting policies can send notifications to Pub/Sub, which can trigger Cloud Functions. This allows automated remediation such as restarting a VM or scaling a deployment. It integrates with existing monitoring and reduces MTTR by removing manual steps. This is a native, serverless approach that requires no additional infrastructure.

Cloud CDN caches static assets at Google edge points of presence, so repeated requests terminate near users rather than traversing to the Compute Engine backends. Enabling it on the existing Global HTTPS Load Balancer requires no application code changes, directly addressing the slow static asset loads.

A lifecycle policy applies transition rules based on object age, automatically moving objects from Standard to Archive after 90 days without manual intervention. This directly satisfies the requirement to reduce storage costs for infrequently accessed data through automated class transitions.

Multi-regional Cloud Storage provides durable, geo-redundant storage for configuration and deployment scripts, so rebuilds after a regional failure can retrieve them without depending on the failed region. This supports the four-hour RTO by accelerating Compute Engine re-provisioning.

Database Migration Service (DMS) supports online migration from Oracle to Cloud SQL for PostgreSQL with minimal downtime.

Preemptible VMs cost up to 80% less than standard instances, satisfying the cost-reduction constraint. Because the batch training jobs tolerate interruption, the 24-hour maximum lifespan and abrupt termination risk are acceptable. Spot VMs offer similar discounts but with different eviction behaviour; preemptible suits this workload's fault tolerance.

Cloud Bigtable sorts rows lexicographically by row key, so a timestamp prefix scatters a single ID's rows across the entire table, forcing wide scans. Leading with the random ID groups all of one ID's rows contiguously, letting queries read a narrow, adjacent range.

Active Assist uses machine learning to analyze resource usage and provide recommendations, such as identifying idle VMs, unattached disks, or overprovisioned instances. It can also recommend committed use discounts. This directly meets the requirement for automated cost recommendations and helps teams follow best practices.

PgBouncer sits between the application and Cloud SQL, multiplexing many client connections onto a small pool of persistent backend connections. This satisfies the no-code-change constraint and relieves connection overhead, since the application still connects normally to the proxy.

Terraform is a declarative infrastructure as code tool that supports version control and provides a 'terraform plan' command to preview changes before applying. The Google Cloud provider allows management of all GCP resources. This meets the requirements for repeatability, version control, and change preview.

Setting requests and limits gives the scheduler accurate information to place pods and prevents noisy-neighbour problems. It also enables the cluster autoscaler to make better scaling decisions and allows vertical pod autoscaling to right-size workloads. Without them, the scheduler cannot bin-pack efficiently, leading to the underutilisation and overcommitment described.

A business impact analysis (BIA) links applications to business processes, revealing criticality, dependencies, and potential operational overhead. This helps prioritize migrations and identify opportunities to reduce overhead, such as retiring redundant applications or consolidating. It ensures the migration plan supports the business goal, not just technical feasibility. Without BIA, the plan may miss cost-saving and risk-reduction opportunities.

Placing the appliance in the same VPC and overriding the default route to use the appliance as the next hop forces all egress through it for inspection. Instances keep private IPs and no public IPs, and the existing VPC is reused with only route and firewall rule changes, minimising network redesign. This is the standard hub-and-spoke or inline inspection pattern in a single VPC.

Cloud Spanner provides externally consistent reads and linearisable transactions globally, using TrueTime to synchronise commit timestamps across regions. This satisfies the stem's requirement for strong consistency across regions for financial transactions, unlike eventually consistent multi-region databases.

Database Migration Service uses continuous replication to keep the target Cloud SQL instance synchronised with the source MySQL database, then performs a brief cutover. This minimises downtime for the mission-critical 5 TB database, satisfying the stem's constraint.

Transfer Appliance ships data physically, bypassing the 1 Gbps link that would take far longer than 30 days for 500 TB. It is cost-effective for bulk offline transfer and reliable, satisfying both the deadline and cost constraints.

Request success rate measures the proportion of successful requests against total requests, expressed as a ratio. This directly satisfies the stem's 99.9% availability SLO over a 30-day window, since availability is defined by served versus total valid requests.

Cloud CDN caches static content at Google's global edge locations, reducing latency for worldwide users while serving from Cloud Storage origins. Its cache invalidation feature lets the team purge stale objects quickly after updates, satisfying both the latency and invalidation constraints.

A managed instance group automatically recreates preempted VMs, directly addressing the reliability constraint while retaining preemptible pricing. Autoscaling maintains capacity by adding instances when demand rises, so the batch job recovers without manual intervention. This satisfies the requirement to improve resilience without significantly increasing cost, since preemptible rates still apply.

Spend-based CUDs are billing-account-level commitments, so Google Cloud automatically applies the resulting discount credits across all eligible projects under that billing account without per-project configuration. This satisfies the stem's cost-optimisation goal for inconsistent usage, since no resource-level matching is required.

BigQuery automatically moves data to long-term storage after 90 days of no modifications, reducing storage costs by about 50%. The data remains queryable, and query performance is generally not affected. This approach requires no manual intervention and is ideal for rarely queried historical data.

Indexes let PostgreSQL satisfy query predicates without sequential scans, cutting execution time for the slow queries observed. This addresses the query-performance half of the scenario directly, reducing per-query resource consumption on the Cloud SQL instance.

A locked retention policy prevents objects from being deleted or overwritten until the retention period expires, and it cannot be removed or shortened once locked. This enforces immutability for seven years for all users, including administrators, with minimal configuration. It directly satisfies the compliance requirement without custom code or external tooling.

Cloud KMS allows you to create and manage customer-managed encryption keys (CMEK). By granting the appropriate IAM role to the service account, the application can use the key to encrypt and decrypt data. This meets the requirement for CMEK. Additionally, Cloud KMS integrates with Cloud Audit Logs to track key usage, satisfying the auditing requirement.

A lifecycle policy applies rule-based transitions based on object age, moving data from Standard to Nearline at 30 days and to Archive at 90 days automatically. This satisfies the stem's requirement for scheduled storage-class transitions without manual intervention.

Istio provides fine-grained traffic splitting to route a percentage of traffic to the canary. Combined with Prometheus metrics and analysis, you can automatically promote or roll back based on error rates. This directly supports progressive delivery with automated rollback, meeting the requirement for risk reduction and monitoring.

Budget alerts provide proactive notifications when costs approach or exceed predefined limits. They do not stop spending, but they enable timely action. This is a core cost governance mechanism that increases awareness and allows teams to react before costs escalate. It complements detailed analysis by providing early warnings.

Database Migration Service performs continuous, near-zero-downtime replication from on-premises MySQL into Cloud SQL, then promotes the replica at cutover. This directly satisfies the stem's minimal-downtime constraint, unlike dump-and-restore approaches that require taking the source offline.

Rehosting (lift and shift) moves the application with minimal changes, often using Migrate for Compute Engine to replicate the VM to Google Cloud. This meets the immediate goal of minimal modification. It also provides a foundation for later optimization, such as refactoring or replatforming, once the application is running in the cloud.

Partitioning by date divides the table into segments, so queries filtering on the date column prune irrelevant partitions and scan only matching ones. This directly reduces bytes scanned, satisfying the cost-reduction goal for date-filtered analytical queries.

PgBouncer pools and reuses backend connections, so many short-lived client connections multiplex onto a small set of persistent Cloud SQL connections. This removes per-request connection setup overhead, directly addressing the stem's high connection rate and latency constraint.

Exporting Firestore data to BigQuery satisfies the isolation constraint: BigQuery runs aggregations and joins on a columnar engine, separate from Firestore's document-oriented production workload. Firestore natively lacks joins and efficient aggregation, so offloading analytics prevents read contention and preserves catalog latency.

Cloud CDN caches content at Google's globally distributed edge points of presence, serving repeated requests close to users. This directly reduces latency for worldwide users and offloads origin traffic, satisfying the requirement to minimise load on the Compute Engine backend instances behind the global HTTPS load balancer.

At 100 Mbps, transferring 200 TB over the network would take roughly 200 days, far exceeding the 30-day deadline. Transfer Appliance ships data physically via a rackable appliance, sidestepping the bandwidth constraint and completing the migration within the required window.

A blameless postmortem examines the systemic and process failures behind an incident, documenting contributing causes and corrective actions without attributing fault to individuals. This directly satisfies the stem's dual requirement: understanding what went wrong and preventing recurrence, while preserving the psychological safety that encourages honest reporting.

Cloud CDN caches static and cacheable responses at edge points of presence near European and Asian users, cutting round-trip latency to the us-east1 origin. This satisfies the stem's latency goal without altering application architecture, since caching happens transparently at the load balancer layer.