Přehled JavaScriptu v Azure Container Apps

Azure Container Apps může v cloudu spouštět libovolnou kontejnerizovanou javascriptovou aplikaci a zároveň poskytuje flexibilní možnosti nasazení aplikací.

Konfigurace

Azure Container Apps umožňuje zjednodušení nasazení aplikací v jazyce JavaScript prostřednictvím efektivní kontejnerizace, včetně nastavení proměnných prostředí, navrhování efektivních souborů Dockerfile a uspořádání procesu sestavení vaší aplikace.

Proměnné prostředí

Proměnné prostředí jsou zásadní pro konfiguraci aplikace. .env Pomocí souboru můžete tyto proměnné spravovat místně a zajistit jejich bezpečnou správu v produkčním prostředí pomocí služby, jako je Azure Key Vault.

Následující příklad ukazuje, jak vytvořit proměnné pro vaši aplikaci.

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

Containers

Dobře nakonfigurovaný soubor Dockerfile je nezbytný pro kontejnerizaci vaší aplikace:

Použijte základní soubor Dockerfile: Pokud několik projektů sdílí společné nastavení, můžete vytvořit základní soubor Dockerfile, který obsahuje tyto běžné kroky. Soubor Dockerfile každého projektu pak může začít s FROM touto základní imagí a přidat konfigurace specifické pro projekt.
Parametrizace argumentů sestavení: Pomocí argumentů sestavení (ARG) v souboru Dockerfile můžete zajistit větší flexibilitu. Tímto způsobem můžete předat různé hodnoty těchto argumentů při sestavování pro vývoj, přípravu nebo produkci.
Optimalizovaná Node.js základní image: Ujistěte se, že používáte odpovídající Node.js základní image. Zvažte použití menších, optimalizovaných obrázků, jako jsou optimalizované verze Alpine, abyste snížili režii.
Minimální soubory – Kopírujte jen nezbytné: Zaměřte se na kopírování pouze potřebných souborů do kontejneru. Vytvořte soubor, .dockerignore aby se zajistilo, že se vývojové soubory nekopírují, například .env a node_modules. Tento soubor pomáhá urychlit sestavování v případech, kdy vývojáři zkopírovali nepotřebné soubory.
Samostatné sestavení a prostředí runtime s vícefázovými sestaveními: Pomocí vícefázových sestavení vytvořte kompaktní konečný obraz oddělením prostředí sestavení od prostředí runtime.
Předběžné sestavení artefaktů kompilací a balením: Předběžné sestavení artefaktů aplikace (například kompilace TypeScriptu nebo balení JavaScriptu) před jejich kopírováním do fáze runtime může minimalizovat velikost obrazu, urychlit nasazení kontejneru a zlepšit výkon při studeném startu. Pečlivé řazení pokynů v souboru Dockerfile také optimalizuje ukládání do mezipaměti a časy opětovného sestavení.
Docker Compose pro vývojová prostředí: Docker Compose umožňuje definovat a spouštět aplikace Dockeru s více kontejnery. Tento přístup s více kontejnery je užitečný pro nastavení vývojových prostředí. Do souboru compose můžete zahrnout kontext sestavení a soubor Dockerfile. Tato úroveň zapouzdření umožňuje v případě potřeby používat různé soubory Dockerfile pro různé služby.

Základní soubor Dockerfile

Tento soubor slouží jako běžný výchozí bod pro vaše Node.js obrázky. Můžete ji použít s direktivou FROM v souborech Dockerfile, které odkazují na tuto základní image. K podpoře poslední a zabezpečené verze image použijte číslo verze nebo potvrzení.

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

Když předáte hodnoty pomocí příznaku --build-arg během procesu sestavení, předané hodnoty přepíší pevně zakódované výchozí hodnoty v souboru Dockerfile.

Například:

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

V tomto příkladu jsou proměnné prostředí PORT a ENABLE_DEBUG nastaveny na explicitní hodnoty místo jejich výchozích hodnot.

Konvence označování imagí kontejneru, jako je použití latest , jsou konvence. Přečtěte si další informace o doporučeních pro označování a správu verzí imagí kontejnerů.

