Tutorial: Criar um aplicativo de chat em tempo real sem servidor com o Azure Functions e o serviço Azure Web PubSub

Artigo
04/18/2024

O serviço Azure Web PubSub ajuda você a criar aplicativos Web de mensagens em tempo real usando o WebSockets e o padrão de publicação-assinatura com facilidade. O Azure Functions é uma plataforma sem servidor que permite executar seu código sem gerenciar qualquer infraestrutura. Neste tutorial, você aprende como usar o serviço Azure Web PubSub e o Azure Functions para criar um aplicativo sem servidor com mensagens em tempo real e o padrão de publicação-assinatura.

Neste tutorial, você aprenderá como:

Criar um aplicativo de chat em tempo real sem servidor
Trabalhar com as associações de gatilho de função e as associações de saída do Web PubSub
Implantar a função no aplicativo de funções do Azure
Configurar a autenticação do Azure
Configurar o manipulador de eventos do Web PubSub para rotear eventos e mensagens para o aplicativo

Pré-requisitos

Um editor de códigos, como o Visual Studio Code
Node.js versão 18.x ou posterior.

Observação

Para obter mais informações sobre as versões compatíveis do Node.js, confira a documentação das versões de runtime do Azure Functions.
Azure Functions Core Tools (v4 ou superior, preferencialmente) para executar aplicativos de função do Azure localmente e implantar no Azure.
A CLI do Azure para gerenciar recursos do Azure.

Caso você não tenha uma assinatura do Azure, crie uma conta gratuita do Azure antes de começar.

Entre no portal do Azure em https://portal.azure.com/ com sua conta do Azure.

Criar uma instância do serviço Azure Web PubSub

Seu aplicativo se conectará a uma instância do serviço Web PubSub no Azure.

Selecione no botão Novo localizado no canto superior esquerdo do portal do Azure. Na tela Novo, digite Web PubSub na caixa de pesquisa e pressione ENTER. (Você também pode pesquisar o Azure Web PubSub na categoria Web.)
Selecione Web PubSub nos resultados da pesquisa e escolha Criar.

Insira as configurações a seguir.

Configuração	Valor sugerido	Descrição
Nome do recurso	Nome globalmente exclusivo	O Nome globalmente exclusivo que identifica a nova instância do serviço Azure Web PubSub. Os caracteres válidos são `a-z`, `A-Z`, `0-9` e `-`.
Assinatura	Sua assinatura	A assinatura do Azure na qual essa nova instância do serviço Azure Web PubSub será criada.
Grupo de Recursos	myResourceGroup	Nome do novo grupo de recursos no qual a instância do serviço Azure Web PubSub será criada.
Localidade	Oeste dos EUA	Selecione uma região perto de você.
Tipo de preços	Grátis	Primeiro, você pode experimentar o serviço Azure Web PubSub gratuitamente. Saiba mais detalhes sobre os tipos de preços do serviço Azure Web PubSub
Contagem de unidades	-	A contagem de unidades especifica quantas conexões a instância do serviço Azure Web PubSub pode aceitar. Cada unidade dá suporte a, no máximo, 1.000 conexões simultâneas. Só é configurável na camada Standard.

Captura de tela da criação da instância do Azure Web PubSub no Portal.

Selecione Criar para começar a implantar a instância do serviço Azure Web PubSub.

Criar as funções

Verifique se você tem o Azure Functions Core Tools instalado. E, em seguida, criar um diretório vazio para o projeto. Execute o comando neste diretório de trabalho.
```
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
```

Instale o Microsoft.Azure.WebJobs.Extensions.WebPubSub.

Confirme e atualize o extensionBundle do host.json para a versão 4.* ou posterior, para obter suporte ao Web PubSub.

{
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  }
}

Confirme e atualize o extensionBundle do host.json para a versão 3.3.0 ou posterior para obter suporte do Web PubSub.

