Bien démarrer avec les requêtes HTTP de connexions hybrides Relay dans Java

Article
08/19/2024

NET
Node.JS

Dans ce guide de démarrage rapide, vous créez des applications Java, à savoir un expéditeur et un récepteur, qui envoient et reçoivent des messages à l’aide du protocole HTTP. Les applications utilisent la fonctionnalité Connexions hybrides d’Azure Relay. Pour en savoir plus sur Azure Relay en général, consultez Azure Relay.

Ce démarrage rapide comporte les étapes suivantes :

Créer un espace de noms Relay à l’aide du portail Azure.
Créer une connexion hybride dans cet espace de noms à l’aide du portail Azure.
Écrire une application de console (écouteur) de serveur pour recevoir des messages.
Écrire une application de console (expéditeur) de client pour envoyer des messages.
Exécuter les applications.

Prérequis

Java. Veillez à exécuter JDK 1.8+
Maven. Assurez-vous que Maven est installé
SDK Azure Relay. Passer en revue le SDK Java
Un abonnement Azure. Si vous n’en avez pas, créez un compte gratuit avant de commencer.

Créer un espace de noms à l’aide du Portail Azure

Connectez-vous au portail Azure.
Sélectionnez Tous les services dans le menu de gauche. Sélectionnez Intégration, recherchez Relais, déplacez la souris sur Relais, puis sélectionnez Créer.
Dans la page Créer un espace de noms, suivez ces étapes :
1. Choisissez un abonnement Azure dans lequel créer l’espace de noms.
2. Pour l’option Groupe de ressources, choisissez un groupe de ressources existant dans lequel placer l’espace de noms, ou créez-en un nouveau.
3. Donnez un nom à l’espace de noms Relais.
4. Sélectionnez la région où votre espace de noms doit être hébergé.
5. Au bas de la page, sélectionnez Examiner et créer.
6. Dans la page Vérifier + créer, sélectionnez Créer.
7. Après quelques minutes, la page Relais de l’espace de noms s’affiche.

Obtenir des informations d'identification d'administration

Dans la page Relais, sélectionnez Stratégies d’accès partagé sur le menu de gauche.
Dans la page Stratégies d’accès partagé, sélectionnez RootManageSharedAccessKey.
Sous Stratégie SAS : RootManageSharedAccessKey, sélectionnez le bouton Copier à côté de Chaîne de connexion principale. L’action copie la chaîne de connexion dans le Presse-papiers pour l’utiliser plus tard. Copiez cette valeur dans le Bloc-notes ou un autre emplacement temporaire.
Répétez l’étape précédente pour copier et coller la valeur de Clé primaire dans un emplacement temporaire pour une utilisation ultérieure.

Créer une connexion hybride à l’aide du portail Azure

Dans la page Relay de votre espace de noms, suivez ces étapes pour créer une connexion hybride.

Dans le menu de gauche, sous Entités, sélectionnez Connexions hybrides, puis + Connexion hybride.
Dans la page Créer une connexion hybride, entrez un nom pour la connexion hybride, puis sélectionnez Créer.

Créer une application de serveur (récepteur)

Pour écouter et recevoir des messages à partir de Relay, écrivez une application console Java.

Création d’une application Java

Si vous avez désactivé l’option « Nécessite l’autorisation client » lors de la création du Relay, vous pouvez envoyer des requêtes à l’URL de Connexions hybrides avec n’importe quel navigateur. Pour accéder à des points de terminaison protégés, vous devez créer et mettre un jeton dans l’en-tête ServiceBusAuthorization, montré ici.

Voici une structure de projet Maven simple et une classe Java qui illustre l’envoi de requêtes à une URL de connexions hybrides avec l’autorisation cliente utilisant la bibliothèque Azure Relay.

Ajouter le package Relay

Modifiez votre fichier pom.xml dans votre package d’application Maven pour inclure le package Azure Relay.

<dependency>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>azure-relay</artifactId>
    <version>0.0.6</version>
</dependency>

Exécutez mvn dependency:copy-dependencies -DoutputDirectory=lib dans votre projet mvn pour ajouter le fichier jar de dépendances dans le répertoire lib de votre projet. Il importe toutes les dépendances du package mvn azure-relay. Ce package fournit des fonctions permettant de construire des identificateurs de ressources uniformes (URI) Relay et des jetons.

Écriture de code pour envoyer des messages

