Freigeben über

JavaScript für Azure-Container-Apps – Übersicht

Azure-Container-Apps können jede containerisierte JavaScript-Anwendung in der Cloud ausführen und flexible Optionen für die Bereitstellung Ihrer Anwendungen bieten.

Konfiguration

Mit Azure Container-Apps können Sie die Bereitstellung Ihrer JavaScript-Anwendungen durch eine effektive Containerisierung optimieren, einschließlich der Einrichtung von Umgebungsvariablen, dem Entwerfen effizienter Dockerfiles und der Organisation des Erstellungsprozesses Ihrer Anwendung.

Umgebungsvariablen

Umgebungsvariablen sind für die Konfiguration Ihrer Anwendung von entscheidender Bedeutung. Verwenden Sie eine .env Datei, um diese Variablen lokal zu verwalten und sicherzustellen, dass sie in der Produktion mit einem Dienst wie Azure Key Vault sicher verwaltet werden.

Das folgende Beispiel zeigt, wie Sie Variablen für Ihre Anwendung erstellen.

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

Behälter

Eine gut konfigurierte Dockerfile-Datei ist für die Containerisierung Ihrer Anwendung unerlässlich:

  • Verwenden Sie eine Dockerfile-Basisdatei: Wenn mehrere Projekte ein gemeinsames Setup verwenden, können Sie eine Dockerfile-Basis erstellen, die diese allgemeinen Schritte enthält. Die Dockerfile-Datei jedes Projekts kann dann mit FROM diesem Basisimage beginnen und projektspezifische Konfigurationen hinzufügen.

  • Parametrisierung von Buildargumenten: Sie können Buildargumente (ARG) in Ihrer Dockerfile-Datei verwenden, um sie flexibler zu gestalten. Auf diese Weise können Sie beim Erstellen für Entwicklung, Staging oder Produktion unterschiedliche Werte für diese Argumente übergeben.

  • Optimiertes Node.js Basisimage: Stellen Sie sicher, dass Sie ein geeignetes Node.js Basisimage verwenden. Erwägen Sie die Verwendung kleinerer, optimierter Bilder wie z. B. der Alpinen Varianten, um den Aufwand zu reduzieren.

  • Minimale Dateien – Nur Wesentliches kopieren: Konzentrieren Sie sich auf das Kopieren nur der erforderlichen Dateien in Ihren Container. Erstellen Sie eine .dockerignore-Datei, um sicherzustellen, dass Entwicklungsdateien wie .env und node_modules nicht kopiert werden. Diese Datei hilft beim Beschleunigen von Builds in Fällen, in denen Entwickler unnötige Dateien kopiert haben.

  • Trennen Sie Build und Laufzeit mit mehrstufigen Builds: Verwenden Sie mehrstufige Builds, um ein schlankes endgültiges Image zu erstellen, indem Sie die Buildumgebung von der Laufzeitumgebung trennen.

  • Vorkompilierte Artefakte durch Kompilieren und Bündeln: Vorkompilieren der Anwendungsartefakte (z. B. Kompilieren von TypeScript oder Bündeln von JavaScript), bevor sie in die Laufzeitumgebung kopiert werden, kann die Imagegröße minimieren, die Containerbereitstellung beschleunigen und das Kaltstartverhalten verbessern. Die sorgfältige Sortierung von Anweisungen in Ihrer Dockerfile optimiert auch die Zwischenspeicherung und die Neuerstellungszeiten.

  • Docker Compose für Entwicklungsumgebungen: Mit Docker Compose können Sie Docker-Anwendungen mit mehreren Containern definieren und ausführen. Dieser Ansatz mit mehreren Containern ist nützlich für die Einrichtung von Entwicklungsumgebungen. Sie können den Buildkontext und Dockerfile in die Erstelldatei einschließen. Mit dieser Kapselungsebene können Sie bei Bedarf unterschiedliche Dockerfiles für unterschiedliche Dienste verwenden.

Dockerfile-Basisdatei

Diese Datei dient als gemeinsamer Ausgangspunkt für Ihre Node.js Bilder. Sie können sie mit einer FROM Direktive in Dockerfiles verwenden, die auf dieses Basisimage verweisen. Verwenden Sie entweder eine Versionsnummer oder einen Commit, um die aktuelle und sichere Version des Images zu unterstützen.

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

Wenn Sie Werte mithilfe des --build-arg Flags während des Buildvorgangs übergeben, überschreiben die übergebenen Werte die hartcodierten Standardwerte in Ihrer Dockerfile-Datei.

Beispiel:

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

In diesem Beispiel werden die Umgebungsvariablen PORT und ENABLE_DEBUG auf explizite Werte anstelle ihrer Standardwerte festgelegt.

