Guia de início rápido: use Java para criar um aplicativo mostrando a contagem de estrelas do GitHub com o Azure Functions e o Serviço SignalR

Artigo
12/12/2024

Neste artigo, você usará o Serviço Azure SignalR, o Azure Functions e o Java para criar um aplicativo sem servidor para transmitir mensagens aos clientes.

Nota

O código neste artigo está disponível no GitHub.

Importante

As cadeias de conexão brutas aparecem neste artigo apenas para fins de demonstração.

Uma cadeia de conexão inclui as informações de autorização necessárias para seu aplicativo acessar o serviço Azure Web PubSub. A chave de acesso dentro da cadeia de conexão é semelhante a uma senha de root para o seu serviço. Em ambientes de produção, proteja sempre as suas chaves de acesso. Use o Azure Key Vault para gerenciar e girar suas chaves com segurança e proteger sua cadeia de conexão usando a ID do Microsoft Entra e autorizar o acesso com a ID do Microsoft Entra.

Evite distribuir chaves de acesso para outros usuários, codificá-las ou salvá-las em qualquer lugar em texto simples acessível a outras pessoas. Rode as chaves se acreditar que podem ter sido comprometidas.

Pré-requisitos

Um editor de código, como o Visual Studio Code
Uma conta do Azure com uma subscrição ativa. Se ainda não tiver uma conta, crie uma conta gratuitamente.
Ferramentas principais do Azure Functions. Usado para executar aplicativos do Azure Function localmente.
- As ligações necessárias do Serviço SignalR em Java só são suportadas no Azure Function Core Tools versão 2.4.419 (versão de host 2.0.12332) ou superior.
- Para instalar extensões, o Azure Functions Core Tools requer o SDK do .NET Core instalado. No entanto, nenhum conhecimento do .NET é necessário para criar aplicativos Java Azure Function.
Java Developer Kit, versão 11
Apache Maven, versão 3.0 ou superior.

Este início rápido pode ser executado no macOS, Windows ou Linux.

Criar uma instância do Azure SignalR Service

Nesta seção, você cria uma instância básica do Azure SignalR para usar em seu aplicativo. As etapas a seguir usam o portal do Azure para criar uma nova instância, mas você também pode usar a CLI do Azure. Para obter mais informações, consulte o comando az signalr create na Referência da CLI do Serviço Azure SignalR.

Inicie sessão no portal do Azure.
No canto superior esquerdo da página, selecione + Criar um recurso.
Na página Criar um recurso, na caixa de texto Serviços de pesquisa e marketplace, digite signalr e selecione Serviço SignalR na lista.
Na página Serviço SignalR, selecione Criar.
Na guia Noções básicas, você insere as informações essenciais para sua nova instância do Serviço SignalR. Introduza os seguintes valores:

Campo	Valor sugerido	Description
Subscrição	Selecione a sua subscrição	Selecione a assinatura que você deseja usar para criar uma nova instância do Serviço SignalR.
Grupo de recursos	Criar um grupo de recursos chamado SignalRTestResources	Selecione ou crie um grupo de recursos para o seu recurso SignalR. É útil criar um novo grupo de recursos para este tutorial em vez de usar um grupo de recursos existente. Para liberar recursos depois de concluir o tutorial, exclua o grupo de recursos. A exclusão de um grupo de recursos também exclui todos os recursos que pertencem ao grupo. Esta ação não pode ser anulada. Antes de excluir um grupo de recursos, verifique se ele não contém recursos que você deseja manter. Para obter mais informações, veja Utilizar grupos de recursos para gerir os recursos do Azure.
Nome do recurso	testsignalr	Introduza um nome de recurso exclusivo para utilizar no recurso do SignalR. Se o testsignalr já estiver em sua região, adicione um dígito ou caractere até que o nome seja exclusivo. O nome deve ser uma cadeia de 1 a 63 caracteres e conter apenas números, letras e o caractere hífen (`-`). O nome não pode começar ou terminar com o caractere de hífen e os caracteres de hífen consecutivos não são válidos.
Região	Escolha a sua região	Selecione a região apropriada para sua nova instância do Serviço SignalR. O Serviço Azure SignalR não está atualmente disponível em todas as regiões. Para obter mais informações, consulte Disponibilidade da região do Serviço Azure SignalR
Escalão de preço	Selecione Alterar e, em seguida, escolha Gratuito (Somente desenvolvimento/teste). Escolha Selecionar para confirmar sua escolha de nível de preço.	O Serviço Azure SignalR tem três níveis de preço: Gratuito, Standard e Premium. Os tutoriais usam o nível Gratuito , salvo indicação em contrário nos pré-requisitos. Para obter mais informações sobre as diferenças de funcionalidade entre camadas e preços, consulte Preços do Serviço Azure SignalR
Modo de serviço	Escolha o modo de serviço apropriado	Use Padrão quando hospedar a lógica do hub SignalR em seus aplicativos Web e usar o serviço SignalR como proxy. Use Serverless quando usar tecnologias Serverless , como o Azure Functions, para hospedar a lógica do hub SignalR. O modo clássico é apenas para compatibilidade com versões anteriores e não é recomendado o uso. Para obter mais informações, consulte Modo de serviço no Serviço Azure SignalR.

