http.rs 6.83 KB
Newer Older
1
2
3
// SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: Apache-2.0

4
5
use std::sync::Arc;

6
use crate::{
7
    discovery::{ModelManager, ModelWatcher, MODEL_ROOT_PATH},
8
    engines::StreamingEngineAdapter,
9
    entrypoint::{self, input::common, EngineConfig},
10
    http::service::service_v2,
11
    kv_router::KvRouterConfig,
12
13
14
    types::openai::{
        chat_completions::{NvCreateChatCompletionRequest, NvCreateChatCompletionStreamResponse},
        completions::{NvCreateCompletionRequest, NvCreateCompletionResponse},
15
16
    },
};
17
use dynamo_runtime::transports::etcd;
18
use dynamo_runtime::{distributed::DistributedConfig, pipeline::RouterMode};
19
use dynamo_runtime::{DistributedRuntime, Runtime};
20
21

/// Build and run an HTTP service
22
pub async fn run(runtime: Runtime, engine_config: EngineConfig) -> anyhow::Result<()> {
23
    let mut http_service_builder = service_v2::HttpService::builder()
24
        .port(engine_config.local_model().http_port())
25
26
        .enable_chat_endpoints(true)
        .enable_cmpl_endpoints(true)
27
        .enable_embeddings_endpoints(true)
28
        .with_request_template(engine_config.local_model().request_template());
29

30
    let http_service = match engine_config {
31
        EngineConfig::Dynamic(_) => {
32
33
34
35
36
            let distributed_runtime = DistributedRuntime::from_settings(runtime.clone()).await?;
            let etcd_client = distributed_runtime.etcd_client();
            // This allows the /health endpoint to query etcd for active instances
            http_service_builder = http_service_builder.with_etcd_client(etcd_client.clone());
            let http_service = http_service_builder.build()?;
37
38
            match etcd_client {
                Some(ref etcd_client) => {
39
                    let router_config = engine_config.local_model().router_config();
40
                    // Listen for models registering themselves in etcd, add them to HTTP service
41
                    run_watcher(
42
                        distributed_runtime,
43
                        http_service.state().manager_clone(),
44
                        etcd_client.clone(),
45
                        MODEL_ROOT_PATH,
46
                        router_config.router_mode,
47
                        Some(router_config.kv_router_config),
48
49
                    )
                    .await?;
50
51
52
53
54
                }
                None => {
                    // Static endpoints don't need discovery
                }
            }
55
            http_service
56
        }
57
58
59
60
        EngineConfig::StaticRemote(local_model) => {
            let card = local_model.card();
            let router_mode = local_model.router_config().router_mode;

61
            let dst_config = DistributedConfig::from_settings(true); // true means static
62
            let distributed_runtime = DistributedRuntime::new(runtime.clone(), dst_config).await?;
63
            let http_service = http_service_builder.build()?;
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
            let manager = http_service.model_manager();

            let endpoint_id = local_model.endpoint_id();
            let component = distributed_runtime
                .namespace(&endpoint_id.namespace)?
                .component(&endpoint_id.component)?;
            let client = component.endpoint(&endpoint_id.name).client().await?;

            let kv_chooser = if router_mode == RouterMode::KV {
                Some(
                    manager
                        .kv_chooser_for(
                            local_model.display_name(),
                            &component,
                            card.kv_cache_block_size,
                            Some(local_model.router_config().kv_router_config),
                        )
                        .await?,
                )
            } else {
                None
            };

            let chat_engine = entrypoint::build_routed_pipeline::<
                NvCreateChatCompletionRequest,
                NvCreateChatCompletionStreamResponse,
            >(card, &client, router_mode, kv_chooser.clone())
            .await?;
            manager.add_chat_completions_model(local_model.display_name(), chat_engine)?;

            let completions_engine = entrypoint::build_routed_pipeline::<
                NvCreateCompletionRequest,
                NvCreateCompletionResponse,
            >(card, &client, router_mode, kv_chooser)
            .await?;
            manager.add_completions_model(local_model.display_name(), completions_engine)?;
100
101

            http_service
102
103
        }
        EngineConfig::StaticFull { engine, model, .. } => {
104
            let http_service = http_service_builder.build()?;
105
106
            let engine = Arc::new(StreamingEngineAdapter::new(engine));
            let manager = http_service.model_manager();
107
108
            manager.add_completions_model(model.service_name(), engine.clone())?;
            manager.add_chat_completions_model(model.service_name(), engine)?;
109
            http_service
110
        }
111
112
        EngineConfig::StaticCore {
            engine: inner_engine,
113
            model,
114
            ..
115
        } => {
116
            let http_service = http_service_builder.build()?;
117
118
119
120
121
            let manager = http_service.model_manager();

            let chat_pipeline = common::build_pipeline::<
                NvCreateChatCompletionRequest,
                NvCreateChatCompletionStreamResponse,
122
            >(model.card(), inner_engine.clone())
123
            .await?;
124
            manager.add_chat_completions_model(model.service_name(), chat_pipeline)?;
125

126
127
            let cmpl_pipeline = common::build_pipeline::<
                NvCreateCompletionRequest,
128
                NvCreateCompletionResponse,
129
            >(model.card(), inner_engine)
130
            .await?;
131
            manager.add_completions_model(model.service_name(), cmpl_pipeline)?;
132
            http_service
133
        }
134
    };
135
136
137
138
139
140
141
142
    tracing::debug!(
        "Supported routes: {:?}",
        http_service
            .route_docs()
            .iter()
            .map(|rd| rd.to_string())
            .collect::<Vec<String>>()
    );
143
144
145
    http_service.run(runtime.primary_token()).await?;
    runtime.shutdown(); // Cancel primary token
    Ok(())
146
}
147
148
149
150

/// Spawns a task that watches for new models in etcd at network_prefix,
/// and registers them with the ModelManager so that the HTTP service can use them.
async fn run_watcher(
151
    runtime: DistributedRuntime,
152
    model_manager: Arc<ModelManager>,
153
154
    etcd_client: etcd::Client,
    network_prefix: &str,
155
    router_mode: RouterMode,
156
    kv_router_config: Option<KvRouterConfig>,
157
) -> anyhow::Result<()> {
158
    let watch_obj = ModelWatcher::new(runtime, model_manager, router_mode, kv_router_config);
159
160
161
    tracing::info!("Watching for remote model at {network_prefix}");
    let models_watcher = etcd_client.kv_get_and_watch_prefix(network_prefix).await?;
    let (_prefix, _watcher, receiver) = models_watcher.dissolve();
162
163
164
    let _watcher_task = tokio::spawn(async move {
        watch_obj.watch(receiver).await;
    });
165
166
    Ok(())
}