Esercizio: creare un flusso di lavoro tramite Durable Functions

16 minuti

In questo esercizio si usa lo scenario di esempio dell'unità precedente per imparare a creare un flusso di lavoro di approvazione nel portale di Azure tramite Durable Functions.

Creare un'app per le funzioni

Accedere al portale di Azure con lo stesso account usato per attivare la sandbox.
Nel menu del portale di Azure o nella home page, in Servizi di Azure, selezionare Crea una risorsa. Viene visualizzato il riquadro Crea una risorsa.
Cercare e selezionare App per le funzioni. Selezionare A consumo, quindi selezionare il pulsante Seleziona. Viene visualizzato il riquadro Crea app per le funzioni.

Nella scheda Informazioni di base immettere i valori indicati di seguito per ogni impostazione.

Impostazione	valore	Descrizione
Dettagli del progetto
Subscription	Concierge Subscription	Specifica la sottoscrizione in cui viene creata questa nuova app per le funzioni.
Gruppo di risorse	Nell'elenco a discesa selezionare [nome gruppo di risorse sandbox]	Specifica il nome del gruppo di risorse in cui creare l'app per le funzioni. Si crea l'app per le funzioni nel gruppo di risorse sandbox assegnato quando è stata attivata la sandbox, vale a dire [nome gruppo di risorse sandbox].
Dettagli dell'istanza
Nome dell'app per le funzioni	[Nome univoco a livello globale]	Specifica il nome che identifica la nuova app per le funzioni. I caratteri validi sono `a-z`, `0-9` e `-`.
Pubblica	Codice	Specifica che la funzione usa il codice anziché un contenitore.
Stack di runtime	Node.JS	Specifica che il codice di esempio in questo modulo è scritto in JavaScript.
Versione	20 LTS	Specifica la versione dello stack di runtime.
Area	[Selezionare dall'elenco seguente questa sezione]	Scegliere l'area più vicina all'utente che sia anche tra quelle consentite nelle Aree sandbox seguenti.
Sistema operativo
Sistema operativo	Windows	Specifica il sistema operativo che ospita l'app per le funzioni.
Piano

La sandbox gratuita consente di creare risorse in un subset delle aree globali di Azure. Selezionare un'area nell'elenco seguente durante la creazione delle risorse:

Stati Uniti occidentali 2
Stati Uniti centro-meridionali
Stati Uniti centrali
Stati Uniti orientali
Europa occidentale

Asia sud-orientale
Giappone orientale
Brasile meridionale
Australia sud-orientale
India centrale

Selezionare Avanti: Archiviazione.

Nella scheda Archiviazione immettere i valori seguenti per ogni impostazione.

Impostazione	valore	Descrizione
Storage
Account di archiviazione	[Nome univoco a livello globale]	Specifica il nome del nuovo account di archiviazione usato dall'app per le funzioni (che non deve corrispondere al nome univoco globale specificato per la funzione). I nomi degli account di archiviazione devono avere una lunghezza compresa tra 3 e 24 caratteri e possono contenere solo numeri e lettere minuscole. Questa finestra di dialogo compila automaticamente il campo con un nome univoco generato dinamicamente. È comunque possibile usare un nome diverso o anche un account esistente.

Selezionare Avanti: Rete. Accettare i valori predefiniti.
Selezionare Avanti: Monitoraggio.
Nella scheda Monitoraggio immettere il valore indicato di seguito per l'impostazione.

Impostazione valore Descrizione

Application Insights

Abilita Application Insights No Specifica che Application Insights viene disabilitato per questo modulo.
Selezionare Rivedi e crea e rivedere le opzioni configurate. Se si è soddisfatti, selezionare Crea per effettuare il provisioning dell'app per le funzioni e distribuirla.

Impostazione	valore	Descrizione
Application Insights
Abilita Application Insights	No	Specifica che Application Insights viene disabilitato per questo modulo.

Attendere il completamento della distribuzione prima di continuare. La distribuzione potrebbe richiedere alcuni minuti.

Installare il pacchetto npm di Durable Functions

Poiché si stanno creando funzioni di Durable Functions in JavaScript, è necessario installare il pacchetto npm durable-functions. A tale scopo, eseguire i passaggi seguenti.

Selezionare Vai alla risorsa per selezionare l'app per le funzioni. Viene visualizzato il riquadro App per le funzioni.
Nel riquadro dei menu a sinistra, in Strumenti di sviluppo, selezionare Editor del servizio app (anteprima), quindi selezionare Apri Editor. Il riquadro Avvio rapido dell'editor del servizio app viene visualizzato in una nuova finestra del browser.
Nel riquadro dei menu a sinistra evidenziare la cartella WWWROOT.
Nel menu della barra degli strumenti a sinistra selezionare l'icona Apri console.

Viene avviata la console. Puoi usare questa console per accedere al server Web che ospita le funzioni e scrivere il codice per le funzioni.
Creare un nuovo file package.json.
- Immettere i comandi seguenti nella console per creare il nuovo file JSON e aprirlo nell'editor.
```
touch package.json
open package.json
```
- Aggiungi il seguente codice.
```
{
  "name": "example",
  "version": "1.0.0"
}
```
  Sostituire example con il nome del pacchetto. Ad esempio, è possibile usare il nome univoco globale specificato per la funzione in precedenza.
Selezionare CTRL+S per salvare il file, quindi CTRL+Q per chiudere il documento.
Tornare al portale di Azure.
Nella barra dei menu a sinistra, in Strumenti di sviluppo selezionare Console. Verrà visualizzato il riquadro Console relativo all'app per le funzioni.
Esegui questo comando:
```
npm install durable-functions
```
Questo comando indica a npm (Node Package Manager) di installare il pacchetto durable-functions e tutte le dipendenze necessarie. L’installazione può richiedere alcuni minuti e la gestione pacchetti del nodo potrebbe visualizzare alcuni avvisi, che è possibile ignorare.

Nota

Se viene richiesto di installare una versione più recente di npm, usa il comando specificato nell'errore per installare la versione più recente, quindi installa il pacchetto durable-functions dopo l'installazione della nuova versione.

Attendere che l'installazione di tutti i pacchetti sia terminata.
Nel riquadro dei menu a sinistra scorrere verso l'alto e selezionare Panoramica, nella barra dei menu in alto selezionare Riavvia e quindi selezionare Sì alla richiesta di riavvio.

Attendere il completamento del processo di riavvio prima di continuare.

Creare la funzione client per l'invio di una proposta di progetto

Nel menu del portale di Azure o nella Pagina iniziale, in Risorse recenti selezionare Visualizza tutto e quindi selezionare l'app per le funzioni. Viene visualizzato il riquadro App per le funzioni.
Nella pagina Panoramica selezionare la scheda Funzioni al centro della schermata.
Selezionare il pulsante Crea nel portale di Azure. Viene visualizzato il riquadro Crea funzione.
In Seleziona un modello, nella casella Filtro, immetti Durable Functions Http Starter e seleziona il modello dall'elenco. Questo modello crea una funzione di Durable Functions eseguita in risposta a una richiesta HTTP.
In Dettagli modello, nel campo Nuova funzione, immetti HttpStart come nome della funzione e nel campo Livello di autorizzazione, seleziona Funzione, quindi seleziona Crea. Viene visualizzato il riquadro HttpStart per la funzione.

Nel riquadro del menu a sinistra, in Developer selezionare Codice + Test. Viene visualizzato il riquadro Codice e test per la funzione.

Nell'editor compare il codice del file index.js. Il file dovrebbe essere simile all'esempio seguente:

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);
};

