Tous les produits
Search

Ce produit

    Alibaba Cloud Service Mesh:Accélérer le service d'IA avec KServe, Fluid et ASM

    Centre de documentation

    Alibaba Cloud Service Mesh:Accélérer le service d'IA avec KServe, Fluid et ASM

    Dernière mise à jour :Aug 11, 2026

    KServe, anciennement KFServing, est un moteur de service et d'inférence de modèles d'IA pour les environnements cloud natifs. Il prend en charge la mise à l'échelle automatique (autoscaling), la réduction à zéro (scale-to-zero) et le déploiement canari. Alibaba Cloud Service Mesh (ASM) s'intègre au composant Knative Serving et propose KServe sur ASM, permettant une configuration en un clic de KServe pour le service d'IA. Fluid est un orchestrateur et accélérateur de datasets distribués, open source et natif Kubernetes, conçu pour les applications gourmandes en données, telles que les charges de travail Big Data et IA. Vous pouvez intégrer directement KServe sur ASM à Fluid afin d'accélérer le chargement des modèles. Cette rubrique explique comment utiliser KServe et Fluid sur ASM pour accélérer l'accès aux données lors du service d'IA.

    Prérequis

    • Ajoutez un cluster Kubernetes à une instance ASM. Pour plus d'informations, consultez les rubriques Créer une instance ASM et Ajouter un cluster à une instance ASM.

      Remarque

      • L'instance ASM doit être en version 1.17 ou ultérieure. Pour savoir comment mettre à niveau une instance, consultez la rubrique Mettre à niveau une instance ASM.

      • Exigences relatives au cluster Kubernetes :

        • Le cluster ACK doit être en version 1.22 ou ultérieure. Pour plus d'informations, consultez les rubriques Créer un cluster ACK managé ou Mettre à niveau un cluster ACK. Si vous utilisez une unité de traitement graphique (GPU) pour exécuter des services d'IA, le cluster ACK doit contenir des nœuds accélérés par GPU, tels que ecs.gn6i-c16g1.4xlarge.

        • Le cluster ACK Serverless doit être en version 1.18 ou ultérieure et le composant CoreDNS doit être installé. Pour plus d'informations, consultez les rubriques Créer un cluster ACK Serverless et Gérer les composants.

    • Activez l'accès aux ressources Istio via l'API Kubernetes du cluster du plan de données pour l'instance ASM. Pour plus d'informations, consultez la rubrique Utiliser l'API Kubernetes d'un cluster du plan de données pour accéder aux ressources Istio.

    • Créez une passerelle d'entrée (ingress gateway) pour le cluster. Cette rubrique utilise une passerelle d'entrée ASM nommée ingressgateway qui expose les ports 80 et 443. Pour plus d'informations, consultez la rubrique Créer une passerelle d'entrée.

    • Déployez le composant Knative Serving dans le cluster ACK ou le cluster ACK Serverless et activez Knative sur ASM. Pour plus d'informations, consultez la rubrique Utiliser Knative sur ASM pour déployer une application serverless.

      Déployer Knative Serving

      • Pour déployer Knative dans un cluster ACK, consultez la rubrique Déployer Knative.

      • Pour déployer Knative dans un cluster ACK Serverless, consultez la rubrique Activer Knative.

      Remarque

      Si vous sélectionnez Kourier comme passerelle de service lors d'un déploiement Knative en un clic, désinstallez le composant Kourier une fois l'installation terminée. Pour ce faire, accédez à la page Clusters dans la console ACK, cliquez sur le cluster cible, puis choisissez Applications > Knative. Une fois Kourier sélectionné comme passerelle et les composants installés, accédez à l'onglet Components et désinstallez le composant Kourier dans la section Add-on Components.

      Activer Knative sur ASM

      1. Connectez-vous à la console ASM. Dans le volet de navigation de gauche, choisissez Service Mesh > Mesh Management.

      2. Sur la page Mesh Management , cliquez sur le nom de l'instance ASM. Dans le volet de navigation de gauche, choisissez Ecosystem > Knative on ASM.

      3. Sur la page Knative on ASM, cliquez sur Enable Knative on ASM.

    • Activez Object Storage Service (OSS) et créez un bucket. Pour plus d'informations, consultez les rubriques Activer OSS et Créer des buckets.

    Étape 1 : Activer KServe sur ASM

    1. Connectez-vous à la console ASM. Dans le volet de navigation de gauche, choisissez Service Mesh > Mesh Management.

    2. Sur la page Mesh Management , cliquez sur le nom de l'instance ASM. Dans le volet de navigation de gauche, choisissez Ecosystem > KServe on ASM.

    3. Sur la page KServe on ASM, activez ou désactivez l'option Automatically install the CertManager component in the cluster , puis cliquez sur Enable KServe on ASM.

      cert-manager est un système de gestion du cycle de vie des certificats qui automatise leur délivrance et leur déploiement. KServe sur ASM dépend du composant cert-manager. Lors de l'installation de KServe, le composant cert-manager est automatiquement installé.

      • Si cert-manager n'est pas installé dans votre cluster, activez l'option Automatically install the CertManager component in the cluster .

      • Si cert-manager est déjà installé dans votre cluster du plan de données, désactivez l'option Automatically install the CertManager component in the cluster .

    Étape 2 : Installer Fluid et accélérer la mise en cache

    1. Déployez le composant ack-fluid, en version 0.9.10 ou ultérieure, dans votre cluster.

      • Si votre cluster du plan de données est un cluster ACK, installez la suite AI cloud native et déployez le composant ack-fluid.

        Remarque

        Si Fluid open source est installé, désinstallez-le avant de déployer le composant ack-fluid.

        • Si vous n'avez pas installé la suite AI cloud native, activez l'option Fluid Data Acceleration lors de l'installation. Pour plus d'informations, consultez la rubrique Déployer la suite AI cloud native.

        • Si vous avez déjà installé la suite AI cloud native, connectez-vous à la console ACK. Accédez à la page Applications > Cloud-native AI Suite et déployez ack-fluid.

      • Si votre cluster du plan de données est un cluster ACK Serverless , déployez le composant ack-fluid. Pour plus d'informations, consultez la section Déployer les composants du plan de contrôle de Fluid de la rubrique Accélérer l'accès aux données pour les applications Job .

    2. Préparez un modèle d'IA et téléchargez-le dans un bucket OSS.

      1. Préparez les données issues de votre modèle d'IA entraîné.

        Cette rubrique utilise le modèle BLOOM, un grand modèle de langage (LLM) open source basé sur Transformer et construit sur PyTorch, à titre d'exemple. Pour plus d'informations sur les données du modèle, consultez le site Hugging Face .

      2. Téléversez les fichiers de données du modèle téléchargés dans un bucket OSS et notez le chemin de stockage.

        Le format du chemin de stockage est oss://{bucket}/{path} . Par exemple, si vous créez un bucket nommé fluid-demo et téléversez tous les fichiers de données du modèle dans le répertoire models/bloom à l'intérieur, le chemin de stockage est oss://fluid-demo/models/bloom .

        Remarque

        Vous pouvez utiliser ossutil, un outil client fourni par OSS, pour téléverser des données. Pour plus d'informations, consultez la rubrique Installer ossutil .

    3. Créez un namespace pour le cache Fluid et le service d'IA, et configurez les permissions d'accès à OSS.

      1. Utilisez kubectl pour vous connecter au cluster du plan de données. Pour plus d'informations, consultez la rubrique Se connecter à un cluster ACK avec kubectl .

      2. Exécutez la commande suivante pour créer le namespace kserve-fluid-demo destiné au cache Fluid et au service d'IA KServe :

        kubectl create ns kserve-fluid-demo

      3. Créez un fichier nommé oss-secret.yaml avec le contenu suivant.

        Les champs fs.oss.accessKeyId et fs.oss.accessKeySecret correspondent respectivement à l'ID AccessKey et au secret AccessKey permettant d'accéder à OSS.

        apiVersion: v1
