Skapa och distribuera arbetsflöden för en klientbaserad logikapp med Azure Arc-aktiverade Logic Apps (förhandsversion)

Kommentar

Den här funktionen är i förhandsversion och omfattas av kompletterande användningsvillkor för Förhandsversioner av Microsoft Azure.

Med Azure Arc-aktiverade Logic Apps och Azure-portalen kan du skapa och distribuera arbetsflöden för en klientbaserad logikapp till en Kubernetes-infrastruktur som du använder och hanterar. Dina logikappar körs på en anpassad plats som mappas till ett Azure Arc-aktiverat Kubernetes-kluster där du har installerat och aktiverat paketet med Azure App Service-plattformstillägg.

Det här klustret kan till exempel vara Azure Kubernetes Service, bare-metal Kubernetes eller en annan konfiguration. Med tilläggspaketet kan du köra plattformstjänster som Azure Logic Apps, Azure App Service och Azure Functions i kubernetes-klustret.

Mer information finns i följande dokumentation:

• Vad är Azure Arc-aktiverade Logic Apps?
• Miljö för en klientorganisation jämfört med flera klientorganisationer och integrationstjänst
• Översikt över Azure Arc
• Översikt över Azure Kubernetes Service
• Vad är Azure Arc-aktiverad Kubernetes?
• Anpassade platser i Azure Arc-aktiverade Kubernetes
• App Service, Functions och Logic Apps i Azure Arc (förhandsversion)
• Konfigurera ett Azure Arc-aktiverat Kubernetes-kluster för att köra App Service, Functions och Logic Apps (förhandsversion)

Förutsättningar

I det här avsnittet beskrivs de vanliga förutsättningarna för alla metoder och verktyg som du kan använda för att skapa och distribuera dina arbetsflöden för logikappar. Verktygsspecifika krav visas tillsammans med motsvarande steg.

• Ett Azure-konto med en aktiv prenumeration. Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto.

• En Kubernetes-miljö med ett Azure Arc-aktiverat Kubernetes-kluster och en anpassad plats där du kan vara värd för och köra Azure Logic Apps, Azure App Service och Azure Functions.

  Viktigt!

  Kontrollera att du använder samma resursplats för kubernetes-miljön, den anpassade platsen och logikappen.

  När du skapar App Service-pakettillägget i kubernetes-klustret kan du ändra standardskalningsbeteendet för att köra logikappens arbetsflöden. När du skapar tillägget med hjälp av Azure CLI-kommandot az k8s-extension createska du inkludera konfigurationsinställningen: keda.enabled=true

  az k8s-extension create {other-command-options} --configuration-settings "keda.enabled=true"

  Mer information finns i följande dokumentation:

  • App Service, Functions och Logic Apps i Azure Arc (förhandsversion)
  • Klustertillägg på Azure Arc-aktiverade Kubernetes
  • Konfigurera ett Azure Arc-aktiverat Kubernetes-kluster för att köra App Service, Functions och Logic Apps (förhandsversion)
  • Ändra standardskalningsbeteendet

• Din egen Microsoft Entra-identitet

  Om dina arbetsflöden behöver använda azure-värdbaserade anslutningar, till exempel Office 365 Outlook eller Azure Storage, måste logikappen använda en Microsoft Entra-identitet för autentisering. Azure Arc-aktiverade Logic Apps kan köras på valfri infrastruktur, men kräver en identitet som har behörighet att använda Azure-värdbaserade anslutningar. Om du vill konfigurera den här identiteten skapar du en appregistrering i Microsoft Entra-ID som logikappen använder som nödvändig identitet.

  Kommentar

  Stöd för hanterad identitet är för närvarande inte tillgängligt för Azure Arc-aktiverade Logic Apps.

  Följ dessa steg för att skapa en Microsoft Entra-appregistrering med hjälp av Azure CLI:

  1. Skapa en appregistrering med hjälp az ad sp create av kommandot .

  2. Om du vill granska all information kör du az ad sp show kommandot.

  3. Från utdata från båda kommandona letar du upp och sparar klient-ID, objekt-ID, klient-ID och klienthemlighetsvärden som du behöver behålla för senare användning.

  Följ dessa steg för att skapa en Microsoft Entra-appregistrering med hjälp av Azure-portalen:

  1. Skapa en ny Microsoft Entra-appregistrering med hjälp av Azure-portalen.

  2. När du har skapat den hittar du den nya appregistreringen i portalen.

  3. På registreringsmenyn väljer du Översikt och sparar klient-ID, klient-ID och klienthemlighetsvärden.

  4. Om du vill hitta objekt-ID:t väljer du namnet på appregistreringen bredvid det hanterade programmet i det lokala katalogfältet . Kopiera objekt-ID:t från egenskapsvyn.

Skapa och distribuera logikappar

Baserat på om du vill använda Azure CLI, Visual Studio Code eller Azure-portalen väljer du den matchande fliken för att granska de specifika förutsättningarna och stegen.

