Připojení Azure Functions k Azure Storage pomocí Visual Studio Code

Azure Functions umožňuje připojit Azure služby a další prostředky k funkcím, aniž byste museli psát vlastní integrační kód. Tyto vazby, které představují vstup i výstup, jsou deklarovány v rámci definice funkce. Data z vazeb má funkce k dispozici jako parametry. Trigger je speciální typ vstupního spojení. I když má funkce pouze jeden trigger, může mít více vstupních a výstupních vazeb. Další informace najdete v tématu Azure Functions koncepty triggerů a vazeb.

V tomto článku se dozvíte, jak pomocí Visual Studio Kódu připojit Azure Storage k funkci, kterou jste vytvořili v předchozím článku rychlého startu. Výstupní vazba, kterou přidáte do této funkce, zapisuje data z požadavku HTTP do zprávy ve frontě služby Azure Queue Storage.

Většina vazeb vyžaduje uložený řetězec připojení, který služba Functions používá k přístupu k vázané službě. Pro zjednodušení použijete účet storage, který jste vytvořili pomocí aplikace funkcí. Připojení k tomuto účtu je již uloženo v nastavení aplikace s názvem AzureWebJobsStorage.

Poznámka:

Tento článek aktuálně podporuje Node.js v4 pro funkce.

Konfigurace místního prostředí

Než začnete, musíte splnit následující požadavky:

  • Nainstalujte rozšíření Azure Storage pro Visual Studio Code.

  • Nainstalujte Azure Storage Explorer. Storage Explorer je nástroj, který použijete k prozkoumání zpráv fronty vygenerovaných výstupní vazbou. Storage Explorer se podporuje v operačních systémech macOS, Windows a Linux.

Tento článek předpokládá, že už jste přihlášení ke svému Azure předplatnému z Visual Studio Code. Můžete se přihlásit spuštěním příkazu Azure: Sign In z palety příkazů.

Stažení nastavení aplikace funkcí

V článku previous quickstart jste vytvořili aplikaci funkcí v Azure společně s požadovaným účtem storage. Connection string pro tento účet se bezpečně uloží v nastavení aplikace v Azure. V tomto článku napíšete zprávy do fronty Storage ve stejném účtu. Pokud se chcete připojit ke svému účtu storage při místním spuštění funkce, musíte stáhnout nastavení aplikace do souboru local.settings.json.

  1. Stisknutím klávesy F1 otevřete paletu příkazů a pak vyhledejte a spusťte příkaz Azure Functions: Download Remote Settings....

  2. Zvolte aplikaci funkcí, kterou jste vytvořili v předchozím článku. Chcete-li přepsat stávající místní nastavení, vyberte možnost Ano pro všechny.

    Důležité

    Protože soubor local.settings.json obsahuje tajné kódy, nikdy se nepublikuje a není vyloučen ze správy zdrojového kódu.

  3. Zkopírujte hodnotu AzureWebJobsStorage, která je klíčem pro hodnotu připojovacího řetězce účtu úložiště. Pomocí tohoto připojení ověříte, že výstupní vazba funguje podle očekávání.

Registrace rozšíření vazeb

Vzhledem k tomu, že používáte výstupní vazbu fronty úložiště, musíte mít před spuštěním projektu nainstalované rozšíření vazeb úložiště.

Vaše project je nakonfigurovaná tak, aby používala extension bundles, která automaticky nainstaluje předdefinovanou sadu balíčků rozšíření.

Sady rozšíření jsou už povolené v souboru host.json v kořenovém adresáři project, který by měl vypadat jako v následujícím příkladu:

{
  "version": "2.0",
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[3.*, 4.0.0)"
  }
}

Teď můžete do projektu přidat výstupní vazbu úložiště.

Vaše project je nakonfigurovaná tak, aby používala extension bundles, která automaticky nainstaluje předdefinovanou sadu balíčků rozšíření.