{
  "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

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

Crie uma função index para ler e hospedar uma página da Web estática para clientes.

func new -n index -t HttpTrigger

Atualize src/functions/index.js e copie os seguintes códigos.

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

Atualize index/function.json e copie os seguintes códigos JSON.

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

Atualize index/index.js e copie os seguintes códigos.

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

Atualize index.cs e substitua a função Run pelos códigos a seguir.

[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",
    };
}

Atualize index.cs e substitua a função Run pelos códigos a seguir.

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

Atualize index/function.json e copie os seguintes códigos JSON.

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

Atualize __init__.py e substitua a função main pelos códigos a seguir.

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")

Crie uma função negotiate para ajudar os clientes a obterem a URL de conexão do serviço com o token de acesso.

func new -n negotiate -t HttpTrigger

Observação

Neste exemplo, usamos o cabeçalho de identidade do usuário do Microsoft Entra ID x-ms-client-principal-name para recuperar userId. Isso não funcionará em uma função local. Você pode torná-lo vazio ou usar outras formas de obter ou gerar a userId na execução local. Por exemplo, permita que o cliente digite um nome de usuário e o transmita em uma consulta como ?user={$username} quando chamar a função negotiate para obter a URL de conexão do serviço. Na função negotiate, defina userId com o valor {query.user}.

Atualize src/functions/negotiate e copie os seguintes códigos.

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

const connection = input.generic({
    type: 'webPubSubConnection',
    name: 'connection',
    userId: '{headers.x-ms-client-principal-name}',
    hub: 'simplechat'
});

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

Atualize negotiate/function.json e copie os seguintes códigos JSON.

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    },
    {
      "type": "webPubSubConnection",
      "name": "connection",
      "hub": "simplechat",
      "userId": "{headers.x-ms-client-principal-name}",
      "direction": "in"
    }
  ]
}

Atualize negotiate/index.js e copie os seguintes códigos.

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

Atualize negotiate.cs e substitua a função Run pelos códigos a seguir.

[FunctionName("negotiate")]
public static WebPubSubConnection Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
    [WebPubSubConnection(Hub = "simplechat", UserId = "{headers.x-ms-client-principal-name}")] WebPubSubConnection connection,
    ILogger log)
{
    log.LogInformation("Connecting...");
    return connection;
}

Adicione as instruções using no cabeçalho para resolver as dependências necessárias.
```
using Microsoft.Azure.WebJobs.Extensions.WebPubSub;
```

Atualize negotiate.cs e substitua a função Run pelos códigos a seguir.

[Function("negotiate")]
public HttpResponseData Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req,
    [WebPubSubConnectionInput(Hub = "simplechat", UserId = "{headers.x-ms-client-principal-name}")] WebPubSubConnection connectionInfo)
{
    var response = req.CreateResponse(HttpStatusCode.OK);
    response.WriteAsJsonAsync(connectionInfo);
    return response;
}

Atualize negotiate/function.json e copie os seguintes códigos JSON.

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "webPubSubConnection",
      "name": "connection",
      "hub": "simplechat",
      "userId": "{headers.x-ms-client-principal-name}",
      "direction": "in"
    }
  ]
}

Atualize negotiate/__init__.py e copie os seguintes códigos.

import azure.functions as func


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

Crie uma função message para transmitir mensagens do cliente por meio do serviço.

func new -n message -t HttpTrigger

Atualize src/functions/message.js e copie os seguintes códigos.

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

const wpsMsg = output.generic({
    type: 'webPubSub',
    name: 'actions',
    hub: 'simplechat',
});

const wpsTrigger = trigger.generic({
    type: 'webPubSubTrigger',
    name: 'request',
    hub: 'simplechat',
    eventName: 'message',
    eventType: 'user'
});

