Paketbaserad distribution för Azure Functions

Funktionsappar som hostas på Azure Container Apps distribueras som containerbilder, inte .zip paket. För att skapa och distribuera en bildbaserad funktionsapp, se Create a function app on Azure Container Apps using code.

Skapa ett distributionspaket

I de flesta fall behöver du inte skapa distributionspaketet själv. Dessa verktygsbaserade distributionsmetoder skapar paketet som en del av publiceringsprocessen:

• Azure Functions Core Tools-kommandotfunc azure functionapp publish.
• Visual Studio Code-publicering.
• Visual Studio-utgeving.
• GitHub Actions-distribution, som paketerar den konfigurerade projektvägen.

För Azure-pipelines distribution skapar pipeline-byggstegen .zip arkivet och skickar det till distributionsuppgiftenAzureFunctionApp.

När du behöver arbeta direkt med ett färdigt distributionspaket, skapa paketet genom att använda func pack. Till exempel, skapa paketet själv när du distribuerar genom att använda en extern paket-URL.

Du kan också skapa .zip arkivet manuellt. När du skapar arkivet manuellt, följ dessa krav på paketstruktur.

Krav på distributionspaket

Zip-arkivet som du distribuerar måste innehålla alla filer som behövs för att köra funktionsappen. Du kan manuellt skapa ett zip-arkiv från innehållet i en Functions-projektmapp med hjälp av inbyggda .zip komprimeringsfunktioner eller verktyg som inte kommer från Microsoft.

Arkivet måste innehålla host.json filen i roten för den extraherade mappen. Den valda språkstacken för funktionsappen skapar andra krav:

• .NET (isolerad arbetsmodell)
• .NET (processmodell)
• Java
• JavaScript
• TypeScript
• PowerShell
• Python

En zip-distributionsprocess packar ut .zip arkivets filer och mappar i katalogen wwwroot . Om du inkluderar föräldrakatalogen när du skapar arkivet hittar systemet inte de filer det förväntar sig att se i wwwroot.

Distribuera ett paket

Flex Consumption använder paketdistribution för att lagra ett färdigt paket i appens distributionslagringscontainer. Appen körs direkt från detta paket. Ställ inte in WEBSITE_RUN_FROM_PACKAGE appinställningarna.

Distribuera paketet genom att använda Core Tools, Visual Studio Code eller Azure CLI. Dessa verktyg väljer automatiskt rätt paketimplementeringsbeteende för en Flex Consumption-app.

Dessa verktyg utför en push-distribution genom att skicka paketet till appens distributions-endpoint. För Flex Consumption skickar dessa klienter paketet till /api/publish appens scm värd. När distributionsändpunkten endast är tillgänglig över en privat slutpunkt måste datorn, runnern eller agenten som utför utrullningen ha nätverksanslutning till och DNS-lösning för den privata utrullningsändpunkten. Distributionstjänsten lagrar det bearbetade paketet i den konfigurerade distributionscontainern; att ladda upp ett paket direkt till denna container distribuerar det inte. För att distribuera utan att skicka från den initierande klienten till distributionsterminalen, använd en Bicep- eller ARM-mallutplacering med en paket-URL som distributionstjänsten kan komma åt.

Distribuera med hjälp av Azure CLI

Använd kommandot az functionapp deployment source config-zip för att distribuera ett paket:

az functionapp deployment source config-zip --resource-group <RESOURCE_GROUP> \
  --name <APP_NAME> --src <ZIP_FILE_PATH>

Lägg till --build-remote true när källprojektet kräver en fjärrbyggnation. Begär inte en fjärrbyggd version av ett paket som func pack redan är färdigt att köra, som ett Go-distributionspaket.

För att konfigurera lagring för distribution eller återställa en tidigare distribution, se Skapa och hantera funktionsappar i Flex Consumption-planen.

Distribuera ett paket

Premium-, Dedicated- och Consumption-planappar använder zip-distributions-API:et. Distributionstjänsten utför dessa åtgärder:

• Ta bort filer som finns kvar från tidigare distributioner.
• Kör distributionsskript och andra anpassningar av distributionen.
• Skriv distributionsloggar.
• Synkroniseringsfunktionen triggas.

Distribuera med hjälp av Azure CLI