Sady rozšíření jsou už povolené v souboru host.json v kořenovém adresáři project, který by měl vypadat jako v následujícím příkladu:

{
  "version": "2.0",
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  }
}

Teď můžete do projektu přidat výstupní vazbu úložiště.

Kromě triggerů typu HTTP a časovače se vazby implementují jako balíčky rozšíření. Spuštěním následujícího příkazu dotnet add package v okně terminálu přidejte balíček rozšíření Storage do svého project.

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Storage.Queues --prerelease

Teď můžete do projektu přidat výstupní vazbu úložiště.

Přidejte výstupní vazbu

Chcete-li zapsat do fronty Azure Storage:

  • Přidejte vlastnost do konfigurace vazby extraOutputs

    {
    methods: ['GET', 'POST'],
    extraOutputs: [sendToQueue], // add output binding to HTTP trigger
    authLevel: 'function',
    handler: () => {}
}

  • output.storageQueue Přidání funkce nad app.http volání

    const sendToQueue = output.storageQueue({
  queueName: 'outqueue',
  connection: 'AzureWebJobsStorage',
});

Chcete-li zapsat do fronty Azure Storage:

  • Přidejte vlastnost do konfigurace vazby extraOutputs

    {
    methods: ['GET', 'POST'],
    extraOutputs: [sendToQueue], // add output binding to HTTP trigger
    authLevel: 'function',
    handler: () => {}
}

  • output.storageQueue Přidání funkce nad app.http volání

    const sendToQueue: StorageQueueOutput = output.storageQueue({
  queueName: 'outqueue',
  connection: 'AzureWebJobsStorage',
});

Ve službě Functions každý typ vazby vyžaduje direction, typea jedinečný name. Způsob, jakým definujete tyto atributy, závisí na jazyce vaší aplikace funkcí.

Atributy vazby jsou definovány v souboru function.json pro danou funkci. V závislosti na typu vazby mohou být vyžadovány další vlastnosti. Konfigurace výstupu fronty popisuje pole požadovaná pro vazbu fronty služby Azure Storage. Rozšíření usnadňuje přidávání vazeb do souboru function.json .

Pokud chcete vytvořit vazbu, klikněte pravým tlačítkem myši (Ctrl+klikněte na macOS) function.json soubor ve složce HttpTrigger a zvolte Přidat vazbu.... Podle pokynů definujte následující vlastnosti vazby pro novou vazbu:

Výzva Hodnota Popis
Výběr směru vazby out Vazba je výstupní vazba.
Výběr vazby dle směru... Azure Queue Storage Vazba je vazba Azure Storage fronty.
Název použitý k identifikaci této vazby v kódu msg Název, který identifikuje parametr vazby odkazovaný v kódu.
Fronta, do které se zpráva odešle outqueue Název fronty, do které vazba zapisuje. Pokud queueName neexistuje, binding ji vytvoří při prvním použití.
Výběr nastavení z local.setting.json AzureWebJobsStorage Název nastavení aplikace, které obsahuje connection string pro účet Storage. Nastavení AzureWebJobsStorage obsahuje connection string pro účet Storage, který jste vytvořili pomocí aplikace funkcí.

Do pole bindings v souboru function.json se přidá vazba, která by měla vypadat takto:

      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

Atributy vazby jsou definovány označením specifického kódu funkce v souboru function_app.py. Pomocí dekorátoru queue_output přidáte výstupní vazbu Azure Queue storage.

Pomocí dekorátoru queue_output je směr vazby implicitně výstupní a typ je Azure Storage Queue. Do kódu funkce v function_app.py přidejte následující dekorátor:

@app.queue_output(arg_name="msg", queue_name="outqueue", connection="AzureWebJobsStorage")

V tomto kódu arg_name identifikuje parametr vazby odkazovaný v kódu, queue_name je název fronty, do které vazba zapisuje, a connection je název nastavení aplikace, které obsahuje connection string pro účet Storage. Při rychlých startech použijete stejný účet úložiště jako je u aplikace funkcí, která je nastavena v AzureWebJobsStorage. queue_name Pokud neexistuje, vazba ji vytvoří při prvním použití.