Azure CLI

Innan du börjar måste du ha följande objekt:

• Det senaste Azure CLI-tillägget installerat på den lokala datorn.

  • Om du inte har det här tillägget kan du läsa installationsguiden för ditt operativsystem eller din plattform.

  • Om du inte är säker på att du har den senaste versionen följer du stegen för att kontrollera din miljö och CLI-version.

• Förhandsversionen av Azure Logic Apps-tillägget (Standard) för Azure CLI.

  Även om Azure Logic Apps för en klientorganisation är allmänt tillgängligt är Azure Logic Apps-tillägget fortfarande i förhandsversion.

• En Azure-resursgrupp där du kan skapa din logikapp.

  Om du inte har den här resursgruppen följer du stegen för att skapa resursgruppen.

• Ett Azure Storage-konto som ska användas med logikappen för data- och körningshistorikkvarhållning.

  Om du inte har det här lagringskontot kan du skapa det här kontot när du skapar logikappen, eller så kan du följa stegen för att skapa ett lagringskonto.

Kontrollera miljö- och CLI-version

1. Logga in på Azure-portalen. Kontrollera att din prenumeration är aktiv genom att köra följande kommando:

   az login
   

2. Kontrollera din version av Azure CLI i en terminal eller ett kommandofönster genom att köra följande kommando:

   az --version
   

   Den senaste versionen finns i de senaste viktig information.

3. Om du inte har den senaste versionen uppdaterar du installationen genom att följa installationsguiden för ditt operativsystem eller din plattform.

Installera Azure Logic Apps-tillägget (Standard) för Azure CLI

Installera azure logic apps-tillägget (standard) för förhandsversionen av en enda klientorganisation för Azure CLI genom att köra följande kommando:

az extension add --yes --source "https://aka.ms/logicapp-latest-py2.py3-none-any.whl"

Skapa resursgrupp

Om du inte redan har en resursgrupp för logikappen skapar du gruppen genom att köra kommandot az group create. Om du inte redan har angett en standardprenumeration för ditt Azure-konto ska du använda parametern --subscription med ditt prenumerationsnamn eller din identifierare. Annars behöver du inte använda parametern --subscription .

Dricks

Om du vill ange en standardprenumeration kör du följande kommando och ersätter MySubscription med ditt prenumerationsnamn eller din identifierare.

az account set --subscription MySubscription

Följande kommando skapar till exempel en resursgrupp med namnet MyResourceGroupName med azure-prenumerationen med namnet MySubscription på platsen eastus:

az group create --name MyResourceGroupName 
   --subscription MySubscription 
   --location eastus

Om resursgruppen har skapats visas utdata som provisioningState Succeeded:

<...>
   "name": "testResourceGroup",
   "properties": {
      "provisioningState": "Succeeded"
    },
<...>

Skapa en logikapp

Om du vill skapa en Azure Arc-aktiverad logikapp kör du kommandot , az logicapp createmed följande obligatoriska parametrar. Resursplatserna för logikappen, den anpassade platsen och Kubernetes-miljön måste alla vara desamma.

Parameters	Description
--name -n	Ett unikt namn för logikappen
--resource-group -g	Namnet på resursgruppen där du vill skapa logikappen. Om du inte har någon att använda skapar du en resursgrupp.
--storage-account -s	Lagringskontot som ska användas med logikappen. Använd ett strängvärde för lagringskonton i samma resursgrupp. Använd ett resurs-ID för lagringskonton i en annan resursgrupp.

az logicapp create --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription 
   --storage-account MyStorageAccount --custom-location MyCustomLocation

Om du vill skapa en Azure Arc-aktiverad logikapp med en privat Azure Container Registry-avbildning (ACR) kör du kommandot , az logicapp createmed följande obligatoriska parametrar:

az logicapp create --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription 
   --storage-account MyStorageAccount --custom-location MyCustomLocation 
   --deployment-container-image-name myacr.azurecr.io/myimage:tag
   --docker-registry-server-password MyPassword 
   --docker-registry-server-user MyUsername

Visa information om logikappen

Om du vill visa information om din Azure Arc-aktiverade logikapp kör du kommandot , az logicapp showmed följande obligatoriska parametrar:

az logicapp show --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription

Distribuera logikapp

Om du vill distribuera din Azure Arc-aktiverade logikapp med hjälp av Kudu zip-distributionen i Azure App Service kör du kommandot , az logicapp deployment source config-zipmed följande obligatoriska parametrar:

Viktigt!

Kontrollera att zip-filen innehåller projektets artefakter på rotnivå. Dessa artefakter omfattar alla arbetsflödesmappar, konfigurationsfiler som host.json, connections.json och andra relaterade filer. Lägg inte till några extra mappar eller placera artefakter i mappar som inte redan finns i projektstrukturen. Den här listan visar till exempel filstrukturen MyBuildArtifacts.zip:

