Ejercicio: Uso de un controlador personalizado para compilar una aplicación

3 minutos

En este ejercicio, compilará y ejecutará una aplicación sin servidor mediante Go.

Scaffolding de la aplicación

Comience por realizar el scaffolding de la aplicación mediante la extensión Azure Functions en Visual Studio Code.

Seleccione Ver>Paleta de comandos.
Seleccione Azure Functions: Crear nuevo proyecto.
Seleccione una carpeta, normalmente la carpeta actual.
En Seleccionar un idioma, elija Controlador personalizado.
En Select a template for your first function (Seleccionar una plantilla para la primera función), seleccione HttpTrigger.
Asigne un nombre a la aplicación, como hola.
Seleccione el nivel de autorización anónimo. Si quieres, puedes cambiar eso más tarde.

Ahora tiene un proyecto de aspecto similar al siguiente:

hello/
  function.json
.funcignore
.gitignore
host.json
local.settings.json
proxies.json

Creación de la aplicación

La siguiente serie de pasos es sobre la creación de una aplicación que puede responder a un desencadenador HTTP.

Cree un archivo denominado server.go en la raíz del proyecto.
Proporcione al archivo server.go el siguiente contenido:
```
package main

import (
 "fmt"
 "io"
 "log"
 "net/http"
 "os"
)
```
El código anterior importa todas las bibliotecas que necesita para compilar una aplicación HTTP y buscar variables de entorno.
Agregue el código siguiente después de las instrucciones de importación:
```
func main() {
  customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")
  if !exists {
    customHandlerPort = "8080"
  }
  mux := http.NewServeMux()
  // mux.HandleFunc("/api/hello", helloHandler)
  fmt.Println("Go server Listening on: ", customHandlerPort)
  log.Fatal(http.ListenAndServe(":"+customHandlerPort, mux))
}
```
La función main() se invoca por sí misma. La primera línea del código indica cómo lee la variable de entorno FUNCTIONS_CUSTOM_HANDLER_PORT:
```
customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")
```
A continuación, la función comprueba si el puerto existe. Si no es así, a la función se le asigna el puerto 8080:
```
if !exists {
  customHandlerPort = "8080"
}
```
El código siguiente crea una instancia de servidor HTTP:
```
mux := http.NewServeMux()
```
La última línea de importancia es la que empieza a escuchar un puerto específico y señala que está listo para recibir solicitudes, con el método ListenAndServe():
```
log.Fatal(http.ListenAndServe(":"+customHandlerPort, mux))
```
Vamos a agregar el código restante. En primer lugar, busque la línea siguiente y quite la marca de comentario:
```
// mux.HandleFunc("/api/hello", helloHandler)
```

Entre las instrucciones import y la función main(), agregue el código siguiente:

func helloHandler(w http.ResponseWriter, r *http.Request) {
  w.Header().Set("Content-Type", "application/json")
  if r.Method == "GET" {
    w.Write([]byte("hello world"))
  } else {
    body, _ := io.ReadAll(r.Body)
    w.Write(body)
  }
}

La función helloHandler() establece el tipo de contenido en application/json. Responde con "hola mundo" o con el cuerpo publicado, si lo hubiera.

Ejecuta la aplicación

Llegado este punto, ha terminado de crear el código, pero debe realizar alguna configuración para que este escenario funcione. Debe señalar dónde está el archivo ejecutable para que el host de Functions pueda encontrarlo. También debe configurar el enrutamiento y declara que esta aplicación trata con desencadenadores HTTP y ningún otro tipo de enlaces.

Desde un terminal, ejecute go build server.go en la raíz del proyecto:
```
go build server.go
```
Este paso crea un archivo ejecutable denominado servidor en macOS y Linux, o server.exe en un sistema operativo Windows.
Abra el archivo host.json y busque el elemento defaultExecutablePath en el elemento customHandler. Especifique ./server en macOS y Linux o .\\server.exe en un sistema operativo Windows.
En el elemento customHandler, agregue el elemento enableForwardingHttpRequest y asígnele el valor true. El elemento customHandler debería tener ahora un aspecto similar al siguiente:
```
"customHandler": {
 "description": {
   "defaultExecutablePath": "./server",
   "workingDirectory": "",
   "arguments": []
 },
 "enableForwardingHttpRequest" : true
}
```
Desde un terminal, ejecute func start en la raíz del proyecto. Al hacerlo, se inicia la aplicación de Functions.
```
func start
```
Al final de la salida, verá una salida similar a la siguiente:
```
Functions:

     hello: [GET,POST] http://localhost:7071/api/hello
```
Vaya a http://localhost:7071/api/hello en un explorador. Debería ver la salida "hola mundo".

¡Enhorabuena! Ha desarrollado una aplicación sin servidor en Go.

Comentarios

¿Le ha resultado útil esta página?