文档中心

数据智能体 DataAgent（私有化）

账号中心

账号中心接入流程

本文档介绍账号中心 OpenAPI 的鉴权方式、Access Key 创建方式，以及多语言调用示例，帮助调用方快速完成联调。

鉴权方式

账号中心 OpenAPI 使用 AWS Sig v4 签名鉴权。
发起请求前，调用方需要先准备以下信息：

字段	说明
Access Key	「API凭证」中的 AccessKey ID
Secret Key	「API凭证」中，与 AccessKey ID 配套的 Secret
Service	固定为 `minibasebe`
Region	固定为 `pri`

创建 Access Key

前往控制台，在页面右上角单击用户头像，然后进入「系统配置 > 访问控制 > API 凭证」创建 Access Key。

注意

请妥善保存创建后的 AccessKey ID 和 AccessKey Secret，避免泄露到代码仓库或聊天记录中。

调用约定

请求示例中使用的目标地址如下：

http://your-api-domain.com/{api_path}

示例中的公共约定如下：

配置项	取值
请求方法	`POST`
自定义 Query 参数	`test_query=test`
自定义 Header 参数	`X-Custom-Header: somevalue`
自定义 Body 请求体	`{"body":"test"}`

Python 3 示例

先安装依赖：

pip install "botocore~=1.21.64"

代码示例：

import json

from botocore.auth import SigV4Auth
from botocore.awsrequest import AWSRequest
from botocore.credentials import Credentials
from botocore.httpsession import URLLib3Session

credential = Credentials("<access_key>", "<secret_key>")
siger = SigV4Auth(credential, "minibasebe", "pri")
session = URLLib3Session()

body = {"body": "test"}
req = AWSRequest(
    method="POST",
    url="http://your-api-domain.com/{api_path}",
    headers={"X-Custom-Header": "somevalue"},
    data=json.dumps(body),
    params={"test_query": "test"},
)

siger.add_auth(req)

resp = session.send(req.prepare())
print(resp.headers)
print(resp.text)

Java 示例

pom.xml

<dependencies>
    <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>apache-client</artifactId>
        <version>2.16.60</version>
    </dependency>
    <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>auth</artifactId>
        <version>2.16.60</version>
    </dependency>
</dependencies>

Java 代码

import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.AwsCredentials;
import software.amazon.awssdk.auth.signer.Aws4Signer;
import software.amazon.awssdk.auth.signer.params.Aws4SignerParams;
import software.amazon.awssdk.http.ContentStreamProvider;
import software.amazon.awssdk.http.ExecutableHttpRequest;
import software.amazon.awssdk.http.HttpExecuteRequest;
import software.amazon.awssdk.http.HttpExecuteResponse;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.http.SdkHttpMethod;
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.regions.Region;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.stream.Collectors;

