Spring Boot 2.3 – Graceful Shutdown w Praktyce

Dlaczego graceful shutdown jest ważny?

Gdy aplikacja zostaje wyłączona w środku przetwarzania requestu, użytkownik może stracić dane lub otrzymać błąd 500. W środowisku produkcyjnym, gdzie deployments odbywają się regularnie, graceful shutdown to różnica między zadowolonymi użytkownikami a support tickets o zaginionych transakcjach.

Z perspektywy biznesowej oznacza to zero downtime deployments, lepsze user experience i mniej problemów operacyjnych podczas aktualizacji systemu.

Czym jest graceful shutdown?

Gdy aplikacja otrzymuje sygnał wyłączenia (SIGTERM), graceful shutdown:
1. **Przestaje przyjmować nowe requesty**
2. **Kończy aktywne requesty** w określonym czasie
3. **Wywołuje cleanup hooks** (zamykanie połączeń DB, cache, etc.)
4. **Wyłącza się** po zakończeniu wszystkich operacji

Konfiguracja graceful shutdown w Spring Boot 2.3

Podstawowa konfiguracja w application.yml:

server:
  shutdown: graceful
spring:
  lifecycle:
    timeout-per-shutdown-phase: 30s

Alternatywnie w application.properties:

server.shutdown=graceful
spring.lifecycle.timeout-per-shutdown-phase=30s

Jak to działa w praktyce?

Przykład kontrolera który symuluje długotrwałe operacje:

@RestController
public class OrderController {
    
    private static final Logger logger = LoggerFactory.getLogger(OrderController.class);
    
    @PostMapping("/api/orders")
    public ResponseEntity processOrder(@RequestBody OrderRequest request) {
        logger.info("Starting order processing for: {}", request.getOrderId());
        
        try {
            // Symulacja długotrwałego przetwarzania (np. płatność, walidacja)
            Thread.sleep(10000); // 10 sekund
            
            OrderResponse response = OrderResponse.builder()
                .orderId(request.getOrderId())
                .status("COMPLETED")
                .processedAt(LocalDateTime.now())
                .build();
                
            logger.info("Order processing completed: {}", request.getOrderId());
            return ResponseEntity.ok(response);
            
        } catch (InterruptedException e) {
            logger.warn("Order processing interrupted: {}", request.getOrderId());
            return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
                .body(OrderResponse.builder()
                    .orderId(request.getOrderId())
                    .status("PROCESSING_INTERRUPTED")
                    .build());
        }
    }
}

Custom shutdown hooks

Możesz dodać własne operacje cleanup używając @PreDestroy lub custom hooks:

@Service
public class OrderProcessingService {
    
    private final ExecutorService executorService = Executors.newFixedThreadPool(10);
    private final Logger logger = LoggerFactory.getLogger(OrderProcessingService.class);
    
    @PreDestroy
    public void cleanup() {
        logger.info("Starting graceful shutdown of OrderProcessingService");
        
        executorService.shutdown();
        
        try {
            // Czekaj maksymalnie 20 sekund na zakończenie zadań
            if (!executorService.awaitTermination(20, TimeUnit.SECONDS)) {
                logger.warn("Some tasks didn't complete within timeout, forcing shutdown");
                executorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            logger.error("Shutdown interrupted", e);
            executorService.shutdownNow();
            Thread.currentThread().interrupt();
        }
        
        logger.info("OrderProcessingService shutdown completed");
    }
}

Alternative approach z DisposableBean:

@Component
public class DatabaseConnectionManager implements DisposableBean {
    
    private final Logger logger = LoggerFactory.getLogger(DatabaseConnectionManager.class);
    
    @Override
    public void destroy() throws Exception {
        logger.info("Closing database connections gracefully");
        
        // Zamknij connection pools
        // Flush pending transactions  
        // Clear caches
        
        logger.info("Database connections closed");
    }
}

Monitoring graceful shutdown

Dodaj logging żeby monitorować proces wyłączania:

logging:
  level:
    org.springframework.boot.web.embedded.tomcat: INFO
    org.springframework.context.support: DEBUG
  pattern:
    console: "%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"

Przykład custom ActuatorEndpoint dla monitoring:

@Component
@Endpoint(id = "shutdown-status")
public class ShutdownStatusEndpoint {
    
    private volatile boolean shutdownInitiated = false;
    private LocalDateTime shutdownStartTime;
    
    @EventListener
    public void handleContextClosedEvent(ContextClosedEvent event) {
        shutdownInitiated = true;
        shutdownStartTime = LocalDateTime.now();
    }
    
    @ReadOperation
    public Map shutdownStatus() {
        Map status = new HashMap<>();
        status.put("shutdownInitiated", shutdownInitiated);
        if (shutdownStartTime != null) {
            status.put("shutdownStartTime", shutdownStartTime);
            status.put("shutdownDuration", Duration.between(shutdownStartTime, LocalDateTime.now()).getSeconds());
        }
        return status;
    }
}

Różne strategie dla różnych aplikacji

Testing graceful shutdown

Prosty test integracyjny:

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class GracefulShutdownTest {
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @LocalServerPort
    private int port;
    
    @Test
    void shouldCompleteRequestsBeforeShutdown() throws Exception {
        // Uruchom długotrwały request w osobnym wątku
        CompletableFuture> future = CompletableFuture.supplyAsync(() -> {
            return restTemplate.postForEntity(
                "http://localhost:" + port + "/api/long-running-task",
                new TaskRequest("test"),
                String.class
            );
        });
        
        // Poczekaj chwilę i wyślij sygnał shutdown
        Thread.sleep(1000);
        // W prawdziwym teście użyj SpringApplication.exit() lub podobne
        
        // Sprawdź czy request się ukończył pomyślnie
        ResponseEntity response = future.get(45, TimeUnit.SECONDS);
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
    }
}

Przydatne zasoby:

• Spring Boot 2.3.0 Release Notes
• Spring Boot Graceful Shutdown Documentation
• GitHub Issue – Graceful Shutdown Feature Request
• Baeldung – Spring Boot Graceful Shutdown

Jak planujesz wykorzystać graceful shutdown w swoich projektach? Podziel się swoimi doświadczeniami z deployment w komentarzach!