Använd Azure CLI för att trigga en push-distribution. Push-distribuera en .zip-fil till din funktionsapp genom att använda kommandot az functionapp deployment source config-zip. Om du vill använda det här kommandot måste du använda Azure CLI version 2.0.21 eller senare. Om du vill se vilken Azure CLI-version du använder använder az --version du kommandot .

I följande kommando ersätter du <zip_file_path> platshållaren med sökvägen till platsen för filen .zip. Ersätt <app_name> också med funktionsappens unika namn och ersätt <resource_group> med namnet på resursgruppen.

az functionapp deployment source config-zip -g <resource_group> -n \
<app_name> --src <zip_file_path>

Detta kommando distribuerar projektfiler från .zip-filen till din funktionsapp i Azure och startar om appen.

När du använder Azure CLI på din lokala dator <zip_file_path> är sökvägen till filen .zip på datorn. Du kan också köra Azure CLI i Azure Cloud Shell. När du använder Cloud Shell måste du först ladda upp distributionen .zip fil till Azure Files-kontot som är associerat med Cloud Shell. I så fall <zip_file_path> är lagringsplatsen som ditt Cloud Shell-konto använder. För mer information, se Persistera filer i Azure Cloud Shell.

Distribuera ZIP-fil med REST-API:er

Du kan använda REST API:er för distributionstjänsten för att distribuera .zip-filen till din app i Azure. Om du vill distribuera skickar du en POST-begäran till https://<app_name>.scm.azurewebsites.net/api/zipdeploy. POST-begäran måste innehålla filen .zip i meddelandetexten. Autentiseringsuppgifterna för distribution för din app tillhandahålls i begäran med hjälp av grundläggande HTTP-autentisering. Mer information finns i .zip push-distributionsreferens.

För HTTP BASIC-autentisering behöver du dina autentiseringsuppgifter för App Service-distributionen. Information om hur du anger dina autentiseringsuppgifter för distribution finns i Ange och återställa autentiseringsuppgifter på användarnivå.

Med cURL

I följande exempel används cURL-verktyget för att distribuera en .zip fil. Ersätt platshållarna <deployment_user>, <zip_file_path>och <app_name>. När du uppmanas av cURL skriver du in lösenordet.

curl -X POST -u <deployment_user> --data-binary "@<zip_file_path>" https://<app_name>.scm.azurewebsites.net/api/zipdeploy

Den här begäran utlöser push-distribution från den uppladdade .zip-filen. Du kan granska aktuella och tidigare distributioner med hjälp https://<app_name>.scm.azurewebsites.net/api/deployments av slutpunkten, som du ser i följande cURL-exempel. <app_name> Ersätt återigen med namnet på din app och <deployment_user> med användarnamnet för dina autentiseringsuppgifter för distributionen.

curl -u <deployment_user> https://<app_name>.scm.azurewebsites.net/api/deployments

Asynkron zip-distribution

Du kan få anslutningsavbrottsfel när du distribuerar synkront. Lägg till ?isAsync=true i URL:en för att distribuera asynkront. Du får ett svar så snart zip-filen har laddats upp med en Location rubrik som pekar på url:en för avsökningsbar distributionsstatus. När du avsöker URL:en som anges i Location rubriken får du ett HTTP 202-svar (accepterad) medan processen pågår och ett HTTP 200-svar (OK) när arkivet har expanderats och distributionen har slutförts.

Microsoft Entra-autentisering

Ett alternativ till att använda HTTP BASIC-autentisering för zip-distributionen är att använda en Microsoft Entra-identitet. Microsoft Entra-identitet kan behövas om HTTP BASIC-autentisering är inaktiverat för SCM-webbplatsen.

En giltig Microsoft Entra-åtkomsttoken för användaren eller tjänstens huvudnamn som utför distributionen krävs. En åtkomsttoken kan hämtas med hjälp av Azure CLI:s az account get-access-token kommando. Åtkomsttoken används i autentiseringshuvudet för HTTP POST-begäran.

curl -X POST \
    --data-binary "@<zip_file_path>" \
    -H "Authorization: Bearer <access_token>" \
    "https://<app_name>.scm.azurewebsites.net/api/zipdeploy"

Med PowerShell

