Google App Engine Java服务API Key与Secret配置求助

嘿，我来帮你搞定这个问题！你现在的情况是GAE上的Java /hello 接口没做验证，任何人都能直接访问，而你需要生成API Key和Secret密钥对，给第三方应用（比如PHP、Java客户端）用来验证身份对吧？

首先得明确：Google Cloud Console里的「Credentials」标签生成的API Key，主要是给调用Google自家服务（比如Maps、Cloud Storage）用的，不是用来保护你自己的Web服务接口的。要实现你要的功能，得自己在Java应用里加验证逻辑，下面一步步来：

首先你需要生成安全的密钥对，然后把它们存在安全的地方（别硬编码在代码里！）：

• 自己生成密钥：用终端命令生成随机安全字符串，比如 openssl rand -hex 32 生成API Key，再跑一次生成Secret。这样你就能得到类似 abc123def456... 的密钥对。
• 存储密钥：
  • 简单方式：把密钥对存在GAE的环境变量里。在你的 appengine-web.xml 里加：

    <env-variable name="VALID_API_KEYS" value="your-api-key-1:your-secret-1,your-api-key-2:your-secret-2" />
    

    这里可以放多组密钥对，用逗号分隔，每组用冒号分开Key和Secret。
  • 更安全的方式：用Google Cloud Secret Manager存储密钥对，应用启动时通过API读取。适合生产环境，防止密钥泄露。

接下来要给你的接口加拦截器，在请求到达之前检查Key和Secret是否正确。这里分两种情况：

如果你是普通Servlet应用（非Spring Boot） #

创建一个Servlet Filter，用来拦截需要验证的接口：

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

// 只拦截/hello接口，或者改成/*拦截所有
@WebFilter(urlPatterns = "/hello")
public class ApiKeyAuthFilter implements Filter {

    private Map<String, String> validKeySecretPairs;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 从环境变量加载密钥对
        String keysStr = System.getenv("VALID_API_KEYS");
        validKeySecretPairs = new HashMap<>();
        if (keysStr != null) {
            String[] pairs = keysStr.split(",");
            for (String pair : pairs) {
                String[] keySecret = pair.split(":");
                if (keySecret.length == 2) {
                    validKeySecretPairs.put(keySecret[0].trim(), keySecret[1].trim());
                }
            }
        }
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse res = (HttpServletResponse) response;

        // 从请求头获取第三方传来的Key和Secret
        String incomingKey = req.getHeader("X-API-Key");
        String incomingSecret = req.getHeader("X-API-Secret");

        // 验证逻辑
        if (incomingKey == null || incomingSecret == null 
            || !validKeySecretPairs.containsKey(incomingKey)
            || !validKeySecretPairs.get(incomingKey).equals(incomingSecret)) {
            res.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            res.getWriter().write("Invalid API Key or Secret");
            return;
        }

        // 验证通过，继续处理请求
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {
        // 清理资源，这里不需要额外操作
    }
}

如果你的应用没启用注解，就在 web.xml 里手动配置Filter：

<filter>
    <filter-name>ApiKeyAuthFilter</filter-name>
    <filter-class>com.your.package.name.ApiKeyAuthFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>ApiKeyAuthFilter</filter-name>
    <url-pattern>/hello</url-pattern>
</filter-mapping>

如果是Spring Boot应用（可选） #

如果你的GAE应用是Spring Boot架构，用HandlerInterceptor更方便：

import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;

public class ApiKeyAuthInterceptor implements HandlerInterceptor {

    private final Map<String, String> validKeySecretPairs;

    public ApiKeyAuthInterceptor(Map<String, String> validKeySecretPairs) {
        this.validKeySecretPairs = validKeySecretPairs;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String incomingKey = request.getHeader("X-API-Key");
        String incomingSecret = request.getHeader("X-API-Secret");

        if (incomingKey == null || incomingSecret == null 
            || !validKeySecretPairs.containsKey(incomingKey)
            || !validKeySecretPairs.get(incomingKey).equals(incomingSecret)) {
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            response.getWriter().write("Invalid API Key or Secret");
            return false;
        }
        return true;
    }
}

然后在配置类里注册拦截器：

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        Map<String, String> validKeys = new HashMap<>();
        // 从环境变量加载密钥对
        String keysStr = System.getenv("VALID_API_KEYS");
        if (keysStr != null) {
            String[] pairs = keysStr.split(",");
            for (String pair : pairs) {
                String[] keySecret = pair.split(":");
                if (keySecret.length == 2) {
                    validKeys.put(keySecret[0].trim(), keySecret[1].trim());
                }
            }
        }
        // 给/hello接口加拦截
        registry.addInterceptor(new ApiKeyAuthInterceptor(validKeys))
                .addPathPatterns("/hello");
    }
}

把修改后的代码重新部署到GAE，然后测试：

• 直接访问 https://your-app-id.uc.r.appspot.com/hello，应该返回401 Unauthorized，提示密钥无效
• 用Postman或者curl加请求头访问：

  curl -H "X-API-Key: your-api-key-1" -H "X-API-Secret: your-secret-1" https://your-app-id.uc.r.appspot.com/hello
  

  这时候应该能正常返回接口内容。

• 别把密钥硬编码在代码里，一定要用环境变量或者Secret Manager
• 定期轮换密钥，如果某组密钥泄露了，直接在环境变量/Secret Manager里更新就行
• 确保所有请求都走HTTPS，防止密钥在传输过程中被窃取
• 可以加限流逻辑，比如限制每个Key的请求频率，防止恶意攻击

内容的提问来源于stack exchange，提问作者me._