La nube perimetral permite a los desarrolladores implementar microservicios (es decir, servicios web detallados) cerca de los usuarios, lo que da como resultado una mejor experiencia de usuario (es decir, tiempos de respuesta muy rápidos), excelente seguridad y alta disponibilidad. La nube perimetral utiliza centros de datos locales o incluso privados, redes CDN y centros de datos de telecomunicaciones (como 5G MEC) para proporcionar servicios informáticos. Las historias de éxito de la nube perimetral incluyen Cloudflare, Fastly, Akamai, fly.io, Vercel, Netlify y más.
Sin embargo, las nubes de borde son un entorno con recursos limitados en comparación con las nubes públicas más grandes. Si los propios microservicios perimetrales son lentos, sobredimensionados o inseguros, se perderán todos los beneficios de implementarlos en la nube perimetral.
Este artículo mostrará cómo crear un servicio web liviano y de alto rendimiento y luego implementarlo en fly.io, un proveedor de nube perimetral, de forma gratuita .
Fly.io es un proveedor líder de servicios de máquinas virtuales en la nube con centros de datos de vanguardia en todo el mundo. La máquina virtual fly.io admite servidores de aplicaciones, bases de datos y un tiempo de ejecución liviano para microservicios como el nuestro.
Usaré el tiempo de ejecución de WasmEdge como entorno de pruebas de seguridad para estos microservicios. WasmEdge es un tiempo de ejecución de WebAssembly optimizado para servicios nativos de la nube. Empaquetaremos aplicaciones de microservicio escritas en Rust o JavaScript en Docker Images basadas en WasmEdge. Este enfoque tiene varias ventajas enormes.
- WasmEdge ejecuta aplicaciones de espacio aislado a una velocidad casi nativa. Según un estudio revisado por pares, WasmEdge puede ejecutar programas Rust a una velocidad cercana a la de Linux que ejecuta código de máquina nativo.
- WasmEdge es un tiempo de ejecución altamente seguro. Protege sus aplicaciones de amenazas externas e internas.
- La vulnerabilidad del tiempo de ejecución de WasmEdge a los ataques se reduce considerablemente en comparación con el tiempo de ejecución del sistema operativo Linux convencional.
- El riesgo de ataques a la cadena de suministro de software se reduce considerablemente porque el entorno limitado de WebAssembly solo permite el acceso declarado explícitamente.
- WasmEdge proporciona un entorno de ejecución de aplicaciones portátil completo con un consumo de memoria que es solo 1/10 del de una imagen de tiempo de ejecución del sistema operativo Linux estándar.
- El tiempo de ejecución de WasmEdge es multiplataforma. Esto significa que las máquinas para el desarrollo y la implementación no tienen que ser las mismas. Una vez que se crea una aplicación WasmEdge, se puede implementar en cualquier lugar que admita WasmEdge, incluida la infraestructura fly.io.
Para aplicaciones complejas, esta ventaja de rendimiento se magnifica aún más. Por ejemplo, la aplicación de inferencia WasmEdge AI no requiere una instalación de Python. Las aplicaciones WasmEdge node.js tampoco requieren la instalación de node.js y v8.
A continuación en este artículo, demostraré cómo ejecutar
-
Servidor HTTP asíncrono (Rust)
-
Un servicio web de clasificación de imágenes muy rápido (en Rust) y
-
servidor web node.js
-
Microservicios con estado con conexiones de bases de datos
Todo esto se ejecuta de forma rápida y segura en WasmEdge mientras consume solo 1/10 de los recursos requeridos por los contenedores de Linux normales.
Preparación
Primero, asegúrese de tener las herramientas Docker instaladas en su sistema. De lo contrario, siga la primera sección de este tutorial para instalar Docker. A continuación, usaremos el instalador en línea para instalar las herramientas WasmEdge , Rust y fly.io.flyctl
Instale WasmEdge. Ver detalles aquí.
curl -sSf https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install.sh | bash -s -- -e all
Instale óxido. Ver detalles aquí.
`curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh`
Instale herramientas para fly.io. Ver detalles aquí .flyctl
`curl -L `[`https://fly.io/install.sh`](https://fly.io/install.sh)` | sh`
Instalado flyctl 之后，Siga las instrucciones para registrar una cuenta en fly.io. ¡El servicio web ya está listo para implementarse en la nube perimetral!
Un microservicio simple escrito en Rust
Nuestro primer ejemplo es un servicio HTTP simple escrito en Rust. Demuestra una aplicación web moderna que se puede ampliar para admitir una lógica empresarial arbitrariamente compleja. Basado en los populares Tokio e Hyper Crate, este microservicio es muy rápido, asíncrono (sin bloqueo) y muy fácil de crear para los desarrolladores.
Una imagen WasmEdge totalmente vinculada estáticamente pesa solo 4 MB (en comparación con los 40 MB de la imagen base de Linux). Esto es suficiente para ejecutar servicios HTTP asincrónicos escritos en tokio e hyper frameworks de Rust.
Ejecute los siguientes dos comandos CLI para crear la aplicación fly.io a partir de la imagen Slim Docker de WasmEdge.
$ flyctl launch --image juntaoyuan/flyio-echo
$ flyctl deploy
¡está bien! Puede utilizar el comando curl para probar si el servicio web implementado fue exitoso. Se hace eco de cualquier dato que publique.
$ curl https://proud-sunset-3795.fly.dev/echo -d "Hello WasmEdge on fly.io!"
Hello WasmEdge on fly.io!
juntaoyuan/flyio-echoEl dockerfile de la imagen contiene el tiempo de ejecución de WasmEdge y el paquete completo de la aplicación web personalizada WasmEdge_hyper_server.wasm.
FROM WasmEdge/slim-runtime:0.11.0
ADD WasmEdge_hyper_server.wasm /
CMD ["WasmEdge", "--dir", ".:/", "/WasmEdge_hyper_server.wasm"]
El proyecto de código fuente de Rust que crea WasmEdge_hyper_server.wasm la aplicación está aquí. Inicia un servidor HTTP utilizando la API de Tokio. Cuando el servidor recibe una solicitud, delega en echo()una función para procesar la solicitud de forma asincrónica. Esto permite que los microservicios acepten y procesen múltiples solicitudes HTTP simultáneas.
#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let addr = SocketAddr::from(([0, 0, 0, 0], 8080));
let listener = TcpListener::bind(addr).await?;
println!("Listening on http://{}", addr);
loop {
let (stream, _) = listener.accept().await?;
tokio::task::spawn(async move {
if let Err(err) = Http::new().serve_connection(stream, service_fn(echo)).await {
println!("Error serving connection: {:?}", err);
}
});
}
}
Las funciones asincrónicas echo()son las siguientes. Aprovecha la API HTTP proporcionada por Hyper para analizar solicitudes y generar respuestas. Aquí, la respuesta es simplemente el "cuerpo de datos de la solicitud".
async fn echo(req: Request<Body>) -> Result<Response<Body>, hyper::Error> {
match (req.method(), req.uri().path()) {
... ...
(&Method::POST, "/echo") => Ok(Response::new(req.into_body())),
... ...
// Return the 404 Not Found for other routes.
_ => {
let mut not_found = Response::default();
*not_found.status_mut() = StatusCode::NOT_FOUND;
Ok(not_found)
}
}
}
¡Ahora agreguemos algo de sabor a nuestros microservicios básicos!
Un microservicio de inferencia de IA escrito en Rust
En este ejemplo, crearemos un servicio web para clasificar imágenes. Procesa imágenes cargadas a través de modelos Tensorflow Lite. Usaremos la API Rust de WasmEdge para acceder a Tensorflow, en lugar de crear un programa Python complejo (e inflado) que ejecute tareas de inferencia a la velocidad del código de máquina nativo (por ejemplo, en hardware GPU, si está disponible). A través del estándar WASI-NN, la API Rust de WasmEdge se puede utilizar con modelos de IA en Tensorflow, PyTorch, OpenVINO y otros marcos de IA.
WasmEdge ocupa menos de 115 MB para una aplicación de inferencia de IA que incluye dependencias completas de Tensorflow Lite. En comparación, la imagen estándar de Tensorflow Linux tiene más de 400 MB.
A partir de la imagen delgada de Docker de WasmEdge + Tensorflow, ejecute los siguientes dos comandos CLI para crear e implementar una aplicación fly.io.
$ flyctl launch --image juntaoyuan/flyio-classify
$ flyctl deploy
¡está bien! Puede utilizar el comando curl para probar si el servicio web implementado realmente funciona. Devuelve resultados de clasificación de imágenes con rangos de probabilidad.
$ curl https://silent-glade-6853.fly.dev/classify -X POST --data-binary "@grace_hopper.jpg"
military uniform is detected with 206/255 confidence
juntaoyuan/flyio-classifyEl Dockerfile para la imagen de Docker contiene el paquete completo del tiempo de ejecución de WasmEdge, toda la biblioteca de Tensorflow y sus dependencias, y la aplicación web personalizada WasmEdge_hyper_server_tflite.wasm.
FROM WasmEdge/slim-tf:0.11.0
ADD WasmEdge_hyper_server_tflite.wasm /
CMD ["WasmEdge-tensorflow-lite", "--dir", ".:/", "/WasmEdge_hyper_server_tflite.wasm"]
El proyecto de código fuente de Rust utilizado para crear WasmEdge_hyper_server_tflite.wasmla aplicación está aquí . El servidor HTTP asíncrono basado en Tokio está dentro de una main()función asíncrona, como se muestra en el ejemplo anterior. classify()La función procesa los datos de la imagen en la solicitud, convierte la imagen en un tensor, ejecuta el modelo de Tensorflow y convierte el valor de retorno (en un tensor) en etiquetas de texto y probabilidades para el contenido reconocido.
async fn classify(req: Request<Body>) -> Result<Response<Body>, hyper::Error> {
let model_data: &[u8] = include_bytes!("models/mobilenet_v1_1.0_224/mobilenet_v1_1.0_224_quant.tflite");
let labels = include_str!("models/mobilenet_v1_1.0_224/labels_mobilenet_quant_v1_224.txt");
match (req.method(), req.uri().path()) {
(&Method::POST, "/classify") => {
let buf = hyper::body::to_bytes(req.into_body()).await?;
let flat_img = WasmEdge_tensorflow_interface::load_jpg_image_to_rgb8(&buf, 224, 224);
let mut session = WasmEdge_tensorflow_interface::Session::new(&model_data, WasmEdge_tensorflow_interface::ModelType::TensorFlowLite);
session.add_input("input", &flat_img, &[1, 224, 224, 3])
.run();
let res_vec: Vec<u8> = session.get_output("MobilenetV1/Predictions/Reshape_1");
... ...
let mut label_lines = labels.lines();
for _i in 0..max_index {
label_lines.next();
}
let class_name = label_lines.next().unwrap().to_string();
Ok(Response::new(Body::from(format!("{} is detected with {}/255 confidence", class_name, max_value))))
}
// Return the 404 Not Found for other routes.
_ => {
let mut not_found = Response::default();
*not_found.status_mut() = StatusCode::NOT_FOUND;
Ok(not_found)
}
}
}
Al final de este artículo, analizaremos cómo agregar más funciones a los microservicios de Rust, como clientes de bases de datos y clientes de servicios web.
Un microservicio simple en Node.js
Si bien los microservicios basados en Rust son ligeros y rápidos, no todo el mundo es desarrollador de Rust (todavía). Si está más familiarizado con JavaScript, aún puede aprovechar al máximo la seguridad, el rendimiento, el tamaño reducido y la portabilidad de WasmEdge en la nube periférica. Específicamente, es posible crear microservicios para WasmEdge utilizando la API node.js.
Para aplicaciones Node.js, WasmEdge ocupa menos de 15 MB. En comparación, la imagen estándar de Node.js Linux tiene más de 150 MB.
A partir de la imagen delgada de Docker de WasmEdge + node.js, ejecute los siguientes dos comandos CLI para crear e implementar una aplicación fly.io.
$ flyctl launch --image juntaoyuan/flyio-nodejs-echo
$ flyctl deploy
¡está bien! Puede utilizar el comando curl para comprobar que el servicio web implementado realmente funciona. Se hará eco de cualquier dato que publique en él.
$ curl https://solitary-snowflake-1159.fly.dev -d "Hello WasmEdge for Node.js on fly.io!"
Hello WasmEdge for Node.js on fly.io!
juntaoyuan/flyio-nodejs-echoEl Dockerfile de la imagen de Docker contiene el tiempo de ejecución WasmEdge, el tiempo de ejecución QuickJS , el paquete completoWasmEdge_quickjs.wasm de módulos node.js y la aplicación de servicio web .node_echo.js
FROM WasmEdge/slim-runtime:0.11.0
ADD WasmEdge_quickjs.wasm /
ADD node_echo.js /
ADD modules /modules
CMD ["WasmEdge", "--dir", ".:/", "/WasmEdge_quickjs.wasm", "node_echo.js"]
node_echo.jsEl código fuente completo de JavaScript para la aplicación se encuentra a continuación. Obviamente, solo usa la API estándar de node.js para crear un servidor HTTP asincrónico que repite el cuerpo de la solicitud HTTP.
import { createServer, request, fetch } from 'http';
createServer((req, resp) => {
req.on('data', (body) => {
resp.end(body)
})
}).listen(8080, () => {
print('listen 8080 ...\n');
})
El motor QuickJS de WasmEdge no solo proporciona soporte para node.js, sino también soporte para inferencia de Tensorflow. Hemos integrado Rust TensorFlow y WASI-NN SDK en una API de JavaScript para que los desarrolladores de JavaScript puedan crear fácilmente aplicaciones de inferencia de IA .
Microservicios con estado en el borde
Con WasmEdge, también es posible crear microservicios con estado respaldados por bases de datos. Este repositorio de GitHub contiene un ejemplo de un cliente de base de datos sin bloqueo basado en Tokio para aplicaciones WasmEdge.
- El cliente MySQL permite que las aplicaciones WasmEdge accedan a la mayoría de las bases de datos en la nube.
- Las aplicaciones WasmEdge pueden utilizar anna-rs como caché perimetral o base de datos.
Ahora, utilice rápidamente el SDK y el tiempo de ejecución de WasmEdge para crear varios servicios web en la nube perimetral. ¡No puedo esperar a ver tus resultados!