kind: Secret
metadata:
  name: access-key
stringData:
  fs.oss.accessKeyId: xxx # Replace with an Alibaba Cloud AccessKey ID that can access OSS.
  fs.oss.accessKeySecret: xxx # Replace with the corresponding AccessKey secret.

      4. Exécutez la commande suivante pour appliquer le Secret et configurer les identifiants d'accès à OSS :

        kubectl apply -f oss-secret.yaml -n kserve-fluid-demo

    4. Déclarez les données du modèle d'IA auxquelles Fluid doit accéder.

      Soumettez une ressource personnalisée (CR) Dataset et une CR JindoRuntime. La CR Dataset définit l'URL des données dans le système de stockage externe, tandis que la CR JindoRuntime décrit le système de mise en cache et sa configuration.

      1. Créez un fichier nommé oss-jindo.yaml avec le contenu suivant.

        Dans la CR Dataset, remplacez oss://{bucket}/{path} par le chemin de stockage des données du modèle que vous avez noté à l'étape 2.b , et remplacez {endpoint} par le point de terminaison OSS. Pour connaître les points de terminaison OSS selon les régions, consultez la rubrique Régions et points de terminaison .

        oss-jindo.yaml

        apiVersion: data.fluid.io/v1alpha1
kind: Dataset
metadata:
  name: oss-data