Ajoutez les fichiers jar de dépendances au ClassPath de votre fichier Listener.java.
```
javac -cp lib/* src/main/java/com/example/listener/Listener.Java
```

Importez les dépendances dans votre classe Listener.java.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Scanner;
import com.microsoft.azure.relay.HybridConnectionListener;
import com.microsoft.azure.relay.RelayConnectionStringBuilder;
import com.microsoft.azure.relay.RelayedHttpListenerResponse;
import com.microsoft.azure.relay.TokenProvider;

Ajoutez les constants suivantes en haut du fichier Listener.java à une fonction java createConnectionString pour les détails des connexions hybrides.
```
public static String createConnectionString(){
    StringBuilder connectionString = new StringBuilder();
    connectionString.append("Endpoint=sb://");
    connectionString.append("{namespace}");
    connectionString.append(".servicebus.windows.net/;SharedAccessKeyName=");
    connectionString.append("{keyrule}");
    connectionString.append(";SharedAccessKey=");
    connectionString.append("{key}");
    connectionString.append(";EntityPath=");
    connectionString.append("{path}");
    return connectionString.toString();
}
```
Remplacez les espaces réservés entre crochets par les valeurs obtenues lors de la création de la connexion hybride.
- namespace - L’espace de noms du relais. Veillez à utiliser le nom de l’espace de noms complet, par exemple {namespace}.servicebus.windows.net.
- path - Le nom de la connexion hybride.
- keyrule : nom de votre clé de stratégies d’accès partagé, qui est RootManageSharedAccessKey par défaut.
- nst key : clé primaire de l’espace de noms que vous avez enregistrée précédemment.

Ajoutez le code suivant au fichier Listener.java. La fonction main doit ressembler au code suivant :

public static void main( String[] args ) throws URISyntaxException
{
    String CONNECTION_STRING_ENV_VARIABLE_NAME = createConnectionString();
    RelayConnectionStringBuilder connectionParams = new RelayConnectionStringBuilder(CONNECTION_STRING_ENV_VARIABLE_NAME);
    TokenProvider tokenProvider = TokenProvider.createSharedAccessSignatureTokenProvider(
                connectionParams.getSharedAccessKeyName(),
                connectionParams.getSharedAccessKey());
    HybridConnectionListener listener = new HybridConnectionListener(new URI(connectionParams.getEndpoint().toString() + connectionParams.getEntityPath()), tokenProvider);

    // The "context" object encapsulates both the incoming request and the outgoing response
    listener.setRequestHandler((context) -> {
        String receivedText = "";
        if (context.getRequest().getInputStream() != null) {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(context.getRequest().getInputStream(), "UTF8"))) {
                StringBuilder builder = new StringBuilder();
                String inputLine;
                while ((inputLine = reader.readLine()) != null) {
                    builder.append(inputLine);
                }
                receivedText = builder.toString();
            } catch (IOException e) {
                System.out.println(e.getMessage());
            }
        }
        System.out.println("requestHandler received " + receivedText);

        RelayedHttpListenerResponse response = context.getResponse();
        response.setStatusCode(202);
        response.setStatusDescription("OK");

        try {
            response.getOutputStream().write(("Echo: " + receivedText).getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }

        // The context MUST be closed for the message to be sent
        response.close();
    });

    listener.openAsync().join();

    Scanner in = new Scanner(System.in);
    System.out.println("Press ENTER to terminate this program.");
    in.nextLine();

    listener.close();
    in.close();
}

Voici à quoi devrait ressembler votre fichier Listener.java :

