SpringBoot微服务教程：入门与实践-原创手记-慕课网

概述

本文提供了全面的Spring Boot微服务教程，涵盖了从快速搭建Spring Boot项目到实现RESTful API、服务通信与集成、服务治理与容错等关键内容。文章还详细介绍了如何部署与运维微服务应用，包括在Docker和Kubernetes中的实践。通过本文，读者可以深入了解并掌握Spring Boot微服务开发的各个方面。

Spring Boot简介

Spring Boot是什么

Spring Boot 是一个基于Spring框架的开源框架，它简化了Spring应用的初始搭建以及开发过程。Spring Boot旨在简化Spring应用的配置，使开发者可以用最少的代码和最简单的配置来创建独立的、生产级别的Spring应用。Spring Boot可以使开发者不需要编写大量的配置文件，从而大大简化了开发流程，提高了开发效率。

Spring Boot的优点

自动配置：Spring Boot 会根据添加的依赖自动配置应用，例如，添加Spring Data JPA依赖，会自动配置JPA。
独立性：Spring Boot应用可以独立运行，打包为可执行的jar文件，内置了Tomcat、Jetty、Undertow等web容器。
开发速度：通过约定大于配置的方式减少了开发人员的配置文件编写工作，使得开发速度大大提高。
嵌入式支持：支持嵌入式Tomcat、Jetty、Undertow等服务器。
5..)
外部化配置：支持通过properties文件或者YAML文件来定义配置，可以方便地在不同环境中（开发、测试、生产）更改配置。
健康检查和监控：可以使用Actuator模块轻松实现应用的健康检查和监控。
嵌入式脚本引擎Groovy/Shell：可以方便地使用Groovy脚本实现复杂的逻辑。
全局异常处理：提供了全局的异常处理机制，可以捕获并处理任何未捕获的异常。

快速搭建Spring Boot项目

创建一个Spring Boot项目，可以使用Spring Initializr或者Starter Projects进行快速启动。以下是创建一个Spring Boot项目的步骤：

选择Spring Initializr网站：https://start.spring.io/。
选择项目配置：选择项目语言（Java）、构建工具（Maven或Gradle）、Java版本、项目模块（如Web、JPA等）。
填写项目信息：填写项目名称、包名、版本等。
下载并导入项目：下载后，导入到IDE（如IntelliJ IDEA或Eclipse）中。

使用IDEA创建项目示例：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="httpBy: http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.4</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

上述代码是Maven的pom.xml配置文件，它定义了项目的依赖项。注意spring-boot-starter-parent和spring-boot-starter-web，它们分别表示Spring Boot的父项目依赖和Web模块的依赖。

接下来执行以下命令来运行应用：

mvn spring-boot:run

或者在IDE中运行主类（通常命名为Application.java），如下：

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

运行结果会输出应用的启动日志，并且默认会在8080端口上运行。

微服务基础概念

微服务定义

微服务是一种将软件架构设计成一系列小型、独立、可独立部署的服务的架构风格。每个服务都专注于单一功能，并且能够通过定义良好的API接口与其他服务进行通信。微服务架构风格强调独立开发、部署和扩展服务的能力，使得服务可以快速迭代、易于维护和扩展。这种架构风格促进了敏捷开发和持续交付。

微服务架构的优势与挑战

优势：

快速迭代：微服务架构使得每个服务都可以独立开发和部署，提高了团队的工作效率。
可伸缩性：微服务架构使得应用可以按需进行水平扩展，每个服务都可以独立地扩展。
容错能力：由于每个服务都是独立的，一个服务的失败不会影响到其他服务，提高了系统的稳定性和可用性。
技术栈多样化：微服务可以使用不同的编程语言和技术栈，每个服务都可以根据需求选择最合适的技术方案。

挑战：

服务通信复杂：服务间通信需要定义清晰的接口和协议，增加了系统的复杂性。
服务治理：需要管理的服务数量庞大，服务治理、监控、调用链等成为重要的挑战。
运维复杂度：每个微服务都需要独立部署、监控、配置和升级，运维难度增大。
数据一致性：多个服务操作同一个数据时，数据的一致性成为难题。

