Översikt över JavaScript i Azure Container Apps

Azure Container Apps kan köra alla javaScript-program i containrar i molnet samtidigt som du ger flexibla alternativ för hur du distribuerar dina program.

Konfiguration

Med Azure Container Apps kan du effektivisera distributionen av dina JavaScript-program via effektiv containerisering, inklusive att konfigurera miljövariabler, utforma effektiva Dockerfiles och organisera programmets byggprocess.

Miljövariabler

Miljövariabler är avgörande för att konfigurera ditt program. Använd en .env fil för att hantera dessa variabler lokalt och se till att de hanteras säkert i produktion med en tjänst som Azure Key Vault.

I följande exempel visas hur du skapar variabler för ditt program.

# .env
NODE_ENV=production
PORT=3000
AZURE_COSMOS_DB_ENDPOINT=https://<YOUR_COSMOSDB_RESOURCE_NAME>.documents.azure.com:443/

Behållare

En väl konfigurerad Dockerfile är nödvändig för att containerisera ditt program:

Använd en grundläggande Dockerfile: Om flera projekt delar en gemensam konfiguration kan du skapa en bas-Dockerfile som innehåller dessa vanliga steg. Varje projekts Dockerfile kan sedan börja med FROM den här basavbildningen och lägga till projektspecifika konfigurationer.
Parameterisering av byggargument: Du kan använda byggargument (ARG) i Din Dockerfile för att göra den mer flexibel. På så sätt kan du ange olika värden för dessa argument när du bygger för utveckling, testmiljö eller produktion.
Optimerad Node.js basavbildning: Kontrollera att du använder en lämplig Node.js basavbildning. Överväg att använda mindre, optimerade bilder som alpine-varianter för att minska kostnaderna.
Minimala filer – Kopiera endast det nödvändiga: Fokusera på att endast kopiera de filer som behövs till containern. Skapa en .dockerignore fil för att säkerställa att utvecklingsfiler inte kopieras i till exempel .env och node_modules. Den här filen hjälper till att påskynda byggen i fall där utvecklare kopierade i onödiga filer.
Separera build och runtime med flerstegsversioner: Använd versioner i flera steg för att skapa en mager slutlig avbildning genom att separera byggmiljön från körningsmiljön.
Förkompilerade artefakter genom kompilering och paketering: Att förkompilera dina programartefakter (till exempel genom att kompilera TypeScript eller paketera JavaScript) innan du flyttar dem till körningssteget kan minimera avbildningsstorleken, påskynda containerdistributionen och förbättra prestanda vid kallstart. Noggrann ordning på instruktioner i Dockerfile optimerar även cachelagrings- och återskapandetider.
Docker Compose för utvecklingsmiljöer: Med Docker Compose kan du definiera och köra Docker-program med flera containrar. Den här metoden för flera containrar är användbar för att konfigurera utvecklingsmiljöer. Du kan inkludera byggkontexten och Dockerfile i skrivfilen. Med den här inkapslingsnivån kan du använda olika Dockerfiles för olika tjänster vid behov.

Base Dockerfile

Den här filen fungerar som en vanlig startpunkt för dina Node.js-avbildningar. Du kan använda det med ett FROM direktiv i Dockerfiles som refererar till den här basavbildningen. Använd antingen ett versionsnummer eller en commit för att säkerställa att du använder den senaste och säkra versionen av avbildningen.

# Dockerfile.base

FROM node:22-alpine

# Set the working directory
WORKDIR /usr/src/app

# Define build arguments with default values
ARG PORT_DEFAULT=3000
ARG ENABLE_DEBUG_DEFAULT=false

# Set environment variables using the build arguments
ENV PORT=${PORT_DEFAULT}
ENV ENABLE_DEBUG=${ENABLE_DEBUG_DEFAULT}

# Copy package manifests and install dependencies
COPY package*.json ./
RUN npm install

# Expose the application and debugging ports
EXPOSE $PORT
EXPOSE 9229

# This image focuses on common steps; project-specific Dockerfiles can extend this.

När du skickar in värden med hjälp av --build-arg flaggan under byggprocessen åsidosätter de angivna värdena de hårdkodade standardvärdena i Dockerfile.

Till exempel:

docker build \
  --build-arg PORT_DEFAULT=4000 \
  --build-arg ENABLE_DEBUG_DEFAULT=true \
  --tag <IMAGE>:<TAG> \
  --file Dockerfile.base .

