Szybki start: tworzenie skalowalnego internetowego interfejsu API przy użyciu usługi Azure Functions

W tym szybkim starcie użyjesz narzędzi wiersza polecenia dla deweloperów Azure, aby utworzyć skalowalny web API z punktami końcowymi funkcji, które odpowiadają na żądania HTTP. Po przetestowaniu kodu lokalnie wdrożysz go w nowej aplikacji funkcji bezserwerowej utworzonej w planie Flex Consumption w usłudze Azure Functions.

Źródło projektu używa interfejsu wiersza polecenia dla deweloperów platformy Azure (azd), aby uprościć wdrażanie kodu na platformie Azure. To wdrożenie jest zgodne z bieżącymi najlepszymi rozwiązaniami dotyczącymi bezpiecznych i skalowalnych wdrożeń usługi Azure Functions.

Domyślnie plan Flex Consumption jest zgodny z modelem rozliczeń z płatnością za rzeczywiste użycie, co oznacza, że ukończenie tego rozpoczęcia pracy wiąże się z niewielkim kosztem kilku centów amerykańskich lub mniej na koncie platformy Azure.

Prerequisites

• Konto platformy Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.

• Azure CLI dla deweloperów

• Podstawowe narzędzia usługi Azure Functions

• Zestaw SDK platformy .NET 8.0

• Emulator magazynu Azurite

• Java 17 Developer Kit
  • Jeśli używasz innej obsługiwanej wersji języka Java, musisz zaktualizować plik pom.xml projektu.
  • Zmienna JAVA_HOME środowiskowa musi być ustawiona na lokalizację instalacji poprawnej wersji zestawu Java Development Kit (JDK).
• Apache Maven 3.8.x

• Node.js 20

• PowerShell 7.2

• Zestaw SDK dla platformy .NET 6.0

• Python 3.11

• Emulator magazynu Azurite

• Bezpieczne narzędzie do testowania HTTP do wysyłania żądań przy użyciu ładunków JSON do punktów końcowych funkcji. W tym artykule jest używany program curl.

Inicjowanie projektu

Użyj polecenia , azd init aby utworzyć lokalny projekt kodu usługi Azure Functions na podstawie szablonu.

1. W lokalnym terminalu lub wierszu polecenia uruchom to azd init polecenie w pustym folderze:

   azd init --template functions-quickstart-dotnet-azd -e httpendpoint-dotnet
   

   To polecenie ściąga pliki projektu z repozytorium szablonów i inicjuje projekt w bieżącym folderze. Flaga -e ustawia nazwę bieżącego środowiska. W azd środowisko systemowe zapewnia unikatowy kontekst wdrażania dla twojej aplikacji i można zdefiniować więcej niż jeden z nich. Jest ona również używana w nazwie grupy zasobów utworzonej na platformie Azure.

2. Uruchom to polecenie, aby przejść do http folderu aplikacji:

   cd http
   

3. Utwórz plik o nazwie local.settings.json w http folderze zawierającym te dane JSON:

   {
       "IsEncrypted": false,
       "Values": {
           "AzureWebJobsStorage": "UseDevelopmentStorage=true",
           "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated"
       }
   }
   

   Ten plik jest wymagany podczas uruchamiania lokalnego.

1. W lokalnym terminalu lub wierszu polecenia uruchom to azd init polecenie w pustym folderze:

   azd init --template azure-functions-java-flex-consumption-azd -e httpendpoint-java 
   

   To polecenie ściąga pliki projektu z repozytorium szablonów i inicjuje projekt w bieżącym folderze. Flaga -e ustawia nazwę bieżącego środowiska. W azd środowisko systemowe zapewnia unikatowy kontekst wdrażania dla twojej aplikacji i można zdefiniować więcej niż jeden z nich. Jest ona również używana w nazwie grupy zasobów utworzonej na platformie Azure.

2. Uruchom to polecenie, aby przejść do http folderu aplikacji:

   cd http
   