微服务与传统单体架构的区别

单体架构

服务集中化：所有服务都集中在一个应用内，单一应用程序包含所有的功能模块。
开发和部署：整个应用作为一个整体进行开发和部署，开发周期长，部署复杂。
扩展性：整个应用作为一个整体扩展，扩展时需要考虑整个应用的负载情况。

微服务架构

服务独立化：每个服务都是独立的，专注于单一功能。
开发和部署：每个服务可以独立开发、测试和部署，加快了开发和部署速度。
扩展性：可以根据服务的负载情况独立地扩展，提高了系统的灵活性和可用性。

微服务架构的案例展示

假设有一个简单的博客系统，单体架构下，该系统可能包含用户管理、文章发布、评论等功能，所有这些功能都集成在一个应用中。而微服务架构下，可以将用户管理、文章发布、评论等功能拆分成独立的服务，每个服务都专注于单一功能，并且通过定义良好的API接口进行通信。这样的架构使得每个服务可以独立开发、测试、部署和扩展，从而提高了开发效率和系统的灵活性。

Spring Boot微服务开发实战

创建第一个Spring Boot微服务应用

创建Spring Boot项目：如前所述，通过Spring Initializr创建一个新的Spring Boot项目。
配置应用：在主类中添加必要的注解，例如@SpringBootApplication注解，该注解表示这是一个Spring Boot应用。
启动应用：在主类中定义一个main方法，启动应用。

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

上述代码定义了一个简单的Spring Boot应用，该应用使用了@SpringBootApplication注解，该注解表明该应用是一个Spring Boot应用，会自动扫描并配置所有相关的Spring Bean。

创建一个简单的REST控制器：创建一个新的Java类，继承org.springframework.web.bind.annotation.RestController，并添加必要的注解，例如@RestController、@RequestMapping。

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class HelloController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello World!";
    }

}

上述代码定义了一个REST控制器，它包含一个简单的GET方法，返回一个字符串。

运行应用：在IDE中运行主类，访问http://localhost:8080/api/hello，可以看到输出"Hello World!"。

使用Spring Boot Actuator监控应用

Spring Boot Actuator提供了多种管理和监控应用的方法。通过集成Spring Boot Actuator，可以轻松地监控应用的运行状态、资源使用情况等。

添加依赖：在pom.xml文件中添加Spring Boot Actuator依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

配置Actuator：在application.properties或application.yml文件中配置Actuator的端点和访问权限。

management.endpoints.web.exposure.include=*
management.endpoints.web.base-path=/actuator

运行应用：启动应用后，访问http://localhost:8080/actuator，可以看到Actuator提供的多个监控端点，例如health、info、beans等。

下面是一个简单的Actuator监控示例：

$ curl -X GET http://localhost:8080/actuator/health
{
  "status": "UP"
}

实现RESTful API

RESTful API是一种设计良好的API，它使用HTTP协议中的标准方法（如GET、POST、PUT、DELETE）来操作资源。在Spring Boot中，可以通过@RestController注解来实现RESTful API。

创建控制器：创建一个新的Java类，继承org.springframework.web.bind.annotation.RestController。

package com.example.demo;

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/v1/users")
public class UserController {

    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        // 通过id获取用户信息
        return new User(id, "John Doe");
    }

    @PostMapping("/")
    public User createUser(@RequestBody User user) {
        // 创建用户信息
        return new User(user.getId(), user.getName());
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        // 更新用户信息
        return new User(user.getId(), user.getName());
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        // 删除用户信息
    }
}

上述代码定义了一个REST控制器，它提供了获取用户信息、创建用户、更新用户和删除用户的功能。

创建实体类：创建一个新的Java类来表示用户信息。

package com.example.demo;

public class User {

