Lua Academy · Les

Een server bouwen

Accepteer binnenkomende verbindingen.

Les 3 van 413 stappen

Een server bouwen is een gratis Lua Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Lua Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Lua Academy bevat in totaal 4 lessen.

Levenscyclus van een server

Een TCP-server koppelt zich aan een adres, luistert naar verbindingen en accepteert en bedient daarna clients in een lus.

In LuaSocket maak je met socket.tcp() een hoofdobject, maak je daarvan een luisterende server met bind/listen en haal je clients uit de wachtrij met accept.

local socket = require("socket")
local server = assert(socket.tcp())

Aan een poort koppelen

server:bind(host, port) reserveert een lokaal adres. Gebruik "*" of "0.0.0.0" om verbindingen op elke interface te accepteren, of "127.0.0.1" om alleen lokale verbindingen toe te staan.

Bind mislukt met "address already in use" als een ander proces de poort gebruikt.

server:setoption("reuseaddr", true)
local ok, err = server:bind("*", 8080)
if not ok then error("bind failed: " .. err) end

Naar clients luisteren

server:listen(backlog) maakt de socket passief en begint binnenkomende handshakes in een wachtrij te plaatsen. De achterstand is het maximale aantal verbindingen dat kan wachten.

De verkorte vorm socket.bind(host, port, backlog) voert binden en luisteren in één aanroep uit en retourneert een gereed serverobject.

local socket = require("socket")
local server = assert(socket.bind("*", 8080, 32))
print("listening on", server:getsockname())

Een verbinding accepteren

server:accept() blokkeert totdat een client verbinding maakt en retourneert daarna een geheel nieuw TCP-clientobject voor die tegenpartij. De serversocket zelf blijft luisteren.

Op een serversocket met een time-out retourneert accept nil, "timeout", zodat je andere werkzaamheden tussendoor kunt uitvoeren.

local client, err = server:accept()
if client then
  print("client from", client:getpeername())
end

Eén client bedienen

Behandel het geretourneerde object na accept precies als een clientsocket: gebruik receive voor verzoeken en send voor antwoorden.

Geef de socket van elke client een eigen time-out, zodat één trage client de hele server niet kan blokkeren.

client:settimeout(10)
local line = client:receive("*l")
if line then client:send(line .. "\n") end
client:close()

De accept-lus

Een klassieke iteratieve server werkt oneindig door: accepteer een client, bedien die, sluit de verbinding en herhaal. Dit verwerkt één client tegelijk.

Dit is eenvoudig en correct, maar kan geen gelijktijdige clients bedienen, omdat een traag verzoek iedereen erachter blokkeert.

while true do
  local c = server:accept()
  if c then
    local msg = c:receive("*l")
    if msg then c:send(msg .. "\r\n") end
    c:close()
  end
end

Een minimale echo-server

Alles samengevoegd: een echo-server koppelt zich aan een adres, luistert en stuurt vervolgens in een lus de eerste regel van elke client terug.

Dit is de kleinste complete LuaSocket-server en een nuttig doel voor de client die je eerder hebt gebouwd.

local socket = require("socket")
local s = assert(socket.bind("*", 8080))
while true do
  local c = s:accept()
  c:send((c:receive("*l") or "") .. "\r\n")
  c:close()
end

Gelijktijdigheid met select

Gebruik socket.select om veel clients tegelijk te bedienen zonder threads. Het retourneert de sockets die gereed zijn om te lezen, waaronder de luisterende server wanneer er een nieuwe client wacht.

Je beheert een tabel met actieve clients en verwerkt alleen de clients die gegevens hebben. Zo blijft een gebeurtenislus met één thread responsief.

local readable = socket.select(watch, nil, 1)
for _, sock in ipairs(readable) do
  if sock == server then
    table.insert(watch, server:accept())
  end
end

Niet-blokkerende verbindingen accepteren

Stel server:settimeout(0) in, zodat accept nooit blokkeert. Combineer dit met select, zodat je accept alleen aanroept wanneer de luistersocket daadwerkelijk leesbaar is.

Dit vormt de basis voor een schaalbare server in één proces die honderden verbindingen multiplexeert.

server:settimeout(0)
local ready = socket.select({server}, nil, 5)
if #ready > 0 then
  local c = server:accept()
end

Clientfouten afhandelen

Clients kunnen abrupt de verbinding verbreken. Wanneer receive nil, "closed" of een gedeeltelijke buffer retourneert, verwijder je die client uit je bewaaktabel en sluit je diens socket.

Laat één defecte verbinding nooit de accept-lus uitschakelen; isoleer de fouten van elke client.

local data, err = client:receive("*l")
if err == "closed" then
  client:close()
  remove_from_watch(client)
end

Netjes afsluiten

Stop bij het afsluiten met accepteren, sluit elke actieve clientsocket en sluit daarna de luisterende server om de poort vrij te geven.

Als je tijdens het binden reuseaddr instelt, kun je onmiddellijk opnieuw starten zonder de TCP-periode TIME_WAIT af te wachten.

for _, c in ipairs(clients) do c:close() end
server:close()
print("server stopped")

Snelle controle

Kies de aanroepvolgorde die van een nieuwe hoofdsocket een werkende luistersocket maakt.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt een TCP-server gebouwd: binden met reuseaddr, luisteren met een wachtrijlimiet en in een lus accept gebruiken om clients te bedienen.

Je hebt de eenvoudige iteratieve lus gezien en die vervolgens opgeschaald met socket.select voor niet-blokkerende gelijktijdigheid, plus foutisolatie en netjes afsluiten. Vervolgens ga je verder met HTTP.

Gratis beginnen

Leer Lua met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 40
Lessen: 159

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Een server bouwen” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Een server bouwen”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Lua Academy bevat in totaal 4 lessen.

Wat leer ik in “Een server bouwen”?

Accepteer binnenkomende verbindingen. Je oefent met Lua Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Lua Academy te beginnen?

Ervaring vooraf is niet nodig. Lua Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Een server bouwen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Lua Academy?

Ja. Elke les over Lua Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Lua Academy