Een Azure Machine Learning-model gebruiken dat als een webservice is geïmplementeerdConsume an Azure Machine Learning model deployed as a web service

Als u een Azure Machine Learning model implementeert als webservice, wordt een REST API-eind punt gemaakt.Deploying an Azure Machine Learning model as a web service creates a REST API endpoint. U kunt gegevens naar dit eind punt verzenden en de voor spelling ontvangen die door het model wordt geretourneerd.You can send data to this endpoint and receive the prediction returned by the model. In dit document leest u hoe u clients voor de webservice maakt met behulp van C#, go, Java en python.In this document, learn how to create clients for the web service by using C#, Go, Java, and Python.

U maakt een webservice wanneer u een model implementeert in uw lokale omgeving, Azure Container Instances, Azure Kubernetes-service of veld-Programmeer bare poort matrices (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 haalt de URI op die wordt gebruikt om toegang te krijgen tot de webservice met behulp van de Azure machine learning SDK.You retrieve the URI used to access the web service by using the Azure Machine Learning SDK. Als verificatie is ingeschakeld, kunt u ook de SDK gebruiken om de verificatie sleutels of-tokens op te halen.If authentication is enabled, you can also use the SDK to get the authentication keys or tokens.

De algemene werk stroom voor het maken van een client die gebruikmaakt van een machine learning-webservice:The general workflow for creating a client that uses a machine learning web service is:

  1. Gebruik de SDK om de verbindings gegevens op te halen.Use the SDK to get the connection information.
  2. Bepaal het type aanvraag gegevens dat door het model wordt gebruikt.Determine the type of request data used by the model.
  3. Maak een toepassing die de webservice aanroept.Create an application that calls the web service.

Tip

De voor beelden in dit document zijn hand matig gemaakt zonder de specificaties voor het gebruik van OpenAPI (Swagger).The examples in this document are manually created without the use of OpenAPI (Swagger) specifications. Als u een OpenAPI-specificatie hebt ingeschakeld voor uw implementatie, kunt u hulpprogram ma's zoals Swagger-CodeGen gebruiken om client bibliotheken voor uw service te maken.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.

VerbindingsgegevensConnection information

Notitie

Gebruik de Azure Machine Learning SDK om informatie over de webservice op te halen.Use the Azure Machine Learning SDK to get the web service information. Dit is een python-SDK.This is a Python SDK. U kunt elke taal gebruiken om een-client voor de service te maken.You can use any language to create a client for the service.

De klasse azureml. core. webservice bevat de informatie die u nodig hebt voor het maken van een-client.The azureml.core.Webservice class provides the information you need to create a client. De volgende Webservice eigenschappen zijn handig voor het maken van een client toepassing:The following Webservice properties are useful for creating a client application:

  • auth_enabled -Als de sleutel verificatie is ingeschakeld, True anders, False .auth_enabled - If key authentication is enabled, True; otherwise, False.
  • token_auth_enabled -Als token verificatie is ingeschakeld, True anders, False .token_auth_enabled - If token authentication is enabled, True; otherwise, False.
  • scoring_uri -Het REST API adres.scoring_uri - The REST API address.
  • swagger_uri -Het adres van de OpenAPI-specificatie.swagger_uri - The address of the OpenAPI specification. Deze URI is beschikbaar als u automatische schema generatie hebt ingeschakeld.This URI is available if you enabled automatic schema generation. Zie modellen implementeren met Azure machine learningvoor meer informatie.For more information, see Deploy models with Azure Machine Learning.

Er zijn drie manieren om deze informatie op te halen voor geïmplementeerde webservices:There are a three ways to retrieve this information for deployed web services:

  • Wanneer u een model implementeert, Webservice wordt er een object geretourneerd met informatie over de service: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)
    
  • U kunt gebruiken Webservice.list voor het ophalen van een lijst met geïmplementeerde webservices voor modellen in uw werk ruimte.You can use Webservice.list to retrieve a list of deployed web services for models in your workspace. U kunt filters toevoegen om de lijst met geretourneerde gegevens te beperken.You can add filters to narrow the list of information returned. Zie de naslag documentatie voor de webservice voor meer informatie over wat kan worden gefilterd.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)
    
  • Als u de naam van de geïmplementeerde service weet, kunt u een nieuwe instantie van maken Webservice en de werk ruimte en de service naam als para meters opgeven.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. Het nieuwe object bevat informatie over de geïmplementeerde service.The new object contains information about the deployed service.

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

Beveiligde webserviceSecured web service

Als u de geïmplementeerde webservice met een TLS/SSL-certificaat hebt beveiligd, kunt u https gebruiken om verbinding te maken met de service met behulp van de Score of SWAGGER-URI.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. Met HTTPS kunt u de communicatie tussen een client en een webservice beveiligen door de communicatie tussen de twee te versleutelen.HTTPS helps secure communications between a client and a web service by encrypting communications between the two. Versleuteling maakt gebruik van Transport Layer Security (TLS).Encryption uses Transport Layer Security (TLS). TLS wordt soms nog steeds aangeduid als Secure Sockets Layer (SSL). Dit is de voorafgaande taak van TLS.TLS is sometimes still referred to as Secure Sockets Layer (SSL), which was the predecessor of TLS.

