Esercizio - Distribuire un flusso di lavoro di base di App per la logica di Azure con un modello di ARM

Completato

In questa unità verrà distribuito un flusso di lavoro in App per la logica usando un modello di Azure Resource Manager.

Creazione di risorse in Azure

In genere, per prima cosa è necessario creare un gruppo di risorse per contenere tutti gli elementi che è necessario creare. Un gruppo di risorse è utile per amministrare come una singola unità tutte le macchine virtuali, i dischi, le interfacce di rete e gli altri elementi che costituiscono la soluzione.

È possibile creare un gruppo di risorse con il comando az group create dell'interfaccia della riga di comando di Azure. Questo comando accetta un valore --name per specificare un nome di gruppo di risorse univoco nella sottoscrizione. Il comando accetta anche un valore --location per specificare l'area di Azure predefinita per le risorse.

Tuttavia, viene usato l'ambiente sandbox di Azure gratuito, quindi non è necessario creare un gruppo di risorse. In questo esercizio è invece possibile usare il gruppo di risorse creato in precedenza [nome gruppo di risorse sandbox].

Scaricare ed esaminare un modello di base di Resource Manager

1. Nella parte superiore della finestra di Cloud Shell, selezionare l'icona Altro (...) e quindi selezionare impostazioni>Vai alla versione classica.

2. Da Cloud Shell eseguire il comando curl seguente per scaricare il modello da GitHub:

   curl https://raw.githubusercontent.com/MicrosoftDocs/mslearn-logic-apps-and-arm-templates/master/basic-template/template.json > basic-template.json
   

3. Per visualizzare il modello, aprirlo nell’editor predefinito:

   code basic-template.json
   

   La definizione del flusso di lavoro dell’app per la logica descritta in template.json è riportata nel seguente elenco:

   {
       "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
       "contentVersion": "1.0.0.0",
       "parameters": {},
       "variables": {},
       "resources": [
           {
               "type": "Microsoft.Logic/workflows",
               "apiVersion": "2017-07-01",
               "name": "HelloLogicAppsTemplate",
               "location": "westus2",
               "properties": {
                   "state": "Enabled",
                   "definition": {
                       "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
                       "contentVersion": "1.0.0.0",
                       "parameters": {},
                       "triggers": {
                           "manual": {
                               "type": "Request",
                               "kind": "Http",
                               "inputs": {
                                   "method": "GET",
                                   "schema": {}
                               }
                           }
                       },
                       "actions": {
                           "Response": {
                               "runAfter": {},
                               "type": "Response",
                               "kind": "Http",
                               "inputs": {
                                   "body": "Hello Logic Apps Template!",
                                   "statusCode": 200
                               }
                           }
                       },
                       "outputs": {}
                   },
                   "parameters": {}
               }
           }
       ],
       "outputs": {
           "logicAppUrl": {
              "type": "string",
              "value": "[listCallbackURL(concat(resourceId('Microsoft.Logic/workflows/', 'HelloLogicAppsTemplate'), '/triggers/manual'), '2017-07-01').value]"
           }
        }
   }
   

   Come è possibile vedere dalla definizione JSON precedente, e come suggerito dal nome del modello, si tratta di un flusso di lavoro delle app per la logica semplice. Si esamineranno ora i componenti principali dell'app.

   Nel frammento di codice seguente è chiaramente visibile il nome dell'app, ovvero HelloLogicAppsTemplate. Il nome è hardcoded nel modello. Anche il percorso in cui viene eseguita l'app è hardcoded in westus2.

   "name": "HelloLogicAppsTemplate",
   "location": "westus2",
   

   Scorrendo verso il basso, fino alla sezione triggers, è possibile notare che il flusso di lavoro viene attivato con una richiesta HTTP GET. Il trigger è denominato manual.

   "triggers": {
       "manual": {
           "type": "Request",
           "kind": "Http",
           "inputs": {
               "method": "GET",
               "schema": {}
           }
       }
   },
   

   Più avanti, nella sezione azioni, si apprenderà che questo flusso di lavoro include un passaggio o un’azione. Questa azione risponde alla richiesta con il messaggio Hello Azure Logic Apps Template!.

   "actions": {
       "Response": {
           "runAfter": {},
           "type": "Response",
           "kind": "Http",
           "inputs": {
               "body": "Hello Logic Apps Template!",
               "statusCode": 200
           }
       }
   },
   

   La sezione output del modello di Resource Manager include un singolo output denominato logicAppUrl. Questa variabile di output indica l'URL per la risorsa app per la logica distribuita. Questo URL semplifica il test dell'app. L'output usa listCallbackURL per creare l'URl, ma sia il nome del flusso di lavoro che il nome del trigger sono hardcoded.

   "outputs": {
       "logicAppUrl": {
          "type": "string",
          "value": "[listCallbackURL(concat(resourceId('Microsoft.Logic/workflows/', 'HelloLogicAppsTemplate'), '/triggers/manual'), '2017-07-01').value]"
       }
    }
   

   A questo punto è possibile procedere alla distribuzione e al test dell'app.

