API key学习笔记

API Key 基本上可以认为是一个长字符串，允许 API 消费者（即使用 API 的人）访问受限的功能和数据。它作为一种安全措施，确保了 API 服务能够控制谁有权限访问什么数据，同时也帮助跟踪API的使用情况。生成API key来调用API是为了安全、控制和管理API访问的。这也就是为啥生产环境往往都需要加上key来进行第一步验证了。下面对此进行简单总结：

一、为什么要生成API key？

1. 身份验证：

   • API key用于识别调用者的身份，以确保只有授权的用户才能访问API。

2. 访问控制：

   • API key可以设置不同的权限级别，从而控制用户可以访问哪些API功能。

3. 使用限制：

   • 通过API key，可以对每个用户的API调用次数进行限制，防止滥用。

4. 监控和记录：

   • 使用API key可以跟踪和记录每个用户的API调用情况，以便进行分析和故障排除。

5. 安全性：

   • API key是防止未授权访问和保护数据的第一道防线。

二、如何生成API key？

生成API key的过程可能会因平台或服务提供商的不同而有所差异，但一般步骤如下：

1. 注册和登录：

   • 首先，需要在提供API服务的平台上注册一个账户并登录。

2. 创建API项目：

   • 在大多数平台上，需要创建一个新的API项目或应用程序。在创建过程中，通常会要求提供一些基本信息，如项目名称、描述等。

3. 生成API key：

   • 在项目设置或API设置页面，通常会有一个选项用于生成新的API key。点击生成API key按钮后，平台会生成一个唯一的密钥字符串。

4. 保存API key：

   • 生成的API key通常只会显示一次，所以需要妥善保存。建议将其存储在安全的地方，例如环境变量或安全存储管理工具中。

5. 配置API key：

   • 在实际使用API时，需要将生成的API key包含在API请求的头部、参数或配置文件中，以便进行身份验证。

三、示例

》在Google Cloud Platform上生成API key

1. 登录到Google Cloud Platform控制台。
2. 创建一个新的项目或选择一个现有项目。
3. 导航到API和服务 -> 凭据。
4. 点击“创建凭据”按钮，并选择“API密钥”。
5. 系统会生成一个新的API密钥。将其复制并保存。

不同平台的具体操作可能会有所不同，但基本流程是相似的。如果你有特定的平台或API需要生成API key，可以提供更多信息，我可以提供更详细的指导。比如大模型openai qwen等提供的API key访问，申请流程差不多，按需付费即可。

》基于python和fastapi快速生成一个自己api服务的key，以及如何使用验证
（1）sever端main.py

from fastapi import FastAPI, Depends, HTTPException, Header
from typing import Optional
import uuid

app = FastAPI()

# 这里我们将API key存储在内存中，实际应用中应使用数据库或其他安全存储
api_keys = {}

# 生成API key并存储
def create_api_key(user: str) -> str:
    api_key = str(uuid.uuid4())
    api_keys[api_key] = user
    return api_key

# 验证API key
def verify_api_key(x_api_key: str = Header(...)):
    if x_api_key not in api_keys:
        raise HTTPException(status_code=401, detail="Invalid API Key")

# 生成API key的端点
@app.post("/generate_api_key")
def generate_api_key(user: str):
    api_key = create_api_key(user)
    return {"api_key": api_key}

# 需要验证API key的端点
@app.get("/secure_endpoint")
def secure_endpoint(api_key: str = Depends(verify_api_key)):
    return {"message": "You have access to this endpoint"}

if __name__ == "__main__":
    ###generate api key
    user="test_user1"
    user_key=create_api_key(user)
    print("{}:{}".format(user,user_key))
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

（2）client端

import requests

# 生成API key
def generate_api_key(user: str):
    response = requests.post("http://127.0.0.1:8000/generate_api_key", params={"user": user})
    return response.json().get("api_key")

# 使用API key调用受保护的端点
def call_secure_endpoint(api_key: str):
    headers = {"X-API-Key": api_key}
    response = requests.get("http://127.0.0.1:8000/secure_endpoint", headers=headers)
    return response.json()

if __name__ == "__main__":
    """
    user = "test_user"
    api_key = generate_api_key(user)
    print("Generated API Key:", api_key)
    """
    
    ###从server端拿到key
    #api_key="8deb0e23-f2e7-4c01-a306-352bcf7dcf2d"   ##right
    api_key="8deb0e23-f2e7-4c01-a306-352bcf7dcf2a"    ##error
    response = call_secure_endpoint(api_key)
    print("Response from secure endpoint:", response)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

（3）启动服务
启动FastAPI服务：

