赋予权限并运行：

chmod +x call_api_plus.sh
./call_api_plus.sh debian deploy

这里使用了：

-w "\n%{http_code}"

它可以让 curl 在返回内容末尾追加 HTTP 状态码，方便脚本判断接口是否成功。

八、使用 Python 调用 API

虽然 Shell 脚本适合简单调用，但如果涉及复杂逻辑，例如多次请求、异常处理、数据清洗、数据库写入、定时任务等，Python 会更加合适。

首先安装 requests 库：

pip3 install requests

如果 Debian 系统提示外部管理环境限制，可以使用虚拟环境：

sudo apt install -y python3-venv
python3 -m venv venv
source venv/bin/activate
pip install requests

九、Python GET 请求源码

创建文件：

nano api_get.py

写入以下源码：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import requests

def call_get_api():
    url = "https://httpbin.org/get"

    params = {
        "name": "debian",
        "version": "12",
        "type": "api_demo"
    }

    headers = {
        "User-Agent": "Debian-API-Client/1.0"
    }

    try:
        response = requests.get(
            url,
            params=params,
            headers=headers,
            timeout=10
        )

        print("HTTP状态码：", response.status_code)

        response.raise_for_status()

        data = response.json()

        print("接口返回JSON：")
        print(data)

        print("请求URL：", data.get("url"))

    except requests.exceptions.Timeout:
        print("请求超时，请检查网络或接口服务状态")
    except requests.exceptions.ConnectionError:
        print("连接失败，请检查DNS、网络、防火墙或接口地址")
    except requests.exceptions.HTTPError as e:
        print("HTTP错误：", e)
    except ValueError:
        print("返回内容不是合法JSON")
    except Exception as e:
        print("未知错误：", e)

if __name__ == "__main__":
    call_get_api()

运行：

python3 api_get.py

Python 中的 requests.get() 会自动帮我们拼接查询参数，比手写 URL 更安全，也更易维护。

十、Python POST 请求源码

创建文件：

nano api_post.py

写入以下代码：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import requests
import json
from datetime import datetime

