Rychlý start: Vytvoření a nasazení funkcí do Azure Functions pomocí Azure Developer CLI

V tomto rychlém startu pomocí nástrojů příkazového řádku Azure Developer vytvoříte funkce, které reagují na požadavky HTTP. Po místním otestování kódu ho nasadíte do nové aplikace funkcí bez serveru, kterou vytvoříte v plánu Flex Consumption ve službě Azure Functions.

Zdroj projektu používá Azure Developer CLI (azd) ke zjednodušení nasazení kódu do Azure. Toto nasazení se řídí aktuálními osvědčenými postupy pro zabezpečená a škálovatelná nasazení Azure Functions.

Ve výchozím nastavení se plán Flex Consumption řídí fakturačním modelem s průběžnými platbami , což znamená, že k dokončení tohoto rychlého startu se v účtu Azure účtují malé náklady na několik centů nebo méně USD.

Požadavky

• Účet Azure s aktivním předplatným. Vytvoření účtu zdarma

• Azure Developer CLI.

• Azure Functions Core Tools

• Sada .NET 8.0 SDK

• Emulátor úložiště Azurite

• Java 17 Developer Kit
  • Pokud používáte jinou podporovanou verzi Javy, musíte aktualizovat soubor pom.xml projektu.
  • Proměnná JAVA_HOME prostředí musí být nastavena na umístění instalace správné verze sady JDK.
• Apache Maven 3.8.x

• Node.js 20

• PowerShell 7.2

• Sada .NET 6.0 SDK

• Python 3.11

• Zabezpečený testovací nástroj HTTP pro odesílání požadavků s datovými částmi JSON do koncových bodů funkce. Tento článek používá curl.

Inicializace projektu

Pomocí azd init příkazu můžete vytvořit místní projekt kódu Azure Functions ze šablony.

1. V místním terminálu nebo příkazovém řádku spusťte tento azd init příkaz v prázdné složce:

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

   Tento příkaz načte soubory projektu z úložiště šablony a inicializuje projekt v aktuální složce. Příznak -e nastaví název aktuálního prostředí. V azdprostředí se používá k zachování jedinečného kontextu nasazení pro vaši aplikaci a můžete definovat více než jedno. Používá se také v názvu skupiny prostředků, kterou vytvoříte v Azure.

2. Spuštěním tohoto příkazu přejděte do http složky aplikace:

   cd http
   

3. Ve složce, která obsahuje tato data JSON, vytvořte soubor s názvem local.settings.jsonhttp:

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

   Tento soubor se vyžaduje při místním spuštění.

1. V místním terminálu nebo příkazovém řádku spusťte tento azd init příkaz v prázdné složce:

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

   Tento příkaz načte soubory projektu z úložiště šablony a inicializuje projekt v aktuální složce. Příznak -e nastaví název aktuálního prostředí. V azdprostředí se používá k zachování jedinečného kontextu nasazení pro vaši aplikaci a můžete definovat více než jedno. Používá se také v názvu skupiny prostředků, kterou vytvoříte v Azure.

2. Spuštěním tohoto příkazu přejděte do http složky aplikace:

   cd http
   

3. Ve složce, která obsahuje tato data JSON, vytvořte soubor s názvem local.settings.jsonhttp:

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

   Tento soubor se vyžaduje při místním spuštění.

1. V místním terminálu nebo příkazovém řádku spusťte tento azd init příkaz v prázdné složce:

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

   Tento příkaz načte soubory projektu z úložiště šablon a inicializuje projekt v kořenové složce. Příznak -e nastaví název aktuálního prostředí. V azdprostředí se používá k zachování jedinečného kontextu nasazení pro vaši aplikaci a můžete definovat více než jedno. Používá se také v názvu skupiny prostředků, kterou vytvoříte v Azure.

2. V kořenové složce vytvořte soubor s názvem local.settings.json , který obsahuje tato data JSON:

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

   Tento soubor se vyžaduje při místním spuštění.

