Konsumera en Azure Machine Learning-modell som distribuerats som en webbtjänstConsume an Azure Machine Learning model deployed as a web service

gäller för:  Ja Basic Edition  Ja Enterprise Edition                               (Uppgradera till Enterprise Edition) APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

Om du distribuerar en Azure Machine Learning modell som en webb tjänst skapas en REST API-slutpunkt.Deploying an Azure Machine Learning model as a web service creates a REST API endpoint. Du kan skicka data till den här slut punkten och ta emot den förutsägelse som returneras av modellen.You can send data to this endpoint and receive the prediction returned by the model. I det här dokumentet får du lära dig hur du skapar klienter för webb tjänsten med hjälp av C#, go, Java och python.In this document, learn how to create clients for the web service by using C#, Go, Java, and Python.

Du skapar en webb tjänst när du distribuerar en modell till din lokala miljö, Azure Container Instances, Azure Kubernetes-tjänsten eller FPGA (Field-programmerbara grind mat ris).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). Du hämtar den URI som används för att få åtkomst till webb tjänsten med hjälp av Azure Machine Learning SDK.You retrieve the URI used to access the web service by using the Azure Machine Learning SDK. Om autentisering är aktive rad kan du också använda SDK: n för att hämta nycklar eller tokens för autentisering.If authentication is enabled, you can also use the SDK to get the authentication keys or tokens.

Det allmänna arbets flödet för att skapa en klient som använder en Machine Learning-webbtjänst är:The general workflow for creating a client that uses a machine learning web service is:

  1. Hämta anslutnings informationen med hjälp av SDK.Use the SDK to get the connection information.
  2. Bestäm vilken typ av begär ande data som används av modellen.Determine the type of request data used by the model.
  3. Skapa ett program som anropar webb tjänsten.Create an application that calls the web service.

Tips

Exemplen i det här dokumentet skapas manuellt utan användning av OpenAPI-specifikationer (Swagger).The examples in this document are manually created without the use of OpenAPI (Swagger) specifications. Om du har aktiverat en OpenAPI-specifikation för distributionen kan du använda verktyg som Swagger-CODEGEN för att skapa klient bibliotek för din tjänst.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.

Anslutnings informationConnection information

Anteckning

Använd Azure Machine Learning SDK för att hämta information om webb tjänsten.Use the Azure Machine Learning SDK to get the web service information. Det här är en python SDK.This is a Python SDK. Du kan använda valfritt språk för att skapa en klient för tjänsten.You can use any language to create a client for the service.

Azureml. Core. WebService- klassen innehåller den information du behöver för att skapa en-klient.The azureml.core.Webservice class provides the information you need to create a client. Följande Webservice egenskaper är användbara när du skapar ett klient program:The following Webservice properties are useful for creating a client application:

  • auth_enabled– Om Key Authentication har Aktiver ATS, True annars, False .auth_enabled - If key authentication is enabled, True; otherwise, False.
  • token_auth_enabled– Om token-autentisering är aktiverat, True annars, False .token_auth_enabled - If token authentication is enabled, True; otherwise, False.
  • scoring_uri– REST API-adressen.scoring_uri - The REST API address.
  • swagger_uri– Adressen till OpenAPI-specifikationen.swagger_uri - The address of the OpenAPI specification. Denna URI är tillgänglig om du har aktiverat automatiskt skapande av schema.This URI is available if you enabled automatic schema generation. Mer information finns i Distribuera modeller med Azure Machine Learning.For more information, see Deploy models with Azure Machine Learning.

Det finns tre sätt att hämta den här informationen för distribuerade webb tjänster:There are a three ways to retrieve this information for deployed web services:

  • När du distribuerar en modell returneras ett Webservice objekt med information om tjänsten: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)
    
  • Du kan använda Webservice.list för att hämta en lista över distribuerade webb tjänster för modeller i din arbets yta.You can use Webservice.list to retrieve a list of deployed web services for models in your workspace. Du kan lägga till filter för att begränsa listan med information som returneras.You can add filters to narrow the list of information returned. Mer information om vad som kan filtreras finns i referens dokumentationen för 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)
    
  • Om du känner till namnet på den distribuerade tjänsten kan du skapa en ny instans av Webservice och ange arbets ytan och tjänstens namn som parametrar.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. Det nya objektet innehåller information om den distribuerade tjänsten.The new object contains information about the deployed service.

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

Skyddad webb tjänstSecured web service

Om du har skyddat den distribuerade webb tjänsten med ett TLS/SSL-certifikat kan du använda https för att ansluta till tjänsten med hjälp av bedömnings-eller Swagger-URI: n.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. HTTPS skyddar kommunikationen mellan en klient och en webb tjänst genom att kryptera kommunikationen mellan de två.HTTPS helps secure communications between a client and a web service by encrypting communications between the two. Kryptering använder Transport Layer Security (TLS).Encryption uses Transport Layer Security (TLS). TLS kallas ibland även Secure Sockets Layer (SSL), som var den föregående aktiviteten TLS.TLS is sometimes still referred to as Secure Sockets Layer (SSL), which was the predecessor of TLS.

