Övning – Distribuera ett grundläggande Azure Logic Apps-arbetsflöde med hjälp av en ARM-mall

8 minuter

I den här lektionen distribuerar vi ett arbetsflöde i Azure Logic Apps med hjälp av en Azure Resource Manager-mall.

Skapa resurser i Azure

Vanligtvis skapar vi först en resursgrupp som innehåller alla objekt som vi behöver skapa. En resursgrupp hjälper oss att administrera alla virtuella datorer, diskar, nätverksgränssnitt och andra element som utgör vår lösning som en enhet.

Vi kan skapa en resursgrupp med Azure CLI-kommandot az group create. Det här kommandot tar ett --name för att ange ett unikt resursgruppsnamn i vår prenumeration. Kommandot tar också en --location för att ange azure-standardregionen för resurserna.

Vi använder dock den kostnadsfria Sandbox-miljön i Azure, så du behöver inte skapa en resursgrupp. I stället kan du använda den tidigare skapade resursgruppen [resursgruppsnamn för sandbox-miljö] i den här övningen.

Ladda ned och undersöka en grundläggande Resource Manager-mall

Från Cloud Shell kör du följande curl kommando för att ladda ned mallen från GitHub:

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

Om du vill visa mallen öppnar du den i den inbyggda redigeraren:

code basic-template.json

Logikappens arbetsflödesdefinition som beskrivs i template.json visas i följande lista:

{
    "$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]"
        }
     }
}

Som du ser i föregående JSON-definition, och som mallnamnet antyder, är det här arbetsflödet för logikappen grundläggande. Vi tittar på huvudkomponenterna i den här appen.

I följande kodavsnitt ser vi att appen heter HelloLogicAppsTemplate. Det här namnet är hårdkodat i mallen. Platsen där appen körs är också hårdkodad till westus2.

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

När du rullar ned till avsnittet utlösare ser vi att arbetsflödet utlöses med en HTTP GET-begäran. Utlösaren heter manual.

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

Längre ned i åtgärdsavsnittet får vi lära oss att det här arbetsflödet innehåller ett steg eller en åtgärd. Den här åtgärden svarar på begäran med meddelandet Hello Azure Logic Apps Template!.

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

Resource Manager-mallens utdataavsnitt har ett enda utdata som heter logicAppUrl. Den här utdatavariabeln visar URL:en för den distribuerade logikappresursen. Den här URL:en gör det enklare att testa appen. Utdata används listCallbackURL för att skapa URL:en, men arbetsflödets namn och utlösarnamn är båda hårdkodade här.

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

Nu distribuerar vi den här logikappen och testar den.

Validera och distribuera mallen

För att distribuera vår logikappresurs använder az deployment group create vi kommandot eftersom vi distribuerar till en resursgrupp. Vid distribution med hjälp av det här kommandot kan du distribuera en fjärrmall genom att ange dess plats med parametern --template-uri. I vårt fall vill vi distribuera den mall som vi har lokalt, så vi anger parametern --template-file.

Från Cloud Shell kör du az deployment group validate för att verifiera mallen:
```
az deployment group validate \
--resource-group "<rgn>[sandbox resource group name]</rgn>" \
--template-file basic-template.json
```
Argumentet --template-file pekar mot den lokala mallen. Mallens filnamn är basic-template.json.

Du ser ett stort JSON-block som utdata, som anger att mallen har godkänt valideringen.

Azure Resource Manager fyller i mallparametrarna och kontrollerar om mallen skulle köras korrekt i din prenumeration.

Om verifieringen misslyckades visas en detaljerad beskrivning av felet i utdata.
Kör följande az deployment group create kommando i Cloud Shell för att distribuera logikappresursen som definieras av vår grundläggande mall till vår sandbox-resursgrupp:
```
az deployment group create \
--name MyDeployment \
--resource-group "<rgn>[sandbox resource group name]</rgn>" \
--template-file basic-template.json
```
Det här kommandot liknar det föregående kommandot, men omfattar även argumentet --name för att ge distributionen ett namn.

Det tar ungefär två till tre minuter att slutföra kommandot. När distributionen är klar visas ett annat stort JSON-block som utdata som beskriver distributionen. Du ser provisioningState i JSON-resultatet med värdet Succeeded.

Verifiera distributionen

Kör az deployment group show för att verifiera distributionen:
```
az deployment group show \
--name MyDeployment \
--resource-group "<rgn>[sandbox resource group name]</rgn>" 
```
Du ser samma JSON-block som du såg tidigare. Du kan köra det här kommandot senare om du skulle behöva den här informationen om distributionen. Utdata är strukturerade som JSON för att göra det enklare att mata in dem i andra verktyg som du kanske använder för att spåra distributioner och molnanvändning.
För att se hur appen fungerar i praktiken letar du upp värdet för logicAppUrl i JSON-resultatet. Välj URL:en eller kopiera och klistra in den i ett nytt webbläsarfönster. På sidan visas meddelandet Hello Azure Logic Apps Template! enligt följande skärmbild:

Klar! Du har distribuerat ett logikapparbetsflöde med hjälp av en Azure Resource Manager-mall.

Som vi noterade i den här övningen har den grundläggande mallen många hårdkodade värden. Dessa värden gör mallen mindre flexibel än vi skulle vilja. Vi kan förbättra situationen med hjälp av parametrar.

Fortsätt

Övning – Distribuera ett grundläggande Azure Logic Apps-arbetsflöde med hjälp av en ARM-mall

Skapa resurser i Azure

Ladda ned och undersöka en grundläggande Resource Manager-mall

Validera och distribuera mallen

Verifiera distributionen

Feedback