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

Oktatóanyag: Az Azure Functions monitorozása elosztott OpenTelemetria-nyomkövetéssel

Ez a cikk az Azure-függvény OpenTelemetria-támogatását mutatja be, amely integrált Application Insights- és OpenTelemetria-támogatással teszi lehetővé az elosztott nyomkövetést több függvényhívás között. Az első lépésekhez egy Azure Developer CLI-(azd) sablont használ a kódprojekt létrehozásához, valamint azt az Azure-üzembe helyezést, amelyben az alkalmazást futtatni szeretné.

Ebben az oktatóanyagban a azd eszközt a következőkre használhatja:

  • OpenTelemetry-kompatibilis projekt inicializálása sablonból.
  • Tekintse át az OpenTelemetry-integrációt lehetővé tevő kódot.
  • Futtassa és ellenőrizze az OpenTelemetry-kompatibilis alkalmazást helyileg.
  • Függvényalkalmazás és kapcsolódó erőforrások létrehozása az Azure-ban.
  • Telepítse a kódprojektet az Azure-beli függvényalkalmazásban.
  • Ellenőrizze az elosztott nyomkövetést az Application Insightsban.

A sablon által létrehozott szükséges Azure-erőforrások az azure-beli biztonságos és méretezhető függvényalkalmazások üzembe helyezésének aktuális ajánlott eljárásait követik. Ugyanez a azd parancs a kódprojektet is üzembe helyezi az új függvényalkalmazásban az Azure-ban.

Alapértelmezés szerint a Flex Consumption csomag egy használatalapú fizetéses számlázási modellt követ, ami azt jelenti, hogy ennek a rövid útmutatónak a végrehajtása néhány USD cent vagy annál kisebb költséggel jár az Azure-fiókjában.

Fontos

Ez a cikk jelenleg csak a C#, a Python és a TypeScript használatát támogatja. A rövid útmutató elvégzéséhez válasszon egyet a cikk tetején található támogatott nyelvek közül.

Előfeltételek

A projekt inicializálása

azd init A paranccsal hozzon létre egy helyi Azure Functions-kódprojektet egy Olyan sablonból, amely openTelemetry elosztott nyomkövetést tartalmaz.

  1. A helyi terminálban vagy parancssorban futtassa ezt a azd init parancsot egy üres mappában:

    azd init --template functions-quickstart-python-azd-otel -e flexquickstart-otel

    Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet az aktuális mappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. A környezet neve az Azure-ban létrehozott erőforráscsoport nevében is megjelenik.

  1. A helyi terminálban vagy parancssorban futtassa ezt a azd init parancsot egy üres mappában:

    azd init --template functions-quickstart-typescript-azd-otel -e flexquickstart-otel

    Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet az aktuális mappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. A környezet neve az Azure-ban létrehozott erőforráscsoport nevében is megjelenik.

  1. A helyi terminálban vagy parancssorban futtassa ezt a azd init parancsot egy üres mappában:

    azd init --template functions-quickstart-dotnet-azd-otel -e flexquickstart-otel

    Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet az aktuális mappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. A környezet neve az Azure-ban létrehozott erőforráscsoport nevében is megjelenik.

A kód áttekintése

A sablon egy teljes elosztott nyomkövetési forgatókönyvet hoz létre három, közösen működő funkcióval. Tekintsük át az OpenTelemetryvel kapcsolatos legfontosabb szempontokat:

OpenTelemetry-konfiguráció

A src/otel-sample/host.json fájl engedélyezi az OpenTelemetryt a Functions-gazdagépen:

{
  "version": "2.0",
  "telemetryMode": "OpenTelemetry",
  "extensions": {
    "serviceBus": {
        "maxConcurrentCalls": 10
    }
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  }
}

A kulcsbeállítás "telemetryMode": "OpenTelemetry" lehetővé teszi az elosztott nyomkövetést a függvényhívások között.

A src/OTelSample/host.json fájl engedélyezi az OpenTelemetryt a Functions-gazdagépen:

{
  "version": "2.0",
  "telemetryMode": "OpenTelemetry",
  "logging": {
    "OpenTelemetry": {
      "logLevel": {
        "Host.General": "Warning"
      }
    }
  }
}