3. Utwórz plik o nazwie local.settings.json w http folderze zawierającym te dane JSON:

   {
       "IsEncrypted": false,
       "Values": {
           "AzureWebJobsStorage": "UseDevelopmentStorage=true",
           "FUNCTIONS_WORKER_RUNTIME": "java"
       }
   }
   

   Ten plik jest wymagany podczas uruchamiania lokalnego.

1. W lokalnym terminalu lub wierszu polecenia uruchom to azd init polecenie w pustym folderze:

   azd init --template functions-quickstart-javascript-azd -e httpendpoint-js
   

   To polecenie ściąga pliki projektu z repozytorium szablonów i inicjuje projekt w folderze głównym. Flaga -e ustawia nazwę bieżącego środowiska. W azd środowisko systemowe zapewnia unikatowy kontekst wdrażania dla twojej aplikacji i można zdefiniować więcej niż jeden z nich. Jest ona również używana w nazwie grupy zasobów utworzonej na platformie Azure.

2. Utwórz plik o nazwie local.settings.json w folderze głównym zawierającym te dane JSON:

   {
       "IsEncrypted": false,
       "Values": {
           "AzureWebJobsStorage": "UseDevelopmentStorage=true",
           "FUNCTIONS_WORKER_RUNTIME": "node"
       }
   }
   

   Ten plik jest wymagany podczas uruchamiania lokalnego.

1. W lokalnym terminalu lub wierszu polecenia uruchom to azd init polecenie w pustym folderze:

   azd init --template functions-quickstart-powershell-azd -e httpendpoint-ps
   

   To polecenie ściąga pliki projektu z repozytorium szablonów i inicjuje projekt w folderze głównym. Flaga -e ustawia nazwę bieżącego środowiska. W azd środowisko systemowe zapewnia unikatowy kontekst wdrażania dla twojej aplikacji i można zdefiniować więcej niż jeden z nich. Jest ona również używana w nazwie grupy zasobów utworzonej na platformie Azure.

2. Uruchom to polecenie, aby przejść do src folderu aplikacji:

   cd src
   

3. Utwórz plik o nazwie local.settings.json w src folderze zawierającym te dane JSON:

   {
       "IsEncrypted": false,
       "Values": {
           "AzureWebJobsStorage": "UseDevelopmentStorage=true",
           "FUNCTIONS_WORKER_RUNTIME": "powershell",
           "FUNCTIONS_WORKER_RUNTIME_VERSION": "7.2"
       }
   }
   

   Ten plik jest wymagany podczas uruchamiania lokalnego.

1. W lokalnym terminalu lub wierszu polecenia uruchom to azd init polecenie w pustym folderze:

   azd init --template functions-quickstart-typescript-azd -e httpendpoint-ts
   

   To polecenie ściąga pliki projektu z repozytorium szablonów i inicjuje projekt w folderze głównym. Flaga -e ustawia nazwę bieżącego środowiska. W azd środowisko systemowe zapewnia unikatowy kontekst wdrażania dla twojej aplikacji i można zdefiniować więcej niż jeden z nich. Nazwa środowiska jest również używana w nazwie grupy zasobów utworzonej na platformie Azure.

2. Utwórz plik o nazwie local.settings.json w folderze głównym zawierającym te dane JSON:

   {
       "IsEncrypted": false,
       "Values": {
           "AzureWebJobsStorage": "UseDevelopmentStorage=true",
           "FUNCTIONS_WORKER_RUNTIME": "node"
       }
   }
   

   Ten plik jest wymagany podczas uruchamiania lokalnego.

1. W lokalnym terminalu lub wierszu polecenia uruchom to azd init polecenie w pustym folderze:

   azd init --template functions-quickstart-python-http-azd -e httpendpoint-py
   

   To polecenie ściąga pliki projektu z repozytorium szablonów i inicjuje projekt w folderze głównym. Flaga -e ustawia nazwę bieżącego środowiska. W azd środowisko systemowe zapewnia unikatowy kontekst wdrażania dla twojej aplikacji i można zdefiniować więcej niż jeden z nich. Nazwa środowiska jest również używana w nazwie grupy zasobów utworzonej na platformie Azure.