Nastavení vývojového prostředí pomocí Docker Compose

Následující příklad konfigurace používá vyhrazený vývojový Dockerfile (Dockerfile.dev) spolu s připojováním svazků pro místní synchronizaci zdrojů a živé opětovné načítání.

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}

Pokud chcete spustit Docker Compose s vlastními hodnotami, můžete exportovat proměnné prostředí na příkazovém řádku. Například:

PORT=4000 ENABLE_DEBUG=true docker compose up

Produkční soubor Dockerfile

Tento soubor Dockerfile s více fázemi sestaví vaši aplikaci a vytvoří štíhlou image modulu runtime. Ujistěte se, že máte soubor .dockerignore již ve vašem zdrojovém kódu, abyste COPY . . příkazem zabránili kopírování jakýchkoli souborů specifických pro vývojové prostředí, které nejsou potřebné v produkčním prostředí.

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

Skript vstupního bodu umožňuje připojit se k aplikaci kontejneru pro vzdálené ladění.

Pokud chcete spustit kontejner z vytvořené produkční image s vlastními proměnnými prostředí, spusťte:

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

V produkčních buildech se ujistěte, že používáte správnou značku verze, která nemusí být latest. Konvence označování imagí kontejneru, jako je použití latest , jsou konvence. Přečtěte si další informace o doporučeních pro označování a správu verzí imagí kontejnerů.

Nasazení

Pokud chcete podporovat kontinuální integraci nebo průběžné nasazování (CI/CD), nastavte kanál CI/CD pomocí GitHub Actions, Azure DevOps nebo jiného nástroje CI/CD pro automatizaci procesu nasazení.

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

Pokud používáte Docker Registry, přihlaste se ke svému registru a pak nasdílejte image Dockeru do registru kontejneru, jako je Azure Container Registry (ACR) nebo 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>

Začátek chladu

Optimalizujte produkční sestavení zahrnutím pouze základního kódu a závislostí. Pokud chcete zajistit, aby byl objem dat co nejmenší, použijte jeden z následujících přístupů:

Sestavení nebo balíkovací nástroje Dockeru s více fázemi: Pomocí nástrojů sestavení a balíkování, jako je Webpack nebo Rollup, můžete vytvořit nejmenší možný balíček pro váš kontejner. Když kompilujete a balíte pouze to, co je potřeba pro produkční prostředí, pomáháte minimalizovat velikost kontejneru a zlepšit dobu studeného startu.
Pečlivě spravujte závislosti: Zachovejte svou složku štíhlou zahrnutím pouze balíčků potřebných ke spuštění produkčního kódu. Nevypisujte vývojové ani testové závislosti v části dependencies vašeho package.json. Odeberte všechny nepoužívané závislosti a zajistěte, aby soubor package.json a soubor uzamčení zůstal konzistentní.

Zabezpečení

Aspekty zabezpečení pro vývojáře v JavaScriptu, kteří používají Azure Container Apps, zahrnují zabezpečení proměnných prostředí (například použitím Azure Key Vault), zajištění používání HTTPS se správnou správou certifikátů, udržování aktuálnosti závislostí prostřednictvím pravidelných auditů a implementaci robustního logování a monitorování pro rychlou detekci hrozeb a reakci na ně.

Zabezpečené proměnné prostředí

Zajistěte bezpečné ukládání citlivých informací, jako jsou připojovací řetězce databáze a klíče rozhraní API. Pomocí služby Azure Key Vault můžete bezpečně spravovat tajné kódy a proměnné prostředí.

Před spuštěním tohoto příkazu nezapomeňte zástupné symboly nahradit <> hodnotami.

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

HTTPS a certifikáty

Ujistěte se, že se vaše aplikace obsluhuje přes PROTOKOL HTTPS. Azure Container Apps za vás může spravovat certifikáty . Nakonfigurujte vlastní doménu a certifikát na webu Azure Portal.

Správa závislostí

Pravidelně aktualizujte závislosti, abyste se vyhnuli ohrožením zabezpečení. Pomocí nástrojů, jako je npm audit, zkontrolujte zranitelnosti.