MyStatefulWorkflow1-Folder
MyStatefulWorkflow2-Folder
connections.json
host.json

az logicapp deployment source config-zip --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription 
   --src MyBuildArtifact.zip

Starta logikapp

Starta din Azure Arc-aktiverade logikapp genom att köra kommandot , az logicapp start, med följande obligatoriska parametrar:

az logicapp start --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription

Stoppa logikapp

Om du vill stoppa din Azure Arc-aktiverade logikapp kör du kommandot , az logicapp stopmed följande obligatoriska parametrar:

az logicapp stop --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription

Starta om logikappen

Om du vill starta om din Azure Arc-aktiverade logikapp kör du kommandot , az logicapp restartmed följande obligatoriska parametrar:

az logicapp restart --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription

Ta bort logikapp

Om du vill ta bort din Azure Arc-aktiverade logikapp kör du kommandot , az logicapp deletemed följande obligatoriska parametrar:

az logicapp delete --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription

Visual Studio Code

Du kan skapa, distribuera och övervaka dina logikapparbetsflöden från slutpunkt till slutpunkt i Visual Studio Code. Det finns ingen förändring eller skillnad i designerupplevelsen mellan att utveckla logikapparbetsflöden som körs i Azure Logic Apps med en enda klient jämfört med Azure Arc-aktiverade Logic Apps.

1. Om du vill skapa ett logikappsprojekt följer du kraven och stegen i dokumentationen Skapa integreringsarbetsflöden i Azure Logic Apps med en enda klientorganisation med Visual Studio Code .

2. När du är redo att distribuera till Azure använder du funktionen Distribuera till logikapp för att skapa logikappresursen på din tidigare skapade anpassade plats och distribuera dina arbetsflöden till samma plats.

   1. Öppna snabbmenyn från ett tomt område i logikappsprojektets fönster och välj Distribuera till logikapp.

   2. Välj den Azure-prenumeration som är associerad med din anpassade plats.

   3. Om du vill skapa en ny Azure Arc-aktiverad Logic Apps-resurs väljer du Skapa ny logikapp i Azure (Avancerat). Eller så kan du välja en befintlig logikappresurs i listan och hoppa över nästa steg.

   4. Ange ett globalt unikt namn för logikappen.

   5. Välj den anpassade platsen för Den Azure Arc-aktiverade Kubernetes-miljön dit du vill distribuera. Om du väljer en allmän Azure-region i stället skapar du en icke-Azure Arc-aktiverad logikappresurs som körs i Azure Logic Apps med en enda klientorganisation.

   6. Välj eller skapa en ny resursgrupp där du vill distribuera logikappen.

   7. Välj eller skapa ett nytt lagringskonto för att spara logikappens tillstånd och metadata.

   8. Välj eller skapa en ny Application Insights-resurs för att lagra programloggar för din logikapp.

   9. Om du inte har gjort det konfigurerar du din Microsoft Entra-identitet så att logikappen kan autentisera hanterade API-anslutningar. Mer information finns i krav på den översta nivån.

   10. Ange klient-ID, klient-ID, objekt-ID och klienthemlighet för din Microsoft Entra-identitet.

       Kommentar

       Du behöver bara slutföra det här steget en gång. Visual Studio Code uppdaterar projektets connections.json-fil och dina hanterade API-anslutningars åtkomstprinciper åt dig.

3. När du är klar är logikappen live och körs i ditt Azure Arc-aktiverade Kubernetes-kluster, redo att testas.

Azure-portalen

Den portalbaserade designerns redigeringsfunktion är för närvarande under utveckling för Azure Arc-aktiverade Logic Apps. Du kan skapa, distribuera och visa dina logikappar med hjälp av den portalbaserade designern, men du kan inte redigera dem i portalen efter distributionen. För tillfället kan du skapa och redigera ett logikappprojekt lokalt i Visual Studio Code och sedan distribuera med hjälp av Visual Studio Code, Azure CLI eller automatiserade distributioner.

1. Skapa en logikappresurs (Standard) i Azure-portalen. För publiceringsmålet väljer du dockercontainer. För Region väljer du din tidigare skapade anpassade plats som appens plats.

   Som standard körs logikappresursen (Standard) i Azure Logic Apps med en enda klientorganisation. För Azure Arc-aktiverade Logic Apps körs dock logikappresursen på den anpassade plats som du skapade för Kubernetes-miljön. Du behöver inte heller skapa en App Service-plan som skapas åt dig.

   Viktigt!

   Resursplatserna för logikappen, den anpassade platsen och Kubernetes-miljön måste alla vara desamma.

2. Redigera och distribuera logikappen med Visual Studio Code.

