Creación de un Web Server con Worker Pool en 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:0013:36

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

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

Clase 28 de 30

Clase 28 / 30

Recursos

¿Cómo crear un servidor web para gestionar trabajos con Go?

Crear un servidor web que gestione trabajos utilizando Go puede ser un proyecto fascinante y muy educativo. Este análisis te guiará paso a paso para generar un "worker pool" que te permita procesar trabajos en paralelo de manera eficiente. Aquí exploraremos cómo estructurar el código y los conceptos clave detrás de esta implementación.

¿Cuál es la estructura principal de nuestro proyecto?

El punto de partida es crear una carpeta para el proyecto, dentro de la cual vamos a definir un archivo principal llamado main.go. El primer paso es definir el paquete principal y comenzar a diseñar los structs fundamentales para nuestro proyecto.

package main

import (
    "time"
)

// Definición del struct Job
type Job struct {
    Name  string
    Delay time.Duration
    Number int
}

// Definición del struct Worker
type Worker struct {
    ID          int
    JobQueue    chan Job
    WorkerPool  chan chan Job
    QuitChan    chan bool
}

// Definición del struct Dispatcher
type Dispatcher struct {
    WorkerPool  chan chan Job
    MaxWorkers  int
    JobQueue    chan Job
}

Aquí hemos definido tres componentes principales: Job, que representa el trabajo a procesar; Worker, que ejecuta los trabajos; y Dispatcher, que se encarga de distribuir los trabajos entre los workers disponibles.

¿Cómo implementar constructores para workers y dispatchers?

Para poner en práctica los patrones de diseño recomendados en Go, es útil implementar constructores que inicialicen nuestros structs.

func NewWorker(id int, workerPool chan chan Job) Worker {
    return Worker{
        ID:         id,
        JobQueue:   make(chan Job),
        WorkerPool: workerPool,
        QuitChan:   make(chan bool),
    }
}

func NewDispatcher(maxWorkers int, jobQueue chan Job) *Dispatcher {
    workerPool := make(chan chan Job, maxWorkers)
    return &Dispatcher{
        WorkerPool: workerPool,
        MaxWorkers: maxWorkers,
        JobQueue:   jobQueue,
    }
}

Utilizar constructores tiene ventajas significativas, como asegurarnos de que todas las propiedades estén correctamente inicializadas.

¿Cómo funcionan los workers y el proceso de dispatch?

Los workers son el núcleo del procesamiento paralelo. Implementaremos métodos para que continuamente escuchen trabajos y los procesen adecuadamente.

func (w Worker) Start() {
    go func() {
        for {
            w.WorkerPool <- w.JobQueue
            select {
            case job := <-w.JobQueue:
                result := fibonacci(job.Number)
                time.Sleep(job.Delay)
                fmt.Printf("Worker %d ha finalizado con resultado %d\n", w.ID, result)
            case <-w.QuitChan:
                fmt.Printf("Worker %d ha sido detenido\n", w.ID)
                return
            }
        }
    }()
}

func (w Worker) Stop() {
    go func() {
        w.QuitChan <- true
    }()
}

Implementamos tanto la ejecución indefinida de los workers como el mecanismo para detenerlos. En cuanto al dispatcher, su objetivo es asignar trabajos a los workers:

func (d *Dispatcher) Dispatch() {
    go func() {
        for {
            select {
            case job := <-d.JobQueue:
                go func(job Job) {
                    workerJobQueue := <-d.WorkerPool
                    workerJobQueue <- job
                }(job)
            }
        }
    }()
}

¿Cómo ejecutar la serie Fibonacci de forma eficiente?

Para el cálculo de la serie de Fibonacci, utilizamos recursión, un método que ya fue analizado previamente y es ampliamente conocido por su elegancia y simplicidad.

func fibonacci(n int) int {
    if n <= 1 {
        return n
    }
    return fibonacci(n-1) + fibonacci(n-2)
}

¿Qué sigue después de estructurar y programar workers y dispatcher?

Hasta este punto, hemos construido los cimientos de nuestro servidor web en Go. En futuras implementaciones, la integración de una interfaz web para enviar trabajos al dispatcher ampliará las capacidades de este proyecto, permitiendo que múltiples usuarios interactúen y aprovechen este sistema eficiente. No dudes en explorar más allá de lo aprendido aquí y aprovecha la oportunidad de ampliar tu comprensión sobre goroutines, canales y la programación concurrente en Go. ¡Buena suerte y sigue aprendiendo!

Cristian Francisco Meoño Canel

Hace 4 años

Un pequeño resumen de lo que pude entender, espero los ayude

