Exempel: Skapa en anpassad färdighet med python (arkiverad)

Artikel
02/06/2023

Det här exemplet är arkiverat och stöds inte. Den förklarade hur du skapar en anpassad färdighet för webb-API:et med hjälp av Python och Visual Studio Code. Exemplet använde en Azure-funktion som implementerar det anpassade kompetensgränssnittet.

Förutsättningar

Granska det anpassade kompetensgränssnittet för att granska de indata och utdata som en anpassad färdighet ska implementera.
Konfigurera din miljö. Vi följde snabbstart: Skapa en funktion i Azure med Python med Visual Studio Code för att konfigurera serverlös Azure-funktion med hjälp av Visual Studio Code- och Python-tillägg. Snabbstarten leder dig genom installation av följande verktyg och komponenter:

Skapa en Azure-funktion

I det här exemplet används en Azure-funktion för att demonstrera begreppet värd för ett webb-API, men andra metoder är möjliga. Så länge du uppfyller gränssnittskraven för en kognitiv färdighet är den metod du använder oväsentlig. Azure Functions gör det dock enkelt att skapa en anpassad färdighet.

Skapa ett projekt för funktionen

Azure Functions-projektmallen i Visual Studio Code skapar ett lokalt projekt som kan publiceras till en funktionsapp i Azure. Med en funktionsapp kan du gruppera funktioner som en logisk enhet för hantering, distribution och delning av resurser.

I Visual Studio Code trycker du på F1 för att öppna kommandopaletten. I kommandopaletten söker du efter och väljer Azure Functions: Create new project....
Välj en katalogplats för projektarbetsytan och välj Välj. Använd inte en projektmapp som redan är en del av en annan arbetsyta.
Välj ett språk för funktionsappprojektet. I den här handledningen väljer du Python.
Välj Python-versionen (version 3.7.5 stöds av Azure Functions).
Välj en mall för projektets första funktion. Välj HTTP-utlösare för att skapa en funktion utlöses av HTTP i den nya funktionsappen.
Ange ett funktionsnamn. I det här fallet ska vi använda Concatenator
Välj Funktion som auktoriseringsnivå. Du använder en funktionsåtkomstnyckel för att anropa funktionens HTTP-slutpunkt.
Ange hur du vill öppna projektet. För det här steget väljer du Lägg till i arbetsytan för att skapa funktionsappen i den aktuella arbetsytan.

Visual Studio Code skapar funktionsappprojektet på en ny arbetsyta. Det här projektet innehåller filerna host.json och local.settings.jsonconfiguration, plus alla språkspecifika projektfiler.

En ny HTTP-utlöst funktion skapas också i mappen Concatenator i funktionsappsprojektet. I den finns en fil med namnet "__init__.py", med det här innehållet:

import logging

import azure.functions as func


