management:
  endpoints:
    web:
      exposure:
        include: health,metrics,info,loggers,prometheus

curl http://localhost:8080/actuator/health
{"status":"UP","components":{"db":{"status":"UP"},"redis":{"status":"UP"}}}

@Component
public class CustomHealthIndicator implements HealthIndicator {
    @Override
    public Health health() {
        return Health.up().withDetail("custom", "OK").build();
    }
}

curl http://localhost:8080/actuator/metrics/jvm.memory.used
{"name":"jvm.memory.used","measurements":[{"statistic":"VALUE","value":123456789}]}

MeterRegistry registry;
Counter counter = registry.counter("orders.created");
counter.increment();

curl -X POST -H "Content-Type: application/json" -d '{"configuredLevel":"DEBUG"}' \
http://localhost:8080/actuator/loggers/com.example

curl http://localhost:8080/actuator/env

spring:
  security:
    user:
      name: admin
      password: password
management:
  endpoints:
    web:
      base-path: /actuator
      exposure:
        include: "*"

@Component
@Endpoint(id = "orders")
public class OrderEndpoint {
    @ReadOperation
    public Map<String, Object> getOrderStats() {
        return Map.of("total", 1000, "successRate", 0.99);
    }
}

@Component
@WebEndpoint(id = "custom")
public class CustomWebEndpoint {
    @ReadOperation
    public String getCustom() {
        return "Custom endpoint";
    }
}

@WriteOperation
public String updateConfig(@Selector String key, String value) {
    return "Updated " + key + " to " + value;
}

@Component
@Endpoint(id = "order-metrics")
public class OrderMetricsEndpoint {
    private final MeterRegistry registry;
    public OrderMetricsEndpoint(MeterRegistry registry) {
        this.registry = registry;
    }
    @ReadOperation
    public Map<String, Double> getMetrics() {
        return Map.of("orders.created", 
            registry.counter("orders.created").count());
    }
}

@Benchmark
public void accessCustomEndpoint() {
    restTemplate.getForObject("/actuator/orders", Map.class);
}

public Health health() {
    return Health.up().build();
}

Timer timer = registry.timer("order.process");
timer.record(() -> processOrder());

@ReadOperation
public Map<String, Object> getOrderStats() {}

curl -X POST -d '{"configuredLevel":"DEBUG"}' http://localhost:8080/actuator/loggers/com.example

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>ecommerce</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <java.version>21</java.version>
        <spring-boot.version>3.3.0</spring-boot.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>io.micrometer</groupId>
            <artifactId>micrometer-registry-prometheus</artifactId>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>9.1.0</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.13.0</version>
                <configuration>
                    <source>21</source>
                    <target>21</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

spring:
  application:
    name: ecommerce
  datasource:
    url: jdbc:mysql://mysql:3306/ecommerce
    username: root
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
  redis:
    host: redis
    port: 6379
  security:
    user:
      name: admin
      password: password
management:
  endpoints:
    web:
      exposure:
        include: health,metrics,info,loggers,prometheus,orders
      base-path: /actuator
  endpoint:
    health:
      show-details: always
    shutdown:
      enabled: false
logging:
  level:
    org.springframework: INFO

package com.example.ecommerce;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
@Entity
public class Order {
    @Id
    private String orderId;
    private String status;
    public Order() {}
    public Order(String orderId, String status) {
        this.orderId = orderId;
        this.status = status;
    }
    public String getOrderId() { return orderId; }
    public void setOrderId(String orderId) { this.orderId = orderId; }
    public String getStatus() { return status; }
    public void setStatus(String status) { this.status = status; }
}

package com.example.ecommerce;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
@Service
public class OrderService {
    private final OrderRepository repository;
    private final RedisTemplate<String, Order> redisTemplate;
    private final Timer orderTimer;
    private final Counter orderCounter;
    public OrderService(OrderRepository repository, RedisTemplate<String, Order> redisTemplate, 
                       MeterRegistry registry) {
        this.repository = repository;
        this.redisTemplate = redisTemplate;
        this.orderTimer = Timer.builder("order.process").register(registry);
        this.orderCounter = Counter.builder("orders.created").register(registry);
    }
    public Order createOrder(String orderId, String status) {
        return orderTimer.record(() -> {
            Order order = new Order(orderId, status);
            repository.save(order);
            redisTemplate.opsForValue().set(orderId, order);
            orderCounter.increment();
            return order;
        });
    }
    public Order getOrder(String orderId) {
        Order order = redisTemplate.opsForValue().get(orderId);
        if (order == null) {
            order = repository.findById(orderId).orElse(null);
            if (order != null) {
                redisTemplate.opsForValue().set(orderId, order);
            }
        }
        return order;
    }
    public double getSuccessRate() {
        return orderCounter.count() > 0 ? 0.99 : 0.0; // 模擬成功率
    }
}