A kulcsbeállítás "telemetryMode": "OpenTelemetry" lehetővé teszi az elosztott nyomkövetést a függvényhívások között.

Az OpenTelemetry függőségei

A src/otel-sample/requirements.txt fájl tartalmazza az OpenTelemetry-integrációhoz szükséges csomagokat:

azure-functions
azure-monitor-opentelemetry
requests

A azure-monitor-opentelemetry csomag az OpenTelemetry és az Application Insights integrációját biztosítja.

A src/otel-sample/package.json fájl tartalmazza az OpenTelemetry-integrációhoz szükséges csomagokat:

{
  "dependencies": {
    "@azure/functions": "^4.0.0",
    "@azure/functions-opentelemetry-instrumentation": "^0.1.0",
    "@azure/monitor-opentelemetry-exporter": "^1.0.0",
    "axios": "^1.6.0"
  }
}

A @azure/functions-opentelemetry-instrumentation és @azure/monitor-opentelemetry-exporter csomagok biztosítják az OpenTelemetry-integrációt az Application Insightsszal.

A .csproj fájl tartalmazza az OpenTelemetry-integrációhoz szükséges csomagokat:

<PackageReference Include="Azure.Monitor.OpenTelemetry.Exporter" Version="1.4.0" />
<PackageReference Include="Microsoft.Azure.Functions.Worker.OpenTelemetry" Version="1.4.0" />
<PackageReference Include="OpenTelemetry.Instrumentation.Http" Version="1.10.0" />

Ezek a csomagok biztosítják az OpenTelemetry-integrációt az Application Insightsszal és a HTTP-rendszerezéssel az elosztott nyomkövetéshez.

Függvény implementálása

A src/otel-sample/function_app.py függvényei egy elosztott nyomkövetési folyamatot mutatnak be.

Első HTTP-függvény