V project jazyka C# jsou vazby definovány jako atributy vazby v metodě funkce. Konkrétní definice závisí na tom, jestli vaše aplikace běží v procesu (knihovna tříd C#) nebo v izolovaném pracovním procesu.

Otevřete soubor HttpExample.cs project a přidejte následující třídu MultiResponse:

public class MultiResponse
{
    [QueueOutput("outqueue", Connection = "AzureWebJobsStorage")]
    public string[] Messages { get; set; }
    public IActionResult HttpResponse { get; set; }
}

Třída MultiResponse umožňuje zapisovat do úložné fronty s názvem outqueue a úspěšnou zprávu HTTP. Do fronty může být odesláno více zpráv, protože atribut QueueOutput se použije na pole řetězců.

Vlastnost Connection nastaví připojovací řetězec pro účet úložiště. V tomto případě byste mohli vynechat Connection, protože už používáte výchozí účet storage.

V projektu Java jsou vazby definovány jako anotace pro vazby u funkce. Soubor function.json se pak automaticky vygeneruje na základě těchto poznámek.

Přejděte do umístění kódu funkce v části src/main/java, otevřete soubor Function.java project a do definice metody run přidejte následující parametr:

@QueueOutput(name = "msg", queueName = "outqueue", 
connection = "AzureWebJobsStorage") OutputBinding<String> msg,

Parametr msg je typ OutputBinding<T>, který představuje kolekci řetězců, které jsou zapsány jako zprávy do výstupní vazby po dokončení funkce. V tomto případě je výstupem fronta úložiště s názvem outqueue. Connection string pro účet Storage je nastavena metodou connection. Místo samotného řetězce pro připojení předáte nastavení aplikace, které obsahuje řetězec pro připojení k účtu úložiště.

Definice run metody by teď měla vypadat jako v následujícím příkladu:

@FunctionName("HttpExample")
public HttpResponseMessage run(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) 
        HttpRequestMessage<Optional<String>> request, 
        @QueueOutput(name = "msg", queueName = "outqueue", 
        connection = "AzureWebJobsStorage") OutputBinding<String> msg, 
        final ExecutionContext context) {

Přidání kódu, který používá výstupní vazbu

Po definování vazby můžete použít name vazby k přístupu jako atribut v podpisu funkce. Použitím výstupní vazby nemusíte používat kód sady Azure Storage SDK k ověřování, získání odkazu na frontu nebo k zápisu dat. Tyto úlohy za vás provádí běhové prostředí Functions a vazba výstupu fronty.

Přidejte kód, který používá výstupní vazební objekt context.extraOutputs k vytvoření zprávy do fronty. Přidejte tento kód před příkaz return.

context.extraOutputs.set(sendToQueue, [msg]);

V tomto okamžiku by vaše funkce mohla vypadat takto:

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

const sendToQueue = output.storageQueue({
  queueName: 'outqueue',
  connection: 'AzureWebJobsStorage',
});

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

      const name = request.query.get('name') || (await request.text());
      context.log(`Name: ${name}`);

      if (name) {
        const msg = `Name passed to the function ${name}`;
        context.extraOutputs.set(sendToQueue, [msg]);
        return { body: msg };
      } else {
        context.log('Missing required data');
        return { status: 404, body: 'Missing required data' };
      }
    } catch (error) {
      context.log(`Error: ${error}`);
      return { status: 500, body: 'Internal Server Error' };
    }
  },
});

Přidejte kód, který používá výstupní vazební objekt context.extraOutputs k vytvoření zprávy do fronty. Přidejte tento kód před příkaz return.

context.extraOutputs.set(sendToQueue, [msg]);

V tomto okamžiku by vaše funkce mohla vypadat takto:

