CaraML Docs
CaraML Homepage
  • Introduction
    • What is CaraML?
    • Architecture
      • Feature Store Architecture
      • Models Architecture
      • Routers Architecture
      • Experiments Architecture
      • Pipelines Architecture
    • Core Concepts
      • Models Concepts
      • Router Concepts
      • Experiment Concepts
  • User guides
    • Projects
      • Create a project
      • Managing secrets
    • Feature Store
    • Models
      • Create a Model
        • Custom Model
      • Deploy a Model
        • Deploying a Model Version
        • Severing a Model Version
        • Configuring Transformer
          • Standard Transformer
            • Standard Transformer Expressions
            • Standard Transformer UPI
          • Custom Transformer
        • Redeploying a Model Version
      • Deleting a Model
      • Configuring Alerts
      • Batch Prediction
      • Model Schema
      • Model Observability
    • Routers
      • Creating a Router
        • Configure general settings
        • Configure routes
        • Configure traffic rules
        • Configure autoscaling
        • Configure experiment engine
        • Configure enricher
        • Configure ensembler
        • Configure logging
      • Viewing Routers
        • Configuration
        • History
        • Logs
        • More actions
      • Edit Routers
      • Monitoring router
        • Monitor Router Performance
        • Configure Alerts
      • Undeploying Router
      • Redeploying Router
        • Redeploy undeployed router
        • Redeploy version from history
        • Redeploy version from version details page
      • Deleting Router
        • Deleting router versions
        • Deleting router versions from details page
        • Deleting routers
      • Deleting Emsemblers
        • Delete an Ensembler without related entity
        • Delete an Ensembler with active entities
        • Delete an Ensembler with inactive entities
    • Experiments
      • View Experiment Settings
      • Modify Experiment Settings
      • Creating Experiments
      • Viewing Experiments
      • Modifying Experiments
      • Running Experiments
      • Monitoring Experiments
      • Creating Treatments
      • Viewing Treatments
      • Modifying Treatments
      • Creating Segments
      • Viewing Segments
      • Modifying Segments
      • Creating Custom Segmenters
      • Viewing Custom Segmenters
      • Modifying Custom Segmenters
    • Pipelines
  • Tutorial and Examples
    • Model Sample Notebooks
      • Deploy Standard Models
      • Deploy PyFunc Model
      • Using Transformers
      • Run Batch Prediction Job
      • Others examples on Models
    • Router Examples
    • Feature Store Examples
    • Pipeline Examples
    • Performing load test in CaraML
    • Best practice for CaraML
  • CaraML SDK
    • Feature Store SDK
    • Models SDK
    • Routers SDK
    • Pipeline SDK
  • Troubleshooting and FAQs
    • CaraML System FAQ
    • Models FAQ
      • System Limitations
      • Troubleshooting Deployment Errors
      • E2E Test
    • Routers FAQ
    • Experiments FAQ
    • Feature Store FAQ
    • Pipelines FAQ
    • CaraML Error Messages
  • Deployment Guide
    • Deploying CaraML
      • Local Development
    • Monitoring and alerting
      • Configure a monitoring backend
      • Configure an alerting backend
    • Prerequisites and Dependencies
    • System Benchmark results
    • Experiment Treatment Service
  • Release Notes
    • CaraML Release Notes
Powered by GitBook
On this page
  • No Enricher
  • Docker
  • External Enricher
  1. User guides
  2. Routers
  3. Creating a Router

Configure enricher

PreviousConfigure experiment engineNextConfigure ensembler

Last updated 11 months ago

This step is optional and the default behaviour will send the original request to the configured routes.

The Turing enricher has the ability to perform arbitrary transformations on the incoming request for feature enrichment. It can deploy any enricher image (implemented by a user) and integrate it with the rest of the system. Currently, there are 3 options available - no enricher, Docker and an external enricher that is coming soon.

No Enricher

Original request will be sent to configured routes without enrichment.

Docker

Turing will deploy specified Docker image as a pre-processor and will send original request to it for enrichment.

The request to the enricher is constructed from the request headers to the Router, and an identifier Turing-Req-Id that is uniquely assigned to each request received by the Router.

To configure a Docker enricher, there are 3 sections to fill.

Configure the Docker Container. There are 4 required inputs.

Docker Image: The image is formed of 2 parts. Select the registry to where your image is stored. Following that, enter the name of the image.

Endpoint: Relative URL endpoint of the enricher.

Port: Port number exposed by your container.

Timeout: Request timeout, which when exceeded, the request to enricher will be terminated

Service Account: You can optionally mount a service account for your Docker deployment.

Configure any environment variables required by the Docker container. You need to input the name and corresponding value of each input.

Configure the resources required for the enricher. There are 3 required inputs, with default values provided for each.

CPU: Total amount of CPU available for your enricher.

Memory: Total amount of RAM available for your enricher.

Min/Max Replicas: Min/max number of replicas for your enricher. Scaling of the enricher based on traffic volume will be automatically done for you.

CPU Limit: By default, Turing determines the CPU limits of all deployed components using platform-level configured values. These CPU limits is calculated as a factor of the user-defined CPU request value for each component (e.g. 2x of the CPU request value). However, you can override this platform-level configured value by setting this value explicitly on the UI (as seen above) or via the SDK.

Optionally, modify the autoscaling policy on the enricher.

Metric: The autoscaling metric to monitor. Currently, 4 metrics are supported - Concurrency, RPS, CPU and Memory.

Target: The target value of the chosen metric for each replica, after which autoscaling should be triggered.

External Enricher

Coming soon.