Rövid útmutató: Függvények létrehozása és üzembe helyezése az Azure Functionsben az Azure Developer CLI használatával

Ebben a rövid útmutatóban az Azure Developer parancssori eszközeit használva http-kérelmekre reagáló függvényeket hozhat létre. A kód helyi tesztelése után üzembe helyezi azt egy új kiszolgáló nélküli függvényalkalmazásban, amelyet egy Flex Consumption-csomagban hoz létre az Azure Functionsben.

A projektforrás az Azure Developer CLI (azd) használatával egyszerűsíti a kód Azure-ban való üzembe helyezését. Ez az üzembe helyezés a biztonságos és méretezhető Azure Functions-környezetek jelenlegi ajánlott eljárásait követi.

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ásához az Azure-fiókjában néhány USD cent vagy annál kisebb költséggel jár.

Előfeltételek

• Egy Azure-fiók, aktív előfizetéssel. Fiók ingyenes létrehozása.

• Azure Developer CLI.

• Azure Functions Core Tools.

• .NET 8.0 SDK

• Azurite Storage Emulator

• Java 17 Fejlesztői készlet
  • Ha a Java egy másik támogatott verzióját használja, frissítenie kell a projekt pom.xml fájlját.
  • A JAVA_HOME környezeti változót a JDK megfelelő verziójának telepítési helyére kell állítani.
• Apache Maven 3.8.x

• Node.js 20

• PowerShell 7.2

• .NET 6.0 SDK

• Python 3.11.

• Biztonságos HTTP-teszteszköz , amellyel JSON-hasznos adatokkal küldhet kérelmeket a függvényvégpontoknak. Ez a cikk a .curl

A projekt inicializálása

A parancs használatával azd init létrehozhat egy helyi Azure Functions-kódprojektet egy sablonból.

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

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

   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 azda környezetben egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és több is definiálható. Az Azure-ban létrehozott erőforráscsoport nevében is használatos.

2. Futtassa ezt a parancsot az http alkalmazásmappához való navigáláshoz:

   cd http
   

3. Hozzon létre egy local.settings.json nevű fájlt a http JSON-adatokat tartalmazó mappában:

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

   Ez a fájl helyi futtatáskor szükséges.

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

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

   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 azda környezetben egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és több is definiálható. Az Azure-ban létrehozott erőforráscsoport nevében is használatos.

2. Futtassa ezt a parancsot az http alkalmazásmappához való navigáláshoz:

   cd http
   

3. Hozzon létre egy local.settings.json nevű fájlt a http JSON-adatokat tartalmazó mappában:

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

   Ez a fájl helyi futtatáskor szükséges.

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

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

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

2. Hozzon létre egy local.settings.json nevű fájlt a JSON-adatokat tartalmazó gyökérmappában:

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

   Ez a fájl helyi futtatáskor szükséges.

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

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

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

2. Futtassa ezt a parancsot az src alkalmazásmappához való navigáláshoz:

   cd src
   

3. Hozzon létre egy local.settings.json nevű fájlt a src JSON-adatokat tartalmazó mappában:

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

   Ez a fájl helyi futtatáskor szükséges.

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

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

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

2. Hozzon létre egy local.settings.json nevű fájlt a JSON-adatokat tartalmazó gyökérmappában:

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

   Ez a fájl helyi futtatáskor szükséges.

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

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

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

2. Hozzon létre egy local.settings.json nevű fájlt a JSON-adatokat tartalmazó gyökérmappában:

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

   Ez a fájl helyi futtatáskor szükséges.

Virtuális környezet létrehozása és aktiválása

A gyökérmappában futtassa ezeket a parancsokat a következő nevű .venvvirtuális környezet létrehozásához és aktiválásához:

Linux/macOS

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

Ha a Python nem telepítette a venv-csomagot a Linux-disztribúcióra, futtassa a következő parancsot:

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

Futtatás a helyi környezetben

1. Futtassa ezt a parancsot az alkalmazásmappából egy terminálban vagy parancssorban:

   func start
   

   mvn clean package
   mvn azure-functions:run
   

   npm install
   func start  
   

   npm install
   npm start  
   

   Amikor a Functions-gazdagép elindul a helyi projektmappában, a HTTP által aktivált függvények URL-végpontjait írja a terminál kimenetére.

2. A böngészőben keresse meg a httpget végpontot, amelynek így kell kinéznie:

   http://localhost:7071/api/httpget

3. Egy új terminál vagy parancssori ablakban futtassa ezt a curl parancsot egy JSON hasznos adattal rendelkező POST-kérés végpontra való httppost küldéséhez:

   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"
   

   Ez a parancs beolvassa a JSON hasznos adatait a testdata.json projektfájlból. Mindkét HTTP-kérésre találhat példákat a test.http projektfájlban.

4. Ha elkészült, a gazdafolyamat leállításához nyomja le a Ctrl+C billentyűkombinációt a func.exe terminálablakban.

5. Futtassa deactivate a virtuális környezet leállítását.

A kód áttekintése (nem kötelező)

Áttekintheti a két HTTP-eseményindító függvényvégpontot meghatározó kódot:

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

Ez a function.json fájl határozza meg a függvényt httpget :

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

Ez a run.ps1 fájl implementálja a függvénykódot:

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

Ez a function.json fájl határozza meg a függvényt httppost :

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