import {
  app,
  output,
  HttpRequest,
  HttpResponseInit,
  InvocationContext,
  StorageQueueOutput,
} from '@azure/functions';

const sendToQueue: StorageQueueOutput = output.storageQueue({
  queueName: 'outqueue',
  connection: 'AzureWebJobsStorage',
});

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

    const name = request.query.get('name') || (await request.text());
    context.log(`Name: ${name}`);

    if (name) {
      const msg = `Name passed to the function ${name}`;
      context.extraOutputs.set(sendToQueue, [msg]);
      return { body: msg };
    } else {
      context.log('Missing required data');
      return { status: 404, body: 'Missing required data' };
    }
  } catch (error) {
    context.log(`Error: ${error}`);
    return { status: 500, body: 'Internal Server Error' };
  }
}

app.http('HttpExample', {
  methods: ['GET', 'POST'],
  authLevel: 'anonymous',
  handler: HttpExample,
});

Přidejte kód, který pomocí rutiny Push-OutputBinding zapisuje text do fronty s využitím msg výstupní vazby. Před nastavením stavu OK v if příkazu přidejte tento kód.

$outputMsg = $name
Push-OutputBinding -name msg -Value $outputMsg

V tomto okamžiku musí vaše funkce vypadat takto:

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 or the body of the request.
$name = $Request.Query.Name
if (-not $name) {
    $name = $Request.Body.Name
}

if ($name) {
    # Write the $name value to the queue, 
    # which is the name passed to the function.
    $outputMsg = $name
    Push-OutputBinding -name msg -Value $outputMsg

    $status = [HttpStatusCode]::OK
    $body = "Hello $name"
}
else {
    $status = [HttpStatusCode]::BadRequest
    $body = "Please pass a name on the query string or in the request body."
}

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

Aktualizujte HttpExample\function_app.py tak, aby odpovídal následujícímu kódu, přidejte msg parametr do definice funkce a msg.set(name) pod příkaz if name: :

import azure.functions as func
import logging

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@app.route(route="HttpExample")
@app.queue_output(arg_name="msg", queue_name="outqueue", connection="AzureWebJobsStorage")
def HttpExample(req: func.HttpRequest, msg: func.Out [func.QueueMessage]) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')

    name = req.params.get('name')
    if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

    if name:
        msg.set(name)
        return func.HttpResponse(f"Hello, {name}. This HTTP triggered function executed successfully.")
    else:
        return func.HttpResponse(
             "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.",
             status_code=200
        )

Parametr msg je instance azure.functions.Out class. Metoda set zapíše řetězcovou zprávu do fronty. V tomto případě je name předáno do funkce v řetězci dotazu adresy URL.

Nahraďte existující Run metodu následujícím kódem:

[Function("HttpExample")]
public MultiResponse Run([HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequest req)
{
    _logger.LogInformation("C# HTTP trigger function processed a request.");

    var message = "Welcome to Azure Functions!";

    // Return a response to both HTTP trigger and storage output binding.
    return new MultiResponse()
    {
        // Write a single message.
        Messages = new string[] { message },
        HttpResponse = new OkObjectResult(message)
    };
}

Teď můžete pomocí nového msg parametru zapisovat do výstupní vazby z kódu funkce. Před odpověď na úspěch přidejte následující řádek kódu, který přidá hodnotu name do msg výstupní vazby.

msg.setValue(name);

Při použití výstupní vazby nemusíte používat kód sady Azure Storage SDK k ověřování, získání reference na frontu nebo zápisu dat. Tyto úlohy za vás provádí běhové prostředí Functions a vazba výstupu fronty.

Vaše run metoda by teď měla vypadat jako v následujícím příkladu:

@FunctionName("HttpExample")
public HttpResponseMessage run(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) 
        HttpRequestMessage<Optional<String>> request, 
        @QueueOutput(name = "msg", queueName = "outqueue", 
        connection = "AzureWebJobsStorage") OutputBinding<String> msg, 
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a request.");

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

    if (name == null) {
        return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
        .body("Please pass a name on the query string or in the request body").build();
    } else {
        // Write the name to the message queue. 
        msg.setValue(name);

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

Aktualizace testů

Vzhledem k tomu, že archetyp také vytvoří sadu testů, je nutné tyto testy aktualizovat, aby zvládly nový msg parametr v run podpisu metody.

Přejděte do umístění testovacího kódu pod src/test/java, otevřete soubor Function.java project a nahraďte řádek kódu pod //Invoke následujícím kódem.

@SuppressWarnings("unchecked")
final OutputBinding<String> msg = (OutputBinding<String>)mock(OutputBinding.class);
final HttpResponseMessage ret = new Function().run(req, msg, context);

Místní spuštění funkce

Visual Studio Code se integruje s nástroji Azure Functions Core Tools, které vám umožní spustit tento project na místním vývojovém počítači před publikováním do Azure. Pokud ještě nemáte nástroje Core Tools nainstalované místně, zobrazí se výzva k jeho instalaci při prvním spuštění project.

  1. Pokud chcete volat funkci, stiskněte F5 a spusťte projekt aplikace Function App. Na panelu Terminálu se zobrazí výstup nástrojů Core Tools. Aplikace se spustí na panelu Terminálu . Můžete vidět adresu URL koncového bodu vaší HTTP funkce spuštěné místně.

    Screenshot výstupu lokální funkce ve Visual Studio Code.

    Pokud ještě nemáte nainstalované Core Tools, vyberte Install a při zobrazení výzvy k tomu, tyto nástroje nainstalujte.
    Pokud máte potíže se spuštěním ve Windows, ujistěte se, že výchozí terminál pro Visual Studio Code není nastavený na WSL Bash.

  2. Se spuštěnými nástroji Core Tools přejděte do oblasti Azure: Functions. V části Functions rozbalte Local Project>Functions. Klikněte pravým tlačítkem myši (Windows) nebo pomocí Ctrl - klikněte (macOS) na HttpExample funkci a zvolte Spustit funkci nyní....

    Screenshot funkce spuštění z Visual Studio Code.

  3. V části Vložení požadavku stiskněte Enter a odešlete do funkce zprávu požadavku.

  4. Když se funkce spustí místně a vrátí odpověď, v Visual Studio Code se vyvolá oznámení. Informace o provádění funkce se zobrazují na panelu Terminálu .

  5. Stisknutím kombinace kláves Ctrl+C zastavte nástroje Core Tools a odpojte ladicí program.

Místní spuštění funkce

  1. Stejně jako v předchozím článku stiskněte F5, abyste spustili projekt aplikace funkcí a Core Tools.

  2. Se spuštěnými nástroji Core Tools přejděte do oblasti Azure: Functions. V části Functions rozbalte Local Project>Functions. Klikněte pravým tlačítkem myši (Ctrl a klikněte na Mac) na HttpExample funkci a vyberte Spustit funkci nyní....

    Screenshot spouštění funkce z Visual Studio Code.

  3. V Text požadavku se zobrazuje hodnota textu zprávy požadavku { "name": "Azure" }. Stisknutím klávesy Enter odešlete tuto zprávu požadavku do funkce.

  4. Po vrácení odpovědi stiskněte Ctrl+C a zastavte nástroje Core Tools.

Vzhledem k tomu, že používáte storage connection string, vaše funkce se při místním spuštění připojí k účtu Azure storage. Při prvním použití výstupní vazby systém Functions automaticky vytvoří ve vašem účtu úložiště novou frontu s názvem outqueue. K ověření, že byla fronta vytvořena spolu s novou zprávou, použijete Storage Explorer.

Připojení Storage Explorer k účtu

Tuto část přeskočte, pokud jste už nainstalovali Azure Storage Explorer a připojili ho ke svému účtu Azure.

  1. Spusťte nástroj Azure Storage Explorer, vlevo vyberte ikonu připojení a vyberte Přidat účet.

    Screenshot, jak přidat účet Azure do Microsoft Azure Storage Explorer.

  2. V dialogovém okně Pojení zvolte Přidat účet Azure zvolte prostředí Azure a pak vyberte Sign in... .

    Screenshot přihlášení k okně účtu Azure.

Po úspěšném přihlášení ke svému účtu se zobrazí všechna Azure předplatná přidružená k vašemu účtu. Zvolte své předplatné a vyberte Otevřít Průzkumníka.

Prozkoumejte výstupní frontu

  1. V Visual Studio Code stisknutím klávesy F1 otevřete paletu příkazů, vyhledejte a spusťte příkaz Azure Storage: Open in Storage Explorer a zvolte název účtu storage. Váš účet storage se otevře v Azure Storage Explorer.

  2. Rozbalte uzel Fronty a potom vyberte frontu s názvem outqueue.

    Tato fronta obsahuje zprávu, kterou vytvořila výstupní vazba fronty při spuštění funkce aktivované protokolem HTTP. Pokud jste funkci vyvolali s výchozí hodnotou nameAzure, zpráva fronty je Název předaný funkci: Azure.

    Screenshot zprávy ve frontě zobrazené v Azure Storage Explorer.

  3. Spusťte funkci znovu, odešlete další požadavek a ve frontě se zobrazí nová zpráva.

Teď je čas znovu publikovat aktualizovanou aplikaci funkcí na Azure.

Opětovné nasazení a ověření aktualizované aplikace

  1. V Visual Studio Code stisknutím klávesy F1 otevřete paletu příkazů. Na paletě příkazů vyhledejte a vyberte Azure Functions: Deploy to function app....

  2. Zvolte aplikaci funkcí, kterou jste vytvořili v prvním článku. Vzhledem k tomu, že znovu nasazujete project do stejné aplikace, vyberte Deploy a zavřete upozornění na přepsání souborů.

  3. Po dokončení nasazení můžete znovu použít funkci Spustit funkci nyní... pro aktivaci funkce v Azure. Tento příkaz automaticky načte přístupový klíč funkce a použije ho při volání koncového bodu HTTP triggeru.

  4. Znovu zkontrolovat zprávu ve frontě storage a ověřit, že výstupní vazba vygeneruje novou zprávu ve frontě.

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

V Azure zdroje odkazují na aplikace funkcí, funkce, účty storage atd. Jsou seskupené do skupin prostředků, a můžete odstranit vše ve skupině tím, že odstraníte skupinu.

Vytvořili jste prostředky pro dokončení těchto rychlých startů. Tyto prostředky se vám můžou účtovat v závislosti na stavu účtu a cenách služeb . Pokud prostředky už nepotřebujete, můžete k jejich odstranění použít tento postup:

  1. V Visual Studio Code stisknutím klávesy F1 otevřete paletu příkazů. Na paletě příkazů vyhledejte a vyberte Azure: Open in portal.

  2. Zvolte aplikaci funkcí a stiskněte Enter. Otevře se stránka aplikace funkcí v Azure portálu.

  3. Na kartě Přehled vyberte pojmenovaný odkaz vedle skupiny prostředků.

    Snímek obrazovky s výběrem skupiny prostředků, která se má odstranit ze stránky aplikace funkcí

  4. Na stránce Skupina prostředků zkontrolujte seznam zahrnutých prostředků a ověřte, že se jedná o prostředky, které chcete odstranit.

  5. Vyberte Odstranit skupinu prostředků a postupujte podle pokynů.

    Odstranění může trvat několik minut. Po jeho dokončení se na několik sekund zobrazí oznámení. K zobrazení tohoto oznámení můžete také vybrat ikonu zvonku v horní části stránky.

Další kroky

Aktualizovali jste funkci aktivovanou protokolem HTTP tak, aby zapisovala data do Storage fronty. Teď se můžete dozvědět více o vývoji funkcí pomocí Visual Studio Code:

  • Last updated on