3. När du har skapat och distribuerat logikappen kan du övervaka och visa dina arbetsflöden som vanligt med hjälp av portalen eller Application Insights.

   Portalupplevelsen för distribuerade logikappar är för närvarande tillgänglig i skrivskyddat läge, vilket innebär att du inte kan ändra dina arbetsflöden eller appinställningar. Du kan dock fortfarande visa körningshistorik, utlösarhistorik och annan information om dina appar. För tillfället kan du använda Azure CLI, Visual Studio Code eller automatiserade distributioner för att uppdatera dina logikappar.

Konfigurera anslutningsautentisering

För närvarande stöder inte Azure Arc-aktiverade Kubernetes-kluster att använda en logikapps hanterade identitet för att autentisera hanterade API-anslutningar. Du skapar dessa Azure-värdbaserade och hanterade anslutningar när du använder hanterade anslutningsappar i dina arbetsflöden.

I stället måste du skapa en egen appregistrering i Microsoft Entra-ID. Du kan sedan använda den här appregistreringen som en identitet för logikappar som distribueras och körs i Azure Arc-aktiverade Logic Apps. Mer information finns i förhandskraven på den översta nivån.

Från din appregistrering behöver du klient-ID, objekt-ID, klient-ID och klienthemlighet. Om du använder Visual Studio Code för att distribuera har du en inbyggd upplevelse för att konfigurera logikappen med en Microsoft Entra-identitet. Mer information finns i Skapa och distribuera arbetsflöden för logikappar – Visual Studio Code.

Men om du använder Visual Studio Code för utveckling, men du använder Azure CLI eller automatiserade pipelines för att distribuera, följer du dessa steg.

Konfigurera anslutnings- och appinställningar i projektet

1. Leta reda på objektet för den hanterade anslutningen authentication i logikappprojektets connections.json-fil. Ersätt det här objektets innehåll med din appregistreringsinformation, som du tidigare genererade i förhandskraven på den översta nivån:

   "authentication": {
      "type": "ActiveDirectoryOAuth",
      "audience": "https://management.core.windows.net/",
      "credentialType": "Secret",
      "clientId": "@appsetting('WORKFLOWAPP_AAD_CLIENTID')",
      "tenant": "@appsetting('WORKFLOWAPP_AAD_TENANTID')",
      "secret": "@appsetting('WORKFLOWAPP_AAD_CLIENTSECRET')"
   } 
   

2. I logikappprojektets local.settings.json-fil lägger du till klient-ID, objekt-ID, klient-ID och klienthemlighet. Efter distributionen blir de här inställningarna dina inställningar för logikappen.

   {
      "IsEncrypted": false,
      "Values": {
         <...>
         "WORKFLOWAPP_AAD_CLIENTID":"<my-client-ID>",
         "WORKFLOWAPP_AAD_OBJECTID":"<my-object-ID",
         "WORKFLOWAPP_AAD_TENANTID":"<my-tenant-ID>",
         "WORKFLOWAPP_AAD_CLIENTSECRET":"<my-client-secret>"
      }
   }
   

Viktigt!

För produktionsscenarier eller miljöer ska du skydda och skydda sådana hemligheter och känslig information, till exempel med hjälp av ett nyckelvalv.

Lägga till åtkomstprinciper

I Azure Logic Apps för en klientorganisation har varje logikapp en identitet som beviljas behörigheter av åtkomstprinciper för att använda Azure-värdbaserade och hanterade anslutningar. Du kan konfigurera dessa åtkomstprinciper med hjälp av Azure-portalen eller infrastrukturdistributioner.

ARM-mall

I din Azure Resource Manager-mall (ARM-mall) innehåller du följande resursdefinition för varje hanterad API-anslutning och anger följande information:

Parameter	Beskrivning
<anslutningsnamn>	Namnet på din hanterade API-anslutning, till exempel office365
<object-ID>	Objekt-ID:t för din Microsoft Entra-identitet, som tidigare sparats från din appregistrering
<klientorganisations-ID>	Klientorganisations-ID:t för din Microsoft Entra-identitet, som tidigare sparats från din appregistrering

{
   "type": "Microsoft.Web/connections/accessPolicies",
   "apiVersion": "2016-06-01",
   "name": "[concat('<connection-name>'),'/','<object-ID>')]",
   "location": "<location>",
   "dependsOn": [
      "[resourceId('Microsoft.Web/connections', parameters('connection_name'))]"
   ],
   "properties": {
      "principal": {
         "type": "ActiveDirectory",
         "identity": {
            "objectId": "<object-ID>",
            "tenantId": "<tenant-ID>"
         }
      }
   }
}

Mer information finns i dokumentationen om Microsoft.Web/connections/accesspolicies (ARM-mall).

Azure Portal

För den här uppgiften använder du ditt tidigare sparade klient-ID som program-ID.

1. I Azure-portalen letar du upp och öppnar logikappen. På logikappens meny går du till Arbetsflöden och väljer Anslut ions, som visar alla anslutningar i logikappens arbetsflöden.

2. Under API-Anslut ions väljer du en anslutning, som finns office365 i det här exemplet.