I följande exempel används Publish-AzWebapp för att ladda upp .zip-filen. Ersätt platshållarna <group-name>, <app-name>och <zip-file-path>.

Publish-AzWebapp -ResourceGroupName <group-name> -Name <app-name> -ArchivePath <zip-file-path>

Den här begäran utlöser push-distribution från den uppladdade .zip-filen.

Om du vill granska aktuella och tidigare distributioner kör du följande kommandon. Ersätt återigen <deployment-user>platshållarna , <deployment-password>och <app-name> .

$username = "<deployment-user>"
$password = "<deployment-password>"
$apiUrl = "https://<app-name>.scm.azurewebsites.net/api/deployments"
$base64AuthInfo = [Convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes(("{0}:{1}" -f $username, $password)))
$userAgent = "powershell/1.0"
Invoke-RestMethod -Uri $apiUrl -Headers @{Authorization=("Basic {0}" -f $base64AuthInfo)} -UserAgent $userAgent -Method GET

Distribuera genom att använda Bicep eller en mall för Azure Resource Manager

Du kan distribuera ett paket till en Flex Consumption-app som en del av en Bicep- eller Azure Resource Manager (ARM)-mallutplacering. Definiera en Microsoft.Web/sites/extensions resurs som använder tillägget /onedeploy och tillhandahåller URL:en till fjärrpaketet i egenskapen packageUri .

Du måste namnge paketfilen released-package.zip. Functions-värden måste kunna komma åt både den fjärranslutna paketets URL och lagringscontainern för distribution. Att ladda upp paketet direkt till distributionscontainern distribuerar det inte.

För exempel på Bicep- och ARM-mallar, se Definiera Flex Consumption-distributionspaketet.

Distribuera genom att använda en Azure Resource Manager-mall

Du kan använda Azure Resource Manager (ARM)-mallen ZipDeploy-tillägget för att skicka din .zip-fil till din funktionsapp.

Exempel på ZipDeploy ARM-mall

Den här mallen innehåller både en produktions- och mellanlagringsplats och distribueras till den ena eller den andra. Vanligtvis använder du denna mall för att distribuera till staging-platsen och sedan byta för att få ditt nya zip-paket att köras på produktionsplatsen.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "appServiceName": {
      "type": "string"
    },
    "deployToProduction": {
      "type": "bool",
      "defaultValue": false
    },
    "slot": {
      "type": "string",
      "defaultValue": "staging"
    },
    "packageUri": {
      "type": "secureString"
    }
  },
  "resources": [
    {
      "condition": "[parameters('deployToProduction')]",
      "type": "Microsoft.Web/sites/extensions",
      "apiVersion": "2021-02-01",
      "name": "[format('{0}/ZipDeploy', parameters('appServiceName'))]",
      "properties": {
        "packageUri": "[parameters('packageUri')]",
        "appOffline": true
      }
    },
    {
      "condition": "[not(parameters('deployToProduction'))]",
      "type": "Microsoft.Web/sites/slots/extensions",
      "apiVersion": "2021-02-01",
      "name": "[format('{0}/{1}/ZipDeploy', parameters('appServiceName'), parameters('slot'))]",
      "properties": {
        "packageUri": "[parameters('packageUri')]",
        "appOffline": true
      }
    }
  ]
}

Vid den initiala utrullningen deployerar du direkt till produktionsplatsen. Mer information finns i Slot-implementeringar.

Köra funktioner från distributionspaketet

Att köra direkt från distributionspaketet hoppar över att kopiera filer till katalogen wwwroot . Istället monterar Functions-runtimen paketet som en skrivskyddad wwwroot katalog. Den här metoden:

• Minskar problem med filkopieringslåsning.
• Verifierar de filer som körs i din app.
• Förbättrar driftsättningen för Azure Resource Manager.
• Kan minska kallstartstiden, särskilt för JavaScript-appar med stora npm-paketträd.

Flex Consumption-paketkonfiguration

Flex Consumption-appar körs från ett paket som standard. Lägg inte till WEBSITE_RUN_FROM_PACKAGE appinställningarna. Distributionsinställningar, inklusive lagringsbehållaren och dess autentiseringsmetod, är egenskaper för funktionsappens resurs. Mer information finns i Distribution