2. Utwórz plik o nazwie local.settings.json w folderze głównym zawierającym te dane JSON:

   {
       "IsEncrypted": false,
       "Values": {
           "AzureWebJobsStorage": "UseDevelopmentStorage=true",
           "FUNCTIONS_WORKER_RUNTIME": "python"
       }
   }
   

   Ten plik jest wymagany podczas uruchamiania lokalnego.

Tworzenie i aktywowanie środowiska wirtualnego

W folderze głównym uruchom następujące polecenia, aby utworzyć i aktywować środowisko wirtualne o nazwie .venv:

Linux/macOS

python3 -m venv .venv
source .venv/bin/activate

Jeśli język Python nie instaluje pakietu venv w dystrybucji systemu Linux, uruchom następujące polecenie:

sudo apt-get install python3-venv

Windows (bash)

py -m venv .venv
source .venv/scripts/activate

Windows (Cmd)

py -m venv .venv
.venv\scripts\activate

Uruchamianie w środowisku lokalnym

1. Uruchom to polecenie z folderu aplikacji w terminalu lub wierszu polecenia:

   func start
   

   mvn clean package
   mvn azure-functions:run
   

   npm install
   func start  
   

   npm install
   npm start  
   

   Po uruchomieniu hosta usługi Functions w lokalnym folderze projektu zapisuje on punkty końcowe adresu URL funkcji wyzwalanych przez protokół HTTP do danych wyjściowych terminalu.

   Note

   Ponieważ autoryzacja klucza dostępu nie jest wymuszana podczas uruchamiania lokalnego, zwrócony adres URL funkcji nie zawiera wartości klucza dostępu i nie jest potrzebny do wywołania funkcji.

2. W przeglądarce przejdź do adresu końcowego httpget, który powinien wyglądać następująco:

   http://localhost:7071/api/httpget

3. W nowym oknie terminalu lub wiersza polecenia uruchom to curl polecenie, aby wysłać żądanie POST z ładunkiem JSON do punktu końcowego httppost :

   curl -i http://localhost:7071/api/httppost -H "Content-Type: text/json" -d @testdata.json
   

   curl -i http://localhost:7071/api/httppost -H "Content-Type: text/json" -d "@src/functions/testdata.json"
   

   To polecenie odczytuje dane ładunku testdata.json JSON z pliku projektu. Przykłady obu żądań HTTP można znaleźć w test.http pliku projektu.

4. Po zakończeniu naciśnij Ctrl+C w oknie terminalu func.exe , aby zatrzymać proces hosta.

5. Uruchom polecenie deactivate , aby zamknąć środowisko wirtualne.

Przejrzyj kod (opcjonalnie)

Możesz przejrzeć kod definiujący dwa punkty końcowe funkcji wyzwalacza HTTP:

httpget

       [Function("httpget")]
       public IActionResult Run([HttpTrigger(AuthorizationLevel.Function, "get")]
         HttpRequest req,
         string name)
       {
           var returnValue = string.IsNullOrEmpty(name)
               ? "Hello, World."
               : $"Hello, {name}.";

           _logger.LogInformation($"C# HTTP trigger function processed a request for {returnValue}.");

           return new OkObjectResult(returnValue);
       }

@FunctionName("httpget")
public HttpResponseMessage run(
        @HttpTrigger(
            name = "req",
            methods = {HttpMethod.GET},
            authLevel = AuthorizationLevel.FUNCTION)
            HttpRequestMessage<Optional<String>> request,
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a request.");

    // Parse query parameter
    String name = Optional.ofNullable(request.getQueryParameters().get("name")).orElse("World");

    return request.createResponseBuilder(HttpStatus.OK).body("Hello, " + name).build();
}

const { app } = require('@azure/functions');

app.http('httpget', {
    methods: ['GET'],
    authLevel: 'function',
    handler: async (request, context) => {
        context.log(`Http function processed request for url "${request.url}"`);

        const name = request.query.get('name') || await request.text() || 'world';

        return { body: `Hello, ${name}!` };
    }
});

