Bygg och distribuera TypeScript Azure Functions-appar

Azure Functions stöder flera byggalternativ för att publicera dina TypeScript-appar till Azure. Välj din byggmetod baserat på din lokala miljö, appberoenden, TypeScript-kompileringskrav och körtidsbehov.

Val av byggmetod

För privata npm-paket eller anpassade register, se Anpassade beroenden.

Paketera din app för distribution

När du distribuerar din TypeScript-funktionsapp till Azure måste ditt distributionspaket uppfylla dessa krav:

• JavaScript-utdata krävs: Azure Functions kör JavaScript, så TypeScript måste kompileras före eller under driftsättning.

• Rotnivå host.json: Kontrollera att en enskild host.json fil finns i roten för distributionspaketet, inte kapslad i en undermapp.

• package.json main fält: Functions-runtimen läser detta fält vid uppstart för att lokalisera och indexera dina funktioner. Den måste peka på din kompilerade JavaScript-ingångspunkt (till exempel, dist/src/index.js).

• Uteslut utvecklingsfiler: Använd en fil för att utesluta .funcignore onödiga filer från distribution, som i detta exempel:

  .git/
  .vscode/
  local.settings.json
  test/
  .env
  tsconfig.json
  src/
  node_modules/
  

Tänk också på dessa kompromisser när du planerar din utplacering:

• Byggmiljön måste matcha produktionen: Beroenden med inbyggda binärfiler måste byggas för Linux x64-arkitektur. Fjärrbyggnationen hanterar detta automatiskt; för lokal byggnation, överväg att använda Docker eller en containeriserad byggmiljö.
• Distributionspaketets storlek påverkar kallstart: Stora beroendeuppsättningar ökar kallstartslatens eftersom körtiden måste ladda varje fil individuellt. Att paketera din app i färre filer med verktyg som esbuild eller webpack kan avsevärt minska starttiden.
• Fjärrbygget har tidsbegränsningar: Om installation av beroende eller TypeScript-kompilering överskrider plattformsgränser misslyckas bygget. Använd en lokal build med förbyggda beroenden för stora projekt.
• Modulinitiering har tidsbegränsningar: Node.js modulladdning och funktionsindexering vid uppstart är tidsbegränsade. Minska importen på högsta nivå eller använd dynamiska importer när det är möjligt.

Lokal version

Om du inte uttryckligen begär en fjärrbyggnation installerar din maskin beroenden och kompilerar TypeScript. Du paketerar och distribuerar sedan hela det kompilerade projektet och beroendena lokalt till din funktionsapp.

Lokal build resulterar i en större paketuppladdning men ger dig full kontroll över byggprocessen och säkerställer kompatibilitet med din utvecklingsmiljö.

För TypeScript-projekt som använder lokal byggnation:

1. Prekompilera TypeScript: Kompiliera din TypeScript-kod lokalt innan du distribuerar.
2. Installera beroenden: Kör npm install eller yarn install installera beroenden lokalt.
3. Byggverifiering: Se till att dina byggresultat fungerar korrekt i din lokala miljö.
4. Distribuera kompilerad JavaScript-kod: Distribuera den kompilerade JavaScript-koden tillsammans med sina beroenden.

Exempel på byggkommandon för lokal byggnation:

# Install dependencies
npm install

# Compile TypeScript
npm run build
# or
tsc

# Deploy with local build (no remote compilation)
func azure functionapp publish <APP_NAME> --no-build

Du kan konfigurera följande verktyg för att använda lokal build:

• Azure Functions Core Tools: använd func azure functionapp publish med --no-build flaggan.
• AZ CLI:az functionapp deployment source config-zip
• Kontinuerlig leverans med hjälp av GitHub Actions: ange parametern remote-build till false för Flex Consumption-planen eller ange scm-do-build-during-deployment och enable-oryx-build till false för Dedikerade planer.

Fjärrbygge