app.generic('message', {
    trigger: wpsTrigger,
    extraOutputs: [wpsMsg],
    handler: async (request, context) => {
        context.extraOutputs.set(wpsMsg, [{
            "actionName": "sendToAll",
            "data": `[${context.triggerMetadata.connectionContext.userId}] ${request.data}`,
            "dataType": request.dataType
        }]);

        return {
            data: "[SYSTEM] ack.",
            dataType: "text",
        };
    }
});

Atualize message/function.json e copie os seguintes códigos JSON.

{
  "bindings": [
    {
      "type": "webPubSubTrigger",
      "direction": "in",
      "name": "data",
      "hub": "simplechat",
      "eventName": "message",
      "eventType": "user"
    },
    {
      "type": "webPubSub",
      "name": "actions",
      "hub": "simplechat",
      "direction": "out"
    }
  ]
}

Atualize message/index.js e copie os seguintes códigos.

module.exports = async function (context, data) {
  context.bindings.actions = {
    actionName: "sendToAll",
    data: `[${context.bindingData.request.connectionContext.userId}] ${data}`,
    dataType: context.bindingData.dataType,
  };
  // UserEventResponse directly return to caller
  var response = {
    data: "[SYSTEM] ack.",
    dataType: "text",
  };
  return response;
};

Atualize message.cs e substitua a função Run pelos códigos a seguir.

[FunctionName("message")]
public static async Task<UserEventResponse> Run(
    [WebPubSubTrigger("simplechat", WebPubSubEventType.User, "message")] UserEventRequest request,
    BinaryData data,
    WebPubSubDataType dataType,
    [WebPubSub(Hub = "simplechat")] IAsyncCollector<WebPubSubAction> actions)
{
    await actions.AddAsync(WebPubSubAction.CreateSendToAllAction(
        BinaryData.FromString($"[{request.ConnectionContext.UserId}] {data.ToString()}"),
        dataType));
    return new UserEventResponse
    {
        Data = BinaryData.FromString("[SYSTEM] ack"),
        DataType = WebPubSubDataType.Text
    };
}

Adicione as instruções using no cabeçalho para resolver as dependências necessárias.

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

Atualize message.cs e substitua a função Run pelos códigos a seguir.

[Function("message")]
[WebPubSubOutput(Hub = "simplechat")]
public SendToAllAction Run(
    [WebPubSubTrigger("simplechat", WebPubSubEventType.User, "message")] UserEventRequest request)
{
    return new SendToAllAction
    {
        Data = BinaryData.FromString($"[{request.ConnectionContext.UserId}] {request.Data.ToString()}"),
        DataType = request.DataType
    };
}

Atualize message/function.json e copie os seguintes códigos JSON.

{
  "bindings": [
    {
      "type": "webPubSubTrigger",
      "direction": "in",
      "name": "request",
      "hub": "simplechat",
      "eventName": "message",
      "eventType": "user"
    },
    {
      "type": "webPubSub",
      "name": "actions",
      "hub": "simplechat",
      "direction": "out"
    }
  ]
}

Atualize message/__init__.py e copie os seguintes códigos.

import json

import azure.functions as func


def main(request, actions: func.Out[str]) -> None:
    req_json = json.loads(request)
    actions.set(
        json.dumps(
            {
                "actionName": "sendToAll",
                "data": f'[{req_json["connectionContext"]["userId"]}] {req_json["data"]}',
                "dataType": req_json["dataType"],
            }
        )
    )

Adicione a página única do cliente index.html na pasta raiz do projeto e copie o conteúdo.

