Platform For AI:Déployer un OpenClaw dédié avec PAI-EAS en 5 minutes

1. Connectez-vous à la console PAI. Sélectionnez une région en haut de la page. Choisissez ensuite l'espace de travail souhaité et cliquez sur Enter Elastic Algorithm Service (EAS).

2. Dans l'onglet Inference Service, cliquez sur Deploy Service. Dans la section Scenario-based Model Deployment, cliquez sur OpenClaw Deployment.

3. Configurez les paramètres clés suivants :

   Paramètre	Description
   Service Name	Saisissez un nom de service personnalisé. Exemple : openclaw_demo
   Image Configuration	Sélectionnez la version latest.
   Resource Configuration	Sélectionnez un type d'instance CPU selon vos besoins en ressources. La valeur par défaut est ecs.c7a.large.
   Model Settings	Sélectionnez un chemin OSS pour stocker la configuration OpenClaw, par exemple oss://examplebucket/openclaw/.
   VPC	Créez et configurez un VPC, un vSwitch et un groupe de sécurité. Remarque OpenClaw nécessite un accès Internet pour effectuer des recherches sur le Web ou utiliser un navigateur. Nous vous recommandons d'utiliser un VPC avec un accès Internet configuré.

4. Cliquez sur Deploy. Attendez que le statut du service passe à Running. Cela indique que le déploiement a réussi.

1. Créer une passerelle NAT Internet et associer une adresse IP élastique (EIP)

Accédez à la page d'achat de la passerelle NAT – Passerelle NAT Internet.

• Billing Method : Paiement à l'utilisation.

• Region : Sélectionnez la région où se trouve le service EAS.

• Network and Zone : Sélectionnez le VPC configuré pour le service EAS. Ce paramètre ne peut pas être modifié après la création.

• EIP : Sélectionnez une adresse IP élastique (EIP) non associée ou achetez-en une nouvelle.

2. Configurer une entrée SNAT

Accédez à la page Passerelle NAT Internet. Identifiez la passerelle NAT Internet que vous avez créée et, dans la colonne Actions, cliquez sur Configure SNAT . Cliquez ensuite sur Create SNAT Entry.

• SNAT Entry : Sélectionnez VPC Granularity.

• Select EIP : Sélectionnez l'EIP configurée.

Intégration avec DingTalk

1. Créez un bot DingTalk et obtenez son Client ID et son Client Secret. Pour plus d'informations, consultez la documentation Créer un bot OpenClaw en un clic.

2. Dans l'interface WebUI d'OpenClaw, accédez à Configuration > RAW. Dans le bloc de configuration channels, trouvez dingtalk-connector. Saisissez votre Client ID et votre Client Secret, puis enregistrez la configuration.

   Dans le bloc dingtalk-connector, après avoir saisi les valeurs clientId et clientSecret, assurez-vous que enabled est défini sur true. Vous pouvez également ajuster d'autres champs selon vos besoins, tels que separateSessionByConversation, groupSessionScope et sharedMemoryAcrossConversations.

Lark

1. Accédez à la plateforme ouverte Lark. Cliquez sur Create Enterprise Self-Built App, saisissez un nom et une description pour l'application, sélectionnez une icône, puis cliquez sur Create.

2. Dans le volet de navigation de gauche, cliquez sur Credentials and Basic Information. Copiez l'App ID (par exemple, cli_xxx) et l'App Secret.

3. Dans le volet de navigation de gauche, cliquez sur Permission Management. Cliquez sur Batch Import/Export Permissions, collez la configuration JSON suivante, cliquez sur Next, Confirm New Permissions, puis sur Request Activation.

   Afficher la configuration JSON

   {
     "scopes": {
       "tenant": [
         "aily:file:read",
         "aily:file:write",
         "application:application.app_message_stats.overview:readonly",
         "application:application:self_manage",
         "application:bot.menu:write",
         "cardkit:card:write",
         "contact:user.employee_id:readonly",
         "corehr:file:download",
         "docs:document.content:read",
         "event:ip_list",
         "im:chat",
         "im:chat.access_event.bot_p2p_chat:read",
         "im:chat.members:bot_access",
         "im:message",
         "im:message.group_at_msg:readonly",
         "im:message.group_msg",
         "im:message.p2p_msg:readonly",
         "im:message:readonly",
         "im:message:send_as_bot",
         "im:resource",
         "sheets:spreadsheet",
         "wiki:wiki:readonly"
       ],
       "user": ["aily:file:read", "aily:file:write", "im:chat.access_event.bot_p2p_chat:read"]
     }
   }

4. Dans le volet de navigation de gauche, cliquez sur Add App Capabilities. Dans l'onglet Add by Capability, localisez la carte Bot et cliquez sur Configure.