import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";

export async function httpGetFunction(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function processed request for url "${request.url}"`);

    const name = request.query.get('name') || await request.text() || 'world';

    return { body: `Hello, ${name}!` };
};

app.http('httpget', {
    methods: ['GET'],
    authLevel: 'function',
    handler: httpGetFunction
});

Ten function.json plik definiuje httpget funkcję:

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "get"
      ],
      "route": "httpget"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    }
  ]
}

Ten run.ps1 plik implementuje kod funkcji:

using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with query parameters
$name = $Request.Query.name

$body = "This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response."

if ($name) {
    $body = "Hello, $name. This HTTP triggered function executed successfully."
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = [HttpStatusCode]::OK
    Body = $body
})

@app.route(route="httpget", methods=["GET"])
def http_get(req: func.HttpRequest) -> func.HttpResponse:
    name = req.params.get("name", "World")

    logging.info(f"Processing GET request. Name: {name}")

    return func.HttpResponse(f"Hello, {name}!")

httppost

[Function("httppost")]
public IActionResult Run([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req,
    [FromBody] Person person)
{
    _logger.LogInformation($"C# HTTP POST trigger function processed a request for url {req.Body}");

    if (string.IsNullOrEmpty(person.Name) | string.IsNullOrEmpty(person.Age.ToString()) | person.Age == 0)
    {
        _logger.LogInformation("C# HTTP POST trigger function processed a request with no name/age provided.");
        return new BadRequestObjectResult("Please provide both name and age in the request body.");
    }

    var returnValue = $"Hello, {person.Name}! You are {person.Age} years old.";
    
    _logger.LogInformation($"C# HTTP POST trigger function processed a request for {person.Name} who is {person.Age} years old.");
    return new OkObjectResult(returnValue);
}

@FunctionName("httppost")
public HttpResponseMessage runPost(
        @HttpTrigger(
            name = "req",
            methods = {HttpMethod.POST},
            authLevel = AuthorizationLevel.FUNCTION)
            HttpRequestMessage<Optional<String>> request,
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a POST request.");

    // Parse request body
    String name;
    Integer age;
    try {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode jsonNode = mapper.readTree(request.getBody().orElse("{}"));
        name = Optional.ofNullable(jsonNode.get("name")).map(JsonNode::asText).orElse(null);
        age = Optional.ofNullable(jsonNode.get("age")).map(JsonNode::asInt).orElse(null);
        if (name == null || age == null) {
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                    .body("Please provide both name and age in the request body.").build();
        }
    } catch (Exception e) {
        context.getLogger().severe("Error parsing request body: " + e.getMessage());
        return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                .body("Error parsing request body").build();
    }

const { app } = require('@azure/functions');

app.http('httppost', {
    methods: ['POST'],
    authLevel: 'function',
    handler: async (request, context) => {
        context.log(`Http function processed request for url "${request.url}"`);

        try {
            const person = await request.json();
            const { name, age } = person;

            if (!name || !age) {
                return {
                    status: 400,
                    body: 'Please provide both name and age in the request body.'
                };
            }

            return {
                status: 200,
                body: `Hello, ${name}! You are ${age} years old.`
            };
        } catch (error) {
            return {
                status: 400,
                body: 'Invalid request body. Please provide a valid JSON object with name and age.'
            };
        }
    }
});

import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";

interface Person {
    name: string;
    age: number;
}

function isPerson(obj: any): obj is Person {
    return typeof obj === 'object' && obj !== null && 
           typeof obj.name === 'string' && 
           typeof obj.age === 'number';
}

export async function httpPostBodyFunction(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function processed request for url "${request.url}"`);

        try {
            const data: any  = await request.json();
    
            if (!isPerson(data)) {
                return {
                    status: 400,
                    body: 'Please provide both name and age in the request body.'
                };
            }

            return {
                status: 200,
                body: `Hello, ${data.name}! You are ${data.age} years old.`
            };
        } catch (error) {
            return {
                status: 400,
                body: 'Invalid request body. Please provide a valid JSON object with name and age.'
            };
        }
};