El dispatcher recibe todos los jobs, se puede decir que es como el componente global
Cada worker tiene su canal de jobs, y saben cual es el canal del disptacher, es decir el workerpool es el mismo canal para todos los workers.
Cada worker esta enviando su canal al canal del dispatcher
En la medida que el dispatcher recibe jobs este los va repartiendo entre los workers a través de sus canales

package project

import (
	"fmt"
	"time"
)

// Estructura de la tareas de procesar
type Job struct {
	Name   string        //Nombre de la tarea
	Delay  time.Duration //Tiempo de espera
	Number int           // Numero a procesar
}

type Worker struct {
	Id         int           // id del Worker
	JobQueue   chan Job      // Canal de tareas del worker
	WorkerPool chan chan Job //Canal de canales de tareas, este canal se comparte entre todos los workers
	QuitChan   chan bool     //Canal para parar al worker
}

type Dispatcher struct {
	WorkerPool chan chan Job //Canal de canales de tareas, este se les pasa a cada worker nuevo
	MaxWorkers int           //cantidad maxima de workers
	JobQueue   chan Job      //Canal de tareas, se puede ver como un canal global de tareas que despues se reparten entre workers
}

func NewWorker(id int, workerPool chan chan Job) *Worker {
	return &Worker{
		Id:         id,              //Se asigna un id
		WorkerPool: workerPool,      //Se le indica el canal donde tiene quie agregar su canal de tareas
		JobQueue:   make(chan Job),  //Canal de tareas del worker
		QuitChan:   make(chan bool), //Canal para parar al worker
	}
}

func (w Worker) Start() {

	//Se inicia de manera concurrente un ciclo sin fin
	go func() {
		for {

			//Al worker pool se manda el canal de worker, este se manda cada vez iteracion, es decir cuando el worker termino de hacer un jobs
			w.WorkerPool <- w.JobQueue

			//Se multiplexean los canales del worker
			select {
			case job := <-w.JobQueue:
				//Si se recibe un job en el canal de tareas del worker se ejecuta
				fmt.Printf("Worker with id %d Started\n", w.Id)
				fib := Fibonacci(job.Number)
				time.Sleep(job.Delay)
				fmt.Printf("Worker with id %d Finishes with result %d\n", w.Id, fib)

			case <-w.QuitChan:
				//Si se recibe un job en el canal de salida se para el worker (lo sca del ciclo)
				fmt.Printf("Worker with id %d Stopped\n", w.Id)
				return
			}

		}
	}()
}

//La funcion stop manda un true al canl de salida del worker
func (w Worker) Stop() {
	go func() {
		w.QuitChan <- true
	}()
}

//El dispatcher cuenta con el el canal global de jobs y un canal de todos los canales de los workers

func NewDispatcher(jobQueue chan Job, maxWorkers int) *Dispatcher {

	worker := make(chan chan Job, maxWorkers)
	return &Dispatcher{
		JobQueue:   jobQueue,
		MaxWorkers: maxWorkers,
		WorkerPool: worker,
	}
}

func (d *Dispatcher) Dispatch() {

	//Inicia de manera indefinidad a mandar jobs a los canales que se van recibiendo en el canal de caneles de jobs
	for {
		select {
		case job := <-d.JobQueue:
			go func() {
				workerJobQueue := <-d.WorkerPool
				workerJobQueue <- job
			}()
		}
	}
}

func Fibonacci(n int) int {
	if n <= 1 {
		return n
	}

	return Fibonacci(n-1) + Fibonacci(n-2)
}

Hugo René Pereira Monzon

Hace 3 años

Gracias totales 🙌🏼

Julian Torres

Hace 3 años

Gracias

Comentarios (25)25 comentarios

Carlos Nassif Trejo Garcia

Hace 5 años

Angelo Monasterios

Facundo Yuffrida

PAMELA RAMIREZ

Allan Fuentes

Jorge Miguel Anaya León

Benjamin Ortiz Gomez

Olmedo Jesús Jácome Baque

Jaime David Burbano Montoya

Hernando Alvarado

Leonardo Aranguren

Fabio Alvarez

Hace 3 meses

Eber Laurente Lliuyacc

Gerson Daniel Gutierrez Acosta

Carlos Daniel Bonilla Ramirez

José Fabián Beltrán Meza

Hace 2 años

Daniel Barros Garces

Jose Leon Faneite

Raúl Hernán Jr Cuéllar Morales

Leonardo Valdivieso

Solbeauty AndCare

Jose Miguel Valero Reyes

Hace un año

Thomas David Zuluaga Flórez

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 Web Server con Worker Pool en Go