Korzystanie z modelu usługi Azure Machine Learning wdrożonego jako usługa internetowaConsume an Azure Machine Learning model deployed as a web service

Wdrożenie modelu usługi Azure Machine Learning jako usługi internetowej powoduje utworzenie punktu końcowego interfejsu API REST.Deploying an Azure Machine Learning model as a web service creates a REST API endpoint. Można wysłać dane do tego punktu końcowego i otrzymać prognozę zwróconą przez model.You can send data to this endpoint and receive the prediction returned by the model. W tym dokumencie dowiesz się, jak tworzyć klientów dla usługi sieci Web przy użyciu języków C#, go, Java i Python.In this document, learn how to create clients for the web service by using C#, Go, Java, and Python.

Usługa sieci Web jest tworzona podczas wdrażania modelu w środowisku lokalnym, Azure Container Instances, usługi Azure Kubernetes lub tablic bram opartych na polach (FPGA).You create a web service when you deploy a model to your local environment, Azure Container Instances, Azure Kubernetes Service, or field-programmable gate arrays (FPGA). Użytkownik pobiera identyfikator URI służący do uzyskiwania dostępu do usługi sieci Web przy użyciu zestawu SDK Azure Machine Learning.You retrieve the URI used to access the web service by using the Azure Machine Learning SDK. Jeśli jest włączone uwierzytelnianie, można również pobrać klucze uwierzytelniania lub tokeny przy użyciu zestawu SDK.If authentication is enabled, you can also use the SDK to get the authentication keys or tokens.

Ogólny przepływ pracy służący do tworzenia klienta korzystającego z usługi sieci Web Machine Learning to:The general workflow for creating a client that uses a machine learning web service is:

  1. Użyj zestawu SDK, aby uzyskać informacje o połączeniu.Use the SDK to get the connection information.
  2. Określ typ danych żądania używanych przez model.Determine the type of request data used by the model.
  3. Utwórz aplikację, która wywołuje usługę sieci Web.Create an application that calls the web service.

Porada

Przykłady w tym dokumencie są tworzone ręcznie bez użycia specyfikacji OpenAPI (Swagger).The examples in this document are manually created without the use of OpenAPI (Swagger) specifications. Jeśli została włączona Specyfikacja OpenAPI dla danego wdrożenia, można użyć narzędzi, takich jak Swagger-codegen , aby utworzyć biblioteki klienckie dla usługi.If you've enabled an OpenAPI specification for your deployment, you can use tools such as swagger-codegen to create client libraries for your service.

Informacje o połączeniuConnection information

Uwaga

Użyj zestawu SDK Azure Machine Learning, aby uzyskać informacje o usłudze sieci Web.Use the Azure Machine Learning SDK to get the web service information. To jest zestaw SDK języka Python.This is a Python SDK. Możesz użyć dowolnego języka, aby utworzyć klienta dla usługi.You can use any language to create a client for the service.

Klasa Azure. Core. WebService zawiera informacje potrzebne do utworzenia klienta.The azureml.core.Webservice class provides the information you need to create a client. Następujące Webservice właściwości są przydatne podczas tworzenia aplikacji klienckiej:The following Webservice properties are useful for creating a client application:

  • auth_enabled -Jeśli jest włączone uwierzytelnianie klucza True ; w przeciwnym razie False .auth_enabled - If key authentication is enabled, True; otherwise, False.
  • token_auth_enabled -Jeśli uwierzytelnianie tokenu jest włączone, True w przeciwnym razie, False .token_auth_enabled - If token authentication is enabled, True; otherwise, False.
  • scoring_uri — Adres interfejsu API REST.scoring_uri - The REST API address.
  • swagger_uri -Adres specyfikacji OpenAPI.swagger_uri - The address of the OpenAPI specification. Ten identyfikator URI jest dostępny po włączeniu automatycznego generowania schematu.This URI is available if you enabled automatic schema generation. Aby uzyskać więcej informacji, zobacz Wdrażanie modeli przy użyciu Azure Machine Learning.For more information, see Deploy models with Azure Machine Learning.

