Distribueringstekniker i Azure Functions

Utlösarsynkronisering

När en distribution lägger till, tar bort eller ändrar en funktion eller dess triggerkonfiguration måste Functions-infrastrukturen uppdatera triggermetadata för funktionsappen. Denna synkronisering sker automatiskt för många distributionsteknologier. I vissa fall måste du dock synkronisera utlösarna manuellt.

Du måste alltid synkronisera utlösare manuellt när du använder följande distributionsalternativ:

• Url för externt paket
• Lokal Git
• FTPS

Du kan synkronisera utlösare manuellt på något av följande sätt:

• Starta om funktionsappen i Azure-portalen. Functions-värden utför en synkronisering av bakgrundsutlösare när programmet startas.

• az rest Använd kommandot för att skicka en HTTP POST-begäran som anropar API:etsyncfunctiontriggers, som i det här exemplet:

  az rest --method post --url https://management.azure.com/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Web/sites/<APP_NAME>/syncfunctiontriggers?api-version=2016-08-01
  

Tänk på följande när det gäller åtgärden för synkroniseringsutlösare:

• Du måste starta om funktionsappen manuellt när du distribuerar en uppdaterad version av distributionspaketet med hjälp av samma externa paket-URL.
• För appar som körs i en förbruknings- eller Elastic Premium-plan måste du även synkronisera utlösare manuellt i följande scenarier:
  • När distributioner använder en extern paket-URL med en resource manager-baserad distribution med hjälp av ARM-mallar eller Bicep- eller Terraform-filer.
  • När du uppdaterar distributionspaketet på plats genom att använda samma externa paket-URL.
• När du lägger till nätverksbegränsningar i en befintlig funktionsapp måste du garantera anslutningen till standardinställningen för värdlagringskontot i appinställningen AzureWebJobsStorage . Mer information finns i Så här använder du ett skyddat lagringskonto med Azure Functions.

Fjärrbygge

Du kan begära Azure Functions att utföra en fjärrversion av kodprojektet under distributionen. I dessa scenarier begär du en fjärrversion i stället för att bygga lokalt:

• Du distribuerar en app till en Linux-baserad funktionsapp som du har utvecklat på en Windows dator. Den här situationen är ofta fallet för Python apputveckling. Du kan få felaktiga bibliotek när du skapar distributionspaketet lokalt på Windows.
• Projektet har beroenden för ett anpassat paketindex.
• Du vill minska storleken på distributionspaketet.

Hur du begär en fjärrversion beror på om din app körs i Azure på Windows eller Linux.

Följande överväganden gäller när du använder fjärrversioner under distributionen:

• Fjärrversioner stöds för funktionsappar som körs på Linux i förbrukningsplanen. Dock är distributionsalternativen begränsade för dessa appar eftersom de inte har någon följeslagarplats.
• Funktionsappar som körs på Linux i ett Elastic Premium-abonnemang eller i ett dedikerat (App Service)-abonnemang har en kompletterande distributionssida, men den är begränsad jämfört med Windows.
• Ställ inte in WEBSITE_RUN_FROM_PACKAGE när du begär en fjärrbyggnation. För Linux Consumption, Elastic Premium och dedikerade planappar aktiveras istället fjärrbyggande genom att använda distributionsinställningarna som beskrivs i Linux-fliken . Distributionsprocessen kan paketera byggresultatet och konfigurera appen att köras från det paketet.
• Du kan ha problem med fjärrbygge när din app skapades innan funktionen gjordes tillgänglig (1 augusti 2019). För äldre appar skapar du antingen en ny funktionsapp eller kör az functionapp update --resource-group <RESOURCE_GROUP_NAME> --name <APP_NAME> för att uppdatera funktionsappen. Det här kommandot kan ta två försök att lyckas.

Fjärrbygge