spec:
  mounts:
  - mountPoint: "oss://{bucket}/{path}" # Replace with the storage path of the model data files.
    name: bloom-560m
    path: /bloom-560m
    options:
      fs.oss.endpoint: "{endpoint}"  # Replace with the actual OSS endpoint.
    encryptOptions:
      - name: fs.oss.accessKeyId
        valueFrom:
          secretKeyRef:
            name: access-key
            key: fs.oss.accessKeyId
      - name: fs.oss.accessKeySecret
        valueFrom:
          secretKeyRef:
            name: access-key
            key: fs.oss.accessKeySecret
  accessModes:
    - ReadOnlyMany
---
apiVersion: data.fluid.io/v1alpha1
kind: JindoRuntime
metadata:
  name: oss-data
spec:
  replicas: 2
  tieredstore:
    levels:
      - mediumtype: SSD
        volumeType: emptyDir
        path: /mnt/ssd0/cache
        quota: 50Gi
        high: "0.95"
        low: "0.7"
  fuse:
    properties:
      fs.jindofsx.data.cache.enable: "true"
    args:
      - -okernel_cache
      - -oro
      - -oattr_timeout=7200
      - -oentry_timeout=7200
      - -ometrics_port=9089
    cleanPolicy: OnDemand

      2. Exécutez la commande suivante pour déployer les CR Dataset et JindoRuntime :

        kubectl create -f oss-jindo.yaml -n kserve-fluid-demo

      3. Exécutez la commande suivante pour vérifier l'état de déploiement du Dataset et de JindoRuntime :

        kubectl get jindoruntime,dataset -n kserve-fluid-demo

        Résultat attendu :

        NAME                                  MASTER PHASE   WORKER PHASE   FUSE PHASE   AGE
jindoruntime.data.fluid.io/oss-data   Ready          Ready          Ready        3m

NAME                             UFS TOTAL SIZE   CACHED   CACHE CAPACITY   CACHED PERCENTAGE   PHASE   AGE
dataset.data.fluid.io/oss-data   3.14GiB          0.00B    100.00GiB        0.0%                Bound   3m

        Le résultat indique que le champ PHASE du Dataset est défini sur Bound et que le champ FUSE PHASE de JindoRuntime est défini sur Ready , ce qui signifie que le déploiement a réussi.

    5. Préchargez les données avec Fluid pour améliorer les performances d'accès.

      1. Créez un fichier nommé oss-dataload.yaml avec le contenu suivant :

        apiVersion: data.fluid.io/v1alpha1
kind: DataLoad
metadata:
  name: oss-dataload
spec:
  dataset:
    name: oss-data
    namespace: kserve-fluid-demo
  target:
    - path: /bloom-560m
      replicas: 2

      2. Exécutez la commande suivante pour déployer la CR DataLoad et précharger les données :

        kubectl create -f oss-dataload.yaml -n kserve-fluid-demo

      3. Exécutez la commande suivante pour vérifier la progression du préchargement des données :

        kubectl get dataload -n kserve-fluid-demo

        Résultat attendu :

        NAME           DATASET    PHASE      AGE     DURATION
oss-dataload   oss-data   Complete   1m      45s

        Le résultat indique que le préchargement des données prend environ 45s . Vous devez attendre la fin du processus.

    Étape 3 : Déployer le service d'inférence

    1. Créez un fichier nommé oss-fluid-isvc.yaml en fonction du type de votre cluster.

      Cluster ACK

      apiVersion: "serving.kserve.io/v1beta1"
kind: "InferenceService"
metadata:
  name: "fluid-bloom"
spec:
  predictor:
    timeout: 600
    minReplicas: 0
    containers:
      - name: kserve-container
        image: registry.cn-hangzhou.aliyuncs.com/acs/kserve-fluid:bloom-gpu
        resources:
          limits:
            cpu: "12"
            memory: 48Gi
            nvidia.com/gpu: 1 # If you use GPUs, specify the number required. Otherwise, you can omit this field.
          requests:
            cpu: "12"
            memory: 48Gi
        env:
          - name: STORAGE_URI
            value: "pvc://oss-data/bloom-560m"
          - name: MODEL_NAME
            value: "bloom"
            # Set this parameter to "True" if you use GPUs. Otherwise, set it to "False".
          - name: GPU_ENABLED
            value: "True"

      Cluster ACK Serverless

      apiVersion: "serving.kserve.io/v1beta1"
