Creación de un Servidor Web Concurrente con Go

Curso de Go Intermedio: Programación Orientada a Objetos y Concurrencia

Contenido del curso

Introducción

Programación orientada a objetos

Go Modules

Testing

Concurrencia

Proyecto: servidor con worker pools

Conclusión

30
Resumen del Curso Avanzado de Go: Módulos, Tests y Concurrencia
02:34 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0015:21

Creación de un Servidor Web Concurrente con Go

Curso de Go Intermedio: Programación Orientada a Objetos y Concurrencia

Clase 29 de 30

Clase 29 / 30

Recursos

¿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!

AGEO ANDRÉS FUENTES MERIÑO

Hace un año•editado

Si queremos enviar varios Jobs podría ser de esta forma, lo digo porque no encontré el código que dejó el tutor, no sé si dejó algún procedimiento en postman o desde código pero yo elaboré uno.

Agregué dos structs:

Un para recibir cada Job:

type JobJson struct {
	Name   string `json:"name"`
	Delay  string `json:"delay"`
	Number int    `json:"number"`
}

Un struct para contener un listado de este objeto:

type JobJsonList struct {
	Jobs []JobJson `json:"jobs"`
}

Y una modificación a la función RequestHandler:

func RequestHandler(w http.ResponseWriter, r *http.Request, jobQueue chan Job) {
	if r.Method != "POST" { //GET, PUT, DELETE, PATCH
		w.Header().Set("Allow", "POST")
		w.WriteHeader(http.StatusMethodNotAllowed)
	}
  var data JobJsonList

	err := json.NewDecoder(r.Body).Decode(&data)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	// Proceso para recibir la DATA
	fmt.Printf("Received %d items:\n", len(data.Jobs))
	for _, item := range data.Jobs {
		delay, err := time.ParseDuration(item.Delay)
		if err != nil {
			http.Error(w, "Invalid Delay", http.StatusBadRequest)
			return
		}
		fmt.Printf("  Number: %d, Name: %s, Delay: %s\n", item.Number, item.Name, item.Delay)
		job := Job{Name: item.Name, Delay: delay, Number: item.Number}
		jobQueue <- job
	}
	w.WriteHeader(http.StatusAccepted)
}

La petición POST cambiaría y ya no se enviarían RequestParams sino que se envía un body

{
  "jobs": [
    {
      "name": "Fib24",
      "delay": "2s",
      "number": 24
    },
    {
      "name": "Fib25",
      "delay": "2s",
      "number": 25
    },
    {
      "name": "Fib26",
      "delay": "2s",
      "number": 26
    }
  ]
}

No es la mejor manera pero fue la que con un poco de investigación y adaptación se me facilitó.

Y esa fue la salida que se obtuvo:

Worker con ID 1 Started

Worker con ID 0 Started

Worker con ID 2 Started

Worker with ID 2 Finished with result 121393

Worker with ID 0 Finished with result 75025

Worker with ID 1 Finished with result 46368

Así tenemos la posibilidad de añadir más Jobs para que los 4 Workers disponibles operen a su máxima capacidad. -------------- Otra petición:

{
  "jobs": [
    {
      "name": "Fib24",
      "delay": "2s",
      "number": 24
    },
    {
      "name": "Fib25",
      "delay": "2s",
      "number": 25
    },
    {
      "name": "Fib26",
      "delay": "2s",
      "number": 26
    },
    {
      "name": "Fib27",
      "delay": "2s",
      "number": 27
    },
    {
      "name": "Fib28",
      "delay": "2s",
      "number": 28
    },
    {
      "name": "Fib5",
      "delay": "1s",
      "number": 5
    },
    {
      "name": "Fib6",
      "delay": "1s",
      "number": 6
    },
    {
      "name": "Fib7",
      "delay": "1s",
      "number": 7
    },
    {
      "name": "Fib8",
      "delay": "1s",
      "number": 8
    },
    {
      "name": "Fib9",
      "delay": "1s",
      "number": 9
    },
    {
      "name": "Fib10",
      "delay": "1s",
      "number": 10
    }
  ]
}

Salida:

Number: 10, Name: Fib10, Delay: 1s

Worker with ID 2 Finished with result 75025

Worker con ID 2 Started

Worker with ID 1 Finished with result 196418

Worker con ID 1 Started

Worker with ID 3 Finished with result 46368

Worker con ID 3 Started

Worker with ID 0 Finished with result 121393

Worker con ID 0 Started

Worker with ID 3 Finished with result 8

Worker con ID 3 Started

Worker with ID 0 Finished with result 13

Worker con ID 0 Started

Worker with ID 1 Finished with result 5

Worker con ID 1 Started

Worker with ID 0 Finished with result 34

Worker with ID 3 Finished with result 21

Worker with ID 1 Finished with result 55

Worker with ID 2 Finished with result 317811

Comentarios (20)20 comentarios

Carlos Nassif Trejo Garcia

Hace 5 años

Francisco Prado

Hace 3 años

Dario Roman

Carlos Nexans

Hace 4 años

Matias Sidler

Aaron Contreras Garibay

Andres Camilo Bobadilla Parra

Facundo Yuffrida

Carlos Perez

Victor Baruch Pazaran Jaimes

Emilian Harastasan

Juan Carlos Mendoza Rodríguez

Walter Alvarado

Hace 2 años

Teresa Plaz

Henrry Bourgeot

Tomas Alegria Caceres

Tan Zuñiga

Oscar Giraldo Castillo

Hace 9 meses

Víctor Hugo Suárez Quiroz

Enrique Uzcategui

Daniel Alejandro Serrano Ricaurte

Introducción

Programación Orientada a Objetos y Concurrencia en Go

Concurrencia y Testing en Go: Go Routinas y Worker Pools

Fundamentos de Programación en Go: Structs, Apuntadores y Manejo de Errores

Go Routines, Canales y Apuntadores en Golang

Programación orientada a objetos

Programación Orientada a Objetos en Go: Análisis y Comparativa

Equivalente de Clases en Go: Uso de Structs y Propiedades

Métodos en Structs: Implementación de Receiver Functions en Go

Implementación de Constructores en Go: Ejemplos y Mejores Prácticas

Herencia y Composición en Programación Orientada a Objetos

Interfaces y Polimorfismo en TypeScript y Go

Patrón Abstract Factory: Interfaces y Polimorfismo en Go

Implementación del Patrón Factory en Go para Notificaciones

Funciones Anónimas en Go: Uso y Consideraciones Prácticas

Funciones Variádicas y Retornos con Nombre en Go

Go Modules

Manejo de Dependencias y Módulos en Go

Creación y Publicación de Módulos en GitHub con Go

Testing

Tests unitarios y code coverage en Go

Cobertura de Código y Testing en Go: Mejorando la Calidad del Software

Profiling de Código en Go para Optimización de Rendimiento

Testing Unitario en Go: Uso de Mock Services

Testeo Unitario de Funciones con MOOC en Go

Concurrencia

Canales con y sin buffer en Go: diferencias y uso práctico

Sincronización de Rutinas en Go con Wait Group

"Uso de Canales con Buffer como Semáforos en Go"

Manejo de Canales de Lectura y Escritura en Go

Concurrencia en Go: Creación de Worker Pools y Fibonacci

Multiplexación de Canales en Go con Select y Case

Proyecto: servidor con worker pools

Creación de un Web Server con Worker Pool en Go

Creación de un Servidor Web Concurrente con Go

Conclusión

Resumen del Curso Avanzado de Go: Módulos, Tests y Concurrencia

Creación de un Servidor Web Concurrente con Go