Istnieje kilka sposobów na pobranie tych informacji dla wdrożonych usług sieci Web:There are a several ways to retrieve this information for deployed web services:

  • Podczas wdrażania modelu Webservice obiekt jest zwracany z informacjami o usłudze:When you deploy a model, a Webservice object is returned with information about the service:

    service = Model.deploy(ws, "myservice", [model], inference_config, deployment_config)
    service.wait_for_deployment(show_output = True)
    print(service.scoring_uri)
    print(service.swagger_uri)
    
  • Możesz użyć, Webservice.list Aby pobrać listę wdrożonych usług sieci Web dla modeli w obszarze roboczym.You can use Webservice.list to retrieve a list of deployed web services for models in your workspace. Filtry można dodać, aby zawęzić listę zwracanych informacji.You can add filters to narrow the list of information returned. Aby uzyskać więcej informacji o tym, co można filtrować, zobacz dokumentację dotyczącą usługi WebService. list .For more information about what can be filtered on, see the Webservice.list reference documentation.

    services = Webservice.list(ws)
    print(services[0].scoring_uri)
    print(services[0].swagger_uri)
    
  • Jeśli znasz nazwę wdrożonej usługi, możesz utworzyć nowe wystąpienie programu Webservice i podać nazwę obszaru roboczego i usługi jako parametry.If you know the name of the deployed service, you can create a new instance of Webservice, and provide the workspace and service name as parameters. Nowy obiekt zawiera informacje o wdrożonej usłudze.The new object contains information about the deployed service.

    service = Webservice(workspace=ws, name='myservice')
    print(service.scoring_uri)
    print(service.swagger_uri)
    

W poniższej tabeli pokazano, jak wyglądają następujące identyfikatory URI:The following table shows what these URIs look like:

Typ identyfikatora URIURI type PrzykładExample
Identyfikator URI ocenianiaScoring URI http://104.214.29.152:80/api/v1/service/<service-name>/score
Identyfikator URI struktury SwaggerSwagger URI http://104.214.29.152/api/v1/service/<service-name>/swagger.json

Porada

Adres IP będzie różny dla Twojego wdrożenia.The IP address will be different for your deployment. Każdy klaster AKS będzie miał własny adres IP, który jest udostępniany przez wdrożenia dla tego klastra.Each AKS cluster will hve it's own IP address that is shared by deployments to that cluster.

Zabezpieczona usługa sieci WebSecured web service

Jeśli wdrożona usługa sieci Web została zabezpieczona przy użyciu certyfikatu TLS/SSL, możesz użyć protokołu HTTPS , aby nawiązać połączenie z usługą przy użyciu identyfikatora URI tworzenia oceny lub struktury Swagger.If you secured the deployed web service using a TLS/SSL certificate, you can use HTTPS to connect to the service using the scoring or swagger URI. Protokół HTTPS pomaga w zabezpieczeniu komunikacji między klientem a usługą sieci Web przez szyfrowanie komunikacji między nimi.HTTPS helps secure communications between a client and a web service by encrypting communications between the two. Szyfrowanie używa Transport Layer Security (TLS).Encryption uses Transport Layer Security (TLS). Protokół TLS jest czasami nazywany Secure Sockets Layer (SSL), który był POPRZEDNIKIEM protokołu TLS.TLS is sometimes still referred to as Secure Sockets Layer (SSL), which was the predecessor of TLS.

Ważne

Usługi sieci Web wdrożone przez Azure Machine Learning obsługują tylko protokół TLS w wersji 1,2.Web services deployed by Azure Machine Learning only support TLS version 1.2. Podczas tworzenia aplikacji klienckiej upewnij się, że jest ona obsługiwana w tej wersji.When creating a client application, make sure that it supports this version.

Aby uzyskać więcej informacji, zobacz Korzystanie z protokołu TLS w celu zabezpieczenia usługi sieci Web za pomocą Azure Machine Learning.For more information, see Use TLS to secure a web service through Azure Machine Learning.

Uwierzytelnianie dla usługAuthentication for services

Azure Machine Learning zapewnia dwa sposoby kontroli dostępu do usług sieci Web.Azure Machine Learning provides two ways to control access to your web services.

Metoda uwierzytelnianiaAuthentication Method ACIACI AKSAKS
KluczKey Domyślnie wyłączoneDisabled by default Domyślnie włączoneEnabled by default
TokenToken NiedostępnyNot Available Domyślnie wyłączoneDisabled by default

