Recherche de site Web

Comment écrire une application de calculatrice client-serveur en utilisant Python et ZeroMQ

ZeroMQ ou ZMQ pour faire court est une bibliothèque de mise en réseau intégrée. ZMQ vous fournit un socket qui transporte des messages petits/atomiques du client au serveur et vice-versa. Vous pouvez créer des communications par socket un à un, un à plusieurs et plusieurs à plusieurs avec ZMQ. Son modèle d'E/S asynchrone vous permet de construire des applications de messagerie très rapides et évolutives.

Dans cet article, nous allons vous montrer comment écrire une simple application de calculatrice client-serveur en utilisant la bibliothèque Python ZeroMQ. Cet article vous aide à vous familiariser avec ZeroMQ. Cet article couvre les sujets suivants de ZeroMQ :

  • Créer un contexte ZeroMQ
  • Créer un socket de requête ZeroMQ
  • Créer un socket de réponse ZeroMQ
  • Liaison d'une socket ZeroMQ
  • Connexion à un socket de réponse ZeroMQ
  • Utiliser la fonction recv() de ZeroMQ
  • Utiliser la fonction send() de ZeroMQ
  • Fermeture d'une socket ZeroMQ

Table des matières :

  • Installer ZeroMQ
  • Créer un répertoire de projet et des fichiers de projet
  • Écriture du code serveur ZeroMQ
  • Écriture du code client ZeroMQ
  • Comment fonctionne le programme de calculatrice Client-Serveur ZeroMQ
  • Explication du code serveur ZeroMQ
  • Explication du code client ZeroMQ
  • Test de l'application calculatrice Client-Serveur ZeroMQ
  • Conclusion

Installer ZeroMQ

Si vous avez besoin d'aide pour installer ZeroMQ sur Ubuntu 22.04 LTS ou sur tout système d'exploitation avec Python PIP installé, lisez l'article sur Comment installer ZeroMQ sur Ubuntu 22.04 LTS et l'utiliser avec Python 3.

Créer un répertoire de projet et des fichiers de projet

Pour garder tout organisé, créez un nouveau répertoire de projet ~/projects/zmq-python (disons) avec la commande suivante :

mkdir -pv ~/projects/zmq-python

Naviguez vers le nouveau répertoire de projet ~/projects/zmq-python comme suit :

cd ~/projects/zmq-python

Créez deux scripts Python, « client.py » et « server.py », dans le répertoire de projet ~/projects/zmq-python avec la commande suivante :

touch client.py server.py

Enfin, le répertoire du projet devrait ressembler à ce qui suit :

ls -lh

Écriture du code serveur ZeroMQ

Tapez les lignes de code suivantes dans le fichier "server.py" et enregistrez le fichier :

import zmq

context = zmq.Context()
socket = context.socket(zmq.REP) 
socket.bind("tcp://*:5000")

print("ZeroMQ server is ready...")


def decode_client_data(client_data):
    client_data = list(map(float, client_data.split(b',')))
    client_data[0] = int(client_data[0])
    return client_data


num_requests = 0

while True:
    num_requests = num_requests + 1
    
    try:
        client_data = socket.recv()
    except KeyboardInterrupt:
        socket.close()
        print("\nZeroMQ server is stopped.")
        break
    
    decoded_client_data = decode_client_data(client_data)

    option = decoded_client_data[0]
    num1 = decoded_client_data[1]
    num2 = decoded_client_data[2]

    match option:
        case 1:
            action = 'add'
            result = num1 + num2
        case 2:
            action = 'subtract'
            result = num1 - num2
        case 3:
            action = 'multiply'
            result = num1 * num2
        case 4:
            action = 'divide'
            result = num1 / num2
    
    print(f"request#{num_requests} action={action}, numbers=[{num1}, {num2}], result={result}")

    socket.send(bytes(str(result), "utf-8"))

Une fois que vous avez saisi tous les codes, le fichier « server.py » devrait ressembler à la capture d'écran suivante. Pour comprendre ce que fait le code et comment il fonctionne, lisez l'explication du code du serveur ZeroMQ.

Écriture du code client ZeroMQ

Tapez les lignes de code suivantes dans le fichier "client.py" et enregistrez le fichier :

import zmq

context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://localhost:5000")

print("Connected to ZeroMQ server.")

