El día de hoy te enseñaré a detener un servidor web creado con Go desde el propio programa. Dicho de otra manera, el servidor se va a detener a sí mismo.

Para estoy hay varios enfoques pero te enseñaré 2 que yo considero son muy fáciles y no involucran canales o rutinas (go routines).

Detener servidor de Go con Shutdown

La forma correcta de terminar el programa de Go cuando se ejecuta un servidor http es invocando a Shutdown del propio servidor. Normalmente el servidor es creado con el siguiente código:

var servidor *http.Server

O con el siguiente:

servidor = &http.Server{
  Handler: enrutador,
  Addr:    direccion,
  // Timeouts para evitar que el servidor se quede "colgado" por siempre
  WriteTimeout: 15 * time.Second,
  ReadTimeout:  15 * time.Second,
 }

Cuando nosotros necesitemos detener el servidor, invocamos a servidor.Shutdown y le pasamos el contexto context.Background() (context viene del paquete context).

Por ejemplo aquí algo simple donde el servidor se apaga desde una ruta creada con Gorilla mux:

 var servidor *http.Server
 enrutador := mux.NewRouter()
 configurarRutas(enrutador)
 enrutador.HandleFunc("/apagar", func(w http.ResponseWriter, r *http.Request) {
  servidor.Shutdown(context.Background())
 }).Methods("GET").Name(RutaApagarServidor)
 enrutador.Use(middlewareCors)
 // Preparar y encender servidor
 direccion := ":8484"

 servidor = &http.Server{
  Handler: enrutador,
  Addr:    direccion,
  // Timeouts para evitar que el servidor se quede "colgado" por siempre
  WriteTimeout: 15 * time.Second,
  ReadTimeout:  15 * time.Second,
 }

Cuando se invoque a la ruta “apagar” el servidor se va a apagar. Esto, me parece, es la manera correcta y amable de apagar el servidor desde una ruta http y funciona bien, pero en mi caso cuando agrego algunos middlewares me da algunos errores así que probé con otra solución.

Yo recomiendo que uses la solución provista anteriormente, pero si no funciona sigue leyendo.

Terminar el proceso con taskkill

Otra manera un poco rara pero que funciona es… obtener el ID de proceso (pid) y pedirle al sistema operativo que termine el proceso por nosotros. Yo lo he hecho con Windows y funciona perfectamente; solo sería cuestión de adaptarlo a otros sistemas operativos.

Sé que este método es poco ortodoxo pero funciona y es muy simple (incluso me siento sucio por usarlo). El código queda así:

enrutador.HandleFunc("/apagar", func(w http.ResponseWriter, r *http.Request) {
 pid := os.Getpid()
 cmd := exec.Command("taskkill", "/F", "/PID", fmt.Sprintf("%d", pid))
 err := cmd.Run()
 if err != nil{
  log.Printf("Error matando proceso: %v", err)
 }
}).Methods(http.MethodGet)

Obtenemos el PID con os.Getpid, luego invocamos a taskkill en Windows y le pasamos el PID. El comando se va a ejecutar al invocar con cmd.Run. Y así es como se va a terminar todo nuestro programa.

Entiendo que tal vez todo tu programa no dependa solo del servidor, y para esos casos puede que quieras ver la primera solución. Otras soluciones más complejas las he visto en: https://stackoverflow.com/questions/47448666/shutting-down-http-server-after-returning-response