Podczas wysyłania żądania do usługi, która jest zabezpieczona za pomocą klucza lub tokenu, użyj nagłówka autoryzacji w celu przekazania klucza lub tokenu.When sending a request to a service that is secured with a key or token, use the Authorization header to pass the key or token. Klucz lub token musi być sformatowany jako Bearer <key-or-token> , gdzie <key-or-token> jest wartością klucza lub tokenu.The key or token must be formatted as Bearer <key-or-token>, where <key-or-token> is your key or token value.

Podstawowa różnica między kluczami i tokenami polega na tym, że klucze są statyczne i mogą być ponownie generowane ręcznie, a tokeny muszą być odświeżane po wygaśnięciu.The primary difference between keys and tokens is that keys are static and can be regenerated manually, and tokens need to be refreshed upon expiration. Uwierzytelnianie oparte na kluczach jest obsługiwane dla wystąpień kontenerów platformy Azure i wdrożonych usług sieci Web usługi Azure Kubernetes, a uwierzytelnianie oparte na tokenach jest dostępne tylko dla wdrożeń usługi Azure Kubernetes.Key-based auth is supported for Azure Container Instance and Azure Kubernetes Service deployed web-services, and token-based auth is only available for Azure Kubernetes Service deployments. Aby uzyskać więcej informacji na temat konfigurowania uwierzytelniania, zobacz Konfigurowanie uwierzytelniania dla modeli wdrożonych jako usługi sieci Web.For more information on configuring authentication, see Configure authentication for models deployed as web services.

Uwierzytelnianie przy użyciu kluczyAuthentication with keys

Po włączeniu uwierzytelniania dla wdrożenia automatycznie tworzone są klucze uwierzytelniania.When you enable authentication for a deployment, you automatically create authentication keys.

  • Uwierzytelnianie jest domyślnie włączone podczas wdrażania w usłudze Azure Kubernetes Service.Authentication is enabled by default when you are deploying to Azure Kubernetes Service.
  • Podczas wdrażania programu w celu Azure Container Instances uwierzytelnianie jest domyślnie wyłączone.Authentication is disabled by default when you are deploying to Azure Container Instances.

Aby kontrolować uwierzytelnianie, użyj auth_enabled parametru podczas tworzenia lub aktualizowania wdrożenia.To control authentication, use the auth_enabled parameter when you are creating or updating a deployment.

Jeśli jest włączone uwierzytelnianie, można użyć metody, get_keys Aby pobrać podstawowy i pomocniczy klucz uwierzytelniania:If authentication is enabled, you can use the get_keys method to retrieve a primary and secondary authentication key:

primary, secondary = service.get_keys()
print(primary)

Ważne

Jeśli musisz ponownie wygenerować klucz, użyj service.regen_key .If you need to regenerate a key, use service.regen_key.

Uwierzytelnianie przy użyciu tokenówAuthentication with tokens

Po włączeniu uwierzytelniania tokenów dla usługi sieci Web użytkownik musi podać Azure Machine Learning token JWT do usługi sieci Web, aby uzyskać do niej dostęp.When you enable token authentication for a web service, a user must provide an Azure Machine Learning JWT token to the web service to access it.

  • Uwierzytelnianie tokenu jest domyślnie wyłączone podczas wdrażania w usłudze Azure Kubernetes Service.Token authentication is disabled by default when you are deploying to Azure Kubernetes Service.
  • Uwierzytelnianie tokenu nie jest obsługiwane w przypadku wdrażania do Azure Container Instances.Token authentication is not supported when you are deploying to Azure Container Instances.

Aby kontrolować uwierzytelnianie tokenu, użyj token_auth_enabled parametru podczas tworzenia lub aktualizowania wdrożenia.To control token authentication, use the token_auth_enabled parameter when you are creating or updating a deployment.

Jeśli jest włączone uwierzytelnianie tokenu, można użyć metody, get_token Aby pobrać token okaziciela i czas wygaśnięcia tokenów:If token authentication is enabled, you can use the get_token method to retrieve a bearer token and that tokens expiration time:

token, refresh_by = service.get_token()
print(token)