Viktigt

Webb tjänster som distribueras av Azure Machine Learning endast stöd för TLS version 1,2.Web services deployed by Azure Machine Learning only support TLS version 1.2. När du skapar ett klient program måste du kontrol lera att den har stöd för den här versionen.When creating a client application, make sure that it supports this version.

Mer information finns i använda TLS för att skydda en webb tjänst via Azure Machine Learning.For more information, see Use TLS to secure a web service through Azure Machine Learning.

Autentisering för tjänsterAuthentication for services

Azure Machine Learning ger dig möjlighet att styra åtkomsten till dina webb tjänster på två sätt.Azure Machine Learning provides two ways to control access to your web services.

AutentiseringsmetodAuthentication Method ACIACI AKSAKS
NyckelKey Inaktiverat som standardDisabled by default Aktiverat som standardEnabled by default
TokenToken Inte tillgängligtNot Available Inaktiverat som standardDisabled by default

När du skickar en begäran till en tjänst som skyddas med en nyckel eller token ska du använda Authorization -huvudet för att skicka nyckeln eller token.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. Nyckeln eller token måste formateras som Bearer <key-or-token> , där <key-or-token> är nyckel-eller token-värdet.The key or token must be formatted as Bearer <key-or-token>, where <key-or-token> is your key or token value.

Den primära skillnaden mellan nycklar och tokens är att nycklarna är statiska och kan återskapas manuellt, och tokens måste uppdateras när de upphör att gälla.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. Nyckelbaserad autentisering stöds för Azure Container instance och Azure Kubernetes-tjänsten distribuerade webb tjänster, och tokenbaserad autentisering är bara tillgängligt för Azure Kubernetes service-distributioner.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. Mer information och vissa kod exempel finns i avsnittet om att autentisera.See the how-to on authentication for more information and specific code samples.

Autentisering med nycklarAuthentication with keys

När du aktiverar autentisering för en distribution skapar du automatiskt nycklar för autentisering.When you enable authentication for a deployment, you automatically create authentication keys.

  • Autentisering aktive ras som standard när du distribuerar till Azure Kubernetes-tjänsten.Authentication is enabled by default when you are deploying to Azure Kubernetes Service.
  • Autentisering inaktive ras som standard när du distribuerar till Azure Container Instances.Authentication is disabled by default when you are deploying to Azure Container Instances.

Om du vill kontrol lera autentiseringen använder auth_enabled du parametern när du skapar eller uppdaterar en distribution.To control authentication, use the auth_enabled parameter when you are creating or updating a deployment.

Om autentisering är aktive rad kan du använda get_keys metoden för att hämta en primär och sekundär autentiseringsnyckel: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)

Viktigt

Om du behöver återskapa en nyckel använder du service.regen_key .If you need to regenerate a key, use service.regen_key.

Autentisering med tokenAuthentication with tokens

När du aktiverar token-autentisering för en webb tjänst måste en användare ange en Azure Machine Learning JWT-token för webb tjänsten för att få åtkomst till den.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.

  • Token-autentisering inaktive ras som standard när du distribuerar till Azure Kubernetes-tjänsten.Token authentication is disabled by default when you are deploying to Azure Kubernetes Service.
  • Token-autentisering stöds inte när du distribuerar till Azure Container Instances.Token authentication is not supported when you are deploying to Azure Container Instances.

Om du vill kontrol lera token-autentisering använder token_auth_enabled du parametern när du skapar eller uppdaterar en distribution.To control token authentication, use the token_auth_enabled parameter when you are creating or updating a deployment.

Om token-autentisering har Aktiver ATS kan du använda get_token metoden för att hämta en Bearer-token och förfallo tiden för token: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)

Om du har Azure CLI och Machine Learning-tilläggetkan du använda följande kommando för att hämta en 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>

Viktigt

För närvarande är det enda sättet att hämta token genom att använda Azure Machine Learning SDK eller Azure CLI Machine Learning-tillägget.Currently the only way to retrieve the token is by using the Azure Machine Learning SDK or the Azure CLI machine learning extension.

Du måste begära en ny token efter det att token har refresh_by uppnåtts.You will need to request a new token after the token's refresh_by time.

Begär dataRequest data

I REST API förväntas bröd texten i begäran vara ett JSON-dokument med följande struktur:The REST API expects the body of the request to be a JSON document with the following structure:

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

Viktigt

Data strukturen måste matcha vad bedömnings skriptet och modellen i tjänsten förväntar sig.The structure of the data needs to match what the scoring script and model in the service expect. Bedömnings skriptet kan ändra data innan de skickas till modellen.The scoring script might modify the data before passing it to the model.

Modellen i exemplet träna i Notebook förväntar sig till exempel en matris med 10 siffror.For example, the model in the Train within notebook example expects an array of 10 numbers. Bedömnings skriptet för det här exemplet skapar en numpy-matris från begäran och skickar den till modellen.The scoring script for this example creates a Numpy array from the request, and passes it to the model. I följande exempel visas de data som tjänsten förväntar sig:The following example shows the data this service expects:

{
    "data": 
        [
            [
                0.0199132141783263, 
                0.0506801187398187, 
                0.104808689473925, 
                0.0700725447072635, 
                -0.0359677812752396, 
                -0.0266789028311707, 
                -0.0249926566315915, 
                -0.00259226199818282, 
                0.00371173823343597, 
                0.0403433716478807
            ]
        ]
}

Webb tjänsten kan acceptera flera uppsättningar data i en begäran.The web service can accept multiple sets of data in one request. Den returnerar ett JSON-dokument som innehåller en matris med svar.It returns a JSON document containing an array of responses.

Binära dataBinary data

Information om hur du aktiverar stöd för binära data i tjänsten finns i binära data.For information on how to enable support for binary data in your service, see Binary data.

Tips

Aktivering av stöd för binära data sker i den score.py-fil som används av den distribuerade modellen.Enabling support for binary data happens in the score.py file used by the deployed model. Använd HTTP-funktionerna i ditt programmeringsspråk från klienten.From the client, use the HTTP functionality of your programming language. Följande fragment skickar till exempel innehållet i en JPG-fil till en webb tjänst: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'})

Resurs delning mellan ursprung (CORS)Cross-origin resource sharing (CORS)

Information om hur du aktiverar CORS-stöd i tjänsten finns i resurs delning mellan ursprung.For information on enabling CORS support in your service, see Cross-origin resource sharing.

Anropa tjänsten (C#)Call the service (C#)

Det här exemplet visar hur du använder C# för att anropa webb tjänsten som skapats från träna i Notebook -exempel: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);
            }
        }
    }
}

De resultat som returneras liknar följande JSON-dokument:The results returned are similar to the following JSON document:

[217.67978776218715, 224.78937091757172]

Anropa tjänsten (go)Call the service (Go)

Det här exemplet visar hur du använder Go för att anropa webb tjänsten som skapats från tåget i Notebook -exemplet: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))
}

De resultat som returneras liknar följande JSON-dokument:The results returned are similar to the following JSON document:

[217.67978776218715, 224.78937091757172]

Anropa tjänsten (Java)Call the service (Java)

Det här exemplet visar hur du använder Java för att anropa webb tjänsten som skapats från tåget i Notebook -exemplet: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());
    }
}

De resultat som returneras liknar följande JSON-dokument:The results returned are similar to the following JSON document:

[217.67978776218715, 224.78937091757172]

Anropa tjänsten (python)Call the service (Python)

Det här exemplet visar hur du använder python för att anropa webb tjänsten som skapats från tåget i Notebook -exemplet: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)

De resultat som returneras liknar följande JSON-dokument:The results returned are similar to the following JSON document:

[217.67978776218715, 224.78937091757172]

Webb tjänst schema (OpenAPI-specifikation)Web service schema (OpenAPI specification)

Om du har använt automatisk schema generering med din distribution kan du hämta adressen till OpenAPI-specifikationen för tjänsten med hjälp av egenskapen 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. (Till exempel print(service.swagger_uri) .) Använd en GET-begäran eller öppna URI: n i en webbläsare för att hämta specifikationen.(For example, print(service.swagger_uri).) Use a GET request or open the URI in a browser to retrieve the specification.

Följande JSON-dokument är ett exempel på ett schema (OpenAPI-specifikation) som genereras för en distribution: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"
                }
            }
        }
    }
}

Mer information finns i openapi-specifikation.For more information, see OpenAPI specification.

Ett verktyg som kan skapa klient bibliotek från specifikationen finns i Swagger-CODEGEN.For a utility that can create client libraries from the specification, see swagger-codegen.

Tips

Du kan hämta schema-JSON-dokumentet när du har distribuerat tjänsten.You can retrieve the schema JSON document after you deploy the service. Använd egenskapen swagger_uri från den distribuerade webb tjänsten (till exempel service.swagger_uri ) för att hämta URI: n till den lokala webb tjänstens Swagger-fil.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.

Använda tjänsten från Power BIConsume the service from Power BI

Power BI stöder användning av Azure Machine Learning webb tjänster för att utöka data i Power BI med förutsägelser.Power BI supports consumption of Azure Machine Learning web services to enrich the data in Power BI with predictions.

Om du vill generera en webb tjänst som stöds för användning i Power BI måste schemat ha stöd för det format som krävs av 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. Lär dig hur du skapar ett schema som stöds av Power BI.Learn how to create a Power BI-supported schema.

När webb tjänsten har distribuerats kan den förbrukas från Power BI data flöden.Once the web service is deployed, it's consumable from Power BI dataflows. Lär dig hur du använder en Azure Machine Learning-webb tjänst från Power BI.Learn how to consume an Azure Machine Learning web service from Power BI.

Nästa stegNext steps

Om du vill visa en referens arkitektur för real tids poängsättning av python-och djup inlärnings modeller går du till Azure Architecture Center.To view a reference architecture for real-time scoring of Python and deep learning models, go to the Azure architecture center.