I det här exemplet är miljövariablerna PORT och ENABLE_DEBUG inställda på explicita värden i stället för deras standardvärden.

Konventioner för taggning av containeravbildningar, till exempel användning av latest är en konvention. Läs mer om rekommendationer för taggning och versionshantering av containeravbildningar.

Konfigurera utvecklingsmiljö med Docker Compose

I följande exempelkonfiguration används en dockerfile för dedikerad utveckling (Dockerfile.dev) tillsammans med volymmonteringar för direktinläsning och synkronisering av lokal källa.

version: "3.8"
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile.base
      args:
        PORT_DEFAULT: ${PORT:-3000}
        ENABLE_DEBUG_DEFAULT: ${ENABLE_DEBUG:-false}
    ports:
      - "${PORT:-3000}:3000"
      - "9229:9229"  # Expose debug port if needed
    volumes:
      - .:/usr/src/app
      - /usr/src/app/node_modules
    environment:
      - NODE_ENV=development
      - PORT=${PORT:-3000}
      - ENABLE_DEBUG=${ENABLE_DEBUG:-false}

Om du vill starta Docker Compose med anpassade värden kan du exportera miljövariablerna på kommandoraden. Till exempel:

PORT=4000 ENABLE_DEBUG=true docker compose up

Dockerfile för produktion

Den här Docker-filen med flera steg bygger din tillämning och skapar en mager körningsbild. Se till att filen .dockerignore redan finns i källkoden COPY . . så att kommandot inte kopieras i filer som är specifika för utvecklingsmiljön som du inte behöver i produktion.

# Stage 1: Builder
FROM node:22 AS build

WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .

# Build your project (e.g., compile TypeScript or bundle JavaScript)
RUN npm run build

# Stage 2: Runtime
FROM my-base-image:latest AS runtime

WORKDIR /usr/src/app

# Copy only the compiled output and essential files from the build stage
COPY --from=build /usr/src/app/dist ./dist
COPY --from=build /usr/src/app/package*.json ./

# Install only production dependencies
RUN npm ci --omit=dev

# Copy the entrypoint script for remote debugging
COPY entrypoint.sh /usr/src/app/entrypoint.sh
RUN chmod +x /usr/src/app/entrypoint.sh

# Expose the application port (using the PORT environment variable) and the debug port (9229)
EXPOSE $PORT
EXPOSE 9229

# Use the entrypoint script to conditionally enable debugging
ENTRYPOINT ["sh", "/usr/src/app/entrypoint.sh"]

Med entrypoint-skriptet kan du ansluta till containerappen för fjärrfelsökning.

För att köra en container från den skapade produktionsavbildningen med anpassade miljövariabler, kör:

docker run \
  --env PORT=4000 \
  --env ENABLE_DEBUG=true \
  --publish 4000:4000 \
  --publish 9229:9229 \
  <IMAGE>:<TAG>

För produktionsversioner kontrollerar du att du använder rätt versionstagg, som kanske inte är latest. Konventioner för taggning av containeravbildningar, till exempel användning av latest är en konvention. Läs mer om rekommendationer för taggning och versionshantering av containeravbildningar.

Införande

För att stödja kontinuerlig integrering/kontinuerlig distribution (CI/CD) konfigurerar du en CI/CD-pipeline med GitHub Actions, Azure DevOps eller ett annat CI/CD-verktyg för att automatisera distributionsprocessen.

# .github/workflows/deploy.yml
name: Deploy to Azure

on:
push:
    branches:
    - main

jobs:
build-and-deploy:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4

    - name: Set up Node.js
      uses: actions/setup-node@v4
      with:
          node-version: '22'

    - name: Install dependencies
      run: npm ci

    - name: Build the app
      run: npm run build

    - name: Log in to Azure
      uses: azure/login@v2
      with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}

    - name: Deploy to Azure Container Apps
      run: |
          az containerapp up \
          --name my-container-app \
          --resource-group my-resource-group \
          --image my-image:my_tag \
          --environment my-environment \
          --cpu 1 --memory 2Gi \
          --env-vars NODE_ENV=production PORT=3000

När du använder Docker Registry loggar du in i registret och skickar sedan Docker-avbildningarna till ett containerregister som Azure Container Registry (ACR) eller Docker Hub.

