Linux-netværk og TCP/IP for udviklere · Lektion

TCP-klient-serversockets

Implementér pålidelig, forbindelsesorienteret kommunikation ved at bygge grundlæggende TCP-klient- og serverapplikationer i Python

Lektion 2 af 411 trin

TCP-klient-serversockets er en gratis Linux-netværk og TCP/IP for udviklere-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Linux-netværk og TCP/IP for udviklere, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Linux-netværk og TCP/IP for udviklere-kurset indeholder 4 lektioner i alt.

TCP-sockets: Forbindelse først

Velkommen til opbygning af netværksapplikationer med Python! Denne lektion fokuserer på TCP-sockets (transmissionskontrolprotokol), som danner grundlaget for pålidelig internetkommunikation.

I modsætning til UDP er TCP en forbindelsesorienteret protokol. Det betyder, at der oprettes en direkte, stabil forbindelse mellem to applikationer, før der sendes data.

Hvorfor TCP er pålidelig

TCP sikrer, at dine data ankommer korrekt og i den rigtige rækkefølge. Den håndterer:

Garanteret levering: Datasegmenter sendes igen, hvis de går tabt.
Data i rækkefølge: Data ankommer i den rækkefølge, de blev sendt.
Fejlkontrol: Dataintegriteten kontrolleres.
Flowkontrol: Forhindrer, at en hurtig afsender overbelaster en langsom modtager.

Det gør TCP velegnet til webbrowsing, e-mail og filoverførsler.

TCP-server: Lytteren

En TCP-servers rolle er at lytte efter indgående forbindelser fra klienter. Her er den typiske arbejdsgang for en server:

Opret en socket.
Bind socketen til en IP-adresse og port.
Lyt efter klientforbindelser.
Acceptér en indgående forbindelse.
Kommunikér (send/modtag data).
Luk sockets.

Opret en Python-TCP-socket

I Python bruger vi det indbyggede socket-modul. For at oprette en TCP-socket angiver vi socket.AF_INET til IPv4-adressering og socket.SOCK_STREAM til TCP.

Prøv at køre dette grundlæggende eksempel:

import socket

def main():
    # Create a TCP/IP socket
    # AF_INET for IPv4, SOCK_STREAM for TCP
    tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    print("TCP socket created successfully!")
    tcp_socket.close()
    print("Socket closed.")

if __name__ == "__main__":
    main()

Server: Bind til adresse og port

Efter oprettelsen af socketen skal serveren binde den til en bestemt IP-adresse og et portnummer. Det fortæller operativsystemet, hvor serveren skal lytte efter forbindelser.

.bind((HOST, PORT)) knytter socketen til adressen. .listen(backlog) gør den klar til at acceptere forbindelser, hvor backlog er det maksimale antal forbindelser i køen.

import socket

def main():
    HOST = '127.0.0.1'  # Localhost
    PORT = 65432        # Port to listen on (non-privileged)

    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        server_socket.bind((HOST, PORT))
        server_socket.listen(1) # Allow 1 pending connection
        print(f"Server listening on {HOST}:{PORT}")
    except Exception as e:
        print(f"Error binding or listening: {e}")
    finally:
        server_socket.close()
        print("Server socket closed.")

if __name__ == "__main__":
    main()

Server: Acceptér en klient

.accept()-metoden er afgørende for en server. Den blokerer udførelsen, indtil en klient forsøger at oprette forbindelse. Når der er oprettet en forbindelse, returnerer den to værdier:

Et nyt socket-objekt (conn) til kommunikation med den pågældende klient.
Klientens adresse (addr), en (host, port)-tuple.

import socket

def main():
    HOST = '127.0.0.1'
    PORT = 65432

    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind((HOST, PORT))
    server_socket.listen(1)
    print(f"Server waiting for connection on {HOST}:{PORT}...")

    # This will block until a client connects
    conn, addr = server_socket.accept()
    with conn: # Use 'with' for auto-closing the client socket
        print(f"Connected by client from {addr}")
        # In a real app, send/recv would happen here
        conn.sendall(b"Hello from server!") # Send some bytes
        print("Sent greeting to client.")
    server_socket.close()
    print("Server socket closed.")