1. V místním terminálu nebo příkazovém řádku spusťte tento azd init příkaz v prázdné složce:

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

   Tento příkaz načte soubory projektu z úložiště šablon a inicializuje projekt v kořenové složce. Příznak -e nastaví název aktuálního prostředí. V azdprostředí se používá k zachování jedinečného kontextu nasazení pro vaši aplikaci a můžete definovat více než jedno. Používá se také v názvu skupiny prostředků, kterou vytvoříte v Azure.

2. Spuštěním tohoto příkazu přejděte do src složky aplikace:

   cd src
   

3. Ve složce, která obsahuje tato data JSON, vytvořte soubor s názvem local.settings.jsonsrc:

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

   Tento soubor se vyžaduje při místním spuštění.

1. V místním terminálu nebo příkazovém řádku spusťte tento azd init příkaz v prázdné složce:

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

   Tento příkaz načte soubory projektu z úložiště šablon a inicializuje projekt v kořenové složce. Příznak -e nastaví název aktuálního prostředí. V azdprostředí se používá k zachování jedinečného kontextu nasazení pro vaši aplikaci a můžete definovat více než jedno. Používá se také v názvu skupiny prostředků, kterou vytvoříte v Azure.

2. V kořenové složce vytvořte soubor s názvem local.settings.json , který obsahuje tato data JSON:

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

   Tento soubor se vyžaduje při místním spuštění.

1. V místním terminálu nebo příkazovém řádku spusťte tento azd init příkaz v prázdné složce:

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

   Tento příkaz načte soubory projektu z úložiště šablon a inicializuje projekt v kořenové složce. Příznak -e nastaví název aktuálního prostředí. V azdprostředí se používá k zachování jedinečného kontextu nasazení pro vaši aplikaci a můžete definovat více než jedno. Používá se také v názvu skupiny prostředků, kterou vytvoříte v Azure.

2. V kořenové složce vytvořte soubor s názvem local.settings.json , který obsahuje tato data JSON:

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

   Tento soubor se vyžaduje při místním spuštění.

Vytvoření a aktivace virtuálního prostředí

Spuštěním těchto příkazů v kořenové složce vytvořte a aktivujte virtuální prostředí s názvem .venv:

Linux/macOS

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

Pokud Python nenainstaloval balíček venv do distribuce Linuxu, spusťte následující příkaz:

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

Spuštění v místním prostředí

1. Spusťte tento příkaz ze složky aplikace v terminálu nebo na příkazovém řádku:

   func start
   

   mvn clean package
   mvn azure-functions:run
   

   npm install
   func start  
   

   npm install
   npm start  
   

   Když se hostitel Functions spustí ve složce místního projektu, zapíše koncové body adresy URL funkcí aktivovaných protokolem HTTP do výstupu terminálu.

2. V prohlížeči přejděte na httpget koncový bod, který by měl vypadat jako tato adresa URL:

   http://localhost:7071/api/httpget

3. V novém okně terminálu nebo příkazového řádku spusťte tento curl příkaz, kterým odešlete požadavek POST s datovou částí JSON do koncového httppost bodu:

   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"
   

   Tento příkaz načte data datové části JSON ze testdata.json souboru projektu. Příklady obou požadavků HTTP najdete v test.http souboru projektu.

4. Až budete hotovi, ukončete proces hostitele stisknutím ctrl+C v okně func.exe terminálu.

5. Spuštěním deactivate ukončete virtuální prostředí.

Kontrola kódu (volitelné)

Můžete si projít kód, který definuje dva koncové body funkce triggeru 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
});

Tento function.json soubor definuje httpget funkci:

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

Tento run.ps1 soubor implementuje kód funkce:

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

Tento function.json soubor definuje httppost funkci:

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

Tento run.ps1 soubor implementuje kód funkce:

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
        )

Tady si můžete projít kompletní projekt šablony.

