Samouczek: tworzenie aplikacji powiadomień bezserwerowych za pomocą usług Azure Functions i Azure Web PubSub

Artykuł
01/12/2024

Usługa Azure Web PubSub ułatwia tworzenie aplikacji internetowych do obsługi komunikatów w czasie rzeczywistym przy użyciu obiektów WebSocket. Usługa Azure Functions to bezserwerowa platforma, która pozwala uruchamiać kod bez zarządzania jakąkolwiek infrastrukturą. Z tego samouczka dowiesz się, jak używać usługi Azure Web PubSub i usługi Azure Functions do tworzenia aplikacji bezserwerowej z obsługą komunikatów w czasie rzeczywistym w scenariuszach powiadomień.

Z tego samouczka dowiesz się, jak wykonywać następujące czynności:

Tworzenie bezserwerowej aplikacji powiadomień
Praca z powiązaniami wejściowymi i wyjściowymi funkcji Web PubSub
Uruchamianie przykładowych funkcji lokalnie
Wdrażanie funkcji w aplikacji funkcji platformy Azure

Wymagania wstępne

Edytor kodu, taki jak Visual Studio Code
Node.js, wersja 18.x lub nowsza.

Uwaga

Aby uzyskać więcej informacji na temat obsługiwanych wersji środowiska Node.js, zobacz dokumentację wersji środowiska uruchomieniowego usługi Azure Functions.
Azure Functions Core Tools (preferowana wersja 4 lub nowsza) do uruchamiania aplikacji funkcji platformy Azure lokalnie i wdrażania na platformie Azure.
Interfejs wiersza polecenia platformy Azure do zarządzania zasobami platformy Azure.

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto platformy Azure.

Zaloguj się do witryny Azure Portal pod adresem https://portal.azure.com/ przy użyciu konta platformy Azure.

Tworzenie wystąpienia usługi Azure Web PubSub

Aplikacja połączy się z wystąpieniem usługi Web PubSub na platformie Azure.

Wybierz przycisk Nowy znajdujący się w lewym górnym rogu witryny Azure Portal. Na ekranie Nowy wpisz Web PubSub w polu wyszukiwania i naciśnij klawisz Enter. (Możesz również przeszukać usługę Azure Web PubSub z Web kategorii).
Wybierz pozycję Web PubSub z wyników wyszukiwania, a następnie wybierz pozycję Utwórz.

Wprowadź następujące ustawienia.

Ustawienie	Sugerowana wartość	opis
Nazwa zasobu	Nazwa unikatowa w skali globalnej	Globalnie unikatowa nazwa identyfikująca nowe wystąpienie usługi Web PubSub. Prawidłowe znaki to `a-z`, , `0-9A-Z`i `-`.
Subskrypcja	Twoja subskrypcja	Subskrypcja platformy Azure, w ramach której jest tworzone to nowe wystąpienie usługi Web PubSub.
Grupa zasobów	myResourceGroup	Nazwa nowej grupy zasobów, w której ma zostać utworzone wystąpienie usługi Web PubSub.
Lokalizacja	Zachodnie stany USA	Wybierz region blisko Ciebie.
Warstwa cenowa	Bezpłatne	Najpierw możesz bezpłatnie wypróbować usługę Azure Web PubSub. Dowiedz się więcej o warstwach cenowych usługi Azure Web PubSub
Liczba jednostek	-	Liczba jednostek określa liczbę połączeń, które może zaakceptować wystąpienie usługi Web PubSub. Każda jednostka obsługuje co najwyżej 1000 równoczesnych połączeń. Można to skonfigurować tylko w warstwie Standardowa.

Screenshot of creating the Azure Web PubSub instance in portal.

Wybierz pozycję Utwórz , aby rozpocząć wdrażanie wystąpienia usługi Web PubSub.

Tworzenie i uruchamianie funkcji lokalnie