5. Configurer l'abonnement aux événements

   1. Dans l'interface WebUI d'OpenClaw, accédez à Configuration > RAW. Dans la configuration JSON de channels, trouvez feishu, saisissez l'App ID et l'App Secret obtenus précédemment, puis cliquez sur Save. Remarque : Pour des raisons de sécurité, le secret est masqué et affiché sous la forme __OPENCLAW_REDACTED__ après l'enregistrement.

   2. Sur la plateforme ouverte Lark, accédez à la page Events and Callbacks. Dans l'onglet Event Configuration, définissez Subscription Method sur Receive Events via Persistent Connection et cliquez sur Save. Vérifiez que la méthode d'abonnement est bien Persistent Connection (recommandée).

   3. Sur la page de configuration des événements, cliquez sur Add Event, recherchez Accept Message, puis cliquez sur Confirm Add.

6. Sur la page Version Management and Publishing, créez une nouvelle version. Saisissez le Application Version Number et la Update Description, cliquez sur Save, puis soumettez la version pour examen et publication.

   Dans les détails de la version, définissez à la fois Default capability on mobile et Default capability on desktop sur Bot.

7. Ajoutez le bot à vos favoris. Dans l'Workbench, cliquez sur Add to Favorites. Recherchez votre bot et cliquez sur Add. Le bot apparaît dans votre liste de favoris. Double-cliquez dessus pour ouvrir l'interface de chat.

WeCom

1. Créez un bot WeCom et obtenez son Bot ID et son Secret. Pour plus d'informations, consultez la documentation Comment OpenClaw s'intègre à l'intelligence WeCom.

2. Dans l'interface WebUI d'OpenClaw, accédez à Configuration > RAW. Dans le bloc de configuration channels, ajoutez la configuration pour WeCom. Remplacez les valeurs fictives de botId et secret par vos identifiants réels.

       "wecom": {
         "enabled": true,
         "botId": "${WECOM_BOT_ID}",		// Replace with your actual content
         "secret": "${WECOM_SECRET}",	// Replace with your actual content
         "allowFrom": [
           "*"
         ],
         "dmPolicy": "open"
       }

Configurer plusieurs fournisseurs de modèles

Dans l'interface WebUI, accédez à Configuration > RAW. Dans la configuration JSON, localisez le bloc models. Vous pouvez configurer plusieurs fournisseurs de modèles sous providers :

{ 
  // Other configurations omitted ...
  models: {
    mode: 'merge',
    providers: {
      dashscope: {},
      codingplan:{},
      eas:{},
    },
   },
}

providers: {
  codingplan : {
    baseUrl: 'https://coding.dashscope.aliyuncs.com/v1',
    apiKey: '__OPENCLAW_REDACTED__',        // Replace with your actual content
    api: 'openai-completions',
    models: [
      {
        id: 'qwen3.5-plus',
        name: 'qwen3.5-plus',
        reasoning: false,
        input: [
          'text',
          'image',
        ],
        contextWindow: 1000000,
        maxTokens: 65536,
      },
      {
        id: 'qwen3-coder-next',
        name: 'qwen3-coder-next',
        reasoning: false,
        input: [
          'text',
        ],
        contextWindow: 262144,
        maxTokens: 65536,
      },
    ],
  },
},

    providers: {
      eas: {
        baseUrl: 'http://xxxxxx.cn-hangzhou.pai-eas.aliyuncs.com/api/predict/quickstart_deploy_xxxx/v1/',
        apiKey: '__OPENCLAW_REDACTED__',
        api: 'openai-completions',
        models: [
          {
            id: 'Qwen3.5-27B',
            name: 'Qwen3.5-27B',
            api: 'openai-completions',
            reasoning: false,
            input: [
              'text',
            ],
            cost: {
              input: 0,
              output: 0,
              cacheRead: 0,
              cacheWrite: 0,
            },
            contextWindow: 1000000,
            maxTokens: 65536,
          },
        ],
      },
    },

  models: {
    mode: 'merge',
    providers: {
      dashscope: {
        baseUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
        apiKey: '__OPENCLAW_REDACTED__',    // Replace with your actual content
        api: 'openai-completions',
        models: [
          {
            id: 'qwen3.5-plus',
            name: 'qwen3.5-plus',
            reasoning: false,
            input: [
              'text',
              'image',
            ],
            contextWindow: 1000000,
            maxTokens: 65536,
          },
        ],
      },
    },
  },

Configurer le modèle par défaut

Dans l'interface WebUI, accédez à Configuration > RAW. Dans la configuration JSON, localisez le bloc agents.

• agents.defaults.model.primary : Définit le modèle par défaut.

• Nom du modèle : Le format est provider/model, où provider correspond au nom du fournisseur configuré dans providers et model à l'ID du modèle.

  agents: {
    defaults: {
      model: {
        primary: 'dashscope/qwen3.5-plus',
      },
      models: {
        'dashscope/qwen3.5-plus': {},
        'coding/qwen3-coder-next': {},
        'eas/Qwen3.5-27B': {}
      },
    },
  },