def call_post_api():
    url = "https://httpbin.org/post"

    token = "your_token_here"

    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
        "User-Agent": "Debian-API-Client/1.0"
    }

    payload = {
        "username": "debian",
        "action": "create_task",
        "system": "Debian",
        "time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    }

    try:
        response = requests.post(
            url,
            headers=headers,
            json=payload,
            timeout=10
        )

        print("HTTP状态码：", response.status_code)

        response.raise_for_status()

        result = response.json()

        print("接口返回结果：")
        print(json.dumps(result, ensure_ascii=False, indent=2))

        json_data = result.get("json", {})
        print("提交的用户名：", json_data.get("username"))
        print("提交的操作：", json_data.get("action"))

    except requests.exceptions.Timeout:
        print("请求超时")
    except requests.exceptions.ConnectionError:
        print("连接失败")
    except requests.exceptions.HTTPError as e:
        print("HTTP错误：", e)
    except ValueError:
        print("JSON解析失败")
    except Exception as e:
        print("未知错误：", e)

if __name__ == "__main__":
    call_post_api()

运行：

python3 api_post.py

注意，在 requests.post() 中推荐使用：

json=payload

而不是：

data=json.dumps(payload)

因为 json=payload 会自动序列化 JSON，并设置合适的数据格式，代码更简洁。

十一、封装一个可复用的 API 客户端

在真实项目中，我们可能需要调用多个接口。如果每次都重复写 URL、Header、异常处理，会导致代码冗余。下面封装一个通用 API Client。

创建文件：

nano api_client.py

Python通用API客户端源码

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import requests
import json
from typing import Optional, Dict, Any


class APIClient:
    def __init__(self, base_url: str, token: Optional[str] = None, timeout: int = 10):
        self.base_url = base_url.rstrip("/")
        self.token = token
        self.timeout = timeout

    def _headers(self, extra_headers: Optional[Dict[str, str]] = None) -> Dict[str, str]:
        headers = {
            "Content-Type": "application/json",
            "User-Agent": "Debian-API-Client/1.0"
        }

        if self.token:
            headers["Authorization"] = f"Bearer {self.token}"

        if extra_headers:
            headers.update(extra_headers)

        return headers

    def request(
        self,
        method: str,
        path: str,
        params: Optional[Dict[str, Any]] = None,
        data: Optional[Dict[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None
    ) -> Dict[str, Any]:

        url = f"{self.base_url}/{path.lstrip('/')}"

        try:
            response = requests.request(
                method=method.upper(),
                url=url,
                params=params,
                json=data,
                headers=self._headers(headers),
                timeout=self.timeout
            )

            result = {
                "success": False,
                "status_code": response.status_code,
                "data": None,
                "error": None
            }

            try:
                result["data"] = response.json()
            except ValueError:
                result["data"] = response.text

            if 200 <= response.status_code < 300:
                result["success"] = True
            else:
                result["error"] = f"HTTP状态码异常：{response.status_code}"

            return result

        except requests.exceptions.Timeout:
            return {
                "success": False,
                "status_code": None,
                "data": None,
                "error": "请求超时"
            }
        except requests.exceptions.ConnectionError:
            return {
                "success": False,
                "status_code": None,
                "data": None,
                "error": "连接失败"
            }
        except Exception as e:
            return {
                "success": False,
                "status_code": None,
                "data": None,
                "error": str(e)
            }


def main():
    client = APIClient(
        base_url="https://httpbin.org",
        token="your_token_here",
        timeout=10
    )

    get_result = client.request(
        method="GET",
        path="/get",
        params={
            "name": "debian",
            "version": "12"
        }
    )

    print("GET请求结果：")
    print(json.dumps(get_result, ensure_ascii=False, indent=2))

    post_result = client.request(
        method="POST",
        path="/post",
        data={
            "username": "debian",
            "action": "api_client_demo"
        }
    )

    print("POST请求结果：")
    print(json.dumps(post_result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行：

python3 api_client.py

这个 API 客户端的优点是：

• 支持统一的基础 URL；
• 支持 Token；
• 支持 GET、POST、PUT、DELETE 等方法；
• 支持请求参数和 JSON 请求体；
• 统一返回结果结构；
• 统一异常处理；
• 适合在 Debian 自动化脚本中复用。

十二、使用环境变量保存 Token

在生产环境中，不建议把 Token 直接写在源码中，因为源码可能会被提交到 Git 仓库，导致密钥泄露。

推荐使用环境变量。

例如：

export API_TOKEN="your_real_token"

Python 中读取：

import os

token = os.getenv("API_TOKEN")

也可以写入 ~/.bashrc：

echo 'export API_TOKEN="your_real_token"' >> ~/.bashrc
source ~/.bashrc

然后修改客户端：

import os

client = APIClient(
    base_url="https://api.example.com",
    token=os.getenv("API_TOKEN"),
    timeout=10
)

如果是系统服务，也可以在 systemd 配置中设置环境变量。

十三、定时调用 API

Debian 中可以使用 cron 定时执行脚本。

编辑定时任务：

crontab -e

例如每 5 分钟调用一次：

*/5 * * * * /usr/bin/python3 /home/debian/api-demo/api_post.py >> /home/debian/api-demo/api.log 2>&1

每天凌晨 1 点调用：

0 1 * * * /bin/bash /home/debian/api-demo/call_api.sh >> /home/debian/api-demo/call_api.log 2>&1

查看日志：

tail -f /home/debian/api-demo/api.log

如果脚本在命令行可以运行，但在 cron 中不能运行，通常是环境变量或路径问题。建议在脚本中使用绝对路径，并显式加载环境变量。

十四、常见错误与排查方法

1. DNS解析失败

错误表现：

Could not resolve host

解决方法：

ping api.example.com
nslookup api.example.com

如果没有 nslookup：

sudo apt install -y dnsutils

检查 /etc/resolv.conf：

cat /etc/resolv.conf

可以临时修改 DNS：

sudo nano /etc/resolv.conf

加入：

nameserver 8.8.8.8
nameserver 1.1.1.1

2. HTTPS证书错误

错误表现：

SSL certificate problem

安装证书包：

sudo apt install -y ca-certificates
sudo update-ca-certificates

不建议长期使用 curl -k 跳过证书校验，因为这会降低安全性。

3. 接口返回401

401 通常表示认证失败。需要检查：

• Token 是否正确；
• Token 是否过期；
• Header 名称是否正确；
• 是否需要 Bearer 前缀；
• 是否调用了错误环境，例如测试环境和生产环境混用。

4. 接口返回403

403 表示没有权限。可能原因：

• 当前账号没有接口权限；
• IP 不在白名单；
• 请求频率过高；
• Header 缺失；
• 服务端安全策略拦截。

5. 接口返回404

404 表示接口不存在。需要检查：

• URL 是否拼写错误；
• API 版本是否正确；
• 路径是否多写或少写 /；
• 是否使用了错误的域名。

6. 接口返回500

500 是服务端错误，不一定是客户端问题。但仍需确认：

• 请求参数是否符合文档；
• JSON 格式是否正确；
• 必填字段是否缺失；
• 数据类型是否正确；
• 是否触发了服务端异常。

十五、接口调用安全建议

在 Debian 服务器上调用 API 时，除了能调用成功，还要注意安全性。

1. 不要把密钥写死在代码中

建议使用：

• 环境变量；
• 配置文件；
• 密钥管理服务；
• systemd EnvironmentFile。

2. 设置合理超时时间

不要让请求无限等待，例如 Python 中：

requests.get(url, timeout=10)

curl 中：

curl --connect-timeout 5 --max-time 15 https://api.example.com

3. 记录日志但不要泄露敏感信息

日志中不要输出完整 Token、密码、身份证号、手机号等敏感数据。

4. 校验返回状态码

不要只判断接口是否有返回内容，还要判断 HTTP 状态码和业务状态码。

例如：

{
  "code": 0,
  "message": "success"
}

有些接口即使 HTTP 状态码是 200，业务状态也可能是失败。

5. 控制调用频率

如果 API 有频率限制，应加入重试机制和间隔时间，避免触发封禁。

十六、完整项目目录示例

建议将项目组织成如下结构：

api-demo/
├── call_api.sh
├── call_api_plus.sh
├── api_get.py
├── api_post.py
├── api_client.py
├── logs/
│   └── api.log
└── README.md

创建目录：

mkdir -p ~/api-demo/logs

运行 Python 客户端并写入日志：

python3 api_client.py >> logs/api.log 2>&1

查看日志：

tail -n 50 logs/api.log

十七、总结

本文以 Debian 系统为基础，完整介绍了 API 接口调用的常见方法。从最基础的 curl GET 请求、POST 请求，到携带 Token、提交 JSON、上传文件，再到 Shell 脚本封装和 Python 客户端封装，基本覆盖了日常开发和运维中最常见的 API 调用场景。

如果只是临时测试接口，推荐使用 curl；如果需要写自动化运维脚本，可以使用 Shell；如果接口逻辑复杂、需要异常处理、数据解析、批量请求或长期维护，推荐使用 Python 的 requests 库进行封装。

在生产环境中，还需要特别注意 Token 安全、请求超时、日志脱敏、状态码判断和错误重试。掌握这些内容后，你就可以在 Debian 服务器上稳定、安全、高效地调用各种 API 接口，实现自动化业务处理和系统集成。