if __name__ == "__main__":
    main()

TCP-klient: Start forbindelsen

En TCP-klients rolle er at starte en forbindelse til en server. Her er den typiske arbejdsgang:

Opret en socket.
Opret forbindelse til serverens IP-adresse og port.
Kommunikér (send/modtag data).
Luk socketen.

Klient: Opret forbindelse til serveren

Klienten bruger .connect((HOST, PORT))-metoden til at oprette forbindelse til serveren. Hvis det lykkes, oprettes et virtuelt kredsløb. Hvis serveren ikke lytter, får du en ConnectionRefusedError.

Kør dette. Hvis der ikke kører en server, vises der en fejl:

import socket

def main():
    HOST = '127.0.0.1'  # Server's IP address
    PORT = 65432        # Server's port

    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        print(f"Attempting to connect to server at {HOST}:{PORT}...")
        client_socket.connect((HOST, PORT))
        print("Successfully connected to the server!")
    except ConnectionRefusedError:
        print("Connection refused. Is the server running?")
    except Exception as e:
        print(f"Client connection error: {e}")
    finally:
        client_socket.close()
        print("Client socket closed.")

if __name__ == "__main__":
    main()

Send og modtag data

Når forbindelsen er oprettet, kan både klienten og serveren sende og modtage data. Husk, at netværksdata overføres som bytes, så du ofte skal bruge .encode() på strenge, før de sendes, og .decode() til at konvertere modtagne bytes tilbage til strenge.

.sendall(data): Sender alle data pålideligt.
.recv(buffer_size): Modtager op til buffer_size bytes.

import socket

def main():
    HOST = '127.0.0.1'
    PORT = 65432

    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        client_socket.connect((HOST, PORT))
        message = "Hello from the client!"
        client_socket.sendall(message.encode('utf-8'))
        print(f"Client sent: '{message}'")

        data = client_socket.recv(1024) # Receive up to 1024 bytes
        if data:
            print(f"Client received: '{data.decode('utf-8')}'")
        else:
            print("Client received no data (server might have closed).")
    except ConnectionRefusedError:
        print("Connection refused. Please run the server example first!")
    except Exception as e:
        print(f"Client communication error: {e}")
    finally:
        client_socket.close()
        print("Client socket closed.")

if __name__ == "__main__":
    main()

TCP-kommunikationsforløb

Overvej de typiske trin, som en Python-TCP-server gennemgår for at oprette en forbindelse, og hvordan en ekko-klient kommunikerer.

Besvar den i den interaktive lektion

Opsummering: TCP-klient-server-sockets

Godt klaret! Du har lært det grundlæggende om TCP-klient-server-kommunikation i Python:

TCP leverer pålidelig, forbindelsesorienteret kommunikation.
Servere binder til en adresse, lytter efter forbindelser og accepterer klienter.
Klienter opretter forbindelse til en servers adresse.
Begge bruger .sendall() til at sende og .recv() til at modtage bytes.

Disse begreber er afgørende for at bygge robuste netværksapplikationer!

Gratis at komme i gang

Lær Linux-netværk og TCP/IP for udviklere med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “TCP-klient-serversockets” gratis?

Ja — hele teksten til “TCP-klient-serversockets” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Linux-netværk og TCP/IP for udviklere-kurset, skal du opgradere til CoddyKit PRO. Linux-netværk og TCP/IP for udviklere-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “TCP-klient-serversockets”?

Implementér pålidelig, forbindelsesorienteret kommunikation ved at bygge grundlæggende TCP-klient- og serverapplikationer i Python Du øver dig i Linux-netværk og TCP/IP for udviklere med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Linux-netværk og TCP/IP for udviklere?

Der kræves ingen tidligere erfaring. Linux-netværk og TCP/IP for udviklere på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “TCP-klient-serversockets”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Linux-netværk og TCP/IP for udviklere-lektion?

Ja. Alle Linux-netværk og TCP/IP for udviklere-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Linux-netværk og TCP/IP for udviklere