{"id":23448,"date":"2026-09-28T06:56:37","date_gmt":"2026-09-28T06:56:37","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=23448"},"modified":"2026-09-28T06:56:37","modified_gmt":"2026-09-28T06:56:37","slug":"google-professional-cloud-developer-practice-test-questions-and-exam-dumps-part3-q41-60","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/google-professional-cloud-developer-practice-test-questions-and-exam-dumps-part3-q41-60\/","title":{"rendered":"Google Professional Cloud Developer Practice Test Questions and Exam Dumps Part3 Q41-60"},"content":{"rendered":"

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

 <\/p>\n

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

A developer is designing a microservices application in which services need to discover and communicate with one another inside a Google Kubernetes Engine cluster. Which Kubernetes capability provides stable service endpoints?<\/b><\/p>\n

    \n
  1. ConfigMaps<\/span><\/li>\n
  2. PersistentVolumes<\/span><\/li>\n
  3. Kubernetes Services<\/span><\/li>\n
  4. Container images<\/span><\/li>\n<\/ol>\n

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

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

    Kubernetes Services provide stable network endpoints for accessing groups of pods, even when individual pods are replaced or their IP addresses change. In a microservices architecture, each service can communicate with another through its Kubernetes Service name and configured port, rather than depending on individual pod addresses. This simplifies service discovery and supports application scaling and rolling updates. ConfigMaps store non-sensitive configuration, PersistentVolumes provide storage, and container images package application software. Kubernetes Services are therefore suitable for enabling reliable internal communication between microservices running in a GKE cluster.<\/span><\/p>\n

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

    A developer wants to deploy a containerized application to Cloud Run from source code without manually building and managing a container image. Which command-line tool can support this workflow?<\/b><\/p>\n

      \n
    1. gcloud run deploy with source<\/span><\/li>\n
    2. gsutil rsync<\/span><\/li>\n
    3. kubectl get pods<\/span><\/li>\n
    4. bq query<\/span><\/li>\n<\/ol>\n

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

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

      The Google Cloud CLI supports deploying applications to Cloud Run from source using the <\/span>gcloud run deploy<\/span> command with the appropriate source deployment option. This workflow can invoke a build process, produce a container image, and deploy the resulting application to Cloud Run. It reduces the need for developers to manually construct each stage of the container build and deployment process. The deployment still requires suitable permissions, configuration, and a supported application source structure. <\/span>gsutil rsync<\/span> transfers storage objects, <\/span>kubectl get pods<\/span> inspects Kubernetes workloads, and <\/span>bq query<\/span> runs BigQuery queries.<\/span><\/p>\n

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

      A team needs to ensure that a Cloud Run service can access a private Cloud SQL instance securely. Which networking approach should be considered?<\/b><\/p>\n

        \n
      1. Expose the database publicly without restrictions<\/span><\/li>\n
      2. Configure supported private connectivity between Cloud Run and Cloud SQL<\/span><\/li>\n
      3. Embed database credentials in the container image<\/span><\/li>\n
      4. Disable database authentication<\/span><\/li>\n<\/ol>\n

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

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

        Cloud Run can connect to Cloud SQL using supported connection and networking configurations. For a private Cloud SQL instance, developers should configure an appropriate private connectivity path, such as Direct VPC egress or a Serverless VPC Access connector where applicable, and ensure that the service has the necessary database permissions and credentials. This allows the application to communicate with the database without exposing it publicly. Embedding credentials in an image or disabling authentication introduces security risks. The selected networking design should also account for region compatibility, connection limits, and operational monitoring.<\/span><\/p>\n

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

        A developer needs to prevent a Kubernetes application from receiving traffic until it has completed initialization and is ready to serve requests. Which probe should be configured?<\/b><\/p>\n

          \n
        1. Liveness probe<\/span><\/li>\n
        2. Startup script only<\/span><\/li>\n
        3. Readiness probe<\/span><\/li>\n
        4. Resource quota<\/span><\/li>\n<\/ol>\n

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

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

          A readiness probe determines whether a container is ready to accept traffic. Kubernetes uses the probe result to decide whether the pod should be included among the endpoints receiving traffic through its Service. This is particularly useful during startup, initialization, temporary dependency failures, or application warm-up. A liveness probe determines whether a container should be restarted, while a startup probe can protect slow-starting applications from premature liveness failures. Resource quotas limit resource consumption. A readiness probe is therefore the appropriate mechanism for controlling when an application instance begins receiving requests.<\/span><\/p>\n

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

          A developer is configuring a GKE application that takes a long time to initialize. Which probe helps prevent Kubernetes from restarting it prematurely while it starts?<\/b><\/p>\n

            \n
          1. Startup probe<\/span><\/li>\n
          2. Readiness probe only<\/span><\/li>\n
          3. Network policy<\/span><\/li>\n
          4. Horizontal Pod Autoscaler<\/span><\/li>\n<\/ol>\n

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

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

            A startup probe is designed for containers that require significant time to initialize. It allows Kubernetes to defer liveness and readiness probe evaluation until the startup condition succeeds, preventing slow-starting applications from being restarted prematurely because they have not yet become responsive. Developers can configure suitable probe intervals, thresholds, and timeouts based on the application’s expected initialization behavior. A readiness probe controls traffic eligibility, a network policy governs pod communication, and a Horizontal Pod Autoscaler adjusts replica counts. A startup probe is therefore appropriate when an application needs additional time to initialize safely.<\/span><\/p>\n

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

            An application running on GKE experiences increased request volume, and the developer wants Kubernetes to adjust its pod replica count based on observed CPU utilization. Which resource should be configured?<\/b><\/p>\n

              \n
            1. ConfigMap<\/span><\/li>\n
            2. Horizontal Pod Autoscaler<\/span><\/li>\n
            3. PersistentVolumeClaim<\/span><\/li>\n
            4. Ingress<\/span><\/li>\n<\/ol>\n

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

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

              The Horizontal Pod Autoscaler (HPA) adjusts the number of pod replicas according to observed metrics and configured scaling targets. For example, it can increase or decrease a Deployment’s replica count based on CPU utilization when the required metrics infrastructure and resource requests are configured. This helps applications respond to changing workloads while avoiding a permanently fixed replica count. Developers should define sensible minimum and maximum replicas and verify that the application can handle scaling events. ConfigMaps store configuration, PersistentVolumeClaims request storage, and Ingress defines HTTP routing. HPA is therefore appropriate for metric-based pod scaling.<\/span><\/p>\n

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

              A developer wants to restrict communication between selected Kubernetes workloads so that only approved pods can connect to a sensitive backend. Which feature should be configured?<\/b><\/p>\n

                \n
              1. Cloud Scheduler<\/span><\/li>\n
              2. Container registry<\/span><\/li>\n
              3. Kubernetes NetworkPolicy<\/span><\/li>\n
              4. Cloud Build trigger<\/span><\/li>\n<\/ol>\n

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

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

                Kubernetes NetworkPolicy controls network traffic to and from selected pods, subject to support from the cluster’s networking implementation. Developers can define rules that allow communication only from approved workloads or on specified ports, helping reduce unnecessary network access between application components. This is useful for isolating sensitive backends and implementing a more restrictive network design. Policies should be tested carefully because overly restrictive rules can interrupt legitimate application communication. Cloud Scheduler manages scheduled jobs, a container registry stores images, and Cloud Build triggers initiate build workflows. NetworkPolicy is therefore appropriate for controlling pod-to-pod network access.<\/span><\/p>\n

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

                A developer wants to avoid hard-coding a database connection string in a GKE application’s container image. Which Kubernetes object can provide non-sensitive configuration to the container?<\/b><\/p>\n

                  \n
                1. ConfigMap<\/span><\/li>\n
                2. Ingress<\/span><\/li>\n
                3. Deployment strategy<\/span><\/li>\n
                4. Horizontal Pod Autoscaler<\/span><\/li>\n<\/ol>\n

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

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

                  A Kubernetes ConfigMap stores non-sensitive configuration values separately from application code and container images. It can supply configuration through environment variables or mounted files, allowing the same image to be used across multiple environments with different settings. Connection strings that contain passwords or other secrets should not be stored as ordinary ConfigMap values; sensitive information should be handled through Kubernetes Secrets or an appropriate managed secret service. Ingress handles HTTP routing, deployment strategies control updates, and HPA adjusts replica counts. ConfigMap is appropriate for separating non-sensitive application configuration from the container image.<\/span><\/p>\n

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

                  A developer wants to store database passwords securely and make them available to an application running on Google Cloud. Which service should be used?<\/b><\/p>\n

                    \n
                  1. Cloud CDN<\/span><\/li>\n
                  2. Secret Manager<\/span><\/li>\n
                  3. Cloud DNS<\/span><\/li>\n
                  4. Cloud Scheduler<\/span><\/li>\n<\/ol>\n

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

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

                    Secret Manager provides centralized storage and controlled access to sensitive information such as database passwords, API keys, and certificates. Applications can retrieve secrets using authorized identities, while administrators manage access through IAM and monitor usage through audit capabilities. Secret versions also support controlled updates and rotation workflows. Developers should avoid embedding credentials in source code, container images, or ordinary configuration files. Cloud CDN accelerates content delivery, Cloud DNS manages domain resolution, and Cloud Scheduler initiates scheduled tasks. Secret Manager is therefore suitable for securely managing application credentials across Google Cloud environments.<\/span><\/p>\n

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

                    A developer wants a GKE application to automatically retrieve a secret from Secret Manager without placing a long-lived service account key inside the container. Which identity approach is suitable?<\/b><\/p>\n

                      \n
                    1. Public bucket access<\/span><\/li>\n
                    2. Shared administrator credentials<\/span><\/li>\n
                    3. Workload Identity Federation for GKE<\/span><\/li>\n
                    4. Anonymous authentication<\/span><\/li>\n<\/ol>\n

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

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

                      Workload Identity Federation for GKE allows Kubernetes workloads to obtain federated identities for accessing Google Cloud resources, including Secret Manager, when the required IAM configuration is in place. The application can use its workload identity to request access without storing a long-lived service account key in the container. Administrators should grant only the permissions needed to access the relevant secret and verify the Kubernetes service account mapping and workload configuration. Public access, shared administrator credentials, and anonymous authentication do not provide appropriate protection for sensitive secrets. This identity approach supports safer workload authentication and credential management.<\/span><\/p>\n

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

                      A developer needs to inspect the configuration and status of a deployed Kubernetes workload from a command-line environment. Which tool is designed for interacting with Kubernetes clusters?<\/b><\/p>\n

                        \n
                      1. kubectl<\/span><\/li>\n
                      2. gsutil<\/span><\/li>\n
                      3. bq<\/span><\/li>\n
                      4. gcloud storage<\/span><\/li>\n<\/ol>\n

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

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

                        kubectl<\/span> is the Kubernetes command-line tool used to inspect and manage resources in a Kubernetes cluster. Developers can use it to retrieve workload status, examine pod details, view events, apply configuration manifests, and perform other administrative or troubleshooting operations. When working with GKE, the tool must be configured with appropriate cluster credentials and context. <\/span>gsutil<\/span> is associated with Cloud Storage operations, <\/span>bq<\/span> is used for BigQuery, and <\/span>gcloud storage<\/span> provides Cloud Storage commands through the Google Cloud CLI. <\/span>kubectl<\/span> is therefore the appropriate tool for interacting with Kubernetes resources.<\/span><\/p>\n

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

                        A developer wants to inspect application output from a running GKE container to investigate an unexpected error. Which command is commonly used to retrieve container logs?<\/b><\/p>\n

                          \n
                        1. kubectl logs<\/span><\/li>\n
                        2. kubectl scale<\/span><\/li>\n
                        3. kubectl expose<\/span><\/li>\n
                        4. kubectl label<\/span><\/li>\n<\/ol>\n

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

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

                          The <\/span>kubectl logs<\/span> command retrieves logs emitted by containers in Kubernetes pods. Developers can use it to investigate application errors, startup problems, unexpected behavior, and other issues reported through standard output or standard error. For pods with multiple containers, the appropriate container may need to be specified. Logs from terminated containers can sometimes be retrieved using the previous-container option, subject to availability. <\/span>kubectl scale<\/span> changes replica counts, <\/span>kubectl expose<\/span> creates a Service, and <\/span>kubectl label<\/span> manages resource labels. <\/span>kubectl logs<\/span> is therefore the appropriate command for examining container output during troubleshooting.<\/span><\/p>\n

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

                          A developer needs to expose a GKE application externally using an HTTP load balancer and route traffic to the appropriate Kubernetes Service. Which resource can define the routing rules?<\/b><\/p>\n

                            \n
                          1. PersistentVolume<\/span><\/li>\n
                          2. Ingress<\/span><\/li>\n
                          3. ConfigMap<\/span><\/li>\n
                          4. Secret<\/span><\/li>\n<\/ol>\n

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

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

                            An Ingress resource defines HTTP or HTTPS routing rules for directing external requests to Kubernetes Services. Depending on the GKE configuration and selected controller, creating an Ingress can provision or configure a Google Cloud load-balancing resource. Developers can define host-based and path-based routing and configure TLS where supported. The backend Services must be configured correctly, and health checks and firewall requirements should be considered during deployment. PersistentVolumes provide storage, ConfigMaps store non-sensitive configuration, and Secrets manage sensitive values. Ingress is therefore appropriate for defining external web traffic routing to GKE application services.<\/span><\/p>\n

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

                            A developer wants to create a managed relational database that supports automated backups and high availability for a production application. Which Cloud SQL configuration should be considered?<\/b><\/p>\n

                              \n
                            1. A single local database file<\/span><\/li>\n
                            2. High availability configuration<\/span><\/li>\n
                            3. An unauthenticated public database<\/span><\/li>\n
                            4. A container image containing database files<\/span><\/li>\n<\/ol>\n

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

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

                              Cloud SQL offers high availability configurations designed to improve database resilience by maintaining a standby instance and supporting failover when certain failures occur. For production workloads, developers should also configure automated backups, suitable maintenance settings, access controls, and monitoring. High availability can reduce downtime from some infrastructure failures, but it does not replace a comprehensive backup, recovery, and disaster-recovery strategy. A local database file or database files packaged inside an application container are not substitutes for managed production database resilience. A properly configured Cloud SQL high availability setup is therefore appropriate for applications with stronger availability requirements.<\/span><\/p>\n

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

                              A developer is building a Cloud Run application that must handle requests from a Pub\/Sub subscription. Which integration pattern can deliver messages to the service through HTTP requests?<\/b><\/p>\n

                                \n
                              1. Pub\/Sub push subscription<\/span><\/li>\n
                              2. Cloud DNS zone transfer<\/span><\/li>\n
                              3. Cloud Storage lifecycle rule<\/span><\/li>\n
                              4. Kubernetes PersistentVolume<\/span><\/li>\n<\/ol>\n

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

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

                                A Pub\/Sub push subscription delivers messages to a configured HTTPS endpoint by sending HTTP requests. A Cloud Run service can act as that endpoint, allowing the application to process incoming messages without continuously polling Pub\/Sub. The service must be configured to authenticate and authorize the requests appropriately, and its response behavior should follow Pub\/Sub acknowledgment expectations. Developers should also design message processing to handle retries and possible duplicate deliveries safely. DNS zone transfers, storage lifecycle rules, and Kubernetes PersistentVolumes address unrelated infrastructure concerns. A push subscription is therefore a suitable integration pattern for HTTP-based message delivery to Cloud Run.<\/span><\/p>\n

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

                                A developer needs to ensure that a message-processing application does not lose work when a consumer temporarily fails. Which Pub\/Sub design consideration is important?<\/b><\/p>\n

                                  \n
                                1. Disable acknowledgments<\/span><\/li>\n
                                2. Acknowledge messages only after successful processing<\/span><\/li>\n
                                3. Delete the subscription after every message<\/span><\/li>\n
                                4. Publish all messages to an unrelated topic<\/span><\/li>\n<\/ol>\n

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

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

                                  A Pub\/Sub subscriber should acknowledge a message after its processing has completed successfully. If the consumer fails before acknowledgment, Pub\/Sub can redeliver the message according to the subscription’s delivery behavior. This supports reliable processing, but developers must design consumers to tolerate duplicate deliveries because a message may be processed more than once. Idempotent operations, appropriate retry handling, and dead-letter topic configurations can help manage failure scenarios. Disabling acknowledgments or deleting subscriptions undermines reliable processing. Acknowledging only after successful processing is therefore a key design consideration for resilient message-driven applications.<\/span><\/p>\n

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

                                  A developer wants to reduce cold-start latency for a Cloud Run service that receives occasional traffic but must respond quickly when requests arrive. Which configuration can help keep instances available?<\/b><\/p>\n

                                    \n
                                  1. Minimum instances<\/span><\/li>\n
                                  2. Disable authentication<\/span><\/li>\n
                                  3. Remove health monitoring<\/span><\/li>\n
                                  4. Increase log retention only<\/span><\/li>\n<\/ol>\n

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

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

                                    Cloud Run supports minimum instance settings that can keep a specified number of instances available, helping reduce cold-start latency for workloads with intermittent traffic. This can improve responsiveness when requests arrive after periods of inactivity, although it may introduce additional cost because instances are kept available. Developers should evaluate the application’s latency requirements, traffic pattern, resource allocation, and billing implications before enabling the setting. Disabling authentication or removing monitoring does not address instance startup latency, and log retention affects diagnostic data storage. Minimum instances are therefore a relevant configuration for latency-sensitive Cloud Run services.<\/span><\/p>\n

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

                                    A developer needs to ensure that a Cloud Run service uses a specific container image version rather than an image tag that may change over time. Which reference is most suitable for deployment reproducibility?<\/b><\/p>\n

                                      \n
                                    1. A mutable tag such as latest<\/span><\/li>\n
                                    2. An image digest<\/span><\/li>\n
                                    3. An untracked local directory<\/span><\/li>\n
                                    4. A public webpage URL<\/span><\/li>\n<\/ol>\n

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

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

                                      A container image digest uniquely identifies the content of a specific image artifact. Referencing an image by digest helps make deployments reproducible because the deployed workload uses the exact image content associated with that digest, rather than relying on a mutable tag that may later point to a different image. This is particularly useful for controlled releases, auditing, and rollback procedures. Mutable tags can be convenient during development but may introduce uncertainty if they are overwritten. A local directory or webpage URL is not an appropriate immutable container artifact reference. An image digest is therefore suitable for precise deployment identification.<\/span><\/p>\n

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

                                      A developer wants to identify which revision of a Cloud Run service generated a particular request during troubleshooting. Which information should be included in application logs?<\/b><\/p>\n

                                        \n
                                      1. Revision and request context<\/span><\/li>\n
                                      2. Only the developer’s password<\/span><\/li>\n
                                      3. Unrelated billing details<\/span><\/li>\n
                                      4. A static message with no identifiers<\/span><\/li>\n<\/ol>\n

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

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

                                        Including revision identifiers and useful request context in structured application logs helps developers associate errors or performance issues with a specific Cloud Run revision. Contextual fields such as request identifiers, operation names, severity, and relevant non-sensitive metadata can make log searches more effective. Developers should avoid recording passwords, access tokens, or unnecessary personal data. Revision-aware logging is especially valuable during gradual rollouts, when multiple versions may receive traffic concurrently. A static message without identifiers can make diagnosis difficult, while unrelated billing details do not establish which revision handled a request. Revision and request context improve troubleshooting clarity.<\/span><\/p>\n

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

                                        A developer is preparing a production release and wants to verify that the application works correctly before promoting it to the next environment. Which practice supports a controlled release process?<\/b><\/p>\n

                                          \n
                                        1. Skip testing and deploy immediately<\/span><\/li>\n
                                        2. Test the release in a staging environment<\/span><\/li>\n
                                        3. Disable monitoring during deployment<\/span><\/li>\n
                                        4. Replace production configuration with development credentials<\/span><\/li>\n<\/ol>\n

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

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

                                          Testing a release in a staging environment helps developers validate application behavior under conditions that resemble production before promoting the release. Staging tests can cover functionality, integrations, configuration, permissions, performance, and deployment procedures. The environment should use appropriate test data and carefully managed credentials, while avoiding unintended access to production resources. Monitoring and release checks should remain available to help detect problems. Skipping tests or replacing production configuration with development credentials can introduce avoidable operational and security risks. Staging validation is therefore an important step in a controlled application release process.<\/span><\/p>\n

                                           <\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Google Professional Cloud Developer Exam Dumps and Practice Test Dumps.   Question 41 A developer is designing a microservices application in which services need to discover and communicate with one another inside a Google Kubernetes Engine cluster. Which Kubernetes capability provides stable service endpoints? ConfigMaps PersistentVolumes Kubernetes Services Container images Correct Answer: 3 […]<\/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\/23448"}],"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=23448"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/23448\/revisions"}],"predecessor-version":[{"id":23449,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/23448\/revisions\/23449"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=23448"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=23448"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=23448"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}