Convalidare e distribuire il modello

Per distribuire la risorsa app per la logica si userà il comando az deployment group create, poiché la distribuzione viene eseguita in un gruppo di risorse. Quando si usa questo comando per la distribuzione, è possibile scegliere di distribuire un modello remoto specificandone il percorso con il parametro --template-uri. In questo caso, si vuole distribuire il modello disponibile in locale e quindi si imposterà il parametro --template-file.

1. In Cloud Shell, eseguire az deployment group validate per convalidare il modello:

   az deployment group validate \
   --resource-group "<rgn>[sandbox resource group name]</rgn>" \
   --template-file basic-template.json
   

   L'argomento --template-file punta al modello locale. Il nome file del modello è basic-template.json.

   Come output verrà visualizzato un blocco JSON di grandi dimensioni, a indicare che il modello ha superato la convalida.

   Azure Resource Manager compila i parametri del modello e verifica che quest'ultimo venga eseguito correttamente nell'abbonamento.

   Se la convalida ha esito negativo, viene visualizzata una descrizione dettagliata dell’errore nell’output.

2. Eseguire il comando az deployment group create seguente in Cloud Shell per distribuire la risorsa dell’app per la logica definita dal modello di base nel gruppo di risorse sandbox:

   az deployment group create \
   --name MyDeployment \
   --resource-group "<rgn>[sandbox resource group name]</rgn>" \
   --template-file basic-template.json
   

   Questo comando è simile al comando precedente, ma include anche l'argomento --name per assegnare un nome alla distribuzione.

   Il completamento di questo comando richiede da due a tre minuti. Al termine della distribuzione verrà visualizzato un altro blocco JSON di grandi dimensioni come output che descrive la distribuzione. Nel risultato JSON verrà visualizzato provisioningState con il valore Succeeded.

Verificare la distribuzione

1. Eseguire az deployment group show per verificare la distribuzione:

   az deployment group show \
   --name MyDeployment \
   --resource-group "<rgn>[sandbox resource group name]</rgn>" 
   

   Viene visualizzato lo stesso blocco JSON visualizzato in precedenza. È possibile eseguire questo comando in un secondo momento qualora fossero necessari questi dettagli relativi alla distribuzione. L'output è strutturato come JSON per semplificarne il feed in altri strumenti che è possibile usare per tenere traccia delle distribuzioni e dell'uso del cloud.

2. Per visualizzare l'app in azione, trovare il valore logicAppUrl nel risultato JSON. Selezionare l’URL o copiarlo e incollarlo in una nuova finestra del browser. Nella pagina viene visualizzato il messaggio Hello Azure Logic Apps Template! come mostrato nello screenshot seguente:

   

Congratulazioni. È stata completata la distribuzione di un flusso di lavoro delle app per la logica tramite un modello di Azure Resource Manager.

Come osservato in questo esercizio, il modello di base include numerosi valori hardcoded. Questi valori rendono quindi il modello meno flessibile rispetto a quanto auspicabile. È possibile migliorare la situazione usando i parametri.