导入 Amazon Bedrock 透传语言模型 API

适用于：所有 API 管理层级

在本文中，将 Amazon Bedrock 语言模型 API 作为直通 API 导入 API 管理实例。 这是 Azure AI 服务以外的推理提供程序上托管的模型的一个示例。 使用 API 管理中的 AI 网关策略和其他功能来简化集成，提高可观测性，并增强对模型终结点的控制。

详细了解如何在 API 管理中管理 AI API：

• Azure API 管理中的 AI 网关功能
• 导入语言模型 API

详细了解 Amazon Bedrock：

• 什么是 Amazon Bedrock？

先决条件

• 现有的 API 管理实例。 创建一个（如果尚未创建）。
• 一个 Amazon Web Services （AWS） 帐户，有权访问 Amazon Bedrock，以及访问一个或多个 Amazon Bedrock 基础模型。 了解详细信息

创建 IAM 用户访问密钥

若要向 Amazon API 网关验证 API 管理实例，需要 AWS IAM 用户的访问密钥。

要使用 AWS 管理控制台生成所需的访问密钥 ID 和机密密钥，请参阅 AWS 文档中的为自己创建访问密钥。

将访问密钥保存在安全的位置。 在下一步中，你将将它们存储为命名值。

将 IAM 用户访问密钥存储为命名值

使用下表中建议的配置安全地将两个 IAM 用户访问密钥存储为 Azure API 管理实例中的机密 命名值 。

使用门户导入基岩 API

将 Amazon Bedrock API 导入 API 管理：

1. 在 Azure 门户，导航到 API 管理实例。

2. 在左侧菜单中的 API 下，选择 API>+ 添加 API。

3. 在 “定义新 API”下，选择 “语言模型 API”。

   

4. 在 “配置 API ”选项卡上：

   1. 输入 API 的显示名称和（可选）说明。

   2. 在默认的 Amazon Bedrock 端点输入以下 URL： https://bedrock-runtime.<aws-region>.amazonaws.com

      示例：https://bedrock-runtime.us-east-1.amazonaws.com

   3. （可选）选择要与 API 关联的一个或多个 产品 。

   4. 在 Path 中，追加 API 管理实例用于访问 LLM API 终结点的路径。

   5. 在 “类型”中，选择“ 创建传递 API”。

   6. 将 Access 键 中的值留空。

   

5. 在其余选项卡上，可以选择配置策略来管理令牌消耗、语义缓存和 AI 内容安全性。 有关详细信息，请参阅 导入语言模型 API。

6. 选择“审核”。

7. 验证设置后，选择“创建”。

API 管理会创建 API 和（可选）策略，以帮助监视和管理 API。

配置策略以对 Amazon Bedrock API 的请求进行身份验证

配置 API 管理策略以对 Amazon Bedrock API 的请求进行签名。 详细了解如何对 AWS API 请求进行签名

以下示例使用之前为 AWS 访问密钥和秘密密钥创建的名为 accesskey 和 secretkey 的值。 将 region 变量设置为 Amazon Bedrock API 的相应值。 示例使用us-east-1作为该区域。

1. 在 Azure 门户，导航到 API 管理实例。

2. 在左侧菜单中的 API 下，选择 API。

3. 选择在上一部分创建的 API。

4. 在左侧菜单中的 “设计”下，选择“所有操作”。

5. 选择“ 入站处理 ”选项卡。

6. 在 入站处理 策略编辑器中，选择 </> 打开策略编辑器。