För Flex Consumption begär du en fjärrbyggnation genom att skicka en fjärrbyggparameter när du startar driftsättningen. Du konfigurerar inte fjärrbyggandet genom att använda applikationsinställningar. För Core Tools och Visual Studio Code efterfrågas alltid en fjärrbyggnation när du distribuerar en Python-app. Mer information finns i Distribution.

Lagring av appinnehåll

Flex Consumption lagrar det aktuella paketet i den konfigurerade distributionslagringscontainern. Som standard finns denna container i samma konto som används av AzureWebJobsStorage, men du kan konfigurera ett annat distributionslagringskonto.

Lagring av appinnehåll

Beroende på distributionsteknologin kan ditt appinnehåll lagras i appens filsystem, i en Azure Files-innehållsdelning eller på en extern paket-URL. Gå igenom var appinnehåll lagras för varje distributionsteknologi i nästa avsnitt.

Skyddade virtuella nätverk

När din funktionsapp har privata endpoints aktiverade och offentlig nätverksåtkomst är inaktiverad, är deployment-endpointen inte offentligt tillgänglig. Push-distributionsverktyg, inklusive Core Tools, Visual Studio Code, Azure CLI, GitHub Actions och Azure-pipelines, skickar paket till denna endpoint. Maskinen, löparen eller agenten som utför utrullningen måste ha både nätverksanslutning och DNS-upplösning för den privata utrullningsändpunkten.

Du kan tillhandahålla denna koppling på följande sätt:

• För Azure-pipelines, använd en självhostad agent på ett anslutet nätverk eller konfigurera en hanterad DevOps-agentpool med nätverk.
• För GitHub Actions, använd en självhostad runner på ett anslutet nätverk eller konfigurera en GitHub-hostad runner med Azure privat nätverk.
• Koppla din utvecklingsmaskin genom att använda en punkt-till-plats VPN, site-to-site VPN eller ExpressRoute.

Distributionsresursen kan finnas i samma virtuella nätverk eller i ett nätverk som har routing- och DNS-anslutning till den privata slutpunkten, såsom ett peerat virtuellt nätverk.

Resource Manager-baserade paketutplaceringar skickar inte paketet från den initierande klienten till distributionsändpunkten. Istället hämtar distributionstjänsten paketet från URL:en som tillhandahålls i distributionsresursen. Paketets URL och distributionslagringen måste vara tillgängliga för distributionstjänsten. För Flex Consumption, se Deploy by using Bicep eller en Azure Resource Manager-mall.

Mer information om hur du konfigurerar funktionsappen i ett virtuellt nätverk finns i Så här konfigurerar du Azure Functions med ett virtuellt nätverk.

Lagring av appinnehåll och nätverk

Azure Functions på Azure Container Apps distribuerar din app som en containerimage. Avbilden lagras i ett containerregister och nätverket hanteras av Container Apps-miljön. För mer information, se Översikt över Azure Functions på Azure Container Apps och Nätverk i Azure Container Apps.

Flex Consumption-paketets utbyggnad

Paketdistribution är den enda koddistributionsteknologin som stöds för appar på en Flex Consumption-plan. Distributionsprocessen lagrar ett färdigt .zip-paket i appens distributionscontainer, och funktionsappen körs direkt från det paketet.

Så här använder du den: Distribuera med hjälp av publiceringsfunktionen Visual Studio Code eller från kommandoraden med hjälp av Azure Functions Core Tools eller Azure CLI. Azure DevOps-uppgiften och GitHub-åtgärden väljer på liknande sätt rätt paketdistributionsbeteende när de upptäcker en Flex Consumption-app.

När du skapar en Flex Consumption-app måste du ange en container för distributionslagring (blob) samt en autentiseringsmetod för den. Som standard används samma lagringskonto som AzureWebJobsStorage-anslutningen, med en reťazec pripojenia som autentiseringsmetod. Därför konfigureras dina distributionsinställningar under appskapandetiden utan behov av programinställningar.

När ska du använda den: Använd paketutrullning för alla Flex Consumption-koddistributioner. Ingen annan koddistributionsteknologi stöds.

