Övning – Skapa ett arbetsflöde med durable functions

16 minuter

I den här övningen använder du exempelscenariot från föregående lektion för att lära dig hur du skapar ett arbetsflöde för godkännande i Azure-portalen med durable functions.

Skapa en funktionsapp

Logga in på Azure-portalen med samma konto som du använde för att aktivera sandbox-miljön.
På menyn i Azure-portalen eller på sidan Start går du till Azure-tjänsteroch väljer Skapa en resurs. Fönstret Skapa en resurs visas.
Sök efter och välj Function App. Välj Förbrukningoch välj sedan knappen Välj. Fönstret Skapa funktionsapp visas.

På fliken Grundläggande anger du följande värden för varje inställning.

Inställning	Värde	Beskrivning
projektinformation
Abonnemang	Concierge-prenumeration	Anger prenumerationen under vilken den nya funktionsappen skapas.
Resursgrupp	I listrutan väljer du [resursgruppsnamn för sandbox-miljö]	Anger namnet på resursgruppen som du vill skapa funktionsappen i. Vi skapar funktionsappen i sandbox-resursgruppen som tilldelades när vi aktiverade sandbox-miljön, nämligen [resursgruppsnamn för sandbox-miljö].
instansinformation
Funktionsappens namn	[Globalt unikt namn]	Anger namnet som identifierar den nya funktionsappen. Giltiga tecken är `a-z`, `0-9`och `-`.
Publicera	Code	Anger att funktionen använder kod i stället för en container.
Körningsstack	Node.js	Anger att exempelkoden i den här modulen är skriven i JavaScript.
Version	20 LTS	Anger vilken version av körstacken som används.
Region	[Välj i listan som följer det här avsnittet]	Välj den region som är närmast dig och som också är en av de tillåtna sandbox-regioner som följer.
Operativsystem
Operativsystem	Windows	Anger det operativsystem som är värd för funktionsappen.
Plan

Med den kostnadsfria sandbox-miljön kan du skapa resurser i en delmängd av de globala Azure-regionerna. Välj en region i följande lista när du skapar resurser:

Västra USA 2
Sydcentrala USA
Centrala USA
Östra USA
Europa, västra

Sydostasien
Japan, östra
Södra Brasilien
Australien, sydöstra
Centrala Indien

Välj Nästa: Lagring.

På fliken Storage anger du följande värden för varje inställning.

Inställning	Värde	Beskrivning
Förvaring
Lagringskonto	[Globalt unikt namn]	Anger namnet på det nya lagringskontot som används av funktionsappen (som inte behöver matcha det globalt unika namn som du har angett för din funktion). Lagringskontonamn måste vara mellan 3 och 24 tecken långa och kan endast innehålla siffror och gemener. Den här dialogrutan fyller automatiskt i fältet med ett unikt namn som genereras dynamiskt. Du kan dock använda ett annat namn eller till och med ett befintligt konto.

Välj Nästa: Nätverk. Acceptera standardvärdena.
Välj Nästa: Övervakning.

På fliken Övervakning anger du följande värde för inställningen.

Inställning	Värde	Beskrivning
Application Insights
Aktivera Application Insights	Ingen	Anger att Application Insights är inaktiverat för den här modulen.

Välj Granska + skapa och granska de alternativ som du har konfigurerat. Om du är nöjd med dina alternativ väljer du Skapa för att etablera och distribuera funktionsappen.

Vänta tills distributionen har slutförts innan du fortsätter. Utrullningen kan ta några minuter.

Installera npm-paketet durable-functions

Eftersom vi skapar JavaScript Durable Functions måste vi installera durable-functions npm-paketet. Utför följande steg för att göra det.

Välj Gå till resurs för att välja funktionsappen. Ditt fönster för Funktionsapp visas.
I det vänstra menyfönstret går du till Utvecklingsverktygoch väljer App Service-redigeraren (förhandsversion)och väljer sedan Öppna redigeraren. Fönstret App Service Editor Snabbstart visas i ett nytt webbläsarfönster.
Markera mappen WWWROOT i det vänstra menyfönstret.
I den vänstra verktygsfältsmenyn väljer du ikonen Öppna konsolen.

Den här åtgärden startar konsolen. Du kan använda den här konsolen för att komma åt webbservern som är värd för dina funktioner och skriva koden för dina funktioner.
Skapa en ny package.json fil.
- Kör följande kommandon i konsolen för att skapa den nya JSON-filen och öppna den i redigeraren.
```
touch package.json
open package.json
```
- Lägg till följande kod.
```
{
  "name": "example",
  "version": "1.0.0"
}
```
  Ersätt example med namnet på paketet. Du kan till exempel använda det globalt unika namn som du angav för din funktion tidigare.