npm audit

Zpracování chyb

Implementujte robustní zpracování chyb v aplikaci Node.js. K řádnému zpracování chyb použijte middleware v Expressu nebo Fastify.

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

Plynulé vypnutí

Správné vypnutí aplikace je zásadní, aby se zajistilo, že se požadavky na letu dokončí a prostředky se uvolní správně. To pomáhá zabránit ztrátě dat a udržovat bezproblémové uživatelské prostředí během nasazení nebo událostí škálování na více instancí. Následující příklad ukazuje jeden přístup pomocí Node.js a Express ke zpracování signálů vypnutí elegantně.

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

Logování

V Azure Container Apps se volání console.log a console.error automaticky zaznamenávají a protokolují. Azure Container Apps zachycuje standardní výstup () a standardní chybové proudy (stdoutstderr) z vaší aplikace a zpřístupňuje je ve službě Azure Monitor a Log Analytics.

Nastavení logování v Azure Container Apps

Abyste měli jistotu, že jsou vaše protokoly správně zachycené a přístupné, musíte nakonfigurovat nastavení diagnostiky pro vaši aplikaci kontejneru Azure. Nastavení je dvoustupňový proces.

Povolit nastavení diagnostiky: Pomocí Azure CLI povolte nastavení diagnostiky pro vaši aplikaci kontejneru Azure.

Před spuštěním tohoto příkazu nezapomeňte zástupné symboly nahradit <> hodnotami.

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

Přístup k protokolům na portálu vám umožní přejít do pracovního prostoru služby Log Analytics a dotazovat se na protokoly.

Použití knihoven protokolování

Zatímco console.log a console.error jsou automaticky zachyceny, použití knihovny protokolování, jako je Winston, poskytuje větší flexibilitu a kontrolu nad protokolováním. Tato flexibilita umožňuje formátovat protokoly, nastavit úrovně protokolů a výstupní protokoly do více cílů, jako jsou soubory nebo externí protokolovací služby.

Následující příklad ukazuje, jak nakonfigurovat Winston pro ukládání vysoce věrných protokolů.

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

Pokud chcete použít protokolovací nástroj, použijte ve své aplikaci následující syntaxi:

import logger from './logger';

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

Vzdálené debugování

Pokud chcete povolit vzdálené ladění, můžete použít integrovaný inspektor Node. Místo pevného zakódování nastavení ladění do souboru Dockerfile CMD můžete dynamicky povolit vzdálené ladění pomocí shellového skriptu jako vstupního bodu kontejneru.

Následující skript při spuštění kontejneru zkontroluje proměnnou prostředí (například ENABLE_DEBUG). Pokud je proměnná nastavená na true, spustí se skript Node.js v režimu ladění (pomocí --inspect nebo --inspect-brk). V opačném případě kontejner spustí aplikaci normálně.

Vzdálené ladění můžete implementovat pomocí následujících kroků:

Vytvořte skript vstupního bodu v souboru pojmenovaném entrypoint.sh v kořenovém adresáři projektu s následujícím obsahem:

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

Upravte soubor Dockerfile tak, aby zkopíroval entrypoint.sh skript do kontejneru a nastavil ho jako vstupní bod. V případě potřeby také zpřístupňte ladicí port:

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

Aktivujte režim ladění nastavením proměnné prostředí ENABLE_DEBUG na true. Například pomocí Azure CLI:
```
az containerapp update \
  --name <CONTAINER_APP> \
  --env-vars ENABLE_DEBUG=true
```

Před spuštěním tohoto příkazu nezapomeňte zástupné symboly nahradit <> hodnotami.

Tento přístup nabízí flexibilní řešení, které vám umožní restartovat kontejner v režimu ladění změnou hodnoty proměnné prostředí při spuštění. Vyhne se nutnosti vytvořit novou revizi s různými CMD nastaveními pokaždé, když potřebujete ladit aplikaci.

Aspekty údržby a výkonu