uvicorn main:app --reload
1

运行客户端脚本：

python client.py
1

（4）其他
验证和区分接口

from flask import Flask, request, jsonify

app = Flask(__name__)

API_KEY = "YOUR_API_KEY"

def check_api_key():
    api_key = request.headers.get('Authorization')
    if api_key != f"Bearer {API_KEY}":
        return jsonify({"error": "Unauthorized"}), 401

@app.before_request
def before_request():
    if request.endpoint != 'health_check':  # 忽略不需要验证的端点
        check_api_key()

@app.route('/api/v1/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
    # 处理获取用户信息的逻辑
    return jsonify({"user_id": user_id, "name": "John Doe"})

@app.route('/api/v1/orders/<int:order_id>', methods=['GET'])
def get_order(order_id):
    # 处理获取订单信息的逻辑
    return jsonify({"order_id": order_id, "status": "shipped"})

@app.route('/api/v1/products/<int:product_id>', methods=['GET'])
def get_product(product_id):
    # 处理获取产品信息的逻辑
    return jsonify({"product_id": product_id, "name": "Widget"})

@app.route('/health_check', methods=['GET'])
def health_check():
    return jsonify({"status": "ok"})

if __name__ == '__main__':
    app.run(debug=True)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

通过before_request钩子函数在每个请求之前验证API密钥，并通过不同的URL路径来区分多个接口。这样可以确保在访问API接口前都进行了验证，并且可以清楚地区分每个接口调用。

》生成key的其他方式

• 使用UUID生成
  UUID（Universally Unique Identifier）是常用的生成唯一标识符的方法。UUID是128位长的数字，生成的概率极低。

import uuid

def generate_uuid_api_key():
    return str(uuid.uuid4())
1
2
3
4

• 使用哈希函数
  哈希函数（如SHA-256）可以生成固定长度的字符串，可以用于生成API key。

import hashlib
import time

def generate_hash_api_key():
    return hashlib.sha256(str(time.time()).encode('utf-8')).hexdigest()
1
2
3
4
5

• 使用加密随机数

加密随机数生成器可以生成高强度的随机字符串，用于API key。

import secrets

def generate_secure_api_key():
    return secrets.token_urlsafe(32)
1
2
3
4

• 使用令牌生成库
  一些第三方库专门用于生成令牌或API key，如PyJWT、OAuthlib等。

import jwt
import datetime

def generate_jwt_api_key(secret_key, user_id):
    payload = {
        'user_id': user_id,
        'exp': datetime.datetime.utcnow() + datetime.timedelta(days=1)  # 过期时间
    }
    return jwt.encode(payload, secret_key, algorithm='HS256')
1
2
3
4
5
6
7
8
9

• 基于用户信息和时间戳
  结合用户信息和时间戳生成API key，可以确保每个API key的唯一性，同时包含一些有用的信息。

import base64
import hashlib
import time

def generate_user_based_api_key(user_id):
    raw_key = f"{user_id}:{time.time()}"
    return base64.urlsafe_b64encode(hashlib.sha256(raw_key.encode('utf-8')).digest()).decode('utf-8')
1
2
3
4
5
6
7

选择合适的生成方法

• UUID生成：适合一般场景，简单易用。
• 哈希函数生成：适合需要固定长度和散列特性的场景。
• 加密随机数生成：适合高安全性要求的场景。
• 令牌生成库：适合需要嵌入额外信息和控制过期时间的场景。
• 用户信息和时间戳：适合需要基于特定信息生成API key的场景。

选择生成API key的方法时，应考虑以下因素：

• 唯一性：确保生成的API key是唯一的，不会重复。
• 安全性：API key应难以预测或伪造，特别是对于敏感操作。
• 长度和格式：根据使用场景选择合适的长度和格式，如Base64编码或十六进制字符串。
• 易用性：API key应易于生成和管理，适合应用需求。

四、其他

在日常对API key的使用过程中，需要注意以下几点：

• 限制API Key权限：如果可能的话，限制你的 API Key 的权限只包括你真正需要的服务和操作。
• 定期轮换API Key：为减少安全风险，定期更换 API Key 可以是个不错的习惯。
• 监控API使用：留意异常的API调用模式或过量的流量，这可能表明你的 Key 已经泄露。
• 处理错误：合理处理 API 调用中可能出现的错误，例如限流（rate limiting）错误，可以提高用户体验。
• API Hub：提供各式各样开放 API 可直接调用。
• 管理自己的API key：这里推荐一个开源项目https://github.com/songquanpeng/one-api ，可以对自己开放和使用的API key进行管理，比如使用次数权限等。