微服务架构师知识储备体系与学习路径

最新推荐文章于 2025-11-24 15:45:35 发布

原创最新推荐文章于 2025-11-24 15:45:35 发布 · 1.1k 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#微服务 #学习 #架构

微服务专栏收录该内容

7 篇文章

订阅专栏

微服务架构师知识储备体系与学习路径

1. 微服务架构师核心能力

1.1 技术决策能力

技术选型原则

业务匹配度：技术方案与业务需求的契合度
团队技术栈：考虑团队现有技术能力
社区活跃度：技术生态的成熟度和社区支持
性能要求：满足系统的性能指标
可维护性：代码的可读性和可维护性

架构权衡决策

1.2 系统设计能力

高可用设计

多活架构：异地多活、同城双活
容灾设计：故障隔离、快速恢复
降级策略：服务降级、功能降级
熔断机制：防止雪崩效应

可扩展性设计

水平扩展：无状态服务、负载均衡
垂直扩展：硬件升级、资源优化
弹性伸缩：自动扩缩容、资源调度

1.3 团队协作能力

技术沟通

架构文档：清晰的技术文档和架构图
技术评审：代码审查、架构评审
技术分享：团队技术分享和培训

项目管理

技术规划：技术路线图制定
风险控制：技术风险评估和应对
质量保证：代码质量、测试覆盖率

2. 技术知识储备体系

2.1 微服务基础理论

2.1.1 微服务核心概念

服务拆分原则

单一职责：每个服务只负责一个业务功能
高内聚低耦合：服务内部紧密相关，服务间松耦合
数据独立：每个服务拥有独立的数据存储
技术无关：服务间技术栈可以不同

服务边界识别

// 领域驱动设计示例
// 用户领域
public class User {
    private UserId id;
    private String name;
    private Email email;
    private UserStatus status;
}

// 订单领域
public class Order {
    private OrderId id;
    private UserId userId;
    private List<OrderItem> items;
    private OrderStatus status;
}

2.1.2 微服务架构模式

服务发现模式

# Eureka 服务注册配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 30

API网关模式

// Spring Cloud Gateway 配置
@Configuration
public class GatewayConfig {
  
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("user-service", r -> r.path("/api/users/**")
                .filters(f -> f.stripPrefix(2))
                .uri("lb://user-service"))
            .route("order-service", r -> r.path("/api/orders/**")
                .filters(f -> f.stripPrefix(2))
                .uri("lb://order-service"))
            .build();
    }
}

2.2 服务治理技术

2.2.1 负载均衡

客户端负载均衡

// Ribbon 配置
@Configuration
public class RibbonConfig {
  
    @Bean
    public IRule ribbonRule() {
        return new RandomRule(); // 随机策略
    }
  
    @Bean
    public IPing ribbonPing() {
        return new PingUrl();
    }
}

服务端负载均衡

# Nginx 配置
upstream user-service {
    server user-service-1:8080 weight=3;
    server user-service-2:8080 weight=2;
    server user-service-3:8080 weight=1;
}

server {
    listen 80;
    location /api/users/ {
        proxy_pass http://user-service;
    }
}

2.2.2 熔断降级

Hystrix 熔断器

@Component
public class UserServiceClient {
  
    @HystrixCommand(fallbackMethod = "getUserFallback",
                   commandProperties = {
                       @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
                       @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50")
                   })
    public User getUserById(Long id) {
        return userService.getUserById(id);
    }
  
    public User getUserFallback(Long id) {
        return User.builder()
            .id(id)
            .name("用户暂时不可用")
            .build();
    }
}

Sentinel 流量控制

@Component
public class UserService {
  
    @SentinelResource(value = "getUser", 
                     fallback = "getUserFallback",
                     blockHandler = "getUserBlockHandler")
    public User getUserById(Long id) {
        return userRepository.findById(id);
    }
  
    public User getUserFallback(Long id, Throwable ex) {
        return User.builder().id(id).name("服务降级").build();
    }
  
