Megosztás a következőn keresztül:

JavaScript az Azure Container Appsben – áttekintés

Az Azure Container Apps bármilyen tárolóalapú JavaScript-alkalmazást futtathat a felhőben, miközben rugalmas lehetőségeket biztosít az alkalmazások üzembe helyezéséhez.

Konfiguráció

Az Azure Container Apps segít a JavaScript-alkalmazások üzembe helyezésének egyszerűsítésében az effektív konténerizáció révén, beleértve a környezeti változók beállítását, az eredményes Dockerfile-ok tervezését és az alkalmazás építési folyamatának rendszerezését.

Környezeti változók

A környezeti változók kulcsfontosságúak az alkalmazás konfigurálásához. Használjon egy .env fájlt ezeknek a változóknak a helyi kezelésére, és gondoskodjon arról, hogy éles környezetben biztonságosan kezelje őket egy olyan szolgáltatással, mint az Azure Key Vault.

Az alábbi példa bemutatja, hogyan hozhat létre változókat az alkalmazáshoz.

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

Tárolók

A jól konfigurált Dockerfile elengedhetetlen az alkalmazás tárolózásához:

  • Alapszintű Dockerfile használata: Ha több projekt közös beállítással rendelkezik, létrehozhat egy alapszintű Dockerfile-fájlt, amely tartalmazza ezeket a gyakori lépéseket. Ezután minden projekt Dockerfile-fájlja ezzel az alapképpel kezdődhet FROM , és hozzáadhat projektspecifikus konfigurációkat.

  • Buildargumentumok paraméterezése: A Dockerfile buildargumentumait (ARG) használva rugalmasabbá teheti azt. Így különböző értékeket adhat meg ezekhez az argumentumokhoz, amikor fejlesztésre, előkészítésre vagy éles üzemre készül.

  • Optimalizált Node.js alaprendszerkép: Győződjön meg arról, hogy megfelelő Node.js alaprendszerképet használ. Fontolja meg kisebb, optimalizált képek, például az Alpesi változatok használatát a többletterhelés csökkentése érdekében.

  • Minimális fájlok – Csak az alapvető elemek másolása: Koncentráljon arra, hogy csak a szükséges fájlokat másolja a tárolóba. Hozzon létre egy .dockerignore fájlt, amely biztosítja, hogy a fejlesztési fájlok ne legyenek másolva, például .env és node_modules. Ez a fájl felgyorsítja a buildelést azokban az esetekben, amikor a fejlesztők szükségtelen fájlokba másolták őket.

  • Build és futtatókörnyezet elkülönítése többfázisú buildekkel: Többfázisú buildek használatával létrehozhat egy sovány végső rendszerképet úgy, hogy elválasztja a buildkörnyezetet a futtatókörnyezettől.

  • Előre összeállított összetevők összeállítással és összekapcsolással: Az alkalmazásösszetevők (például a TypeScript összeállítása vagy a JavaScript összekapcsolása) előkészítése, mielőtt a futtatókörnyezeti szakaszba másolná őket, minimalizálhatja a kép méretét, felgyorsíthatja a tároló üzembe helyezését, és javíthatja a hidegindítási teljesítményt. A Dockerfile utasításainak gondos sorrendje szintén optimalizálja a gyorsítótárazási és újraépítési időket.

  • Docker Compose fejlesztői környezetekhez: A Docker Compose segítségével többtárolós Docker-alkalmazásokat definiálhat és futtathat. Ez a többtárolós megközelítés hasznos a fejlesztési környezetek beállításához. A összeállítási fájlba belefoglalhatja a buildkörnyezetet és a Dockerfile-t. Ez a beágyazási szint lehetővé teszi, hogy szükség esetén különböző Docker-fájlokat használjon a különböző szolgáltatásokhoz.

Alapszintű Dockerfile

Ez a fájl általános kiindulási pontként szolgál a Node.js képeihez. A Dockerfile-okban, amelyek az alapképre hivatkoznak, a FROM irányelvet használhatja. A rendszerkép legutóbbi és biztonságos verziójának támogatásához használjon verziószámot vagy véglegesítést.

# 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.

Amikor a buildelési folyamat során a --build-arg jelölő használatával ad át értékeket, az átadott értékek felülírják a Dockerfile rögzített alapértelmezett értékeit.

