AI 微雲：如何在一小時內部署輕量級 edge 基礎設施

Micro‑clouds con IA: despliegue ultra‑ligero, barato y de latencia mínima

Cómo montar una infraestructura edge con K3s, OpenFaaS y autoscaling impulsado por IA en menos de una hora.

Introducción

Los precios de los mega‑clouds están fuera de control y la latencia de los centros de datos centrales ya no basta para IA en tiempo real.

Con micro‑clouds IA puedes ejecutar tus funciones de inferencia, pipelines CI/CD o juegos multijugador a menos de 10 ms y pagando centavos por hora.

En este artículo verás:

• qué es una micro‑cloud IA,
• los componentes esenciales,
• proveedores y casos reales,
• y un tutorial paso a paso con scripts listos para copiar.

¿Por qué ahora es el momento de cambiar?

Arquitectura práctica de una micro‑cloud IA

┌─────────────────────┐
│  Cliente (web/app)  │
└───────▲───────▲─────┘
        │       │
   <10 ms   <10 ms
        │       │
┌───────▼───────▼─────┐
│  Nodos edge (K3s)   │
│  - Raspberry Pi 4  │
│  - Intel NUC       │
│  - Fly.io / Cloudflare Workers │
└───────▲───────▲─────┘
        │       │
   OpenFaaS + IA‑autoscaler
        │
┌───────▼───────────────────────┐
│  Micro‑VM (Firecracker / Kata)│
│  Funciones serverless (Python│
│  / Go / Node)                 │
└───────────────────────────────┘

Proveedores emergentes que facilitan la capa edge

Caso de uso real: Inferencia de modelo de clasificación de imágenes

Una startup de retail necesitaba clasificar fotos de productos en < 15 ms y reducir su factura de AWS SageMaker (US$12 k/mes).

Solución:

• 3 nodos edge (2 × Fly.io EU‑West, 1 × Raspberry Pi 4).
• K3s + OpenFaaS con función classify_image.
• Autoscaler basado en un modelo LSTM entrenado con los últimos 30 días de tráfico.

Resultado:

• Latencia media 9 ms (vs 120 ms en us‑east‑1).
• Coste mensual US$1 200 (≈ 90 % de ahorro).

Paso a paso: montar tu propia micro‑cloud IA

A continuación tienes todos los comandos y scripts listos para copiar. Se asume que tienes Docker y kubectl instalados en tu máquina local.

1. Crear el clúster K3s en los nodos edge

1.1 Fly.io (ejemplo con 2 regiones)

# Instala la CLI de Fly
curl -L https://fly.io/install.sh | sh

# Inicia sesión
fly auth login

# Crea una app en dos regiones
fly apps create microcloud-demo
fly regions add iad # Virginia (EEUU)
fly regions add fra # Frankfurt (EU)

# Despliega K3s usando el addon oficial de Fly
fly launch --image rancher/k3s:v1.27.4-k3s1 --detach

1.2 Raspberry Pi (ejemplo con Raspberry Pi OS)

# En cada Pi
curl -sfL https://get.k3s.io | INSTALL_K3S_EXEC="--node-ip $(hostname -I | awk '{print $1}')" sh -
# Copia el kubeconfig al workstation
sudo cat /etc/rancher/k3s/k3s.yaml > ~/.kube/config

2. Instalar OpenFaaS en el clúster

# Añade el repo de OpenFaaS
helm repo add openfaas https://openfaas.github.io/faas-netes/
helm repo update

# Despliega con valores mínimos
helm upgrade --install openfaas openfaas/openfaas \
  --namespace openfaas \
  --create-namespace \
  --set functionNamespace=openfaas-fn \
  --set generateBasicAuth=true

Obtén la contraseña:

kubectl -n openfaas get secret basic-auth -o jsonpath="{.data.password}" | base64 --decode

3. Crear una función de inferencia (Python + TensorFlow Lite)

# Crea el proyecto
faas-cli new classify_image --lang python3

# Edita handler.py
cat > classify_image/handler.py <<'PY'
import os, json, base64
import tensorflow as tf
model = tf.lite.Interpreter(model_path="model.tflite")
model.allocate_tensors()

def handle(event):
    img_bytes = base64.b64decode(event.body)
    # Preprocesado simplificado
    input_data = tf.io.decode_image(img_bytes, channels=3)
    input_data = tf.image.resize(input_data, [224, 224])
    input_data = tf.expand_dims(input_data, 0).numpy().astype('float32')
    # Inferencia
    input_idx = model.get_input_details()[0]["index"]
    model.set_tensor(input_idx, input_data)
    model.invoke()
    output = model.get_tensor(model.get_output_details()[0]["index"])
    pred = int(tf.argmax(output, axis=1).numpy())
    return {"prediction": pred}
PY

# Construye y despliega
faas-cli up -f classify_image.yml

4. Añadir autoscaling predictivo con IA

4.1 Entrenar el modelo de carga (LSTM con Prophet)

# train_scaler.py
import pandas as pd
from prophet import Prophet
df = pd.read_csv("traffic.csv")   # columnas: ds, y (requests per minute)
m = Prophet(yearly_seasonality=False, weekly_seasonality=True, daily_seasonality=True)
m.fit(df)
future = m.make_future_dataframe(periods=60, freq='T')
forecast = m.predict(future)
forecast[['ds','yhat']].to_csv("forecast.csv", index=False)

Ejecuta diariamente en un cron (ej. en un nodo manager) y guarda forecast.csv en un ConfigMap:

kubectl create configmap load-forecast --from-file=forecast.csv

4.2 Autoscaler custom para OpenFaaS

yaml
# hpa

---
*Herramienta mencionada: [GitHub Copilot](https://github.com/features/copilot)*