Validación de una arquitectura

Seleccionar GPU

Debe desplegar un servicio de inferencia basado en GPU para convertir segmentos de texto en voz, lo que garantiza el rendimiento, la escalabilidad y la rentabilidad. Puede evaluar los modelos de GPU (A10, A100, L40S) para determinar el mejor ajuste para el caso de uso.

Puede realizar pruebas de benchmarking con diferentes tipos de GPU. La siguiente tabla proporciona una plantilla. Introduzca valores para X e Y y utilice esos datos para comparar el rendimiento real con el costo.

Tipo de GPU	Latencia media (por 250 segmentos)	Rendimiento (segmentos/seg)	Notas:
A10	X ms	S	Menor costo, adecuado para desarrollo/prueba
A100	X ms	S	Alto rendimiento, mayor costo
L40S	X ms	S	Buen equilibrio entre precio y rendimiento

Recomendación: seleccione la GPU según el tamaño de la carga de trabajo, los requisitos de latencia de SLA y el presupuesto.
Optimización: se ejecuta con FP16/precisión mixta (cuando se admite) para reducir la latencia.

Diseño de clusters de OKE

Diseñe los clusters de OKE para que se adapten a su despliegue.

En este ejemplo, se utiliza una configuración de cluster con dos pools de nodos:

NodePool 1 (nodos de CPU): ejecuta la IU, los trabajadores, RabbitMQ y la base de datos interna
NodePool 2 (nodos de GPU): ejecuta pods de inferencia TorchServe

Asegúrese de que hay suficiente BV en los nodos de GPU.

Etiquete los pools de nodos:

nodepool=cpu en nodos de CPU
nodepool-gpu y nvidia.com/gpu.present=true en nodos de GPU

Asegúrese de que el complemento del plugin del dispositivo OKE NVIDIA esté activado en los nodos de GPU y de que nvidia-smi funcione.

Validar GPU

Para asegurarse de que las GPU estén disponibles tanto para el nodo de OKE como para los pods TorchServe, ejecute los siguientes pasos de validación.

Si ambas comprobaciones se realizan correctamente, confirma que el complemento del plugin del dispositivo NVIDIA está activado y no se necesita ninguna instalación adicional de controlador/software.

Verifique la visibilidad de la GPU en el nodo de trabajador. Por ejemplo:

[opc@oke-cvxkfx3tnkq-nkteldpxwna-s3xcmkmmoda-0 ~]$ nvidia-smi -L
GPU 0: NVIDIA A10 (UUID: GPU-eae0552a-e1d7-7c0f-dc39-886f4eafb439)

Verifique el acceso a la GPU dentro del pod TorchServe. Por ejemplo:

[opc@glvoicepoc-bastion guru]$ kubectl exec -it torchserve-7859b89965-rtqw9 -- /bin/bash
model-server@torchserve-7859b89965-rtqw9:~$ nvidia-smi -L
GPU 0: NVIDIA A10 (UUID: GPU-d6d1852e-6d04-59b9-10de-f68422638fb3)

Distribución de modelo de diseño

Tiene dos opciones para que el modelo .mar esté disponible para los pods de inferencia.

Utilice cubos de OCI Object Storage como reclamación de volumen persistente (PVC) mediante el controlador de Container Storage Interface (CSI).
Transfiera el modelo a OCI File Storage mediante el protocolo de copia segura (SCP) y utilice el sistema de archivos como punto de montaje para una PVC. Por ejemplo:
```
scp -i /path/to/private_key /path/to/local/model.mar
      opc@<file_storage_instance_ip>:/path/to/destination/mount/point/models/
```

Recomendamos OCI Object Storage para mayor simplicidad, o OCI File Storage si tiene varios modelos con actualizaciones frecuentes.

Desplegar TorchServe

Valide el método para desplegar TorchServe.

Los siguientes archivos YAML proporcionan ejemplos de despliegue y configuración.

Exponga el uso del equilibrio de carga de OCI (entrada en OKE a los pods TorchServe).
Proteger con TLS en el equilibrador de carga.
Nunca exponga el puerto de gestión TorchServe (8081) a la red pública de Internet.

Note:

Modifique la sentencia image: del contenedor para que apunte a la ubicación y versión reales del contenedor TorchServe.
multispk_20250121_tts es un nombre de modelo personalizado que se utiliza aquí como ejemplo. Puede sustituirlo por el nombre de su propio modelo y el archivo .mar.

antorcha-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: torchserve
  labels:
    app: torchserve