package com.example.ecommerce;
import org.springframework.data.jpa.repository.JpaRepository;
public interface OrderRepository extends JpaRepository<Order, String> {}

package com.example.ecommerce;
import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
import org.springframework.boot.actuate.endpoint.annotation.ReadOperation;
import org.springframework.stereotype.Component;
import java.util.Map;
@Component
@Endpoint(id = "orders")
public class OrderEndpoint {
    private final OrderService orderService;
    public OrderEndpoint(OrderService orderService) {
        this.orderService = orderService;
    }
    @ReadOperation
    public Map<String, Object> getOrderStats() {
        return Map.of(
            "totalOrders", orderService.getSuccessRate() * 1000, // 模擬數(shù)據(jù)
            "successRate", orderService.getSuccessRate()
        );
    }
}

package com.example.ecommerce;
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;
@Component
public class OrderHealthIndicator implements HealthIndicator {
    private final OrderService orderService;
    public OrderHealthIndicator(OrderService orderService) {
        this.orderService = orderService;
    }
    @Override
    public Health health() {
        try {
            orderService.getOrder("test");
            return Health.up().withDetail("orderService", "OK").build();
        } catch (Exception e) {
            return Health.down().withDetail("orderService", "Error").build();
        }
    }
}

package com.example.ecommerce;
import org.springframework.web.bind.annotation.*;
@RestController
public class OrderController {
    private final OrderService orderService;
    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }
    @PostMapping("/orders")
    public Order createOrder(@RequestBody OrderRequest request) {
        return orderService.createOrder(request.orderId(), request.status());
    }
    @GetMapping("/orders/{id}")
    public Order getOrder(@PathVariable String id) {
        return orderService.getOrder(id);
    }
}
record OrderRequest(String orderId, String status) {}

package com.example.ecommerce;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;
@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/actuator/**").authenticated()
                .anyRequest().permitAll()
            )
            .httpBasic();
        return http.build();
    }
}

package com.example.ecommerce;
import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.stereotype.Component;
@Component
public class OrderMonitor {
    public OrderMonitor(MeterRegistry registry, OrderService orderService) {
        registry.gauge("order.success.rate", orderService, OrderService::getSuccessRate);
    }
}

scrape_configs:
  - job_name: 'ecommerce'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['ecommerce:8080']

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - name: mysql
        image: mysql:8.0
        ports:
        - containerPort: 3306
        env:
        - name: MYSQL_ROOT_PASSWORD
          value: password
        resources:
          requests:
            cpu: "500m"
            memory: "1Gi"
          limits:
            cpu: "1000m"
            memory: "2Gi"
---
apiVersion: v1
kind: Service
metadata:
  name: mysql
spec:
  ports:
  - port: 3306
    targetPort: 3306
  selector:
    app: mysql
  type: ClusterIP

apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis
spec:
  replicas: 1
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
    spec:
      containers:
      - name: redis
        image: redis:7.2
        ports:
        - containerPort: 6379
        resources:
          requests:
            cpu: "500m"
            memory: "1Gi"
          limits:
            cpu: "1000m"
            memory: "2Gi"
---
apiVersion: v1
kind: Service
metadata:
  name: redis
spec:
  ports:
  - port: 6379
    targetPort: 6379
  selector:
    app: redis
  type: ClusterIP

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ecommerce
spec:
  replicas: 50
  selector:
    matchLabels:
      app: ecommerce
  template:
    metadata:
      labels:
        app: ecommerce
    spec:
      containers:
      - name: ecommerce
        image: ecommerce:1.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: "500m"
            memory: "1Gi"
          limits:
            cpu: "1000m"
            memory: "2Gi"
        env:
        - name: JAVA_OPTS
          value: "-XX:+UseParallelGC -Xmx16g"
---
apiVersion: v1
kind: Service
metadata:
  name: ecommerce
spec:
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: ecommerce
  type: ClusterIP

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: ecommerce-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: ecommerce
  minReplicas: 50
  maxReplicas: 200
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

public Health health() {
    return Health.up().build();
}

Timer timer = registry.timer("order.process");

@ReadOperation
public Map<String, Object> getOrderStats() {}

.requestMatchers("/actuator/**").authenticated()

management:
  endpoints:
    web:
      exposure:
        include: health,metrics,prometheus

@Endpoint(id = "orders")
public class OrderEndpoint {}

.requestMatchers("/actuator/**").authenticated()

scrape_configs:
  - job_name: 'ecommerce'