app.http('httppost', {
    methods: ['POST'],
    authLevel: 'function',
    handler: httpPostBodyFunction
});

Ten function.json plik definiuje httppost funkcję:

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "post"
      ],
      "route": "httppost"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    }
  ]
}

Ten run.ps1 plik implementuje kod funkcji:

using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with the body of the request.
$name = $Request.Body.name
$age = $Request.Body.age
$status = [HttpStatusCode]::OK

$body = "This HTTP triggered function executed successfully. Pass a name in the request body for a personalized response."

if ( -not ($name -and $age)){
    $body = "Please provide both 'name' and 'age' in the request body."
    $status = [HttpStatusCode]::BadRequest
}
else {
    <# Action when all if and elseif conditions are false #>
    $body = "Hello, ${name}! You are ${age} years old."
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = $status
    Body = $body
})

@app.route(route="httppost", methods=["POST"])
def http_post(req: func.HttpRequest) -> func.HttpResponse:
    try:
        req_body = req.get_json()
        name = req_body.get('name')
        age = req_body.get('age')
        
        logging.info(f"Processing POST request. Name: {name}")

        if name and isinstance(name, str) and age and isinstance(age, int):
            return func.HttpResponse(f"Hello, {name}! You are {age} years old!")
        else:
            return func.HttpResponse(
                "Please provide both 'name' and 'age' in the request body.",
                status_code=400
            )
    except ValueError:
        return func.HttpResponse(
            "Invalid JSON in request body",
            status_code=400
        )

Pełny projekt szablonu można przejrzeć tutaj.

Pełny projekt szablonu można przejrzeć tutaj.

Pełny projekt szablonu można przejrzeć tutaj.

Pełny projekt szablonu można przejrzeć tutaj.

Pełny projekt szablonu można przejrzeć tutaj.

Pełny projekt szablonu można przejrzeć tutaj.

Po zweryfikowaniu funkcji lokalnie nadszedł czas, aby opublikować je na platformie Azure.

Wdróż na platformie Azure

Ten projekt jest skonfigurowany do użycia azd up polecenia w celu wdrożenia tego projektu w nowej aplikacji funkcji w planie Flex Consumption na platformie Azure.

Tip

Projekt zawiera zestaw plików Bicep (w folderze infra ), które azd wykorzystuje do utworzenia bezpiecznego wdrożenia w planie wykorzystania Flex, które jest zgodne z najlepszymi praktykami.

1. Uruchom to polecenie, aby azd utworzyć wymagane zasoby platformy Azure na platformie Azure i wdrożyć projekt kodu w nowej aplikacji funkcji:

   azd up
   

   Folder główny zawiera azure.yaml plik definicji wymagany przez azdprogram .

   Jeśli jeszcze nie zalogowano się, zostanie wyświetlony monit o uwierzytelnienie przy użyciu konta platformy Azure.

2. Po wyświetleniu monitu podaj następujące wymagane parametry wdrożenia:

   Parameter	Description
   Subskrypcja platformy Azure	Subskrypcja, w której są tworzone zasoby.
   Lokalizacja platformy Azure	Region platformy Azure, w którym ma zostać utworzona grupa zasobów zawierająca nowe zasoby platformy Azure. Wyświetlane są tylko regiony, które obecnie obsługują plan Flex Consumption.
   vnetEnabled	Wybierz pozycję Fałsz. Po ustawieniu wartości True wdrożenie tworzy aplikację funkcji w nowej sieci wirtualnej.

   Polecenie azd up używa Twoich odpowiedzi na te monity wraz z plikami konfiguracji Bicep do wykonania następujących zadań wdrażania:

   • Utwórz i skonfiguruj te wymagane zasoby platformy Azure (równoważne ):azd provision

     • Flex Consumption plan i aplikacja funkcji
     • Azure Storage (wymagane) i Application Insights (zalecane)
     • Zasady dostępu i role dla twojego konta
     • Połączenia między usługami przy użyciu tożsamości zarządzanych (zamiast przechowywanych parametry połączenia)
     • (Opcja) Sieć wirtualna do bezpiecznego uruchamiania aplikacji funkcji i innych zasobów platformy Azure

   • Spakuj i wdróż kod w kontenerze wdrażania (odpowiednik azd deploy). Aplikacja jest następnie uruchamiana i uruchamiana w wdrożonym pakiecie.

   Po pomyślnym zakończeniu działania polecenia zobaczysz linki do utworzonych zasobów.