Upewnij się, że masz zainstalowane narzędzia Azure Functions Core Tools . Teraz utwórz pusty katalog dla projektu. Uruchom polecenie w tym katalogu roboczym. Użyj jednej z podanych opcji poniżej.
```
func init --worker-runtime javascript --model V4
```
```
func init --worker-runtime javascript --model V3
```
```
func init --worker-runtime dotnet
```
```
func init --worker-runtime dotnet-isolated
```
```
func init --worker-runtime python --model V1
```
Wykonaj kroki instalacji Microsoft.Azure.WebJobs.Extensions.WebPubSubprogramu .
Potwierdź lub zaktualizuj host.jsonrozszerzenie 'sBundle do wersji 4.* lub nowszej, aby uzyskać obsługę usługi Web PubSub. Aby zaktualizować host.jsonplik , otwórz plik w edytorze, a następnie zastąp istniejące rozszerzenie wersjiBundle do wersji 4.* lub nowszej.
```
{
    "extensionBundle": {
        "id": "Microsoft.Azure.Functions.ExtensionBundle",
        "version": "[4.*, 5.0.0)"
    }
}
```
Potwierdź lub zaktualizuj host.jsonrozszerzenie 'sBundle do wersji 3.3.0 lub nowszej, aby uzyskać obsługę web PubSub. Aby zaktualizować host.jsonplik , otwórz plik w edytorze, a następnie zastąp istniejące rozszerzenie wersjiBundle do wersji 3.3.0 lub nowszej.
```
{
    "extensionBundle": {
        "id": "Microsoft.Azure.Functions.ExtensionBundle",
        "version": "[3.3.*, 4.0.0)"
    }
}
```
```
dotnet add package Microsoft.Azure.WebJobs.Extensions.WebPubSub
```
```
dotnet add package Microsoft.Azure.Functions.Worker.Extensions.WebPubSub --prerelease
```
Zaktualizuj host.jsonrozszerzenie 'sBundle do wersji 3.3.0 lub nowszej, aby uzyskać obsługę web PubSub. Aby zaktualizować host.jsonplik , otwórz plik w edytorze, a następnie zastąp istniejące rozszerzenie wersjiBundle do wersji 3.3.0 lub nowszej.
```
{
    "extensionBundle": {
        "id": "Microsoft.Azure.Functions.ExtensionBundle",
        "version": "[3.3.*, 4.0.0)"
    }
}
```

index Utwórz funkcję do odczytu i hostowania statycznej strony internetowej dla klientów.

func new -n index -t HttpTrigger

Zaktualizuj src/functions/index.js i skopiuj następujące kody.

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

app.http('index', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: async (context) => {
        const content = await readFile('index.html', 'utf8', (err, data) => {
            if (err) {
                context.err(err)
                return
            }
        });

        return { 
            status: 200,
            headers: { 
                'Content-Type': 'text/html'
            }, 
            body: content, 
        };
    }
});

Zaktualizuj index/function.json i skopiuj następujące kody JSON.

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    }
  ]
}

Zaktualizuj index/index.js i skopiuj następujące kody.

var fs = require('fs');
var path = require('path');

module.exports = function (context, req) {
    var index = context.executionContext.functionDirectory + '/../index.html';
    context.log("index.html path: " + index);
    fs.readFile(index, 'utf8', function (err, data) {
        if (err) {
            console.log(err);
            context.done(err);
        }
        context.res = {
            status: 200,
            headers: {
                'Content-Type': 'text/html'
            },
            body: data
        };
        context.done();
    });
}

Zaktualizuj index.cs i zastąp Run funkcję następującymi kodami.

[FunctionName("index")]
public static IActionResult Run([HttpTrigger(AuthorizationLevel.Anonymous)] HttpRequest req, ExecutionContext context, ILogger log)
{
    var indexFile = Path.Combine(context.FunctionAppDirectory, "index.html");
    log.LogInformation($"index.html path: {indexFile}.");
    return new ContentResult
    {
        Content = File.ReadAllText(indexFile),
        ContentType = "text/html",
    };
}

Zaktualizuj index.cs i zastąp Run funkcję następującymi kodami.

