Go Netzwerkserver erstellen: Von TCP bis HTTP in einem Abend

Warum Go die ideale Sprache für Netzwerkprogrammierung ist

Wenn du jemals einen Netzwerkserver in Python geschrieben hast (besonders mit socket oder asyncio), weißt du, wie schnell der Code zu einem Labyrinth aus Callbacks und Event-Loops werden kann. Go (Golang) löst dieses Problem auf architektonischer Ebene: Goroutinen und Channels machen asynchrone Netzwerkarbeit so einfach wie das Schreiben von sequenziellem Code.

In diesem Artikel tauchen wir praktisch in die Go-Netzwerkprogrammierung ein. Du erfährst, wie du in 15 Minuten einen vollwertigen TCP-Chat baust, ein UDP-Paket sendest und einen HTTP-Server mit Routing startest. Alle Beispiele sind funktionsfähig und können direkt kopiert und ausgeführt werden.

Grundlagen: Das net-Paket und seine Superkraft

In Go lebt die gesamte Netzwerk-Magie im Standardpaket net. Es bietet eine einheitliche Schnittstelle für TCP, UDP, Unix-Sockets und sogar SSL/TLS. Die Hauptstärke: Die Funktionen Listen, Dial und Accept arbeiten synchron, blockieren aber nicht das gesamte Programm, da jede Goroutine leichtgewichtig ist.

Lass uns direkt loslegen.

TCP-Server: Ein Chat in 10 Zeilen

Wir erstellen einen einfachen Echo-Server, der Verbindungen annimmt und die empfangenen Daten zurücksendet. Das ist der Klassiker der Go-Netzwerkprogrammierung.

package main\n\nimport (\n    "bufio"\n    "fmt"\n    "net"\n)\n\nfunc handleConnection(conn net.Conn) {\n    defer conn.Close()\n    scanner := bufio.NewScanner(conn)\n    for scanner.Scan() {\n        message := scanner.Text()\n        fmt.Printf("Empfangen: %s\\n", message)\n        conn.Write([]byte("Echo: " + message + "\\n"))\n    }\n}\n\nfunc main() {\n    listener, _ := net.Listen("tcp", ":8080")\n    fmt.Println("TCP-Server gestartet auf :8080")\n    for {\n        conn, _ := listener.Accept()\n        go handleConnection(conn) // jede Goroutine ist ein eigener Client\n    }\n}

Was passiert hier?

\n
• net.Listen("tcp", ":8080") erstellt einen TCP-Listener auf Port 8080.
\n
• Eine Endlosschleife for nimmt neue Verbindungen über Accept() an.
\n
• Jede Verbindung wird in einer eigenen Goroutine go handleConnection() verarbeitet.
\n
• Innerhalb der Funktion lesen wir Zeilen mit bufio.Scanner und senden eine Antwort.
\n

Starte diesen Code, öffne ein Terminal und verbinde dich mit nc localhost 8080 (oder Telnet). Jede Nachricht wird mit dem Präfix "Echo:" zurückgegeben. Erstaunlicherweise ist das bereits ein vollwertiger Netzwerkserver, der Tausende von Clients ohne einen einzigen Callback bedienen kann.

UDP: Schnelle Zustellung ohne Garantien

Wenn TCP wie ein Telefonat ist (Verbindung aufgebaut – wir kommunizieren), dann ist UDP wie eine Postkarte: abgeschickt und vergessen. Go macht die Arbeit mit UDP genauso einfach.

UDP-Client und Server

// Server\npackage main\n\nimport (\n    "fmt"\n    "net"\n)\n\nfunc main() {\n    addr, _ := net.ResolveUDPAddr("udp", ":8081")\n    conn, _ := net.ListenUDP("udp", addr)\n    defer conn.Close()\n\n    buffer := make([]byte, 1024)\n    for {\n        n, clientAddr, _ := conn.ReadFromUDP(buffer)\n        message := string(buffer[:n])\n        fmt.Printf("Empfangen von %s: %s\\n", clientAddr, message)\n        conn.WriteToUDP([]byte("Erhalten: "+message+"\\n"), clientAddr)\n    }\n}\n\n// Client\n// In einer separaten Datei oder Goroutine:\nconn, _ := net.Dial("udp", "localhost:8081")\ndefer conn.Close()\nconn.Write([]byte("Hallo, UDP!"))\nbuffer := make([]byte, 1024)\nn, _ := conn.Read(buffer)\nfmt.Println(string(buffer[:n]))

Der Hauptunterschied zu TCP:

\n
• Es gibt kein Accept() – wir hören einfach auf einen Port und lesen Datagramme.
\n
• Jedes Paket kommt mit seiner eigenen Absenderadresse.
\n
• Go verwaltet die Pufferung automatisch: ReadFromUDP liefert die Daten und die Adresse des Absenders.
\n