# Tag the image
docker tag \
  <IMAGE>:<TAG> \
  <AZURE_REGISTRY>.azurecr.io/<IMAGE>:<TAG>

# Push the image
docker push <AZURE_REGISTRY>.azurecr.io/<IMAGE>:<TAG>

Kallstart

Optimera din produktionsversion genom att endast inkludera viktig kod och beroenden. Använd någon av följande metoder för att se till att nyttolasten är så smidig som möjligt:

Docker-versioner i flera steg: Använd kompilerings- och paketverktyg som Webpack eller Sammanslagning för att skapa den minsta nyttolasten som är möjlig för din container. När du bara kompilerar och paketerar det som behövs för produktion hjälper du till att minimera containerstorleken och förbättra kalla uppstartstider.
Hantera beroenden noggrant:node_modules Håll mappen mager genom att endast inkludera de paket som krävs för att köra produktionskod. Lista inte utvecklings- eller testberoenden i dependencies-avsnittet i din package.json. Ta bort eventuella oanvända beroenden och se till att din package.json och låsfilen förblir konsekvent.

Säkerhet

Säkerhetsöverväganden för JavaScript-utvecklare som använder Azure Container Apps omfattar att skydda miljövariabler (till exempel att använda Azure Key Vault), säkerställa HTTPS med korrekt certifikathantering, upprätthålla up-to-datumberoenden med regelbundna granskningar och implementera robust loggning och övervakning för att snabbt identifiera och svara på hot.

Säkra miljövariabler

Se till att känslig information som databasanslutningssträngar och API-nycklar lagras på ett säkert sätt. Använd Azure Key Vault för att hantera hemligheter och miljövariabler på ett säkert sätt.

Innan du kör det här kommandot måste du ersätta platshållarna som omges av <> med dina värden.

az keyvault secret set \
  --vault-name <KEY_VAULT_APP> \
  --name "<SECRET_NAME>" \
  --value "<CONNECTION_STRING>"

HTTPS och certifikat

Kontrollera att programmet hanteras via HTTPS. Azure Container Apps kan hantera certifikat åt dig. Konfigurera din anpassade domän och ditt certifikat i Azure-portalen.

Beroendehantering

Uppdatera regelbundet dina beroenden för att undvika säkerhetsrisker. Använd verktyg som npm audit för att söka efter sårbarheter.

npm audit

Felhantering

Implementera robust felhantering i ditt Node.js-program. Använd mellanprogram i Express eller Fastify för att hantera fel på ett korrekt sätt.

// src/middleware/errorHandler.ts
import { Request, Response, NextFunction } from 'express';

export function errorHandler(err: any, req: Request, res: Response, next: NextFunction) {
  console.error(err.stack);
  res.status(500).send('Something broke!');
}

Graciösa avstängningar

Det är viktigt att applikationen stängs av korrekt för att säkerställa att pågående begäranden slutförs och att resurserna friges korrekt. Detta hjälper till att förhindra dataförlust och ger en smidig användarupplevelse under distributioner eller inskalningshändelser. I följande exempel visas en metod som använder Node.js och Express för att hantera avstängningssignaler på ett korrekt sätt.

import express from 'express';
import healthRouter from './health.js';

const app = express();

app.use(healthRouter);

const server = app.listen(process.env.PORT || 3000);

// Graceful shutdown
process.on('SIGTERM', () => {
  console.log('SIGTERM received, shutting down...');
  server.close(() => {
    console.log('Server closed');
    process.exit(0);
  });

  // Force close after 30s
  setTimeout(() => {
    console.error('Could not close connections in time, forcing shutdown');
    process.exit(1);
  }, 30000);
});

Logging

I Azure Container Apps registreras och loggas både console.log och console.error anrop automatiskt. Azure Container Apps samlar in strömmarna för standardutdata (stdout) och standardfel (stderr) från ditt program och gör dem tillgängliga i Azure Monitor och Log Analytics.

Konfigurera loggning i Azure Container Apps

För att säkerställa att loggarna är korrekt insamlade och tillgängliga måste du konfigurera diagnostikinställningar för din Azure Container App. Installationen är en tvåstegsprocess.

Aktivera diagnostikinställningar: Använd Azure CLI för att aktivera diagnostikinställningar för din Azure Container App.