Premium- och dedikerad paketkonfiguration

Ställ WEBSITE_RUN_FROM_PACKAGE in på 1 att köra direkt från det lokalt distribuerade paketet. Runtime-paketet lagrar paketet i mappen c:\home\data\SitePackages på Windows eller /home/data/SitePackages i mappen på Linux.

Konfiguration av konsumtionspaket

Det stödda WEBSITE_RUN_FROM_PACKAGE värdet beror på operativsystemet:

Överväganden kring paketutplacering

Ha dessa krav och begränsningar i åtanke när du distribuerar och kör din funktionsapp från ett paket:

• Paketet måste använda .zip format. Tar- och gzip-format stöds inte.
• Den maximala paketstorleken är 1 GB. Distributionen använder tillfällig lagring när den packar upp projektfiler, så appen måste också ha tillräckligt med tillfällig lagring. Consumption-planen tillhandahåller 500 MB tillfällig lagring per plan.
• När du kör från ett paket är filerna skrivskyddadewwwroot, även i Azure-portalen.
• Du kan inte använda den lokala cachen när du kör från ett paket.
• Ställ inte in WEBSITE_RUN_FROM_PACKAGE när du begär en fjärrbyggnation. Sätt SCM_DO_BUILD_DURING_DEPLOYMENT=trueistället . På Linux, sätt ENABLE_ORYX_BUILD=trueockså .
• WEBSITE_RUN_FROM_PACKAGE fungerar inte med MSDeploy. Använd istället zip-distribution.

Lägg till inställningen WEBSITE_RUN_FROM_PACKAGE

Det finns flera sätt att lägga till, uppdatera och ta bort funktionsappinställningar:

• På Azure-portalen
• Genom att använda Azure CLI
• Genom att använda Azure PowerShell

Ändringar i funktionsappsinställningarna kräver att funktionsappen startas om.

Kör från ett paket som laddats upp av zip-distribution

Ställ WEBSITE_RUN_FROM_PACKAGE in på 1 innan du distribuerar paketet. Zip-distributions-API:et kopierar paketet till SitePackages mappen istället för att extrahera innehållet till wwwroot. Distributionen skapar också en packagename.txt-fil som identifierar paketet som ska monteras. Efter att appen startat om monteras paketet som skrivskyddad wwwroot katalog. Linux Consumption-appar stöder inte detta inställningsvärde utan måste istället köras från en extern paket-URL.

När distributionen startar om appen avslutas de pågående funktionsexekveringarna. För information om att skriva funktioner som hanterar omstarter säkert, se Skriv funktioner som tillståndsfria.

Kör från en extern paket-URL

Använd en extern paket-URL när du behöver hantera paketlagring själv. Du behöver detta alternativ för att köra ett lokalt byggt paket i en Linux Consumption-app. Det stöds inte på Flex Consumption.

Använd en privat Blob Storage-container och ge funktionsappens hanterade identitet åtkomst till paketet. Använd managed identity eftersom SAS-tokens går ut och kräver underhåll. När du publicerar ett uppdaterat paket måste du manuellt synkronisera triggers. Om du uppdaterar paketet på plats utan att ändra dess URL, starta om funktionsappen innan du synkroniserar triggers.

Manuellt ladda upp ett paket till Azure Blob Storage

1. Skapa ett .zip distributionspaket.

2. Gå till ditt lagringskonto i Azure-portalen.

3. Under Datalagring, välj Behållare och skapa eller välj sedan en privat container.

4. Ladda upp paketet till containern.

5. Välj den uppladdade blobben och kopiera dess URL. Om du inte använder en hanterad identitet, generera istället en SAS-URL.

6. I din funktionsapp, expandera Inställningar, välj Miljövariabler och välj sedan Lägg till på fliken Appinställningar .

7. Lägg till en inställning med WEBSITE_RUN_FROM_PACKAGE paketets URL som värde.

8. Applicera ändringarna, starta om appen och synkronisera triggers manuellt.

Hämta ett paket från Azure Blob Storage genom att använda en managed identity

Du kan konfigurera Azure Blob Storage för att auktorisera begäranden med Microsoft Entra ID. Den här konfigurationen innebär att du i stället för att generera en SAS-nyckel med förfallodatum kan förlita dig på programmets hanterade identitet.