Container-Image-Tagging-Konventionen, wie die Verwendung von latest, stellen eine Konvention dar. Erfahren Sie mehr über Empfehlungen zum Tagging und zur Versionierung von Container-Images.

Einrichten der Entwicklungsumgebung mit Docker Compose

In der folgenden Beispielkonfiguration wird eine entwicklungsspezifische Dockerfile (Dockerfile.dev) zusammen mit Volume-Bereitstellungen für Live-Reloading und lokale Quellensynchronisierung verwendet.

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}

Um Docker Compose mit benutzerdefinierten Werten zu starten, können Sie die Umgebungsvariablen in der Befehlszeile exportieren. Beispiel:

PORT=4000 ENABLE_DEBUG=true docker compose up

Produktions-Dockerfile

Dieses mehrstufige Dockerfile erstellt Ihre Anwendung und generiert ein schlankes Laufzeitimage. Stellen Sie sicher, dass die .dockerignore Datei bereits im Quellcode enthalten ist, damit der COPY . . Befehl keine Dateien kopiert, die für die Entwicklungsumgebung spezifisch sind, die Sie in der Produktion nicht benötigen.

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

Mit dem Einstiegspunktskript können Sie eine Verbindung mit Ihrer Container-App zum Remotedebugging herstellen.

Führen Sie Folgendes aus, um einen Container aus dem erstellten Produktionsimage mit benutzerdefinierten Umgebungsvariablen auszuführen:

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

Stellen Sie für Produktionsbuilds sicher, dass Sie das richtige Versionstag verwenden, das möglicherweise nicht latest ist. Container-Image-Tagging-Konventionen wie die Verwendung von latest sind eine Konvention. Erfahren Sie mehr über Empfehlungen zum Tagging und zur Versionierung von Container-Images.

Einsatz

Um eine kontinuierliche Integration/kontinuierliche Bereitstellung (CI/CD) zu unterstützen, richten Sie eine CI/CD-Pipeline mit GitHub-Aktionen, Azure DevOps oder einem anderen CI/CD-Tool ein, um den Bereitstellungsprozess zu automatisieren.

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

Wenn Sie Docker Registry verwenden, melden Sie sich bei Ihrer Registrierung an, und übertragen Sie Dann Ihre Docker-Images an eine Containerregistrierung wie Azure Container Registry (ACR) oder 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>

Kaltstarts

Optimieren Sie Ihren Produktions-Build, indem Sie nur den wesentlichen Code und Abhängigkeiten einschließen. Um sicherzustellen, dass Ihre Nutzlast so schlanke wie möglich ist, verwenden Sie einen der folgenden Ansätze:

  • Mehrstufige Docker-Builds oder Bundler: Verwenden Sie Build- und Bündelungstools wie Webpack oder Rollup, um die kleinste Nutzlast für Ihren Container zu erstellen. Wenn Sie nur das kompilieren und bündeln, was für die Produktion erforderlich ist, können Sie die Größe Ihres Containers minimieren und die Kaltstartzeiten verbessern.

  • Verwalten Sie Abhängigkeiten sorgfältig: Halten Sie Ihren node_modules Ordner schlanker, indem Sie nur die Pakete einschließen, die für die Ausführung von Produktionscode erforderlich sind. Führen Sie keine Entwicklungs- oder Testabhängigkeiten im dependencies-Abschnitt Ihrer package.json auf. Entfernen Sie nicht verwendete Abhängigkeiten und stellen Sie sicher, dass Ihre package.json- und Sperrdatei konsistent bleiben.

Sicherheit

Sicherheitsaspekte für JavaScript-Entwickler, die Azure Container Apps verwenden, umfassen das Sichern von Umgebungsvariablen (wie die Verwendung von Azure Key Vault), die Gewährleistung von HTTPS mit der richtigen Zertifikatverwaltung, die Aufrechterhaltung von auf dem aktuellen Stand gehaltenen Abhängigkeiten durch regelmäßige Audits sowie die Implementierung robuster Protokollierung und Überwachung, um Bedrohungen schnell zu erkennen und zu reagieren.

Sichere Umgebungsvariablen

Stellen Sie sicher, dass vertrauliche Informationen wie Datenbankverbindungszeichenfolgen und API-Schlüssel sicher gespeichert werden. Verwenden Sie Azure Key Vault, um geheime Schlüssel und Umgebungsvariablen sicher zu verwalten.

Bevor Sie diesen Befehl ausführen, sollten Sie die Platzhalter ersetzen, die von <> umgeben sind, mit Ihren Werten.

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

HTTPS und Zertifikate

