聊聊如何玩转spring-boot-admin

<dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-starter-server</artifactId>
            <version>${spring-boot-admin.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

@SpringBootApplication
@EnableAdminServer
public class MonitorApplication {
    public static void main(String[] args) {
        SpringApplication.run(MonitorApplication.class);
    }
}

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

spring:
  security:
    user:
      name: ${MONITOR_USER:admin}
      password: ${MONITOR_PWD:admin}

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityMonitorConfig extends WebSecurityConfigurerAdapter {



    private final AdminServerProperties adminServer;

    private final WebEndpointProperties webEndpointProperties;


    @Override
    protected void configure(HttpSecurity http) throws Exception {
        SavedRequestAwareAuthenticationSuccessHandler successHandler = new SavedRequestAwareAuthenticationSuccessHandler();
        successHandler.setTargetUrlParameter("redirectTo");
        successHandler.setDefaultTargetUrl(this.adminServer.path("/"));


        http.authorizeRequests()
                .requestMatchers(new AntPathRequestMatcher(this.adminServer.path("/assets/**"))).permitAll()
                .requestMatchers(new AntPathRequestMatcher(this.adminServer.path(webEndpointProperties.getBasePath() + "/info")))
                .permitAll()
                .requestMatchers(new AntPathRequestMatcher(adminServer.path(webEndpointProperties.getBasePath() + "/health")))
                .permitAll()
                .requestMatchers(new AntPathRequestMatcher(this.adminServer.path("/login")))
                .permitAll()
                .anyRequest().authenticated()
                .and()
                .formLogin().loginPage(this.adminServer.path("/login")).successHandler(successHandler).and()
                .logout().logoutUrl(this.adminServer.path("/logout")).and()
                .httpBasic().and()
                .csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())
                .ignoringRequestMatchers(
                        new AntPathRequestMatcher(this.adminServer.path("/instances"), POST.toString()),
        new AntPathRequestMatcher(this.adminServer.path("/instances/*"), DELETE.toString()),
        new AntPathRequestMatcher(this.adminServer.path(webEndpointProperties.getBasePath() + "/**")));

        http.rememberMe((rememberMe) -> rememberMe.key(UUID.randomUUID().toString()).tokenValiditySeconds(1209600));


    }

}

spring:
  boot:
    admin:
      ui:
        title: ${UI_TITLE:LYB-GEEK Monitor}
        brand: <img src="assets/img/icon-spring-boot-admin.svg"><span>${spring.boot.admin.ui.title}</span>

spring:
  boot:
    admin:
      ui:
        view-settings:
          - name: "about"
            enabled: false

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