Som standard används appens systemtilldelade identitet. Om du vill ange en användartilldelad identitet kan du ange appinställningen WEBSITE_RUN_FROM_PACKAGE_BLOB_MI_RESOURCE_ID till resurs-ID för den identiteten. Inställningen kan också ha SystemAssigned som värde, vilket är likvärdigt med att utelämna inställningen.

Så här aktiverar du att paketet hämtas med hjälp av identiteten:

1. Kontrollera att bloben har konfigurerats för privat åtkomst.

2. Tilldela identiteten rollen Storage Blob Data Reader med omfång över paketbloben. Mer information om hur du skapar rolltilldelningen finns i Tilldela en Azure roll för åtkomst till blobdata.

3. Ange programinställningen WEBSITE_RUN_FROM_PACKAGE till paketets blob-URL. Den här URL:en är vanligtvis av formuläret https://<storage-account-name>.blob.core.windows.net/<container-name>/<path-to-package> eller liknande.

4. Om du vill ange en användartilldelad identitet kan du ange appinställningen WEBSITE_RUN_FROM_PACKAGE_BLOB_MI_RESOURCE_ID till resurs-ID för den identiteten. Inställningen kan också acceptera SystemAssigned som ett värde, även om det är samma sak som att utelämna inställningen helt och hållet. Ett resurs-ID är en standardrepresentation för en resurs i Azure. För en användartilldelad hanterad identitet blir det /subscriptions/subid/resourcegroups/rg-name/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity-name. Resurs-ID för en användartilldelad hanterad identitet kan hämtas iInställningar>Egenskaper>ID för den användartilldelade hanterade identiteten.

Justering av driftsättning

Distributionsprocessen förutsätter att den .zip fil som du skickar innehåller en färdig app. Som standard körs inga anpassningar. Om du vill aktivera samma byggprocesser som du får med kontinuerlig integrering lägger du till följande i dina programinställningar:

SCM_DO_BUILD_DURING_DEPLOYMENT=true

När du använder .zip push-distribution är den här inställningen false som standard. Standardvärdet är sant för distributioner av kontinuerlig integration. När värdet är true används dina distributionsrelaterade inställningar under distributionen. Du kan konfigurera de här inställningarna antingen som appinställningar eller i en .deployment-konfigurationsfil som finns i roten för din .zip-fil. Mer information finns i Inställningar för lagringsplats och distribution i distributionsreferensen.

Ladda ned funktionsappfiler

Om du behöver exakt det paket som din app kör just nu, ladda ner det från Blob Storage-containern som är konfigurerad för appens distributioner:

1. På din funktionsappsida i Azure-portalen, expandera Inställningar och välj sedan Distributionsinställningar.

2. Under Applikationspaketets plats, notera vilket lagringskonto och vilken container som används för distributioner.

3. Gå till det lagringskontot, expandera Datalagring och välj sedan Containrar.

4. Välj distributionscontainern, välj det aktuella paketet och välj sedan Ladda ner.

Det nedladdade paketet innehåller det byggda app-innehållet som du distribuerade, vilket kan skilja sig från ditt källprojekt. Varje distribution skriver över det aktuella paketet, och distributionscontainern ger ingen distributionshistorik.

För appar som distribueras med CI/CD, behåll källkodsprojektet i versionskontroll och behåll färdiga byggartefakter enligt din versionsbevarandepolicy. Använd en kvarhållen artefakt för att omdistribuera en specifik release. Använd paketet i distributionscontainern när du behöver exakt det paket som appen kör just nu eller när den ursprungliga artefakten inte längre är tillgänglig.

Ladda ned funktionsappfiler

Om du har skapat dina funktioner med hjälp av redigeraren i Azure Portal kan du ladda ned ditt befintliga funktionsappsprojekt som en .zip fil på något av följande sätt:

https://<FUNCTION_APP>.scm.azurewebsites.net/api/zip/site/wwwroot/

För appar som distribueras med CI/CD, behåll källkodsprojektet i versionskontroll och behåll färdiga byggartefakter enligt din versionsbevarandepolicy. Ett källarkiv som laddas ner från ett repository är inte ett distributionspaket. Använd ditt distributionsflöde för att bygga och distribuera projektet.