public class Demo {
    public static void main(String[] args) {
        AwsCredentials awsCreds = AwsBasicCredentials.create("<access_key>", "<secret_key>");
        Aws4SignerParams signerParams = Aws4SignerParams.builder()
                .awsCredentials(awsCreds)
                .signingName("minibasebe")
                .signingRegion(Region.of("pri"))
                .build();
        Aws4Signer signer = Aws4Signer.create();
        SdkHttpClient client = ApacheHttpClient.create();

        ContentStreamProvider content = new ContentStreamProviderImpl();

        SdkHttpFullRequest request = SdkHttpFullRequest.builder()
                .method(SdkHttpMethod.POST)
                .protocol("http")
                .host("minibase.tld")
                .port(80)
                .encodedPath({api_path})
                .appendRawQueryParameter("test_query", "test")
                .appendHeader("X-Custom-Header", "somevalue")
                .contentStreamProvider(content)
                .build();
        request = signer.sign(request, signerParams);

        HttpExecuteRequest executeRequest = HttpExecuteRequest.builder()
                .request(request)
                .contentStreamProvider(content)
                .build();
        ExecutableHttpRequest executableRequest = client.prepareRequest(executeRequest);
        try {
            HttpExecuteResponse response = executableRequest.call();
            String result = new BufferedReader(new InputStreamReader(response.responseBody().get()))
                    .lines()
                    .collect(Collectors.joining("\n"));
            System.out.println(result);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class ContentStreamProviderImpl implements ContentStreamProvider {
    @Override
    public InputStream newStream() {
        return new ByteArrayInputStream("{\"body\":\"test\"}".getBytes(StandardCharsets.UTF_8));
    }
}

Golang 示例

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "time"

    "github.com/aws/aws-sdk-go/aws/credentials"
    v4 "github.com/aws/aws-sdk-go/aws/signer/v4"
)

func main() {
    minibaseURL := url.URL{Scheme: "http", Host: "minibase.tld", Path: {api_path}}
    q := minibaseURL.Query()
    q.Set("test_query", "test")
    minibaseURL.RawQuery = q.Encode()

    reqBodyJson := map[string]string{"body": "test"}
    reqBody, _ := json.Marshal(reqBodyJson)
    reqBodyReader := bytes.NewReader(reqBody)

    req, _ := http.NewRequest(http.MethodPost, minibaseURL.String(), reqBodyReader)
    req.Header.Set("X-Custom-Header", "somevalue")

    signer := v4.NewSigner(credentials.NewStaticCredentials("<access_key>", "<secret_key>", ""))
    signer.Sign(req, reqBodyReader, "minibasebe", "pri", time.Now())

    resp, _ := http.DefaultClient.Do(req)
    respBody, _ := io.ReadAll(resp.Body)
    respBodyJson := new(map[string]any)
    json.Unmarshal(respBody, respBodyJson)
    fmt.Println(respBodyJson)
}

Node.js（ES Modules）示例

package.json

{
  "dependencies": {
    "@aws-crypto/sha256-js": "^4.0.0",
    "@aws-sdk/node-http-handler": "^3.329.0",
    "@aws-sdk/protocol-http": "^3.329.0",
    "@aws-sdk/signature-v4": "^3.329.0"
  }
}

TypeScript

import { Sha256 } from "@aws-crypto/sha256-js";
import { NodeHttpHandler } from "@aws-sdk/node-http-handler";
import { HttpRequest } from "@aws-sdk/protocol-http";
import { SignatureV4 } from "@aws-sdk/signature-v4";
import { IncomingMessage } from "http";

const signerInit = {
  service: "minibasebe",
  region: "pri",
  sha256: Sha256,
  credentials: {
    accessKeyId: "<access_key>",
    secretAccessKey: "<secret_key>",
  },
};
const signer = new SignatureV4(signerInit);

const nodeHttpHandler = new NodeHttpHandler();

const hostname = "minibase.tld";
const port = 80;
const demoRequest = new HttpRequest({
  method: "POST",
  protocol: "http",
  hostname,
  port,
  path: {api_path},
  headers: {
    Host: `${hostname}:${port}`,
    "X-Custom-Header": "somevalue",
  },
  query: {
    test_query: "test",
  },
  body: JSON.stringify({ body: "test" }),
});
const signedRequest = (await signer.sign(demoRequest)) as HttpRequest;

const { response } = await nodeHttpHandler.handle(signedRequest);
const body = await ((body: IncomingMessage) => {
  return new Promise((resolve, reject) => {
    const buffer: Uint8Array[] = [];
    body
      .on("data", (chunk) => {
        buffer.push(chunk);
      })
      .on("end", () => {
        if (!body.complete) {
          reject(new Error("The body failed to stream to the end."));
          return;
        }
        resolve(JSON.parse(Buffer.concat(buffer).toString()));
      });
  });
})(response.body as IncomingMessage);
console.log(body);

JavaScript

import { Sha256 } from "@aws-crypto/sha256-js";
import { NodeHttpHandler } from "@aws-sdk/node-http-handler";
import { HttpRequest } from "@aws-sdk/protocol-http";
import { SignatureV4 } from "@aws-sdk/signature-v4";

const signerInit = {
  service: "minibasebe",
  region: "pri",
  sha256: Sha256,
  credentials: {
    accessKeyId: "<access_key>",
    secretAccessKey: "<secret_key>",
  },
};
const signer = new SignatureV4(signerInit);

const nodeHttpHandler = new NodeHttpHandler();

const hostname = "minibase.tld";
const port = 80;
const demoRequest = new HttpRequest({
  method: "GET",
  protocol: "http",
  hostname,
  port,
  path: {api_path},
  headers: {
    Host: `${hostname}:${port}`,
    "X-Custom-Header": "somevalue",
  },
  query: {
    test_query: "test",
  },
  body: JSON.stringify({ body: "test" }),
});
const signedRequest = await signer.sign(demoRequest);

const { response } = await nodeHttpHandler.handle(signedRequest);
const body = await ((body) => {
  return new Promise((resolve, reject) => {
    const buffer = [];
    body
      .on("data", (chunk) => {
        buffer.push(chunk);
      })
      .on("end", () => {
        if (!body.complete) {
          reject(new Error("The body failed to stream to the end."));
          return;
        }
        resolve(JSON.parse(Buffer.concat(buffer).toString()));
      });
  });
})(response.body);
console.log(body);

使用建议

优先使用 HTTPS 地址发起请求，避免明文传输风险。
将 access_key 和 secret_key 保存在安全的密钥管理系统中。
不要将凭证硬编码到前端代码或公开仓库。
当签名失败时，优先检查时间偏差、请求路径、Query 参数和 Header 是否参与了签名。

最近更新时间：2026.07.27 21:58:48

这个页面对您有帮助吗？

有用

无用

数据智能体 DataAgent（私有化）

pom.xml #

Java 代码 #

package.json #

TypeScript #

JavaScript #

pom.xml

Java 代码

package.json

TypeScript

JavaScript