package com.example.listener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Scanner;
import com.microsoft.azure.relay.HybridConnectionListener;
import com.microsoft.azure.relay.RelayConnectionStringBuilder;
import com.microsoft.azure.relay.RelayedHttpListenerResponse;
import com.microsoft.azure.relay.TokenProvider;

 public class Listener
 {
    public static String createConnectionString(){
        StringBuilder connectionString = new StringBuilder();
        connectionString.append("Endpoint=sb://");
        connectionString.append("{namespace}");
        connectionString.append(".servicebus.windows.net/;SharedAccessKeyName=");
        connectionString.append("{keyrule}");
        connectionString.append(";SharedAccessKey=");
        connectionString.append("{key}");
        connectionString.append(";EntityPath=");
        connectionString.append("{path}");
        return connectionString.toString();
    }

    public static void main( String[] args ) throws URISyntaxException
    {
        String CONNECTION_STRING_ENV_VARIABLE_NAME = createConnectionString();
        RelayConnectionStringBuilder connectionParams = new RelayConnectionStringBuilder(CONNECTION_STRING_ENV_VARIABLE_NAME);
        TokenProvider tokenProvider = TokenProvider.createSharedAccessSignatureTokenProvider(
                    connectionParams.getSharedAccessKeyName(),
                    connectionParams.getSharedAccessKey());
        HybridConnectionListener listener = new HybridConnectionListener(new URI(connectionParams.getEndpoint().toString() + connectionParams.getEntityPath()), tokenProvider);

        // The "context" object encapsulates both the incoming request and the outgoing response
        listener.setRequestHandler((context) -> {
            String receivedText = "";
            if (context.getRequest().getInputStream() != null) {
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(context.getRequest().getInputStream(), "UTF8"))) {
                    StringBuilder builder = new StringBuilder();
                    String inputLine;
                    while ((inputLine = reader.readLine()) != null) {
                        builder.append(inputLine);
                    }
                    receivedText = builder.toString();
                } catch (IOException e) {
                    System.out.println(e.getMessage());
                }
            }
            System.out.println("requestHandler received " + receivedText);

            RelayedHttpListenerResponse response = context.getResponse();
            response.setStatusCode(202);
            response.setStatusDescription("OK");

            try {
                response.getOutputStream().write(("Echo: " + receivedText).getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            }

            // The context MUST be closed for the message to be sent
            response.close();
        });

        listener.openAsync().join();

        Scanner in = new Scanner(System.in);
        System.out.println("Press ENTER to terminate this program.");
        in.nextLine();

        listener.close();
        in.close();
    }
}

Créer une application cliente (expéditeur)

Pour envoyer des messages à Relay, vous pouvez utiliser un client HTTP quelconque ou écrire une application console Java.

Création d’une application Java

Ajouter le package Relay

Modifiez votre fichier pom.xml dans votre package d’application Maven pour inclure le package Azure Relay.

<dependency>
	<groupId>com.microsoft.azure</groupId>
	<artifactId>azure-relay</artifactId>
	<version>0.0.6</version>
</dependency>

Exécutez mvn dependency:copy-dependencies -DoutputDirectory=lib dans votre projet mvn pour ajouter le fichier jar de dépendances dans le répertoire lib de votre projet. Il importe également toutes les dépendances du package mvn azure-relay. Ce package fournit des fonctions permettant de construire des identificateurs de ressources uniformes (URI) Relay et des jetons.

Écriture de code pour envoyer des messages

Ajoutez les fichiers jar de dépendances au ClassPath de votre fichier Sender.java.
```
javac -cp lib/* src/main/java/com/example/sender/Sender.Java
```

Importez les dépendances dans votre classe Sender.java.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.time.Duration;
import java.util.Scanner;
import com.microsoft.azure.relay.RelayConnectionStringBuilder;
import com.microsoft.azure.relay.TokenProvider;

Ajoutez les constants suivantes en haut du fichier Sender.java à une fonction java createConnectionString pour les détails des connexions hybrides.
```
public static String createConnectionString(){
    StringBuilder connectionString = new StringBuilder();
    connectionString.append("Endpoint=sb://");
    connectionString.append("{namespace}");
    connectionString.append(".servicebus.windows.net/;SharedAccessKeyName=");
    connectionString.append("{keyrule}");
    connectionString.append(";SharedAccessKey=");
    connectionString.append("{key}");
    connectionString.append(";EntityPath=");
    connectionString.append("{path}");
    return connectionString.toString();
}
```
Remplacez les espaces réservés entre crochets par les valeurs obtenues lors de la création de la connexion hybride.
- namespace - L’espace de noms du relais. Veillez à utiliser le nom de l’espace de noms complet, par exemple {namespace}.servicebus.windows.net.
- path - Le nom de la connexion hybride.
- keyrule : nom de votre clé de stratégies d’accès partagé, qui est RootManageSharedAccessKey par défaut.
- nst key : clé primaire de l’espace de noms que vous avez enregistrée précédemment.

Ajoutez le code suivant au fichier Sender.java. La fonction main doit ressembler au code suivant.

