Salut ! 

Après avoir suivi les cours sur le réseau en python, je maîtrise le sujet dans ses grandes lignes, maintenant je voudrais savoir s'il est possible de connecter un client et un serveur à distance.

On veut créer un jeu qui devra fonctionner en ligne (local suffirait mais à distance serait bien mieux).

Une raspberry ferait sûrement office de serveur qui serait connecter à un réseau quelconque, donc voilà, je pense avoir été assez clair.

En résumé, je voudrais savoir s'il existe des moyens de relier deux ordi à distance à la même manière que les transferts FTP ) 

Merci d'avance pour vos réponses ! 

À partir du moment où tu utilises des sockets Internet (AF_INET), ceux-ci fonctionnent de la même façon qu'il s'agisse de connecter deux machines du même réseau ou sur des réseaux reliés par Internet. Il te suffit de rendre le serveur (son port) accessible sur une IP publique, et que le client s'y connecte.

Ton code n'a pas besoin de changer.

Mieux que ça, ça veut dire que ton code s'en fiche de savoir si le serveur est sur la même machine, sur un réseau local ou sur une autre planète, du moment qu'il est accessible sur l'adresse IP et le port auquel il essaye de se connecter.

Oui. Enfin ça dépend aussi à quelle adresse tu bind() ton serveur (sur quelle interface il écoute). S'il écoute sur '127.0.0.1' ça ne continuera à fonctionner qu'en local. Si au contraire tu lui passes la chaîne vide comme adresse IP, alors il écoutera sur ce port sur toutes ses interfaces réseau, et dans ce cas tu as juste à rediriger un port de ta box vers le port de ton serveur sur la machine qui le fait tourner.

Par exemple ton IP publique est 1.2.3.4, la machine qui héberge le serveur sur ton réseau local est 192.168.0.13. Ton serveur écoute sur le port 12345.

Si tu rediriges le port 1337 de ta box vers 192.168.0.13:12345, alors tu peux te connecter à ton serveur depuis ton réseau local sur 192.168.0.13:12345 ou bien depuis n'importe où sur le net sur 1.2.3.4:1337.

Dans l'adresse du bind(), tu ne t'occupes que de ta machine. Si tu veux écouter sur le port 12345 sur toutes les interfaces réseau de ta machine, alors tu passes ('', 12345).

La redirection, c'est ton routeur qui la gère, au niveau du réseau c'est résolu bien avant que ça n'atteigne ton serveur, donc c'est complètement transparent pour lui. Ton code n'a pas besoin de savoir s'il se trouve derrière 0, 1 ou 30 routeurs : il ne s'occupe que de la machine qui le fait tourner.

-
Edité par nohar 19 janvier 2017 à 13:02:43

Voilà, c'est ça.

D'accord merci beaucoup pour ton temps et pour tes conseils !

Bonjour,

Je suis le partner a Quentin, nous essayons de connecter nos deux ordis a un serveur

Nous avons reussi mais il y a un petit soucis. Chacun de nous deux arrive a envoyer des messages au serveur, le serveur les recois. Cependant il faut que nous envoyons un msg pour recevoir celui de l'autre. La reception de client a client se fait mal. Voici les codes:

CODE SERVEUR

import socket
import time
import select
import os

#changement du repertoire de python
os.chdir("O:/Users/")
#ouverture du fichier en mode ecriture


#creation sur serveur (socke)
connexion_serveur = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connexion_serveur.bind(('',7000))
connexion_serveur.listen(5)

print("Le serveur est en ligne")
serveur_lance=True
listeclients =[]



while serveur_lance:
        connexion_wait,wlist,xlist = select.select([connexion_serveur],[],[],0.05)

        for connexion in connexion_wait:
                connexion_client,infos = connexion.accept()
                print("L'adresse",infos,"viens de se connecter")
                listeclients.append(connexion_client)
                
                client_a_lire = []
        try:
                client_a_lire,wlist,xlist = select.select(listeclients,[],[],0.05)
        except select.error:
                pass
        else:
                for client in client_a_lire:
                        msg_recu = client.recv(2343245)
                        msg_recu = msg_recu.decode()
                        
                        heure=time.strftime('%d/%m/%y %H:%M',time.localtime())
                        ecrire = heure+">> "+msg_recu+"\n"
                        print(ecrire)
                        for clientE in listeclients:
                                if clientE != client:
                                        msg_send = ecrire.encode()
                                        clientE.send(msg_send)
                        
                        
                        
                        convo = open("conversation.txt","a")
                        convo.write(ecrire)
                        convo.close()

                        if msg_recu == "fin":
                                serveur_lance = False
print("Le serveur se ferme")
for client in listeclients:
        client.close()
connexion_serveur.close()

CODE CLIENT

import socket
from threading import Thread
import time
import os
#recuperation des conversations
with open("conversation.txt","r") as mon_fichier:
    texte = mon_fichier.read()
    print(texte)

#creation du client et connexion au serveur
connexion_serveur = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connexion_serveur.connect(('XX.XXX.XX.X',6000))
online = True

class send(Thread):
    def __init__(self):
        Thread.__init__(self)
    def run(self):
        while 1:
            heure=time.strftime('%d/%m/%y %H:%M',time.localtime())
            msg_send = input(heure+">> ")
            msg_send = msg_send.encode()
            connexion_serveur.send(msg_send)

class receive(Thread):
    def __init__(self):
        Thread.__init__(self)
    def run(self):
        while 1:
            msg_recu = connexion_serveur.recv(324234)
            msg_recu = msg_recu.decode()
            print(">> ",msg_recu)


send().start()
receive().start()

Hmm, la boucle du serveur est un peu alambiquée. Vous n'avez pas besoin de faire deux select() distincts pour écouter sur le socket principal et sur les connexions client.

Schématiquement, le code serait déjà plus simple ainsi :

main_socket = socket(AF_INET, SOCK_STREAM)
# ... initialisation de main_socket ...

all_sockets = [main_socket]
while running:
    # pas de timeout : on attend jusqu'à ce qu'il se passe quelque-chose d'intéressant
    readable, _, _ = select(all_sockets, [], [])
    for sock in readable:
        if sock == main_socket:
            conn, addr = sock.accept()
            print("{}:{} connected".format(*addr))
            all_sockets.append(conn)
            continue
        # Il est conseillé d'utiliser une petite puissance de 2 pour la taille du buffer
        msg = sock.recv(4096)
        if msg == b'fin':
            running = False
        for dest in all_sockets:
            if dest in (sock, main_socket):
                continue
            # la méthode 'sendall' garantit que la totalité du
            # message est envoyée avant de retourner
            dest.sendall(msg)

# ... cleanup ...

Côté client : les méthodes __init__ ne servent à rien : elles se contentent d'appeler celles de la classe mère, ce qui est le comportement par défaut. Vous pouvez les virer

-
Edité par nohar 19 janvier 2017 à 22:34:20