    public User getUserBlockHandler(Long id, BlockException ex) {
        return User.builder().id(id).name("服务限流").build();
    }
}

2.3 API网关技术

2.3.1 网关功能实现

认证授权

@Configuration
public class SecurityConfig {
  
    @Bean
    public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
        return http
            .authorizeExchange()
            .pathMatchers("/api/public/**").permitAll()
            .pathMatchers("/api/**").authenticated()
            .and()
            .oauth2ResourceServer()
            .jwt()
            .and()
            .build();
    }
}

限流配置

@Configuration
public class RateLimitConfig {
  
    @Bean
    public RedisRateLimiter redisRateLimiter() {
        return new RedisRateLimiter(10, 20); // 10个请求/秒，突发20个
    }
  
    @Bean
    public KeyResolver userKeyResolver() {
        return exchange -> Mono.just(
            exchange.getRequest().getQueryParams().getFirst("user"));
    }
}

2.3.2 网关技术选型

技术	语言	性能	功能	学习成本	推荐场景
Spring Cloud Gateway	Java	高	丰富	低	Spring 生态
Kong	Lua	很高	插件化	中	企业级
Zuul	Java	中	基础	低	简单场景
Nginx	C	极高	基础	中	高性能需求

2.4 配置管理

2.4.1 配置中心架构

2.4.2 配置管理实现

Nacos 配置中心

# application.yml
spring:
  cloud:
    nacos:
      config:
        server-addr: localhost:8848
        file-extension: yaml
        namespace: dev
        group: DEFAULT_GROUP

Apollo 配置中心

@Configuration
public class ApolloConfig {
  
    @ApolloConfig
    private Config config;
  
    @Value("${app.timeout:5000}")
    private int timeout;
  
    @ApolloConfigChangeListener
    private void onChange(ConfigChangeEvent changeEvent) {
        if (changeEvent.isChanged("app.timeout")) {
            timeout = config.getIntProperty("app.timeout", 5000);
        }
    }
}

2.5 服务间通信

2.5.1 同步通信

REST API

@FeignClient(name = "user-service", 
             fallback = UserServiceFallback.class)
public interface UserServiceClient {
  
    @GetMapping("/users/{id}")
    User getUserById(@PathVariable Long id);
  
    @PostMapping("/users")
    User createUser(@RequestBody CreateUserRequest request);
}

@Component
public class UserServiceFallback implements UserServiceClient {
  
    @Override
    public User getUserById(Long id) {
        return User.builder().id(id).name("服务不可用").build();
    }
}

gRPC 通信

// user.proto
syntax = "proto3";

service UserService {
    rpc GetUser(GetUserRequest) returns (GetUserResponse);
    rpc CreateUser(CreateUserRequest) returns (CreateUserResponse);
}

message GetUserRequest {
    int64 id = 1;
}

message GetUserResponse {
    int64 id = 1;
    string name = 2;
    string email = 3;
}

// gRPC 客户端
@Component
public class UserGrpcClient {
  
    private final UserServiceGrpc.UserServiceBlockingStub stub;
  
    public UserGrpcClient(Channel channel) {
        this.stub = UserServiceGrpc.newBlockingStub(channel);
    }
  
    public UserResponse getUser(Long id) {
        GetUserRequest request = GetUserRequest.newBuilder()
            .setId(id)
            .build();
        return stub.getUser(request);
    }
}

2.5.2 异步通信

消息队列

// RabbitMQ 消息发送
@Component
public class OrderEventPublisher {
  
    @Autowired
    private RabbitTemplate rabbitTemplate;
  
    public void publishOrderCreated(Order order) {
        OrderCreatedEvent event = OrderCreatedEvent.builder()
            .orderId(order.getId())
            .userId(order.getUserId())
            .amount(order.getAmount())
            .build();
          
        rabbitTemplate.convertAndSend("order.exchange", 
            "order.created", event);
    }
}