Não é necessário alterar as configurações nas guias Rede e Tags para os tutoriais do SignalR.

Selecione o botão Rever + criar na parte inferior do separador Noções básicas .
No separador Rever + criar, reveja os valores e, em seguida, selecione Criar. Leva alguns momentos para que a implantação seja concluída.
Quando a implantação estiver concluída, selecione o botão Ir para recurso.
Na página de recursos do SignalR, selecione Teclas no menu à esquerda, em Configurações.
Copie a cadeia de conexão para a chave primária. Você precisa dessa cadeia de conexão para configurar seu aplicativo posteriormente neste tutorial.

Configurar e executar a aplicação Funções do Azure

Verifique se você tem o Azure Function Core Tools, Java (versão 11 no exemplo) e Maven instalados.

Inicialize o projeto usando o Maven:

mvn archetype:generate -DarchetypeGroupId=com.microsoft.azure -DarchetypeArtifactId=azure-functions-archetype -DjavaVersion=11

O Maven pede os valores necessários para terminar de gerar o projeto. Forneça os seguintes valores:

Pedido	valor	Description
groupId	`com.signalr`	Um valor que identifica exclusivamente seu projeto em todos os projetos, seguindo as regras de nomenclatura de pacotes para Java.
artifactId	`java`	Um valor que é o nome do jar, sem um número de versão.
Versão	`1.0-SNAPSHOT`	Escolha o valor padrão.
embalagem	`com.signalr`	Um valor que é o pacote Java para o código de função gerado. Utilize a predefinição.

Vá para a pasta src/main/java/com/signalr e copie o seguinte código para Function.java:

package com.signalr;

import com.google.gson.Gson;
import com.microsoft.azure.functions.ExecutionContext;
import com.microsoft.azure.functions.HttpMethod;
import com.microsoft.azure.functions.HttpRequestMessage;
import com.microsoft.azure.functions.HttpResponseMessage;
import com.microsoft.azure.functions.HttpStatus;
import com.microsoft.azure.functions.annotation.AuthorizationLevel;
import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.azure.functions.annotation.HttpTrigger;
import com.microsoft.azure.functions.annotation.TimerTrigger;
import com.microsoft.azure.functions.signalr.*;
import com.microsoft.azure.functions.signalr.annotation.*;

import org.apache.commons.io.IOUtils;


import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.nio.charset.StandardCharsets;
import java.util.Optional;

public class Function {
    private static String Etag = "";
    private static String StarCount;

    @FunctionName("index")
    public HttpResponseMessage run(
            @HttpTrigger(
                name = "req",
                methods = {HttpMethod.GET},
                authLevel = AuthorizationLevel.ANONYMOUS)HttpRequestMessage<Optional<String>> request,
            final ExecutionContext context) throws IOException {

        InputStream inputStream = getClass().getClassLoader().getResourceAsStream("content/index.html");
        String text = IOUtils.toString(inputStream, StandardCharsets.UTF_8.name());
        return request.createResponseBuilder(HttpStatus.OK).header("Content-Type", "text/html").body(text).build();
    }

    @FunctionName("negotiate")
    public SignalRConnectionInfo negotiate(
            @HttpTrigger(
                name = "req",
                methods = { HttpMethod.POST },
                authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> req,
            @SignalRConnectionInfoInput(
                name = "connectionInfo",
                hubName = "serverless") SignalRConnectionInfo connectionInfo) {

        return connectionInfo;
    }

    @FunctionName("broadcast")
    @SignalROutput(name = "$return", hubName = "serverless")
    public SignalRMessage broadcast(
        @TimerTrigger(name = "timeTrigger", schedule = "*/5 * * * * *") String timerInfo) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder().uri(URI.create("https://api.github.com/repos/azure/azure-signalr")).header("User-Agent", "serverless").header("If-None-Match", Etag).build();
        HttpResponse<String> res = client.send(req, BodyHandlers.ofString());
        if (res.headers().firstValue("Etag").isPresent())
        {
            Etag = res.headers().firstValue("Etag").get();
        }
        if (res.statusCode() == 200)
        {
            Gson gson = new Gson();
            GitResult result = gson.fromJson(res.body(), GitResult.class);
            StarCount = result.stargazers_count;
        }

        return new SignalRMessage("newMessage", "Current start count of https://github.com/Azure/azure-signalr is:".concat(StarCount));
    }

