Aller au contenu

Programmation orientée réseau et développement d'applications web#

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 avec defer.

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 ou net.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().