Például:

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

Ebben a példában a környezeti változók PORTENABLE_DEBUG explicit értékekre vannak beállítva az alapértelmezett értékek helyett.

A tárolórendszerképek címkézési konvenciói, mint például a latest használata, egy konvenciót képviselnek. További információ a tárolólemezképek címkézésére és verziószámozására vonatkozó javaslatokról.

Fejlesztői környezet beállítása a Docker Compose használatával

Az alábbi példakonfiguráció egy dedikált fejlesztésű Dockerfile -t (Dockerfile.dev) használ, valamint mennyiségi csatlakoztatásokat az élő újratöltéshez és a helyi forrásszinkronizáláshoz.

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}

Ha egyéni értékekkel szeretné elindítani a Docker Compose-t, exportálhatja a parancssor környezeti változóit. Például:

PORT=4000 ENABLE_DEBUG=true docker compose up

Termelési Dockerfile

Ez a többfázisú Dockerfile létrehozza az alkalmazást, és egy sovány futtatókörnyezeti rendszerképet hoz létre. Győződjön meg arról, hogy a .dockerignore fájl már szerepel a forráskódban, hogy a COPY . . parancs ne másolja a fejlesztési környezethez szükséges, de a termelési környezetben nem szükséges fájlokat.

# 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"]

A entrypoint-szkript lehetővé teszi, hogy távoli hibakeresés céljából csatlakozzon a tárolóalkalmazáshoz.

Ha egyéni környezeti változókkal szeretne tárolót futtatni az épített üzemi lemezképből, futtassa a következőt:

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

Éles buildek esetén győződjön meg arról, hogy a megfelelő verziócímkét használja, ami lehet, hogy nem latest. A konténerképek címkézési konvenciói, mint például a latest használata, konvenciók. További információ a tárolólemezképek címkézésére és verziószámozására vonatkozó javaslatokról.

Telepítés

A folyamatos integráció/folyamatos üzembe helyezés (CI/CD) támogatásához állítson be egy CI/CD-folyamatot a GitHub Actions, az Azure DevOps vagy egy másik CI/CD-eszköz használatával az üzembe helyezési folyamat automatizálásához.

# .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

A Docker Registry használatakor jelentkezzen be a beállításjegyzékbe, majd küldje el a Docker-lemezképeket egy tárolóregisztrációs adatbázisba, például az Azure Container Registrybe (ACR) vagy a Docker Hubba.

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

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

Hidegindítások

Optimalizálja a gyártási buildet, úgy hogy csak a lényeges kódot és függőségeket tartalmazza. Annak érdekében, hogy a hasznos teher a lehető legkisebb legyen, használja az alábbi módszerek egyikét:

  • Többfázisú Docker-buildek vagy -kötegelők: Az olyan buildelési és kötegelési eszközök, mint a Webpack vagy a Rollup, segítenek a tároló számára a lehető legkisebb hasznos teher létrehozásában. Ha csak az éles környezethez szükséges elemeket állítja össze és csomagolja össze, segít minimalizálni a tároló méretét, és segíteni a hideg kezdési idők javításában.

  • A függőségek körültekintő kezelése: Tartsa a node_modules mappát úgy, hogy csak az éles kód futtatásához szükséges csomagokat tartalmazza. Ne sorolja fel a fejlesztési vagy tesztelési függőségeket a dependencies szakaszában package.json. Távolítsa el a nem használt függőségeket, és győződjön meg arról, hogy a package.json és a lock fájl konzisztensen maradnak.

Biztonság

Az Azure Container Appst használó JavaScript-fejlesztők biztonsági szempontjai közé tartozik a környezeti változók védelme (például az Azure Key Vault használata), a HTTPS megfelelő tanúsítványkezeléssel való biztosítása, a up-todátumfüggőségek rendszeres naplózással való fenntartása, valamint a fenyegetések gyors észleléséhez és elhárításához szükséges robusztus naplózás és monitorozás.

Biztonságos környezeti változók

Győződjön meg arról, hogy a bizalmas információk, például az adatbázis-kapcsolati sztringek és az API-kulcsok biztonságosan vannak tárolva. Az Azure Key Vault használatával biztonságosan kezelheti a titkos kulcsokat és a környezeti változókat.