Välj Ctrl+S- för att spara filen och sedan Ctrl+Q för att stänga dokumentet.
Växla tillbaka till Azure-portalen.
I den vänstra menyraden under Utvecklingsverktygväljer du Console. Fönstret Console visas för funktionsappen.
Kör följande kommando:
```
npm install durable-functions
```
Det här kommandot instruerar nodpakethanteraren att installera durable-functions-paketet och eventuella nödvändiga beroenden. Installationen kan ta några minuter att slutföra och nodpakethanteraren kan visa några varningar som du kan ignorera.

Not

Om du uppmanas att installera en nyare version av npm använder du kommandot som angavs i felet för att installera den nyare versionen och installerar sedan durable-functions-paketet när den nya versionen har installerats.

Vänta tills alla paket har installerats.
I det vänstra menyfönstret rullar du uppåt och väljer Översikt, och i den översta menyraden väljer du Starta omoch väljer sedan Ja när du uppmanas att starta om.

Vänta tills omstarten har slutförts innan du fortsätter.

Skapa klientfunktionen för att skicka ett designförslag

På menyn i Azure-portalen eller på sidan Start under Senaste resurserväljer du Visa allaoch väljer sedan funktionsappen. Ditt fönster Funktionsapp visas.
På sidan Översikt väljer du fliken Functions i mitten av skärmen.
Välj knappen Skapa i Azure-portalen. Fönstret Skapa funktion visas.
Gå till Välj en mall, i rutan Filtrera anger du Durable Functions HTTP starter och väljer mallen i listan. Den här mallen skapar en varaktig funktion som körs som svar på en HTTP-begäran.
Under Mallinformationanger du HttpStart som namnet på funktionen i fältet Ny funktion och i fältet auktoriseringsnivå väljer du Funktionoch väljer sedan Skapa. Fönstret HttpStart visas för din funktion.

I det vänstra menyfönstret går du till Developeroch väljer Code + Test. Fönstret Code + Test visas för din funktion.

Koden för filen index.js visas i redigeraren. Filen bör likna följande exempel:

const df = require("durable-functions");

module.exports = async function (context, req) {
    const client = df.getClient(context);
    const instanceId = await client.startNew(req.params.functionName, undefined, req.body);

    context.log(`Started orchestration with ID = '${instanceId}'.`);

    return client.createCheckStatusResponse(context.bindingData.req, instanceId);
};

I listrutan för filerna i funktionen väljer du function.json för att visa bindningarna som är associerade med den nya funktionen. Den här informationen anger eventuella autentiseringskrav tillsammans med DE HTTP-metoder som kan utlösa funktionen. Den här filen anger också att funktionen är en klient som startar orkestreringsprocessen. Filen bör likna följande exempel:
```
{
  "bindings": [
    {
      "authLevel": "function",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "route": "orchestrators/{functionName}",
      "methods": [
        "post",
        "get"
      ]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "starter",
      "type": "orchestrationClient",
      "direction": "in"
    }
  ]
}
```
Notis

En bindning associerar resurser och andra objekt med en utlösare. Det är en deklarativ mekanism som tar bort behovet av hårdkodade referenser till andra tjänster och funktioner i koden.

Skapa orkestreringsfunktionen

På menyn i Azure-portalen eller på sidan Start, under Senaste resurser, välj Visa alla, och välj sedan din funktionsapp. Fönstret Funktionsapp visas.
På sidan Översikt väljer du fliken Functions i mitten av skärmen.
I menyraden Functions väljer du Skapa. Panelen Skapa funktion visas.
Under Välj en mall, i rutan Filter anger du Durable Functions-orkestrator och välj den mallen i listan. Den här mallen skapar en varaktig funktion som samordnar körningen av funktioner.
Under Mallinformationanger du OrchFunction som namnet på funktionen för fältet Ny funktion och väljer sedan Skapa. Funktionsfönstret OrchFunction visas.
I det vänstra menyfönstret går du till Developeroch väljer Code + Test. Fönstret Code + Test visas för din funktion.

Koden för filen index.js visas i redigeraren.
Ersätt den befintliga koden med följande kod.
```
const df = require("durable-functions");

module.exports = df.orchestrator(function* (context) {
    const outputs = [];

    /*
    * We will call the approval activity with a reject and an approved to simulate both
    */

    outputs.push(yield context.df.callActivity("Approval", "Approved"));
    outputs.push(yield context.df.callActivity("Approval", "Rejected"));

    return outputs;
});
```
Den här koden anropar en aktivitetsfunktion med namnet Approval, som du skapar inom kort. Koden i orchestrator-funktionen anropar funktionen Approval två gånger. Första gången simuleras godkännandet av förslaget och andra gången testas logiken för förslagsavvisning.

