Compila e distribuisci app TypeScript Funzioni di Azure

Funzioni di Azure supporta molteplici opzioni di build per pubblicare le tue app TypeScript su Azure. Scegli il tuo metodo di build in base all'ambiente locale, alle dipendenze dell'app, ai requisiti di compilazione TypeScript e alle esigenze di runtime.

Scelta di un metodo di costruzione

Fattore Costruzione locale (consigliata) Configurazione remota
Migliore per Compilazioni complesse, repository singoli, strumenti personalizzati Progetti semplici, implementazioni rapide
Dimensione del pacchetto Più grande (comprende node_modules) Più piccolo (dipendenze installate in Azure)
Compilazione TypeScript Compili localmente Azure compila automaticamente
Compatibilità binaria nativa Devi essere compatibile con l'architettura di destinazione Gestito automaticamente (Linux x64)
Rischio di timeout compilazione Nessuno (funziona sul tuo computer) Possibile per grandi insiemi di dipendenza
Controllo Completo (qualsiasi strumento di build, di bundling o di ottimizzazione) Limitato ai valori predefiniti della piattaforma

Per pacchetti npm privati o registri personalizzati, vedi Dipendenze personalizzate.

Creare il pacchetto dell'app per la distribuzione

Quando distribuisci la tua app di funzione TypeScript su Azure, il pacchetto di distribuzione deve soddisfare questi requisiti:

  • Output JavaScript richiesto: Funzioni di Azure esegue JavaScript, quindi TypeScript deve essere compilato prima o durante la distribuzione.

  • host.jsonLivello radice: assicurarsi che un singolo host.json file si trova nella radice del pacchetto di distribuzione, non annidato in una sottocartella.

  • package.json main campo: L'runtime Functions legge questo campo all'avvio per localizzare e indicizzare le tue funzioni. Deve puntare al tuo punto di ingresso JavaScript compilato (ad esempio, dist/src/index.js).

  • Escludere file di sviluppo: Usa un .funcignore file per escludere file non necessari dalla distribuzione, come in questo esempio:

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

Tieni anche a mente questi compromessi quando pianifichi il tuo dispiegamento:

  • L'ambiente di build deve corrispondere alla produzione: le dipendenze con binari nativi devono essere costruite per l'architettura Linux x64. La build remota gestisce questo automaticamente; per la build locale, considera l'uso di Docker o di un ambiente di build containerizzato.
  • La dimensione del pacchetto di distribuzione influisce sull'avvio a freddo: grandi set di dipendenze aumentano la latenza di avvio a freddo perché il runtime deve caricare ogni file singolarmente. Racgruppare la tua app in meno file con strumenti come esbuild o webpack può ridurre significativamente i tempi di avvio.
  • La build remota ha limiti di timeout: se l'installazione di dipendenze o la compilazione TypeScript superano i limiti della piattaforma, la build fallisce. Usa una build locale con dipendenze predefinite per progetti grandi.
  • L'inizializzazione del modulo ha limiti di tempo: Node.js caricamento del modulo e indicizzazione delle funzioni durante l'avvio sono limitati nel tempo. Riduci le importazioni di alto livello o usa importazioni dinamiche quando possibile.

Compilazione locale

Se non richiedi esplicitamente una compilazione remota, la tua macchina installa le dipendenze e compila TypeScript. Poi impacchezioni e distribuisci l'intero progetto compilato e le dipendenze localmente nella tua app di funzione.

La build locale comporta un caricamento di un pacchetto più grande ma ti dà il controllo completo sul processo di compilazione e garantisce compatibilità con il tuo ambiente di sviluppo.

Per i progetti TypeScript che utilizzano la compilazione locale:

  1. Precompile TypeScript: compila localmente il tuo codice TypeScript prima del deployment.
  2. Installa dipendenze: Esegui npm install o yarn install installa le dipendenze localmente.
  3. Verifica build: Assicurati che i risultati delle build funzionino correttamente nel tuo ambiente locale.
  4. Distribuire l'output compilato: distribuire il codice JavaScript compilato insieme alle dipendenze.

Comandi di build di esempio per la build locale:

# 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

Puoi configurare i seguenti strumenti per usare la build locale:

Compilazione remota

Quando si utilizza la compilazione remota, la piattaforma Functions gestisce l'installazione dei pacchetti, la compilazione TypeScript e garantisce la compatibilità con l'ambiente di esecuzione remota.

Utilizzando la build remota, ottieni un pacchetto di distribuzione più piccolo perché non è necessario includere node_modules o compilare file JavaScript.

Quando distribuisci progetti TypeScript usando una build remota:

  1. Rilevamento automatico: La piattaforma rileva i progetti TypeScript tramite la presenza di tsconfig.json.
  2. Compilazione: La piattaforma compila i file TypeScript utilizzando la configurazione TypeScript del tuo progetto.
  3. Installazione delle dipendenze: la piattaforma installa sia dependencies sia devDependencies a partire da package.json, poiché i pacchetti necessari in fase di compilazione come typescript sono necessari per la compilazione.
  4. Ottimizzazione: La piattaforma include solo i file necessari nel pacchetto finale di distribuzione.

Puoi usare la build remota quando pubblichi la tua app TypeScript utilizzando questi strumenti:

Per abilitare la compilazione remota per altri scenari, ad esempio Recapito continuo con Azure Pipelines, vedere Abilitazione della compilazione remota.

Dipendenze personalizzate

Funzioni di Azure supporta dipendenze npm personalizzate e private utilizzando registri npm personalizzati, pacchetti privati o pacchetti locali.

Build remota con registro npm personalizzato

Quando i tuoi pacchetti privati sono disponibili in un registro npm personalizzato, puoi richiedere una compilazione remota dopo aver configurato la posizione del registro.

Per utilizzare un registro personalizzato, crea un .npmrc file nella radice del tuo progetto:

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

Pacchetti locali e moduli privati

Sono supportati pacchetti locali e moduli privati durante la creazione di applicazioni TypeScript Azure Function.

Per includere pacchetti locali usando la build remota, riferiscili nel tuo package.json file:

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

Per includere le dipendenze locali usando la build locale, installa le dipendenze localmente e distribuisci con la build remota disabilitata:

# 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

Usa i pacchetti dell'area di lavoro

Per configurazioni di monorepo o npm workspace, fai riferimento ai pacchetti condivisi usando npm workspace nel tuo package.json file:

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

Bundle prima della distribuzione

Usa strumenti di bundle come webpack, esbuild o rollup per creare un unico bundle prima del deployment:

# Bundle your application
npm run bundle

# Deploy the bundled output
func azure functionapp publish <APP_NAME> --no-build
  • Last updated on