Belangrijk

Webservices die door Azure Machine Learning worden geïmplementeerd, ondersteunen alleen TLS-versie 1,2.Web services deployed by Azure Machine Learning only support TLS version 1.2. Zorg ervoor dat deze versie wordt ondersteund bij het maken van een client toepassing.When creating a client application, make sure that it supports this version.

Zie TLS gebruiken om een webservice te beveiligen via Azure machine learningvoor meer informatie.For more information, see Use TLS to secure a web service through Azure Machine Learning.

Verificatie voor servicesAuthentication for services

Azure Machine Learning biedt twee manieren om de toegang tot uw webservices te beheren.Azure Machine Learning provides two ways to control access to your web services.

VerificatiemethodeAuthentication Method ACIACI AKSAKS
SleutelKey Standaard uitgeschakeldDisabled by default Standaard ingeschakeldEnabled by default
TokenToken Niet beschikbaarNot Available Standaard uitgeschakeldDisabled by default

Wanneer u een aanvraag verzendt naar een service die is beveiligd met een sleutel of token, gebruikt u de autorisatie -header om de sleutel of het token door te geven.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. De sleutel of het token moet zijn geformatteerd als Bearer <key-or-token> , waarbij <key-or-token> de sleutel of Token waarde is.The key or token must be formatted as Bearer <key-or-token>, where <key-or-token> is your key or token value.

Het belangrijkste verschil tussen sleutels en tokens is dat sleutels statisch zijn en hand matig opnieuw kunnen worden gegenereerden dat tokens na verloop van tijd moeten worden vernieuwd.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. Verificatie op basis van sleutels wordt ondersteund voor Azure container instance en Azure Kubernetes Service geïmplementeerde webservices en verificatie op basis van tokens is alleen beschikbaar voor Azure Kubernetes-service-implementaties.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. Zie verificatie voor meer informatie en specifieke code voorbeelden.See the how-to on authentication for more information and specific code samples.

Verificatie met sleutelsAuthentication with keys

Wanneer u verificatie voor een implementatie inschakelt, maakt u automatisch verificatie sleutels.When you enable authentication for a deployment, you automatically create authentication keys.

  • Verificatie is standaard ingeschakeld wanneer u naar de Azure Kubernetes-service implementeert.Authentication is enabled by default when you are deploying to Azure Kubernetes Service.
  • Verificatie is standaard uitgeschakeld wanneer u implementeert naar Azure Container Instances.Authentication is disabled by default when you are deploying to Azure Container Instances.

Als u de verificatie wilt beheren, gebruikt auth_enabled u de para meter bij het maken of bijwerken van een implementatie.To control authentication, use the auth_enabled parameter when you are creating or updating a deployment.

Als verificatie is ingeschakeld, kunt u de get_keys methode gebruiken om een primaire en secundaire verificatie sleutel op te halen: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)

Belangrijk

Als u een sleutel opnieuw moet genereren, gebruikt u service.regen_key .If you need to regenerate a key, use service.regen_key.

Verificatie met tokensAuthentication with tokens

Wanneer u token verificatie inschakelt voor een webservice, moet een gebruiker een Azure Machine Learning JWT-token voor de webservice opgeven om deze te openen.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 verificatie is standaard uitgeschakeld wanneer u implementeert in azure Kubernetes service.Token authentication is disabled by default when you are deploying to Azure Kubernetes Service.
  • Token authenticatie wordt niet ondersteund wanneer u implementeert naar Azure Container Instances.Token authentication is not supported when you are deploying to Azure Container Instances.

Als u de verificatie van tokens wilt beheren, gebruikt token_auth_enabled u de para meter bij het maken of bijwerken van een implementatie.To control token authentication, use the token_auth_enabled parameter when you are creating or updating a deployment.

Als token verificatie is ingeschakeld, kunt u de get_token methode gebruiken om een Bearer-token op te halen en de verval tijd van tokens: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)

Als u de Azure CLI en de uitbrei ding machine learninghebt, kunt u de volgende opdracht gebruiken om een token op te halen: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>

Belangrijk

Momenteel is de enige manier om het token op te halen met behulp van de Azure Machine Learning SDK of de Azure CLI machine learning-extensie.Currently the only way to retrieve the token is by using the Azure Machine Learning SDK or the Azure CLI machine learning extension.

U moet een nieuw token aanvragen na de tijd van de token refresh_by .You will need to request a new token after the token's refresh_by time.

Gegevens opvragenRequest data

De REST API verwacht dat de hoofd tekst van de aanvraag een JSON-document is met de volgende structuur:The REST API expects the body of the request to be a JSON document with the following structure:

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

Belangrijk

De structuur van de gegevens moet overeenkomen met het Score script en het model in de service.The structure of the data needs to match what the scoring script and model in the service expect. Het Score script kan de gegevens wijzigen voordat deze aan het model worden door gegeven.The scoring script might modify the data before passing it to the model.

