{
  "service": {
    "name": "web",
    "port": 80,
    "tags": ["primary"],
    "check": {
      "http": "http://localhost:80/health",
      "interval": "10s"
    }
  }
}

curl -X PUT http://localhost:8500/v1/agent/service/register \
  -d '{
    "Name": "web",
    "Port": 80,
    "Check": {
      "HTTP": "http://localhost:80/health",
      "Interval": "10s"
    }
  }'

# 存储配置
consul kv put config/database/host "db.example.com"
consul kv put config/database/port "5432"

# 读取配置
consul kv get config/database/host

# 监听配置变化
consul watch -type=key -key=config/database/host \
  'echo "Database host changed"'

Kind = "service-router"
Name = "web"
Routes = [
  {
    Match {
      HTTP {
        Header = [
          {
            Name  = "x-version"
            Exact = "v2"
          }
        ]
      }
    }
    Destination {
      Service = "web"
      ServiceSubset = "v2"
    }
  }
]

Kind = "service-intentions"
Name = "web"
Sources = [
  {
    Name   = "frontend"
    Action = "allow"
  },
  {
    Name   = "backend"
    Action = "deny"
  }
]

# 注册服务
curl -X PUT http://localhost:8500/v1/agent/service/register \
  -d @service.json

# 查询服务
curl http://localhost:8500/v1/health/service/web?passing

# 注销服务
curl -X PUT http://localhost:8500/v1/agent/service/deregister/web

# 存储键值
curl -X PUT http://localhost:8500/v1/kv/config/app \
  -d 'configuration data'

# 读取键值
curl http://localhost:8500/v1/kv/config/app

# 删除键值
curl -X DELETE http://localhost:8500/v1/kv/config/app

# 查询服务
dig @127.0.0.1 -p 8600 web.service.consul

# 查询健康服务
dig @127.0.0.1 -p 8600 web.service.consul SRV

# 查询节点
dig @127.0.0.1 -p 8600 node1.node.consul

# 集群成员
consul members

# 服务列表
consul catalog services

# 节点信息
consul catalog nodes

# 健康检查
consul monitor

# 配置重载
consul reload

<dependencies>
    <!-- Spring Cloud Consul -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-consul-discovery</artifactId>
    </dependency>
    
    <!-- Consul配置管理 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-consul-config</artifactId>
    </dependency>
    
    <!-- 健康检查 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    
    <!-- Web支持 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2021.0.3</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

