AvailablityProbesAutoConfiguration에 대해 알아보자(spring boot readiness, liveness 관련)

livenessProbe:
  httpGet:
    path: /actuator/health/liveness
    port: liveness-port
  failureThreshold: ...
  periodSeconds: ...

readinessProbe:
  httpGet:
    path: /actuator/health/readiness
    port: liveness-port
  failureThreshold: ...
  periodSeconds: ...

@Configuration(proxyBeanMethods = false)
@Conditional(AvailabilityProbesAutoConfiguration.ProbesCondition.class)
@AutoConfigureAfter({ AvailabilityHealthContributorAutoConfiguration.class,
        ApplicationAvailabilityAutoConfiguration.class })
public class AvailabilityProbesAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean(name = "livenessStateHealthIndicator")
    public LivenessStateHealthIndicator livenessStateHealthIndicator(ApplicationAvailability applicationAvailability) {
        return new LivenessStateHealthIndicator(applicationAvailability);
    }

    @Bean
    @ConditionalOnMissingBean(name = "readinessStateHealthIndicator")
    public ReadinessStateHealthIndicator readinessStateHealthIndicator(
            ApplicationAvailability applicationAvailability) {
        return new ReadinessStateHealthIndicator(applicationAvailability);
    }

    @Bean
    public AvailabilityProbesHealthEndpointGroupsPostProcessor availabilityProbesHealthEndpointGroupsPostProcessor() {
        return new AvailabilityProbesHealthEndpointGroupsPostProcessor();
    }
    
    //...
}

static class ProbesCondition extends SpringBootCondition {

    private static final String ENABLED_PROPERTY = "management.endpoint.health.probes.enabled";

    private static final String DEPRECATED_ENABLED_PROPERTY = "management.health.probes.enabled";

    @Override
    public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment environment = context.getEnvironment();
        ConditionMessage.Builder message = ConditionMessage.forCondition("Probes availability");
        ConditionOutcome outcome = onProperty(environment, message, ENABLED_PROPERTY);
        if (outcome != null) {
            return outcome;
        }
        outcome = onProperty(environment, message, DEPRECATED_ENABLED_PROPERTY);
        if (outcome != null) {
            return outcome;
        }
        if (CloudPlatform.getActive(environment) == CloudPlatform.KUBERNETES) { // 주목!
            return ConditionOutcome.match(message.because("running on Kubernetes"));
        }
        return ConditionOutcome.noMatch(message.because("not running on a supported cloud platform"));
    }

    private ConditionOutcome onProperty(Environment environment, ConditionMessage.Builder message,
                                        String propertyName) {
        String enabled = environment.getProperty(propertyName);
        if (enabled != null) {
            boolean match = !"false".equalsIgnoreCase(enabled);
            return new ConditionOutcome(match, message.because("'" + propertyName + "' set to '" + enabled + "'"));
        }
        return null;
    }

}

public enum CloudPlatform {
    NONE {

        @Override
        public boolean isDetected(Environment environment) {
            return false;
        }

    },
    
    //...

    KUBERNETES {

        private static final String KUBERNETES_SERVICE_HOST = "KUBERNETES_SERVICE_HOST";

        private static final String KUBERNETES_SERVICE_PORT = "KUBERNETES_SERVICE_PORT";

        private static final String SERVICE_HOST_SUFFIX = "_SERVICE_HOST";

        private static final String SERVICE_PORT_SUFFIX = "_SERVICE_PORT";

        @Override
        public boolean isDetected(Environment environment) {
            if (environment instanceof ConfigurableEnvironment) {
                return isAutoDetected((ConfigurableEnvironment) environment);
            }
            return false;
        }

        private boolean isAutoDetected(ConfigurableEnvironment environment) {
            PropertySource<?> environmentPropertySource = environment.getPropertySources()
                    .get(StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME);
            if (environmentPropertySource != null) {
                if (environmentPropertySource.containsProperty(KUBERNETES_SERVICE_HOST)
                        && environmentPropertySource.containsProperty(KUBERNETES_SERVICE_PORT)) {
                    return true;
                }
                if (environmentPropertySource instanceof EnumerablePropertySource) {
                    return isAutoDetected((EnumerablePropertySource<?>) environmentPropertySource);
                }
            }
            return false;
        }

        private boolean isAutoDetected(EnumerablePropertySource<?> environmentPropertySource) {
            for (String propertyName : environmentPropertySource.getPropertyNames()) {
                if (propertyName.endsWith(SERVICE_HOST_SUFFIX)) {
                    String serviceName = propertyName.substring(0,
                            propertyName.length() - SERVICE_HOST_SUFFIX.length());
                    if (environmentPropertySource.getProperty(serviceName + SERVICE_PORT_SUFFIX) != null) {
                        return true;
                    }
                }
            }
            return false;
        }

    };
    
    //...
    
    /**
     * Returns the active {@link CloudPlatform} or {@code null} if one is not active.
     * @param environment the environment
     * @return the {@link CloudPlatform} or {@code null}
     */
    public static CloudPlatform getActive(Environment environment) {
        if (environment != null) {
            for (CloudPlatform cloudPlatform : values()) {
                if (cloudPlatform.isActive(environment)) {
                    return cloudPlatform;
                }
            }
        }
        return null;
    }

    /**
     * Determines if the platform is active (i.e. the application is running in it).
     * @param environment the environment
     * @return if the platform is active.
     */
    public boolean isActive(Environment environment) {
        return isEnforced(environment) || isDetected(environment);
    }

    /**
     * Determines if the platform is enforced by looking at the
     * {@code "spring.main.cloud-platform"} configuration property.
     * @param environment the environment
     * @return if the platform is enforced
     * @since 2.3.0
     */
    public boolean isEnforced(Environment environment) {
        return isEnforced(environment.getProperty(PROPERTY_NAME));
    }

    /**
     * Determines if the platform is detected by looking for platform-specific environment
     * variables.
     * @param environment the environment
     * @return if the platform is auto-detected.
     * @since 2.3.0
     */
    public abstract boolean isDetected(Environment environment);
}