Var appinnehåll lagras: När du skapar en Flex Consumption-funktionsapp anger du en distributionslagringscontainer. Distributionstjänsten lagrar det bearbetade, färdiga paketet i denna container. Push-distributionsverktyg skickar först källpaketet till appens distributionsendpoint; de laddar inte upp direkt till distributionscontainern. För att ändra lagringsplatsen, öppna sidan för distributionsinställningar i Azure-portalen eller använd Azure CLI.

Det underliggande plattforms-API:et identifieras ibland som OneDeploy. Definitioner av infrastruktur som kod exponerar denna implementation genom det bokstavliga /onedeploy resursnamnet. Du behöver inte välja eller konfigurera detta API när du distribuerar med stöd av utvecklingsverktyg eller CI/CD-leverantörer.

ZIP-utplacering

ZIP-distribution är standard- och rekommenderad distributionsteknik för funktionsappar på Consumption, Elastic Premium och Dedicated (App Service)-planerna. Slutresultatet är ett färdigt .zip paket som funktionsappen körs på. Den skiljer sig från den externa paket-URL:en eftersom plattformen ansvarar för fjärrbyggande och lagring av appinnehåll.

Hur man använder det: Distribuera genom att använda ditt föredragna klientverktyg: Visual Studio Code, Visual Studio, eller från kommandoraden genom att använda Azure Functions Core Tools eller Azure CLI. Azure DevOps-uppgiften och GitHub Action använder på liknande sätt ZIP-distribution.

När du använder ZIP-distribution kan du ställa in att din app ska köras från paketet. Om du vill köra från paketet anger du värdet för programinställningen WEBSITE_RUN_FROM_PACKAGE till 1. Vi rekommenderar ZIP-distribution. Det ger snabbare laddningstider för dina applikationer, och det är standard för Visual Studio Code, Visual Studio och Azure CLI.

När ska du använda det: ZIP-distribution är standard- och rekommenderad distributionsteknik för funktionsappar på Windows Consumption, Windows och Linux Elastic Premium samt Windows och Linux App Service (Dedicated).

Var appinnehåll lagras: Appinnehåll från en ZIP-distribution lagras som standard i filsystemet, vilket Azure kan säkerhetskopiera med Azure Files från det lagringskonto du anger när du skapar funktionsappen. I Linux-förbrukning sparas appinnehållet i stället på en blob i lagringskontot som anges av appinställningen AzureWebJobsStorage , och appinställningen WEBSITE_RUN_FROM_PACKAGE får värdet för blob-URL:en.

Url för externt paket

Använd en extern paket-URL när du vill kontrollera hur distributioner sker manuellt. Du ansvarar för att ladda upp ett färdigt .zip-paket som innehåller ditt byggda appinnehåll till bloblagring och referera till denna externa URL som applikationsinställning i din funktionsapp. När din app startar om hämtar den paketet, monterar det och kör från paketet.

Så här använder du det: Lägg till WEBSITE_RUN_FROM_PACKAGE i dina programinställningar. Värdet för den här inställningen ska vara en blob-URL som pekar på platsen för det specifika paket som du vill att appen ska köra. Du kan lägga till inställningar antingen i portalen eller av med hjälp av Azure CLI.

Om du använder Azure Blob Storage kan din funktionsapp komma åt containern antingen genom en hanterad identitetsbaserad anslutning eller med en shared access-signatur (SAS). Det alternativ du väljer påverkar vilken typ av URL du använder som värde för WEBSITE_RUN_FROM_PACKAGE. Hanterad identitet rekommenderas för övergripande säkerhet och eftersom SAS-token upphör att gälla och måste underhållas manuellt.

När du distribuerar paketfilen som en funktionsapp refererar till måste du synkronisera utlösare manuellt, inklusive den inledande distributionen. När du ändrar innehållet i paketfilen och inte själva URL:en måste du även starta om funktionsappen för att synkronisera utlösare. För konfigurationssteg, se Kör från en extern paket-URL.