Innan du kör det här kommandot måste du ersätta platshållarna som omges av <> med dina värden.

az monitor diagnostic-settings create \
--resource /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Web/containerApps/<CONTAINER_APP_NAME> \
--name "containerapp-logs" \
--workspace <LOG_ANALYTICS_WORKSPACE_ID> \
--logs '[{"category": "ContainerAppConsoleLogs","enabled": true}]'

Få åtkomst till loggar i portalen genom att gå till ditt Log Analytics-arbetsyta och göra sökningar i loggarna.

Använda loggningsbibliotek

När console.log och console.error registreras automatiskt ger användning av ett loggningsbibliotek som Winston mer flexibilitet och kontroll över din loggning. Med den här flexibiliteten kan du formatera loggar, ange loggnivåer och utdataloggar till flera mål som filer eller externa loggningstjänster.

I följande exempel visas hur du konfigurerar Winston för att lagra loggar med hög återgivning.

// src/logger.ts
import { createLogger, transports, format } from 'winston';

const logger = createLogger({
  level: 'info',
  format: format.combine(
    format.timestamp(),
    format.json()
  ),
  transports: [
    new transports.Console(),
    new transports.File({ filename: 'app.log' })
  ]
});

export default logger;

Om du vill använda loggern använder du följande syntax i ditt program:

import logger from './logger';

logger.info('This is an info message');
logger.error('This is an error message');

Fjärrfelsökning

För att aktivera fjärrfelsökning kan du använda Nodes inbyggda inspektör. I stället för att hårdkoda felsökningsinställningarna CMDi Dockerfile kan du dynamiskt aktivera fjärrfelsökning med hjälp av ett gränssnittsskript som containerns startpunkt.

Följande skript kontrollerar en miljövariabel (till exempel ENABLE_DEBUG) när containern startar. Om variabeln är inställd till true, startar skriptet Node.js i felsökningsläge, med hjälp av --inspect eller --inspect-brk. Annars startar containern programmet normalt.

Du kan implementera fjärrfelsökning med följande steg:

Skapa ett startpunktsskript i en fil med namnet entrypoint.sh i projektets rot med följande innehåll:

#!/bin/sh
# If ENABLE_DEBUG is set to "true", start Node with debugging enabled
if [ "$ENABLE_DEBUG" = "true" ]; then
  echo "Debug mode enabled: starting Node with inspector"
  exec node --inspect=0.0.0.0:9229 dist/index.js
else
  echo "Starting Node without debug mode"
  exec node dist/index.js
fi

Ändra Dockerfile för att kopiera skriptet entrypoint.sh till containern och ange det som startpunkt. Exponera även felsökningsporten om det behövs:

# Copy the entrypoint script to the container
COPY entrypoint.sh /usr/src/app/entrypoint.sh

# Ensure the script is executable
RUN chmod +x /usr/src/app/entrypoint.sh

# Expose the debugging port (if using debug mode)
EXPOSE 9229

# Set the shell script as the container’s entrypoint
ENTRYPOINT ["sh", "/usr/src/app/entrypoint.sh"]

Utlösa felsökningsläge genom att ange miljövariabeln ENABLE_DEBUG till true. Du kan till exempel använda Azure CLI:
```
az containerapp update \
  --name <CONTAINER_APP> \
  --env-vars ENABLE_DEBUG=true
```

Innan du kör det här kommandot måste du ersätta platshållarna som omges av <> med dina värden.

Den här metoden erbjuder en flexibel lösning som gör att du kan starta om containern i felsökningsläge genom att uppdatera en miljövariabel vid start. Det undviker behovet av att skapa en ny revision med olika CMD inställningar varje gång du behöver felsöka ditt program.

Överväganden för underhåll och prestanda

Om du vill underhålla och optimera programmets prestanda över tid ser du till att du effektivt hanterar ändringar av miljövariabler, övervakar dina resurser, behåller dina beroenden up-to-date, konfigurerar skalning korrekt och konfigurerar övervakningsaviseringar.

Ändringar i miljövariabler

Eftersom varje ändring av miljövariabler kräver en ny distribuerad revision gör du alla ändringar i appens hemligheter samtidigt. När ändringarna är klara länkar du hemligheterna till revisionens miljövariabler. Den här metoden minimerar antalet revisioner och bidrar till att upprätthålla en ren distributionshistorik.