3. Välj Åtkomstprinciper>Lägg till under Inställningar på anslutningens meny.

4. I fönstret Lägg till åtkomstprincip går du till sökrutan och letar upp och väljer ditt tidigare sparade klient-ID.

5. När du är klar väljer du Lägg till.

6. Upprepa de här stegen för varje Azure-värdbaserad anslutning i logikappen.

Automatisera DevOps-distribution

Om du vill skapa och distribuera dina Azure Arc-aktiverade logikappar kan du använda samma pipelines och processer som för en klientbaserade logikappar. Om du vill automatisera infrastrukturdistributioner med hjälp av pipelines för DevOps gör du följande ändringar på infrastrukturnivå för både icke-container- och containerdistributioner.

Standarddistribution (icke-container)

Om du använder zip-distribution för distribution av logikappar behöver du inte konfigurera ett Docker-register för att vara värd för containeravbildningar. Även om logikappar på Kubernetes tekniskt körs på containrar, hanterar Azure Arc-aktiverade Logic Apps dessa containrar åt dig. I det här scenariot utför du följande uppgifter när du konfigurerar infrastrukturen:

• Meddela resursprovidern att du skapar en logikapp i Kubernetes.
• Inkludera en App Service-plan med din distribution. Mer information finns i Inkludera App Service-plan med distribution.

I din Azure Resource Manager-mall (ARM-mall) innehåller du följande värden:

Objekt	JSON-egenskap	Description
Plats	location	Se till att använda samma resursplats (Azure-region) som din anpassade plats och Kubernetes-miljö. Resursplatserna för logikappen, den anpassade platsen och Kubernetes-miljön måste alla vara desamma. Obs! Det här värdet är inte samma som namnet på din anpassade plats.
Apptyp	kind	Den typ av app som du distribuerar så att Azure-plattformen kan identifiera din app. För Azure Logic Apps ser den här informationen ut som i följande exempel: kubernetes,functionapp,workflowapp,linux
Utökad plats	extendedLocation	Det här objektet kräver den "name" anpassade platsen för Kubernetes-miljön och måste ha värdet "type" "CustomLocation".
Resurs-ID för värdplan	serverFarmId	Resurs-ID:t för den associerade App Service-planen, formaterat på följande sätt: "/subscriptions/{subscriptionID}/resourceGroups/{groupName}/providers/Microsoft.Web/serverfarms/{appServicePlanName}"
Lagring anslutningssträng	AzureWebJobsStorage	Anslutningssträng för ditt lagringskonto Viktigt: Du måste ange anslutningssträng för ditt lagringskonto i ARM-mallen. För produktionsscenarier eller miljöer ska du skydda och skydda sådana hemligheter och känslig information, till exempel med hjälp av ett nyckelvalv.

ARM-mall

I följande exempel beskrivs ett exempel på en Azure Arc-aktiverad Logic Apps-resursdefinition som du kan använda i ARM-mallen. Mer information finns i JSON-dokumentationen (Microsoft.Web/sites template format).

{
   "type": "Microsoft.Web/sites",
   "apiVersion": "2020-12-01",
   "name": "[parameters('name')]",
   "location": "[parameters('location')]",
   "kind": "kubernetes,functionapp,workflowapp,linux",
   "extendedLocation": {
      "name": "[parameters('customLocationId')]",
      "type": "CustomLocation"
    },
   "properties": {
      "clientAffinityEnabled": false,
      "name": "[parameters('name')]",
      "serverFarmId": "<hosting-plan-ID>",
      "siteConfig": {
         "appSettings": [
            {
               "name": "FUNCTIONS_EXTENSION_VERSION",
               "value": "~3"
            },
            {
               "name": "FUNCTIONS_WORKER_RUNTIME",
               "value": "node"
            },
            {
               "name": "AzureWebJobsStorage",
               "value": "<storage-connection-string>"
            },
            {
               "name": "AzureFunctionsJobHost__extensionBundle__id",
               "value": "Microsoft.Azure.Functions.ExtensionBundle.Workflows"
            },
            {
               "name": "AzureFunctionsJobHost__extensionBundle__version",
               "value": "[1.*, 2.0.0)"
            },
            {
               "name": "APP_KIND",
               "value": "workflowapp"
            }
         ],
         "use32BitWorkerProcess": "[parameters('use32BitWorkerProcess')]",
         "linuxFxVersion": "Node|12"
      }
   }
}

Containerdistribution

Om du föredrar att använda containerverktyg och distributionsprocesser kan du containerisera dina logikappar och distribuera dem till Azure Arc-aktiverade Logic Apps. I det här scenariot utför du följande uppgifter på hög nivå när du konfigurerar infrastrukturen:

• Konfigurera ett Docker-register för att vara värd för dina containeravbildningar.