Pokud chcete udržovat a optimalizovat výkon své aplikace v průběhu času, zajistěte efektivní správu změn proměnných prostředí, monitorování svých prostředků, udržujte své závislosti aktuální, správně nakonfigurujte škálování a nastavte monitorovací upozornění.

Změny proměnných prostředí

Vzhledem k tomu, že každá změna proměnných prostředí vyžaduje novou nasazenou revizi, proveďte všechny změny tajných kódů aplikace najednou. Po dokončení změn propojte tajné kódy s proměnnými prostředí revize. Tento přístup minimalizuje počet revizí a pomáhá udržovat čistou historii nasazení.

Přidělení prostředků

Monitorujte a upravte přidělení procesoru a paměti pro kontejnery na základě vzorců výkonu a využití aplikace. Nadměrné zřizování může vést k zbytečným nákladům, zatímco nedostatečné zřizování může způsobit problémy s výkonem.

Aktualizace závislostí

Pravidelně aktualizujte závislosti, abyste mohli těžit z vylepšení výkonu a oprav zabezpečení. Tento proces můžete automatizovat pomocí nástrojů, jako je npm-check-updates.

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

Stupňování

Nakonfigurujte automatické škálování na základě zatížení aplikace. Azure Container Apps podporuje horizontální škálování, které automaticky upraví počet instancí kontejnerů na základě využití procesoru nebo paměti.

Následující příklad ukazuje, jak nastavit pravidlo škálování na základě procesoru. Před spuštěním tohoto příkazu nezapomeňte zástupné symboly nahradit <> hodnotami.

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

Monitorování výstrah

Nastavte monitorování a výstrahy pro sledování výkonu a stavu vaší aplikace. Pomocí služby Azure Monitor můžete vytvářet výstrahy pro konkrétní metriky, jako jsou využití procesoru, využití paměti a doby odezvy.

Před spuštěním tohoto příkazu nezapomeňte zástupné symboly nahradit <> hodnotami.

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

Řízení zdrojů

Pomocí rozšíření Azure Container Apps pro Visual Studio Code můžete rychle vytvářet, upravovat a nasazovat kontejnerizované aplikace přímo ze sady Visual Studio Code.

Řešení problémů

Když ve službě Azure Container Apps narazí vaše aplikace na problémy za běhu, můžete k vyhledání a vyřešení problému použít protokolování, vzdálené ladění a upozornění kontroly stavu.

Logování

Povolte a nakonfigurujte protokolování pro zaznamenání protokolů aplikace. Ke shromažďování a analýze protokolů použijte Azure Monitor a Log Analytics. Před spuštěním těchto příkazů nezapomeňte zástupné symboly nahradit <> hodnotami.

Vytvořte nový pracovní prostor.

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

Pak vytvořte nové nastavení pracovního prostoru.

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

Debugging

Ke spuštěném kontejneru se připojujete pomocí nástrojů pro vzdálené ladění . Ujistěte se, že váš soubor Dockerfile zveřejňuje potřebné porty pro ladění.

# Expose the debugging port
EXPOSE 9229

Kontroly stavu

Nakonfigurujte kontroly stavu pro monitorování stavu vaší aplikace. Tato funkce zajišťuje, aby služba Azure Container Apps mohl kontejner restartovat, pokud přestane reagovat.

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

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-02-25

Sdílet prostřednictvím

Přehled JavaScriptu v Azure Container Apps

Konfigurace

Proměnné prostředí

Containers

Základní soubor Dockerfile

Nastavení vývojového prostředí pomocí Docker Compose

Produkční soubor Dockerfile

Nasazení

Začátek chladu

Zabezpečení

Zabezpečené proměnné prostředí

HTTPS a certifikáty

Správa závislostí

Zpracování chyb

Plynulé vypnutí

Logování

Nastavení logování v Azure Container Apps

Použití knihoven protokolování

Vzdálené debugování

Aspekty údržby a výkonu

Změny proměnných prostředí

Přidělení prostředků

Aktualizace závislostí

Stupňování

Monitorování výstrah

Řízení zdrojů

Řešení problémů

Logování

Debugging

Kontroly stavu

Související obsah

Váš názor

Další materiály