<html>
  <body>
    <h1>Azure Web PubSub Serverless Chat App</h1>
    <div id="login"></div>
    <p></p>
    <input id="message" placeholder="Type to chat..." />
    <div id="messages"></div>
    <script>
      (async function () {
        let authenticated = window.location.href.includes(
          "?authenticated=true"
        );
        if (!authenticated) {
          // auth
          let login = document.querySelector("#login");
          let link = document.createElement("a");
          link.href = `${window.location.origin}/.auth/login/aad?post_login_redirect_url=/api/index?authenticated=true`;
          link.text = "login";
          login.appendChild(link);
        } else {
          // negotiate
          let messages = document.querySelector("#messages");
          let res = await fetch(`${window.location.origin}/api/negotiate`, {
            credentials: "include",
          });
          let url = await res.json();
          // connect
          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);
          };
          let message = document.querySelector("#message");
          message.addEventListener("keypress", (e) => {
            if (e.charCode !== 13) return;
            ws.send(message.value);
            message.value = "";
          });
        }
      })();
    </script>
  </body>
</html>

Como o projeto C# compilar arquivos em uma pasta de saída diferente, você precisa atualizar o *.csproj para fazer com que a página de conteúdos o acompanhe.

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

Como o projeto C# compilar arquivos em uma pasta de saída diferente, você precisa atualizar o *.csproj para fazer com que a página de conteúdos o acompanhe.

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

Criar e implantar o Aplicativo de Funções do Azure

Antes de poder implantar o código da função no Azure, você precisa criar três recursos:

Um grupo de recursos, que é um contêiner lógico para recursos relacionados.
Uma conta de armazenamento, que é usada para manter o estado e outras informações sobre suas funções.
Um aplicativo de funções, que fornece o ambiente para a execução do código de função. Um aplicativo de funções é mapeado para seu projeto de função local e permite agrupar funções como uma unidade lógica para facilitar o gerenciamento, a implantação e o compartilhamento de recursos.

Use os comandos a seguir para criar esses itens.

Se você ainda não tiver feito isso, entre no Azure:
```
az login
```
Crie um grupo de recursos ou ignore essa etapa reutilizando o do serviço do Azure Web PubSub:
```
az group create -n WebPubSubFunction -l <REGION>
```
Crie uma conta de armazenamento para uso geral no grupo de recursos e na região:
```
az storage account create -n <STORAGE_NAME> -l <REGION> -g WebPubSubFunction
```

Criar o aplicativo de funções no 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>

Observação

Verifique a documentação das versões de tempo de execução do Azure Functions para definir o parâmetro --runtime-version para o valor com suporte.

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>

Observação

Verifique a documentação das versões de tempo de execução do Azure Functions para definir o parâmetro --runtime-version para o valor com suporte.

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>

Implantar o projeto de funções no Azure:

Depois de criar com sucesso o aplicativo de funções no Azure, você estará pronto para implantar o projeto de funções local usando o comando func azure functionapp publish.
```
func azure functionapp publish <FUNCIONAPP_NAME>
```
Configure o WebPubSubConnectionString para o aplicativo de funções:

Primeiro, encontre seu recurso do Web PubSub no portal do Azure e copie a cadeia de conexão em Chaves. Depois, acesse as configurações do Aplicativo de Funções em Portal do Azure ->Configurações ->Configuração. Além disso, adicione um novo item em Configurações de aplicativo, com um nome igual a WebPubSubConnectionString e o valor como a cadeia de conexão do recurso do Web PubSub.

Configurar o serviço Web PubSub `Event Handler`

Neste exemplo, usamos WebPubSubTrigger para escutar as solicitações upstream do serviço. Portanto, o Web PubSub precisa saber as informações do ponto de extremidade da função para enviar solicitações de cliente de destino. Além disso, o aplicativo de funções do Azure exige uma chave do sistema para segurança em relação aos métodos de webhook específicos da extensão. Na etapa anterior, depois de implantarmos o aplicativo de funções com as funções message, obteremos a chave do sistema.

Acesse Portal do Azure -> localize seu recurso do Aplicativo de Funções ->Chaves do aplicativo ->Chaves do sistema ->webpubsub_extension. Copie o valor como <APP_KEY>.

Captura de tela da obtenção das chaves do sistema da função.