Ez a run.ps1 fájl implementálja a függvénykódot:

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
        )

A teljes sablonprojektet itt tekintheti át.

A teljes sablonprojektet itt tekintheti át.

A teljes sablonprojektet itt tekintheti át.

A teljes sablonprojektet itt tekintheti át.

A teljes sablonprojektet itt tekintheti át.

A teljes sablonprojektet itt tekintheti át.

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

Azure-erőforrások létrehozása

Ez a projekt úgy van konfigurálva, hogy a azd provision parancs használatával függvényalkalmazást hozzon létre egy Flex Consumption-csomagban, valamint egyéb szükséges Azure-erőforrásokat.

Feljegyzés

Ez a projekt olyan Bicep-fájlokat tartalmaz, amelyek azd az ajánlott eljárásokat követve biztonságos üzembe helyezést hoznak létre egy Rugalmas használatú csomagban.

azd deploy A azd up Java-alkalmazások jelenleg nem támogatják a parancsokat és a parancsokat.

1. A projekt gyökérmappájában futtassa ezt a parancsot a szükséges Azure-erőforrások létrehozásához:

   azd provision
   

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

   Ha még nincs bejelentkezve, 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	Leírás
   Azure-előfizetés	Előfizetés, amelyben az erőforrások létrejönnek.
   Azure-hely	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 provision parancs a bicep konfigurációs fájlokkal a következő kérdésekre adott választ használja a szükséges Azure-erőforrások létrehozásához és konfigurálásához:

   • Rugalmas kihasználtságú csomag és függvényalkalmazás
   • Azure Storage (kötelező) és Application Insights (ajánlott)
   • 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)
   • Virtuális hálózat a függvényalkalmazás és a többi Azure-erőforrás biztonságos futtatásához

   A parancs sikeres végrehajtása után üzembe helyezheti a projektkódot ebben az új függvényalkalmazásban az Azure-ban.

Üzembe helyezés az Azure-ban

A Core Tools használatával csomagolhatja a kódot, és üzembe helyezheti az Azure-ban a target kimeneti mappából.

1. Lépjen a kimeneti mappában lévő alkalmazásmappa megfelelőjéhez target :

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

   Ennek a mappának host.json fájllal kell rendelkeznie, amely azt jelzi, hogy ez a lefordított Java-függvényalkalmazás gyökere.

2. Futtassa az alábbi parancsokat a lefordított Java-kódprojekt üzembe helyezéséhez az Azure új függvényalkalmazás-erőforrásában a Core Tools használatával:

   erősen megüt

   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% 
   

   A azd env get-value parancs lekéri a függvényalkalmazás nevét a helyi környezetből, amely az üzembe helyezéshez func azure functionapp publishszükséges. A sikeres közzététel után az Azure-ban a HTTP-triggervégpontokra mutató hivatkozások jelennek meg.

Üzembe helyezés az Azure-ban

Ez a projekt úgy van konfigurálva, hogy a parancs használatával telepítse ezt a azd up projektet egy új függvényalkalmazásban egy Rugalmas használatú csomagban az Azure-ban.

Tipp.

Ez a projekt olyan Bicep-fájlokat tartalmaz, amelyek azd az ajánlott eljárásokat követve biztonságos üzembe helyezést hoznak létre egy Rugalmas használatú csomagban.

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 nincs bejelentkezve, 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	Leírás
   Azure-előfizetés	Előfizetés, amelyben az erőforrások létrejönnek.
   Azure-hely	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):

     • Rugalmas kihasználtságú csomag és függvényalkalmazás
     • Azure Storage (kötelező) és Application Insights (ajánlott)
     • 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)
     • Virtuális hálózat a függvényalkalmazás és a többi Azure-erőforrás biztonságos futtatásához

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

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

Mostantól meghívhatja a függvényvégpontokat az Azure-ban, ha HTTP-kéréseket küld az URL-címekre a HTTP-teszteszközzel vagy a böngészőből (GET-kérelmek esetén). Amikor a függvények az Azure-ban futnak, a hozzáférési kulcs engedélyezése kötelező, és a kéréshez meg kell adnia egy függvényhozzáférési kulcsot.

A Core Tools segítségével beszerezheti az Azure-ban futó függvények URL-végpontjait.

1. A helyi terminálban vagy parancssorban futtassa az alábbi parancsokat az URL-végpont értékeinek lekéréséhez:

   erősen megüt

   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 
   

   A azd env get-value parancs lekéri a függvényalkalmazás nevét a helyi környezetből. --show-keys A beállítás azt func azure functionapp list-functions jelenti, hogy a visszaadott meghívási URL- cím: az egyes végpontok értéke tartalmaz egy függvényszintű hozzáférési kulcsot.

2. A korábbiakhoz hasonlóan a HTTP-teszteszköz használatával ellenőrizze ezeket az URL-címeket az Azure-ban futó függvényalkalmazásban.

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

A parancsot annyiszor futtathatja azd up , 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.

Feljegyzés

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

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 olyan változóját, amelyet az Azure-erőforrások létrehozásakor használtak.

Az erőforrások eltávolí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

Feljegyzé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

• Rugalmas kihasználtságú csomag
• Azure Developer CLI (azd)
• azd-referencia
• Az Azure Functions Core Tools referenciája
• Az Azure Functions helyi kódolása és tesztelése