• Om du vill containerisera logikappen lägger du till följande Dockerfile i logikappprojektets rotmapp och följer stegen för att skapa och publicera en avbildning i Docker-registret, till exempel granska Självstudie: Skapa och distribuera containeravbildningar i molnet med Azure Container Registry Tasks.

  Kommentar

  Om du använder SQL som lagringsprovider kontrollerar du att du använder en Azure Functions-avbildningsversion 3.3.1 eller senare.

  FROM mcr.microsoft.com/azure-functions/node:3.3.1
  ENV AzureWebJobsScriptRoot=/home/site/wwwroot \
  AzureFunctionsJobHost__Logging__Console__IsEnabled=true \
  FUNCTIONS_V2_COMPATIBILITY_MODE=true
  COPY . /home/site/wwwroot
  RUN cd /home/site/wwwroot
  

• Meddela resursprovidern att du skapar en logikapp i Kubernetes.

• I distributionsmallen pekar du på Docker-registret och containeravbildningen där du planerar att distribuera. Azure Logic Apps med en klientorganisation använder den här informationen för att hämta containeravbildningen från Docker-registret.

• Inkludera en App Service-plan med din distribution. Mer information finns i Inkludera App Service-plan med distribution.

I din Azure Resource Manager-mall (ARM-mall) innehåller du följande värden:

Objekt	JSON-egenskap	Description
Plats	location	Se till att använda samma resursplats (Azure-region) som din anpassade plats och Kubernetes-miljö. Resursplatserna för logikappen, den anpassade platsen och Kubernetes-miljön måste alla vara desamma. Obs! Det här värdet är inte samma som namnet på din anpassade plats.
Apptyp	kind	Den typ av app som du distribuerar så att Azure-plattformen kan identifiera din app. För Azure Logic Apps ser den här informationen ut som i följande exempel: kubernetes,functionapp,workflowapp,container
Utökad plats	extendedLocation	Det här objektet kräver den "name" anpassade platsen för Kubernetes-miljön och måste ha "type" angetts till "CustomLocation".
Containerns namn	linuxFxVersion	Namnet på containern, formaterat på följande sätt: DOCKER\|<container-name>
Resurs-ID för värdplan	serverFarmId	Resurs-ID:t för den associerade App Service-planen, formaterat på följande sätt: "/subscriptions/{subscriptionID}/resourceGroups/{groupName}/providers/Microsoft.Web/serverfarms/{appServicePlanName}"
Lagring anslutningssträng	AzureWebJobsStorage	Anslutningssträng för ditt lagringskonto Viktigt: När du distribuerar till en Docker-container måste du ange anslutningssträng för ditt lagringskonto i ARM-mallen. För produktionsscenarier eller miljöer ska du skydda och skydda sådana hemligheter och känslig information, till exempel med hjälp av ett nyckelvalv.

Om du vill referera till Docker-registret och containeravbildningen inkluderar du dessa värden i mallen:

Objekt	JSON-egenskap	Description
Url för Docker-registerserver	DOCKER_REGISTRY_SERVER_URL	URL:en för Docker-registerservern
Docker-registerserver	DOCKER_REGISTRY_SERVER_USERNAME	Användarnamnet för att komma åt Docker-registerservern
Docker-registerserverlösenord	DOCKER_REGISTRY_SERVER_PASSWORD	Lösenordet för att komma åt Docker-registerservern

ARM-mall

I följande exempel beskrivs ett exempel på en Azure Arc-aktiverad Logic Apps-resursdefinition som du kan använda i ARM-mallen. Mer information finns i dokumentationen om mallformatet microsoft.web/sites (ARM-mall).

{
   "type": "Microsoft.Web/sites",
   "apiVersion": "2020-12-01",
   "name": "[parameters('name')]",
   "location": "[parameters('location')]",
   "kind": " kubernetes,functionapp,workflowapp,container",
   "extendedLocation": {
      "name": "[parameters('customLocationId')]",
      "type": "CustomLocation"
    },
   "properties": {
      "name": "[parameters('name')]",
      "clientAffinityEnabled": false,
      "serverFarmId": "<hosting-plan-ID>",
      "siteConfig": {
         "appSettings": [
            {
               "name": "FUNCTIONS_EXTENSION_VERSION",
               "value": "~3"
            },
            {
               "name": "FUNCTIONS_WORKER_RUNTIME",
               "value": "node"
            },
            {
               "name": "AzureWebJobsStorage",
               "value": "<storage-connection-string>"
            },
            {
               "name": "AzureFunctionsJobHost__extensionBundle__id",
               "value": "Microsoft.Azure.Functions.ExtensionBundle.Workflows"
            },
            {
               "name": "AzureFunctionsJobHost__extensionBundle__version",
               "value": "[1.*, 2.0.0)"
            },
            {
               "name": "APP_KIND",
               "value": "workflowapp"
            }, 
            {
               "name": "DOCKER_REGISTRY_SERVER_URL",
               "value": "<docker-registry-server-URL>"
            },
            { 
               "name": "DOCKER_REGISTRY_SERVER_USERNAME",
               "value": "<docker-registry-server-username>"
            },
            {
               "name": "DOCKER_REGISTRY_SERVER_PASSWORD",
               "value": "<docker-registry-server-password>"
            }
         ],
         "use32BitWorkerProcess": "[parameters('use32BitWorkerProcess')]",
         "linuxFxVersion": "DOCKER|<container-name>"
      }
   }
}