@app.function_name("first_http_function")
@app.route(route="first_http_function", auth_level=func.AuthLevel.ANONYMOUS)
def first_http_function(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Python HTTP trigger function (first) processed a request.')

    # Call the second function
    base_url = f"{req.url.split('/api/')[0]}/api"
    second_function_url = f"{base_url}/second_http_function"

    response = requests.get(second_function_url)
    second_function_result = response.text

    result = {
        "message": "Hello from the first function!",
        "second_function_response": second_function_result
    }

    return func.HttpResponse(
        json.dumps(result),
        status_code=200,
        mimetype="application/json"
    )

Második HTTP-függvény

@app.function_name("second_http_function")
@app.route(route="second_http_function", auth_level=func.AuthLevel.ANONYMOUS)
@app.service_bus_queue_output(arg_name="outputsbmsg", queue_name="%ServiceBusQueueName%",
                              connection="ServiceBusConnection")
def second_http_function(req: func.HttpRequest, outputsbmsg: func.Out[str]) -> func.HttpResponse:
    logging.info('Python HTTP trigger function (second) processed a request.')

    message = "This is the second function responding."

    # Send a message to the Service Bus queue
    queue_message = "Message from second HTTP function to trigger ServiceBus queue processing"
    outputsbmsg.set(queue_message)
    logging.info('Sent message to ServiceBus queue: %s', queue_message)

    return func.HttpResponse(
        message,
        status_code=200
    )

Service Bus üzenetsor eseményindító

@app.service_bus_queue_trigger(arg_name="azservicebus", queue_name="%ServiceBusQueueName%",
                               connection="ServiceBusConnection") 
def servicebus_queue_trigger(azservicebus: func.ServiceBusMessage):
    logging.info('Python ServiceBus Queue trigger start processing a message: %s',
                azservicebus.get_body().decode('utf-8'))
    time.sleep(5)  # Simulate processing work
    logging.info('Python ServiceBus Queue trigger end processing a message')

Az OpenTelemetry konfigurációja a következő helyen src/otel-sample/index.tsvan beállítva:

import { AzureFunctionsInstrumentation } from '@azure/functions-opentelemetry-instrumentation';
import { AzureMonitorTraceExporter, AzureMonitorLogExporter } from '@azure/monitor-opentelemetry-exporter';
import { getNodeAutoInstrumentations, getResourceDetectors } from '@opentelemetry/auto-instrumentations-node';
import { registerInstrumentations } from '@opentelemetry/instrumentation';
import { detectResources } from '@opentelemetry/resources';
import { LoggerProvider, SimpleLogRecordProcessor } from '@opentelemetry/sdk-logs';
import { NodeTracerProvider, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';

const resource = detectResources({ detectors: getResourceDetectors() });

const tracerProvider = new NodeTracerProvider({ 
  resource, 
  spanProcessors: [new SimpleSpanProcessor(new AzureMonitorTraceExporter())] 
});
tracerProvider.register();

const loggerProvider = new LoggerProvider({
  resource,
  processors: [new SimpleLogRecordProcessor(new AzureMonitorLogExporter())],
});

registerInstrumentations({
    tracerProvider,
    loggerProvider,
    instrumentations: [getNodeAutoInstrumentations(), new AzureFunctionsInstrumentation()],
});

A függvények a src/otel-sample/src/functions mappában vannak definiálva:

Első HTTP-függvény

export async function firstHttpFunction(
  request: HttpRequest,
  context: InvocationContext
): Promise<HttpResponseInit> {
  context.log("TypeScript HTTP trigger function (first) processed a request.");

  try {
    // Call the second function
    const baseUrl = request.url.split("/api/")[0];
    const secondFunctionUrl = `${baseUrl}/api/second_http_function`;

    const response = await axios.get(secondFunctionUrl);
    const secondFunctionResult = response.data;

    const result = {
      message: "Hello from the first function!",
      second_function_response: secondFunctionResult,
    };

    return {
      status: 200,
      body: JSON.stringify(result),
      headers: { "Content-Type": "application/json" },
    };
  } catch (error) {
    return {
      status: 500,
      body: JSON.stringify({ error: "Failed to process request" }),
    };
  }
}

Második HTTP-függvény

export async function secondHttpFunction(
  request: HttpRequest,
  context: InvocationContext
): Promise<HttpResponseInit> {
  context.log("TypeScript HTTP trigger function (second) processed a request.");

  const message = "This is the second function responding.";

  // Send a message to the Service Bus queue
  const queueMessage =
    "Message from second HTTP function to trigger ServiceBus queue processing";

  context.extraOutputs.set(serviceBusOutput, queueMessage);
  context.log("Sent message to ServiceBus queue:", queueMessage);

  return {
    status: 200,
    body: message,
  };
}

Service Bus-üzenetsor-eseményindító

export async function serviceBusQueueTrigger(
  message: unknown,
  context: InvocationContext
): Promise<void> {
  context.log("TypeScript ServiceBus Queue trigger start processing a message:", message);

  // Simulate processing time
  await new Promise((resolve) => setTimeout(resolve, 5000));

  context.log("TypeScript ServiceBus Queue trigger end processing a message");
}

Az OpenTelemetry konfigurációja a következő helyen src/OTelSample/Program.csvan beállítva:

using Azure.Monitor.OpenTelemetry.Exporter;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.OpenTelemetry;
using OpenTelemetry.Trace;

var builder = FunctionsApplication.CreateBuilder(args);

builder.ConfigureFunctionsWebApplication();

builder.Logging.AddOpenTelemetry(logging =>
{
    logging.IncludeFormattedMessage = true;
    logging.IncludeScopes = true;
});

builder.Services.AddOpenTelemetry()    
    .WithTracing(tracing =>
    {
        tracing.AddHttpClientInstrumentation();
    });

builder.Services.AddOpenTelemetry().UseAzureMonitorExporter();
builder.Services.AddOpenTelemetry().UseFunctionsWorkerDefaults();

builder.Services.AddHttpClient();

builder.Build().Run();

A függvények külön osztályfájlokban vannak definiálva:

Első HTTP-függvény

public class FirstHttpTrigger
{
    private readonly ILogger<FirstHttpTrigger> _logger;
    private readonly IHttpClientFactory _httpClientFactory;

    public FirstHttpTrigger(ILogger<FirstHttpTrigger> logger, IHttpClientFactory httpClientFactory)
    {
        _logger = logger;
        _httpClientFactory = httpClientFactory;
    }

    [Function("first_http_function")]
    public async Task<IActionResult> Run(
         [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req)
    {
        _logger.LogInformation("first_http_function function processed a request.");

        var baseUrl = $"{req.Url.AbsoluteUri.Split("/api/")[0]}/api";
        var targetUri = $"{baseUrl}/second_http_function";

        var client = _httpClientFactory.CreateClient();
        var response = await client.GetAsync(targetUri);
        var content = await response.Content.ReadAsStringAsync();

        return new OkObjectResult($"Called second_http_function, status: {response.StatusCode}, content: {content}");
    }
}

Második HTTP-függvény

public class SecondHttpTrigger
{
    private readonly ILogger<SecondHttpTrigger> _logger;

    public SecondHttpTrigger(ILogger<SecondHttpTrigger> logger)
    {
        _logger = logger;
    }

    [Function("second_http_function")]
    public MultiResponse Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req)
    {
        _logger.LogInformation("second_http_function function processed a request.");

        return new MultiResponse
        {
            Messages = new string[] { "Hello" },
            HttpResponse = req.CreateResponse(System.Net.HttpStatusCode.OK)
        };
    }
}

public class MultiResponse
{
    [ServiceBusOutput("%ServiceBusQueueName%", Connection = "ServiceBusConnection")]
    public string[]? Messages { get; set; }

    [HttpResult]
    public HttpResponseData? HttpResponse { get; set; }
}

Service Bus Queue-eseményindító

public class ServiceBusQueueTrigger
{
    private readonly ILogger<ServiceBusQueueTrigger> _logger;

    public ServiceBusQueueTrigger(ILogger<ServiceBusQueueTrigger> logger)
    {
        _logger = logger;
    }

    [Function("servicebus_queue_trigger")]
    public async Task Run(
        [ServiceBusTrigger("%ServiceBusQueueName%", Connection = "ServiceBusConnection")]
        ServiceBusReceivedMessage message,
        ServiceBusMessageActions messageActions)
    {
        _logger.LogInformation("Message ID: {id}", message.MessageId);
        _logger.LogInformation("Message Body: {body}", message.Body);

        // Complete the message
        await messageActions.CompleteMessageAsync(message);
    }
}

Elosztott nyomkövetési folyamat

Ez az architektúra egy teljes elosztott nyomkövetési forgatókönyvet hoz létre a következő viselkedéssel:

  1. Az első HTTP-függvény HTTP-kérést kap, és meghívja a második HTTP-függvényt
  2. A második HTTP-függvény válaszol, és üzenetet küld a Service Busnak
  3. A Service Bus-eseményindító késleltetve dolgozza fel az üzenetet a feldolgozási munka szimulálásához

Az OpenTelemetry implementáció főbb szempontjai:

  • OpenTelemetry-integráció: A host.json fájl engedélyezi az OpenTelemetryt a következővel: "telemetryMode": "OpenTelemetry"
  • Függvényláncolás: Az első függvény HTTP-kérések használatával hívja meg a másodikat, és korrelált nyomkövetéseket hoz létre
  • Service Bus-integráció: A második függvény a Service Busnak ad ki kimenetet, amely a harmadik függvényt aktiválja
  • Névtelen hitelesítés: A HTTP-függvények használják auth_level=func.AuthLevel.ANONYMOUS, ezért nincs szükség függvénykulcsra

A teljes sablonprojektet itt tekintheti át.

  • OpenTelemetria-integráció: A index.ts fájl konfigurálja az OpenTelemetryt az Azure Monitor-exportőrökkel nyomkövetésekhez és naplókhoz
  • Függvényláncolás: Az első függvény automatikus nyomkövetési propagálású axios használatával hívja meg a másodikat
  • Service Bus-integráció: A második függvény kimeneti kötések használatával kimenetet ad ki a Service Busnak, amely a harmadik függvényt aktiválja
  • Felügyelt identitás: Minden Service Bus-kapcsolat felügyelt identitást használ kapcsolati sztringek helyett
  • Feldolgozási szimuláció: A Service Bus-eseményindító 5 másodperces késleltetése az üzenetfeldolgozási munkát szimulálja

A teljes sablonprojektet itt tekintheti át.

  • OpenTelemetria-integráció: A Program.cs fájl konfigurálja az OpenTelemetryt az Azure Monitor-exportőrrel
  • Függvényláncolás: Az első függvény meghívja a másodikat a HttpClient és az OpenTelemetry rendszerezés használatával
  • Service Bus-integráció: A második függvény kimeneti kötések használatával kimenetet ad ki a Service Busnak, amely a harmadik függvényt aktiválja
  • Felügyelt identitás: Minden Service Bus-kapcsolat felügyelt identitást használ kapcsolati sztringek helyett
  • .NET 8 Izolált feldolgozó: A legújabb Azure Functions .NET izolált feldolgozói modellt használja a jobb teljesítmény és rugalmasság érdekében

A teljes sablonprojektet itt tekintheti át.

Miután helyben ellenőrizte a függvényeket, ideje közzétenni őket az Azure-ban.

Telepítés az Azure-ra

Ez a projekt úgy van konfigurálva, hogy a azd up parancsot használva telepítse ezt a projektet az Azure-ban egy új függvényalkalmazásba, egy Flex Consumtion csomagban OpenTelemetry-támogatással.

Jótanács

Ez a projekt tartalmaz egy Bicep-fájlkészletet, amelyek azd használatával biztonságos üzembe helyezést hoznak létre egy Flex fogyasztási tervhez, amely az ajánlott legjobb gyakorlatokat követi, beleértve a kezelt identitáskapcsolatokat is.

  1. Futtassa ezt a parancsot, hogy azd létrehozza a szükséges Azure-erőforrásokat az Azure-ban, és üzembe helyezze a kódprojektet az új függvényalkalmazásban:

    azd up

    A gyökérmappa tartalmazza a azure.yaml szükséges definíciófájlt azd.

    Ha még nem jelentkezett be, a rendszer arra kéri, hogy hitelesítse az Azure-fiókjával.

  2. Amikor a rendszer kéri, adja meg a szükséges üzembehelyezési paramétereket:

    Paraméter Description
    Azure-előfizetés Előfizetés, amelyben az erőforrások létrejönnek.
    Azure-lokáció Azure-régió, amelyben létre kell hozni az új Azure-erőforrásokat tartalmazó erőforráscsoportot. Csak azok a régiók jelennek meg, amelyek jelenleg támogatják a Rugalmas felhasználás csomagot.

    A azd up parancs a Bicep konfigurációs fájljaival a következő kérdésekre adott választ használja az üzembehelyezési feladatok elvégzéséhez:

    • Hozza létre és konfigurálja ezeket a szükséges Azure-erőforrásokat (a következőnek felel meg azd provision):

      • Az Azure Functions Flex használati csomagja és függvényalkalmazása az OpenTelemetry engedélyezésével
      • Azure Storage (kötelező) és Application Insights (ajánlott)
      • Service Bus-névtér és üzenetsor elosztott nyomkövetési bemutatóhoz
      • Hozzáférési szabályzatok és szerepkörök a fiókhoz
      • Szolgáltatásközi kapcsolatok felügyelt identitásokkal (tárolt kapcsolati sztring helyett)

    • Csomagolja és telepítse a kódot az üzembehelyezési tárolóba (ez egyenértékű a következőval azd deploy). Az alkalmazás ezután elindul, és az üzembe helyezett csomagban fut.

    A parancs sikeres végrehajtása után megjelennek a létrehozott erőforrásokra mutató hivatkozások.

Elosztott nyomkövetés tesztelése

Most tesztelheti az OpenTelemetry elosztott nyomkövetési funkcióit az üzembe helyezett függvények meghívásával és az Application Insights telemetriájának megfigyelésével.

A függvény meghívása az Azure-ban

A függvényvégpontokat az Azure-ban http-kérésekkel hívhatja meg az URL-címekre. Mivel a sablon HTTP-függvényei névtelen hozzáféréssel vannak konfigurálva, nincs szükség függvénykulcsra.

  1. A helyi terminálban vagy parancssorban futtassa ezt a parancsot a függvényalkalmazás nevének lekéréséhez és az URL-cím létrehozásához:

    APP_NAME=$(azd env get-value AZURE_FUNCTION_NAME)
echo "Function URL: https://$APP_NAME.azurewebsites.net/api/first_http_function"

    A azd env get-value parancs lekéri a függvényalkalmazás nevét a helyi környezetből.

  2. Tesztelje a függvényt a böngészőben az URL-címre való navigálással:

    https://your-function-app.azurewebsites.net/api/first_http_function

    Cserélje le your-function-app az előző lépésben szereplő tényleges függvényalkalmazás nevére. Ez az egyetlen kérés egy elosztott nyomkövetést hoz létre, amely mindhárom függvényen végigfolyik.

Elosztott nyomkövetés megtekintése az Application Insightsban

A függvény meghívása után megfigyelheti a teljes elosztott nyomkövetést az Application Insightsban:

Megjegyzés:

A függvény meghívása után eltarthat néhány percig, amíg a telemetriai adatok megjelennek az Application Insightsban. Ha nem látja azonnal az adatokat, várjon néhány percet, és frissítse a nézetet.

  1. Nyissa meg az Application Insights-erőforrást az Azure Portalon (ugyanabban az erőforráscsoportban található, mint a függvényalkalmazás).

  2. Nyissa meg az alkalmazástérképet az elosztott nyomkövetés mindhárom függvényben való megtekintéséhez. Látnia kell, ahogy a HTTP-kérés átjut a függvényeken, majd továbbhalad a Service Buson.

  3. A tranzakciókereséssel megkeresheti a kérést, és megtekintheti a teljes nyomkövetési ütemtervet. Keressen tranzakciókat a függvényalkalmazásból.

  4. Válasszon ki egy adott tranzakciót a végpontok közötti nyomkövetés megtekintéséhez, amely a következőt mutatja:

    • A HTTP-kérés a következőre: first_http_function
    • A belső HTTP-hívás a(z) second_http_function-ra/ről
    • Az elküldött Service Bus-üzenet
    • A servicebus_queue_trigger feldolgozza a Service Bus üzenetét

  5. A nyomkövetési részletekben a következőt láthatja:

    • Időzítési információk: Az egyes lépések hossza
    • Függőségek: A függvények közötti kapcsolatok
    • Naplók: A nyomkövetéssel korrelált alkalmazásnaplók
    • Teljesítménymetrikák: Válaszidők és átviteli sebesség

Ez a példa a teljes körű elosztott nyomkövetést mutatja be több Azure Functionsben OpenTelemetry-integrációval, így teljes betekintést nyújt az alkalmazás viselkedésébe és teljesítményébe.

A kód ismételt üzembe helyezése

Futtassa a azd up parancsot annyiszor, amennyi szükséges az Azure-erőforrások kiépítéséhez és a kódfrissítések üzembe helyezéséhez a függvényalkalmazásban.

Megjegyzés:

A legújabb üzembehelyezési csomag mindig felülírja az üzembe helyezett kódfájlokat.

A kérésekre adott kezdeti válaszokat azd és az általuk azd létrehozott környezeti változókat a rendszer helyileg tárolja a nevesített környezetben. azd env get-values A paranccsal áttekintheti a környezet összes változóját, amelyet a parancs az Azure-erőforrások létrehozásakor használ.

Erőforrások tisztítása

Ha végzett a függvényalkalmazással és a kapcsolódó erőforrásokkal, ezzel a paranccsal törölheti a függvényalkalmazást és annak kapcsolódó erőforrásait az Azure-ból, és elkerülheti a további költségek felmerülését:

azd down --no-prompt

Megjegyzés:

A --no-prompt beállítás arra utasítja azd , hogy az erőforráscsoportot anélkül törölje, hogy ön megerősítést kap.

Ez a parancs nincs hatással a helyi kódprojektre.

Kapcsolódó tartalom

  • Last updated on