Jeśli masz interfejs wiersza polecenia platformy Azure i rozszerzenie uczenia maszynowego, możesz użyć następującego polecenia, aby uzyskać token:If you have the Azure CLI and the machine learning extension, you can use the following command to get a token:

az ml service get-access-token -n <service-name>

Ważne

Obecnie jedynym sposobem na pobranie tokenu jest użycie zestawu SDK Azure Machine Learning lub rozszerzenia Azure Machine Learning.Currently the only way to retrieve the token is by using the Azure Machine Learning SDK or the Azure CLI machine learning extension.

Po upływie czasu tokenu trzeba będzie zażądać nowego tokenu refresh_by .You will need to request a new token after the token's refresh_by time.

Dane żądaniaRequest data

Interfejs API REST oczekuje treści żądania jako dokumentu JSON o następującej strukturze:The REST API expects the body of the request to be a JSON document with the following structure:

{
    "data":
        [
            <model-specific-data-structure>
        ]
}

Ważne

Struktura danych musi być zgodna z oczekiwanym skryptem oceniania i modelem w usłudze.The structure of the data needs to match what the scoring script and model in the service expect. Skrypt oceniania może zmodyfikować dane przed przekazaniem ich do modelu.The scoring script might modify the data before passing it to the model.

Dane binarneBinary data

Aby uzyskać informacje na temat włączania obsługi danych binarnych w usłudze, zobacz dane binarne.For information on how to enable support for binary data in your service, see Binary data.

Porada

Włączenie obsługi danych binarnych odbywa się w pliku score.py używanym przez wdrożony model.Enabling support for binary data happens in the score.py file used by the deployed model. Z poziomu klienta Użyj funkcji HTTP języka programowania.From the client, use the HTTP functionality of your programming language. Na przykład poniższy fragment kodu wysyła zawartość pliku JPG do usługi sieci Web:For example, the following snippet sends the contents of a JPG file to a web service:

import requests
# Load image data
data = open('example.jpg', 'rb').read()
# Post raw data to scoring URI
res = request.post(url='<scoring-uri>', data=data, headers={'Content-Type': 'application/> octet-stream'})

Współużytkowanie zasobów między źródłami (CORS)Cross-origin resource sharing (CORS)

Aby uzyskać informacje na temat włączania obsługi mechanizmu CORS w usłudze, zobacz udostępnianie zasobów między źródłami.For information on enabling CORS support in your service, see Cross-origin resource sharing.

