L'architecture serveur-client est un modèle de communication où un serveur central gère les requêtes et fournit des services à plusieurs clients connectés. En utilisant la librairie `socket` du langage Python, il est possible de mettre en place un serveur qui peut prendre en charge plusieurs clients pour échanger des messages. Les sockets permettent l'établissement de connexions réseau, l'envoi et la réception de données entre les applications.
Pour créer un serveur en Python avec la librairie `socket`, il est nécessaire de suivre plusieurs étapes clés :
1. Création d'un socket serveur : On crée un socket en spécifiant l'adresse IP et le port sur lequel le serveur écoutera les connexions des clients.
2. Liaison du socket : Le socket est lié à une adresse IP et un port spécifique.
3. Attente des connexions : Le serveur reste en écoute pour accepter les connexions entrantes des clients.
Voici le code Python d'un serveur capable de gérer plusieurs clients pour qu'ils puissent s'échanger des messages, ainsi que le code du client associé :
**Serveur :**
```python
import socket
import threading
clients = []
def handle_client(client_socket, client_address):
while True:
message = client_socket.recv(1024).decode()
if message == "exit":
clients.remove((client_socket, client_address))
break
for client in clients:
if client != (client_socket, client_address): # Evite d'envoyer le message à l'émetteur
client[0].send(message.encode())
def main():
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("127.0.0.1", 9999))
server.listen(5)
print("Serveur en attente de connexions...")
while True:
client_socket, client_address = server.accept()
print(f"Connexion acceptée de {client_address}")
clients.append((client_socket, client_address))
client_handler = threading.Thread(target=handle_client, args=(client_socket, client_address))
client_handler.start()
if __name__ == "__main__":
main()
```
**Client :**
```python
import socket
import threading
def send_message():
while True:
message = input("Message à envoyer ('exit' pour quitter) : ")
client_socket.send(message.encode())
if message == "exit":
break
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect(("127.0.0.1", 9999))
send_thread = threading.Thread(target=send_message)
send_thread.start()
while True:
incoming_message = client_socket.recv(1024).decode()
print(f"Message reçu : {incoming_message}")
if incoming_message == "exit":
break
```
**Exemple de fonctionnement :**
1. Lancez d'abord le serveur, puis exécutez autant d'instances de clients que vous le souhaitez.
2. Chaque client peut envoyer des messages qui seront reçus par tous les autres clients connectés au serveur.
3. Pour quitter, un client peut saisir "exit" et la connexion se termine pour ce client.
4. Le serveur continue de fonctionner pour les autres clients connectés.
**Conditions requises pour le bon fonctionnement :**
1. Assurez-vous que le serveur et les clients sont exécutés sur des machines accessibles sur le même réseau, ou sur la même machine (localhost).
2. Les ports 9999 (ou tout autre port que vous spécifiez) doivent être disponibles et ouverts pour permettre les connexions.
3. Assurez-vous que le pare-feu ne bloque pas les connexions entrantes et sortantes sur le port spécifié.
4. Les adresses IP et les ports spécifiés dans les codes serveur et client doivent correspondre pour permettre une communication correcte.
N'hésitez pas à ajuster et personnaliser ces codes en fonction de vos besoins spécifiques et des fonctionnalités que vous souhaitez implémenter !
4. Acceptation des connexions : Lorsqu'un client se connecte, le serveur accepte la connexion et crée un nouveau socket dédié à ce client.
5. Échange de données : Le serveur et le client peuvent alors échanger des données via les sockets.