7. 配置以下策略：

   <policies>
   <inbound>
       <base />
       <set-variable name="now" value="@(DateTime.UtcNow)" />
       <set-header name="X-Amz-Date" exists-action="override">
           <value>@(((DateTime)context.Variables["now"]).ToString("yyyyMMddTHHmmssZ"))</value>
       </set-header>
       <set-header name="X-Amz-Content-Sha256" exists-action="override">
           <value>@{
               var body = context.Request.Body.As<string>(preserveContent: true);
               using (var sha256 = System.Security.Cryptography.SHA256.Create())
               {
                   var hash = sha256.ComputeHash(System.Text.Encoding.UTF8.GetBytes(body));
                   return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
               }
           }</value>
       </set-header>
       <set-header name="Authorization" exists-action="override">
           <value>@{
               var accessKey = "{{accesskey}}";
               var secretKey = "{{secretkey}}";
               var region = "us-east-1";
               var service = "bedrock";
   
               var method = context.Request.Method;
               var uri = context.Request.Url;
               var host = uri.Host;
   
               // Create canonical path
               var path = uri.Path;
               var modelSplit = path.Split(new[] { "model/" }, 2, StringSplitOptions.None);
               var afterModel = modelSplit.Length > 1 ? modelSplit[1] : "";
               var parts = afterModel.Split(new[] { '/' }, 2);
               var model = System.Uri.EscapeDataString(parts[0]);
               var remainder = parts.Length > 1 ? parts[1] : "";
               var canonicalPath = $"/model/{model}/{remainder}";
   
               var amzDate = ((DateTime)context.Variables["now"]).ToString("yyyyMMddTHHmmssZ");
               var dateStamp = ((DateTime)context.Variables["now"]).ToString("yyyyMMdd");
   
               // Hash the payload
               var body = context.Request.Body.As<string>(preserveContent: true);
               string hashedPayload;
               using (var sha256 = System.Security.Cryptography.SHA256.Create())
               {
                   var hash = sha256.ComputeHash(System.Text.Encoding.UTF8.GetBytes(body));
                   hashedPayload = BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
               }
   
               // Create canonical query string
               var queryDict = context.Request.Url.Query;
               var canonicalQueryString = "";
               if (queryDict != null && queryDict.Count > 0)
               {
                   var encodedParams = new List<string>();
                   foreach (var kvp in queryDict)
                   {
                       var encodedKey = System.Uri.EscapeDataString(kvp.Key);
                       var encodedValue = System.Uri.EscapeDataString(kvp.Value.First() ?? "");
                       encodedParams.Add($"{encodedKey}={encodedValue}");
                   }
                   canonicalQueryString = string.Join("&", encodedParams.OrderBy(p => p));
               }
   
               // Create signed headers and canonical headers
               var headers = context.Request.Headers;
               var canonicalHeaderList = new List<string[]>();
   
               // Add content-type if present
               var contentType = headers.GetValueOrDefault("Content-Type", "").ToLowerInvariant();
               if (!string.IsNullOrEmpty(contentType))
               {
                   canonicalHeaderList.Add(new[] { "content-type", contentType });
               }
   
               // Always add host
               canonicalHeaderList.Add(new[] { "host", host });
   
               // Add x-amz-* headers (excluding x-amz-date, x-amz-content-sha256)
               foreach (var header in headers)
               {
                   var name = header.Key.ToLowerInvariant();
                   if (string.Equals(name, "x-amz-content-sha256", StringComparison.OrdinalIgnoreCase) || 
                       string.Equals(name, "x-amz-date", StringComparison.OrdinalIgnoreCase))
                   {
                       continue;
                   }
   
                   if (name.StartsWith("x-amz-"))
                   {
                       var value = header.Value.First()?.Trim();
                       canonicalHeaderList.Add(new[] { name, value });
                   }
               }
               canonicalHeaderList.Add(new[] { "x-amz-content-sha256", hashedPayload });
               canonicalHeaderList.Add(new[] { "x-amz-date", amzDate });
               var canonicalHeadersOrdered = canonicalHeaderList.OrderBy(h => h[0]);
               var canonicalHeaders = string.Join("\n", canonicalHeadersOrdered.Select(h => $"{h[0]}:{h[1].Trim()}")) + "\n";
               var signedHeaders = string.Join(";", canonicalHeadersOrdered.Select(h => h[0]));
   
               // Create and hash the canonical request
               var canonicalRequest = $"{method}\n{canonicalPath}\n{canonicalQueryString}\n{canonicalHeaders}\n{signedHeaders}\n{hashedPayload}";
               string hashedCanonicalRequest = "";
               using (var sha256 = System.Security.Cryptography.SHA256.Create())
               {
                   var hash = sha256.ComputeHash(System.Text.Encoding.UTF8.GetBytes(canonicalRequest));
                   hashedCanonicalRequest = BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
               }
   
               // Build string to sign
               var credentialScope = $"{dateStamp}/{region}/{service}/aws4_request";
               var stringToSign = $"AWS4-HMAC-SHA256\n{amzDate}\n{credentialScope}\n{hashedCanonicalRequest}";
   
               // Sign it using secret key
               byte[] kSecret = System.Text.Encoding.UTF8.GetBytes("AWS4" + secretKey);
               byte[] kDate, kRegion, kService, kSigning;
               using (var h1 = new System.Security.Cryptography.HMACSHA256(kSecret))
               {
                   kDate = h1.ComputeHash(System.Text.Encoding.UTF8.GetBytes(dateStamp));
               }
               using (var h2 = new System.Security.Cryptography.HMACSHA256(kDate))
               {
                   kRegion = h2.ComputeHash(System.Text.Encoding.UTF8.GetBytes(region));
               }
               using (var h3 = new System.Security.Cryptography.HMACSHA256(kRegion))
               {
                   kService = h3.ComputeHash(System.Text.Encoding.UTF8.GetBytes(service));
               }
               using (var h4 = new System.Security.Cryptography.HMACSHA256(kService))
               {
                   kSigning = h4.ComputeHash(System.Text.Encoding.UTF8.GetBytes("aws4_request"));
               }
   
               // Auth header
               string signature; 
               using (var hmac = new System.Security.Cryptography.HMACSHA256(kSigning))
               {
                   var sigBytes = hmac.ComputeHash(System.Text.Encoding.UTF8.GetBytes(stringToSign));
                   signature = BitConverter.ToString(sigBytes).Replace("-", "").ToLowerInvariant();
               }
   
               return $"AWS4-HMAC-SHA256 Credential={accessKey}/{credentialScope}, SignedHeaders={signedHeaders}, Signature={signature}";
           }</value>
       </set-header>
       <set-header name="Host" exists-action="override">
           <value>@(context.Request.Url.Host)</value>
       </set-header>
   </inbound>
   <backend>
       <base />
   </backend>
   <outbound>
       <base />
   </outbound>
   <on-error>
       <base />
   </on-error>
   </policies>
   

