1# Cloud Native - Spring Cloud
2 
3## Spring Cloud Config Server
4 
5```java
6// Config Server
7@SpringBootApplication
8@EnableConfigServer
9public class ConfigServerApplication {
10    public static void main(String[] args) {
11        SpringApplication.run(ConfigServerApplication.class, args);
12    }
13}
14 
15// application.yml
16server:
17  port: 8888
18 
19spring:
20  cloud:
21    config:
22      server:
23        git:
24          uri: https://github.com/example/config-repo
25          default-label: main
26          search-paths: '{application}'
27          username: ${GIT_USERNAME}
28          password: ${GIT_PASSWORD}
29        native:
30          search-locations: classpath:/config
31  security:
32    user:
33      name: config-user
34      password: ${CONFIG_PASSWORD}
35 
36// Config Client
37@SpringBootApplication
38public class ClientApplication {
39    public static void main(String[] args) {
40        SpringApplication.run(ClientApplication.class, args);
41    }
42}
43 
44// application.yml (Config Client)
45spring:
46  application:
47    name: user-service
48  config:
49    import: "configserver:http://localhost:8888"
50  cloud:
51    config:
52      username: config-user
53      password: ${CONFIG_PASSWORD}
54      fail-fast: true
55      retry:
56        max-attempts: 6
57        initial-interval: 1000
58```
59 
60## Dynamic Configuration Refresh
61 
62```java
63@RestController
64@RefreshScope
65public class ConfigController {
66    @Value("${app.feature.enabled:false}")
67    private boolean featureEnabled;
68 
69    @Value("${app.max-connections:100}")
70    private int maxConnections;
71 
72    @GetMapping("/config")
73    public Map<String, Object> getConfig() {
74        return Map.of(
75            "featureEnabled", featureEnabled,
76            "maxConnections", maxConnections
77        );
78    }
79}
80 
81// Refresh configuration via Actuator endpoint:
82// POST /actuator/refresh
83```
84 
85## Service Discovery - Eureka
86 
87```java
88// Eureka Server
89@SpringBootApplication
90@EnableEurekaServer
91public class EurekaServerApplication {
92    public static void main(String[] args) {
93        SpringApplication.run(EurekaServerApplication.class, args);
94    }
95}
96 
97// application.yml (Eureka Server)
98server:
99  port: 8761
100 
101eureka:
102  instance:
103    hostname: localhost
104  client:
105    register-with-eureka: false
106    fetch-registry: false
107    service-url:
108      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
109 
110// Eureka Client
111@SpringBootApplication
112@EnableDiscoveryClient
113public class UserServiceApplication {
114    public static void main(String[] args) {
115        SpringApplication.run(UserServiceApplication.class, args);
116    }
117}
118 
119// application.yml (Eureka Client)
120spring:
121  application:
122    name: user-service
123 
124eureka:
125  client:
126    service-url:
127      defaultZone: http://localhost:8761/eureka/
128    registry-fetch-interval-seconds: 5
129  instance:
130    prefer-ip-address: true
131    lease-renewal-interval-in-seconds: 10
132    lease-expiration-duration-in-seconds: 30
133```
134 
135## Spring Cloud Gateway
136 
137```java
138@SpringBootApplication
139public class GatewayApplication {
140    public static void main(String[] args) {
141        SpringApplication.run(GatewayApplication.class, args);
142    }
143 
144    @Bean
145    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
146        return builder.routes()
147            .route("user-service", r -> r
148                .path("/api/users/**")
149                .filters(f -> f
150                    .rewritePath("/api/users/(?<segment>.*)", "/users/${segment}")
151                    .addRequestHeader("X-Gateway", "Spring-Cloud-Gateway")
152                    .circuitBreaker(config -> config
153                        .setName("userServiceCircuitBreaker")
154                        .setFallbackUri("forward:/fallback/users")
155                    )
156                    .retry(config -> config
157                        .setRetries(3)
158                        .setStatuses(HttpStatus.SERVICE_UNAVAILABLE)
159                    )
160                )
161                .uri("lb://user-service")
162            )
163            .route("order-service", r -> r
164                .path("/api/orders/**")
165                .filters(f -> f
166                    .rewritePath("/api/orders/(?<segment>.*)", "/orders/${segment}")
167                    .requestRateLimiter(config -> config
168                        .setRateLimiter(redisRateLimiter())
169                        .setKeyResolver(userKeyResolver())
170                    )
171                )
172                .uri("lb://order-service")
173            )
174            .build();
175    }
176 
177    @Bean
178    public RedisRateLimiter redisRateLimiter() {
179        return new RedisRateLimiter(10, 20); // replenishRate, burstCapacity
180    }
181 
182    @Bean
183    public KeyResolver userKeyResolver() {
184        return exchange -> Mono.just(
185            exchange.getRequest().getHeaders().getFirst("X-User-Id")
186        );
187    }
188}
189 
190// application.yml (Gateway)
191spring:
192  cloud:
193    gateway:
194      discovery:
195        locator:
196          enabled: true
197          lower-case-service-id: true
198      default-filters:
199        - DedupeResponseHeader=Access-Control-Allow-Origin
200      globalcors:
201        cors-configurations:
202          '[/**]':
203            allowed-origins: "*"
204            allowed-methods:
205              - GET
206              - POST
207              - PUT
208              - DELETE
209            allowed-headers: "*"
210```
211 
212## Circuit Breaker - Resilience4j
213 
214```java
215@Service
216@RequiredArgsConstructor
217public class ExternalApiService {
218    private final WebClient webClient;
219 
220    @CircuitBreaker(name = "externalApi", fallbackMethod = "getFallbackData")
221    @Retry(name = "externalApi")
222    @RateLimiter(name = "externalApi")
223    public Mono<ExternalData> getData(String id) {
224        return webClient
225            .get()
226            .uri("/data/{id}", id)
227            .retrieve()
228            .bodyToMono(ExternalData.class)
229            .timeout(Duration.ofSeconds(3));
230    }
231 
232    private Mono<ExternalData> getFallbackData(String id, Exception e) {
233        log.warn("Fallback triggered for id: {}, error: {}", id, e.getMessage());
234        return Mono.just(new ExternalData(id, "Fallback data", LocalDateTime.now()));
235    }
236}
237 
238// application.yml
239resilience4j:
240  circuitbreaker:
241    instances:
242      externalApi:
243        register-health-indicator: true
244        sliding-window-size: 10
245        minimum-number-of-calls: 5
246        permitted-number-of-calls-in-half-open-state: 3
247        automatic-transition-from-open-to-half-open-enabled: true
248        wait-duration-in-open-state: 5s
249        failure-rate-threshold: 50
250        event-consumer-buffer-size: 10
251 
252  retry:
253    instances:
254      externalApi:
255        max-attempts: 3
256        wait-duration: 1s
257        enable-exponential-backoff: true
258        exponential-backoff-multiplier: 2
259 
260  ratelimiter:
261    instances:
262      externalApi:
263        limit-for-period: 10
264        limit-refresh-period: 1s
265        timeout-duration: 0s
266```
267 
268## Distributed Tracing - Micrometer Tracing
269 
270```java
271// application.yml
272management:
273  tracing:
274    sampling:
275      probability: 1.0
276  zipkin:
277    tracing:
278      endpoint: http://localhost:9411/api/v2/spans
279 
280logging:
281  pattern:
282    level: "%5p [${spring.application.name:},%X{traceId:-},%X{spanId:-}]"
283 
284// Custom spans
285@Service
286@RequiredArgsConstructor
287public class OrderService {
288    private final Tracer tracer;
289    private final OrderRepository orderRepository;
290 
291    public Order processOrder(OrderRequest request) {
292        Span span = tracer.nextSpan().name("processOrder").start();
293        try (Tracer.SpanInScope ws = tracer.withSpan(span)) {
294            span.tag("order.type", request.type());
295            span.tag("order.items", String.valueOf(request.items().size()));
296 
297            // Business logic
298            Order order = createOrder(request);
299 
300            span.event("order.created");
301            return order;
302        } finally {
303            span.end();
304        }
305    }
306}
307```
308 
309## Load Balancing with Spring Cloud LoadBalancer
310 
311```java
312@Configuration
313@LoadBalancerClient(name = "user-service", configuration = UserServiceLoadBalancerConfig.class)
314public class LoadBalancerConfiguration {
315}
316 
317@Configuration
318public class UserServiceLoadBalancerConfig {
319 
320    @Bean
321    public ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(
322            LoadBalancerClientFactory clientFactory,
323            ObjectProvider<LoadBalancerProperties> properties) {
324        return new RandomLoadBalancer(
325            clientFactory.getLazyProvider("user-service", ServiceInstanceListSupplier.class),
326            "user-service"
327        );
328    }
329}
330 
331@Service
332@RequiredArgsConstructor
333public class UserClientService {
334    private final WebClient.Builder webClientBuilder;
335 
336    public Mono<User> getUser(Long id) {
337        return webClientBuilder
338            .baseUrl("http://user-service")
339            .build()
340            .get()
341            .uri("/users/{id}", id)
342            .retrieve()
343            .bodyToMono(User.class);
344    }
345}
346```
347 
348## Health Checks & Actuator
349 
350```java
351@Component
352public class CustomHealthIndicator implements HealthIndicator {
353 
354    @Override
355    public Health health() {
356        boolean serviceUp = checkExternalService();
357 
358        if (serviceUp) {
359            return Health.up()
360                .withDetail("externalService", "Available")
361                .withDetail("timestamp", LocalDateTime.now())
362                .build();
363        } else {
364            return Health.down()
365                .withDetail("externalService", "Unavailable")
366                .withDetail("error", "Connection timeout")
367                .build();
368        }
369    }
370 
371    private boolean checkExternalService() {
372        // Check external dependency
373        return true;
374    }
375}
376 
377// application.yml
378management:
379  endpoints:
380    web:
381      exposure:
382        include: health,info,metrics,prometheus
383  endpoint:
384    health:
385      show-details: always
386      probes:
387        enabled: true
388  health:
389    livenessState:
390      enabled: true
391    readinessState:
392      enabled: true
393  metrics:
394    export:
395      prometheus:
396        enabled: true
397    tags:
398      application: ${spring.application.name}
399```
400 
401## Kubernetes Deployment
402 
403```yaml
404# deployment.yaml
405apiVersion: apps/v1
406kind: Deployment
407metadata:
408  name: user-service
409spec:
410  replicas: 3
411  selector:
412    matchLabels:
413      app: user-service
414  template:
415    metadata:
416      labels:
417        app: user-service
418    spec:
419      containers:
420      - name: user-service
421        image: user-service:1.0.0
422        ports:
423        - containerPort: 8080
424        env:
425        - name: SPRING_PROFILES_ACTIVE
426          value: "kubernetes"
427        - name: JAVA_OPTS
428          value: "-Xmx512m -Xms256m"
429        livenessProbe:
430          httpGet:
431            path: /actuator/health/liveness
432            port: 8080
433          initialDelaySeconds: 60
434          periodSeconds: 10
435        readinessProbe:
436          httpGet:
437            path: /actuator/health/readiness
438            port: 8080
439          initialDelaySeconds: 30
440          periodSeconds: 5
441        resources:
442          requests:
443            memory: "512Mi"
444            cpu: "500m"
445          limits:
446            memory: "1Gi"
447            cpu: "1000m"
448---
449apiVersion: v1
450kind: Service
451metadata:
452  name: user-service
453spec:
454  selector:
455    app: user-service
456  ports:
457  - port: 80
458    targetPort: 8080
459  type: ClusterIP
460```
461 
462## Docker Configuration
463 
464```dockerfile
465# Dockerfile (Multi-stage)
466FROM eclipse-temurin:17-jdk-alpine AS build
467WORKDIR /workspace/app
468 
469COPY mvnw .
470COPY .mvn .mvn
471COPY pom.xml .
472COPY src src
473 
474RUN ./mvnw install -DskipTests
475RUN mkdir -p target/dependency && (cd target/dependency; jar -xf ../*.jar)
476 
477FROM eclipse-temurin:17-jre-alpine
478VOLUME /tmp
479ARG DEPENDENCY=/workspace/app/target/dependency
480COPY --from=build ${DEPENDENCY}/BOOT-INF/lib /app/lib
481COPY --from=build ${DEPENDENCY}/META-INF /app/META-INF
482COPY --from=build ${DEPENDENCY}/BOOT-INF/classes /app
483 
484ENTRYPOINT ["java","-cp","app:app/lib/*","com.example.Application"]
485```
486 
487## Quick Reference
488 
489| Component | Purpose |
490|-----------|---------|
491| **Config Server** | Centralized configuration management |
492| **Eureka** | Service discovery and registration |
493| **Gateway** | API gateway with routing, filtering, load balancing |
494| **Circuit Breaker** | Fault tolerance and fallback patterns |
495| **Load Balancer** | Client-side load balancing |
496| **Tracing** | Distributed tracing across services |
497| **Actuator** | Production-ready monitoring and management |
498| **Kubernetes** | Container orchestration and deployment |
499