[Function("index")]
public HttpResponseData Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req, FunctionContext context)
{
    var path = Path.Combine(context.FunctionDefinition.PathToAssembly, "../index.html");
    _logger.LogInformation($"index.html path: {path}.");

    var response = req.CreateResponse();
    response.WriteString(File.ReadAllText(path));
    response.Headers.Add("Content-Type", "text/html");
    return response;
}

Zaktualizuj index/function.json i skopiuj następujące kody JSON.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    }
  ]
}

Zaktualizuj index/__init__.py i skopiuj następujące kody.

import os

import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:
    f = open(os.path.dirname(os.path.realpath(__file__)) + '/../index.html')
    return func.HttpResponse(f.read(), mimetype='text/html')

negotiate Utwórz funkcję, aby ułatwić klientom uzyskiwanie adresu URL połączenia z usługą przy użyciu tokenu dostępu.

func new -n negotiate -t HttpTrigger

Zaktualizuj src/functions/negotiate.js i skopiuj następujące kody.

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

const connection = input.generic({
    type: 'webPubSubConnection',
    name: 'connection',
    hub: 'notification'
});

app.http('negotiate', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    extraInputs: [connection],
    handler: async (request, context) => {
        return { body: JSON.stringify(context.extraInputs.get('connection')) };
    },
});

Zaktualizuj negotiate/function.json i skopiuj następujące kody JSON.

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    },
    {
      "type": "webPubSubConnection",
      "name": "connection",
      "hub": "notification",
      "direction": "in"
    }
  ]
}

Utwórz folder negocjując i aktualizując negotiate/index.js i kopiując następujące kody.

module.exports = function (context, req, connection) {
    context.res = { body: connection };
    context.done();
};

Zaktualizuj negotiate.cs i zastąp Run funkcję następującymi kodami.

[FunctionName("negotiate")]
public static WebPubSubConnection Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
    [WebPubSubConnection(Hub = "notification")] WebPubSubConnection connection,
    ILogger log)
{
    log.LogInformation("Connecting...");

    return connection;
}

Dodaj using instrukcje w nagłówku, aby rozwiązać wymagane zależności.
```
using Microsoft.Azure.WebJobs.Extensions.WebPubSub;
```

Zaktualizuj negotiate.cs i zastąp Run funkcję następującymi kodami.

[Function("negotiate")]
public HttpResponseData Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req,
    [WebPubSubConnectionInput(Hub = "notification")] WebPubSubConnection connectionInfo)
{
    var response = req.CreateResponse(HttpStatusCode.OK);
    response.WriteAsJsonAsync(connectionInfo);
    return response;
}

Utwórz folder negocjując i aktualizując negotiate/function.json i kopiując następujące kody json.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "webPubSubConnection",
      "name": "connection",
      "hub": "notification",
      "direction": "in"
    }
  ]
}

Zaktualizuj negotiate/__init__.py i skopiuj następujące kody.

import logging

import azure.functions as func


def main(req: func.HttpRequest, connection) -> func.HttpResponse:
    return func.HttpResponse(connection)

Utwórz funkcję do generowania notification powiadomień za pomocą polecenia TimerTrigger.

func new -n notification -t TimerTrigger

Zaktualizuj src/functions/notification.js i skopiuj następujące kody.

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

const wpsAction = output.generic({
    type: 'webPubSub',
    name: 'action',
    hub: 'notification'
});

app.timer('notification', {
    schedule: "*/10 * * * * *",
    extraOutputs: [wpsAction],
    handler: (myTimer, context) => {
        context.extraOutputs.set(wpsAction, {
            actionName: 'sendToAll',
            data: `[DateTime: ${new Date()}] Temperature: ${getValue(22, 1)}\xB0C, Humidity: ${getValue(40, 2)}%`,
            dataType: 'text',
        });
    },
});

function getValue(baseNum, floatNum) {
    return (baseNum + 2 * floatNum * (Math.random() - 0.5)).toFixed(3);
}

Zaktualizuj notification/function.json i skopiuj następujące kody JSON.

{
  "bindings": [
    {
      "name": "myTimer",
      "type": "timerTrigger",
      "direction": "in",
      "schedule": "*/10 * * * * *"
    },
    {
      "type": "webPubSub",
      "name": "actions",
      "hub": "notification",
      "direction": "out"
    }
  ]
}

