{"id":30782,"date":"2019-10-31T21:37:25","date_gmt":"2019-10-31T18:37:25","guid":{"rendered":"https:\/\/prohoster.info\/blog\/razrabotka-veb-serverov-na-golang-ot-prostogo-k-slozhnomu\/"},"modified":"2019-10-31T21:37:25","modified_gmt":"2019-10-31T18:37:25","slug":"razrabotka-veb-serverov-na-golang-ot-prostogo-k-slozhnomu","status":"publish","type":"post","link":"https:\/\/prohoster.info\/es\/blog\/news\/razrabotka-veb-serverov-na-golang-ot-prostogo-k-slozhnomu","title":{"rendered":"Desarrollo de servidores web en Golang \u2014 de lo simple a lo complejo","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

\"Desarrollo
\n
\nHace cinco a\u00f1os comenc\u00e9 a desarrollar Gophish<\/a><\/noindex>, lo que me dio la oportunidad de aprender Golang. Me di cuenta de que Go es un lenguaje poderoso, cuyas capacidades se complementan con muchas bibliotecas. Go es vers\u00e1til: en particular, se pueden desarrollar f\u00e1cilmente aplicaciones del lado del servidor.<\/p>\n

Este art\u00edculo se dedica a escribir un servidor en Go. Comenzaremos con cosas simples, como \u00ab\u00a1Hola, mundo!\u00bb, y terminaremos con una aplicaci\u00f3n que tenga las siguientes capacidades:<\/p>\n

\u2014 Uso de Let's Encrypt para HTTPS.
\n\u2014 Funciona como enrutador API.
\n\u2014 Trabaja con middleware.
\n\u2014 Manejo de archivos est\u00e1ticos.
\n\u2014 Finalizaci\u00f3n adecuada.
\n<\/a><\/noindex><\/p>\n

Skillbox recomienda:<\/b> Curso pr\u00e1ctico \u00abDesarrollador de Python desde cero\u00bb<\/a><\/noindex>.<\/p>\n

Recordamos:<\/b> para todos los lectores de \u00abHabr\u00bb \u2014 un descuento de 10,000 rublos al registrarse en cualquier curso de Skillbox usando el c\u00f3digo promocional \u00abHabr\u00bb.<\/i>\n<\/p><\/blockquote>\n

\u00a1Hola, mundo!<\/h3>\n

\nSe puede crear un servidor web en Go muy r\u00e1pidamente. Aqu\u00ed hay un ejemplo de un manejador que devuelve el mencionado \u00ab\u00a1Hola, mundo!\u00bb.<\/p>\n

package main\n \nimport (\n\"fmt\"\n\"net\/http\"\n)\n \nfunc main() {\nhttp.HandleFunc(\"\/\", func(w http.ResponseWriter, r *http.Request) {\nfmt.Fprintf(w, \"\u00a1Hola, Mundo!\")\n})\nhttp.ListenAndServe(\":80\", nil)\n}<\/code><\/pre>\n
\nDespu\u00e9s de esto, si inicias la aplicaci\u00f3n y abres la p\u00e1gina localhost<\/noindex>, ver\u00e1s de inmediato el texto \u00ab\u00a1Hola, mundo!\u00bb (por supuesto, si todo funciona correctamente).<\/p>\n
A partir de aqu\u00ed, utilizaremos el manejador repetidamente, pero primero comprendamos c\u00f3mo funciona todo.<\/p>\n
net\/http<\/h4>\n
\nEn el ejemplo se utiliz\u00f3 el paquete net\/http<\/code><\/a><\/noindex>, que es la herramienta principal en Go para desarrollar tanto servidores como clientes HTTP. Para entender el c\u00f3digo, analicemos el significado de tres elementos importantes: http.Handler, http.ServeMux y http.Server.<\/p>\n
Manejadores HTTP<\/h4>\n
\nCuando recibimos una solicitud, el manejador la analiza y forma una respuesta. Los manejadores en Go se implementan de la siguiente manera:<\/p>\n
type Handler interface {\n        ServeHTTP(ResponseWriter, *Request)\n}<\/code><\/pre>\n
\nEn el primer ejemplo se utiliza la funci\u00f3n auxiliar http.HandleFunc. Esta envuelve otra funci\u00f3n que, a su vez, recibe http.ResponseWriter y http.Request en ServeHTTP.<\/p>\n
En otras palabras, los manejadores en Golang est\u00e1n representados por una \u00fanica interfaz, lo que ofrece muchas posibilidades para el programador. Por ejemplo, el middleware se implementa mediante un manejador, donde ServeHTTP primero hace algo y luego llama al m\u00e9todo ServeHTTP de otro manejador.<\/p>\n
Como se mencion\u00f3 anteriormente, los manejadores simplemente generan respuestas a solicitudes. Pero, \u00bfqu\u00e9 manejador espec\u00edfico se debe usar en un momento determinado?<\/p>\n
Enrutamiento de solicitudes<\/h4>\n
\nPara tomar la decisi\u00f3n correcta, utilice un multiplexor HTTP. En varias bibliotecas, se le denomina muxer o router, pero todo es lo mismo. La funci\u00f3n del multiplexor consiste en analizar la ruta de la solicitud y seleccionar el manejador correspondiente.<\/p>\n
Si se necesita soporte para enrutamiento complejo, entonces es mejor utilizar bibliotecas de terceros. Algunas de las m\u00e1s avanzadas son gorilla\/mux<\/a><\/noindex> y go-chi\/chi<\/a><\/noindex>, estas bibliotecas permiten implementar el procesamiento intermedio sin problemas. Con su ayuda, se puede configurar el enrutamiento con comodines y realizar varias otras tareas. Su ventaja es la compatibilidad con los manejadores HTTP est\u00e1ndares. Como resultado, puede escribir un c\u00f3digo simple con la posibilidad de modificarlo en el futuro.<\/p>\n
Trabajar con marcos complejos en situaciones normales requerir\u00e1 soluciones no est\u00e1ndar, lo cual complica significativamente el uso de manejadores predeterminados. Para crear la mayor\u00eda de las aplicaciones, basta con una combinaci\u00f3n de la biblioteca por defecto y un enrutador sencillo.<\/p>\n
Procesamiento de solicitudes<\/h4>\n
\nAdem\u00e1s, necesitamos un componente que 'escuche' las conexiones entrantes y redirija todas las solicitudes al manejador correcto. Esta tarea la puede llevar a cabo sin dificultad http.Server.<\/p>\n
A continuaci\u00f3n se muestra que el servidor es responsable de todas las tareas relacionadas con el procesamiento de conexiones. Esto incluye, por ejemplo, el trabajo con el protocolo TLS. Para implementar la llamada http.ListenAndServer se utiliza el servidor HTTP est\u00e1ndar.<\/p>\n
Ahora revisemos ejemplos m\u00e1s complejos.<\/p>\n
Adici\u00f3n de Let\u2019s Encrypt<\/h3>\n
\nPor defecto, nuestra aplicaci\u00f3n opera con el protocolo HTTP; sin embargo, se recomienda utilizar el protocolo HTTPS. En Go, esto se puede hacer sin problemas. Si ha obtenido un certificado y una clave privada, entonces es suficiente con especificar ListenAndServeTLS indicando los archivos de certificado y clave correctos.<\/p>\n
http.ListenAndServeTLS(\":443\", \"cert.pem\", \"key.pem\", nil)<\/code><\/pre>\n
\nSiempre se puede hacer mejor.<\/p>\n
Let\u2019s Encrypt<\/a><\/noindex> ofrece certificados gratuitos con la posibilidad de actualizaciones autom\u00e1ticas. Para utilizar el servicio, se necesita el paquete autocert<\/code>.<\/p>\n
La forma m\u00e1s sencilla de configurarlo es utilizar el m\u00e9todo autocert.NewListener en combinaci\u00f3n con http.Serve. El m\u00e9todo permite obtener y actualizar certificados TLS, mientras que el servidor HTTP maneja las solicitudes:<\/p>\n
http.Serve(autocert.NewListener(\"example.com\"), nil)<\/code><\/pre>\n
\nSi abrimos en el navegador example.com<\/a><\/noindex>, entonces obtendremos una respuesta HTTPS \u00abHello, world!\u00bb.<\/p>\n
Si se necesita una configuraci\u00f3n m\u00e1s detallada, es conveniente utilizar el gestor autocert.Manager. A continuaci\u00f3n, creamos nuestra propia instancia http.Server (hasta ahora hemos utilizado la predeterminada) y a\u00f1adimos el gestor a la configuraci\u00f3n TLS del servidor:<\/p>\n
m := &autocert.Manager{\nCache:      autocert.DirCache(\"golang-autocert\"),\nPrompt:     autocert.AcceptTOS,\nHostPolicy: autocert.HostWhitelist(\"example.org\", \"www.example.org\"),\n}\nserver := &http.Server{\n    Addr:      \":443\",\n    TLSConfig: m.TLSConfig(),\n}\nserver.ListenAndServeTLS(\"\", \"\")<\/code><\/pre>\n
\nEsta es una forma sencilla de implementar soporte completo para HTTPS con renovaci\u00f3n autom\u00e1tica del certificado.<\/p>\n
A\u00f1adiendo rutas personalizadas<\/h3>\n
\nEl enrutador predeterminado incluido en la biblioteca est\u00e1ndar es bueno, pero es muy simple. En la mayor\u00eda de las aplicaciones, se necesita una enrutaci\u00f3n m\u00e1s compleja, incluyendo enrutamientos anidados y comodines o bien un procedimiento para establecer plantillas y par\u00e1metros de rutas.<\/p>\n
En este caso, vale la pena utilizar paquetes gorilla\/mux<\/a><\/noindex> y go-chi\/chi<\/a><\/noindex>. Con este \u00faltimo aprenderemos a trabajar \u2014 a continuaci\u00f3n se muestra un ejemplo.<\/p>\n
Dado \u2014 el archivo api\/v1\/api.go, que contiene las rutas para nuestra API:<\/p>\n
\/ HelloResponse is the JSON representation for a customized message\ntype HelloResponse struct {\nMessage string `json:\"message\"`\n}\n \n\/\/ HelloName returns a personalized JSON message\nfunc HelloName(w http.ResponseWriter, r *http.Request) {\nname := chi.URLParam(r, \"name\")\nresponse := HelloResponse{\nMessage: fmt.Sprintf(\"Hello %s!\", name),\n}\njsonResponse(w, response, http.StatusOK)\n}\n \n\/\/ NewRouter returns an HTTP handler that implements the routes for the API\nfunc NewRouter() http.Handler {\nr := chi.NewRouter()\nr.Get(\"\/{name}\", HelloName)\nreturn r\n}<\/code><\/pre>\n
\nEstablecemos un prefijo para las rutas api\/vq en el archivo principal.<\/p>\n
Podemos montarlo en nuestro enrutador principal bajo el prefijo api\/v1\/ de vuelta en nuestra aplicaci\u00f3n principal:<\/p>\n
\/\/ NewRouter returns a new HTTP handler that implements the main server routes\nfunc NewRouter() http.Handler {\nrouter := chi.NewRouter()\n    router.Mount(\"\/api\/v1\/\", v1.NewRouter())\n    return router\n}\nhttp.Serve(autocert.NewListener(\"example.com\"), NewRouter())<\/code><\/pre>\n
\nLa simplicidad en el manejo de rutas complejas en Go permite simplificar la estructuraci\u00f3n al mantener grandes aplicaciones complejas.<\/p>\n
Trabajo con middleware<\/h3>\n
\nEn el caso de la intermediaci\u00f3n, se utiliza un envolvimiento de un manejador HTTP dentro de otro, lo que permite realizar r\u00e1pidamente autenticaci\u00f3n, compresi\u00f3n, registro y algunas otras funciones.<\/p>\n
Como ejemplo, consideremos la interfaz http.Handler, con la que escribiremos un manejador de autenticaci\u00f3n de usuarios del servicio.<\/p>\n
func RequireAuthentication(next http.Handler) http.Handler {\n    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n        if !isAuthenticated(r) {\n            http.Redirect(w, r, \"\\\/login\", http.StatusTemporaryRedirect)\n            return\n        }\n        \\\/\\\/ Asumiendo que la autenticaci\u00f3n ha pasado, ejecuta el manejador original\n        next.ServeHTTP(w, r)\n    })\n}<\/code><\/pre>\n
\nExisten enrutadores de terceros, como chi, que permiten ampliar la funcionalidad de la intermediaci\u00f3n.<\/p>\n
Trabajo con archivos est\u00e1ticos<\/h3>\n
\nLa biblioteca est\u00e1ndar de Go incluye capacidades para trabajar con contenido est\u00e1tico, incluyendo im\u00e1genes, as\u00ed como archivos JavaScript y CSS. Se puede acceder a ellos a trav\u00e9s de la funci\u00f3n http.FileServer. Esta devuelve un manejador que distribuye archivos desde un directorio espec\u00edfico.<\/p>\n
func NewRouter() http.Handler {\n    router := chi.NewRouter()\n    r.Get(\"\/{name}\", HelloName)\n \n\/\/ Configuraci\u00f3n para servir archivos est\u00e1ticos\nstaticPath, _ := filepath.Abs(\"..\\\/..\\\/static\\\/\\\")\nfs := http.FileServer(http.Dir(staticPath))\n    router.Handle(\"\/*\", fs)\n    \n    return r<\/code><\/pre>\n
\nEs importante recordar que http.Dir muestra el contenido del directorio si no hay un archivo principal index.html en \u00e9l. En este caso, para prevenir la exposici\u00f3n del directorio, se debe usar el paquete no indexado<\/code><\/a><\/noindex>.<\/p>\n
Cierre correcto<\/h3>\n
\nEn Go, existe una funci\u00f3n para el cierre adecuado del servidor HTTP. Esto se puede hacer utilizando el m\u00e9todo Shutdown(). El servidor se ejecuta en una goroutine, y luego se escucha un canal para recibir la se\u00f1al de interrupci\u00f3n. Una vez recibida la se\u00f1al, el servidor se apaga, pero no inmediatamente, sino despu\u00e9s de unos segundos.<\/p>\n
handler := server.NewRouter()\nsrv := &http.Server{\n    Handler: handler,\n}\n \ngo func() {\nsrv.Serve(autocert.NewListener(domains...))\n}()\n \n\/\/ Esperar a una interrupci\u00f3n\nc := make(chan os.Signal, 1)\nsignal.Notify(c, os.Interrupt)\n<-c\n \n\/\/ Intentar un cierre elegante\nctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)\ndefer cancel()\nsrv.Shutdown(ctx)<\/code><\/pre>\n
<\/p>\n
En conclusi\u00f3n<\/h3>\n
\nGo es un lenguaje poderoso con una biblioteca est\u00e1ndar pr\u00e1cticamente universal. Sus capacidades predeterminadas son bastante amplias, y se pueden mejorar mediante interfaces, lo que permite desarrollar servidores HTTP realmente confiables.<\/p>\n
Skillbox recomienda:<\/b><\/p>\n