Go Academy · Lezione

golang.org/x/time/rate

Usare il limitatore di frequenza

golang.org/x/time/rate è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 2 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 Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

Il package rate

golang.org/x/time/rate fornisce un Limiter token bucket pronto per l'uso in produzione. È la scelta standard per la limitazione della frequenza in Go.

Implementazione collaudata sul campo
Metodi Allow, Wait e Reserve
Compatibile con i context

Creare un Limiter

rate.NewLimiter accetta un rate (token al secondo) e una dimensione del burst. rate.Limit è un float64 che rappresenta gli eventi al secondo.

limiter := rate.NewLimiter(rate.Limit(10), 5)

rate.Every

Se ragiona in termini di intervalli invece che di rate al secondo, rate.Every converte una durata in un rate. Un evento ogni 200 ms equivale a cinque eventi al secondo.

limiter := rate.NewLimiter(rate.Every(200*time.Millisecond), 1)

Allow

Allow indica se in questo momento è disponibile un token. Restituisce true e consuma un token oppure restituisce immediatamente false. Lo utilizzi per rifiutare le richieste in eccesso.

if !limiter.Allow() {
    fmt.Println("rejected: too many requests")
    return
}

Wait

Wait si blocca finché non è disponibile un token oppure il context viene annullato. È ideale quando si desidera distribuire il lavoro nel tempo invece di scartarlo.

if err := limiter.Wait(ctx); err != nil {
    return err
}
doWork()

Reserve

Reserve restituisce una Reservation che indica quanto tempo bisogna attendere. Chiami Delay() per conoscere l'attesa e Cancel() se decide di non procedere.

r := limiter.Reserve()
if !r.OK() {
    return
}
time.Sleep(r.Delay())

Nota: package esterno

Il package rate non fa parte della libreria standard, quindi richiede go get golang.org/x/time/rate e un modulo. Gli snippet che lo importano sono illustrativi e qui non vengono eseguiti inline.

Un analogo eseguibile con la libreria standard

Poiché il package rate è esterno, ecco un ciclo di distribuzione temporale basato sulla libreria standard che imita Wait eseguendo un tick ogni 200 ms.

package main

import (
    "fmt"
    "time"
)

func main() {
    tick := time.NewTicker(200 * time.Millisecond)
    defer tick.Stop()
    for i := 0; i < 4; i++ {
        <-tick.C
        fmt.Println("processed event", i)
    }
}

Regolare i limiti a runtime

È possibile modificare i limiti al volo con SetLimit e SetBurst. È utile quando il ricaricamento della configurazione o una risposta 429 del servizio a monte indicano che è necessario rallentare.

limiter.SetLimit(rate.Limit(20))
limiter.SetBurst(10)

Limitatori per client

Mantenga una mappa dalla chiave del client a *rate.Limiter, protetta da un mutex. Crei un limitatore alla prima richiesta per quella chiave, quindi lo riutilizzi per le richieste successive.

func getLimiter(m map[string]*rate.Limiter, key string) *rate.Limiter {
    if l, ok := m[key]; ok {
        return l
    }
    l := rate.NewLimiter(rate.Limit(5), 10)
    m[key] = l
    return l
}

Middleware HTTP

Avvolga gli handler in modo che ogni richiesta chiami prima Allow(). Se restituisce false, risponda con HTTP 429 Too Many Requests. Questo è il modo standard di limitare la frequenza sul server.

Verifica rapida

Verifichi la Sua conoscenza del pacchetto rate.

Riepilogo

Ha imparato a usare golang.org/x/time/rate:

NewLimiter(rate, burst) crea il bucket
rate.Every converte un intervallo in una frequenza
Allow rifiuta, Wait regola il ritmo, Reserve restituisce il ritardo
SetLimit e SetBurst regolano i valori durante l'esecuzione
Mappa per client più HTTP 429 per i server

Domande Frequenti

La lezione «golang.org/x/time/rate» è gratuita?

Sì — il testo completo di «golang.org/x/time/rate» è 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 Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «golang.org/x/time/rate»?

Usare il limitatore di frequenza Eserciti Go 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 Go Academy?

Non è richiesta alcuna esperienza precedente. Go 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 2 di 4.

Quanto tempo richiede la lezione «golang.org/x/time/rate»?

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 Go Academy?

Sì. Ogni lezione Go 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 Go Academy