När du ska använda den: Extern paket-URL är den enda distributionsmetod som stöds för appar som körs i Linux-förbrukningsplanen när du inte vill att en fjärrversion ska ske. Den här metoden är också den rekommenderade distributionstekniken när du skapa din app utan Azure Files. För skalbara appar som körs på Linux bör du i stället överväga Flex Consumption plan för hosting.

Var appinnehåll lagras: Du ansvarar för att ladda upp appinnehållet till Blob Storage. Du kan använda vilket Blob Storage-konto som helst, men Azure Blob Storage rekommenderas.

Docker-container

Du kan distribuera en funktionsapp som körs i en Linux-container.

Så här använder du den:Skapa dina funktioner i en Linux-container distribuera sedan containern till en Premium- eller Dedikerad plan i Azure Functions eller en annan containervärd. Använd Azure Functions Core Tools för att skapa en anpassad Dockerfile för ditt projekt som du använder för att skapa en containerbaserad funktionsapp. Du kan använda containern i följande distributioner:

• Distribuera till de Azure Functions-resurser som du skapar i Azure-portalen. Mer information finns i Azure portal create using containers.
• Distribuera till de resurser för Azure Functions som du skapar från kommandoraden. Kräver antingen en Premium- eller Dedikerad (App Service)-plan. Mer information finns i Skapa din första containerbaserade Azure Functions.
• Distribuera till ett Kubernetes-kluster. Du kan distribuera till ett kluster med hjälp av Azure Functions Core Tools. Använd kommandot func kubernetes deploy.

När du ska använda den: Använd alternativet Docker-container när du behöver mer kontroll över Linux-miljön där funktionsappen körs och var containern finns. Den här distributionsmekanismen är endast tillgänglig för funktioner som körs i Linux.

Var appinnehåll lagras: Du lagrar appinnehåll i det angivna containerregistret som en del av avbildningen.

Källkontroll

Du kan aktivera kontinuerlig integrering mellan din funktionsapp och en källkodslagringsplats. När du aktiverar källkontroll utlöser en uppdatering av kod i den anslutna källlagringsplatsen distributionen av den senaste koden från lagringsplatsen. För mer information, se Kontinuerlig distribution för Azure Functions.

Så här använder du det: Det enklaste sättet att konfigurera publicering från källkontroll är från Distributionscenter i området Funktioner i portalen. Mer information finns i Kontinuerlig distribution för Azure Functions.

När du ska använda den: Att använda källkontroll är bästa praxis för team som samarbetar i sina funktionsappar. Källkontroll är ett bra distributionsalternativ som möjliggör mer avancerade distributionspipelines. Vanligtvis aktiverar du källkontroll på en mellanlagringsplats, som du kan växla till produktion efter validering av uppdateringar från lagringsplatsen. Mer information finns i Azure Functions distributionsplatser.

Var appinnehåll lagras: Källkontrollsystemet lagrar appinnehållet. Appens filsystern lagrar en lokalt klonad och byggd appinnehållsstruktur, som kanske stöds av Azure Files från det lagringskonto som specificerades när funktionsappen skapades.

Lokal Git

Använd lokal Git för att pusha kod från din lokala dator till Azure Functions med hjälp av Git.

Så här använder du den: Följ anvisningarna i Lokal Git-distribution till Azure App Service.

När du ska använda den: Undvik att använda distributionsmetoder som kräver ytterligare steg för att synkronisera utlösare manuellt för att minska risken för fel. Använd zip-distribution när det är möjligt.

Var appinnehåll lagras: Filsystemet lagrar appinnehåll. Filsystemet kan backas upp av Azure Files från det lagringskonto du anger när du skapar funktionsappen.

FTPS

Du kan använda FTPS för att direkt överföra filer till Azure Functions, men använd inte denna distributionsmetod. När du inte planerar att använda FTPS, inaktivera det. För att lära dig hur du gör i Azure-portalen, se Enforce FTPS.