Zaktualizuj notification/index.js i skopiuj następujące kody.

module.exports = function (context, myTimer) {
    context.bindings.actions = {
        "actionName": "sendToAll",
        "data": `[DateTime: ${new Date()}] Temperature: ${getValue(22, 1)}\xB0C, Humidity: ${getValue(40, 2)}%`,
        "dataType": "text"
    }
    context.done();
};

function getValue(baseNum, floatNum) {
    return (baseNum + 2 * floatNum * (Math.random() - 0.5)).toFixed(3);
}

Zaktualizuj notification.cs i zastąp Run funkcję następującymi kodami.

[FunctionName("notification")]
public static async Task Run([TimerTrigger("*/10 * * * * *")]TimerInfo myTimer, ILogger log,
    [WebPubSub(Hub = "notification")] IAsyncCollector<WebPubSubAction> actions)
{
    await actions.AddAsync(new SendToAllAction
    {
        Data = BinaryData.FromString($"[DateTime: {DateTime.Now}] Temperature: {GetValue(23, 1)}{'\xB0'}C, Humidity: {GetValue(40, 2)}%"),
        DataType = WebPubSubDataType.Text
    });
}

private static string GetValue(double baseNum, double floatNum)
{
    var rng = new Random();
    var value = baseNum + floatNum * 2 * (rng.NextDouble() - 0.5);
    return value.ToString("0.000");
}

Dodaj using instrukcje w nagłówku, aby rozwiązać wymagane zależności.

using System.Threading.Tasks;
using Microsoft.Azure.WebJobs.Extensions.WebPubSub;
using Microsoft.Azure.WebPubSub.Common;

Zaktualizuj notification.cs i zastąp Run funkcję następującymi kodami.

[Function("notification")]
[WebPubSubOutput(Hub = "notification")]
public SendToAllAction Run([TimerTrigger("*/10 * * * * *")] MyInfo myTimer)
{
    return new SendToAllAction
    {
        Data = BinaryData.FromString($"[DateTime: {DateTime.Now}] Temperature: {GetValue(23, 1)}{'\xB0'}C, Humidity: {GetValue(40, 2)}%"),
        DataType = WebPubSubDataType.Text
    };
}

private static string GetValue(double baseNum, double floatNum)
{
    var rng = new Random();
    var value = baseNum + floatNum * 2 * (rng.NextDouble() - 0.5);
    return value.ToString("0.000");
}

Utwórz powiadomienie folderu i zaktualizuj notification/function.json i skopiuj następujące kody json.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "myTimer",
      "type": "timerTrigger",
      "direction": "in",
      "schedule": "*/10 * * * * *"
    },
    {
      "type": "webPubSub",
      "name": "actions",
      "hub": "notification",
      "direction": "out"
    }
  ]
}

Zaktualizuj notification/__init__.py i skopiuj następujące kody.

import datetime
import random
import json

import azure.functions as func

def main(myTimer: func.TimerRequest, actions: func.Out[str]) -> None:
    time = datetime.datetime.now().strftime("%A %d-%b-%Y %H:%M:%S")
    actions.set(json.dumps({
        'actionName': 'sendToAll',
        'data': '\x5B DateTime: {0} \x5D Temperature: {1:.3f} \xB0C, Humidity: {2:.3f} \x25'.format(time, 22 + 2 * (random.random() - 0.5), 44 + 4 * (random.random() - 0.5)),
        'dataType': 'text'
    }))

Dodaj pojedynczą stronę index.html klienta w folderze głównym projektu i skopiuj zawartość.

<html>
    <body>
    <h1>Azure Web PubSub Notification</h1>
    <div id="messages"></div>
    <script>
        (async function () {
            let messages = document.querySelector('#messages');
            let res = await fetch(`${window.location.origin}/api/negotiate`);
            let url = await res.json();
            let ws = new WebSocket(url.url);
            ws.onopen = () => console.log('connected');

            ws.onmessage = event => {
                let m = document.createElement('p');
                m.innerText = event.data;
                messages.appendChild(m);
            };
        })();
    </script>
    </body>