A parancs futtatása előtt cserélje le a <>-be ágyazott helyőrzőket a saját értékeivel.

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

HTTPS és tanúsítványok

Győződjön meg arról, hogy az alkalmazás HTTPS-en keresztül van kézbesítve. Az Azure Container Apps kezelheti az Ön tanúsítványait . Konfigurálja egyéni tartományát és tanúsítványát az Azure Portalon.

Függőségkezelés

A biztonsági rések elkerülése érdekében rendszeresen frissítse a függőségeket. Használjon olyan eszközöket, mint npm audit a biztonsági rések keresése.

npm audit

Hibakezelés

Robusztus hibakezelés implementálása a Node.js alkalmazásban. Használjon köztes szoftvereket az Expressben vagy a Fastify-ben a hibák elegáns kezeléséhez.

// 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!');
}

Zökkenőmentes leállítások

Az alkalmazás megfelelő leállítása elengedhetetlen ahhoz, hogy a repülés közbeni kérések befejeződjenek, és az erőforrások megfelelően legyenek felszabadítva. Ez segít megelőzni az adatvesztést, és zökkenőmentes felhasználói élményt biztosít az üzembe helyezés vagy a méretezési események során. Az alábbi példa az Node.js és az Express egyik módszerét mutatja be a leállítási jelek elegáns kezelésére.

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);
});

Fakitermelés

Az Azure Container Appsben mind a console.log hívásokat, mind a console.error hívásokat automatikusan rögzíti és naplózza a rendszer. Az Azure Container Apps rögzíti az alkalmazás szabványos kimeneti (stdout) és standard hiba (stderr) streameit, és elérhetővé teszi őket az Azure Monitorban és a Log Analyticsben.

Naplózás beállítása az Azure Container Appsben

Ahhoz, hogy a naplók megfelelően rögzítve és elérhetők legyenek, konfigurálnia kell az Azure Container App diagnosztikai beállításait. A beállítás kétlépéses folyamat.

  1. Diagnosztikai beállítások engedélyezése: Az Azure CLI használatával engedélyezheti az Azure Container App diagnosztikai beállításait.

    A parancs futtatása előtt cserélje le az értékekkel körülvett <> helyőrzőket.

    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}]'

  2. A naplók portálon való eléréséhez lépjen a Log Analytics-munkaterületre, és kérdezze le a naplókat.

Naplózási könyvtárak használata

Miközben console.log és console.error automatikusan rögzítődnek, egy Winstonhoz hasonló naplózási könyvtár használata nagyobb rugalmasságot és ellenőrzést biztosít a naplózás felett. Ez a rugalmasság lehetővé teszi a naplók formázását, a naplószintek és a kimeneti naplók több célhelyre, például fájlokra vagy külső naplózási szolgáltatásokra való beállítását.

Az alábbi példa bemutatja, hogyan konfigurálhatja Winstont a magas megbízhatósági naplók tárolására.

// 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;

A naplózó használatához használja az alábbi szintaxist az alkalmazásban:

import logger from './logger';

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

Távoli hibakeresés

A távoli hibakeresés engedélyezéséhez használhatja a Node beépített felügyelőjét. Ahelyett, hogy a hibakeresési beállításokat a Dockerfile-fájlba belekódolná CMD, dinamikusan engedélyezheti a távoli hibakeresést egy shell script használatával a tároló belépési pontjaként.

A következő szkript ellenőrzi a környezeti változót (például ENABLE_DEBUG) a tároló indításakor. Ha a változó értéke true-ra van állítva, a szkript hibakeresési módban indítja el a Node.js (a --inspect vagy --inspect-brk használatával). Ellenkező esetben a tároló normál módon indítja el az alkalmazást.

A távoli hibakeresést az alábbi lépésekkel valósíthatja meg:

  1. Hozzon létre egy belépésipont-szkriptet a projekt gyökerénél elnevezett entrypoint.sh fájlban a következő tartalommal:

    #!/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

  2. Módosítsa a Dockerfile-t úgy, hogy a entrypoint.sh szkriptet a tárolóba másolja, és állítsa be belépési pontként. Szükség esetén tegye elérhetővé a hibakeresési portot is:

    # 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"]

  3. Hibakeresési mód aktiválása a környezeti változó ENABLE_DEBUGtruebeállításával. Például az Azure CLI használatával:

    az containerapp update \
  --name <CONTAINER_APP> \
  --env-vars ENABLE_DEBUG=true