    class GitResult {
        public String stargazers_count;
    }
}

Algumas dependências precisam ser adicionadas. Abra pom.xml e adicione as seguintes dependências usadas no código:

<dependency>
    <groupId>com.microsoft.azure.functions</groupId>
    <artifactId>azure-functions-java-library-signalr</artifactId>
    <version>1.0.0</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
</dependency>
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.7</version>
</dependency>

A interface do cliente para este exemplo é uma página da Web. Lemos o conteúdo HTML de content/index.html na função e, em index seguida, criamos um novo arquivo content/index.html no resources diretório. Sua árvore de diretórios deve ter esta aparência:

    | - src
    | | - main
    | | | - java
    | | | | - com
    | | | | | - signalr
    | | | | | | - Function.java
    | | | - resources
    | | | | - content
    | | | | | - index.html
    | - pom.xml
    | - host.json
    | - local.settings.json

Abra index.html e copie o seguinte conteúdo:

<html>

<body>
    <h1>Azure SignalR Serverless Sample</h1>
    <div id="messages"></div>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/microsoft-signalr/3.1.7/signalr.min.js"></script>
    <script>
    let messages = document.querySelector('#messages');
    const apiBaseUrl = window.location.origin;
    const connection = new signalR.HubConnectionBuilder()
        .withUrl(apiBaseUrl + '/api')
        .configureLogging(signalR.LogLevel.Information)
        .build();
        connection.on('newMessage', (message) => {
        document.getElementById("messages").innerHTML = message;
        });

        connection.start()
        .catch(console.error);
    </script>
</body>

</html>

O Azure Functions requer uma conta de armazenamento para funcionar. Você pode instalar e executar o Emulador de Armazenamento do Azure.
Você está quase terminado agora. A última etapa é definir uma cadeia de conexão do Serviço SignalR para as configurações da Função do Azure.
1. Procure a instância do Azure SignalR que você implantou anteriormente usando a caixa Pesquisar no portal do Azure. Selecione a instância para abri-la.
2. Selecione Chaves para ver as cadeias de ligação para a instância do Serviço SignalR.
3. Copie a cadeia de conexão primária e execute o seguinte comando.
  
  As cadeias de conexão brutas aparecem neste artigo apenas para fins de demonstração. Em ambientes de produção, proteja sempre as suas chaves de acesso. Use o Azure Key Vault para gerenciar e girar suas chaves com segurança e proteger sua cadeia de conexão usando a ID do Microsoft Entra e autorizar o acesso com a ID do Microsoft Entra.
```
func settings add AzureSignalRConnectionString "<signalr-connection-string>"
# Also we need to set AzureWebJobsStorage as Azure Function's requirement
func settings add AzureWebJobsStorage "UseDevelopmentStorage=true"
```
Execute a função do Azure no local:
```
mvn clean package
mvn azure-functions:run
```
Depois que o Azure Function estiver sendo executado localmente, vá para http://localhost:7071/api/index e você verá a contagem de estrelas atual. Se você estrela ou "desestrela" no GitHub, você terá uma contagem de estrelas atualizando a cada poucos segundos.

Clean up resources (Limpar recursos)

Se não pretender continuar a utilizar esta aplicação, elimine todos os recursos criados com este início rápido com os seguintes passos, para não lhe serem cobrados custos:

No portal do Azure, selecione Grupos de recursos à esquerda e, em seguida, selecione o grupo de recursos que criou. Em alternativa, pode utilizar a caixa de pesquisa para pesquisar o grupo de recursos pelo seu nome.
Na janela que abre, selecione o grupo de recursos e clique em Eliminar grupo de recursos.
Na nova janela, escreva o nome do grupo de recursos a eliminar e, em seguida, clique em Eliminar.

Tem problemas? Experimente o guia de resolução de problemas ou informe-nos.

Próximos passos

Neste início rápido, você criou e executou um aplicativo sem servidor em tempo real no host local. Em seguida, saiba mais sobre como comunicar bidirecional entre clientes e o Azure Function com o Serviço SignalR.

Associações do Serviço SignalR para o Azure Functions

Comunicação bidirecional no Serverless

Crie sua primeira função com Java e Maven

Partilhar via