eureka:
  instance:
    instance-id: ${spring.application.name}:${spring.cloud.client.ip-address}:${spring.application.instance_id:${server.port}}
    prefer-ip-address: ${PREFER_IP:true}  #是否选择IP注册
    # ip-address: ${IP_ADDRESS:localhost} #指定IP地址注册
    lease-renewal-interval-in-seconds: 5 #续约更新时间间隔（默认30秒）,使得eureka及时剔除无效服务
    lease-expiration-duration-in-seconds: 10 #续约到期时间（默认90秒）
    hostname: ${HOSTNAME:${spring.application.name}}
  client:
    service-url:
      defaultZone: ${EUREKA_CLIENT_SERVICEURL_DEFAULTZONE:http://localhost:8761/eureka/}
      #缩短延迟向服务端注册的时间、默认40s
    initial-instance-info-replication-interval-seconds: 10
    #提高Eureka-Client端拉取Server注册信息的频率,默认30s
    registry-fetch-interval-seconds: 5

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-starter-client</artifactId>
            <version>${spring-boot-admin-client.version}</version>
        </dependency>

       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

management:
  endpoints:
    web:
      exposure:
        include: "*" 
  endpoint:
    health:
      show-details: ALWAYS

spring:
  boot:
    admin:
      client:
        url: http://localhost:8080

spring:
  boot:
    admin:
      client:
        url: http://localhost:8080
        username: admin
        password: admin

info:
  groupId: @project.groupId@
  artifactId: @project.artifactId@
  version: @project.version@
  describe: 这是一个微服务应用

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <executions>
                <execution>
                    <goals>
                        <goal>build-info</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

logging:
  file:
    path: ${LOG_FILE_PATH:/data/logs/cloud-mini-comsumer}

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <include resource="org/springframework/boot/logging/logback/defaults.xml"/>
    <property name="serviceName" value="cloud-mini-comsumer"/>
    <property name="logHome" value="/data/logs/${serviceName}"/>
    <contextName>${serviceName}</contextName>

    <!--输出到控制台-->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${CONSOLE_LOG_PATTERN}</pattern>
        </encoder>
    </appender>

    <!--按天生成日志-->
    <appender name="logFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <Prudent>true</Prudent>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <FileNamePattern>
                ${logHome}/%d{yyyy-MM-dd}/%d{yyyy-MM-dd}.log
            </FileNamePattern>
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <layout class="ch.qos.logback.classic.PatternLayout">
            <Pattern>
                %d{yyyy-MM-dd HH:mm:ss} -%msg%n
            </Pattern>
        </layout>
    </appender>

    <root level="info">
        <appender-ref ref="console"/>
        <appender-ref ref="logFile"/>
    </root>

</configuration>

<include resource="org/springframework/boot/logging/logback/defaults.xml"/>

<include resource="org/springframework/boot/logging/logback/base.xml" />

@WebEndpoint(id = "logfile")
public class LogFileWebEndpoint {

  private static final Log logger = LogFactory.getLog(LogFileWebEndpoint.class);

  private File externalFile;

  private final LogFile logFile;

  public LogFileWebEndpoint(LogFile logFile, File externalFile) {
    this.externalFile = externalFile;
    this.logFile = logFile;
  }

  @ReadOperation(produces = "text/plain; charset=UTF-8")
  public Resource logFile() {
    Resource logFileResource = getLogFileResource();
    if (logFileResource == null || !logFileResource.isReadable()) {
      return null;
    }
    return logFileResource;
  }

  private Resource getLogFileResource() {
    if (this.externalFile != null) {
      return new FileSystemResource(this.externalFile);
    }
    if (this.logFile == null) {
      logger.debug("Missing 'logging.file.name' or 'logging.file.path' properties");
      return null;
    }
    return new FileSystemResource(this.logFile.toString());
  }

}

public class LogFile {

  /**
   * The name of the Spring property that contains the name of the log file. Names can
   * be an exact location or relative to the current directory.
   * @deprecated since 2.2.0 in favor of {@link #FILE_NAME_PROPERTY}
   */
  @Deprecated
  public static final String FILE_PROPERTY = "logging.file";

  /**
   * The name of the Spring property that contains the directory where log files are
   * written.
   * @deprecated since 2.2.0 in favor of {@link #FILE_PATH_PROPERTY}
   */
  @Deprecated
  public static final String PATH_PROPERTY = "logging.path";

  /**
   * The name of the Spring property that contains the name of the log file. Names can
   * be an exact location or relative to the current directory.
   * @since 2.2.0
   */
  public static final String FILE_NAME_PROPERTY = "logging.file.name";

  /**
   * The name of the Spring property that contains the directory where log files are
   * written.
   * @since 2.2.0
   */
  public static final String FILE_PATH_PROPERTY = "logging.file.path";

  private final String file;

  private final String path;

  /**
   * Create a new {@link LogFile} instance.
   * @param file a reference to the file to write
   */
  LogFile(String file) {
    this(file, null);
  }

  /**
   * Create a new {@link LogFile} instance.
   * @param file a reference to the file to write
   * @param path a reference to the logging path to use if {@code file} is not specified
   */
  LogFile(String file, String path) {
    Assert.isTrue(StringUtils.hasLength(file) || StringUtils.hasLength(path), "File or Path must not be empty");
    this.file = file;
    this.path = path;
  }

  /**
   * Apply log file details to {@code LOG_PATH} and {@code LOG_FILE} system properties.
   */
  public void applyToSystemProperties() {
    applyTo(System.getProperties());
  }

  /**
   * Apply log file details to {@code LOG_PATH} and {@code LOG_FILE} map entries.
   * @param properties the properties to apply to
   */
  public void applyTo(Properties properties) {
    put(properties, LoggingSystemProperties.LOG_PATH, this.path);
    put(properties, LoggingSystemProperties.LOG_FILE, toString());
  }

  private void put(Properties properties, String key, String value) {
    if (StringUtils.hasLength(value)) {
      properties.put(key, value);
    }
  }

  @Override
  public String toString() {
    if (StringUtils.hasLength(this.file)) {
      return this.file;
    }
    return new File(this.path, "spring.log").getPath();
  }

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

eureka:
  instance:
    instance-id: ${spring.application.name}:${spring.cloud.client.ip-address}:${spring.application.instance_id:${random.uuid}}
    prefer-ip-address: ${PREFER_IP:false} #是否选择IP注册
 # ip-address: ${IP_ADDRESS:localhost} #指定IP地址注册
    lease-renewal-interval-in-seconds: 5  #续约更新时间间隔（默认30秒）,使得eureka及时剔除无效服务
    lease-expiration-duration-in-seconds: 10 #续约到期时间（默认90秒）
    hostname: ${HOSTNAME:${spring.application.name}}
    metadata-map:
      ipAddress: ${spring.cloud.client.ip-address}
      management:
        address: ${spring.cloud.client.ip-address}
  client:
    service-url:
      defaultZone: ${EUREKA_CLIENT_SERVICEURL_DEFAULTZONE:http://localhost:8761/eureka/}
      #缩短延迟向服务端注册的时间、默认40s
    initial-instance-info-replication-interval-seconds: 10
    #提高Eureka-Client端拉取Server注册信息的频率,默认30s
    registry-fetch-interval-seconds: 5

management:
  endpoints:
    web:
      base-path: ${MONINTOR_BASE_PATH:/lyb-geek}
      exposure:
        include: "*"

eureka:
  instance:
    metadata-map:
      management:
        context-path: ${management.endpoints.web.base-path:/actuator}

eureka:
  instance:
    metadata-map:
      user.name: ${spring.security.user.name}
      user.password: ${spring.security.user.password}

eureka:
  instance:
    metadata-map:
      management:
        address: ${spring.cloud.client.ip-address}

de.codecentric.boot.admin.server.cloud.discovery.DefaultServiceInstanceConverter

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
        </dependency>

spring:
  mail:
    host: ${MAIL_HOST:邮箱服务器地址}
    port:
    username: ${MAIL_USERNAME:邮箱服务器用户名}
    password: ${MAIL_PWD:邮箱服务器密码}
    protocol: ${MAIL_PROTOCOL:smtp}
    default-encoding: UTF-8
    properties:
      mail.smtp.auth: true
      mail.smtp.starttls.enable: true
      mail.smtp.starttls.required: true
      mail.smtp.socketFactory.port: ${MAIL_SMTP_SOCKETFACTORY_PORT:465}
      mail.smtp.socketFactory.class: javax.net.ssl.SSLSocketFactory
      mail.smtp.socketFactory.fallback: false
      mail.smtp.ssl.protocols: ${MAIL_SMTP_SSL_PROTOCOLS:TLSv1}

spring:
  boot:
    admin:
      notify:
        mail:
          to: ${NOTIFY_MAIL_TO:邮箱接收人，多个用,隔开}
          from: ${NOTIFY_MAIL_FROM:邮箱发送人}