Inicio rápido: Creación de una función de Go o Rust en Azure con Visual Studio Code

Artículo
05/13/2021
11 minutos para leer

En este artículo se usa Visual Studio Code para crear una función de controlador personalizado que responda a solicitudes HTTP. Después de probar el código localmente, se implementa en el entorno sin servidor de Azure Functions.

Los controladores personalizados se pueden usar para crear funciones en cualquier lenguaje o entorno de ejecución mediante la ejecución de un proceso del servidor HTTP. En este artículo se admiten Go y Rust.

Este inicio rápido supone un pequeño costo en su cuenta de Azure.

Configurar su entorno

Antes de empezar, asegúrese de que cumple los siguientes requisitos:

Go
Rust

Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.
Visual Studio Code en una de las plataformas admitidas.
La extensión de Azure Functions para Visual Studio Code.
Azure Functions Core Tools, versión 3.x. Use el comando func --version para comprobar que está correctamente instalado.
Go, se recomienda la última versión. Use el comando go version para comprobar la versión.

Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.
Visual Studio Code en una de las plataformas admitidas.
La extensión de Azure Functions para Visual Studio Code.
Azure Functions Core Tools, versión 3.x. Use el comando func --version para comprobar que está correctamente instalado.
Cadena de herramientas de Rust mediante rustup. Use el comando rustc --version para comprobar la versión.

Creación del proyecto local

En esta sección se usa Visual Studio Code para crear un proyecto local de controladores personalizados de Azure Functions. Más adelante en este artículo, publicará el código de función en Azure.

Seleccione el icono de Azure en la barra de actividades y después en el área Azure: Functions, seleccione el icono Crear un proyecto.
Elija una ubicación de directorio para el área de trabajo del proyecto y elija Seleccionar.

Nota

Estos pasos se han diseñado para completarse fuera de un área de trabajo. Por tanto, no seleccione una carpeta de proyecto que forme parte de un área de trabajo.
Escriba la siguiente información cuando se le indique:
- Seleccione un lenguaje para el proyecto de funciones: Elija Custom.
- Seleccione una plantilla para la primera función del proyecto: Elija HTTP trigger.
- Especifique un nombre de función: Escriba HttpExample.
- Nivel de autorización: Elija Anonymous, que permite que cualquier llame al punto de conexión de la función. Para obtener información sobre el nivel de autorización, consulte Claves de autorización.
- Seleccione cómo desea que se abra el proyecto: Elija Add to workspace.
Con esta información, Visual Studio Code genera un proyecto de Azure Functions con una función de desencadenador HTTP. Los archivos del proyecto locales se pueden ver en Explorer. Para obtener más información sobre los archivos que se crean, consulte Archivos del proyecto generados.

Creación y compilación de la función

El archivo function.json de la carpeta HttpExample declara una función de desencadenador HTTP. Para completar la función, agregue un controlador y compílela en un archivo ejecutable.

Go
Rust

Pulse Ctrl + N (Cmd + N en macOS) para crear un archivo nuevo. Guárdelo como handler.go en la carpeta raíz de la aplicación de funciones (en la misma carpeta que host.json).

En el archivo handler.go, agregue el código siguiente y guárdelo. Este es el controlador personalizado de Go.

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    message := "This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response.\n"
    name := r.URL.Query().Get("name")
    if name != "" {
        message = fmt.Sprintf("Hello, %s. This HTTP triggered function executed successfully.\n", name)
    }
    fmt.Fprint(w, message)
}

func main() {
    listenAddr := ":8080"
    if val, ok := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT"); ok {
        listenAddr = ":" + val
    }
    http.HandleFunc("/api/HttpExample", helloHandler)
    log.Printf("About to listen on %s. Go to https://127.0.0.1%s/", listenAddr, listenAddr)
    log.Fatal(http.ListenAndServe(listenAddr, nil))
}

Pulse Ctrl + Mayús + ` o seleccione Nuevo terminal en el menú Terminal para abrir un nuevo terminal integrado en VS Code.
Compile el controlador personalizado con el siguiente comando. Se genera un archivo ejecutable llamado handler (handler.exe en Windows) en la carpeta raíz de la aplicación de funciones.
```
go build handler.go
```

Pulse Ctrl + Mayús + ` o seleccione Nuevo terminal en el menú Terminal para abrir un nuevo terminal integrado en VS Code.
En la carpeta raíz de la aplicación de funciones (en la misma carpeta que host.json), inicialice un proyecto de Rust llamado handler.
```
cargo init --name handler
```
En el archivo Cargo.toml, agregue las siguientes dependencias necesarias para completar esta guía de inicio rápido. En el ejemplo se usa el marco de servidor web warp.
```
[dependencies]
warp = "0.3"
tokio = { version = "1", features = ["rt", "macros", "rt-multi-thread"] }
```

En el archivo src/main.rs, agregue el código siguiente y guárdelo. Este es el controlador personalizado de Rust.

use std::collections::HashMap;
use std::env;
use std::net::Ipv4Addr;
use warp::{http::Response, Filter};