Tady si můžete projít kompletní projekt šablony.

Tady si můžete projít kompletní projekt šablony.

Tady si můžete projít kompletní projekt šablony.

Tady si můžete projít kompletní projekt šablony.

Tady si můžete projít kompletní projekt šablony.

Po místním ověření funkcí je čas je publikovat do Azure.

Vytvoření zdrojů Azure

Tento projekt je nakonfigurovaný tak, aby pomocí azd provision příkazu vytvořil aplikaci funkcí v plánu Flex Consumption spolu s dalšími požadovanými prostředky Azure.

Poznámka:

Tento projekt zahrnuje sadu souborů Bicep, které používají k vytvoření zabezpečeného nasazení do plánu Flex Consumption, který azd dodržuje osvědčené postupy.

azd deploy Pro azd up aplikace v Javě se v současné době nepodporují příkazy.

1. V kořenové složce projektu spusťte tento příkaz a vytvořte požadované prostředky Azure:

   azd provision
   

   Kořenová složka obsahuje azure.yaml definiční soubor vyžadovaný azd.

   Pokud ještě nejste přihlášení, zobrazí se výzva k ověření pomocí účtu Azure.

2. Po zobrazení výzvy zadejte tyto požadované parametry nasazení:

   Parametr	Popis
   Předplatné Azure	Předplatné, ve kterém se vaše prostředky vytvářejí.
   Umístění Azure	Oblast Azure, ve které se má vytvořit skupina prostředků, která obsahuje nové prostředky Azure. Zobrazí se pouze oblasti, které aktuálně podporují plán Flex Consumption.

   Příkaz azd provision použije vaši odpověď na tyto výzvy s konfiguračními soubory Bicep k vytvoření a konfiguraci těchto požadovaných prostředků Azure:

   • Plán Flex Consumption a aplikace funkcí
   • Azure Storage (povinné) a Application Insights (doporučeno)
   • Zásady přístupu a role pro váš účet
   • Připojení mezi službami pomocí spravovaných identit (místo uložených připojovací řetězec)
   • Virtuální síť pro bezpečné spuštění aplikace funkcí i dalších prostředků Azure

   Po úspěšném dokončení příkazu můžete kód projektu nasadit do této nové aplikace funkcí v Azure.

Nasazení do Azure

Pomocí nástrojů Core Tools můžete zabalit kód a nasadit ho target do Azure z výstupní složky.

1. Ve výstupní složce přejděte ke složce aplikace ekvivalentní target :

   cd http/target/azure-functions/contoso-functions
   

   Tato složka by měla mít soubor host.json, který označuje, že se jedná o kořen zkompilované aplikace funkcí Java.

2. Spuštěním těchto příkazů nasaďte zkompilovaný projekt kódu Java do nového prostředku aplikace funkcí v Azure pomocí nástrojů Core Tools:

   udeřit

   APP_NAME=$(azd env get-value AZURE_FUNCTION_NAME)
   func azure functionapp publish $APP_NAME
   

   Cmd

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

   Příkaz azd env get-value získá název vaší aplikace funkcí z místního prostředí, které je vyžadováno pro nasazení pomocí func azure functionapp publish. Po úspěšném dokončení publikování se v Azure zobrazí odkazy na koncové body triggeru HTTP.

Nasazení do Azure

Tento projekt je nakonfigurovaný tak, aby pomocí azd up příkazu nasadil tento projekt do nové aplikace funkcí v plánu Flex Consumption v Azure.

Tip

Tento projekt zahrnuje sadu souborů Bicep, které používají k vytvoření zabezpečeného nasazení do plánu Flex Consumption, který azd dodržuje osvědčené postupy.

1. Spuštěním tohoto příkazu vytvořte azd požadované prostředky Azure v Azure a nasaďte projekt kódu do nové aplikace funkcí:

   azd up
   

   Kořenová složka obsahuje azure.yaml definiční soubor vyžadovaný azd.

   Pokud ještě nejste přihlášení, zobrazí se výzva k ověření pomocí účtu Azure.