// 消息消费
@RabbitListener(queues = "order.created.queue")
public void handleOrderCreated(OrderCreatedEvent event) {
    // 处理订单创建事件
    inventoryService.reserveStock(event.getOrderId());
    paymentService.processPayment(event.getOrderId());
}

事件驱动架构

// 事件发布
@Component
public class DomainEventPublisher {
  
    @Autowired
    private ApplicationEventPublisher eventPublisher;
  
    public void publishOrderCreated(Order order) {
        OrderCreatedEvent event = new OrderCreatedEvent(order);
        eventPublisher.publishEvent(event);
    }
}

// 事件监听
@EventListener
public void handleOrderCreated(OrderCreatedEvent event) {
    // 发送通知
    notificationService.sendOrderConfirmation(event.getOrder());
  
    // 更新库存
    inventoryService.updateStock(event.getOrder().getItems());
}

2.6 数据管理

2.6.1 数据库设计

数据库分离

-- 用户服务数据库
CREATE DATABASE user_service;
USE user_service;
CREATE TABLE users (
    id BIGINT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- 订单服务数据库
CREATE DATABASE order_service;
USE order_service;
CREATE TABLE orders (
    id BIGINT PRIMARY KEY,
    user_id BIGINT NOT NULL,
    amount DECIMAL(10,2) NOT NULL,
    status VARCHAR(20) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

分布式事务 - Saga模式

@Component
public class OrderSaga {
  
    @SagaOrchestrationStart
    public void handle(OrderCreatedEvent event) {
        // 1. 创建订单
        Order order = orderService.createOrder(event.getOrderRequest());
      
        // 2. 扣减库存
        InventoryReserveCommand command = InventoryReserveCommand.builder()
            .orderId(order.getId())
            .items(order.getItems())
            .build();
        commandGateway.send(command);
    }
  
    @SagaOrchestrationAssociate
    public void handle(InventoryReservedEvent event) {
        // 3. 扣减账户余额
        PaymentProcessCommand command = PaymentProcessCommand.builder()
            .orderId(event.getOrderId())
            .amount(event.getAmount())
            .build();
        commandGateway.send(command);
    }
  
    @SagaOrchestrationAssociate
    public void handle(PaymentProcessedEvent event) {
        // 4. 发送通知
        notificationService.sendOrderConfirmation(event.getOrderId());
    }
}

2.6.2 数据一致性

最终一致性实现

@Service
public class OrderService {
  
    @Autowired
    private OrderRepository orderRepository;
  
    @Autowired
    private OutboxEventRepository outboxRepository;
  
    @Transactional
    public Order createOrder(CreateOrderRequest request) {
        // 1. 创建订单
        Order order = orderRepository.save(Order.from(request));
      
        // 2. 记录事件到本地数据库
        OutboxEvent event = OutboxEvent.builder()
            .aggregateId(order.getId())
            .eventType("OrderCreated")
            .eventData(JSON.toJSONString(order))
            .status(EventStatus.PENDING)
            .build();
        outboxRepository.save(event);
      
        return order;
    }
}

// 事件发布器
@Component
public class OutboxEventPublisher {
  
    @Scheduled(fixedDelay = 5000)
    public void publishEvents() {
        List<OutboxEvent> events = outboxRepository.findPendingEvents();
      
        for (OutboxEvent event : events) {
            try {
                // 发布事件
                eventPublisher.publishEvent(event);
              
                // 标记为已发布
                event.setStatus(EventStatus.PUBLISHED);
                outboxRepository.save(event);
            } catch (Exception e) {
                log.error("Failed to publish event: {}", event.getId(), e);
            }
        }
    }
}

2.7 监控与运维

2.7.1 监控体系

Prometheus + Grafana

# prometheus.yml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'microservices'
    static_configs:
      - targets: ['user-service:8080', 'order-service:8080']
    metrics_path: '/actuator/prometheus'

应用监控

@Component
public class CustomMetrics {
  
    private final MeterRegistry meterRegistry;
    private final Counter orderCreatedCounter;
    private final Timer orderProcessingTimer;
  
    public CustomMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.orderCreatedCounter = Counter.builder("orders.created")
            .description("Number of orders created")
            .register(meterRegistry);
        this.orderProcessingTimer = Timer.builder("orders.processing.time")
            .description("Order processing time")
            .register(meterRegistry);
    }
  
    public void recordOrderCreated() {
        orderCreatedCounter.increment();
    }
  
    public Timer.Sample startOrderProcessing() {
        return Timer.start(meterRegistry);
    }
}

2.7.2 分布式链路追踪

Zipkin 集成

@Configuration
public class TracingConfig {
  
    @Bean
    public Sender sender() {
        return OkHttpSender.create("http://localhost:9411/api/v2/spans");
    }
  
    @Bean
    public AsyncReporter<Span> spanReporter() {
        return AsyncReporter.create(sender());
    }
  
    @Bean
    public Tracing tracing() {
        return Tracing.newBuilder()
            .localServiceName("user-service")
            .spanReporter(spanReporter())
            .sampler(Sampler.create(0.1f))
            .build();
    }
}

自定义链路追踪

@RestController
public class OrderController {
  
    @Autowired
    private Tracer tracer;
  
    @GetMapping("/orders/{id}")
    public ResponseEntity<Order> getOrder(@PathVariable Long id) {
        Span span = tracer.nextSpan()
            .name("get-order")
            .tag("order.id", id.toString())
            .start();
          
        try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) {
            Order order = orderService.getOrderById(id);
            return ResponseEntity.ok(order);
        } finally {
            span.end();
        }
    }
}

