Sélection dynamique de back-ends de passerelle d'API sur des éléments de demande

Pour ajouter une sélection de back-end dynamique à une spécification de déploiement d'API à l'aide de la console, procédez comme suit :

1. Créez ou mettez à jour un déploiement d'API à l'aide de la console, sélectionnez l'option Entièrement nouveau, puis saisissez les détails sur la page Informations de base.

   Pour plus d'informations, reportez-vous à Déploiement d'une API sur une passerelle d'API en créant un déploiement d'API et à Mise à jour d'une passerelle d'API.

2. Sur la page Authentification, indiquez comment authentifier les demandes effectuées sur les routages dans le déploiement d'API.

   Pour plus d'informations, reportez-vous à Ajout de l'authentification et de l'autorisation aux déploiements d'API.

3. Sur la page Routages, créez un routage et spécifiez les éléments suivants :

   • Chemin : chemin pour les appels d'API utilisant les méthodes répertoriées vers le service back-end. Le chemin d'accès que vous spécifiez doit remplir les conditions suivantes :

     • Il doit être relatif au préfixe de chemin de déploiement (reportez-vous à Déploiement d'une API sur une passerelle d'API en créant un déploiement d'API).
     • Il doit être précédé d'une barre oblique (/). Il peut également consister en une unique barre oblique.
     • Il peut contenir plusieurs barres obliques (à condition qu'elles ne soient pas adjacentes), ainsi que se terminer par une barre oblique.
     • Il peut inclure des caractères alphanumériques en majuscules et minuscules.
     • Il peut inclure les caractères spéciaux $ - _ . + ! * ' ( ) , % ; : @ & = .
     • Il peut inclure des paramètres et des caractères génériques (reportez-vous à Ajout de paramètres de chemin et de caractères génériques aux chemins de routage).
   • Méthodes : méthodes acceptées par le service back-end. Par exemple, GET, PUT.
4. Sélectionnez Ajouter plusieurs back-ends pour indiquer que les demandes doivent être acheminées vers des back-ends différents, en fonction de la variable de contexte et des règles que vous entrez.
   1. Dans la liste Sélecteur, sélectionnez la table de contexte (contenant la variable de contexte) à utiliser pour déterminer le back-end vers lequel envoyer la demande, comme suit :
      • Authentification : utilisez la valeur d'une demande renvoyée par une fonction d'autorisation ou contenue dans un jeton JWT (et enregistrée dans la table de contexte request.auth) pour déterminer le back-end.
      • En-têtes : utilisez la valeur d'un en-tête de la demande d'origine (et enregistrée dans la table de contexte request.headers) pour déterminer le back-end.
      • Hôte : utilisez le nom de l'hôte auquel la demande d'origine a été envoyée (extrait du champ hôte de l'en-tête d'hôte de la demande et enregistré dans la table de contexte request.host) pour déterminer le back-end.
      • Chemin : utilisez un paramètre de chemin de la demande d'origine (et enregistré dans la table de contexte request.path) pour déterminer le back-end.
      • Paramètres de requête : utilisez la valeur d'un paramètre de requête de la demande d'origine (et enregistrée dans la table de contexte request.query) pour déterminer le back-end.
      • Sous-domaine : utilisez la partie principale du nom d'hôte auquel la demande d'origine a été envoyée (c'est-à-dire la partie du nom d'hôte non spécifiée comme clé et enregistrée dans la table de contexte request.subdomain) pour déterminer le back-end. Notez que la clé est la dernière partie du nom d'hôte à ne pas utiliser.
      • OCID de plan d'utilisation : utilisez l'OCID d'un plan d'utilisation auquel le client d'API est abonné (identifié à partir d'un jeton client dans la demande d'origine et enregistré dans la table de contexte request.usage_plan) pour déterminer le back-end.
   2. En fonction de la table de contexte sélectionnée, saisissez le nom de la clé à utiliser pour déterminer le back-end auquel envoyer la demande.
5. Sélectionnez Définir le back-end pour entrer une règle pour la variable de contexte qui, si elle est remplie, achemine la demande vers le back-end que vous définissez.
6. Entrez les détails de la règle comme suit :
   • Nom : entrez le nom de la règle. Utilisez le nom que vous entrez pour identifier le back-end lorsque vous faites référence aux journaux et aux mesures.
   • Type de correspondance : indiquez dans quelle mesure la valeur de variable de contexte doit correspondre à une valeur que vous entrez pour que la demande soit acheminée vers ce back-end. Sélectionnez Tout si vous voulez que la variable de contexte corresponde exactement à la valeur du champ Valeurs. Sélectionnez Caractère générique si la variable de contexte doit correspondre à une valeur du champ Expression contenant des caractères génériques. La mise en correspondance des valeurs n'est pas sensible à la casse si vous sélectionnez Une des valeurs, et la casse si vous sélectionnez Caractère générique.
   • Valeurs : (affiché si vous avez sélectionné Une valeur parmi dans le champ Type de correspondance.) Indiquez une valeur (ou plusieurs valeurs dans une liste séparée par des virgules) à laquelle la variable de contexte doit correspondre exactement. Notez que la correspondance n'est pas sensible à la casse si vous avez sélectionné Un des éléments. Notez également que les valeurs doivent être uniques au sein d'une règle back-end unique et dans toutes les règles back-end définies pour le déploiement d'API.
   • Expression : (affichée si vous avez sélectionné Caractère générique dans le champ Type de correspondance) Indiquez une valeur commençant par ou se terminant par un caractère générique auquel la variable de contexte doit correspondre. Utilisez le caractère générique * (astérisque) pour indiquer zéro ou plusieurs caractères, et/ou le caractère générique + (signe plus) pour indiquer un ou plusieurs caractères. Notez que la correspondance est sensible à la casse si vous avez sélectionné Caractère générique. Notez que vous ne pouvez pas inclure plusieurs caractères génériques dans une valeur et que vous ne pouvez pas inclure de caractères génériques au milieu d'une valeur. Notez également qu'une configuration de caractères génériques incorrecte peut entraîner l'acheminement des demandes vers des back-ends involontaires.
   • Définir comme valeur par défaut : indiquez si vous souhaitez utiliser le back-end défini pour cette règle si aucune règle back-end ne correspond.
7. Entrez les détails du back-end comme suit :
   1. Dans le champ Type de back-end, sélectionnez HTTP/HTTPS, Oracle Functions, Réponse de stockage ou Déconnexion comme back-end vers lequel acheminer la demande si la règle que vous avez entrée est respectée.
   2. Saisissez les détails du back-end que vous avez sélectionné. Les détails à saisir dépendent du type de back-end que vous avez sélectionné et sont décrits en détail dans :
      • Utilisation de la console pour ajouter des back-ends HTTP ou HTTPS à une spécification de déploiement d'API
      • Utilisation de la console pour ajouter des back-ends de fonction sans serveur à une spécification de déploiement d'API
      • Utilisation de la console pour ajouter des réponses par défaut à une spécification de déploiement d'API
   3. Sélectionnez Définir pour créer le back-end et la règle associée.
8. (Facultatif) Sélectionnez à nouveau Définir le back-end pour définir d'autres back-ends et les règles associées.
9. (Facultatif) Sélectionnez Autre routage pour saisir les détails d'autres routages.
10. Sélectionnez Suivant afin de vérifier les détails saisis pour le déploiement d'API.
11. Sélectionnez Créer ou Enregistrer les modifications pour créer ou mettre à jour le déploiement d'API.
12. (Facultatif) Vérifiez que l'API a été déployée en l'appelant (reportez-vous à Appel d'une API déployée sur une passerelle d'API).

Pour ajouter une sélection de back-end dynamique à une spécification de déploiement d'API dans un fichier JSON, procédez comme suit :

1. A l'aide de l'éditeur JSON de votre choix, créez une spécification de déploiement d'API (reportez-vous à Création d'une spécification de déploiement d'API) au format suivant :

   {
     "requestPolicies": {},
     "routes": [
       {
         "path": "<api-route-path>",
         "methods": ["<method-list>"],
         "backend": {
           "type": "DYNAMIC_ROUTING_BACKEND",
           "selectionSource": {
             "type": "SINGLE",
             "selector": "<context-table-key>"
           },
           "routingBackends": [
             {
               "key": {
                 "type": "<ANY_OF|WILDCARD>",
                 "values": [
                   "<context-variable-value>"
                 ],
                 "isDefault": "<true|false>",
                 "name": "<rule-name>"
               },
               "backend": {
                 "type": "<backend-type>",
                 "<backend-target>": "<identifier>"
               }
             }
           ]
         }
       }
     ]
   }
   

   où :

   • "requestPolicies" indique des stratégies facultatives permettant de contrôler le comportement d'un déploiement d'API. Pour appliquer des stratégies à tous les routages dans une spécification de déploiement d'API, placez les stratégies en dehors de la section routes. Pour appliquer les stratégies uniquement à un routage spécifique, placez les stratégies dans la section routes. Reportez-vous à Ajout de stratégies de demande et de réponse aux spécifications de déploiement d'API.

   • <api-route-path> spécifie un chemin pour les appels d'API utilisant les méthodes répertoriées vers le service back-end. Le chemin d'accès que vous spécifiez doit remplir les conditions suivantes :

     • Il doit être relatif au préfixe de chemin de déploiement (reportez-vous à Déploiement d'une API sur une passerelle d'API en créant un déploiement d'API).
     • Il doit être précédé d'une barre oblique (/). Il peut également consister en une unique barre oblique.
     • Il peut contenir plusieurs barres obliques (à condition qu'elles ne soient pas adjacentes), ainsi que se terminer par une barre oblique.
     • Il peut inclure des caractères alphanumériques en majuscules et minuscules.
     • Il peut inclure les caractères spéciaux $ - _ . + ! * ' ( ) , % ; : @ & = .
     • Il peut inclure des paramètres et des caractères génériques (reportez-vous à Ajout de paramètres de chemin et de caractères génériques aux chemins de routage).
   • <method-list> indique les méthodes acceptées par le service back-end, séparées par des virgules. Par exemple, "GET, PUT".
   • "type": "DYNAMIC_ROUTING_BACKEND" indique que vous voulez sélectionner dynamiquement le back-end en fonction des éléments de la demande.
   • "type": "SINGLE" indique que vous voulez utiliser une seule variable de contexte pour sélectionner dynamiquement le back-end.
   • "selector": "<context-table-key>" indique la table de contexte (et la clé, le cas échéant) à partir de laquelle obtenir la valeur de variable de contexte qui détermine le back-end auquel envoyer la demande, comme suit :
     • request.auth[<key>] Utilisez la valeur d'une réclamation renvoyée par une fonction d'autorisation ou contenue dans un jeton Web JSON (JWT) pour déterminer le back-end. <key> est le nom de la réclamation. Par exemple, request.auth[tenant]
     • request.headers[<key>] Utilisez la valeur d'un en-tête de la demande d'origine pour déterminer le back-end. <key> est le nom de l'en-tête. Par exemple, request.headers[Accept]
     • request.host Utilisez le nom de l'hôte auquel la demande d'origine a été envoyée (extrait du champ hôte de l'en-tête de l'hôte dans la demande) pour déterminer le back-end.
     • request.path[<key>] Utilisez un paramètre de chemin de la demande d'origine pour déterminer le back-end. <key> est le nom du paramètre de chemin. Par exemple, request.path[region]
     • request.query[<key>] Utilisez la valeur d'un paramètre de requête de la demande d'origine pour déterminer le back-end. <key> est le nom du paramètre de requête. Par exemple, request.query[state].
     • request.subdomain[<key>] Utilisez la première partie du nom d'hôte auquel la demande d'origine a été envoyée (la seule partie du nom d'hôte non spécifiée en tant que clé) pour déterminer le back-end. <key> est la dernière partie du nom d'hôte à ne pas utiliser. Par exemple, request.subdomain[example.com]
     • request.usage_plan[id] Utilisez l'OCID d'un plan d'utilisation auquel le client d'API est abonné (identifié à partir d'un jeton client dans la demande d'origine) pour déterminer le back-end.
   • "key": {...} indique la règle à respecter pour envoyer une demande au back-end indiqué par "backend": {…}.
   • "type": "<ANY_OF|WILDCARD>" indique dans quelle mesure la valeur de la variable de contexte identifiée par <context-table-key> doit correspondre à la valeur saisie pour <context-variable-value> afin que la demande soit envoyée au back-end indiqué par "backend": {…}. Indiquez ANY_OF si la valeur de la variable de contexte identifiée par <context-table-key> doit correspondre exactement à la valeur indiquée pour <context-variable-value>. Indiquez WILDCARD si la valeur de la variable de contexte identifiée par <context-table-key> doit correspondre à une valeur contenant des caractères génériques que vous indiquez pour <context-variable-value>. La mise en correspondance des valeurs ne fait pas la distinction entre les majuscules et les minuscules si vous indiquez ANY_OF et la casse si vous indiquez WILDCARD.
   • <context-variable-value> est une valeur qui peut correspondre à la valeur de la variable de contexte identifiée par <context-table-key>. Vous pouvez inclure plusieurs entrées "<context-variable-value>" dans le tableau values:[...], séparées par des virgules. La demande est envoyée au back-end indiqué par "backend": {…} si les valeurs correspondent, comme suit :
     • Si vous avez spécifié "type": "ANY_OF", les valeurs doivent correspondre exactement. Notez que les valeurs doivent être uniques dans une règle de back-end unique et dans toutes les règles de back-end définies pour un déploiement d'API. La correspondance de valeur ne fait pas la distinction entre les majuscules et les minuscules si vous avez spécifié ANY_OF.
     • Si vous avez indiqué "type": "WILDCARD", vous pouvez indiquer une valeur pour <context-variable-value> qui commence par un caractère générique ou se termine par un caractère générique. Utilisez le caractère générique * (astérisque) pour indiquer zéro ou plusieurs caractères, et/ou le caractère générique + (signe plus) pour indiquer un ou plusieurs caractères. Notez que vous ne pouvez pas inclure plusieurs caractères génériques dans une valeur et que vous ne pouvez pas inclure de caractères génériques au milieu d'une valeur. La correspondance de valeur est sensible à la casse si vous avez indiqué WILDCARD. Notez également qu'une configuration de caractères génériques incorrecte peut entraîner l'acheminement des demandes vers des back-ends involontaires.
     Par exemple, si vous souhaitez qu'une demande d'un client API capable d'accepter une réponse xml (comme indiqué dans l'en-tête Accepter de la demande) soit acheminée vers un back-end qui renvoie xml, vous pouvez spécifier :
     • "selector": "request.headers[Accept]"
     • "type": "ANY_OF"
     • "values": ["application/xml"]
   • "isDefault": "<true|false>" est une valeur booléenne facultative (true ou false) indiquant si le back-end doit être utilisé pour cette règle si aucune règle de back-end ne correspond. Si rien n'est indiqué, la valeur par défaut (false) est utilisée.
   • "name": "<rule-name>" indique le nom de la règle. Utilisez ce nom pour identifier le back-end lors de la référence aux journaux et aux mesures.
   • <backend-type> indique le type de service back-end. Valeurs valides : ORACLE_FUNCTIONS_BACKEND, HTTP_BACKEND et STOCK_RESPONSE_BACKEND.
   • <backend-target> et <identifier> spécifient le service back-end. Les valeurs valides pour <backend-target> et <identifier> dépendent de la valeur de <backend-type>, comme suit :
     • Si vous définissez <backend-type> sur ORACLE_FUNCTIONS_BACKEND, remplacez <backend-target> par functionId et <identifier> par l'OCID de la fonction. Par exemple, "functionId": "ocid1.fnfunc.oc1.phx.aaaaaaaaab5b...". Reportez-vous à Ajout d'une fonction dans OCI Functions en tant que back-end de passerelle d'API.
     • Si vous définissez <backend-type> sur HTTP_BACKEND, remplacez <backend-target> par url et <identifier> par l'URL du service back-end. Par exemple, "url": "https://api.weather.gov". Reportez-vous à Ajout d'une URL HTTP ou HTTPS en tant que back-end de passerelle d'API.
     • Si vous définissez <backend-type> sur STOCK_RESPONSE_BACKEND, remplacez <backend-target> et <identifier> par les paires clé-valeur appropriées. Reportez-vous à Ajout de réponses par défaut en tant que back-end de passerelle d'API.

   Par exemple, la spécification de déploiement d'API de base suivante inclut la sélection back-end dynamique qui achemine les demandes en fonction de la valeur du paramètre de requête vehicle-type transmis dans la demande. Si le paramètre de requête vehicle-type a la valeur car, la demande est acheminée vers cars-api.example.com. Si le paramètre de requête vehicle-type a la valeur truck ou minivan, la demande est acheminée vers une fonction sans serveur dans OCI Functions à des fins de traitement. Si la valeur du paramètre de requête vehicle-type n'est ni car, ni truck, ni minivan, la demande est acheminée vers cars-api.example.com par défaut :

   {
     "routes": [
       {
         "path": "/users/{path1*}",
         "methods": [
           "GET",
           "POST",
           "PUT",
           "DELETE"
         ],
         "backend": {
           "type": "DYNAMIC_ROUTING_BACKEND",
           "selectionSource": {
             "type": "SINGLE",
             "selector": "request.query[vehicle-type]"
           },
           "routingBackends": [
             {
               "key": {
                 "type": "ANY_OF",
                 "values": [
                   "cars"
                 ],
                 "isDefault": "true",
                 "name": "car-rule"
               },
               "backend": {
                 "type": "HTTP_BACKEND",
                 "url": "https://cars-api.example.com"
               }
             },
             {
               "key": {
                 "type": "ANY_OF",
                 "values": [
                   "minivan",
                   "truck"
                 ],
                 "name": "truck-minivan-rule"
               },
               "backend": {
                 "type": "ORACLE_FUNCTIONS_BACKEND",
                 "functionId": "ocid1.fnfunc.oc1.phx.aaaaaaaaab______xmq"
               }
             }
           ]
         }
       }
     ]
   }

2. Enregistrez le fichier JSON qui contient la spécification de déploiement d'API.

3. Utilisez la spécification de déploiement d'API lorsque vous créez ou mettez à jour un déploiement d'API en :

   • spécifiant le fichier JSON dans la console lorsque vous sélectionnez l'option Télécharger une API existante,
   • spécifiant le fichier JSON dans une demande adressée à l'API REST d'API Gateway.

   Pour plus d'informations, reportez-vous à Déploiement d'une API sur une passerelle d'API en créant un déploiement d'API.

4. (Facultatif) Assurez-vous que l'API a été déployée en l'appelant (reportez-vous à Appel d'une API déployée sur une passerelle d'API).

Les exemples de cette section utilisent la définition de déploiement d'API et la spécification de déploiement d'API incomplète suivantes dans un fichier JSON :

{
  "displayName": "Marketing Deployment",
  "gatewayId": "ocid1.apigateway.oc1..aaaaaaaab______hga",
  "compartmentId": "ocid1.compartment.oc1..aaaaaaaa7______ysq",
  "pathPrefix": "/marketing",
  "specification": {
    "routes": [
      {
      "path": "/sales",
      "methods": [
        "GET",
        "POST",
        "PUT",
        "DELETE"
      ],
      "backend": {
        "type": "DYNAMIC_ROUTING_BACKEND",
        .
        .
        .
        }
      }
    ]
  },
  "freeformTags": {},
  "definedTags": {}
}

Ces exemples s'appliquent lorsque vous définissez une spécification de déploiement d'API à l'aide des boîtes de dialogue de la console.

{
  "routes": [
    {
      "path": "/sales",
      "methods": [
        "GET",
        "POST",
        "PUT",
        "DELETE"
      ],
      "backend": {
        "type": "DYNAMIC_ROUTING_BACKEND",
        "selectionSource": {
          "type": "SINGLE",
          "selector": "request.host"
        },
        "routingBackends": [
          {
            "key": {
              "type": "ANY_OF",
              "values": [
                "cars.example.com"
              ],
              "isDefault": "true",
              "name": "car-rule"
            },
            "backend": {
              "type": "HTTP_BACKEND",
              "url": "http://cars-api.example.com"
            }
          },
          {
            "key": {
              "type": "ANY_OF",
              "values": [
                "minivans.examplecloud.com",
                "trucks.example.com"
              ],
              "name": "truck-minivan-rule"
            },
            "backend": {
              "type": "ORACLE_FUNCTIONS_BACKEND",
              "functionId": "ocid1.fnfunc.oc1.phx.aaaaaaaaab______xmq"
            }
          }
        ]
      }
    }
  ]
}

{
  "routes": [
    {
      "path": "/sales",
      "methods": [
        "GET",
        "POST",
        "PUT",
        "DELETE"
      ],
      "backend": {
        "type": "DYNAMIC_ROUTING_BACKEND",
        "selectionSource": {
          "type": "SINGLE",
          "selector": "request.subdomain[example.com]"
        },
        "routingBackends": [
          {
            "key": {
              "type": "ANY_OF",
              "values": [
                "cars"
              ],
              "isDefault": "true",
              "name": "car-rule"
            },
            "backend": {
              "type": "HTTP_BACKEND",
              "url": "https://cars-api.example.com"
            }
          },
          {
            "key": {
              "type": "ANY_OF",
              "values": [
                "minivans",
                "trucks"
              ],
              "name": "truck-minivan-rule"
            },
            "backend": {
              "type": "ORACLE_FUNCTIONS_BACKEND",
              "functionId": "ocid1.fnfunc.oc1.phx.aaaaaaaaab______xmq"
            }
          }
        ]
      }
    }
  ]
}

{
  "routes": [
    {
      "path": "/sales",
      "methods": [
        "GET",
        "POST",
        "PUT",
        "DELETE"
      ],
      "backend": {
        "type": "DYNAMIC_ROUTING_BACKEND",
        "selectionSource": {
          "type": "SINGLE",
          "selector": "request.subdomain[example.com]"
        },
        "routingBackends": [
          {
            "key": {
              "type": "ANY_OF",
              "values": [
                "cars",
                "hatchbacks"
              ],
              "name": "car-hatchback-rule"
            },
            "backend": {
              "type": "HTTP_BACKEND",
              "url": "https://${request.subdomain[example.com]}-api.example.com"
            }
          }
        ]
      }
    }
  ]
}

{
  "routes": [
    {
      "path": "/sales",
      "methods": [
        "GET",
        "POST",
        "PUT",
        "DELETE"
      ],
      "backend": {
        "type": "DYNAMIC_ROUTING_BACKEND",
        "selectionSource": {
          "type": "SINGLE",
          "selector": "request.subdomain[example.com]"
        },
        "routingBackends": [
          {
            "key": {
              "type": "WILDCARD",
              "values": [
                "*s"
              ],
              "name": "domestic-rule"
            },
            "backend": {
              "type": "HTTP_BACKEND",
              "url": "https://${request.subdomain[example.com]}-api.example.com"
            }
          }
        ]
      }
    }
  ]
}

{
  "routes": [
    {
      "path": "/sales",
      "methods": [
        "GET",
        "POST",
        "PUT",
        "DELETE"
      ],
      "backend": {
        "type": "DYNAMIC_ROUTING_BACKEND",
        "selectionSource": {
          "type": "SINGLE",
          "selector": "request.usage_plan[id]"
        },
        "routingBackends": [
          {
            "key": {
              "type": "ANY_OF",
              "values": [
                "ocid1.usageplan.oc1..aaaaaaaaab______gap"
              ],
              "name": "free-rule",
              "isDefault": true
            },
            "backend": {
              "type": "HTTP_BACKEND",
              "url": "http://dev.example.com/"
            }
          },
          {
            "key": {
              "type": "ANY_OF",
              "values": [
                "ocid1.usageplan.oc1..aaaaaaaaay______lcf"
              ],
              "name": "premium-rule"
            },
            "backend": {
              "type": "HTTP_BACKEND",
              "url": "http://api.example.com"
            }
          }
        ]
      }
    }
  ]
}

{
  "routes": [
    {
      "path": "/sales",
      "methods": [
        "GET",
        "POST",
        "PUT",
        "DELETE"
      ],
      "backend": {
        "type": "DYNAMIC_ROUTING_BACKEND",
        "selectionSource": {
          "type": "SINGLE",
          "selector": "request.headers[Accept]"
        },
        "routingBackends": [
          {
            "key": {
              "type": "ANY_OF",
              "values": [
                "application/json"
              ],
              "name": "json-rule",
              "isDefault": true
            },
            "backend": {
              "type": "HTTP_BACKEND",
              "url": "http://api.example.com"
            }
          },
          {
            "key": {
              "type": "ANY_OF",
              "values": [
                "application/xml"
              ],
              "name": "xml-rule"
            },
            "backend": {
              "type": "HTTP_BACKEND",
              "url": "http://xml.example.com"
            }
          }
        ]
      }
    }
  ]
}

{
  "routes": [
    {
      "path": "/sales",
      "methods": [
        "GET",
        "POST",
        "PUT",
        "DELETE"
      ],
      "backend": {
        "type": "DYNAMIC_ROUTING_BACKEND",
        "selectionSource": {
          "type": "SINGLE",
          "selector": "request.auth[tenant]"
        },
        "routingBackends": [
          {
            "key": {
              "type": "ANY_OF",
              "values": [
                "tenant-cars"
              ],
              "name": "cars-tenant-rule",
              "isDefault": true
            },
            "backend": {
              "type": "HTTP_BACKEND",
              "url": "http://cars-api.example.com"
            }
          },
          {
            "key": {
              "type": "ANY_OF",
              "values": [
                "tenant-trucks"
              ],
              "name": "trucks-tenant-rule"
            },
            "backend": {
              "type": "HTTP_BACKEND",
              "url": "http://trucks-api.example.com"
            }
          }
        ]
      }
    }
  ]
}

{
  "routes": [
    {
      "path": "/sales",
      "methods": [
        "GET",
        "POST",
        "PUT",
        "DELETE"
      ],
      "backend": {
        "type": "DYNAMIC_ROUTING_BACKEND",
        "selectionSource": {
          "type": "SINGLE",
          "selector": "request.query[vehicle-type]"
        },
        "routingBackends": [
          {
            "key": {
              "type": "ANY_OF",
              "values": [
                "car"
              ],
              "isDefault": "true",
              "name": "car-rule"
            },
            "backend": {
              "type": "HTTP_BACKEND",
              "url": "https://cars-api.example.com"
            }
          },
          {
            "key": {
              "type": "ANY_OF",
              "values": [
                "minivan",
                "truck"
              ],
              "name": "truck-rule"
            },
            "backend": {
              "type": "ORACLE_FUNCTIONS_BACKEND",
              "functionId": "ocid1.fnfunc.oc1.phx.aaaaaaaaab______xmq"
            }
          }
        ]
      }
    }
  ]
}