Object Storage Service:Model broadcasting

Option 1 : Acheter et configurer Tair (recommandé)

Tair est le service de base de données cloud entièrement géré d'Alibaba Cloud, compatible avec le protocole Redis.

1. Créez une instance Tair (version 6.0 ou ultérieure, avec les spécifications minimales). Vue d'ensemble du guide de démarrage rapide.

2. Configurez une liste d'autorisation afin que les nœuds d'inférence puissent accéder à l'instance Tair.

3. Notez l'Connection Address, le Port Number, le Username et le Password pour la configuration de la diffusion de modèles.

Option 2 : Déployer un service Redis autonome

Vous pouvez également déployer Redis dans un cluster Kubernetes.

Le fichier YAML suivant déploie Redis avec une authentification ACL.

1. Créez un fichier de configuration ACL et générez un secret Kubernetes.

   # Create ACL content
   cat > users.acl << EOF
   user default off -@all
   user Username on >Password ~* &* +@all
   EOF
   
   # Create a secret
   kubectl create secret generic redis-acl-secret \
     --from-file=users.acl \
     --dry-run=client -o yaml | kubectl apply -f -

   Remarque

   Remplacez Username et Password par votre nom d'utilisateur et votre mot de passe réels.

2. Appliquez le fichier YAML suivant pour déployer Redis.

   # redis-service.yaml
   apiVersion: v1
   kind: Service
   metadata:
     name: redis
   spec:
     selector:
       app: model-redis
     ports:
       - protocol: TCP
         port: 6379
         targetPort: 6379
   
   ---
   # redis-deployment.yaml
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: model-redis-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: model-redis
     template:
       metadata:
         labels:
           app: model-redis
       spec:
         containers:
         - name: redis
           image: mirrors-ssl.aliyuncs.com/redis:8.4.0
           ports:
           - containerPort: 6379
           command: ["redis-server"]
           args:
           - "--aclfile"
           - "/etc/redis/users.acl"
           - "--maxmemory"
           - "900mb"
           - "--maxmemory-policy"
           - "volatile-lru"
           - "--save"
           - ""
           - "--appendonly"
           - "no"
           - "--loglevel"
           - "notice"
           resources:
             requests:
               memory: "1Gi"
               cpu: "100m"
             limits:
               memory: "1Gi"
               cpu: "200m"
           volumeMounts:
           - name: acl-config
             mountPath: /etc/redis/users.acl
             subPath: users.acl
         volumes:
         - name: acl-config
           secret:
             secretName: redis-acl-secret

3. Déployez le service Redis.

   kubectl apply -f redis-service.yaml

{
  ...
  "broadcast": {
    "enableBroadcast": true,
    "tenant": "${P2P_KEY_PREFIX}",
    "db": {
      "host": "${P2P_REDIS_HOST}",
      "port": 6379,
      "username": "${P2P_REDIS_USERNAME}",
      "password": "${P2P_REDIS_PASSWD}"
    }
  },
  "bindPort": 19898
  ...
}

Test dans la région de Pékin

Environnement de test

Taille de cache illimitée

• Un seul flux vers la source est utilisé ; tous les autres transferts de données passent par P2P, ce qui minimise la pression sur la bande passante OSS.

• Le temps moyen de préparation du modèle reste proche de O(1) quel que soit le nombre de nœuds, ce qui démontre une excellente mise à l'échelle horizontale.

Taille de cache limitée

Le temps de préparation du modèle a été testé pour 1, 10, 50 et 100 nœuds démarrant simultanément, avec une taille de cache illimitée et limitée à 100, 60, 40, 20 et 0 Go.

• La diffusion de modèles fonctionne comme prévu pour toutes les limites de taille de cache.

• L'impact de la limite de cache est cohérent quel que soit le niveau de concurrence. Un cache de 40 Go ou plus n'a aucun effet significatif sur le temps de préparation du modèle. Les performances diminuent sensiblement à 20 Go ou moins.

Test dans la région d'Ulanqab

Environnement de test

Le temps de préparation du modèle a été testé pour 1, 10, 50 et 100 nœuds démarrant simultanément, avec une taille de cache illimitée et limitée à 60 et 0 Go.

Même avec une bande passante de téléchargement OSS limitée, la diffusion de modèles maintient une excellente mise à l'échelle horizontale et minimise la pression sur la bande passante de la source.