Binaire gegevensBinary data

Zie binaire gegevensvoor meer informatie over het inschakelen van ondersteuning voor binaire gegevens in uw service.For information on how to enable support for binary data in your service, see Binary data.

Tip

Het inschakelen van ondersteuning voor binaire gegevens vindt plaats in het score.py-bestand dat wordt gebruikt door het geïmplementeerde model.Enabling support for binary data happens in the score.py file used by the deployed model. Gebruik van de client de HTTP-functionaliteit van uw programmeer taal.From the client, use the HTTP functionality of your programming language. Zo verzendt het volgende code fragment de inhoud van een JPG-bestand naar een webservice: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'})

Cross-Origin-resource delen (CORS)Cross-origin resource sharing (CORS)

Zie Cross-Origin-resource delenvoor meer informatie over het inschakelen van CORS-ondersteuning in uw service.For information on enabling CORS support in your service, see Cross-origin resource sharing.

De service (C#) aanroepenCall the service (C#)

In dit voor beeld ziet u hoe u C# kunt gebruiken om de webservice aan te roepen die vanuit de trein in het notebook -voor beeld is gemaakt: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 geretourneerde resultaten zijn vergelijkbaar met het volgende JSON-document:The results returned are similar to the following JSON document:

[217.67978776218715, 224.78937091757172]

De service aanroepen (Go)Call the service (Go)

In dit voor beeld ziet u hoe u kunt gebruiken om de webservice aan te roepen die is gemaakt vanuit de trein in het notebook -voor beeld: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 geretourneerde resultaten zijn vergelijkbaar met het volgende JSON-document:The results returned are similar to the following JSON document:

[217.67978776218715, 224.78937091757172]

De service aanroepen (Java)Call the service (Java)

Dit voor beeld laat zien hoe u Java gebruikt voor het aanroepen van de webservice die is gemaakt op basis van de trein in het notebook -voor beeld: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 geretourneerde resultaten zijn vergelijkbaar met het volgende JSON-document:The results returned are similar to the following JSON document:

[217.67978776218715, 224.78937091757172]

De service aanroepen (python)Call the service (Python)

In dit voor beeld wordt gedemonstreerd hoe u python gebruikt om de webservice aan te roepen die is gemaakt via de trein in een notebook -voor beeld: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 geretourneerde resultaten zijn vergelijkbaar met het volgende JSON-document:The results returned are similar to the following JSON document:

[217.67978776218715, 224.78937091757172]

Web Service-schema (OpenAPI-specificatie)Web service schema (OpenAPI specification)

Als u automatische schema generatie hebt gebruikt met uw implementatie, kunt u het adres van de OpenAPI-specificatie voor de service ophalen met behulp van de eigenschap 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. (Bijvoorbeeld print(service.swagger_uri) .) Gebruik een GET-aanvraag of open de URI in een browser om de specificatie op te halen.(For example, print(service.swagger_uri).) Use a GET request or open the URI in a browser to retrieve the specification.

Het volgende JSON-document is een voor beeld van een schema (OpenAPI-specificatie) dat is gegenereerd voor een implementatie: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"
                }
            }
        }
    }
}

Zie OpenAPI Specification(Engelstalig) voor meer informatie.For more information, see OpenAPI specification.

Zie Swagger-CodeGenvoor een hulp programma waarmee client bibliotheken kunnen worden gemaakt op basis van de specificatie.For a utility that can create client libraries from the specification, see swagger-codegen.

Tip

U kunt het schema-JSON-document ophalen nadat u de service hebt geïmplementeerd.You can retrieve the schema JSON document after you deploy the service. Gebruik de eigenschap swagger_uri van de geïmplementeerde webservice (bijvoorbeeld service.swagger_uri ) om de URI naar het Swagger-bestand van de lokale webservice op te halen.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.

De service gebruiken vanuit Power BIConsume the service from Power BI

Power BI ondersteunt het gebruik van Azure Machine Learning webservices om de gegevens in Power BI te verrijken met voor spellingen.Power BI supports consumption of Azure Machine Learning web services to enrich the data in Power BI with predictions.

Als u een webservice wilt genereren die wordt ondersteund voor gebruik in Power BI, moet het schema ondersteuning bieden voor de indeling die wordt vereist door 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. Meer informatie over het maken van een door Power bi ondersteund schema.Learn how to create a Power BI-supported schema.

Zodra de webservice is geïmplementeerd, kan deze worden verbruikt vanaf Power BI gegevens stromen.Once the web service is deployed, it's consumable from Power BI dataflows. Meer informatie over het gebruik van een Azure machine learning-webservice van Power bi.Learn how to consume an Azure Machine Learning web service from Power BI.

Volgende stappenNext steps

Ga naar het Azure Architecture Centerom een referentie architectuur voor realtime-scores van python-en diepe leer modellen te bekijken.To view a reference architecture for real-time scoring of Python and deep learning models, go to the Azure architecture center.