    private Long id;
    private String name;

    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    // getter和setter方法
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

上述代码定义了一个简单的User类，它包含一个id和一个name字段。

测试实现的RESTful API

为了测试我们实现的RESTful API，可以使用Postman或curl工具发送请求。例如，使用curl命令发送GET请求来获取用户信息：

$ curl -X GET http://localhost:8080/api/v1/users/1

通过上述命令，可以获取用户ID为1的用户信息。

微服务通信与集成

使用RabbitMQ实现消息队列

RabbitMQ是一个开源的消息代理，支持多种消息协议，包括AMQP。RabbitMQ可以用来实现消息的异步处理，使得系统更加松耦合、可扩展。

添加依赖：在pom.xml文件中添加RabbitMQ依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

配置RabbitMQ：在application.properties或application.yml文件中配置RabbitMQ的连接信息。

spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

定义消息生产者：创建一个新的Java类，定义一个发送消息的方法。

package com.example.demo;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MessageProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendMessage(String message) {
        rabbitTemplate.convertAndSend("myExchange", "myRoutingKey", message);
    }
}

上述代码定义了一个消息生产者，它使用RabbitTemplate发送消息到指定的交换机和路由键。

定义消息消费者：创建一个新的Java类，定义一个接收消息的方法。

package com.example.demo;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class MessageConsumer {

    @RabbitListener(queues = "myQueue")
    public void receiveMessage(String message) {
        System.out.println("Received message: " + message);
    }
}

上述代码定义了一个消息消费者，它监听指定的消息队列，并处理接收到的消息。

测试消息队列

为了测试消息队列，可以编写一个简单的测试类来发送消息并验证消息是否被接收。

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class RabbitMQTest {

    @Autowired
    private MessageProducer producer;

    @Test
    public void testSendAndReceiveMessage() {
        producer.sendMessage("Hello, RabbitMQ!");
        // 验证消息是否被接收
        // 实际测试中可能需要等待一定时间或使用断言验证结果
    }
}

通过上述代码，可以测试消息是否能够成功发送和接收。

服务发现与注册（Eureka）

Eureka是Netflix开源的服务发现组件，它提供了服务注册、发现和负载均衡的功能。Eureka用于构建微服务架构，提供了服务的注册、发现和负载均衡的功能，使得服务之间可以轻松地进行通信。

添加依赖：在pom.xml文件中添加Eureka依赖。

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

配置Eureka服务器：在application.properties或application.yml文件中配置Eureka服务器的端口和其他信息。

spring.application.name=eureka-server
server.port=8761
eureka.instance.hostname=localhost
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

运行Eureka服务器：启动Eureka服务器后，访问http://localhost:8761/，可以看到Eureka服务器的管理界面。
配置Eureka客户端：在微服务应用中添加Eureka客户端的配置。

spring.application.name=my-service
server.port=8080
eureka.instance.hostname=localhost
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

启动微服务应用：启动微服务应用后，它会自动注册到Eureka服务器，并可以在Eureka服务器的管理界面中看到该服务的信息。

使用API Gateway（Zuul）

API Gateway是微服务架构中的一种服务，它作为所有请求的入口点，负责路由、过滤和处理请求。API Gateway可以实现路由、认证、限流等功能，使得微服务架构更加健壮和灵活。

添加依赖：在pom.xml文件中添加Zuul的依赖。

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>

配置API Gateway：在application.properties或application.yml文件中配置API Gateway的路由规则。

