Select Two (Multi-Select) Questions

Use Cloud Build triggers with branch filters.

Why wrong: Useful for automation but not specifically for security/reliability of deployments.

Push all artifacts to a public Container Registry.

Why wrong: Public registry is insecure.

Enable Cloud Build service account with Editor role.

Why wrong: Too permissive; use least privilege.

Number of requests per second.

Why wrong: Request volume alone does not indicate a problem.

CPU utilization at 50%.

Why wrong: 50% utilization is not critical; might be normal.

Memory usage trend.

Why wrong: Memory trends are not immediate page triggers unless critical.

Alert on every microsecond of latency increase.

Why wrong: Alerting on every tiny change generates noise and desensitizes responders.

Use a single high-level alert that covers all symptoms.

Why wrong: A single alert for all symptoms conflates issues and makes triage difficult.

Set alert thresholds based on arbitrary guesses.

Why wrong: Thresholds should be data-driven, not arbitrary.

Increase max-instances

Why wrong: Increases capacity but does not directly reduce per-request latency.

Enable HTTP/2

Why wrong: May improve multiplexing but not as impactful as cold start reduction.

Use a regional endpoint

Why wrong: May add network latency compared to global endpoint.

node/cpu/usage_time

Why wrong: Node-level metric, not per-container.

container/memory/usage_bytes

Why wrong: Memory metric, not CPU.

container/accelerator/duty_cycle

Why wrong: GPU metric, not CPU throttling.

Use HTTP/2 for faster connection reuse.

Why wrong: Cloud Run supports HTTP/2 but it's not a primary performance factor.

Configure VPC egress through Cloud NAT for lower latency.

Why wrong: NAT adds latency; direct egress is faster.

Disable default service accounts in all projects.

Why wrong: Good practice, but not essential for initial CI/CD foundation.

Configure VPC Service Controls for all projects.

Why wrong: Important for security, but not a prerequisite for basic CI/CD setup.

Rotate keys manually every 90 days.

Why wrong: Manual rotation is error-prone and not recommended.

Embed keys in application code.

Why wrong: Insecure.

Store keys in Cloud Storage with public access.

Why wrong: Insecure.

Identify the person responsible for the incident.

Why wrong: Postmortems are blameless; they focus on systems, not individuals.

Implement a solution immediately.

Why wrong: Implementation happens during incident response, not postmortem.

Automatically escalate all incidents to the engineering manager.

Why wrong: Over-escalation causes noise.

Assign only one engineer to be on call to reduce confusion.

Why wrong: Single point of failure; multiple on-call is better.

Use only one notification channel (e.g., email) to keep the team focused.

Why wrong: Multiple channels increase reliability.

Real-time user feedback

Why wrong: User feedback is not a real-time metric, and not typically on a dashboard.

Security audit logs

Why wrong: Security logs are not directly relevant for service performance incidents.

Error Reporting

Why wrong: Error Reporting aggregates errors but does not define SLIs.

Cloud Trace

Why wrong: Cloud Trace provides latency data but is not used to define SLIs directly.

Cloud Profiler

Why wrong: Cloud Profiler is for performance profiling, not SLOs.

Alerts

Why wrong: Alerts are a result of observability, not a core pillar.

Dashboards

Why wrong: Dashboards visualize data but are not a foundational pillar.

Use a regional Cloud Run with separate service per region.

Why wrong: Regional deployment does not directly reduce startup latency.

Increase the maximum instances limit.

Why wrong: Max instances limit scaling cap, not startup time.

Increase the container concurrency setting.

Why wrong: Concurrency affects how many requests per instance, not startup time.

Use a multi-cluster ingress

Why wrong: Mainly for disaster recovery, not direct performance optimization.

Increase the number of nodes to maximum

Why wrong: Overprovisioning wastes resources and may not improve performance.

Set min-instances to 5 to avoid cold starts

Why wrong: High min-instances increase cost and may not be needed for sporadic traffic; 1 is often enough.

Use Cloud Run for Anthos on GKE for better performance

Why wrong: Cloud Run for Anthos runs on GKE but doesn't inherently solve cold starts; it adds complexity.

Use Cloud Scheduler to trigger the service periodically

Why wrong: Scheduled pings keep instances warm but waste resources; better to optimize cold start directly.

Use standard persistent disk for cost savings

Why wrong: Standard disk has lower IOPS and is not optimal for high I/O workloads.

Enable disk encryption

Why wrong: Encryption adds a slight overhead and does not improve performance.

Increase disk size

Why wrong: Larger disk increases capacity but not IOPS per GB; performance gain is marginal.

Rely solely on synthetic monitoring to measure user experience.

Why wrong: Synthetic monitoring does not capture real user behavior and should be combined with real user monitoring.

Use multiple monitoring tools to cover all aspects of the system.

Why wrong: Consolidating monitoring into a single tool reduces complexity and improves consistency.

Manually analyze logs and metrics to identify issues.

Why wrong: Manual analysis is inefficient; automation is key in cloud monitoring.

Disable all unnecessary APIs at the organization level.

Why wrong: Disabling APIs globally may affect other projects; better to manage per project.

Export billing data to BigQuery for detailed analysis.

Why wrong: Exporting to BigQuery is for analysis, not direct cost control.

Grant billing account access to all project owners.

Why wrong: Granting billing access to all owners increases risk of accidental spending.

Use a single large machine type for all services.

Why wrong: Not a targeted solution for tail latency.

Enable session affinity to keep users on the same pod.

Why wrong: Session affinity can cause uneven load and increase tail latency.

Increase the batch size for processing requests.

Why wrong: Larger batches increase latency for each request.