Lua Academy · Lezione

Costruire un server

Accetti connessioni in ingresso.

Lezione 3 di 413 passaggi

Costruire un server è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Ciclo di vita del server

Un server TCP associa un indirizzo, resta in ascolto delle connessioni e poi esegue un ciclo in cui accetta e gestisce i client.

In LuaSocket si crea un master con socket.tcp(), lo si trasforma in un server in ascolto con bind/listen e si prelevano i client dalla coda con accept.

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

Associare una porta

server:bind(host, port) riserva un indirizzo locale. Usi "*" o "0.0.0.0" per accettare connessioni su ogni interfaccia, oppure "127.0.0.1" per accettarle solo localmente.

Il bind fallisce con "address already in use" se un altro processo occupa la porta.

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

Restare in ascolto dei client

server:listen(backlog) rende il socket passivo e inizia ad accodare gli handshake in arrivo. Il backlog è il numero massimo di connessioni in attesa.

La scorciatoia socket.bind(host, port, backlog) esegue bind e listen con una sola chiamata e restituisce un oggetto server pronto.

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

Accettare una connessione

server:accept() blocca l'esecuzione finché un client non si connette, quindi restituisce un oggetto client TCP completamente nuovo per quel peer. Il socket server continua a restare in ascolto.

Su un socket server con timeout, accept restituisce nil, "timeout", consentendo di alternare altre attività.

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

Gestire un client

Dopo accept, tratti l'oggetto restituito esattamente come un socket client: riceva le richieste con receive e invii le risposte con send.

Assegni al socket del singolo client un timeout autonomo, così un client lento non può bloccare l'intero server.

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

Il ciclo di accept

Un server iterativo classico esegue un ciclo infinito: accetta un client, lo gestisce, lo chiude e ripete. In questo modo gestisce un client alla volta.

È semplice e corretto, ma non può gestire client simultanei, perché una richiesta lenta blocca tutti quelli successivi.

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

Un server echo minimale

Riunendo tutti gli elementi, un server echo esegue il bind, resta in ascolto e poi ripete la prima riga di ogni client.

Questo è il più piccolo server LuaSocket completo e un obiettivo utile per il client costruito in precedenza.

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

Concorrenza con select

Per gestire molti client contemporaneamente senza thread, usi socket.select. Restituisce i socket pronti per la lettura, incluso il server in ascolto quando è in attesa un nuovo client.

Gestisca una tabella dei client attivi ed elabori solo quelli che hanno dati, mantenendo reattivo un ciclo di eventi a thread singolo.

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

Accept non bloccante

Imposti server:settimeout(0) affinché accept non blocchi mai l'esecuzione. Lo abbini a select, in modo da chiamare accept solo quando il listener è effettivamente leggibile.

Questa è la base di un server scalabile a processo singolo, in grado di multiplexare centinaia di connessioni.

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

Gestire gli errori dei client

I client possono disconnettersi bruscamente. Quando receive restituisce nil, "closed" o un buffer parziale, rimuova il client dalla tabella di monitoraggio e chiuda il relativo socket.

Non permetta mai che una connessione danneggiata interrompa il ciclo di accept; isoli gli errori di ogni client.

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

Chiusura ordinata

Durante la chiusura, interrompa l'accettazione di nuove connessioni, chiuda ogni socket client attivo e infine chiuda il server in ascolto per liberare la porta.

Impostare reuseaddr al momento del bind consente di riavviare immediatamente il server senza attendere la scadenza del periodo TCP TIME_WAIT.

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

Verifica rapida

Scelga la sequenza di chiamate che trasforma un socket master appena creato in un listener funzionante.

Rispondi nella lezione interattiva

Riepilogo

Ha costruito un server TCP: eseguire il bind con reuseaddr, restare in ascolto con un backlog ed eseguire un ciclo su accept per gestire i client.

Ha visto il semplice ciclo iterativo, poi lo ha reso scalabile con socket.select per ottenere concorrenza non bloccante, oltre all'isolamento degli errori e alla chiusura ordinata. Ora passerà a un livello superiore, HTTP.

Gratis per iniziare

Impara Lua con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 40
Lezioni: 159

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Costruire un server» è gratuita?

Sì — il testo completo di «Costruire un server» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Costruire un server»?

Accetti connessioni in ingresso. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Costruire un server»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Lua Academy