Creación de un Servidor Web Concurrente con Go

¿Cómo crear un servidor web con Workers y Dispatcher en Go?

Crear un servidor web no es simplemente desarrollar una interfaz que acepte solicitudes. En este curso, construimos un servidor web utilizando Go, enfocándonos en manejar tareas complejas de manera concurrente a través de la implementación de workers y dispatcher. Aprenderemos cómo crear estas funciones, encolar trabajos, y validar métodos de solicitud eficazmente.

¿Cómo iniciamos el servidor web?

Antes de iniciar el servidor, es fundamental definir las estructuras necesarias. Una vez hecho esto, creamos la función run para nuestro dispatcher. Esta función itera a través de la cantidad máxima de workers establecidos, creando e inicializando cada uno de ellos.

func (d *Dispatcher) Run() {
    for i := 0; i < d.MaxWorkers; i++ {
        worker := NewWorker(i, d.WorkerPool)
        worker.Start()
    }

    // Dispatch like a Goroutine
    go d.dispatch()
}

Dentro de la función main, establecemos los valores necesarios, como el número máximo de trabajadores, la cantidad máxima de trabajos y el puerto del servidor:

const (
    MaxWorkers = 4
    MaxQueue   = 20
    Port       = ":8081"
)

func main() {
    jobQueue := make(chan Job, MaxQueue)
    dispatcher := NewDispatcher(MaxWorkers, jobQueue)
    dispatcher.Run()
}

¿Cómo manejar solicitudes HTTP?

La función RequestHandler es crucial para procesar las solicitudes entrantes, validando que el método sea POST y extrayendo los valores necesarios para crear un trabajo:

func RequestHandler(w http.ResponseWriter, r *http.Request, jobQueue chan Job) {
    if r.Method != "POST" {
        w.WriteHeader(http.StatusMethodNotAllowed)
        return
    }

    // Parse values from request
    delay, err := time.ParseDuration(r.FormValue("delay"))
    if err != nil {
        http.Error(w, "Invalid delay", http.StatusBadRequest)
        return
    }
    
    value, err := strconv.Atoi(r.FormValue("value"))
    if err != nil {
        http.Error(w, "Invalid value", http.StatusBadRequest)
        return
    }

    name := r.FormValue("name")
    if name == "" {
        http.Error(w, "Invalid name", http.StatusBadRequest)
        return
    }

    // Create and enqueue job
    job := Job{Name: name, Delay: delay, Number: value}
    jobQueue <- job
    w.WriteHeader(http.StatusCreated)
}

¿Cómo configurar las rutas de nuestro servidor?

Mediante http.HandleFunc, definimos la ruta que nuestro servidor manejará, asociando la función correspondiente que procesará las solicitudes:

http.HandleFunc("/fib", func(w http.ResponseWriter, r *http.Request) {
    RequestHandler(w, r, jobQueue)
})

Finalmente, lanzamos nuestro servidor:

log.Fatal(http.ListenAndServe(Port, nil))

¿Cómo validar la implementación?

Para probar la validez de nuestro servidor web con workers en Go, es recomendable utilizar herramientas como Postman. Esto nos permite enviar solicitudes HTTP tipo POST con los valores esenciales: name, value y delay. Al hacer esto, verificas si el servidor maneja correctamente las solicitudes y realiza tareas concurrentes eficientemente.

Prueba diferentes configuraciones de workers y job queue utilizando el código de ejemplo que provee el instructor, y observa cómo se desempeña tu aplicación al recibir múltiples solicitudes al mismo tiempo. Esto te ayudará no solo a profundizar en el manejo de concurrencia, sino también a optimizar tus soluciones para futuras implementaciones.

Continúa tu aprendizaje explorando estos mecanismos y saca el máximo provecho de las capacidades de Go. ¡No te detengas aquí, sigue creciendo en esta emocionante área de la programación!