def take_option_input():
    prompt = """
What do you want to do?
    1. add numbers
    2. subtract numbers
    3. multiply numbers
    4. divide numbers
    5. exit
-> """
    
    try:
        option = input(prompt)
    except KeyboardInterrupt:
        option = 5

    return option


def take_numbers_input():
    num1 = float(input("number 1: "))
    num2 = float(input("number 2: "))

    return [num1, num2]

def encode_request_data(request_data):
    request_data_string = ','.join(map(str, request_data))
    encoded_data = bytes(request_data_string, 'utf-8')
    return encoded_data

while True:
    option = int(take_option_input())

    if option < 1 or option > 4: #option is 5 or outside range 1-4 - close client socket
        socket.close()
        print("\nClient disconnected from ZeroMQ server.")
        break

    numbers = take_numbers_input()
    request_data = [option, *numbers]
    encoded_data = encode_request_data(request_data)

    socket.send(encoded_data)

    result = float(socket.recv())
    print(f"result is: {result}")

Une fois que vous avez saisi tous les codes, le fichier « client.py » devrait ressembler à la capture d'écran suivante. Pour comprendre ce que fait le code et comment il fonctionne, lisez l'explication du code client ZeroMQ.

Comment fonctionne le programme de calculatrice Client-Serveur ZeroMQ

Le fichier "server.py" exécute un serveur ZeroMQ. Le serveur écoute les requêtes des clients ZeroMQ. Le fichier "client.py" exécute un client ZeroMQ. Le client ZeroMQ prend deux nombres à virgule flottante et l'opération arithmétique (addition, soustraction, multiplication ou division) à effectuer sur les nombres comme entrée de l'utilisateur. Une fois que les données d'entrée sont prises en charge par l'utilisateur, le programme client les encode, les envoie au serveur ZeroMQ et attend une réponse du serveur ZeroMQ. Le serveur ZeroMQ reçoit les données du client, les décode, effectue l'opération arithmétique sur les nombres à virgule flottante et renvoie le résultat au client ZeroMQ. Le programme client ZeroMQ reçoit le résultat et l'affiche à l'écran.

Explication du code serveur ZeroMQ

La ligne 1 importe le ZeroMQ.

La ligne 3 crée un contexte ZeroMQ.

La ligne 4 crée un socket de réponse ZeroMQ afin qu'il puisse répondre aux demandes des clients.

La ligne 5 lie le socket ZeroMQ au port TCP 5000.

Les lignes 9 à 12 créent une fonction decode_client_data(). Cette fonction prend les données clients encodées, les décode et renvoie les données sous forme de liste Python. Le premier élément de la liste est l'opération (c'est-à-dire addition, soustraction, multiplication, division) à effectuer sur le deuxième et le troisième éléments. Le deuxième et le troisième éléments sont des nombres à virgule flottante.

La variable num_requests ne fait que suivre le nombre de requêtes client ZeroMQ que le serveur ZeroMQ traité. Ce n'est pas très important.

Le programme serveur utilise une boucle while infinie (ligne 17) pour continuer à écouter les requêtes du client ZeroMQ.

La ligne 21 utilise la fonction socket.recv() pour lire les données envoyées par le client ZeroMQ.

L'instruction try-except est utilisée pour détecter l'exception KeyboardInterrupt et fermer la socket du serveur ZeroMQ lorsque l'exception KeyboardInterrupt se produit. Lorsque vous appuyez sur + C pendant que le programme « server.py » est en cours d'exécution, il envoie une exception KeyboardInterrupt au programme ZeroMQ, ce qui entraîne la fermeture de la socket du serveur ZeroMQ.

La ligne 27 décode les données qui sont envoyées par le client ZeroMQ.

Les données décodées sont stockées dans différentes variables pour rendre le programme plus lisible.

En fonction de l'option, une opération arithmétique est effectuée sur les nombres à virgule flottante, et le résultat est stocké dans une variable.

La ligne 47 affiche les statistiques du serveur, comme le numéro de la requête qu'il a traitée, l'action et les chiffres qu'il a reçus du client ZeroMQ, ainsi que le résultat qu'il renvoie au client ZeroMQ.

Dans la ligne 49, socket.send() est utilisé pour renvoyer le résultat au client ZeroMQ.

Explication du code client ZeroMQ

La ligne 1 importe le ZeroMQ.