dependencies {
    implementation 'org.springframework.cloud:spring-cloud-starter-consul-discovery'
    implementation 'org.springframework.cloud:spring-cloud-starter-consul-config'
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

dependencyManagement {
    imports {
        mavenBom "org.springframework.cloud:spring-cloud-dependencies:2021.0.3"
    }
}

# application.yml
spring:
  application:
    name: user-service
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        enabled: true
        register: true
        deregister: true
        prefer-ip-address: true
        ip-address: ${spring.cloud.client.ip-address}
        port: ${server.port}
        service-name: ${spring.application.name}
        instance-id: ${spring.application.name}:${spring.cloud.client.ip-address}:${server.port}
        tags:
          - version=1.0
          - environment=dev
        metadata:
          version: 1.0
          team: backend
        health-check-path: /actuator/health
        health-check-interval: 10s
        health-check-timeout: 3s
        health-check-critical-timeout: 30s

server:
  port: 8080

management:
  endpoints:
    web:
      exposure:
        include: health,info
  endpoint:
    health:
      show-details: always

@SpringBootApplication
@EnableDiscoveryClient  // 启用服务发现
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

@RestController
public class ServiceController {
    
    @Autowired
    private DiscoveryClient discoveryClient;
    
    @GetMapping("/services")
    public List<String> getServices() {
        return discoveryClient.getServices();
    }
    
    @GetMapping("/instances/{serviceName}")
    public List<ServiceInstance> getInstances(@PathVariable String serviceName) {
        return discoveryClient.getInstances(serviceName);
    }
    
    @GetMapping("/call-user-service")
    public String callUserService() {
        List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
        if (!instances.isEmpty()) {
            ServiceInstance instance = instances.get(0);
            String url = "http://" + instance.getHost() + ":" + instance.getPort() + "/users";
            // 调用服务
            RestTemplate restTemplate = new RestTemplate();
            return restTemplate.getForObject(url, String.class);
        }
        return "No available instances";
    }
}

@Configuration
public class LoadBalancerConfig {
    
    @Bean
    @LoadBalanced  // 启用负载均衡
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Service
public class UserService {
    
    @Autowired
    private RestTemplate restTemplate;
    
    public String getUserInfo(Long userId) {
        // 直接使用服务名调用
        String url = "http://user-service/users/" + userId;
        return restTemplate.getForObject(url, String.class);
    }
}

// 添加依赖
// <dependency>
//     <groupId>org.springframework.cloud</groupId>
//     <artifactId>spring-cloud-starter-openfeign</artifactId>
// </dependency>

@FeignClient(name = "user-service")
public interface UserServiceClient {
    
    @GetMapping("/users/{id}")
    User getUserById(@PathVariable("id") Long id);
    
    @PostMapping("/users")
    User createUser(@RequestBody User user);
}

@RestController
public class OrderController {
    
    @Autowired
    private UserServiceClient userServiceClient;
    
    @GetMapping("/orders/{orderId}/user")
    public User getOrderUser(@PathVariable Long orderId) {
        // 通过Feign客户端调用用户服务
        return userServiceClient.getUserById(orderId);
    }
}

// 启动类添加注解
@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients  // 启用Feign客户端
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

# bootstrap.yml (优先级高于application.yml)
spring:
  application:
    name: user-service
  cloud:
    consul:
      host: localhost
      port: 8500
      config:
        enabled: true
        prefix: config
        default-context: application
        profile-separator: ','
        format: YAML
        data-key: data
        watch:
          enabled: true
          delay: 1000

# 存储应用通用配置
consul kv put config/application/data @application-config.yml

# 存储特定服务配置
consul kv put config/user-service/data @user-service-config.yml

# 存储环境特定配置
consul kv put config/user-service,dev/data @user-service-dev-config.yml

# user-service-config.yml
database:
  url: jdbc:mysql://localhost:3306/userdb
  username: user
  password: password
  
redis:
  host: localhost
  port: 6379
  
business:
  max-retry-times: 3
  timeout: 5000

@RestController
@RefreshScope  // 支持配置动态刷新
public class ConfigController {
    
    @Value("${business.max-retry-times:3}")
    private int maxRetryTimes;
    
    @Value("${business.timeout:5000}")
    private int timeout;
    
    @GetMapping("/config")
    public Map<String, Object> getConfig() {
        Map<String, Object> config = new HashMap<>();
        config.put("maxRetryTimes", maxRetryTimes);
        config.put("timeout", timeout);
        return config;
    }
}

// 配置属性类
@Component
@ConfigurationProperties(prefix = "business")
@RefreshScope
public class BusinessProperties {
    private int maxRetryTimes = 3;
    private int timeout = 5000;
    
    // getter and setter
    public int getMaxRetryTimes() { return maxRetryTimes; }
    public void setMaxRetryTimes(int maxRetryTimes) { this.maxRetryTimes = maxRetryTimes; }
    public int getTimeout() { return timeout; }
    public void setTimeout(int timeout) { this.timeout = timeout; }
}

@Component
public class CustomHealthIndicator implements HealthIndicator {
    
    @Override
    public Health health() {
        // 检查数据库连接
        if (isDatabaseHealthy()) {
            return Health.up()
                    .withDetail("database", "Available")
                    .withDetail("status", "UP")
                    .build();
        } else {
            return Health.down()
                    .withDetail("database", "Unavailable")
                    .withDetail("status", "DOWN")
                    .build();
        }
    }
    
    private boolean isDatabaseHealthy() {
        // 实际的数据库健康检查逻辑
        return true;
    }
}

// 业务健康检查
@Component("business")
public class BusinessHealthIndicator implements HealthIndicator {
    
    @Autowired
    private BusinessService businessService;
    
    @Override
    public Health health() {
        try {
            businessService.checkBusinessHealth();
            return Health.up()
                    .withDetail("business", "All systems operational")
                    .build();
        } catch (Exception e) {
            return Health.down()
                    .withDetail("business", "Service unavailable")
                    .withDetail("error", e.getMessage())
                    .build();
        }
    }
}

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics
  endpoint:
    health:
      show-details: always
      show-components: always
  health:
    consul:
      enabled: true
    db:
      enabled: true
    redis:
      enabled: true

spring:
  cloud:
    consul:
      discovery:
        health-check-path: /actuator/health
        health-check-interval: 15s
        health-check-timeout: 5s
        health-check-critical-timeout: 60s
        health-check-tls-skip-verify: true

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class UserServiceApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
    
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@RestController
@RequestMapping("/users")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        User user = userService.findById(id);
        return ResponseEntity.ok(user);
    }
    
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User savedUser = userService.save(user);
        return ResponseEntity.ok(savedUser);
    }
    
    @GetMapping("/health")
    public ResponseEntity<String> health() {
        return ResponseEntity.ok("User Service is healthy");
    }
}

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private NotificationServiceClient notificationClient;
    
    public User findById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new UserNotFoundException("User not found: " + id));
    }
    
    public User save(User user) {
        User savedUser = userRepository.save(user);
        // 调用通知服务
        notificationClient.sendWelcomeNotification(savedUser.getId());
        return savedUser;
    }
}

@FeignClient(name = "notification-service")
public interface NotificationServiceClient {
    
    @PostMapping("/notifications/welcome")
    void sendWelcomeNotification(@RequestParam("userId") Long userId);
}

# application.yml
spring:
  profiles:
    active: dev

---
# 开发环境
spring:
  profiles: dev
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        tags:
          - environment=dev
          - version=1.0-SNAPSHOT

---
# 测试环境  
spring:
  profiles: test
  cloud:
    consul:
      host: consul-test.example.com
      port: 8500
      discovery:
        tags:
          - environment=test
          - version=1.0-RC

---
# 生产环境
spring:
  profiles: prod
  cloud:
    consul:
      host: consul-prod.example.com
      port: 8500
      discovery:
        tags:
          - environment=prod
          - version=1.0-RELEASE
        health-check-interval: 30s

datacenter = "dc1"
data_dir = "/opt/consul/data"
log_level = "INFO"
server = true
bootstrap_expect = 3
bind_addr = "10.0.1.10"
client_addr = "0.0.0.0"

retry_join = [
  "10.0.1.11",
  "10.0.1.12"
]

ui_config {
  enabled = true
}

acl = {
  enabled = true
  default_policy = "deny"
}