</html>

Ponieważ projekt języka C# kompiluje pliki do innego folderu wyjściowego, musisz zaktualizować *.csproj plik, aby strona zawartości była w nim dostępna.

<ItemGroup>
    <None Update="index.html">
        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
</ItemGroup>

Ponieważ projekt języka C# kompiluje pliki do innego folderu wyjściowego, musisz zaktualizować *.csproj plik, aby strona zawartości była w nim dostępna.

<ItemGroup>
    <None Update="index.html">
        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
</ItemGroup>

Konfigurowanie i uruchamianie aplikacji funkcji platformy Azure
- W przeglądarce otwórz witrynę Azure Portal i upewnij się, że wdrożone wcześniej wystąpienie usługi Web PubSub zostało pomyślnie utworzone. Przejdź do wystąpienia.
- Wybierz pozycję Klucze i skopiuj parametry połączenia.
Uruchom polecenie w folderze funkcji, aby ustawić parametry połączenia usługi. Zastąp <connection-string> wartość wartością zgodnie z potrzebami.
```
func settings add WebPubSubConnectionString "<connection-string>"
```
Uwaga

TimerTrigger Używany w przykładzie ma zależność od usługi Azure Storage, ale możesz użyć lokalnego emulatora magazynu, gdy funkcja jest uruchomiona lokalnie. Jeśli wystąpi błąd, taki jak There was an error performing a read operation on the Blob Storage Secret Repository. Please ensure the 'AzureWebJobsStorage' connection string is valid., musisz pobrać i włączyć emulator usługi Storage.

Teraz możesz uruchomić funkcję lokalną za pomocą polecenia.
```
func start --port 7071
```
I sprawdzając uruchomione dzienniki, możesz odwiedzić lokalną stronę statyczną hosta, odwiedzając stronę: http://localhost:7071/api/index.

Uwaga

Niektóre browers automatycznie przekieruj do https tego prowadzi do nieprawidłowego adresu URL. Zasugeruj użycie Edge i sprawdź dwukrotnie adres URL, jeśli renderowanie nie powiodło się.

Wdrażanie aplikacji funkcji na platformie Azure

Przed wdrożeniem kodu funkcji na platformie Azure należy utworzyć trzy zasoby:

Grupa zasobów, która jest kontenerem logicznym dla powiązanych zasobów.
Konto magazynu, które służy do obsługi stanu i innych informacji o funkcjach.
Aplikacja funkcji, która udostępnia środowisko do wykonywania kodu funkcji. Aplikacja funkcji mapuje na lokalny projekt funkcji i umożliwia grupowanie funkcji jako jednostki logicznej w celu łatwiejszego zarządzania, wdrażania i udostępniania zasobów.

Użyj następujących poleceń, aby utworzyć te elementy.

Zaloguj się do platformy Azure:
```
az login
```
Utwórz grupę zasobów lub możesz pominąć, ponownie używając jednej z usług Azure Web PubSub:
```
az group create -n WebPubSubFunction -l <REGION>
```

Utwórz konto magazynu ogólnego przeznaczenia w grupie zasobów i regionie:

az storage account create -n <STORAGE_NAME> -l <REGION> -g WebPubSubFunction

Utwórz aplikację funkcji na platformie Azure:

az functionapp create --resource-group WebPubSubFunction --consumption-plan-location <REGION> --runtime node --runtime-version 18 --functions-version 4 --name <FUNCIONAPP_NAME> --storage-account <STORAGE_NAME>

Uwaga

Zapoznaj się z dokumentacją wersji środowiska uruchomieniowego usługi Azure Functions, aby ustawić --runtime-version parametr na obsługiwaną wartość.

az functionapp create --resource-group WebPubSubFunction --consumption-plan-location <REGION> --runtime node --runtime-version 18 --functions-version 4 --name <FUNCIONAPP_NAME> --storage-account <STORAGE_NAME>

Uwaga

