Go: how to create a UDP client and server

Go (or Golang) is an open-source programming language developed by Google that offers high performance, ease of use, and networking support. In this article, well explore how to create a simple UDP client and server using Go.

What is UDP?

User Datagram Protocol (UDP) is a connectionless and unreliable communication protocol. Unlike TCP, UDP does not establish a connection before sending data, which makes it faster, but less reliable, as sent packets may be lost or arrive out of sequence. It is especially useful for applications where speed is critical and some data loss is not a concern, such as online gaming or content streaming.

Create the UDP Server

Lets start by creating the UDP server. This server will listen on a specific port and receive data sent by clients.

package main

import (
	"fmt"
	"net"
)

func main() {
	// Specifica l'indirizzo e la porta su cui il server UDP deve ascoltare
	serverAddr, err := net.ResolveUDPAddr("udp", ":8080")
	if err != nil {
		fmt.Println("Errore nella risoluzione dell'indirizzo:", err)
		return
	}

	// Crea una connessione UDP
	conn, err := net.ListenUDP("udp", serverAddr)
	if err != nil {
		fmt.Println("Errore nell'ascolto UDP:", err)
		return
	}
	defer conn.Close()

	fmt.Println("Server UDP in ascolto su", conn.LocalAddr())

	// Buffer per memorizzare i dati ricevuti
	buffer := make([]byte, 1024)

	for {
		// Ricevi dati dal client
		n, addr, err := conn.ReadFromUDP(buffer)
		if err != nil {
			fmt.Println("Errore nella lettura:", err)
			continue
		}

		// Converti i dati ricevuti in una stringa e stampali
		data := string(buffer[:n])
		fmt.Printf("Ricevuti %d byte da %s: %s\n", n, addr, data)
	}
}

Create the UDP Client

Now lets create the UDP client, which will send data to the specified server.

package main

import (
	"fmt"
	"net"
)

func main() {
	// Specifica l'indirizzo del server UDP
	serverAddr, err := net.ResolveUDPAddr("udp", "localhost:8080")
	if err != nil {
		fmt.Println("Errore nella risoluzione dell'indirizzo:", err)
		return
	}

	// Crea una connessione UDP
	conn, err := net.DialUDP("udp", nil, serverAddr)
	if err != nil {
		fmt.Println("Errore nella connessione UDP:", err)
		return
	}
	defer conn.Close()

	// Dati da inviare al server
	message := []byte("Ciao, server! Questo è un messaggio UDP.")

	// Invia i dati al server
	_, err = conn.Write(message)
	if err != nil {
		fmt.Println("Errore nell'invio dei dati:", err)
		return
	}

	fmt.Println("Dati inviati al server con successo.")
}

The client connects to the server using net.Dial and specifying the address and port of the server to connect to. After that, it sends the data to the server using conn.Write([]byte(data)) .

Running Server and Client

To run the server, save the server code in a file called server.go and the client code in a file called client.go . Next, open two terminals and navigate to both folders containing the respective client and server files.

In the first terminal, run the server:

go run server.go

In the second terminal, run the client:

go run client.go

You should see server output indicating receiving data from the client and client output indicating sending data to the server.

Conclusion

In this article, you learned how to create a simple UDP client and server using the Go programming language. Now you have a solid foundation for developing more complex and custom network applications in Go. Remember that UDP is an unreliable protocol, so you should implement proper flow control and error handling mechanisms if you want to use it for more critical applications. Experiment with the provided code and explore more features and possibilities offered by Go for networking.