跳到主要内容

Cloud Foundry 支持

DeepSeek V3 中英对照 Cloud Foundry Support

Spring Boot 的 actuator 模块包含了额外的支持，这些支持在你部署到兼容的 Cloud Foundry 实例时会被激活。/cloudfoundryapplication 路径为所有 @Endpoint bean 提供了一个替代的安全路由。

扩展支持使得 Cloud Foundry 管理界面（例如，可用于查看已部署应用程序的 Web 应用程序）能够通过 Spring Boot 执行器信息进行增强。例如，应用程序状态页面可以包含完整的健康信息，而不仅仅是典型的“运行中”或“已停止”状态。

备注

/cloudfoundryapplication 路径对普通用户来说无法直接访问。要使用该端点，您必须在请求中传递一个有效的 UAA 令牌。

禁用扩展的 Cloud Foundry Actuator 支持​

如果你想完全禁用 /cloudfoundryapplication 端点，可以在你的 application.properties 文件中添加以下设置：

management.cloudfoundry.enabled=false
properties

Cloud Foundry 自签名证书​

默认情况下，/cloudfoundryapplication 端点的安全验证会向各种 Cloud Foundry 服务进行 SSL 调用。如果你的 Cloud Foundry UAA 或 Cloud Controller 服务使用自签名证书，你需要设置以下属性：

management.cloudfoundry.skip-ssl-validation=true
properties

自定义上下文路径​

如果服务器的上下文路径（context-path）被配置为非 / 的路径，Cloud Foundry 端点将不会在应用的根路径下可用。例如，如果配置为 server.servlet.context-path=/app，那么 Cloud Foundry 端点将可以通过 /app/cloudfoundryapplication/* 访问。

如果你期望无论服务器的上下文路径如何，Cloud Foundry 端点始终在 /cloudfoundryapplication/* 下可用，你需要在应用程序中明确配置这一点。具体的配置取决于所使用的 Web 服务器。对于 Tomcat，你可以添加以下配置：

import java.io.IOException;
import java.util.Collections;

import jakarta.servlet.GenericServlet;
import jakarta.servlet.Servlet;
import jakarta.servlet.ServletContainerInitializer;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import org.apache.catalina.Host;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.startup.Tomcat;

import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.servlet.ServletContextInitializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyCloudFoundryConfiguration {

    @Bean
    public TomcatServletWebServerFactory servletWebServerFactory() {
        return new TomcatServletWebServerFactory() {

            @Override
            protected void prepareContext(Host host, ServletContextInitializer[] initializers) {
                super.prepareContext(host, initializers);
                StandardContext child = new StandardContext();
                child.addLifecycleListener(new Tomcat.FixContextListener());
                child.setPath("/cloudfoundryapplication");
                ServletContainerInitializer initializer = getServletContextInitializer(getContextPath());
                child.addServletContainerInitializer(initializer, Collections.emptySet());
                child.setCrossContext(true);
                host.addChild(child);
            }

        };
    }

    private ServletContainerInitializer getServletContextInitializer(String contextPath) {
        return (classes, context) -> {
            Servlet servlet = new GenericServlet() {

                @Override
                public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
                    ServletContext context = req.getServletContext().getContext(contextPath);
                    context.getRequestDispatcher("/cloudfoundryapplication").forward(req, res);
                }

            };
            context.addServlet("cloudfoundry", servlet).addMapping("/*");
        };
    }

}
java

如果你正在使用基于 Webflux 的应用程序，你可以使用以下配置：

import java.util.Map;

import reactor.core.publisher.Mono;

import org.springframework.boot.autoconfigure.web.reactive.WebFluxProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.server.reactive.ContextPathCompositeHandler;
import org.springframework.http.server.reactive.HttpHandler;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.server.adapter.WebHttpHandlerBuilder;

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(WebFluxProperties.class)
public class MyReactiveCloudFoundryConfiguration {

    @Bean
    public HttpHandler httpHandler(ApplicationContext applicationContext, WebFluxProperties properties) {
        HttpHandler httpHandler = WebHttpHandlerBuilder.applicationContext(applicationContext).build();
        return new CloudFoundryHttpHandler(properties.getBasePath(), httpHandler);
    }

    private static final class CloudFoundryHttpHandler implements HttpHandler {

        private final HttpHandler delegate;

        private final ContextPathCompositeHandler contextPathDelegate;

        private CloudFoundryHttpHandler(String basePath, HttpHandler delegate) {
            this.delegate = delegate;
            this.contextPathDelegate = new ContextPathCompositeHandler(Map.of(basePath, delegate));
        }

        @Override
        public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
            // Remove underlying context path first (e.g. Servlet container)
            String path = request.getPath().pathWithinApplication().value();
            if (path.startsWith("/cloudfoundryapplication")) {
                return this.delegate.handle(request, response);
            }
            else {
                return this.contextPathDelegate.handle(request, response);
            }
        }

    }

}
java