2.8 容器化与编排

2.8.1 Docker 容器化

Dockerfile 优化

# 多阶段构建
FROM maven:3.8.4-openjdk-11-slim AS build
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn clean package -DskipTests

FROM openjdk:11-jre-slim
WORKDIR /app
COPY --from=build /app/target/service.jar app.jar

# 非root用户运行
RUN addgroup --system spring && adduser --system spring --ingroup spring
USER spring:spring

EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app.jar"]

Docker Compose

version: '3.8'

services:
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: microservices
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql

  redis:
    image: redis:6.2-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

  user-service:
    build: ./user-service
    ports:
      - "8081:8080"
    environment:
      - SPRING_DATASOURCE_URL=jdbc:mysql://mysql:3306/microservices
      - SPRING_REDIS_HOST=redis
    depends_on:
      - mysql
      - redis

volumes:
  mysql_data:
  redis_data:

2.8.2 Kubernetes 编排

Deployment 配置

apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: user-service:latest
        ports:
        - containerPort: 8080
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "k8s"
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5

Service 配置

apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
  - port: 80
    targetPort: 8080
  type: ClusterIP

2.9 安全与认证

2.9.1 服务间认证

JWT 服务间认证

@Component
public class ServiceAuthInterceptor implements ClientHttpRequestInterceptor {
  
    @Autowired
    private JwtTokenProvider jwtTokenProvider;
  
    @Override
    public ClientHttpResponse intercept(
            HttpRequest request, 
            byte[] body, 
            ClientHttpRequestExecution execution) throws IOException {
      
        String token = jwtTokenProvider.generateServiceToken();
        request.getHeaders().setBearerAuth(token);
      
        return execution.execute(request, body);
    }
}

@Service
public class JwtTokenProvider {
  
    @Value("${jwt.secret}")
    private String secret;
  
    public String generateServiceToken() {
        Map<String, Object> claims = new HashMap<>();
        claims.put("service", "user-service");
        claims.put("iat", System.currentTimeMillis() / 1000);
        claims.put("exp", (System.currentTimeMillis() / 1000) + 3600);
      
        return Jwts.builder()
            .setClaims(claims)
            .signWith(SignatureAlgorithm.HS256, secret)
            .compact();
    }
}

2.9.2 API 安全

OAuth2 资源服务器