Så här använder du den: Följ anvisningarna i FTPS-distributionsinställningarna för att hämta den URL och de autentiseringsuppgifter som du kan använda för att distribuera till funktionsappen med hjälp av FTPS.

När du ska använda den: Undvik att använda distributionsmetoder som kräver ytterligare steg för att synkronisera utlösare manuellt för att minska risken för fel. Använd zip-distribution när det är möjligt.

Var appinnehåll lagras: Appinnehåll lagras i filsystemet. FTP/FTPS-distributioner misslyckas när appens filsystem stöds av Azure Files i standardvärdskontots lagring. FTP/FTPS misslyckas med Azure Files som monterad lagring på grund av FTP-begränsningar.

Redigering i portalen

I den portalbaserade redigeraren kan du direkt redigera de filer som finns i funktionsappen (i princip distribuera varje gång du sparar ändringarna).

Så här använder du den: Om du vill redigera dina funktioner i Azure-portalen måste du skapa dina funktioner i portalen. För att bevara en enda källa till sanning blir din funktion skrivskyddad och förhindrar fortsatt redigering i portalen om du använder någon annan distributionsmetod. Om du vill återgå till ett tillstånd där du kan redigera dina filer i Azure portalen kan du manuellt återställa redigeringsläget till Read/Write och ta bort eventuella distributionsrelaterade programinställningar (till exempel WEBSITE_RUN_FROM_PACKAGE).

När du använder den: Portalen är ett bra sätt att komma igång med Azure Functions. På grund av utvecklingsbegränsningar i Azure-portalen bör du använda något av följande klientverktyg för mer avancerat utvecklingsarbete:

• Visual Studio Code
• Azure Functions Core Tools (kommandorad)
• Visual Studio

Where appinnehåll lagras: Appinnehåll lagras i filsystemet, som kan backas upp av Azure Files från lagringskontot som du anger när du skapar funktionsappen.

Containerbildsdistribution

Azure Functions på Azure Container Apps distribuerar din kod som en containerimage. Du kan distribuera från ett kodprojekt genom att använda den hanterade Container Apps-upplevelsen, eller distribuera en anpassad image när du behöver kontroll över bildens innehåll. För mer information, se Skapa en funktionsapp i Azure Container Apps med hjälp av kod och Översikt över Azure Functions i Azure Container Apps.

Funktioner som körs för närvarande stoppas när du distribuerar ny kod. Efter att distributionen är klar laddas den nya koden in och börjar behandla förfrågningar. Detta våldsamma uppsägningsbeteende kallas en återupptagningsstrategi. För driftsättningar med nästan inget driftstopp, använd distributionsfack.

Granska Förbättera prestanda och tillförlitlighet för Azure Functions för att lära dig hur du skriver tillståndslösa och defensiva funktioner.

Standardbeteendet använder återskapa-strategin, som stoppar funktioner som för närvarande körs under distribution. Flex Consumption stöder två strategier för webbplatsuppdateringar. Du kan konfigurera löpande uppdateringar för distributioner med noll driftstopp.

Azure Container Apps hanterar programuppdateringar med hjälp av revisioner. För mer information om hur man kontrollerar hur nya versioner tar emot trafik, se Uppdatera och distribuera ändringar i Azure Container Apps.

Distributionsplatser

Flex Consumption stöder inte distributionsslots. För driftsättningar utan driftstopp, konfigurera rullande uppdateringar.

Distributionsplatser

När du distribuerar funktionsappen till Azure kan du distribuera till ett separat distributionsfack i stället för direkt till produktion. Att distribuera till ett distributionsfack och sedan växla till produktion efter verifiering är det rekommenderade sättet att konfigurera kontinuerlig distribution.

Hur du distribuerar till ett fack beror på vilket distributionsverktyg du använder. Till exempel, när du använder Azure Functions Core Tools, anger du alternativet --slot för att ange namnet på en specifik slot för kommandot func azure functionapp publish.

Mer information om distributionsplatser finns i dokumentationen Azure Functions Deployment Slots.