När du använder fjärrbyggnation hanterar Functions-plattformen paketinstallation, TypeScript-kompilering och säkerställer kompatibilitet med fjärrmiljön.

Genom att använda fjärrbyggnation får du ett mindre distributionspaket eftersom du inte behöver inkludera node_modules eller kompilera JavaScript-filer.

När du distribuerar TypeScript-projekt med hjälp av fjärrbyggande:

1. Automatisk detektering: Plattformen upptäcker TypeScript-projekt genom närvaron av tsconfig.json.
2. Kompilering: Plattformen kompilerar TypeScript-filer genom att använda ditt projekts TypeScript-konfiguration.
3. Beroendeinstallation: Plattformen installerar både dependencies och devDependencies från package.json, eftersom byggtidspaket som typescript behövs för kompilering.
4. Optimering: Plattformen inkluderar endast nödvändiga filer i det slutliga distributionspaketet.

Du kan använda fjärrbyggande när du publicerar din TypeScript-app genom att använda dessa verktyg:

• Azure Functions Core Tools: kommandot func azure functionapp publish kräver flaggan --build-remote=true för att möjliggöra fjärrbyggande för Node.js appar.
• AZ CLI:az functionapp deployment source config-zip kräver flaggan --build-remote=true för att aktivera fjärrbyggande för Node.js appar.
• Visual Studio Code: Kommandot Azure Functions: Deploy to Azure... använder alltid en fjärrversion.
• Kontinuerlig leverans med GitHub Actions: Åtgärden Azure/functions-action@v1 använder fjärrbygge när parametern remote-build är inställd på true för Flex Consumption-planen eller när scm-do-build-during-deployment och enable-oryx-build är inställd på true för dedikerade planer.

Information om hur du aktiverar fjärrbygge för andra scenarier, till exempel Kontinuerlig leverans med Azure-pipelines, finns i Aktivera fjärrversion.

Anpassade beroenden

Azure Functions stödjer både anpassade och privata npm-beroenden genom att använda anpassade npm-register, privata paket eller lokala paket.

Fjärrbygg med anpassat npm-register

När dina privata paket finns tillgängliga i ett anpassat npm-register kan du begära en fjärrbyggnation efter att ha konfigurerat registerplatsen.

För att använda ett eget register, skapa en .npmrc fil i din projektrot:

registry=https://your-private-registry.com/
//your-private-registry.com/:_authToken=${NPM_TOKEN}

Lokala paket och privata moduler

Lokala paket och privata moduler stöds vid byggande av TypeScript Azure Function-appar.

För att inkludera lokala paket med fjärrbyggande, referera till dem i din package.json fil:

{
  "dependencies": {
    "@azure/functions": "^4.0.0",
    "my-private-package": "file:../my-private-package",
    "another-local-package": "file:./packages/local-lib"
  }
}

För att inkludera lokala beroenden med lokal byggnation, installera beroendena lokalt och distribuera med fjärrbyggandet inaktiverat:

# Install all dependencies including local ones
npm install

# Build your TypeScript project
npm run build

# Publish with local build
func azure functionapp publish <APP_NAME> --no-build

Använd workspace-paket

För monorepo- eller npm-arbetsytor, referera till delade paket genom att använda npm-arbetsytor i din package.json fil:

{
  "name": "functions-app",
  "dependencies": {
    "@azure/functions": "^4.0.0",
    "@mycompany/shared-lib": "workspace:*"
  },
  "workspaces": [
    "packages/*"
  ]
}

Paketera innan utrullning

Använd paketeringsverktyg som webpack, esbuild eller rollup för att skapa ett enda paket innan driftsättning:

# Bundle your application
npm run bundle

# Deploy the bundled output
func azure functionapp publish <APP_NAME> --no-build

Relaterade artiklar

• Azure Functions utvecklarreferensguide för Node.js appar
• Implementeringstekniker i Azure Functions
• Arbeta med Azure Functions Core Tools