{"id":17505,"date":"2026-09-21T09:56:27","date_gmt":"2026-09-21T09:56:27","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=17505"},"modified":"2026-09-21T09:56:27","modified_gmt":"2026-09-21T09:56:27","slug":"microsoft-ai-300-practice-test-questions-and-exam-dumps-part14-q261-280","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/microsoft-ai-300-practice-test-questions-and-exam-dumps-part14-q261-280\/","title":{"rendered":"Microsoft AI-300 Practice Test Questions and Exam Dumps Part14 Q261-280"},"content":{"rendered":"

View Full <\/b>Microsoft AI-300 Exam Dumps<\/b><\/a> and Practice Test Dumps<\/b><\/p>\n

 <\/p>\n

Question 261. Which practice helps ensure that model training runs can be reproduced later?<\/b><\/p>\n

    \n
  1. <\/b> Deleting experiment metadata<\/span>
    \n<\/span>2.<\/b> Versioning code, data references, dependencies, and configuration<\/span>
    \n<\/span>3.<\/b> Changing dependencies manually<\/span>
    \n<\/span>4.<\/b> Storing only the final model filename<\/span><\/li>\n<\/ol>\n

    Correct Answer: 2. Versioning code, data references, dependencies, and configuration<\/b><\/p>\n

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

    Reproducible training requires more than retaining the final model artifact. The training code, data references, dependency versions, environment definition, parameters, and relevant configuration should be captured and versioned. This allows a team to understand how a particular model was produced and provides a path for repeating the training process when necessary. Experiment metadata can also help connect a model to a specific run and its evaluation results. Reproducibility is particularly valuable when investigating unexpected model behavior or comparing new experiments with previous results. By preserving the relevant inputs and configuration, an MLOps workflow creates a traceable history rather than relying on undocumented assumptions.<\/span><\/p>\n

    Question 262. Which mechanism can prevent a model from moving to production when its evaluation metric does not meet the required threshold?<\/b><\/p>\n

      \n
    1. <\/b> Automated quality gate<\/span>
      \n<\/span>2.<\/b> DNS configuration<\/span>
      \n<\/span>3.<\/b> Endpoint hostname<\/span>
      \n<\/span>4.<\/b> Storage lifecycle policy<\/span><\/li>\n<\/ol>\n

      Correct Answer: 1. Automated quality gate<\/b><\/p>\n

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

      An automated quality gate can compare model evaluation results against predefined acceptance criteria before allowing an artifact to proceed through the deployment pipeline. For example, a team may establish a minimum value for an appropriate performance metric based on the application’s requirements. If the candidate model does not satisfy the condition, the pipeline can stop or pause promotion and record the result for investigation. This makes model-quality validation repeatable and reduces the chance of accidentally deploying an insufficiently evaluated artifact. Quality gates should be designed around meaningful requirements and used alongside software testing, security validation, data checks, and other controls rather than treated as the only deployment safeguard.<\/span><\/p>\n

      Question 263. Which deployment approach keeps the current production version available while a new version is prepared separately?<\/b><\/p>\n

        \n
      1. <\/b> In-place replacement<\/span>
        \n<\/span>2.<\/b> Blue-green deployment<\/span>
        \n<\/span>3.<\/b> Uncontrolled deployment<\/span>
        \n<\/span>4.<\/b> Manual file overwrite<\/span><\/li>\n<\/ol>\n

        Correct Answer: 2. Blue-green deployment<\/b><\/p>\n

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

        Blue-green deployment maintains separate versions or environments so that the currently active production version can continue serving requests while a new version is prepared. The new environment can be validated using health checks, integration tests, and other deployment checks before traffic is switched. Keeping the existing version available provides a straightforward recovery path if the new release does not behave as expected. This strategy can also make deployment transitions easier to manage because the active and candidate versions are clearly separated. Blue-green deployment does not eliminate the need for monitoring or validation, but it provides an operational structure for controlled switching between validated deployment versions.<\/span><\/p>\n

        Question 264. What should be monitored to determine whether an online ML endpoint is becoming slower?<\/b><\/p>\n

          \n
        1. <\/b> Request latency<\/span>
          \n<\/span>2.<\/b> Model registry size<\/span>
          \n<\/span>3.<\/b> Number of source files<\/span>
          \n<\/span>4.<\/b> Dataset filename<\/span><\/li>\n<\/ol>\n

          Correct Answer: 1. Request latency<\/b><\/p>\n

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

          Request latency measures how long an online endpoint takes to process a request and return a response. Monitoring this value over time can reveal performance degradation that may affect users or downstream applications. Increases in latency can be caused by higher request volume, insufficient resources, inefficient inference operations, dependency failures, network conditions, or deployment changes. Teams can compare current measurements with established baselines and investigate significant deviations. Latency should be analyzed together with error rate, availability, throughput, and resource utilization because a change in one metric may help explain another. Continuous latency monitoring is therefore an important part of operating an online ML endpoint reliably.<\/span><\/p>\n

          Question 265. Which information should be retained to support an effective rollback after a failed deployment?<\/b><\/p>\n

            \n
          1. <\/b> Only the failed model<\/span>
            \n<\/span>2.<\/b> Only the deployment timestamp<\/span>
            \n<\/span>3.<\/b> Known-good model version, environment, and deployment configuration<\/span>
            \n<\/span>4.<\/b> Only the latest source-code file<\/span><\/li>\n<\/ol>\n

            Correct Answer: 3. Known-good model version, environment, and deployment configuration<\/b><\/p>\n

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

            An effective rollback requires the information necessary to restore a previously validated deployment. Retaining the known-good model version is important, but the model may also depend on a specific environment, dependency set, configuration, and infrastructure definition. These associated artifacts should therefore be versioned and retained together. Deployment metadata can help identify exactly which combination was previously validated. When a new release causes unacceptable behavior, this information allows operators to return to a known state without reconstructing the deployment manually. A well-defined rollback process should also preserve logs from the failed release so that the underlying problem can be investigated after service has been restored.<\/span><\/p>\n

            Question 266. Which monitoring signal can help identify changes in incoming feature distributions?<\/b><\/p>\n

              \n
            1. <\/b> Data drift<\/span>
              \n<\/span>2.<\/b> Deployment count<\/span>
              \n<\/span>3.<\/b> Pipeline name<\/span>
              \n<\/span>4.<\/b> Model file size<\/span><\/li>\n<\/ol>\n

              Correct Answer: 1. Data drift<\/b><\/p>\n

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

              Data drift monitoring examines changes in the statistical characteristics of production input data compared with an established reference. A feature distribution may change because of evolving user behavior, changes in business processes, external conditions, data collection changes, or other factors. Detecting drift does not by itself prove that model performance has degraded, but it provides a signal that conditions may differ from those observed during model development or validation. Teams can investigate affected features and compare the drift with model-performance measurements and data-quality indicators. This makes drift monitoring useful as part of a broader observability strategy for detecting changes that may require further analysis or model maintenance.<\/span><\/p>\n

              Question 267. Why should deployment configuration be stored in source control?<\/b><\/p>\n

                \n
              1. <\/b> To make configuration changes traceable and reproducible<\/span>
                \n<\/span>2.<\/b> To prevent automated deployment<\/span>
                \n<\/span>3.<\/b> To eliminate model testing<\/span>
                \n<\/span>4.<\/b> To make production changes undocumented<\/span><\/li>\n<\/ol>\n

                Correct Answer: 1. To make configuration changes traceable and reproducible<\/b><\/p>\n

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

                Storing deployment configuration in source control provides a historical record of how a workload was configured at different points in time. Changes can be reviewed before they are incorporated into a release, and each deployment can be associated with a particular revision. This helps teams identify configuration differences when troubleshooting production issues and supports reproducibility when recreating a previous environment. Source control also works effectively with CI\/CD pipelines because automated processes can retrieve a known version of the configuration rather than relying on undocumented manual settings. This practice reduces configuration drift and provides an important connection between infrastructure, application code, and deployment history.<\/span><\/p>\n

                Question 268. Which control helps ensure that an automated deployment identity cannot modify unrelated resources?<\/b><\/p>\n

                  \n
                1. <\/b> Least-privilege permissions<\/span>
                  \n<\/span>2.<\/b> Shared administrator credentials<\/span>
                  \n<\/span>3.<\/b> Anonymous access<\/span>
                  \n<\/span>4.<\/b> Full subscription permissions<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 1. Least-privilege permissions<\/b><\/p>\n

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

                  Least-privilege permissions restrict an identity to the resources and actions required for its intended responsibilities. An automated deployment identity might need to deploy a specific endpoint or retrieve an approved model artifact, but granting unrestricted permissions could expose unrelated resources to unnecessary risk. Using narrowly scoped roles and managed identities can reduce this exposure while avoiding the need for long-lived credentials in scripts. Permissions should be reviewed as deployment requirements change and access activity should be appropriately logged. Least privilege is particularly relevant for automated systems because pipelines can execute repeatedly and at scale. Limiting their permissions helps reduce the potential impact of compromised credentials or configuration mistakes.<\/span><\/p>\n

                  Question 269. What is the purpose of monitoring prediction distributions after a model is deployed?<\/b><\/p>\n

                    \n
                  1. <\/b> To detect unexpected changes in model output behavior<\/span>
                    \n<\/span>2.<\/b> To replace all software testing<\/span>
                    \n<\/span>3.<\/b> To prevent model versioning<\/span>
                    \n<\/span>4.<\/b> To configure DNS automatically<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 1. To detect unexpected changes in model output behavior<\/b><\/p>\n

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

                    Prediction distribution monitoring examines how frequently different model outputs occur and compares current behavior with an established reference. Unexpected changes can provide an early signal that the incoming data, application context, model behavior, or operational conditions have changed. For example, a classification system may begin producing one category much more frequently than it did during validation. Such a change does not automatically demonstrate that predictions are incorrect, but it can identify an area requiring investigation. Combining prediction monitoring with data-drift measurements, data-quality checks, and available ground-truth performance metrics provides stronger evidence when assessing whether a production model is behaving differently from expectations.<\/span><\/p>\n

                    Question 270. What should happen when an endpoint health check fails during deployment?<\/b><\/p>\n

                      \n
                    1. <\/b> The deployment should normally be stopped, rejected, or recovered according to the defined process<\/span>
                      \n<\/span>2.<\/b> All monitoring should be disabled<\/span>
                      \n<\/span>3.<\/b> The failed endpoint should receive all traffic<\/span>
                      \n<\/span>4.<\/b> The previous model should be deleted<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 1. The deployment should normally be stopped, rejected, or recovered according to the defined process<\/b><\/p>\n

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

                      Health checks provide an important service-level validation before and during deployment. If a new endpoint fails a required health check, directing additional production traffic to that endpoint can increase the impact of the problem. A controlled deployment process should therefore prevent further promotion or initiate the defined recovery procedure. Depending on the architecture, this may involve keeping traffic on the existing version, removing the unhealthy instance, or triggering rollback. Health-check failures should also be logged so that engineers can investigate the cause. This control is complementary to model evaluation because an endpoint can fail operationally even when the model itself has acceptable evaluation metrics.<\/span><\/p>\n

                      Question 271. Which practice provides a history of changes made to ML deployment code and configuration?<\/b><\/p>\n

                        \n
                      1. <\/b> Source control<\/span>
                        \n<\/span>2.<\/b> Endpoint scaling<\/span>
                        \n<\/span>3.<\/b> Data normalization<\/span>
                        \n<\/span>4.<\/b> Model inference<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 1. Source control<\/b><\/p>\n

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

                        Source control maintains a history of revisions to code, configuration, infrastructure definitions, and other managed artifacts. In an MLOps environment, this history helps teams identify what changed between releases and associate deployments with specific revisions. Review mechanisms such as pull requests can provide additional oversight before changes are merged. Source control also supports rollback of configuration and code when a previous version needs to be restored. It should be used alongside model and environment versioning because the production behavior of an ML workload can depend on many related artifacts. Maintaining this history makes deployment processes more traceable and simplifies troubleshooting after unexpected changes.<\/span><\/p>\n

                        Question 272. Which process validates that multiple ML service components can work together correctly?<\/b><\/p>\n

                          \n
                        1. <\/b> Unit testing<\/span>
                          \n<\/span>2.<\/b> Integration testing<\/span>
                          \n<\/span>3.<\/b> Source-code formatting<\/span>
                          \n<\/span>4.<\/b> Artifact naming<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 2. Integration testing<\/b><\/p>\n

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

                          Integration testing focuses on interactions between components rather than the behavior of a single isolated function. For an ML application, an integration test might verify that an endpoint receives an input request, applies the required preprocessing, accesses the model correctly, communicates with supporting services, and returns an expected response. Such tests can identify interface mismatches, configuration errors, dependency problems, and incorrect assumptions between components. They are different from unit tests, which generally focus on individual pieces of code. Running integration tests as part of a deployment pipeline provides additional confidence that the assembled system behaves correctly before it is promoted to production.<\/span><\/p>\n

                          Question 273. Which practice can help detect whether production data no longer resembles the data used during model development?<\/b><\/p>\n

                            \n
                          1. <\/b> Data-drift monitoring<\/span>
                            \n<\/span>2.<\/b> Log deletion<\/span>
                            \n<\/span>3.<\/b> Endpoint renaming<\/span>
                            \n<\/span>4.<\/b> Model file compression<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1. Data-drift monitoring<\/b><\/p>\n

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

                            Data-drift monitoring compares characteristics of incoming production data with a reference distribution or baseline. If meaningful differences emerge, the team can investigate whether changes in the operational environment may affect model behavior. Sources of drift can include changing user populations, new product behavior, altered data collection processes, or external events. Drift is a monitoring signal rather than definitive evidence of model failure, so it should be considered together with data quality and model-performance measurements. Regular monitoring helps organizations recognize when production conditions are changing and provides information that can support decisions about investigation, retraining, or other lifecycle activities.<\/span><\/p>\n

                            Question 274. Why should a production model be associated with a specific environment definition?<\/b><\/p>\n

                              \n
                            1. <\/b> To identify the dependencies and runtime conditions used by the deployment<\/span>
                              \n<\/span>2.<\/b> To eliminate source control<\/span>
                              \n<\/span>3.<\/b> To prevent model evaluation<\/span>
                              \n<\/span>4.<\/b> To make all environments manually configured<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 1. To identify the dependencies and runtime conditions used by the deployment<\/b><\/p>\n

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

                              A model’s behavior can depend on the runtime libraries, framework versions, operating environment, and configuration used to execute it. Associating the model with a specific environment definition helps establish which dependencies and runtime conditions were validated for that deployment. If an incident occurs, engineers can use this information to determine whether the environment changed between releases. Environment definitions should be versioned and reproducible so that a previous deployment can be recreated when needed. This practice complements model and source-code versioning, creating a more complete representation of the release. It is particularly important when automated pipelines deploy models repeatedly across multiple environments.<\/span><\/p>\n

                              Question 275. Which deployment strategy can limit initial exposure of a new ML model in production?<\/b><\/p>\n

                                \n
                              1. <\/b> Canary deployment<\/span>
                                \n<\/span>2.<\/b> Immediate full replacement<\/span>
                                \n<\/span>3.<\/b> Uncontrolled deployment<\/span>
                                \n<\/span>4.<\/b> Manual deletion<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 1. Canary deployment<\/b><\/p>\n

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

                                Canary deployment limits the initial exposure of a new model by directing only a controlled portion of production traffic to it. The existing version continues serving the remaining traffic while the new model is observed under real operational conditions. Teams can monitor error rates, latency, availability, resource consumption, prediction behavior, and other relevant indicators. If the canary version performs within the required boundaries, its traffic allocation can be increased gradually. If problems appear, traffic can be reduced or returned to the established version. This approach provides a structured transition mechanism and can reduce the operational impact of issues discovered only after a model encounters real production inputs.<\/span><\/p>\n

                                Question 276. What is the role of automated testing in a continuous ML deployment pipeline?<\/b><\/p>\n

                                  \n
                                1. <\/b> To identify defects before artifacts are promoted<\/span>
                                  \n<\/span>2.<\/b> To eliminate the need for source control<\/span>
                                  \n<\/span>3.<\/b> To guarantee perfect model performance<\/span>
                                  \n<\/span>4.<\/b> To disable production monitoring<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 1. To identify defects before artifacts are promoted<\/b><\/p>\n

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

                                  Automated testing provides repeatable checks that can run whenever code, configuration, or other deployment artifacts change. Tests may include unit tests, integration tests, data validation, security checks, and other workload-specific validations. Running these checks before promotion helps identify defects early, when they are generally easier to correct. Automated testing does not guarantee perfect model performance because ML behavior can depend on data and production conditions. Instead, it forms one layer of a broader lifecycle that includes model evaluation, controlled deployment, monitoring, and rollback. Integrating testing into CI\/CD helps make quality checks consistent rather than dependent solely on manual execution.<\/span><\/p>\n

                                  Question 277. Which information can help connect a deployed model to the training run that produced it?<\/b><\/p>\n

                                    \n
                                  1. <\/b> Experiment and model lineage metadata<\/span>
                                    \n<\/span>2.<\/b> Endpoint color scheme<\/span>
                                    \n<\/span>3.<\/b> DNS cache duration<\/span>
                                    \n<\/span>4.<\/b> Number of active browser sessions<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1. Experiment and model lineage metadata<\/b><\/p>\n

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

                                    Lineage metadata can establish relationships between training runs, datasets, source revisions, model artifacts, evaluation results, and deployments. This connection is useful when engineers need to determine where a production model originated or reproduce the conditions under which it was created. Experiment tracking can record parameters and metrics, while model registries can associate these records with specific model versions. Maintaining lineage also helps compare candidate models and investigate production issues. The exact metadata captured depends on the workflow, but the goal is to create a traceable relationship between the inputs and processes that produced a model and the artifact that was eventually deployed.<\/span><\/p>\n

                                    Question 278. Which practice helps protect sensitive credentials used by an ML application?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Store credentials in source code<\/span>
                                      \n<\/span>2.<\/b> Use a managed secret store<\/span>
                                      \n<\/span>3.<\/b> Add credentials to deployment logs<\/span>
                                      \n<\/span>4.<\/b> Place passwords in public configuration files<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 2. Use a managed secret store<\/b><\/p>\n

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

                                      A managed secret store provides a dedicated mechanism for protecting credentials, keys, certificates, and other sensitive values. Instead of embedding secrets directly in source code or configuration files, applications and deployment pipelines can access them through controlled identity-based mechanisms. This reduces the likelihood that credentials will be exposed through source repositories, logs, or shared artifacts. Secret-management services can also support access auditing and credential rotation. Access should follow least-privilege principles so that workloads retrieve only the secrets required for their tasks. Separating secret values from application code also allows credentials to change without requiring the underlying application logic to be rewritten.<\/span><\/p>\n

                                      Question 279. Which approach provides evidence that a model met required criteria before production promotion?<\/b><\/p>\n

                                        \n
                                      1. <\/b> Retaining model evaluation results<\/span>
                                        \n<\/span>2.<\/b> Deleting failed experiments<\/span>
                                        \n<\/span>3.<\/b> Removing model metadata<\/span>
                                        \n<\/span>4.<\/b> Skipping validation<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 1. Retaining model evaluation results<\/b><\/p>\n

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

                                        Retaining model evaluation results provides a record of the measurements used to assess a candidate before promotion. These results can include performance metrics, validation dataset references, model version identifiers, timestamps, and other relevant metadata. Such evidence helps establish why a model was considered suitable for the next deployment stage and provides historical context for later investigations. If production behavior changes, engineers can compare current measurements with the results recorded during validation. Evaluation records should be maintained alongside the corresponding model and code versions so that the evidence remains meaningful. This creates stronger traceability than simply recording that a model was approved.<\/span><\/p>\n

                                        Question 280. Which lifecycle best represents a controlled MLOps deployment process?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Develop, version, test, validate, promote through controlled stages, monitor, and maintain rollback capability<\/span>
                                          \n<\/span>2.<\/b> Develop, deploy immediately, and remove monitoring<\/span>
                                          \n<\/span>3.<\/b> Modify production manually without recording changes<\/span>
                                          \n<\/span>4.<\/b> Delete previous releases after every deployment<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 1. Develop, version, test, validate, promote through controlled stages, monitor, and maintain rollback capability<\/b><\/p>\n

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

                                          A controlled MLOps lifecycle connects development activities with disciplined deployment and operational practices. Code, model artifacts, dependencies, environments, and configuration should be versioned so that releases remain traceable and reproducible. Automated tests and model validation provide checks before promotion, while controlled stages and approval or quality gates help prevent unsuitable artifacts from reaching production. After deployment, monitoring should cover operational and model-related signals such as errors, latency, availability, data quality, drift, and prediction behavior. Finally, retaining known-good versions and maintaining rollback procedures provides a recovery mechanism for unexpected failures. These practices work together to support repeatable and observable ML operations.<\/span><\/p>\n

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

                                          View Full Microsoft AI-300 Exam Dumps and Practice Test Dumps   Question 261. Which practice helps ensure that model training runs can be reproduced later? Deleting experiment metadata 2. Versioning code, data references, dependencies, and configuration 3. Changing dependencies manually 4. Storing only the final model filename Correct Answer: 2. Versioning code, data references, dependencies, […]<\/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\/17505"}],"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=17505"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/17505\/revisions"}],"predecessor-version":[{"id":17506,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/17505\/revisions\/17506"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=17505"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=17505"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=17505"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}