Zapoznaj się z dokumentacją wersji środowiska uruchomieniowego usługi Azure Functions, aby ustawić --runtime-version parametr na obsługiwaną wartość.

az functionapp create --resource-group WebPubSubFunction --consumption-plan-location <REGION> --runtime dotnet --functions-version 4 --name <FUNCIONAPP_NAME> --storage-account <STORAGE_NAME>

az functionapp create --resource-group WebPubSubFunction --consumption-plan-location <REGION> --runtime dotnet-isolated --functions-version 4 --name <FUNCIONAPP_NAME> --storage-account <STORAGE_NAME>

az functionapp create --resource-group WebPubSubFunction --consumption-plan-location <REGION> --runtime python --runtime-version 3.9 --functions-version 4 --name <FUNCIONAPP_NAME> --os-type linux --storage-account <STORAGE_NAME>

Wdróż projekt funkcji na platformie Azure:

Po utworzeniu aplikacji funkcji na platformie Azure możesz teraz przystąpić do wdrażania projektu funkcji lokalnych przy użyciu polecenia func azure functionapp publish .
```
func azure functionapp publish <FUNCIONAPP_NAME> --publish-local-settings
```
Uwaga

W tym miejscu wdrażamy ustawienia local.settings.json lokalne razem z parametrem --publish-local-settingspolecenia . Jeśli używasz emulatora usługi Microsoft Azure Storage, możesz wpisać no polecenie , aby pominąć zastępowanie tej wartości na platformie Azure po wyświetleniu monitu: App setting AzureWebJobsStorage is different between azure and local.settings.json, Would you like to overwrite value in azure? [yes/no/show]. Poza tym można zaktualizować ustawienia aplikacji funkcji w witrynie Azure Portal ->Ustawienia ->Configuration.
Teraz możesz sprawdzić witrynę z poziomu aplikacji funkcji platformy Azure, przechodząc do adresu URL: https://<FUNCIONAPP_NAME>.azurewebsites.net/api/index.

Czyszczenie zasobów

Jeśli nie zamierzasz nadal korzystać z tej aplikacji, usuń wszystkie zasoby utworzone przez ten dokument, wykonując następujące kroki, aby nie ponosić żadnych opłat:

W witrynie Azure Portal wybierz grupy zasobów daleko po lewej stronie, a następnie wybierz utworzoną grupę zasobów. Użyj pola wyszukiwania, aby znaleźć grupę zasobów według jej nazwy.
W wyświetlonym oknie wybierz grupę zasobów, a następnie wybierz pozycję Usuń grupę zasobów.
W nowym oknie wpisz nazwę grupy zasobów do usunięcia, a następnie wybierz pozycję Usuń.

Następne kroki

W tym przewodniku Szybki start przedstawiono sposób uruchamiania bezserwerowej aplikacji do czatu. Teraz możesz rozpocząć tworzenie własnej aplikacji.

Samouczek: tworzenie prostego czatroomu za pomocą usługi Azure Web PubSub

Powiązania usługi Azure Web PubSub dla usługi Azure Functions

Zapoznaj się z więcej przykładów usługi Azure Web PubSub

Udostępnij za pośrednictwem

Samouczek: tworzenie aplikacji powiadomień bezserwerowych za pomocą usług Azure Functions i Azure Web PubSub

Wymagania wstępne

Tworzenie wystąpienia usługi Azure Web PubSub

Tworzenie i uruchamianie funkcji lokalnie

Wdrażanie aplikacji funkcji na platformie Azure

Czyszczenie zasobów

Następne kroki

Opinia

Dodatkowe zasoby

Udostępnij za pośrednictwem

Samouczek: tworzenie aplikacji powiadomień bezserwerowych za pomocą usług Azure Functions i Azure Web PubSub

Wymagania wstępne

Logowanie się do platformy Azure

Tworzenie wystąpienia usługi Azure Web PubSub

Tworzenie i uruchamianie funkcji lokalnie

Wdrażanie aplikacji funkcji na platformie Azure

Czyszczenie zasobów

Następne kroki

Opinia

Dodatkowe zasoby