010 network oriented
Concepts de base des protocoles TCP et UDP#
- TCP (Transmission Control Protocol) : - Orienté connexion, nécessite une connexion établie entre les machines avant la transmission de données. - Fournit la livraison de paquets en ordre et sans erreur. - Peut entraîner des latences plus élevées en raison des accusés de réception et des retransmissions. - Utilisé pour des applications nécessitant une transmission de données fiable, comme les serveurs web (HTTP/HTTPS).
- UDP (User Datagram Protocol) : - Sans connexion, ne nécessite pas de connexion établie avant la transmission de données. - Ne garantit pas la livraison de paquets en ordre ni sans erreur. - Plus rapide et moins gourmand en ressources que TCP, mais moins fiable. - Adapté aux applications de diffusion en temps réel, comme le streaming vidéo ou la VoIP.
Création d'un client TCP en Go#
- Utilisation du package
net
de la bibliothèque standard Go. - Fonction
net.Dial
pour initier une connexion TCP. - Exemple de code :
package main import ( "fmt" "net" "log" ) func main() { conn, err := net.Dial("tcp", "localhost:8080") if err != nil { log.Fatal(err) } defer conn.Close() fmt.Fprintf(conn, "Bonjour depuis le client TCP!\n") }
- Gestion des erreurs avec
log.Fatal
et contrôle de la fermeture de la connexion avecdefer
.
Création d'un serveur TCP en Go#
- Utilisation du package
net
. - Fonction
net.Listen
pour écouter sur un port spécifique. - Traitement des clients avec
Accept
et gestion des requêtes dans des goroutines pour parallélisation. - Exemple de code :
package main import ( "bufio" "fmt" "net" "log" ) func main() { ln, err := net.Listen("tcp", ":8080") if err != nil { log.Fatal(err) } for { conn, err := ln.Accept() if err != nil { log.Println(err) continue } go handleConnection(conn) } } func handleConnection(conn net.Conn) { message, _ := bufio.NewReader(conn).ReadString('\n') fmt.Print("Message reçu:", string(message)) conn.Close() }
- Utilisation de
bufio
pour lire les données reçues.
Création d'un client UDP en Go#
- Utilisation du package
net
. - Fonction
net.DialUDP
pour initier une connexion UDP. - Exemple de code :
package main import ( "fmt" "net" "log" ) func main() { addr, err := net.ResolveUDPAddr("udp", "localhost:8081") if err != nil { log.Fatal(err) } conn, err := net.DialUDP("udp", nil, addr) if err != nil { log.Fatal(err) } defer conn.Close() fmt.Fprintf(conn, "Bonjour depuis le client UDP!\n") }
- Utilisation de
net.ResolveUDPAddr
pour résoudre l'adresse.
Création d#
'un serveur UDP en Go
- Utilisation du package
net
. - Fonction
net.ListenUDP
pour écouter sur un port spécifique. - Exemple de code :
package main import ( "fmt" "net" "log" ) func main() { addr, err := net.ResolveUDPAddr("udp", ":8081") if err != nil { log.Fatal(err) } conn, err := net.ListenUDP("udp", addr) if err != nil { log.Fatal(err) } defer conn.Close() buffer := make([]byte, 1024) n, _, _ := conn.ReadFromUDP(buffer) fmt.Println(string(buffer[:n])) }
- Utilisation de
ReadFromUDP
pour lire les données reçues.
Gestion des erreurs et des déconnexions#
- Gestion des erreurs avec le second retour des fonctions, par exemple
net.Dial
ounet.Listen
. - Si une erreur se produit, le programme s'arrête généralement ou passe à la prochaine itération.
- Pour la gestion des déconnexions, il est important de fermer les connexions après utilisation pour libérer des ressources, par exemple en utilisant
defer conn.Close()
.