def main(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')

    name = req.params.get('name')
    if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

    if name:
        return func.HttpResponse(f"Hello {name}!")
    else:
        return func.HttpResponse(
             "Please pass a name on the query string or in the request body",
             status_code=400
        )

Nu ska vi ändra koden så att den följer det anpassade färdighetsgränssnittet. Ersätt standardkoden med följande innehåll:

import logging
import azure.functions as func
import json

def main(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')

    try:
        body = json.dumps(req.get_json())
    except ValueError:
        return func.HttpResponse(
             "Invalid body",
             status_code=400
        )
    
    if body:
        result = compose_response(body)
        return func.HttpResponse(result, mimetype="application/json")
    else:
        return func.HttpResponse(
             "Invalid body",
             status_code=400
        )


def compose_response(json_data):
    values = json.loads(json_data)['values']
    
    # Prepare the Output before the loop
    results = {}
    results["values"] = []
    
    for value in values:
        output_record = transform_value(value)
        if output_record != None:
            results["values"].append(output_record)
    return json.dumps(results, ensure_ascii=False)

## Perform an operation on a record
def transform_value(value):
    try:
        recordId = value['recordId']
    except AssertionError  as error:
        return None

    # Validate the inputs
    try:         
        assert ('data' in value), "'data' field is required."
        data = value['data']        
        assert ('text1' in data), "'text1' field is required in 'data' object."
        assert ('text2' in data), "'text2' field is required in 'data' object."
    except AssertionError  as error:
        return (
            {
            "recordId": recordId,
            "errors": [ { "message": "Error:" + error.args[0] }   ]       
            })

    try:                
        concatenated_string = value['data']['text1'] + " " + value['data']['text2']  
        # Here you could do something more interesting with the inputs

    except:
        return (
            {
            "recordId": recordId,
            "errors": [ { "message": "Could not complete operation for record." }   ]       
            })

    return ({
            "recordId": recordId,
            "data": {
                "text": concatenated_string
                    }
            })

Metoden transform_value utför en åtgärd på en enda post. Du kan ändra metoden så att den uppfyller dina specifika behov. Kom ihåg att utföra nödvändig indataverifiering och att returnera eventuella fel och varningar om åtgärden inte kan slutföras.

Felsöka koden lokalt

Visual Studio Code gör det enkelt att felsöka koden. Tryck på F5 eller gå till menyn Felsökning och välj Starta felsökning.

Du kan ange brytpunkter i koden genom att trycka på "F9" på den rad du är intresserad av.

När du har börjat felsöka körs funktionen lokalt. Du kan använda ett verktyg som Postman eller Fiddler för att skicka begäran till localhost. Observera platsen för den lokala slutpunkten i terminalfönstret.

Skapa en funktionsapp i Azure

När du är nöjd med funktionsbeteendet kan du publicera det. Hittills har du jobbat lokalt. I det här avsnittet skapar du en funktionsapp i Azure och distribuerar sedan det lokala projektet till den app som du skapade.

Skapa appen från Visual Studio Code

I Visual Studio Code trycker du på F1 för att öppna kommandopaletten. I kommandopaletten söker du efter och väljer Skapa funktionsapp i Azure.
Om du har flera aktiva prenumerationer väljer du prenumerationen för den här appen.
Ange ett globalt unikt namn för funktionsappen. Ange ett namn som är giltigt för en URL.
Välj en körningsstack och välj den språkversion som du har kört lokalt på.
Välj en plats för din app. Om möjligt väljer du samma region som även är värd för söktjänsten.

Det tar några minuter att skapa appen. När den är klar visas den nya appen under Resurser och Funktionsapp för den aktiva prenumerationen.

Distribuera till Azure

Tryck på F1 i Visual Studio Code för att öppna kommandopaletten. I kommandopaletten söker du efter och väljer Distribuera till funktionsapplikation....
Välj den funktionsapp som du skapade.
Bekräfta att du vill fortsätta och välj sedan Deploy. Du kan övervaka distributionsstatusen i utdatafönstret.
Växla till Azure-portalen, navigera till Alla resurser. Sök efter funktionsappen som du distribuerade med det globalt unika namn som du angav i ett tidigare steg.

Tips

Du kan också högerklicka på funktionsappen i Visual Studio Code och välja Öppna i portalen.
I portalen till vänster väljer du Functionsoch väljer sedan den funktion som du skapade.
På funktionens översiktssida väljer du Hämta funktions-URL i kommandofältet längst upp. På så sätt kan du kopiera URL:en för att anropa funktionen.

Testa funktionen i Azure

Med hjälp av standardvärdnyckeln och URL:en som du kopierade testar du funktionen från Azure-portalen.

Till vänster under Utvecklare väljer du Code + Test.
Välj Test/Kör i kommandofältet.

För indata, använd Post, standardnyckeln, och klistra sedan in i begärandekroppen:

{
    "values": [
        {
            "recordId": "e1",
            "data":
            {
                "text1":  "Hello",
                "text2":  "World"
            }
        },
        {
            "recordId": "e2",
            "data": "This is an invalid input"
        }
    ]
}

Välj Kör.

Det här exemplet bör ge samma resultat som du såg tidigare när du körde funktionen i den lokala miljön.

Lägga till en kompetens

Nu när du har en ny anpassad färdighet kan du lägga till den i din kompetensuppsättning. Exemplet nedan visar hur du anropar färdigheten för att sammanfoga dokumentets rubrik och författare till ett enda fält, som vi anropar merged_title_author.

Ersätt [your-function-url-here] med URL:en för din nya Azure-funktion.

{
    "skills": [
      "[... other existing skills in the skillset are here]",  
      {
        "@odata.type": "#Microsoft.Skills.Custom.WebApiSkill",
        "description": "Our new search custom skill",
        "uri": "https://[your-function-url-here]",        
          "context": "/document/merged_content/organizations/*",
          "inputs": [
            {
              "name": "text1",
              "source": "/document/metadata_title"
            },
            {
              "name": "text2",
              "source": "/document/metadata_author"
            },
          ],
          "outputs": [
            {
              "name": "text",
              "targetName": "merged_title_author"
            }
          ]
      }
  ]
}

Kom ihåg att lägga till en "outputFieldMapping" i indexerarens definition för att skicka "merged_title_author" till ett "fullname"-fält i sökindexet.

"outputFieldMappings": [
    {
        "sourceFieldName": "/document/content/merged_title_author",
        "targetFieldName": "fullname"
    }
]

Dela via