La ligne 3 crée un contexte ZeroMQ.

La ligne 4 crée un socket de requête ZeroMQ afin de pouvoir envoyer les requêtes aux serveurs ZeroMQ.

La ligne 5 se connecte au serveur ZeroMQ qui fonctionne sur le port TCP 5000.

Les lignes 9 à 24 définissent la fonction take_option_input(). Cette fonction imprime les actions disponibles que l'utilisateur peut entreprendre et invite l'utilisateur à sélectionner une option dans la liste.

Les lignes 26 à 30 définissent la fonction take_numbers_input(). Cette fonction demande simplement à l'utilisateur de saisir deux nombres à virgule flottante et retourne les nombres à virgule flottante que l'utilisateur a saisis sous forme de liste.

Les lignes 32 à 35 définissent la fonction encode_request_data(). Cette fonction code l'option et deux nombres à virgule flottante que l'utilisateur a saisis dans un tableau d'octets UTF-8 afin que le programme client ZeroMQ puisse les envoyer au serveur ZeroMQ en une seule fois.

La ligne 37 exécute une boucle while infinie afin que le client ZeroMQ puisse continuer à demander à l'utilisateur de faire des calculs ou de quitter le programme client si l'utilisateur ne souhaite plus effectuer de calculs.

La ligne 40 vérifie si l'utilisateur veut quitter ou a choisi la mauvaise option.

La méthode socket.close() à la ligne 41 est utilisée pour fermer le socket client ZeroMQ si l'utilisateur choisit une mauvaise option ou l'option 5 (qui est quitter).

La ligne 45 prend deux nombres à virgule flottante comme entrées de l'utilisateur.

La ligne 46 crée une liste des options (opérations arithmétiques à effectuer) et des nombres à virgule flottante.

La ligne 47 encode les données du client.

La ligne 49 utilise socket.send() pour envoyer les données clients encodées au serveur ZeroMQ.

Une fois que le serveur ZeroMQ envoie une réponse, la ligne 51 utilise la fonction socket.recv() pour la lire.

La ligne 51 imprime le résultat reçu sur la console.

Test de l'application calculatrice Client-Serveur ZeroMQ

Pour tester l'application de calculatrice Client-Serveur ZeroMQ, exécutez d'abord le programme serveur ZeroMQ "server.py" avec la commande suivante :

python3 server.py

Comme vous pouvez le voir, le programme serveur ZeroMQ a démarré et il est prêt à répondre aux demandes des clients.

Ensuite, exécutez le programme client ZeroMQ "client.py" avec la commande suivante :

python3 client.py

Le programme client ZeroMQ est en cours d'exécution. Le programme client affiche les actions disponibles que les utilisateurs peuvent effectuer et attend que l'utilisateur en sélectionne une.

Commençons par l'opération arithmétique d'addition.

Tapez 1 et appuyez sur <Entrée>.

Tapez le premier nombre et appuyez sur <Entrée>.

Tapez le deuxième nombre et appuyez sur <Entrée>.

Comme vous pouvez le voir, un résultat est affiché.

Le programme serveur ZeroMQ affiche également les bonnes statistiques.

De la même manière, vous pouvez soustraire, multiplier et diviser les nombres en utilisant le programme client et serveur ZeroMQ.

Le serveur ZeroMQ affiche toutes les statistiques/demandes effectuées par le client ZeroMQ.

Pour fermer le programme client ZeroMQ, tapez 5 et appuyez sur <Entrée>. Le programme client ZeroMQ devrait être fermé.

Pour arrêter le programme serveur ZeroMQ, appuyez sur <Ctrl> + C. Le programme serveur ZeroMQ devrait être arrêté.

Conclusion

Nous vous avons montré comment écrire une simple application calculatrice client-serveur en utilisant la bibliothèque Python ZeroMQ. Nous avons couvert les fonctionnalités suivantes de ZeroMQ dans cet article :

  • Créer un contexte ZeroMQ
  • Créer un socket de requête ZeroMQ
  • Créer un socket de réponse ZeroMQ
  • Liaison d'une socket ZeroMQ
  • Connexion à un socket de réponse ZeroMQ
  • Utiliser la fonction recv() de ZeroMQ
  • Utiliser la fonction send() de ZeroMQ
  • Fermeture d'une socket ZeroMQ