2. Po zobrazení výzvy zadejte tyto požadované parametry nasazení:

   Parametr	Popis
   Předplatné Azure	Předplatné, ve kterém se vaše prostředky vytvářejí.
   Umístění Azure	Oblast Azure, ve které se má vytvořit skupina prostředků, která obsahuje nové prostředky Azure. Zobrazí se pouze oblasti, které aktuálně podporují plán Flex Consumption.

   Příkaz azd up použije k dokončení těchto úloh nasazení odpověď na tyto výzvy s konfiguračními soubory Bicep:

   • Vytvořte a nakonfigurujte tyto požadované prostředky Azure (ekvivalentní azd provision):

     • Plán Flex Consumption a aplikace funkcí
     • Azure Storage (povinné) a Application Insights (doporučeno)
     • Zásady přístupu a role pro váš účet
     • Připojení mezi službami pomocí spravovaných identit (místo uložených připojovací řetězec)
     • Virtuální síť pro bezpečné spuštění aplikace funkcí i dalších prostředků Azure

   • Zabalte a nasaďte kód do kontejneru nasazení (ekvivalentní).azd deploy Aplikace se pak spustí a spustí v nasazeném balíčku.

   Po úspěšném dokončení příkazu se zobrazí odkazy na prostředky, které jste vytvořili.

Vyvolání funkce v Azure

Koncové body funkcí v Azure teď můžete vyvolat tak, že na jejich adresy URL odešlete požadavky HTTP pomocí testovacího nástroje HTTP nebo z prohlížeče (pro požadavky GET). Při spuštění funkcí v Azure se vynucuje autorizace přístupového klíče a vy musíte zadat přístupový klíč funkce s vaším požadavkem.

Nástroje Core Tools můžete použít k získání koncových bodů adresy URL vašich funkcí spuštěných v Azure.

1. V místním terminálu nebo příkazovém řádku spusťte tyto příkazy, abyste získali hodnoty koncového bodu adresy URL:

   udeřit

   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 
   

   Příkaz azd env get-value získá název aplikace funkcí z místního prostředí. --show-keys Použití možnosti func azure functionapp list-functions znamená, že vrácená adresa URL vyvolání: hodnota pro každý koncový bod obsahuje přístupový klíč na úrovni funkce.

2. Stejně jako předtím pomocí testovacího nástroje HTTP ověřte tyto adresy URL ve vaší aplikaci funkcí spuštěné v Azure.

Opětovné nasazení kódu

Příkaz můžete spustit azd up tolikrát, kolikrát potřebujete zřídit prostředky Azure a nasadit aktualizace kódu do aplikace funkcí.

Poznámka:

Nasazené soubory kódu se vždy přepíšou nejnovějším balíčkem pro nasazení.

Vaše počáteční odpovědi na azd výzvy a všechny proměnné prostředí vygenerované azd pomocí se ukládají místně ve vašem pojmenovaném prostředí. azd env get-values Pomocí příkazu zkontrolujte všechny proměnné ve vašem prostředí, které se použily při vytváření prostředků Azure.

Vyčištění prostředků

Po dokončení práce s aplikací funkcí a souvisejícími prostředky můžete pomocí tohoto příkazu odstranit aplikaci funkcí a související prostředky z Azure a vyhnout se dalším nákladům:

azd down --no-prompt

Poznámka:

Tato --no-prompt možnost dává azd pokyn k odstranění skupiny prostředků bez potvrzení od vás.

Tento příkaz nemá vliv na místní projekt kódu.

Související obsah

• Plán Flex Consumption
• Azure Developer CLI (azd)
• azd – referenční dokumentace
• Referenční informace ke službě Azure Functions Core Tools
• Místní psaní kódu a testování funkcí Azure Functions