Värdet som varje anrop returnerar kombineras och skickas tillbaka till klientfunktionen. I en produktionsmiljö anropar orkestreringsfunktionen en serie aktivitetsfunktioner som fattar beslutet om att godkänna/avvisa och returnera resultatet av dessa aktiviteter.
I den översta menyraden väljer du Spara för att spara den nya funktionen.

Skapa aktivitetsfunktionen

På menyn i Azure-portalen eller på sidan Start, under Senaste resurser, väljer du Visa allaoch väljer sedan din funktionsapp. Fönstret Funktionsapp visas.
På sidan Översikt väljer du fliken Functions i mitten av skärmen.
I menyraden Functions väljer du Skapa. Panelen Skapa funktion visas.
I avsnittet Välj en mall, i fältet Filter anger du Durable Functions-aktivitet och välj den mallen från listan. Den här mallen skapar en varaktig funktion som körs när en aktivitet anropas av en orchestrator-funktion.
Under Mallinformationanger du Godkännande som namnet på funktionen för fältet Ny funktion och väljer sedan Skapa. Fönstret Godkännande visas för funktionsappen.
I det vänstra menyfönstret går du till Developeroch väljer Code + Test. Fönstret Code + Test visas för din funktion.

Koden för filen index.js visas i redigeraren.
Ersätt den befintliga koden med följande kod.
```
module.exports = async function (context) {
    return `Your project design proposal has been -  ${context.bindings.name}!`;
};
```
Den här funktionen returnerar ett meddelande som anger förslagets status. Uttrycket context.bindings.name är antingen Accepted eller Rejected, beroende på parametern som skickas till funktionen från orchestrator. I ett verkligt scenario lägger du till logiken som hanterar åtgärderna för att acceptera eller avvisa i den här funktionen.
I den översta menyraden väljer du Spara för att spara den nya funktionen.

Kontrollera att arbetsflödet för varaktiga funktioner startar

På menyn i Azure-portalen eller på sidan Start, under Senaste resurser, väljer du Visa alla, och väljer sedan din funktionsapp. Fönstret Funktionsapp visas.
Välj fliken Functions i mitten av sidan.
Välj funktionen HttpStart. Panelen HttpStart visas för din funktion.
I den översta menyraden väljer du Hämta funktions-URL och kopierar URL:en. Url:en bör likna följande exempel:
```
https://example.azurewebsites.net/api/orchestrators/{functionName}?code=AbCdEfGhIjKlMnOpQrStUvWxYz==
```
Du använder den här URL:en för att köra dina funktioner.

Öppna ett nytt webbläsarfönster och gå till den URL som du kopierade. I URL:en ersätter du platshållaren {functionName} med OrchFunction, vilket bör likna följande exempel:

https://example.azurewebsites.net/api/orchestrators/OrchFunction?code=AbCdEfGhIjKlMnOpQrStUvWxYz==

Svarsmeddelandet innehåller en uppsättning URI-slutpunkter som du kan använda för att övervaka och hantera körningen, vilket bör likna följande exempel:

{
  "id": "f0e1d2c3b4a5968778695a4b3c2d1e0f",
  "statusQueryGetUri": "https://example.azurewebsites.net/...",
  "sendEventPostUri": "https://example.azurewebsites.net/...",
  "terminatePostUri": "https://example.azurewebsites.net/...",
  "rewindPostUri": "https://example.azurewebsites.net/...",
  "purgeHistoryDeleteUri": "https://example.azurewebsites.net/..."
}

Kopiera värdet statusQueryGetUri och använd webbläsaren för att gå till den här URL:en. Du bör se ett svarsmeddelande som liknar följande exempel:
```
{
  "name": "OrchFunction",
  "instanceId": "f0e1d2c3b4a5968778695a4b3c2d1e0f",
  "runtimeStatus": "Completed",
  "input": null,
  "customStatus": null,
  "output": [
    "Your project design proposal has been -  Approved!",
    "Your project design proposal has been -  Rejected!"
  ],
  "createdTime": "2019-04-16T15:23:03Z",
  "lastUpdatedTime": "2019-04-16T15:23:35Z"
}
```
Kom ihåg att orkestreringsfunktionen kör aktivitetsfunktionen två gånger. Första gången anger aktivitetsfunktionen att projektförslaget godkänns. Andra gången avvisas förslaget. Orkestreringsfunktionen kombinerar meddelandena från båda funktionsanropen och returnerar dem till klientfunktionen.