Wywoływanie funkcji na platformie Azure

Teraz możesz wywołać punkty końcowe funkcji na platformie Azure, wysyłając żądania HTTP do ich adresów URL przy użyciu narzędzia testowego HTTP lub z przeglądarki (w przypadku żądań GET). Po uruchomieniu funkcji na platformie Azure wymuszana jest autoryzacja klucza dostępu i musisz podać klucz dostępu funkcji wraz z żądaniem.

Aby uzyskać punkty końcowe adresów URL funkcji działających na platformie Azure, możesz użyć narzędzi Core Tools.

1. W lokalnym terminalu lub wierszu polecenia uruchom następujące polecenia, aby uzyskać wartości punktu końcowego adresu URL:

   bash

   SET APP_NAME=$(azd env get-value AZURE_FUNCTION_NAME)
   func azure functionapp list-functions $APP_NAME --show-keys
   

   Cmd

   for /f "tokens=*" %i in ('azd env get-value AZURE_FUNCTION_NAME') do set APP_NAME=%i
   func azure functionapp list-functions %APP_NAME% --show-keys 
   

   PowerShell

   $APP_NAME = azd env get-value AZURE_FUNCTION_NAME
   func azure functionapp list-functions $APP_NAME --show-keys
   

   Cmd

   for /f "tokens=*" %i in ('azd env get-value AZURE_FUNCTION_NAME') do set APP_NAME=%i
   func azure functionapp list-functions %APP_NAME% --show-keys 
   

   Polecenie azd env get-value pobiera nazwę aplikacji funkcji ze środowiska lokalnego. Jeśli używasz opcji --show-keys z func azure functionapp list-functions, wartość zwróconego adresu URL wywołania: dla każdego punktu końcowego zawiera klucz dostępu na poziomie funkcji.

2. Tak jak wcześniej użyj narzędzia testowego HTTP, aby zweryfikować te adresy URL w aplikacji funkcji uruchomionej na platformie Azure.

Ponowne wdrażanie kodu

azd up Uruchom polecenie tyle razy, ile potrzebujesz, aby aprowizować zasoby platformy Azure i wdrażać aktualizacje kodu w aplikacji funkcji.

Note

Wdrożone pliki kodu są zawsze zastępowane przez najnowszy pakiet wdrożeniowy.

Początkowe odpowiedzi na azd monity i wszystkie zmienne środowiskowe wygenerowane przez azd program są przechowywane lokalnie w nazwanym środowisku. Użyj polecenia , azd env get-values aby przejrzeć wszystkie zmienne w środowisku, które były używane podczas tworzenia zasobów platformy Azure.

Czyszczenie zasobów

Po zakończeniu pracy z aplikacją funkcji i powiązanymi zasobami użyj tego polecenia, aby usunąć aplikację funkcji i powiązane z nią zasoby z platformy Azure i uniknąć ponoszenia dodatkowych kosztów:

azd down --no-prompt

Note

Opcja --no-prompt powoduje azd usunięcie grupy zasobów bez potwierdzenia.

To polecenie nie ma wpływu na lokalny projekt kodu.

Treści powiązane

• Scenariusze usługi Azure Functions
• Plan Flex Consumption
• Interfejs wiersza polecenia dla deweloperów platformy Azure (azd)
• azd — odwołanie
• Dokumentacja podstawowych narzędzi usługi Azure Functions
• Kodowanie i testowanie usługi Azure Functions lokalnie