spring.application.name=api-gateway
server.port=8080
zuul.routes.users.path=/users/**
zuul.routes.users.url=http://localhost:8081/

上述配置表示所有以/users/**开头的请求都会路由到http://localhost:8081/。

定义路由规则：在主类中添加@EnableZuulProxy注解。

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@EnableZuulProxy
@SpringBootApplication
public class GatewayApplication {

    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }

}

上述代码定义了一个API Gateway应用，它使用了@EnableZuulProxy注解，该注解表示该应用是一个Zuul代理。

启动应用：启动API Gateway应用后，所有请求都会通过API Gateway进行路由。

测试API Gateway

为了测试API Gateway，可以创建一个简单的控制器来模拟用户服务，并使用API Gateway进行路由测试。

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping("/{id}")
    public String getUser(@PathVariable Long id) {
        return "User ID: " + id;
    }
}

启动应用后，访问http://localhost:8080/users/1，可以看到返回的用户信息。

服务治理与容错

实现服务熔断与限流（Hystrix）

Hystrix是一个开源的服务容错框架，它提供了服务的熔断、隔离、限流等功能。通过使用Hystrix，可以实现服务的容错处理，提高系统的稳定性和可用性。

添加依赖：在pom.xml文件中添加Hystrix的依赖。

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

配置Hystrix：在application.properties或application.yml文件中配置Hystrix的熔断器和隔离策略。

hystrix.command.default.execution.isolation.strategy=SEMAPHORE
hystrix.command.default.execution.isolation.semaphore.maxConcurrentRequests=10
hystrix.command.default.circuitBreaker.requestVolumeThreshold=20
hystrix.command.default.circuitBreaker.errorThresholdPercentage=50
hystrix.command.default.circuitBreaker.sleepWindowInMilliseconds=5000

上述配置表示熔断器在收到20次请求后，如果失败率达到50%，则进入熔断状态，并在5000毫秒后尝试恢复。

定义熔断器：在Java类中定义一个熔断器。

package com.example.demo;

import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixCommandKey;
import com.netflix.hystrix.HystrixCommandProperties;

public class MyCommand extends HystrixCommand<String> {

    private String name;

    protected MyCommand(String name) {
        super(HystrixCommandKey.Factory.asKey("MyCommand"),
                HystrixCommandGroupKey.Factory.asKey("Demo"));
        this.name = name;
    }

    @Override
    protected String run() throws Exception {
        // 执行业务逻辑
        return "Hello, " + name + "!";
    }

    @Override
    protected String getFallback() {
        // 定义熔断时的返回值
        return "Fallback!";
    }
}

上述代码定义了一个熔断器，它在执行业务逻辑时，如果出现异常，则返回默认的错误信息。

测试服务熔断与限流

为了测试服务熔断与限流，可以编写一个简单的测试类来模拟多个请求并验证熔断器的行为。

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class HystrixTest {

    @Autowired
    private MyCommand myCommand;

    @Test
    public void testCommand() {
        // 模拟多个请求
        for (int i = 0; i < 21; i++) {
            System.out.println(myCommand.execute());
        }
        // 验证熔断器的行为
        // 模拟异常请求
        for (int i = 0; i < 11; i++) {
            System.out.println(myCommand.execute());
        }
    }
}

通过上述代码，可以测试熔断器的熔断逻辑。

使用Spring Cloud Config集中化配置管理

Spring Cloud Config提供了一种集中化管理配置的方式，它支持从本地文件、Git仓库等源中加载配置文件。通过使用Spring Cloud Config，可以轻松地管理不同环境下的配置信息。

添加依赖：在pom.xml文件中添加Spring Cloud Config的依赖。

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>

配置配置服务器：在application.properties或application.yml文件中配置配置服务器的端口和其他信息。

spring.application.name=config-server
server.port=8888
spring.cloud.config.server.git.uri=https://github.com/your-repo/your-project
spring.cloud.config.server.git.username=your-username
spring.cloud.config.server.git.password=your-password

启动配置服务器：启动配置服务器后，访问http://localhost:8888/config-client/default，可以看到配置信息。
配置客户端：在微服务应用中添加Spring Cloud Config客户端的依赖。

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

配置客户端：在bootstrap.properties或bootstrap.yml文件中配置客户端的配置位置。

spring.application.name=config-client
spring.cloud.config.uri=http://localhost:8888

测试Spring Cloud Config

为了测试Spring Cloud Config，可以在配置服务器中添加一个配置文件，并在客户端中使用该配置文件。

配置服务器：在Git仓库中添加一个配置文件application.yml。

# application.yml
app:
  message: Hello, Config!

客户端：在客户端代码中使用配置文件中的信息。

package com.example.demo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ConfigController {

    @Value("${app.message}")
    private String message;

    @GetMapping("/config-message")
    public String getConfigMessage() {
        return message;
    }
}

启动客户端后，访问http://localhost:8080/config-message，可以看到返回的配置信息。

服务降级与重试机制

服务降级与重试机制是服务治理中常见的容错策略，它可以提高系统的稳定性和可用性。

服务降级：当后端服务不可用时，前端服务返回预定义的错误信息，而不是等待后端服务返回结果。

package com.example.demo;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ServiceConfig {

    @Bean
    public Service fallBackService() {
        return () -> "Fallback Service!";
    }
}

上述代码定义了一个服务降级的逻辑，当后端服务不可用时，返回默认的错误信息。

服务重试：当请求失败时，客户端可以自动重试，直到请求成功或达到重试次数上限。

package com.example.demo;

import org.springframework.retry.annotation.EnableRetry;
import org.springframework.retry.backoff.FixedBackOffPolicy;
import org.springframework.retry.policy.SimpleRetryPolicy;
import org.springframework.retry.support.RetryTemplate;

@Configuration
@EnableRetry
public class RetryConfig {

    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate retryTemplate = new RetryTemplate();
        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
        retryPolicy.setMaxAttempts(3);
        retryTemplate.setRetryPolicy(retryPolicy);

        FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
        backOffPolicy.setBackOffPeriod(1000);
        retryTemplate.setBackOffPolicy(backOffPolicy);

        return retryTemplate;
    }
}

上述代码定义了一个重试机制，当请求失败时，客户端可以自动重试，直到请求成功或达到重试次数上限。

测试服务降级与重试

为了测试服务降级与重试机制，可以编写一个简单的测试类来模拟不同请求并验证降级和重试逻辑。

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class RetryTest {

    @Autowired
    private RetryConfig retryConfig;

    @Test
    public void testRetry() {
        // 模拟请求失败
        // 验证重试机制
        // 验证降级逻辑
    }
}

通过上述代码，可以测试服务降级与重试机制的实际效果。

部署与运维

构建与打包Spring Boot应用

构建应用：在IDE中运行mvn clean package命令构建应用。

mvn clean package

上述命令会清理构建目录，然后构建应用，并生成可执行的jar文件。

打包应用：构建完成后，在target目录下会生成一个可执行的jar文件。

java -jar target/demo-0.0.1-SNAPSHOT.jar

上述命令会运行生成的jar文件。

在Docker中部署微服务应用

创建Dockerfile：在项目的根目录下创建一个Dockerfile文件。

FROM openjdk:11-jre-slim

ADD target/demo-0.0.1-SNAPSHOT.jar app.jar

ENTRYPOINT ["java","-jar","app.jar"]

上述Dockerfile定义了一个Docker镜像，它基于openjdk:11-jre-slim镜像，将生成的jar文件复制到镜像中，并设置启动命令。

构建Docker镜像：在项目目录下运行docker build -t my-app:latest .命令构建Docker镜像。

docker build -t my-app:latest .

上述命令会构建一个名为my-app的Docker镜像。

运行Docker容器：运行docker run -p 8080:8080 my-app:latest命令启动容器。

docker run -p 8080:8080 my-app:latest

上述命令会启动一个容器，并将容器的8080端口映射到主机的8080端口。

测试Docker部署

为了测试Docker部署，可以启动容器后在浏览器中访问应用，并验证应用是否正常运行。

使用Kubernetes管理微服务集群

创建Kubernetes资源文件：创建一个名为deployment.yaml的文件，定义一个Kubernetes Deployment资源。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-app:latest
        ports:
        - containerPort: 8080

上述资源文件定义了一个名为my-app的Deployment资源，它包含三个副本，并映射了容器的8080端口。

创建Kubernetes资源：运行kubectl apply -f deployment.yaml命令创建资源。

kubectl apply -f deployment.yaml

上述命令会创建一个名为my-app的Deployment资源。

创建Kubernetes服务：创建一个名为service.yaml的文件，定义一个Kubernetes Service资源。

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
  type: LoadBalancer

上述资源文件定义了一个名为my-app-service的服务资源，它将请求路由到my-app应用的8080端口。

创建Kubernetes服务：运行kubectl apply -f service.yaml命令创建服务。

kubectl apply -f service.yaml

上述命令会创建一个名为my-app-service的服务资源。

测试Kubernetes部署

为了测试Kubernetes部署，可以访问服务地址并验证应用是否正常运行。