Inkludera App Service-plan med distribution

Oavsett om du har en standard- eller containerdistribution måste du inkludera en App Service-plan med din distribution. Även om den här planen blir mindre relevant för en Kubernetes-miljö, kräver både standard- och containerdistributionerna fortfarande en App Service-plan.

Även om andra alternativ för att skapa vanligtvis hanterar etablering av Azure-resursen för den här planen, måste du uttryckligen skapa Azure-resursen för planen om dina distributioner använder "infrastruktur som kod"-mallar. Värdplansresursen ändras inte, bara sku informationen.

I din Azure Resource Manager-mall (ARM-mall) innehåller du följande värden:

Objekt	JSON-egenskap	Description
Plats	location	Se till att använda samma resursplats (Azure-region) som din anpassade plats och Kubernetes-miljö. Resursplatserna för logikappen, den anpassade platsen och Kubernetes-miljön måste alla vara desamma. Obs! Det här värdet är inte samma som namnet på din anpassade plats.
Variant	kind	Den typ av App Service-plan som distribueras som måste vara kubernetes,linux
Utökad plats	extendedLocation	Det här objektet kräver den "name" anpassade platsen för Kubernetes-miljön och måste ha "type" angetts till "CustomLocation".
Namn på värdplan	name	Namnet på App Service-planen
Plannivå	sku: tier	App Service-plannivån, som är K1
Plannamn	sku: name	App Service-plannamnet, som är Kubernetes

ARM-mall

I följande exempel beskrivs en exempelresursdefinition för App Service-plan som du kan använda med appdistributionen. Mer information finns i dokumentationen om mallformatet Microsoft.Web/serverfarms (ARM-mall).

{
   "type": "Microsoft.Web/serverfarms",
   "apiVersion": "2020-12-01",
   "location": "<location>",
   "name": "<hosting-plan-name>",
   "kind": "kubernetes,linux",
   "extendedLocation": {
      "name": "[parameters('customLocationId')]",
      "type": "CustomLocation"
   },
   "sku": {
      "tier": "Kubernetes",
      "name": "K1", 
      "capacity": 1
   },
   "properties": {
      "kubeEnvironmentProfile": {
         "id": "[parameters('kubeEnvironmentId')]"
      }
   }
}

Ändra standardskalningsbeteende

Azure Arc-aktiverade Logic Apps hanterar automatiskt skalning för dina logikappar baserat på antalet jobb i serverdelslagringskön. Du kan dock ändra standardskalningsbeteendet.

I en logikapp anger arbetsflödesdefinitionen sekvensen med åtgärder som ska köras. När en arbetsflödeskörning utlöses skapar Azure Logic Apps-körningen ett jobb för varje åtgärdstyp i arbetsflödesdefinitionen. Körningen organiserar sedan dessa jobb i en jobbsekvenserare. Den här sekvenseraren orkestrerar körningen av jobben för arbetsflödesdefinitionen, men den underliggande Azure Logic Apps-jobborkestreringsmotorn kör varje jobb.

För tillståndskänsliga arbetsflöden använder jobborkestreringsmotorn lagringskömeddelanden för att schemalägga jobb i jobbsekvenserarna. I bakgrunden övervakar jobbutskickare (eller dispatcher worker-instanser) dessa jobbköer. Orkestreringsmotorn använder ett lägsta och högsta standardantal arbetsinstanser för att övervaka jobbköerna. För tillståndslösa arbetsflöden håller orkestreringsmotorn helt åtgärdstillstånd i minnet.

Om du vill ändra standardskalningsbeteendet anger du olika minsta och högsta antal arbetsinstanser som övervakar jobbköerna.

Förutsättningar för att ändra skalning

I ditt Azure Arc-aktiverade Kubernetes-kluster måste det tidigare skapade App Service-pakettillägget keda.enabled ha egenskapen inställd på true. Mer information finns i förhandskraven på den översta nivån.

Ändra skalningströskel

I Azure Arc-aktiverade Logic Apps utlöser längden på jobbkön en skalningshändelse och anger ett tröskelvärde för hur ofta skalning sker för logikappen. Du kan ändra kölängden, som har standardvärdet inställt på 20 jobb. Öka kölängden om du vill skala mindre ofta. Minska kölängden om du vill skala oftare. Den här processen kan kräva en del utvärderingsversioner och fel.

Om du vill ändra kölängden anger du Runtime.ScaleMonitor.KEDA.TargetQueueLength egenskapen i logikappprojektets host.json-fil på rotnivå, till exempel:

"extensions": {
   "workflow": {
      "settings": {
         "Runtime.ScaleMonitor.KEDA.TargetQueueLength": "10"
      }
   }
}

Ändra maximalt dataflöde

På en befintlig logikappresurs kan du ändra det maximala antalet arbetsinstanser, som har standardvärdet inställt på 2. Det här värdet styr den övre gränsen för hur många arbetsinstanser som kan övervaka jobbköerna.

Om du vill ändra det här maxvärdet använder du Azure CLI (endast skapa logikapp) och Azure-portalen.

Azure CLI

Om du vill skapa en ny logikapp kör du kommandot , az logicapp createmed följande parametrar:

az logicapp create --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription 
   --storage-account MyStorageAccount --custom-location MyCustomLocation 
   [--plan MyHostingPlan] [--min-worker-count 1] [--max-worker-count 4]

Använd parametern för att konfigurera maximalt antal instanser --settings :

az logicapp config appsettings set --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription
   --settings "K8SE_APP_MAX_INSTANCE_COUNT=10"

Azure Portal

I inställningarna för en klientbaserad logikapp lägger du till eller redigerar K8SE_APP_MAX_INSTANCE_COUNT inställningsvärdet genom att följa dessa steg:

1. I Azure-portalen letar du upp och öppnar din logikapp med en enda klientorganisation.

2. Välj Konfiguration under Inställningar på logikappmenyn.

3. I fönstret Konfiguration under Programinställningar lägger du antingen till en ny programinställning eller redigerar det befintliga värdet om det redan har lagts till.

   1. Välj Ny programinställning och lägg till inställningen K8SE_APP_MAX_INSTANCE_COUNT med det högsta värde du vill ha.

   2. Redigera det befintliga värdet för inställningen K8SE_APP_MAX_INSTANCE_COUNT .

4. När du är klar kan du spara ändringarna.

Ändra minsta dataflöde

På en befintlig logikappresurs kan du ändra det minsta antalet arbetsinstanser, som har standardvärdet inställt på 1. Det här värdet styr den lägre gränsen för hur många arbetsinstanser som kan övervaka jobbköerna. Öka det här värdet för hög tillgänglighet eller prestanda.

Om du vill ändra detta minimum använder du Azure CLI eller Azure-portalen.

Azure CLI

För en befintlig logikappresurs kör du kommandot , az logicapp scalemed följande parametrar:

az logicapp scale --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription 
   --instance-count 5 

Om du vill skapa en ny logikapp kör du kommandot , az logicapp createmed följande parametrar:

az logicapp create --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription 
   --storage-account MyStorageAccount --custom-location MyCustomLocation 
   [--plan MyHostingPlan] [--min-worker-count 2] [--max-worker-count 4]

Azure Portal

I inställningarna för den enskilda klientbaserade logikappen ändrar du egenskapsvärdet Skala ut genom att följa dessa steg:

1. I Azure-portalen letar du upp och öppnar din logikapp med en enda klientorganisation.

2. På logikappmenyn går du till Inställningar och väljer Skala ut.

3. Dra skjutreglaget för minsta instanser till önskat värde i fönstret Skala ut.

4. När du är klar kan du spara ändringarna.

Felsöka problem

Om du vill ha mer information om dina distribuerade logikappar kan du prova följande alternativ:

Åtkomst till appinställningar och konfiguration

För att komma åt appinställningarna kör du kommandot , az logicapp config appsettingsmed följande parametrar:

az logicapp config appsettings list --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription

Om du vill konfigurera en appinställning kör du kommandot , az logicapp config appsettings setmed följande parametrar. Se till att använda parametern --settings med inställningens namn och värde.

az logicapp config appsettings set --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription 
   --settings "MySetting=1"

Om du vill ta bort en appinställning kör du kommandot , az logicapp config appsettings deletemed följande parametrar. Se till att använda parametern --setting-names med namnet på den inställning som du vill ta bort.

az logicapp config appsettings delete --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription
   --setting-names MySetting

Visa egenskaper för logikapp

Om du vill visa appens information och egenskaper kör du kommandot , az logicapp showmed följande parametrar:

az logicapp show --name MyLogicAppName 
   --resource-group MyResourceGroupName --subscription MySubscription

Övervaka arbetsflödesaktivitet

Följ dessa steg om du vill visa aktiviteten för ett arbetsflöde i logikappen:

1. I Azure-portalen letar du upp och öppnar din distribuerade logikapp.

2. På logikappmenyn väljer du Arbetsflöden och sedan ditt arbetsflöde.

3. Välj Övervaka på arbetsflödesmenyn.

Samla in loggar

Om du vill hämta loggade data om logikappen aktiverar du Application Insights i logikappen om den inte redan är aktiverad.

Nästa steg

• Om Azure Arc-aktiverade Logic Apps