#[tokio::main]
async fn main() {
    let example1 = warp::get()
        .and(warp::path("api"))
        .and(warp::path("HttpExample"))
        .and(warp::query::<HashMap<String, String>>())
        .map(|p: HashMap<String, String>| match p.get("name") {
            Some(name) => Response::builder().body(format!("Hello, {}. This HTTP triggered function executed successfully.", name)),
            None => Response::builder().body(String::from("This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response.")),
        });

    let port_key = "FUNCTIONS_CUSTOMHANDLER_PORT";
    let port: u16 = match env::var(port_key) {
        Ok(val) => val.parse().expect("Custom Handler port is not a number!"),
        Err(_) => 3000,
    };

    warp::serve(example1).run((Ipv4Addr::UNSPECIFIED, port)).await
}

Compile un archivo binario para el controlador personalizado. Se genera un archivo ejecutable llamado handler (handler.exe en Windows) en la carpeta raíz de la aplicación de funciones.
```
cargo build --release
cp target/release/handler .
```

Configuración de la aplicación de funciones

El host de la función se debe configurar para ejecutar el archivo binario del controlador personalizado al iniciarse.

Abra el archivo host.json.
En la sección customHandler.description, establezca el valor de defaultExecutablePath en handler (en Windows, establézcalo en handler.exe).
En la sección customHandler, agregue una propiedad llamada enableForwardingHttpRequest y establezca su valor en true. En el caso de las funciones que solo se componen de un desencadenador HTTP, esta configuración simplifica la programación, ya que permite trabajar con una solicitud HTTP típica en lugar de la carga de la solicitud del controlador personalizado.

Confirme que la sección customHandler es similar a la de este ejemplo. Guarde el archivo.

"customHandler": {
  "description": {
    "defaultExecutablePath": "handler",
    "workingDirectory": "",
    "arguments": []
  },
  "enableForwardingHttpRequest": true
}

La aplicación de funciones está configurada para iniciar el archivo ejecutable del controlador personalizado.

Ejecución local de la función

Puede ejecutar este proyecto en el equipo de desarrollo local antes de publicar en Azure.

En el terminal integrado, inicie la aplicación de funciones mediante Azure Functions Core Tools.
```
func start
```
Con Core Tools en ejecución, vaya a la siguiente dirección URL para ejecutar una solicitud GET, que incluye la cadena de consulta ?name=Functions.

http://localhost:7071/api/HttpExample?name=Functions
Se devuelve una respuesta, que tiene un aspecto similar al siguiente en un explorador:
La información sobre la solicitud se muestra en el panel Terminal.
Pulse Ctrl + C para detener Core Tools.

Después de comprobar que la función se ejecuta correctamente en el equipo local, es el momento de usar Visual Studio Code para publicar el proyecto directamente en Azure.

Para poder publicar la aplicación, debe iniciar sesión en Azure.

Si aún no ha iniciado sesión, seleccione el icono de Azure en la barra de actividades y después en el área Azure: Functions, elija Iniciar sesión en Azure… . Si aún no dispone de una cuenta, puede crear una cuenta gratuita de Azure . Los alumnos pueden crear una cuenta de Azure gratuita para estudiantes .

Si ya ha iniciado sesión, vaya a la sección siguiente.
Cuando se le solicite en el explorador, elija su cuenta de Azure e inicie sesión con las credenciales de la misma.
Cuando haya iniciado sesión correctamente, puede cerrar la nueva ventana del explorador. Las suscripciones que pertenecen a su cuenta de Azure se muestran a la barra lateral.

Compilación del controlador personalizado para Azure

En esta sección, publicará el proyecto en Azure en una aplicación de funciones que ejecuta Linux. En la mayoría de los casos, debe volver a compilar el archivo binario y ajustar la configuración para que coincida con la plataforma de destino antes de publicarla en Azure.

Go
Rust

En el terminal integrado, compile el controlador en Linux/x64. Se crea un archivo binario llamado handler en la carpeta raíz de la aplicación de funciones.
- macOS
- Linux
- Windows
```
GOOS=linux GOARCH=amd64 go build handler.go
```
```
GOOS=linux GOARCH=amd64 go build handler.go
```
```
set GOOS=linux
set GOARCH=amd64
go build handler.go
```
Cambie el valor de defaultExecutablePath en host.json de handler.exe a handler. Esto indica a la aplicación de funciones que ejecute el archivo binario de Linux.

Cree un archivo en .cargo/config. Agregue el contenido siguiente y guarde el archivo.
```
[target.x86_64-unknown-linux-musl]
linker = "rust-lld"
```
En el terminal integrado, compile el controlador en Linux/x64. Se crea un archivo binario llamado handler. Cópielo en la carpeta raíz de la aplicación de funciones.
```
rustup target add x86_64-unknown-linux-musl
cargo build --release --target=x86_64-unknown-linux-musl
cp target/x86_64-unknown-linux-musl/release/handler .
```
Si usa Windows, cambie el valor de defaultExecutablePath en host.json de handler.exe a handler. Esto indica a la aplicación de funciones que ejecute el archivo binario de Linux.
Agregue la línea siguiente al archivo .funcignore:
```
target
```
Esto evita que se publique el contenido de la carpeta target.