Stellen Sie sicher, dass Ihre Anwendung über HTTPS bereitgestellt wird. Azure Container-Apps können Zertifikate für Sie verwalten. Konfigurieren Sie Ihre benutzerdefinierte Domäne und Ihr Zertifikat im Azure-Portal.

Abhängigkeitsverwaltung

Aktualisieren Sie Ihre Abhängigkeiten regelmäßig, um Sicherheitsrisiken zu vermeiden. Verwenden Sie Tools wie npm audit, um auf Sicherheitslücken zu überprüfen.

npm audit

Fehlerbehandlung

Implementieren Sie eine robuste Fehlerbehandlung in Ihrer Node.js-Anwendung. Verwenden Sie Middleware in Express oder Fastify, um Fehler ordnungsgemäß zu behandeln.

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

Ordnungsgemäßes Herunterfahren

Das ordnungsgemäße Herunterfahren Ihrer Anwendung ist entscheidend, um sicherzustellen, dass In-Flight-Anforderungen vollständig und Ressourcen ordnungsgemäß freigegeben werden. Dies trägt dazu bei, Datenverluste zu verhindern und eine reibungslose Benutzererfahrung bei Bereitstellungen oder Skalierungsereignissen zu gewährleisten. Im folgenden Beispiel wird ein Ansatz veranschaulicht, der Node.js und Express verwendet, um Schließungssignale ordnungsgemäß zu verarbeiten.

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

Protokollierung

In Azure-Container-Apps werden sowohl console.log-Aufrufe als auch console.error-Aufrufe automatisch erfasst und protokolliert. Azure Container Apps erfasst die Standardausgabe (stdout) und den Standardfehlerstrom (stderr) aus Ihrer Anwendung und stellt sie in Azure Monitor und Log Analytics zur Verfügung.

Einrichten der Protokollierung in Azure Container Apps

Um sicherzustellen, dass Ihre Protokolle ordnungsgemäß erfasst und barrierefrei sind, müssen Sie Diagnoseeinstellungen für Ihre Azure-Container-App konfigurieren. Setup ist ein zweistufiger Prozess.

  1. Diagnoseeinstellungen aktivieren: Verwenden Sie die Azure CLI, um Diagnoseeinstellungen für Ihre Azure-Container-App zu aktivieren.

    Bevor Sie diesen Befehl ausführen, stellen Sie sicher, dass Sie die Platzhalter, die von <> umgeben sind, durch Ihre Werte ersetzen.

    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. Greifen Sie auf Protokolle im Portal zu, indem Sie zu Ihrem Log Analytics-Arbeitsbereich wechseln und die Protokolle abfragen.

Verwenden von Protokollierungsbibliotheken

Während console.log und console.error automatisch erfasst werden, bietet die Verwendung einer Protokollierungsbibliothek wie Winston mehr Flexibilität und Kontrolle über Ihre Protokollierung. Mit dieser Flexibilität können Sie Protokolle formatieren, Protokollstufen festlegen und Protokolle an mehrere Ziele wie Dateien oder externe Protokollierungsdienste ausgeben.

Im folgenden Beispiel wird veranschaulicht, wie Winston zum Speichern von Protokollen mit hoher Genauigkeit konfiguriert wird.

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

Verwenden Sie zum Verwenden des Loggers die folgende Syntax in Ihrer Anwendung:

import logger from './logger';

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

Remotedebuggen

Zum Aktivieren des Remotedebuggings können Sie den integrierten Node-Inspektor verwenden. Anstatt die Debug-Einstellungen in die Dockerfile CMD zu codieren, können Sie das Remote-Debugging dynamisch aktivieren, indem Sie ein Shellskript als Einstiegspunkt Ihres Containers verwenden.

Das folgende Skript überprüft eine Umgebungsvariable (z. B ENABLE_DEBUG. ) beim Starten des Containers. Wenn die Variable auf true festgelegt ist, startet das Skript Node.js im Debugmodus (mit --inspect oder --inspect-brk). Andernfalls startet der Container die Anwendung normal.

Sie können das Remotedebugging mit den folgenden Schritten implementieren:

  1. Erstellen Sie ein Einstiegspunktskript in einer Datei, die im Stammverzeichnis Ihres Projekts mit dem folgenden Inhalt benannt entrypoint.sh ist:

    #!/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. Ändern Sie Ihre Dockerfile-Datei, um das entrypoint.sh Skript in den Container zu kopieren und als Einstiegspunkt festzulegen. Machen Sie den Debugport bei Bedarf auch verfügbar:

    # 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. Aktivieren Sie den Debug-Modus, indem Sie die Umgebungsvariable ENABLE_DEBUG auf true setzen. Verwenden Sie z. B. die Azure CLI:

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

Bevor Sie diesen Befehl ausführen, ersetzen Sie die Platzhalter, die von <> umgeben sind, durch Ihre Werte.