A parancs futtatása előtt cserélje le a <> karakterekkel jelölt helyőrzőket a saját értékeire.

Ez a megközelítés egy rugalmas megoldást kínál, amely lehetővé teszi a tároló hibakeresési módban való újraindítását egy környezeti változó indításkor történő frissítésével. Így nem kell minden alkalommal különböző beállításokkal CMD rendelkező új változatot létrehoznia, amikor hibakeresést kell végeznie az alkalmazásban.

Karbantartási és teljesítménybeli szempontok

Az alkalmazás teljesítményének időbeli fenntartása és optimalizálása érdekében gondoskodjon a környezeti változók változásainak hatékony kezeléséről, az erőforrások figyeléséről, a függőségek up-todátumának megőrzéséről, a skálázás megfelelő konfigurálásával és a figyelési riasztások beállításáról.

Környezeti változók változásai

Mivel a környezeti változók minden módosítása új üzembe helyezett változatot igényel, azonnal végezze el az alkalmazás titkos kulcsainak módosítását. Ha a módosítások befejeződnek, csatolja a titkos kulcsokat a változat környezeti változóihoz. Ez a megközelítés minimálisra csökkenti a változatok számát, és segít fenntartani a tiszta üzembe helyezési előzményeket.

Erőforrás-elosztás

Monitorozza és módosítsa a tárolók processzor- és memóriafoglalását az alkalmazás teljesítmény- és használati mintái alapján. A túlkiépítés szükségtelen költségekhez vezethet, míg az alulkiépítés teljesítményproblémákat okozhat.

Függőségi frissítések

Rendszeresen frissítse függőségeit, hogy kihasználhassa a teljesítménybeli fejlesztéseket és a biztonsági javításokat. Ehhez hasonló npm-check-updates eszközökkel automatizálhatja ezt a folyamatot.

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

Skálázás

Az automatikus skálázás konfigurálása az alkalmazás terhelése alapján. Az Azure Container Apps támogatja a horizontális skálázást, amely automatikusan módosítja a tárolópéldányok számát a processzor- vagy memóriahasználat alapján.

Az alábbi példa bemutatja, hogyan állíthat be cpu-alapú méretezési szabályt. A parancs futtatása előtt cserélje le az értékekkel körülvett <> helyőrzőket.

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

Riasztások figyelése

Monitorozás és riasztások beállítása az alkalmazás teljesítményének és állapotának nyomon követéséhez. Az Azure Monitor használatával riasztásokat hozhat létre bizonyos metrikákhoz, például a processzorhasználathoz, a memóriahasználathoz és a válaszidőkhöz.

A parancs futtatása előtt cserélje le az értékekkel körülvett <> helyőrzőket.

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%"

Erőforrás-kezelés

A Visual Studio Code Azure Container Apps bővítményével közvetlenül a Visual Studio Code-ból hozhat létre, szerkeszthet és helyezhet üzembe tárolóalapú alkalmazásokat.

Hibaelhárítás

Ha az alkalmazás futásidejű problémákba ütközik az Azure Container Appsben, naplózási, távoli hibakeresési és állapot-ellenőrzési riasztásokkal megkeresheti és megoldhatja a problémát.

Fakitermelés

A naplózás engedélyezése és konfigurálása az alkalmazásnaplók rögzítéséhez. Naplók gyűjtése és elemzése az Azure Monitor és a Log Analytics használatával. A parancsok futtatása előtt cserélje le az értékekkel körülvett <> helyőrzőket.

  1. Hozzon létre egy új munkaterületet.

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

  2. Ezután hozzon létre egy új munkaterület-beállítást.

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

Hibakeresés

Távoli hibakeresési eszközökkel csatlakozhat a futó tárolóhoz. Győződjön meg arról, hogy a Dockerfile elérhetővé teszi a hibakereséshez szükséges portokat.

# Expose the debugging port
EXPOSE 9229

Állapotellenőrzések

Konfigurálja az állapot-ellenőrzéseket az alkalmazás állapotának figyeléséhez. Ez a funkció biztosítja, hogy az Azure Container Apps újraindítsa a tárolót, ha az nem válaszol.

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

Kapcsolódó tartalom