调用 Bedrock API

若要通过 API 管理调用 Bedrock API，可以使用 AWS Bedrock SDK。 此示例使用 .NET SDK，但可以使用任何支持 AWS Bedrock API 的语言。

以下示例使用自定义 HTTP 客户端来实例化随附文件中 BedrockHttpClientFactory.cs定义的类。 自定义 HTTP 客户端将请求路由到 API 管理终结点，并在请求标头中包含 API 管理订阅密钥（如有必要）。

using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
using Amazon.Runtime;
using BedrockClient;

// Leave accessKey and secretKey values as empty strings. Authentication to AWS API is handled through policies in API Management.
var accessKey = "";
var secretKey = "";
var credentials = new BasicAWSCredentials(accessKey, secretKey);

// Create custom configuration to route requests through API Management
// apimUrl is the API Management endpoint, such as https://apim-hello-word.azure-api.net/bedrock
var apimUrl = "<api-management-endpoint">;
// Provide name and value for the API Management subscription key header.
var apimSubscriptionHeaderName = "api-key";
var apimSubscriptionKey = "<your-apim-subscription-key>";
var config = new AmazonBedrockRuntimeConfig()
{
    HttpClientFactory = new BedrockHttpClientFactory(apimUrl, apimSubscriptionHeaderName, apimSubscriptionKey),
    // Set the AWS region where your Bedrock model is hosted.
    RegionEndpoint = RegionEndpoint.USEast1
};

var client = new AmazonBedrockRuntimeClient(credentials, config);

// Set the model ID, e.g., Claude 3 Haiku. Find the supported models in Amazon Bedrock documentation: https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html.
var modelId = "us.anthropic.claude-3-5-haiku-20241022-v1:0";

// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";

// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseRequest
{
    ModelId = modelId,
    Messages = new List<Message>
    {
        new Message
        {
            Role = ConversationRole.User,
            Content = new List<ContentBlock> { new ContentBlock { Text = userMessage } }
        }
    },
    InferenceConfig = new InferenceConfiguration()
    {
        MaxTokens = 512,
        Temperature = 0.5F,
        TopP = 0.9F
    }
};

try
{
    // Send the request to the Bedrock runtime and wait for the result.
    var response = await client.ConverseAsync(request);

    // Extract and print the response text.
    string responseText = response?.Output?.Message?.Content?[0]?.Text ?? "";
    Console.WriteLine(responseText);
}
catch (AmazonBedrockRuntimeException e)
{
    Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
    throw;
}

BedrockHttpClientFactory.cs

以下代码实现类以创建自定义 HTTP 客户端，该客户端通过 API 管理将请求路由到 Bedrock API，包括标头中的 API 管理订阅密钥。

using Amazon.Runtime;

namespace BedrockClient
{
    public class BedrockHttpClientFactory : HttpClientFactory
    {
        readonly string subscriptionKey;
        readonly string subscriptionHeaderName;
        readonly string rerouteUrl;

        public BedrockHttpClientFactory(string rerouteUrl, string subscriptionHeaderName, string subscriptionKey)
        {
            this.rerouteUrl = rerouteUrl;
            this.subscriptionHeaderName = subscriptionHeaderName;
            this.subscriptionKey = subscriptionKey;
        }

        public override HttpClient CreateHttpClient(IClientConfig clientConfig)
        {
            var handler = new RerouteHandler(rerouteUrl)
            {
                InnerHandler = new HttpClientHandler()
            };

            var httpClient = new HttpClient(handler);
            httpClient.DefaultRequestHeaders.Add(this.subscriptionHeaderName, this.subscriptionKey);
            return httpClient;
        }
    }

    public class RerouteHandler : DelegatingHandler
    {
        readonly string rerouteUrl;
        readonly string host;

        public RerouteHandler(string rerouteUrl)
        {
            this.rerouteUrl = rerouteUrl;
            this.host = rerouteUrl.Split("/")[2].Split(":")[0];
        }

        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            var originalUri = request.RequestUri;
            request.RequestUri = new Uri($"{this.rerouteUrl}{originalUri.PathAndQuery}");
            request.Headers.Host = this.host;
            return base.SendAsync(request, cancellationToken);
        }
    }
}

相关内容

• Azure API 管理中的 AI 网关功能