Dieser Ansatz bietet eine flexible Lösung, mit der Sie den Container im Debugmodus neu starten können, indem Sie eine Umgebungsvariable beim Start aktualisieren. Es vermeidet die Notwendigkeit, bei jedem Debuggen der Anwendung eine neue Revision mit unterschiedlichen CMD Einstellungen zu erstellen.

Überlegungen zur Wartung und Leistung

Um die Leistung Ihrer Anwendung im Laufe der Zeit aufrechtzuerhalten und zu optimieren, stellen Sie sicher, dass Sie Änderungen der Umgebungsvariablen effizient verwalten, Ihre Ressourcen überwachen, Ihre Abhängigkeiten up-to-datum beibehalten, die Skalierung ordnungsgemäß konfigurieren und Überwachungswarnungen einrichten.

Änderungen der Umgebungsvariable

Da jede Änderung an Umgebungsvariablen eine neue bereitgestellte Version erfordert, nehmen Sie alle Änderungen an den Geheimnissen der App gleichzeitig vor. Wenn Änderungen abgeschlossen sind, verknüpfen Sie die geheimen Schlüssel mit den Umgebungsvariablen der Überarbeitung. Dieser Ansatz minimiert die Anzahl der Überarbeitungen und trägt dazu bei, einen sauberen Bereitstellungsverlauf beizubehalten.

Ressourcenallokation

Überwachen und Anpassen der CPU- und Speicherzuweisung für Ihre Container basierend auf den Leistungs- und Nutzungsmustern der Anwendung. Die Überbereitstellung kann zu unnötigen Kosten führen, während die Unterbereitstellung Leistungsprobleme verursachen kann.

Updates für Abhängigkeiten

Aktualisieren Sie Ihre Abhängigkeiten regelmäßig, um von Leistungsverbesserungen und Sicherheitspatches zu profitieren. Verwenden Sie Tools wie npm-check-updates, um diesen Prozess zu automatisieren.

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

Scaling

Konfigurieren Sie die automatische Skalierung basierend auf der Last der Anwendung. Azure-Container-Apps unterstützen die horizontale Skalierung, wodurch die Anzahl der Containerinstanzen basierend auf der CPU- oder Speicherauslastung automatisch angepasst wird.

Im folgenden Beispiel wird das Festlegen einer CPU-basierten Skalierungsregel veranschaulicht. Bevor Sie diesen Befehl ausführen, ersetzen Sie die Platzhalter, die von <> umgeben sind, durch Ihre Werte.

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

Überwachungswarnungen

Richten Sie Überwachung und Warnungen ein, um die Leistung und den Status Ihrer Anwendung nachzuverfolgen. Verwenden Sie Azure Monitor, um Warnungen für bestimmte Metriken wie CPU-Auslastung, Arbeitsspeicherauslastung und Reaktionszeiten zu erstellen.

Bevor Sie diesen Befehl ausführen, ersetzen Sie die Platzhalter, die von <> umgeben sind, durch Ihre Werte.

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

Ressourcenverwaltung

Verwenden Sie die Azure Container Apps-Erweiterung für Visual Studio Code, um containerisierte Apps schnell aus Visual Studio Code zu erstellen, zu bearbeiten und bereitzustellen.

Problembehandlung

Wenn Ihre Anwendung Laufzeitprobleme in Azure-Container-Apps aufweist, können Sie mithilfe von Protokollierungs-, Remotedebugging- und Integritätsprüfungswarnungen das Problem finden und beheben.

Protokollierung

Aktivieren und konfigurieren Sie die Protokollierung zum Erfassen von Anwendungsprotokollen. Verwenden Sie Azure Monitor und Log Analytics, um Protokolle zu sammeln und zu analysieren. Bevor Sie diese Befehle ausführen, müssen Sie die Platzhalter, die von <> umschlossen sind, durch Ihre Werte ersetzen.

  1. Erstellen Sie einen neuen Arbeitsbereich.

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

  2. Erstellen Sie dann eine neue Arbeitsbereichseinstellung.

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

Fehlersuche

Sie verwenden Remote-Debugging-Tools, um eine Verbindung mit dem ausgeführten Container herzustellen. Stellen Sie sicher, dass Ihre Dockerfile die erforderlichen Ports für das Debuggen verfügbar macht.

# Expose the debugging port
EXPOSE 9229

Gesundheitschecks

Konfigurieren Sie Integritätsprüfungen, um die Integrität Ihrer Anwendung zu überwachen. Mit diesem Feature wird sichergestellt, dass Azure-Container-Apps Ihren Container neu starten können, wenn er nicht mehr reagiert.

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

Verwandte Inhalte

  • Last updated on