Defina Event Handler no serviço Azure Web PubSub. Acesse Portal do Azure -> localize seu recurso do Web PubSub ->Configurações. Adicione um novo mapeamento de configurações de hub para a função em uso. Substitua o <FUNCTIONAPP_NAME> e a <APP_KEY> pelas suas informações.

Nome do hub: simplechat
Modelo de URL: https://<FUNCTIONAPP_NAME>.azurewebsites.net/runtime/webhooks/webpubsub?code=<APP_KEY>
Padrão de evento do usuário: *
Eventos do Sistema: – (não é necessário configurar essa opção neste exemplo)

Captura de tela da configuração do manipulador de eventos.

Configurar o para habilitar a autenticação de cliente

Acesse Portal do Azure -> localize seu recurso do Aplicativo de Funções ->Autenticação. Clique em Add identity provider. Defina as configurações de autenticação do Serviço de Aplicativo como Permitir o acesso não autenticado, de modo que a página de índice do cliente possa ser visitada por usuários anônimos antes de redirecioná-los para autenticação. Em seguida, Salve.

Aqui, escolhemos Microsoft como o provedor de identidade, que usa x-ms-client-principal-name como userId na função negotiate. Além disso, você pode configurar outros provedores de identidade seguindo os links. Não se esqueça de atualizar o valor userId na função negotiate de acordo.

Experimentar o aplicativo

Agora você poderá testar sua página no aplicativo de funções: https://<FUNCTIONAPP_NAME>.azurewebsites.net/api/index. Veja o instantâneo.

Clique em login para se autenticar.
Digite uma mensagem na caixa de entrada para conversar.

Na função de mensagem, transmitimos a mensagem do chamador para todos os clientes e retornar o chamador com a mensagem [SYSTEM] ack. Portanto, podemos saber no instantâneo de exemplo de chat que as primeiras quatro mensagens são do cliente atual e as duas últimas mensagens são de outro cliente.

Captura de tela do exemplo de chat.

Limpar recursos

Se você não pretende continuar usando este aplicativo, exclua todos os recursos criados por este documento com as seguintes etapas para não gerar custos:

No portal do Azure, selecione Grupos de recursos na extremidade esquerda, depois selecione o recurso de grupo que você criou. Você poderá usar a caixa de pesquisa para localizar o grupo de recursos pelo nome.
Na janela que será aberta, selecione o grupo de recursos e escolha Excluir grupo de recursos.
Na nova janela, digite o nome do grupo de recursos a ser excluído e selecione Excluir.

Próximas etapas

Neste início rápido, você aprendeu a executar um aplicativo de chat sem servidor. Agora, você pode começar a criar seu próprio aplicativo.

Associações do Azure Web PubSub para o Azure Functions

Início Rápido: Criar uma sala de chat simples com o Azure Web PubSub

Explorar mais exemplos do Azure Web PubSub

Compartilhar via

Tutorial: Criar um aplicativo de chat em tempo real sem servidor com o Azure Functions e o serviço Azure Web PubSub

Pré-requisitos

Criar uma instância do serviço Azure Web PubSub

Criar as funções

Criar e implantar o Aplicativo de Funções do Azure

Configurar o serviço Web PubSub `Event Handler`

Configurar o para habilitar a autenticação de cliente

Experimentar o aplicativo

Limpar recursos

Próximas etapas

Comentários

Recursos adicionais

Compartilhar via

Tutorial: Criar um aplicativo de chat em tempo real sem servidor com o Azure Functions e o serviço Azure Web PubSub

Pré-requisitos

Entrar no Azure

Criar uma instância do serviço Azure Web PubSub

Criar as funções

Criar e implantar o Aplicativo de Funções do Azure

Configurar o serviço Web PubSub Event Handler

Configurar o para habilitar a autenticação de cliente

Experimentar o aplicativo

Limpar recursos

Próximas etapas

Comentários

Recursos adicionais

Configurar o serviço Web PubSub `Event Handler`