Wywoływanie usługi (C#)Call the service (C#)

W tym przykładzie pokazano, jak używać języka C# do wywoływania usługi sieci Web utworzonej na podstawie szkolenia w ramach przykładu notesu :This example demonstrates how to use C# to call the web service created from the Train within notebook example:

using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using Newtonsoft.Json;

namespace MLWebServiceClient
{
    // The data structure expected by the service
    internal class InputData
    {
        [JsonProperty("data")]
        // The service used by this example expects an array containing
        //   one or more arrays of doubles
        internal double[,] data;
    }
    class Program
    {
        static void Main(string[] args)
        {
            // Set the scoring URI and authentication key or token
            string scoringUri = "<your web service URI>";
            string authKey = "<your key or token>";

            // Set the data to be sent to the service.
            // In this case, we are sending two sets of data to be scored.
            InputData payload = new InputData();
            payload.data = new double[,] {
                {
                    0.0199132141783263,
                    0.0506801187398187,
                    0.104808689473925,
                    0.0700725447072635,
                    -0.0359677812752396,
                    -0.0266789028311707,
                    -0.0249926566315915,
                    -0.00259226199818282,
                    0.00371173823343597,
                    0.0403433716478807
                },
                {
                    -0.0127796318808497, 
                    -0.044641636506989, 
                    0.0606183944448076, 
                    0.0528581912385822, 
                    0.0479653430750293, 
                    0.0293746718291555, 
                    -0.0176293810234174, 
                    0.0343088588777263, 
                    0.0702112981933102, 
                    0.00720651632920303
                }
            };

            // Create the HTTP client
            HttpClient client = new HttpClient();
            // Set the auth header. Only needed if the web service requires authentication.
            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", authKey);

            // Make the request
            try {
                var request = new HttpRequestMessage(HttpMethod.Post, new Uri(scoringUri));
                request.Content = new StringContent(JsonConvert.SerializeObject(payload));
                request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
                var response = client.SendAsync(request).Result;
                // Display the response from the web service
                Console.WriteLine(response.Content.ReadAsStringAsync().Result);
            }
            catch (Exception e)
            {
                Console.Out.WriteLine(e.Message);
            }
        }
    }
}

Zwrócone wyniki są podobne do następującego dokumentu JSON:The results returned are similar to the following JSON document:

[217.67978776218715, 224.78937091757172]

Wywoływanie usługi (go)Call the service (Go)

W tym przykładzie pokazano, jak używać języka go do wywoływania usługi sieci Web utworzonej na podstawie szkolenia w ramach przykładu notesu :This example demonstrates how to use Go to call the web service created from the Train within notebook example:

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

// Features for this model are an array of decimal values
type Features []float64

// The web service input can accept multiple sets of values for scoring
type InputData struct {
    Data []Features `json:"data",omitempty`
}

// Define some example data
var exampleData = []Features{
    []float64{
        0.0199132141783263, 
        0.0506801187398187, 
        0.104808689473925, 
        0.0700725447072635, 
        -0.0359677812752396, 
        -0.0266789028311707, 
        -0.0249926566315915, 
        -0.00259226199818282, 
        0.00371173823343597, 
        0.0403433716478807,
    },
    []float64{
        -0.0127796318808497, 
        -0.044641636506989, 
        0.0606183944448076, 
        0.0528581912385822, 
        0.0479653430750293, 
        0.0293746718291555, 
        -0.0176293810234174, 
        0.0343088588777263, 
        0.0702112981933102, 
        0.00720651632920303,
    },
}

// Set to the URI for your service
var serviceUri string = "<your web service URI>"
// Set to the authentication key or token (if any) for your service
var authKey string = "<your key or token>"

func main() {
    // Create the input data from example data
    jsonData := InputData{
        Data: exampleData,
    }
    // Create JSON from it and create the body for the HTTP request
    jsonValue, _ := json.Marshal(jsonData)
    body := bytes.NewBuffer(jsonValue)

    // Create the HTTP request
    client := &http.Client{}
    request, err := http.NewRequest("POST", serviceUri, body)
    request.Header.Add("Content-Type", "application/json")

    // These next two are only needed if using an authentication key
    bearer := fmt.Sprintf("Bearer %v", authKey)
    request.Header.Add("Authorization", bearer)

    // Send the request to the web service
    resp, err := client.Do(request)
    if err != nil {
        fmt.Println("Failure: ", err)
    }

    // Display the response received
    respBody, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(respBody))
}

Zwrócone wyniki są podobne do następującego dokumentu JSON:The results returned are similar to the following JSON document:

[217.67978776218715, 224.78937091757172]

Wywoływanie usługi (Java)Call the service (Java)

W tym przykładzie pokazano, jak używać języka Java do wywoływania usługi sieci Web utworzonej na podstawie szkolenia w ramach przykładu notesu :This example demonstrates how to use Java to call the web service created from the Train within notebook example:

import java.io.IOException;
import org.apache.http.client.fluent.*;
import org.apache.http.entity.ContentType;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;