public static void main(String[] args) throws IOException {
    String CONNECTION_STRING_ENV_VARIABLE_NAME = createConnectionString();
    if (CONNECTION_STRING_ENV_VARIABLE_NAME == null || CONNECTION_STRING_ENV_VARIABLE_NAME.isEmpty()){
        System.err.println("Connection string is null or empty. Please check your createConnectionString method.");
        return;
    }
    RelayConnectionStringBuilder connectionParams = new RelayConnectionStringBuilder(CONNECTION_STRING_ENV_VARIABLE_NAME);
    TokenProvider tokenProvider = TokenProvider.createSharedAccessSignatureTokenProvider(
            connectionParams.getSharedAccessKeyName(), 
            connectionParams.getSharedAccessKey());
    URL url = buildHttpConnectionURL(connectionParams.getEndpoint().toString(), connectionParams.getEntityPath());
    String tokenString = tokenProvider.getTokenAsync(url.toString(), Duration.ofHours(1)).join().getToken();
    Scanner in = new Scanner(System.in);
    while (true) {
        System.out.println("Press ENTER to terminate this program.");
        String message = in.nextLine();
        int value = System.in.read();
        if (value == '\n' || value == '\r') {
            System.out.println("Terminating the program...");
            break;}
        // Starting a HTTP connection to the listener
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        // Sending an HTTP request to the listener
        // To send a message body, use POST
        conn.setRequestMethod((message == null || message.length() == 0) ? "GET" : "POST");
        conn.setRequestProperty("ServiceBusAuthorization", tokenString);
        conn.setDoOutput(true);
        OutputStreamWriter out = new OutputStreamWriter(conn.getOutputStream());
        out.write(message, 0, message.length());
        out.flush();
        out.close();
        // Reading the HTTP response
        String inputLine;
        BufferedReader reader = null;
        StringBuilder responseBuilder = new StringBuilder();
        try {
            InputStream inputStream = conn.getInputStream();
            reader = new BufferedReader(new InputStreamReader(inputStream));
            System.out.println("status code: " + conn.getResponseCode());
            while ((inputLine = reader.readLine()) != null) {
                responseBuilder.append(inputLine);
            }
            System.out.println("received back " + responseBuilder.toString());
        } catch (IOException e) {
            System.out.println("The listener is offline or could not be reached.");
            break;
        } finally {
            if (reader != null) {
                reader.close();
            }
        }
    }
    in.close();
}

static URL buildHttpConnectionURL(String endpoint, String entity) throws MalformedURLException {
    StringBuilder urlBuilder = new StringBuilder(endpoint + entity);

    // For HTTP connections, the scheme must be https://
    int schemeIndex = urlBuilder.indexOf("://");
    if (schemeIndex < 0) {
        throw new IllegalArgumentException("Invalid scheme from the given endpoint.");
    }
    urlBuilder.replace(0, schemeIndex, "https");
    return new URL(urlBuilder.toString());
}

Voici à quoi devrait ressembler votre fichier Sender.java :

package com.example.sender;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.time.Duration;
import java.util.Scanner;
import com.microsoft.azure.relay.RelayConnectionStringBuilder;
import com.microsoft.azure.relay.TokenProvider;

public class Sender
{
    public static String createConnectionString(){
        StringBuilder connectionString = new StringBuilder();
        connectionString.append("Endpoint=sb://");
        connectionString.append("{namespace}");
        connectionString.append(".servicebus.windows.net/;SharedAccessKeyName=");
        connectionString.append("{keyrule}");
        connectionString.append(";SharedAccessKey=");
        connectionString.append("{key}");
        connectionString.append(";EntityPath=");
        connectionString.append("{path}");
        return connectionString.toString();
        }
    public static void main(String[] args) throws IOException {
        String CONNECTION_STRING_ENV_VARIABLE_NAME = createConnectionString();
        if (CONNECTION_STRING_ENV_VARIABLE_NAME == null || CONNECTION_STRING_ENV_VARIABLE_NAME.isEmpty()){
            System.err.println("Connection string is null or empty. Please check your createConnectionString method.");
            return;
        }
        RelayConnectionStringBuilder connectionParams = new RelayConnectionStringBuilder(CONNECTION_STRING_ENV_VARIABLE_NAME);
        TokenProvider tokenProvider = TokenProvider.createSharedAccessSignatureTokenProvider(
                connectionParams.getSharedAccessKeyName(), 
                connectionParams.getSharedAccessKey());
        URL url = buildHttpConnectionURL(connectionParams.getEndpoint().toString(), connectionParams.getEntityPath());
        String tokenString = tokenProvider.getTokenAsync(url.toString(), Duration.ofHours(1)).join().getToken();
        Scanner in = new Scanner(System.in);
        while (true) {
            System.out.println("Press ENTER to terminate this program.");
            String message = in.nextLine();
            int value = System.in.read();
            if (value == '\n' || value == '\r') {
                System.out.println("Terminating the program...");
                break;}
            // Starting a HTTP connection to the listener
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            // Sending an HTTP request to the listener
            // To send a message body, use POST
            conn.setRequestMethod((message == null || message.length() == 0) ? "GET" : "POST");
            conn.setRequestProperty("ServiceBusAuthorization", tokenString);
            conn.setDoOutput(true);
            OutputStreamWriter out = new OutputStreamWriter(conn.getOutputStream());
            out.write(message, 0, message.length());
            out.flush();
            out.close();
            // Reading the HTTP response
            String inputLine;
            BufferedReader reader = null;
            StringBuilder responseBuilder = new StringBuilder();
            try {
                InputStream inputStream = conn.getInputStream();
                reader = new BufferedReader(new InputStreamReader(inputStream));
                System.out.println("status code: " + conn.getResponseCode());
                while ((inputLine = reader.readLine()) != null) {
                    responseBuilder.append(inputLine);
                }
                System.out.println("received back " + responseBuilder.toString());
            } catch (IOException e) {
                System.out.println("The listener is offline or could not be reached.");
                break;
            } finally {
                if (reader != null) {
                    reader.close();
                }
            }
        }
        in.close();
    }