Nel menu a discesa per i file nella funzione selezionare function.json per visualizzare i binding associati alla nuova funzione. Queste informazioni consentono di specificare eventuali requisiti di autenticazione, nonché i metodi HTTP che possono attivare la funzione. Questo file specifica anche che la funzione è un client che avvia il processo di orchestrazione. Il file dovrebbe essere simile all'esempio seguente:
```
{
  "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"
    }
  ]
}
```
Nota

Un binding associa le risorse e altri elementi a un trigger. È un meccanismo dichiarativo che elimina la necessità di impostare come hardcoded i riferimenti ad altri servizi e funzioni nel codice.

Creare la funzione di orchestrazione

Nel menu del portale di Azure o nella Pagina iniziale, in Risorse recenti selezionare Visualizza tutto e quindi selezionare l'app per le funzioni. Viene visualizzato il riquadro App per le funzioni.
Nella pagina Panoramica selezionare la scheda Funzioni al centro della schermata.
Sulla barra dei menu Funzioni selezionare Crea. Viene visualizzato il riquadro Crea funzione.
In Seleziona un modello, nella casella Filtro, immetti Durable Functions Orchestrator e seleziona tale modello dall'elenco. Questo modello crea una funzione Durable Functions che orchestra l'esecuzione delle funzioni.
In Dettagli modello, nel campo Nuova funzione, immetti OrchFunction come nome della funzione, quindi seleziona Crea. Viene visualizzato il riquadro della funzione OrchFunction.
Nel riquadro del menu a sinistra, in Developer selezionare Codice + Test. Viene visualizzato il riquadro Codice e test per la funzione.

