Zip-distribution för Azure Functions

Artikel
07/18/2024

I den här artikeln beskrivs hur du distribuerar dina funktionsappsprojektfiler till Azure från en .zip -fil (komprimerad). Du lär dig hur du gör en push-distribution, både med hjälp av Azure CLI och med hjälp av REST-API:erna. Azure Functions Core Tools använder även dessa distributions-API:er när du publicerar ett lokalt projekt till Azure.

Zip-distribution är också ett enkelt sätt att köra dina funktioner från distributionspaketet. Mer information finns i Köra dina funktioner från en paketfil i Azure.

Azure Functions har ett komplett utbud av alternativ för kontinuerlig distribution och integrering som tillhandahålls av Azure App Service. Mer information finns i Kontinuerlig distribution för Azure Functions.

För att påskynda utvecklingen kan det vara enklare att distribuera funktionsappens projektfiler direkt från en .zip fil. .ZIP-distributions-API:et tar innehållet i en .zip-fil och extraherar innehållet till mappen i funktionsappen wwwroot . Den här .zip fildistributionen använder samma Kudu-tjänst som driver kontinuerliga integreringsbaserade distributioner, inklusive:

Borttagning av filer som har lämnats över från tidigare distributioner.
Distributionsanpassning, inklusive körning av distributionsskript.
Distributionsloggar.
Funktionsutlösare för synkronisering i en funktionsapp för förbrukningsplan .

Mer information finns i distributionsreferensen för .zip.

Viktigt!

När du använder .zip distribution tas alla filer från en befintlig distribution som inte finns i .zip-filen bort från funktionsappen.

Krav för distribution .zip fil

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

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

Viktigt!

För språk som genererar kompilerade utdata för distribution ska du komprimera innehållet i utdatamappen som du planerar att publicera och inte hela projektmappen. När Functions extraherar innehållet i zip-arkivet host.json måste filen finnas i paketets rot.

En zip-distributionsprocess extraherar zip-arkivets filer och mappar i wwwroot katalogen. Om du inkluderar den överordnade katalogen när du skapar arkivet hittar systemet inte de filer som förväntas visas i wwwroot.

Distribuera med hjälp av Azure CLI

Du kan använda Azure CLI för att utlösa en push-distribution. Push-distribuera en .zip-fil till funktionsappen med hjälp av 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 du kommandot az --version.

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>

Det här kommandot distribuerar projektfiler från den nedladdade .zip-filen till din funktionsapp i Azure. Sedan startas appen om. Om du vill visa listan över distributioner för den här funktionsappen måste du använda REST-API:erna.

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. Mer information finns i Spara 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 referensen för .zip push-distribution.

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

När du distribuerar synkront kan du få fel som rör tidsgränser för anslutningar. Lägg till ?isAsync=true i URL:en för att distribuera asynkront. Du får ett svar så snart zip-filen laddas 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 (godkänt) 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 med hjälp av ARM-mall

Du kan använda ZipDeploy ARM-malltillägget för att skicka din .zip-fil till funktionsappen.

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 den här mallen för att distribuera till mellanlagringsplatsen och sedan växla 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
      }
    }
  ]
}

För den första distributionen distribuerar du direkt till produktionsplatsen. Mer information finns i Fackdistributioner.

Köra funktioner från distributionspaketet

Du kan också välja att köra dina funktioner direkt från distributionspaketfilen. Den här metoden hoppar över distributionssteget för att kopiera filer från paketet till katalogen i funktionsappen wwwroot . I stället monteras paketfilen av Functions-körningen och innehållet i wwwroot katalogen blir skrivskyddat.

Zip-distributionen integreras med den här funktionen, som du kan aktivera genom att ange inställningen för funktionsappen WEBSITE_RUN_FROM_PACKAGE till värdet 1. Mer information finns i Kör dina funktioner från en distributionspaketfil.

Anpassning av distribution

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 gäller för distributioner av kontinuerlig integrering. 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 har skapat dina funktioner med hjälp av redigeraren i Azure-portalen kan du ladda ned ditt befintliga funktionsappsprojekt som en .zip fil på något av följande sätt:

Från Azure-portalen:
1. Logga in på Azure-portalen och gå sedan till funktionsappen.
2. På fliken Översikt väljer du Ladda ned appinnehåll. Välj dina nedladdningsalternativ och välj sedan Ladda ned.
  
  Den nedladdade .zip filen är i rätt format för att publiceras om till funktionsappen med hjälp av .zip push-distribution. Portalnedladdningen kan också lägga till de filer som behövs för att öppna funktionsappen direkt i Visual Studio.
Använda REST-API:er:

Använd följande GET API för distribution för att ladda ned filerna från projektet <function_app> :
```
https://<function_app>.scm.azurewebsites.net/api/zip/site/wwwroot/
```
Inklusive /site/wwwroot/ ser till att zip-filen endast innehåller projektfilerna för funktionsappen och inte hela webbplatsen. Om du inte redan är inloggad i Azure uppmanas du att göra det.

Du kan också ladda ned en .zip fil från en GitHub-lagringsplats. När du laddar ned en GitHub-lagringsplats som en .zip fil lägger GitHub till en extra mappnivå för grenen. Den här extra mappnivån innebär att du inte kan distribuera .zip filen direkt när du laddade ned den från GitHub. Om du använder en GitHub-lagringsplats för att underhålla din funktionsapp bör du använda kontinuerlig integrering för att distribuera din app.

Nästa steg

Köra dina funktioner från en paketfil i Azure

Dela via