{"id":13152,"date":"2026-09-16T06:51:34","date_gmt":"2026-09-16T06:51:34","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=13152"},"modified":"2026-09-16T07:21:13","modified_gmt":"2026-09-16T07:21:13","slug":"google-professional-cloud-devops-engineer-practice-test-questions-and-exam-dumps-part-1-q1-q20","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/google-professional-cloud-devops-engineer-practice-test-questions-and-exam-dumps-part-1-q1-q20\/","title":{"rendered":"Google Professional Cloud DevOps Engineer Practice Test Questions and Exam Dumps Part 1 Q1 – Q20"},"content":{"rendered":"

<\/h2>\n

View Full <\/b>Google Professional Cloud DevOps Engineer Exam Dumps<\/b><\/a> and Practice Test Dumps.<\/b><\/h2>\n

 <\/p>\n

Question 1<\/b><\/h3>\n

Which metric represents a standard Service Level Indicator (SLI) for measuring request latency in an e-commerce checkout service?<\/b><\/p>\n

    \n
  1. Total count of database CPU throttling events divided by overall system operational uptime.<\/span><\/li>\n
  2. Count of successful checkout requests returning an HTTP status code under 500 in less than 500 milliseconds, divided by total valid checkout requests.<\/span><\/li>\n
  3. Total number of container restarts on Google Kubernetes Engine divided by total deployed microservice pods.<\/span><\/li>\n
  4. Total egress network bytes transmitted across regional Virtual Private Cloud firewalls over a 24-hour cycle.<\/span><\/li>\n<\/ol>\n

    Correct Answer:<\/b> 2<\/b><\/p>\n

    Explanation:<\/b><\/p>\n

    A Service Level Indicator defines how well a service performs, with latency typically measured as the ratio of valid requests served within an acceptable threshold to total requests. For an e-commerce checkout service, tracking requests completing successfully under a specific timeframe accurately reflects user experience. Setting realistic SLIs and SLOs allows engineering teams to manage reliability, govern error budgets, and balance velocity with system stability effectively. Properly crafted indicators avoid noise and focus directly on customer-facing symptoms rather than internal infrastructure metrics. Continuous monitoring ensures alignment with business goals and maintains high user satisfaction standards.<\/span><\/p>\n

    Question 2<\/b><\/h3>\n

    Which Google Cloud service ensures that production container images are cryptographically verified before deployment to Google Kubernetes Engine (GKE)?<\/b><\/p>\n

      \n
    1. Cloud Key Management Service combined with Binary Authorization<\/span><\/li>\n
    2. Identity and Access Management service accounts with primitive roles<\/span><\/li>\n
    3. Virtual Private Cloud firewall rules and packet mirroring agents<\/span><\/li>\n
    4. Compute Engine metadata server security plugins<\/span><\/li>\n<\/ol>\n

      Correct Answer:<\/b> 1<\/b><\/p>\n

      Explanation:<\/b><\/p>\n

      Binary Authorization is a deploy-time security control ensuring only trusted, cryptographically signed container images run on Google Kubernetes Engine clusters. By integrating with Cloud Key Management Service, organizations sign images automatically during the CI\/CD pipeline build process inside Cloud Build. This prevents unauthorized or vulnerable images from executing in production environments, mitigating supply chain security risks. Enforcing these policies strengthens compliance mandates, prevents tampering, and guarantees that every deployed workload traces back to an auditable, secure build provenance. Automated verification significantly reduces human error and runtime security breaches.<\/span><\/p>\n

      Question 3<\/b><\/h3>\n

      Where should a DevOps team look in Google Cloud Observability to identify if pods are failing readiness probes during traffic spikes?<\/b><\/p>\n

        \n
      1. Cloud Monitoring container metrics and Cloud Logging query console for pod liveness and readiness events<\/span><\/li>\n
      2. Cloud Storage audit logs for bucket permission changes and IAM policy bindings<\/span><\/li>\n
      3. Billing export tables in BigQuery for aggregated daily usage trends<\/span><\/li>\n
      4. VPC Flow Logs for packet drop counts across regional subnets<\/span><\/li>\n<\/ol>\n

        Correct Answer:<\/b> 1<\/b><\/p>\n

        Explanation:<\/b><\/p>\n

        Cloud Monitoring and Cloud Logging provide comprehensive observability into Kubernetes cluster events, container resource utilization, and probe failures. By querying container logs and monitoring pod restart counts or readiness probe failures, engineers pinpoint why load balancer backends drop traffic. This visibility enables rapid root-cause analysis during incidents, helping teams tune probe timeouts, adjust resource requests, and resolve scaling bottlenecks. Effective observability shortens mean time to resolution and maintains high availability. Proactive alerting on probe failures catches issues early.<\/span><\/p>\n

        Question 4<\/b><\/h3>\n

        Where should the Terraform state file be stored securely for a multi-developer team working on Google Cloud infrastructure?<\/b><\/p>\n

          \n
        1. In a version-controlled local directory on each developer’s personal laptop<\/span><\/li>\n
        2. In a secured, version-enabled Google Cloud Storage bucket with restricted IAM permissions and state locking<\/span><\/li>\n
        3. Directly inside the temporary build directory of transient Cloud Build workers<\/span><\/li>\n
        4. On a single Compute Engine instance running an unencrypted local SQLite database<\/span><\/li>\n<\/ol>\n

          Correct Answer:<\/b> 2<\/b><\/p>\n

          Explanation:<\/b><\/p>\n

          Storing Terraform state files in a centralized, version-enabled Cloud Storage bucket ensures multiple developers share a consistent source of truth while preventing concurrent write conflicts through state locking. Using Cloud Storage protects sensitive infrastructure metadata, provides audit history, and supports disaster recovery through object versioning. Securing the bucket with strict IAM policies ensures that only authorized pipelines and engineers read or modify infrastructure states. Centralized state management is a foundational practice for reliable cloud automation. Proper access controls mitigate security risks.<\/span><\/p>\n

          Question 5<\/b><\/h3>\n

          Which parameters should you evaluate to configure autoscaling for a microservice running on Cloud Run experiencing high latency?<\/b><\/p>\n

            \n
          1. Maximum instance count, container concurrency, and minimum provisioned instances<\/span><\/li>\n
          2. Virtual Private Cloud subnet IP address allocation ranges<\/span><\/li>\n
          3. Cloud SQL database connection pool idle timeouts<\/span><\/li>\n
          4. Artifact Registry image vulnerability scan frequencies<\/span><\/li>\n<\/ol>\n

            Correct Answer:<\/b> 1<\/b><\/p>\n

            Explanation:<\/b><\/p>\n

            Cloud Run autoscaling depends heavily on managing maximum instance limits, container concurrency per instance, and minimum idle instances. Tuning concurrency optimizes how many requests a single container handles simultaneously, while minimum instances reduce cold-start latency for latency-sensitive services. Configuring maximum instances prevents runaway cloud costs during unanticipated traffic surges. Balancing these parameters ensures stable application performance, resource efficiency, and predictable operational expenditures. Continuous load testing helps determine ideal configuration values.<\/span><\/p>\n

            Question 6<\/b><\/h3>\n

            What should you configure in Cloud Deploy to implement a canary deployment that automatically rolls back if error rates exceed a specific threshold?<\/b><\/p>\n

              \n
            1. A static Kubernetes deployment manifest without automated health checks<\/span><\/li>\n
            2. A Cloud Deploy delivery pipeline combined with automated analysis integration via Cloud Monitoring metrics<\/span><\/li>\n
            3. A manual shell script executed via local developer workstations during maintenance windows<\/span><\/li>\n
            4. An uptime check targeting private database IP addresses behind internal load balancers<\/span><\/li>\n<\/ol>\n

              Correct Answer:<\/b> 2<\/b><\/p>\n

              Explanation:<\/b><\/p>\n

              Cloud Deploy supports advanced delivery pipelines executing canary deployments with automated verification. By integrating Cloud Monitoring metrics, Cloud Deploy evaluates error rates or latency during the canary phase and automatically triggers rollbacks if health indicators degrade. This minimizes blast radius, protects end-users from faulty releases, and automates deployment safety. Automated verification replaces error-prone manual monitoring with consistent, policy-driven release controls. Progressive delivery enhances deployment velocity safely.<\/span><\/p>\n

              Question 7<\/b><\/h3>\n

              According to Google SRE incident management practices, what is the immediate priority after mitigating a security exposure caused by an unauthorized IAM role assignment?<\/b><\/p>\n

                \n
              1. Conduct a blameless postmortem to identify root causes and establish preventive action items<\/span><\/li>\n
              2. Immediately terminate all engineering staff associated with the project deployment<\/span><\/li>\n
              3. Delete the entire Google Cloud project and restore from backups taken three years ago<\/span><\/li>\n
              4. Disable all monitoring alerts to prevent notification fatigue across the operations team<\/span><\/li>\n<\/ol>\n

                Correct Answer:<\/b> 2<\/b><\/p>\n

                Explanation:<\/b><\/p>\n

                Following an incident, conducting a blameless postmortem is a core SRE practice designed to understand what happened, why it happened, and how to prevent recurrence. Focusing on systemic weaknesses rather than assigning individual blame fosters a healthy engineering culture and encourages transparent reporting. Action items generated from postmortems improve automation, tighten IAM guardrails, and strengthen overall system resilience. Blameless reviews turn failures into valuable learning opportunities. Continuous improvement drives long-term reliability.<\/span><\/p>\n

                Question 8<\/b><\/h3>\n

                Which Google Cloud service should you use to aggregate logs from hundreds of Compute Engine instances and GKE clusters into a centralized sink?<\/b><\/p>\n

                  \n
                1. Cloud Logging log sinks routed to Cloud Storage or BigQuery<\/span><\/li>\n
                2. Local text files stored directly on individual container root volumes<\/span><\/li>\n
                3. Secure shell command line loops querying system logs manually<\/span><\/li>\n
                4. Virtual Private Cloud packet capture tools without storage persistence<\/span><\/li>\n<\/ol>\n

                  Correct Answer:<\/b> 1<\/b><\/p>\n

                  Explanation:<\/b><\/p>\n

                  Cloud Logging allows administrators to create log sinks exporting filtered logs in real-time to destination services such as Cloud Storage for cost-effective archive, BigQuery for advanced SQL-based analytics, or Pub\/Sub for streaming integration. Centralizing logs ensures compliance with regulatory retention policies and provides a unified dataset for troubleshooting distributed applications. Configuring structured logging improves query performance and simplifies pattern detection. Automated sink routing scales seamlessly across large multi-project organizations.<\/span><\/p>\n

                  Question 9<\/b><\/h3>\n

                  According to DORA metrics, which metric measures how long it takes for a code commit to get deployed into production?<\/b><\/p>\n

                    \n
                  1. Mean Time to Recovery (MTTR)<\/span><\/li>\n
                  2. Change Lead Time<\/span><\/li>\n
                  3. Deployment Frequency<\/span><\/li>\n
                  4. Change Failure Rate<\/span><\/li>\n<\/ol>\n

                    Correct Answer:<\/b> 2<\/b><\/p>\n

                    Explanation:<\/b><\/p>\n

                    Change Lead Time measures the amount of time it takes for code to go from initial commit to running successfully in production. It is one of the core DORA metrics used to evaluate software delivery performance and operational efficiency. Shortening lead time indicates an efficient, automated CI\/CD pipeline capable of delivering rapid value to customers. High-performing teams optimize this metric alongside deployment frequency and change failure rate. Streamlined pipelines reduce friction across development and operations.<\/span><\/p>\n

                    Question 10<\/b><\/h3>\n

                    Which components should you define when setting up an alerting policy in Cloud Monitoring for a Cloud SQL database experiencing high CPU utilization?<\/b><\/p>\n

                      \n
                    1. An alerting policy with a metric filter on Cloud SQL CPU utilization, a threshold condition, and a notification channel<\/span><\/li>\n
                    2. A static cron job running hourly ping requests against the public IP address<\/span><\/li>\n
                    3. An Artifact Registry vulnerability scanning rule for container layers<\/span><\/li>\n
                    4. A Virtual Private Cloud firewall rule blocking unauthorized inbound traffic<\/span><\/li>\n<\/ol>\n

                      Correct Answer:<\/b> 1<\/b><\/p>\n

                      Explanation:<\/b><\/p>\n

                      Cloud Monitoring alerting policies allow teams to define metric-based conditions, evaluation time windows, and notification channels such as email, PagerDuty, or Slack. Setting precise thresholds for resource utilization ensures operations engineers receive early warnings before system performance degrades significantly. Proactive alerting reduces incident duration and prevents outages. Tuning alert sensitivity avoids false positives and alert fatigue.<\/span><\/p>\n

                      Question 11<\/b><\/h3>\n

                      Which Google Cloud feature should you use to enforce organizational policies that prevent developers from provisioning overly expensive Compute Engine machine types?<\/b><\/p>\n

                        \n
                      1. Organization Policy Service with constraints on allowed VM instance types<\/span><\/li>\n
                      2. Manual code review checklist shared via internal wiki pages<\/span><\/li>\n
                      3. Cloud Storage bucket lifecycle rules for temporary files<\/span><\/li>\n
                      4. VPC Service Controls perimeters around public IP addresses<\/span><\/li>\n<\/ol>\n

                        Correct Answer:<\/b> 1<\/b><\/p>\n

                        Explanation:<\/b><\/p>\n

                        The Organization Policy Service allows central cloud administrators to set guardrails and constraints\u2014such as restricting allowed Compute Engine machine types or prohibiting external IP addresses\u2014across folders or projects. This programmable governance prevents cost overruns and enforces security compliance automatically at resource creation time. Enforcing policies at the organization level reduces reliance on manual audits. Proactive guardrails balance developer agility with financial control.<\/span><\/p>\n

                        Question 12<\/b><\/h3>\n

                        Which tool should you use to test network connectivity and inspect packet paths between two microservices running in different VPC networks?<\/b><\/p>\n

                          \n
                        1. Network Intelligence Center Connectivity Tests<\/span><\/li>\n
                        2. Artifact Registry container vulnerability scanner<\/span><\/li>\n
                        3. Cloud Billing budget alert threshold calculator<\/span><\/li>\n
                        4. Cloud Deploy pipeline progression verifier<\/span><\/li>\n<\/ol>\n

                          Correct Answer:<\/b> 1<\/b><\/p>\n

                          Explanation:<\/b><\/p>\n

                          Network Intelligence Center Connectivity Tests provides static configuration analysis between source and destination endpoints within Google Cloud, identifying firewall blockages, routing misconfigurations, or gateway issues. It helps DevOps and network engineers troubleshoot connectivity problems rapidly without needing to execute live packet captures. Automated path analysis saves valuable time during network incidents. Regular testing ensures robust multi-vpc connectivity.<\/span><\/p>\n

                          Question 13<\/b><\/h3>\n

                          Which Google Cloud service should you use to store and access application database credentials securely without hardcoding secrets?<\/b><\/p>\n

                            \n
                          1. Secret Manager<\/span><\/li>\n
                          2. Cloud Storage public buckets<\/span><\/li>\n
                          3. Compute Engine serial port output logs<\/span><\/li>\n
                          4. Artifact Registry unencrypted source tarballs<\/span><\/li>\n<\/ol>\n

                            Correct Answer:<\/b> 1<\/b><\/p>\n

                            Explanation:<\/b><\/p>\n

                            Secret Manager provides secure, centralized storage for sensitive data such as API keys, passwords, and database credentials, supporting versioning and fine-grained IAM access control. Applications can retrieve secrets programmatically at runtime, eliminating the risks associated with hardcoded credentials in source code repositories or container images. Using Secret Manager enhances security posture and compliance alignment. Auditing access to secrets tracks who retrieved sensitive data.<\/span><\/p>\n

                            Question 14<\/b><\/h3>\n

                            Which Kubernetes resource or traffic management tool facilitates routing a specific percentage of incoming user traffic to a canary deployment on GKE?<\/b><\/p>\n

                              \n
                            1. An Ingress controller or service mesh traffic splitting configuration<\/span><\/li>\n
                            2. A static firewall rule blocking 95% of random IP packets<\/span><\/li>\n
                            3. A Cloud Storage object lifecycle expiration policy<\/span><\/li>\n
                            4. A Cloud SQL read replica scaling multiplier<\/span><\/li>\n<\/ol>\n

                              Correct Answer:<\/b> 1<\/b><\/p>\n

                              Explanation:<\/b><\/p>\n

                              Traffic splitting for canary deployments on GKE is typically achieved using an Ingress controller or a service mesh such as Istio or Cloud Service Mesh. These tools allow precise percentage-based routing of traffic between different version deployments, enabling safe validation of new features with real user traffic. Gradual traffic shifting minimizes blast radius if bugs exist in the new release. Automated metric observability during canary splits ensures rapid detection of anomalies.<\/span><\/p>\n

                              Question 15<\/b><\/h3>\n

                              How should you structure your Terraform configuration to handle environment-specific variables securely across staging and production?<\/b><\/p>\n

                                \n
                              1. Use Terraform workspaces or separate directory structures with distinct input variable files (.tfvars)<\/span><\/li>\n
                              2. Hardcode environment names and secret keys directly inside the main resource provider blocks<\/span><\/li>\n
                              3. Store all production credentials in plain text inside public GitHub repositories<\/span><\/li>\n
                              4. Execute manual gcloud command line scripts wrapped in shell loops on local machines<\/span><\/li>\n<\/ol>\n

                                Correct Answer:<\/b> 1<\/b><\/p>\n

                                Explanation:<\/b><\/p>\n

                                Isolating environment-specific configurations using Terraform workspaces or dedicated directory structures with separate variable files ensures clean, maintainable Infrastructure as Code. This approach prevents staging changes from accidentally affecting production resources and allows tailored parameterization for each environment. Proper state segregation protects production stability. Version-controlled variable files improve auditability.<\/span><\/p>\n

                                Question 16<\/b><\/h3>\n

                                What action should a team prioritize next when an error budget is completely exhausted due to a major service outage?<\/b><\/p>\n

                                  \n
                                1. Freeze new feature deployments and shift all engineering effort toward reliability, bug fixes, and test automation until the error budget recovers<\/span><\/li>\n
                                2. Increase the SLO target to 99.99% to hide the previous outage from management stakeholders<\/span><\/li>\n
                                3. Disable all monitoring and alerting systems to stop recording failed requests<\/span><\/li>\n
                                4. Increase infrastructure capacity by 500% without investigating root causes<\/span><\/li>\n<\/ol>\n

                                  Correct Answer:<\/b> 1<\/b><\/p>\n

                                  Explanation:<\/b><\/p>\n

                                  When an error budget is exhausted, standard SRE policy mandates halting feature releases and prioritizing reliability improvements until the budget recovers. This policy balances velocity with stability, aligning development and operations incentives around customer trust. Push reliability work ahead of new features to prevent further degradation of the user experience. Error budgets provide an objective, data-driven mechanism for managing risk.<\/span><\/p>\n

                                  Question 17<\/b><\/h3>\n

                                  Which Google Cloud feature enables continuous vulnerability scanning of container images as soon as they are pushed to Artifact Registry?<\/b><\/p>\n

                                    \n
                                  1. Artifact Registry container vulnerability scanning integration<\/span><\/li>\n
                                  2. Manual inspection of log files using text editors<\/span><\/li>\n
                                  3. Periodic ping sweeps executed via Cron jobs on Compute Engine<\/span><\/li>\n
                                  4. Virtual Private Cloud subnet flow log aggregations<\/span><\/li>\n<\/ol>\n

                                    Correct Answer:<\/b> 1<\/b><\/p>\n

                                    Explanation:<\/b><\/p>\n

                                    Artifact Registry includes built-in vulnerability scanning that automatically inspects pushed container images against known Common Vulnerabilities and Exposures databases. This automated inspection identifies software flaws in base images and dependencies before code reaches production. Early detection in the CI\/CD pipeline reduces security risk and enforces compliance. Integrating scans into build workflows ensures proactive remediation.<\/span><\/p>\n

                                    Question 18<\/b><\/h3>\n

                                    Which Google Cloud service should you integrate with Compute Engine instances to perform distributed tracing and diagnose latency bottlenecks?<\/b><\/p>\n

                                      \n
                                    1. Cloud Trace<\/span><\/li>\n
                                    2. Cloud Billing<\/span><\/li>\n
                                    3. Cloud Storage<\/span><\/li>\n
                                    4. Artifact Registry<\/span><\/li>\n<\/ol>\n

                                      Correct Answer:<\/b> 1<\/b><\/p>\n

                                      Explanation:<\/b><\/p>\n

                                      Cloud Trace collects latency data from distributed applications and provides detailed latency reports and call trees, helping engineers identify performance bottlenecks across microservices. It allows teams to visualize how requests flow through complex architectures and pinpoint slow database queries or network calls. Distributed tracing is essential for maintaining performance in modern cloud-native environments. Optimizing latency improves overall user satisfaction.<\/span><\/p>\n

                                      Question 19<\/b><\/h3>\n

                                      Where should an engineer view aggregated historical resource utilization trends for CPU, memory, and disk I\/O across a fleet of instances over three months?<\/b><\/p>\n

                                        \n
                                      1. Cloud Monitoring metrics explorer and pre-built dashboards<\/span><\/li>\n
                                      2. Local shell logs stored on temporary instance boot disks<\/span><\/li>\n
                                      3. Cloud Billing cost breakdown spreadsheets<\/span><\/li>\n
                                      4. VPC Flow Log packet header summaries<\/span><\/li>\n<\/ol>\n

                                        Correct Answer:<\/b> 1<\/b><\/p>\n

                                        Explanation:<\/b><\/p>\n

                                        Cloud Monitoring retains metric data for extended periods, allowing engineers to analyze historical resource utilization trends for CPU, memory, and disk I\/O. Pre-built dashboards and Metrics Explorer provide intuitive visualizations for capacity planning and performance tuning. Historical analysis helps teams right-size instances and predict future scaling requirements. Accurate metrics drive cost-effective infrastructure management.<\/span><\/p>\n

                                        Question 20<\/b><\/h3>\n

                                        Which security principle should you apply to restrict a Cloud Build service account so it can only deploy to specific GKE clusters?<\/b><\/p>\n

                                          \n
                                        1. Principle of least privilege using granular IAM roles and bindings<\/span><\/li>\n
                                        2. Assigning the primitive Project Owner role to the Cloud Build service account<\/span><\/li>\n
                                        3. Disabling all authentication checks across internal cluster endpoints<\/span><\/li>\n
                                        4. Storing plain-text administrator passwords inside public configuration files<\/span><\/li>\n<\/ol>\n

                                          Correct Answer:<\/b> 1<\/b><\/p>\n

                                          Explanation:<\/b><\/p>\n

                                          The principle of least privilege dictates granting only the minimum necessary permissions required to perform specific tasks. Applying granular IAM roles to the Cloud Build service account limits potential blast radius if the pipeline is compromised. Proper permission scoping protects production workloads from unauthorized access or accidental destruction. Regular IAM audits ensure compliance with security best practices.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Google Professional Cloud DevOps Engineer Exam Dumps and Practice Test Dumps.   Question 1 Which metric represents a standard Service Level Indicator (SLI) for measuring request latency in an e-commerce checkout service? Total count of database CPU throttling events divided by overall system operational uptime. Count of successful checkout requests returning an HTTP […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/13152"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=13152"}],"version-history":[{"count":2,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/13152\/revisions"}],"predecessor-version":[{"id":13258,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/13152\/revisions\/13258"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=13152"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=13152"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=13152"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}