Nell'editor compare il codice del file index.js.
Sostituire il codice esistente con quello seguente.
```
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;
});
```
Questo codice chiama una funzione di attività denominata Approvazione, che verrà creata a breve. Il codice nella funzione di orchestrazione richiama la funzione Approval due volte. La prima volta simula l'accettazione della proposta e la seconda volta testa la logica di rifiuto della proposta.

Il valore restituito da ogni chiamata viene combinato e passato di nuovo alla funzione client. In un ambiente di produzione, la funzione di orchestrazione potrebbe chiamare una serie di funzioni di attività che prendono la decisione di accettazione/rifiuto e restituiscono il risultato di tali attività.
Nella barra dei menu in alto selezionare Salva per salvare le modifiche.

Creare la funzione di attività

Nel menu del portale di Azure o nella Pagina iniziale, in Risorse recenti selezionare Visualizza tutto e quindi selezionare l'app per le funzioni. Viene visualizzato il riquadro App per le funzioni.
Nella pagina Panoramica selezionare la scheda Funzioni al centro della schermata.
Sulla barra dei menu Funzioni selezionare Crea. Viene visualizzato il riquadro Crea funzione.
In Seleziona un modello, nella casella Filtro, immetti Durable Functions Activity e seleziona il modello dall'elenco. Questo modello crea una funzione di Durable Functions che viene eseguita quando un'attività viene chiamata da una funzione dell'agente di orchestrazione.
In Dettagli modello, nel campo Nuova funzione, immetti Approval come nome della funzione, quindi seleziona Crea. Verrà visualizzato il riquadro Approval relativo all'app per le funzioni.
Nel riquadro del menu a sinistra, in Developer selezionare Codice + Test. Viene visualizzato il riquadro Codice e test per la funzione.

Nell'editor compare il codice del file index.js.
Sostituire il codice esistente con quello seguente.
```
module.exports = async function (context) {
    return `Your project design proposal has been -  ${context.bindings.name}!`;
};
```
Questa funzione restituisce un messaggio che indica lo stato della proposta. L'espressione context.bindings.name è Accepted o Rejected, a seconda del parametro passato alla funzione dall'agente di orchestrazione. In uno scenario reale sarebbe necessario aggiungere la logica che gestisce le operazioni di accettazione o rifiuto in questa funzione.
Nella barra dei menu in alto selezionare Salva per salvare le modifiche.

Verificare che il flusso di lavoro di Durable Functions venga avviato

Nel menu del portale di Azure o nella Pagina iniziale, in Risorse recenti selezionare Visualizza tutto e quindi selezionare l'app per le funzioni. Viene visualizzato il riquadro App per le funzioni.
Selezionare la scheda Funzioni al centro della pagina.
Selezionare la funzione HttpStart. Viene visualizzato il riquadro HttpStart per la funzione.
Nella barra dei menu in alto, seleziona Recupera URL della funzione e copia l'URL. L'URL dovrebbe essere simile all'esempio seguente:
```
https://example.azurewebsites.net/api/orchestrators/{functionName}?code=AbCdEfGhIjKlMnOpQrStUvWxYz==
```
Questo URL viene usato per eseguire le funzioni.

Aprire una nuova finestra del browser e passare all'URL copiato. Nell'URL sostituire il segnaposto {functionName} con OrchFunction, che dovrebbe essere simile all'esempio seguente:

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

Il messaggio di risposta contiene un set di endpoint URI che è possibile usare per monitorare e gestire l'esecuzione e dovrebbe avere un aspetto simile al seguente:

{
  "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/..."
}

Copiare il valore statusQueryGetUri e usare il Web browser per passare a questo URL. Dovrebbe essere visualizzato un messaggio di risposta simile all'esempio seguente:
```
{
  "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"
}
```
È importante ricordare che la funzione di orchestrazione esegue la funzione di attività due volte. La prima volta, la funzione di attività indica che la proposta di progetto è stata accettata. La seconda volta, la proposta viene rifiutata. La funzione di orchestrazione combina i messaggi di entrambe le chiamate di funzione e li restituisce alla funzione client.

Continua