spec:
  replicas: 1
  selector:
    matchLabels:
      app: torchserve
  template:
    metadata:
      labels:
        app: torchserve
    spec:
      nodeSelector:
        nodepool: torchserve
      tolerations:
        - key: "nvidia.com/gpu"
          operator: "Exists"
          effect: "NoSchedule"
      imagePullSecrets:
        - name: ocir-creds
      containers:
        - name: torchserve
          image: ocir.<your-region>.oci.oraclecloud.com/<tenancy-namespace>/<torchserve_image>:<version>
          ports:
            - containerPort: 8080
            - containerPort: 8081
            - containerPort: 8082
            - containerPort: 7070
            - containerPort: 7071
          env:
            - name: GPUS__DEVICES
              value: "0"
            - name: METRICS_MODE
              value: "logical"  # or "endpoint"
            - name: ENABLE_METRICS_API
              value: "true"  
          resources:
            limits:
              nvidia.com/gpu: 1
          volumeMounts:
            - name: models-volume
              mountPath: /home/model-server/model-store
      volumes:
        - name: models-volume
          persistentVolumeClaim:
            claimName: fss-voiceengine-models

configmap-torchserve.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: config-properties
  namespace: default # Adjust the namespace as necessary
data:
  config.properties: |
    inference_address=http://0.0.0.0:8080
    management_address=http://0.0.0.0:8081
    metrics_address=http://0.0.0.0:8082
    number_of_netty_threads=32
    job_queue_size=1000
    model_store=/home/model-server/model-store
    workflow_store=/home/model-server/wf-store
    install_py_dep_per_model=true
    max_request_size=196605000
    max_response_size=196605000
    default_workers_per_model=1
    job_queue_size=100
    metrics_mode=logical
    load_models=/home/model-server/model-store/multispk_20250121_tts.mar

Configurar escala automática

Configure la escala automática en el nivel de pod y de trabajador.

Configure la escala automática a nivel de pod mediante la escala automática controlada por eventos (KEDA) de Kubernetes con métricas de Prometheus para escalar pods TorchServe según la profundidad de la cola de solicitudes o las métricas personalizadas o el uso de CPU/GPU.

Configurar la escala automática en el nivel de trabajador (TorchServe).

Note:

En los siguientes ejemplos, estamos utilizando TorchServe Model Lifecycle con multispk_20250121_tts.

Registre el modelo. Por ejemplo, ejecute el siguiente comando desde cualquier cliente remoto que pueda acceder al punto final TorchServe a través de HTTP para registrar el archivo .mar con un trabajador inicial.
```
curl -X POST "http://10.0.20.160:8081/models?model_name=multispk_20250121_tts&url=multispk_20250121_tts.mar&initial_workers=1"

Configure initial_workers per model demand.
```
La IP (10.0.20.160) y el puerto (8081) hacen referencia al punto final de la API de gestión de inferencias TorchServe.

Anule el registro de un modelo. Por ejemplo:

curl -X DELETE "http://10.0.20.160:8081/models/multispk_20250121_tts"

Escala/agregación de trabajadores. Por ejemplo, para actualizar el número de trabajadores para el modelo en ejecución:
```
curl -X PUT "http://10.0.20.160:8081/models/multispk_20250121_tts?min_worker=12"
```

Rendimiento de la Prueba

Valide su diseño con pruebas de rendimiento.

En la aplicación cliente, envíe 250 segmentos simultáneos. Capturar:
- Latencia p50/p95
- Rendimiento (segmentos/seg)
- Utilización de GPU (nvidia-smi)
- Tiempo completo de finalización del trabajo

Desde el pod, ejecute:

kubectl exec -it <pod_name> -- nvidia-smi

En la API de métricas TorchServe (puerto 8082), ejecute:
```
curl http://10.0.20.160:8082/metrics
```

Consideraciones para la seguridad y la optimización de costos

Al validar su diseño, tenga en cuenta los factores de seguridad y optimización de costos:

Consideraciones sobre la seguridad:
- Aplique la terminación de TLS en el equilibrador de carga o la entrada.
- Mantenga solo la API de gestión TorchServe interna.
- Utilice OCI Identity and Access Management y los grupos de seguridad de red para limitar el acceso.
Consideraciones de optimización de costos:
- Elija su tipo de GPU en función de un equilibrio entre el acuerdo de nivel de servicio (SLA) y el costo.
- Utilizar la escala programada (reducir el pool de nodos de GPU durante las horas no pico).
- Utilice OCI Object Storage en OCI File Storage si los modelos se actualizan con poca frecuencia.
- La inferencia no siempre se ejecuta 24×7. Comparta GPU no utilizadas con cargas de trabajo de formación durante períodos de inactividad para maximizar la utilización y reducir los costos.