public class App {
    // Handle making the request
    public static void sendRequest(String data) {
        // Replace with the scoring_uri of your service
        String uri = "<your web service URI>";
        // If using authentication, replace with the auth key or token
        String key = "<your key or token>";
        try {
            // Create the request
            Content content = Request.Post(uri)
            .addHeader("Content-Type", "application/json")
            // Only needed if using authentication
            .addHeader("Authorization", "Bearer " + key)
            // Set the JSON data as the body
            .bodyString(data, ContentType.APPLICATION_JSON)
            // Make the request and display the response.
            .execute().returnContent();
            System.out.println(content);
        }
        catch (IOException e) {
            System.out.println(e);
        }
    }
    public static void main(String[] args) {
        // Create the data to send to the service
        JSONObject obj = new JSONObject();
        // In this case, it's an array of arrays
        JSONArray dataItems = new JSONArray();
        // Inner array has 10 elements
        JSONArray item1 = new JSONArray();
        item1.add(0.0199132141783263);
        item1.add(0.0506801187398187);
        item1.add(0.104808689473925);
        item1.add(0.0700725447072635);
        item1.add(-0.0359677812752396);
        item1.add(-0.0266789028311707);
        item1.add(-0.0249926566315915);
        item1.add(-0.00259226199818282);
        item1.add(0.00371173823343597);
        item1.add(0.0403433716478807);
        // Add the first set of data to be scored
        dataItems.add(item1);
        // Create and add the second set
        JSONArray item2 = new JSONArray();
        item2.add(-0.0127796318808497);
        item2.add(-0.044641636506989);
        item2.add(0.0606183944448076);
        item2.add(0.0528581912385822);
        item2.add(0.0479653430750293);
        item2.add(0.0293746718291555);
        item2.add(-0.0176293810234174);
        item2.add(0.0343088588777263);
        item2.add(0.0702112981933102);
        item2.add(0.00720651632920303);
        dataItems.add(item2);
        obj.put("data", dataItems);

        // Make the request using the JSON document string
        sendRequest(obj.toJSONString());
    }
}

Zwrócone wyniki są podobne do następującego dokumentu JSON:The results returned are similar to the following JSON document:

[217.67978776218715, 224.78937091757172]

Wywoływanie usługi (Python)Call the service (Python)

W tym przykładzie pokazano, jak używać języka Python do wywoływania usługi sieci Web utworzonej na podstawie szkolenia w ramach przykładu notesu :This example demonstrates how to use Python to call the web service created from the Train within notebook example:

import requests
import json

# URL for the web service
scoring_uri = '<your web service URI>'
# If the service is authenticated, set the key or token
key = '<your key or token>'

# Two sets of data to score, so we get two results back
data = {"data":
        [
            [
                0.0199132141783263,
                0.0506801187398187,
                0.104808689473925,
                0.0700725447072635,
                -0.0359677812752396,
                -0.0266789028311707,
                -0.0249926566315915,
                -0.00259226199818282,
                0.00371173823343597,
                0.0403433716478807
            ],
            [
                -0.0127796318808497,
                -0.044641636506989,
                0.0606183944448076,
                0.0528581912385822,
                0.0479653430750293,
                0.0293746718291555,
                -0.0176293810234174,
                0.0343088588777263,
                0.0702112981933102,
                0.00720651632920303]
        ]
        }
# Convert to JSON string
input_data = json.dumps(data)

# Set the content type
headers = {'Content-Type': 'application/json'}
# If authentication is enabled, set the authorization header
headers['Authorization'] = f'Bearer {key}'

# Make the request and display the response
resp = requests.post(scoring_uri, input_data, headers=headers)
print(resp.text)

Zwrócone wyniki są podobne do następującego dokumentu JSON:The results returned are similar to the following JSON document:

[217.67978776218715, 224.78937091757172]

Schemat usługi sieci Web (Specyfikacja OpenAPI)Web service schema (OpenAPI specification)

Jeśli używasz automatycznej generacji schematu w ramach wdrożenia, możesz uzyskać adres specyfikacji OpenAPI dla usługi przy użyciu właściwości swagger_uri.If you used automatic schema generation with your deployment, you can get the address of the OpenAPI specification for the service by using the swagger_uri property. (Na przykład print(service.swagger_uri) .) Użyj żądania GET lub Otwórz identyfikator URI w przeglądarce, aby pobrać specyfikację.(For example, print(service.swagger_uri).) Use a GET request or open the URI in a browser to retrieve the specification.

Poniższy dokument JSON jest przykładem schematu (Specyfikacja OpenAPI) wygenerowanego dla wdrożenia:The following JSON document is an example of a schema (OpenAPI specification) generated for a deployment:

{
    "swagger": "2.0",
    "info": {
        "title": "myservice",
        "description": "API specification for Azure Machine Learning myservice",
        "version": "1.0"
    },
    "schemes": [
        "https"
    ],
    "consumes": [
        "application/json"
    ],
    "produces": [
        "application/json"
    ],
    "securityDefinitions": {
        "Bearer": {
            "type": "apiKey",
            "name": "Authorization",
            "in": "header",
            "description": "For example: Bearer abc123"
        }
    },
    "paths": {
        "/": {
            "get": {
                "operationId": "ServiceHealthCheck",
                "description": "Simple health check endpoint to ensure the service is up at any given point.",
                "responses": {
                    "200": {
                        "description": "If service is up and running, this response will be returned with the content 'Healthy'",
                        "schema": {
                            "type": "string"
                        },
                        "examples": {
                            "application/json": "Healthy"
                        }
                    },
                    "default": {
                        "description": "The service failed to execute due to an error.",
                        "schema": {
                            "$ref": "#/definitions/ErrorResponse"
                        }
                    }
                }
            }
        },
        "/score": {
            "post": {
                "operationId": "RunMLService",
                "description": "Run web service's model and get the prediction output",
                "security": [
                    {
                        "Bearer": []
                    }
                ],
                "parameters": [
                    {
                        "name": "serviceInputPayload",
                        "in": "body",
                        "description": "The input payload for executing the real-time machine learning service.",
                        "schema": {
                            "$ref": "#/definitions/ServiceInput"
                        }
                    }
                ],
                "responses": {
                    "200": {
                        "description": "The service processed the input correctly and provided a result prediction, if applicable.",
                        "schema": {
                            "$ref": "#/definitions/ServiceOutput"
                        }
                    },
                    "default": {
                        "description": "The service failed to execute due to an error.",
                        "schema": {
                            "$ref": "#/definitions/ErrorResponse"
                        }
                    }
                }
            }
        }
    },
    "definitions": {
        "ServiceInput": {
            "type": "object",
            "properties": {
                "data": {
                    "type": "array",
                    "items": {
                        "type": "array",
                        "items": {
                            "type": "integer",
                            "format": "int64"
                        }
                    }
                }
            },
            "example": {
                "data": [
                    [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]
                ]
            }
        },
        "ServiceOutput": {
            "type": "array",
            "items": {
                "type": "number",
                "format": "double"
            },
            "example": [
                3726.995
            ]
        },
        "ErrorResponse": {
            "type": "object",
            "properties": {
                "status_code": {
                    "type": "integer",
                    "format": "int32"
                },
                "message": {
                    "type": "string"
                }
            }
        }
    }
}

Aby uzyskać więcej informacji, zobacz Specyfikacja openapi.For more information, see OpenAPI specification.

Aby uzyskać narzędzie, które może tworzyć biblioteki klienckie ze specyfikacją, zobacz Swagger-codegen.For a utility that can create client libraries from the specification, see swagger-codegen.

Porada

Po wdrożeniu usługi można pobrać dokument JSON schematu.You can retrieve the schema JSON document after you deploy the service. Użyj właściwości swagger_uri ze wdrożonej usługi sieci Web (na przykład service.swagger_uri ), aby uzyskać identyfikator URI do pliku struktury Swagger lokalnej usługi sieci Web.Use the swagger_uri property from the deployed web service (for example, service.swagger_uri) to get the URI to the local web service's Swagger file.

Korzystanie z usługi z Power BIConsume the service from Power BI

Power BI obsługuje użycie usług sieci Web Azure Machine Learning do wzbogacania danych w Power BI z przewidywaniami.Power BI supports consumption of Azure Machine Learning web services to enrich the data in Power BI with predictions.

Aby wygenerować usługę sieci Web obsługiwaną do użycia w Power BI, schemat musi obsługiwać format wymagany przez Power BI.To generate a web service that's supported for consumption in Power BI, the schema must support the format that's required by Power BI. Dowiedz się, jak utworzyć schemat obsługiwany przez Power BI.Learn how to create a Power BI-supported schema.

Po wdrożeniu usługi internetowej może być ona używana przez przepływy danych usługi Power BI.Once the web service is deployed, it's consumable from Power BI dataflows. Dowiedz się, jak korzystać z usługi internetowej Azure Machine Learning za pomocą usługi Power BI.Learn how to consume an Azure Machine Learning web service from Power BI.

Następne krokiNext steps

Aby wyświetlić architekturę referencyjną dla oceny w czasie rzeczywistym dla modeli Python i głębokiego uczenia, przejdź do centrum architektury platformy Azure.To view a reference architecture for real-time scoring of Python and deep learning models, go to the Azure architecture center.