    static URL buildHttpConnectionURL(String endpoint, String entity) throws MalformedURLException {
        StringBuilder urlBuilder = new StringBuilder(endpoint + entity);

        // For HTTP connections, the scheme must be https://
        int schemeIndex = urlBuilder.indexOf("://");
        if (schemeIndex < 0) {
            throw new IllegalArgumentException("Invalid scheme from the given endpoint.");
        }
        urlBuilder.replace(0, schemeIndex, "https");
        return new URL(urlBuilder.toString());
    }
}

Remarque

L’exemple de code de cet article utilise une chaîne de connexion pour s’authentifier auprès d’un espace de noms Azure Relay afin de simplifier le tutoriel. Nous vous recommandons d’utiliser l’authentification Microsoft Entra ID dans les environnements de production, plutôt que d’utiliser des chaînes de connexion ou des signatures d’accès partagé, qui peuvent être plus facilement compromises. Pour obtenir des informations détaillées et des exemples de code sur l’utilisation de l’authentification Microsoft Entra ID, consultez Authentifier et autoriser une application avec Microsoft Entra ID pour accéder aux entités Azure Relay et Authentifier une identité managée avec Microsoft Entra ID pour accéder aux ressources Azure Relay.

Exécution des applications

Exécutez l’application serveur : à partir d’une invite de commandes Java ou du type d’application java -cp <jar_dependency_path> com.example.listener.Listener.java.
Exécutez l’application cliente : à partir d’une invite de commandes Java ou du type d’application java -cp <jar_dependency_path> com.example.sender.Sender.java, puis entrez du texte.
Vérifiez que la console d’application de serveur renvoie le texte entré dans l’application cliente.

Félicitations, vous avez créé une application de connexions hybrides complète avec Java !

Étapes suivantes

Dans ce guide de démarrage rapide, vous avez créé des applications cliente et serveur Java qui utilisent HTTP pour envoyer et recevoir des messages. La fonctionnalité Connexions hybrides d’Azure Relay permet également d’envoyer et de recevoir des messages à l’aide de WebSockets. Pour apprendre à utiliser WebSockets avec des connexions hybrides Azure Relay, consultez le guide de démarrage rapide de WebSockets.

Dans ce guide de démarrage rapide, vous avez utilisé Java pour créer des applications cliente et serveur. Pour apprendre à écrire des applications cliente et serveur à l’aide du .NET Framework, consultez le guide de démarrage rapide de WebSockets dans .NET ou le guide de démarrage rapide de HTTP dans .NET.

Partager via

Bien démarrer avec les requêtes HTTP de connexions hybrides Relay dans Java

Prérequis

Créer un espace de noms à l’aide du Portail Azure

Obtenir des informations d'identification d'administration

Créer une connexion hybride à l’aide du portail Azure

Créer une application de serveur (récepteur)

Création d’une application Java

Ajouter le package Relay

Écriture de code pour envoyer des messages

Créer une application cliente (expéditeur)

Création d’une application Java

Ajouter le package Relay

Écriture de code pour envoyer des messages

Exécution des applications

Étapes suivantes

Commentaires

Ressources supplémentaires