kind: "InferenceService"
metadata:
  name: "fluid-bloom"
  labels:
    alibabacloud.com/fluid-sidecar-target: "eci"
  annotations:
    k8s.aliyun.com/eci-use-specs : "ecs.gn6i-c16g1.4xlarge"  # Replace with the desired ECS instance type.
    knative.aliyun.com/reserve-instance-eci-use-specs: "ecs.gn6i-c16g1.4xlarge"   # Replace with the desired ECS instance type.
spec:
  predictor:
    timeout: 600
    minReplicas: 0
    containers:
      - name: kserve-container
        image: registry.cn-hangzhou.aliyuncs.com/acs/kserve-fluid:bloom-gpu
        resources:
          limits:
            cpu: "12"
            memory: 48Gi
          requests:
            cpu: "12"
            memory: 48Gi
        env:
          - name: STORAGE_URI
            value: "pvc://oss-data/bloom-560m"
          - name: MODEL_NAME
            value: "bloom"
            # Set this parameter to "True" if you use GPUs. Otherwise, set it to "False".
          - name: GPU_ENABLED
            value: "True"
      Remarque

      • Cet exemple utilise un grand modèle de langage et demande des ressources importantes (12 cœurs CPU, 48 Go de mémoire). Ajustez le champ resources dans la configuration InferenceService en fonction de la charge de travail de votre cluster.

      • Cet exemple définit le champ image sur l'image d'exemple registry.cn-hangzhou.aliyuncs.com/acs/kserve-fluid:bloom-gpu . Cette image fournit des interfaces pour le chargement du modèle et l'inférence. Consultez le code de cette image d'exemple dans la communauté open source KServe pour personnaliser votre propre image. Pour plus d'informations, consultez les exemples Docker de KServe.

    2. Exécutez la commande suivante pour déployer le service d'inférence du modèle d'IA :

      kubectl create -f oss-fluid-isvc.yaml -n kserve-fluid-demo

    3. Exécutez la commande suivante pour vérifier l'état de déploiement du service d'inférence du modèle d'IA :

      kubectl get inferenceservice -n kserve-fluid-demo

      Résultat attendu :

      NAME          URL                                                READY   PREV   LATEST   PREVROLLEDOUTREVISION   LATESTREADYREVISION           AGE
fluid-bloom   http://fluid-bloom.kserve-fluid-demo.example.com   True           100                              fluid-bloom-predictor-00001   2d

      Lorsque le champ READY affiche True , le service d'inférence du modèle d'IA a été déployé avec succès.

    Étape 4 : Accéder au service d'inférence

    1. Obtenez l'adresse de la passerelle d'entrée ASM.

      1. Connectez-vous à la console ASM. Dans le volet de navigation de gauche, choisissez Service Mesh > Mesh Management.

      2. Sur la page Mesh Management , cliquez sur le nom de l'instance ASM. Dans le volet de navigation de gauche, choisissez ASM Gateways > Ingress Gateway.

      3. Dans la section Service Address de la passerelle ingressgateway, affichez et copiez l'adresse du service de la passerelle ASM.

    2. Exécutez la commande suivante pour accéder au service d'inférence du modèle d'IA d'exemple, bloom . Remplacez {ASM gateway service address} par l'adresse de la passerelle d'entrée ASM obtenue à l'étape précédente .

      curl -v -H "Content-Type: application/json" -H "Host: fluid-bloom.kserve-fluid-demo.example.com" "http://{ASM gateway service address}:80/v1/models/bloom:predict" -d '{"prompt": "It was a dark and stormy night", "result_length": 50}'

      Résultat attendu :

      *   Trying xxx.xx.xx.xx :80...
* Connected to xxx.xx.xx.xx  (xxx.xx.xx.xx ) port 80 (#0)
> POST /v1/models/bloom:predict HTTP/1.1
> Host: fluid-bloom-predictor.kserve-fluid-demo.example.com
> User-Agent: curl/7.84.0
> Accept: */*
> Content-Type: application/json
> Content-Length: 65
> 
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< content-length: 227
< content-type: application/json
< date: Thu, 20 Apr 2023 09:49:00 GMT
< server: istio-envoy
< x-envoy-upstream-service-time: 1142
< 
{
  "result": "It was a dark and stormy night, and the wind was blowing in the\ndirection of the west. The wind was blowing in the direction of the\nwest, and the wind was blowing in the direction of the west. The\nwind was"
}
* Connection # 0 to host xxx.xx.xx.xx left intact

      Le résultat montre que le service d'inférence du modèle d'IA a généré avec succès du texte à partir de l'entrée d'exemple et a renvoyé un résultat d'inférence.

    Rubriques connexes