Resurstilldelning

Övervaka och justera processor- och minnesallokering för dina containrar baserat på programmets prestanda- och användningsmönster. Överetablering kan leda till onödiga kostnader, medan underetablering kan orsaka prestandaproblem.

Beroendeuppdateringar

Uppdatera regelbundet dina beroenden för att dra nytta av prestandaförbättringar och säkerhetskorrigeringar. Använd verktyg som npm-check-updates för att automatisera den här processen.

npm install -g npm-check-updates
ncu -u
npm install

Skalning

Konfigurera automatisk skalning baserat på programmets belastning. Azure Container Apps stöder horisontell skalning, vilket automatiskt justerar antalet containerinstanser baserat på cpu- eller minnesanvändning.

I följande exempel visas hur du anger en CPU-baserad skalningsregel. Innan du kör det här kommandot måste du ersätta platshållarna som omges av <> med dina värden.

az containerapp revision set-scale \
  --name <CONTAINER_APP> \
  --resource-group <RESOURCE_GROUP> \
  --min-replicas 1 \
  --max-replicas 10 \
  --cpu 80

Övervaka aviseringar

Konfigurera övervakning och aviseringar för att spåra programmets prestanda och hälsa. Använd Azure Monitor för att skapa aviseringar för specifika mått, till exempel CPU-användning, minnesanvändning och svarstider.

Innan du kör det här kommandot måste du ersätta platshållarna som omges av <> med dina värden.

az monitor metrics alert create \
  --name "HighCPUUsage" \
  --resource-group <RESOURCE_GROUP> \
  --scopes /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.ContainerInstance/containerGroups/<CONTAINER_GROUP> \
  --condition "avg Percentage CPU > 80" \
  --description "Alert when CPU usage is above 80%"

Resurshantering

Använd Azure Container Apps-tillägget för Visual Studio Code för att snabbt skapa, redigera och distribuera containerbaserade appar direkt från Visual Studio Code.

Felsökning

När programmet stöter på körningsproblem i Azure Container Apps kan du använda aviseringar om loggning, fjärrfelsökning och hälsokontroll för att hitta och lösa problemet.

Logging

Aktivera och konfigurera loggning för att samla in programloggar. Använd Azure Monitor och Log Analytics för att samla in och analysera loggar. Innan du kör dessa kommandon måste du ersätta platshållarna som omges av <> med dina värden.

Skapa en ny arbetsyta.

az monitor log-analytics workspace create \
    --resource-group <RESOURCE_GROUP> \
    --workspace-name <WORKSPACE_NAME>

Skapa sedan en ny arbetsyteinställning.

az monitor diagnostic-settings create \
    --resource <CONTAINER_APP> \
    --workspace <WORKSPACE_NAME> \
    --logs '[{"category": "ContainerAppConsoleLogs","enabled": true}]'

Debugging

Du använder fjärrfelsökningsverktyg för att ansluta till containern som körs. Se till att Dockerfile exponerar nödvändiga portar för felsökning.

# Expose the debugging port
EXPOSE 9229

Hälsokontroller

Konfigurera hälsokontroller för att övervaka hälsotillståndet för ditt program. Den här funktionen säkerställer att Azure Container Apps kan starta om containern om den inte svarar.

# Azure Container Apps YAML configuration
properties:
configuration:
    livenessProbe:
    httpGet:
        path: /health
        port: 3000
    initialDelaySeconds: 30
    periodSeconds: 10

Feedback

Var den här sidan hjälpsam?

Last updated on 2026-02-25

Dela via

Översikt över JavaScript i Azure Container Apps

Konfiguration

Miljövariabler

Behållare

Base Dockerfile

Konfigurera utvecklingsmiljö med Docker Compose

Dockerfile för produktion

Införande

Kallstart

Säkerhet

Säkra miljövariabler

HTTPS och certifikat

Beroendehantering

Felhantering

Graciösa avstängningar

Logging

Konfigurera loggning i Azure Container Apps

Använda loggningsbibliotek

Fjärrfelsökning

Överväganden för underhåll och prestanda

Ändringar i miljövariabler

Resurstilldelning

Beroendeuppdateringar

Skalning

Övervaka aviseringar

Resurshantering

Felsökning

Logging

Debugging

Hälsokontroller

Relaterat innehåll

Feedback

Ytterligare resurser