@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
  
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/api/public/**").permitAll()
            .antMatchers("/api/admin/**").hasRole("ADMIN")
            .antMatchers("/api/**").authenticated()
            .and()
            .csrf().disable();
    }
  
    @Override
    public void configure(ResourceServerSecurityConfigurer resources) {
        resources.resourceId("microservices-api");
    }
}

2.10 性能优化

2.10.1 缓存策略

Redis 缓存

@Service
public class UserService {
  
    @Autowired
    private UserRepository userRepository;
  
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
  
    private static final String USER_CACHE_KEY = "user:";
    private static final long CACHE_TTL = 3600; // 1小时
  
    @Cacheable(value = "users", key = "#id")
    public User getUserById(Long id) {
        return userRepository.findById(id);
    }
  
    @CacheEvict(value = "users", key = "#user.id")
    public User updateUser(User user) {
        User updatedUser = userRepository.save(user);
      
        // 更新缓存
        String cacheKey = USER_CACHE_KEY + user.getId();
        redisTemplate.opsForValue().set(cacheKey, updatedUser, CACHE_TTL, TimeUnit.SECONDS);
      
        return updatedUser;
    }
}

多级缓存

@Component
public class MultiLevelCache {
  
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
  
    private final Cache<String, Object> localCache = Caffeine.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(5, TimeUnit.MINUTES)
        .build();
  
    public Object get(String key) {
        // 1. 本地缓存
        Object value = localCache.getIfPresent(key);
        if (value != null) {
            return value;
        }
      
        // 2. Redis缓存
        value = redisTemplate.opsForValue().get(key);
        if (value != null) {
            localCache.put(key, value);
            return value;
        }
      
        // 3. 数据库
        value = loadFromDatabase(key);
        if (value != null) {
            localCache.put(key, value);
            redisTemplate.opsForValue().set(key, value, 3600, TimeUnit.SECONDS);
        }
      
        return value;
    }
}

2.10.2 数据库优化

连接池配置

# application.yml
spring:
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000
      leak-detection-threshold: 60000

查询优化

@Repository
public class UserRepository {
  
    @Query("SELECT u FROM User u WHERE u.email = :email")
    @QueryHints(@QueryHint(name = "org.hibernate.cacheable", value = "true"))
    User findByEmail(@Param("email") String email);
  
    @Query("SELECT u FROM User u WHERE u.status = :status AND u.createdAt >= :startDate")
    List<User> findActiveUsersSince(@Param("status") UserStatus status, 
                                   @Param("startDate") LocalDateTime startDate);
}

2.11 测试策略

2.11.1 测试金字塔

单元测试

@ExtendWith(MockitoExtension.class)
class UserServiceTest {
  
    @Mock
    private UserRepository userRepository;
  
    @InjectMocks
    private UserService userService;
  
    @Test
    void shouldCreateUser() {
        // Given
        CreateUserRequest request = CreateUserRequest.builder()
            .name("John Doe")
            .email("john@example.com")
            .build();
      
        User expectedUser = User.builder()
            .id(1L)
            .name("John Doe")
            .email("john@example.com")
            .build();
      
        when(userRepository.save(any(User.class))).thenReturn(expectedUser);
      
        // When
        User result = userService.createUser(request);
      
        // Then
        assertThat(result.getName()).isEqualTo("John Doe");
        assertThat(result.getEmail()).isEqualTo("john@example.com");
    }
}

集成测试

@SpringBootTest
@Testcontainers
class UserServiceIntegrationTest {
  
    @Container
    static MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8.0")
        .withDatabaseName("testdb")
        .withUsername("test")
        .withPassword("test");
  
    @Autowired
    private UserService userService;
  
    @Test
    void shouldCreateAndRetrieveUser() {
        // Given
        CreateUserRequest request = CreateUserRequest.builder()
            .name("John Doe")
            .email("john@example.com")
            .build();
      
        // When
        User createdUser = userService.createUser(request);
        User retrievedUser = userService.getUserById(createdUser.getId());
      
        // Then
        assertThat(retrievedUser.getName()).isEqualTo("John Doe");
        assertThat(retrievedUser.getEmail()).isEqualTo("john@example.com");
    }
}

契约测试

@ExtendWith(PactConsumerTestExt.class)
class UserServiceContractTest {
  
    @Pact(consumer = "order-service", provider = "user-service")
    RequestResponsePact getUserPact(PactDslWithProvider builder) {
        return builder
            .given("user exists")
            .uponReceiving("get user request")
            .path("/users/1")
            .method("GET")
            .willRespondWith()
            .status(200)
            .headers(Map.of("Content-Type", "application/json"))
            .body("""
                {
                    "id": 1,
                    "name": "John Doe",
                    "email": "john@example.com"
                }
                """)
            .toPact();
    }
  
    @Test
    @PactTestFor(pactMethod = "getUserPact")
    void testGetUser(MockServer mockServer) {
        // Given
        String userServiceUrl = mockServer.getUrl();
      
        // When
        User user = userServiceClient.getUser(1L);
      
        // Then
        assertThat(user.getId()).isEqualTo(1L);
        assertThat(user.getName()).isEqualTo("John Doe");
    }
}

2.12 DevOps实践

2.12.1 CI/CD 流水线

Jenkinsfile

pipeline {
    agent any
  
    environment {
        DOCKER_REGISTRY = 'your-registry.com'
        IMAGE_NAME = 'microservices'
    }
  
    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
      
        stage('Build') {
            steps {
                sh 'mvn clean package -DskipTests'
            }
        }
      
        stage('Test') {
            steps {
                sh 'mvn test'
            }
            post {
                always {
                    publishTestResults testResultsPattern: 'target/surefire-reports/*.xml'
                }
            }
        }
      
        stage('Docker Build') {
            steps {
                script {
                    def image = docker.build("${DOCKER_REGISTRY}/${IMAGE_NAME}:${BUILD_NUMBER}")
                    docker.withRegistry("https://${DOCKER_REGISTRY}", 'docker-registry-credentials') {
                        image.push()
                        image.push('latest')
                    }
                }
            }
        }
      
        stage('Deploy to K8s') {
            steps {
                sh 'kubectl apply -f k8s/'
                sh 'kubectl rollout restart deployment/microservices'
            }
        }
    }
  
    post {
        always {
            cleanWs()
        }
        failure {
            emailext (
                subject: "Build Failed: ${env.JOB_NAME} - ${env.BUILD_NUMBER}",
                body: "Build failed. Check console output at ${env.BUILD_URL}",
                to: "team@example.com"
            )
        }
    }
}

2.12.2 基础设施即代码

Terraform 配置

# main.tf
provider "aws" {
  region = "us-west-2"
}

resource "aws_ecs_cluster" "microservices" {
  name = "microservices-cluster"
  
  setting {
    name  = "containerInsights"
    value = "enabled"
  }
}

resource "aws_ecs_service" "user_service" {
  name            = "user-service"
  cluster         = aws_ecs_cluster.microservices.id
  task_definition = aws_ecs_task_definition.user_service.arn
  desired_count   = 3
  
  load_balancer {
    target_group_arn = aws_lb_target_group.user_service.arn
    container_name   = "user-service"
    container_port   = 8080
  }
}

resource "aws_ecs_task_definition" "user_service" {
  family                   = "user-service"
  network_mode             = "awsvpc"
  requires_compatibilities = ["FARGATE"]
  cpu                      = "256"
  memory                   = "512"
  
  container_definitions = jsonencode([
    {
      name  = "user-service"
      image = "your-registry.com/microservices:latest"
      portMappings = [
        {
          containerPort = 8080
          hostPort      = 8080
        }
      ]
      environment = [
        {
          name  = "SPRING_PROFILES_ACTIVE"
          value = "aws"
        }
      ]
    }
  ])
}