file upload - ¿Cómo limitaría la velocidad de carga y descarga desde el servidor en golang?

file-upload download

Question

¿Cómo limitaría la velocidad de carga y descarga desde el servidor en golang?

Estoy escribiendo un servidor de golang para permitir a los usuarios cargar y descargar archivos. Y el archivo es grande, alrededor de 1GB de bytes. Quiero limitar la velocidad de carga y descarga a (por ejemplo) 1 MB / s (configurable por supuesto).

a continuación está mi código de carga:

func uploadFile(w http.ResponseWriter, r *http.Request) {
file, _, err := r.FormFile("file")
if err != nil {
http.Error(w, err.Error(), 500)
return
}
defer file.Close()
os.MkdirAll(`e:/test`, os.ModePerm)
out, err := os.Create(`e:/test/test.mpg`)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
defer out.Close()
_, err = io.Copy(out, file)
if err != nil {
http.Error(w, err.Error(), 500)
}
}

Answer 1

Hay un algoritmo de depósito de fichas que puede ser útil para implementar dicho límite de velocidad. Encontré una implementación de ejemplo, que puede usar: https://github.com/juju/ratelimit

package main
import (
"bytes"
"fmt"
"io"
"time"
"github.com/juju/ratelimit"
)
func main() {
// Source holding 1MB
src := bytes.NewReader(make([]byte, 1024*1024))
// Destination
dst := &bytes.Buffer{}
// Bucket adding 100KB every second, holding max 100KB
bucket := ratelimit.NewBucketWithRate(100*1024, 100*1024)
start := time.Now()
// Copy source to destination, but wrap our reader with rate limited one
io.Copy(dst, ratelimit.Reader(src, bucket))
fmt.Printf("Copied %d bytes in %s/n", dst.Len(), time.Since(start))
}

Después de ejecutarlo, la salida es:

Copied 1048576 bytes in 9.239607694s

Puede usar diferentes implementaciones de segmento para proporcionar el comportamiento deseado. En su código, después de configurar el depósito de token derecho, debe llamar a:

_, err = io.Copy(out, ratelimit.Reader(file, bucket))

Answer 2

Puede consultar la implementación de PuerkitoBio/throttled , presentado en este artículo :

throttled , un paquete Go que implementa diversas estrategias para controlar el acceso a los manejadores HTTP.
Desde el primer momento, admite la limitación de velocidad de las solicitudes , el flujo de solicitudes a intervalos constantes y los umbrales de uso de memoria para otorgar o denegar el acceso, pero también proporciona mecanismos para ampliar su funcionalidad.

El límite de velocidad no es exactamente lo que necesita, pero puede dar una buena idea para implementar una función similar .