Publicar el proyecto en Azure

En esta sección, va a crear una aplicación de funciones y los recursos relacionados en su suscripción de Azure y, después, va a implementar el código.

Importante

La publicación en una aplicación de función existente sobrescribe el contenido de esa aplicación en Azure.

Seleccione el icono de Azure en la barra de actividades y después en el área Azure: Functions, seleccione el botón de implementación en la aplicación de funciones.
Escriba la siguiente información cuando se le indique:
- Seleccione la carpeta: elija una carpeta en el área de trabajo o busque una que contenga la aplicación de funciones. No verá esta opción si ya tiene una aplicación de funciones válida abierta.
- Seleccione la suscripción: elija la suscripción que desee usar. No se mostrará esta opción si solo tiene una suscripción.
- Seleccione la aplicación de funciones en Azure: Elija + Create new Function App (advanced).
  
  Importante
  
  La opción advanced permite elegir el sistema operativo específico en el que se ejecuta la aplicación de funciones en Azure, que en este caso es Linux.
- Escriba un nombre único global para la aplicación de funciones: Escriba un nombre que sea válido en una ruta de acceso de la dirección URL. El nombre que escriba se valida para asegurarse de que es único en Azure Functions.
- Seleccione una pila del entorno en tiempo de ejecución: Elija Custom Handler.
- Seleccione un sistema operativo: Elija Linux.
- Seleccione un plan de hospedaje: Elija Consumption.
- Seleccione un grupo de recursos: Elija + Create new resource group. Escriba un nombre para el grupo de recursos. El nombre debe ser único en la suscripción de Azure. Puede usar el nombre sugerido en la solicitud.
- Seleccione una cuenta de almacenamiento: Elija + Create new storage account. Este nombre debe ser único globalmente en Azure. Puede usar el nombre sugerido en la solicitud.
- Seleccione un recurso de Application Insights: Elija + Create Application Insights resource. Este nombre debe ser único globalmente en Azure. Puede usar el nombre sugerido en la solicitud.
- Seleccione una ubicación para los nuevos recursos: Para mejorar el rendimiento, elija una región cerca de usted. La extensión muestra el estado de los recursos individuales a medida que se crean en Azure en el área de notificación.
Cuando se complete, se crearán los siguientes recursos de Azure en la suscripción:
- Un grupo de recursos, que es un contenedor lógico de recursos relacionados.
- Una cuenta de Azure Storage estándar, que mantiene información de estado y de otro tipo sobre los proyectos.
- Un plan de consumo, que define el host subyacente para su aplicación de funciones sin servidor.
- Una aplicación de funciones, que proporciona el entorno para ejecutar el código de función. Una aplicación de funciones permite agrupar funciones como una unidad lógica para facilitar la administración, la implementación y el uso compartido de recursos en el mismo plan de hospedaje.
- Una instancia de Application Insights conectada a la aplicación de funciones, que realiza un seguimiento del uso de la función sin servidor.
Una vez que se haya creado la aplicación de función se mostrará una notificación y se aplicará el paquete de implementación.
Seleccione View Output (Ver salida) en esta notificación para ver la creación y los resultados de la implementación, incluidos los recursos de Azure que ha creado. Si se pierde la notificación, seleccione el icono de campana en la esquina inferior derecha para verlo de nuevo.

Ejecución de la función en Azure

Vuelva al área Azure: Functions en la barra lateral y expanda su suscripción, la nueva aplicación de funciones y Functions. Haga clic con el botón derecho (Windows) o Ctrl + clic en (macOS) en la función HttpExample y elija Execute Function Now... (Ejecutar la función ahora...).
En Enter request body (Especificar el cuerpo de la solicitud) verá el valor del cuerpo del mensaje de solicitud de { "name": "Azure" }. Presione Entrar para enviar este mensaje de solicitud a la función.
Cuando la función se ejecuta en Azure y devuelve una respuesta, se genera una notificación en Visual Studio Code.

Limpieza de recursos

Si va al paso siguiente y agrega un enlace de cola de Azure Storage a una función, tendrá que conservar todos los recursos intactos para basarse en lo que ya ha hecho.

De lo contrario, puede usar los pasos siguientes para eliminar la aplicación de funciones y sus recursos relacionados para evitar incurrir en costos adicionales.

En Visual Studio Code, presione F1 para abrir la paleta de comandos. En la paleta de comandos, busque y seleccione Azure Functions: Open in portal.
Elija una aplicación de funciones y presione Entrar. La página de la aplicación de funciones se abre en Azure Portal.
En la pestaña Información general, seleccione el vínculo con nombre junto a Grupo de recursos.
En la página Grupo de recursos, revise la lista de recursos incluidos y compruebe que son los que desea eliminar.
Seleccione Eliminar grupo de recursos y siga las instrucciones.

El proceso de eliminación tardará un par de minutos. Cuando termine, aparece una notificación durante unos segundos. También puede seleccionar el icono de campana en la parte superior de la página para ver la notificación.

Para más información sobre los costos de Functions, consulte Estimación de los costos según el plan de consumo.

Pasos siguientes

Controladores personalizados de Azure Functions