• cloud-demo：父工程，管理依赖
• order-service：订单微服务，只负责订单相关业务
• user-service：用户微服务，只负责用户相关业务
• 微服务的要求：
•         订单微服务和用户微服务都必须有各自的数据库，相互独立
•         订单服务和用户服务都对外暴露Restful的接口
•         订单服务如果需要查询用户信息，只能调用用户服务的Restful接口，不能查询用户数据库

• 单一职责：根据业务模块拆分，做到单一职责，不要重复开发相同业务
• 数据独立：不同微服务都应该有自己独立的数据库，不要访问其它微服务的数据库
• 面向服务：将自己的业务暴露为接口，供其它微服务调用

@Bean
public RestTemplate restTemplate(){
    return new RestTemplate();
}

@Autowired
private RestTemplate restTemplate;

@GetMapping("{orderId}")
public Order queryOrderByUserId(@PathVariable("orderId") Long orderId) {
    //1.根据id查询订单
    Order order = orderService.queryOrderById(orderId);
    //2.查询用户
    //2.1 动态封装http请求
    String url = "http://localhost:8081/user/"+order.getUserId();
    //2.2 发送http请求查询用户
    User user = restTemplate.getForObject(url, User.class);
    //3.将user信息封装到order中
    order.setUser(user);
    //4.返回order
    return order;
}

4.Eureka

• 消费者如何得知提供者实例地址？
•         提供者服务实例启动后，将自己的信息注册到 eureka-server(Eureka服务端)，即服务注册。eureka-server 保存服务名称到服务实例地址列表的映射关系，消费者根据服务名称，拉取实例地址列表，即服务发现或服务拉取。
•         【tips】服务提供者和消费者都称为Eureka的客户端。
• 消费者如何从多个提供者实例中选择具体的实例？
•         消费者从实例列表中利用负载均衡算法选中一个实例地址，向该实例地址发起远程调用。
• 消费者如何得知某个提供者实例是否依然健康，是不是已经宕机？
•         提供者会每隔一段时间(默认30秒)向 eureka-server 发起请求，报告自己状态，称为心跳续约。当超过一定时间没有发送心跳时，eureka-server 会认为该微服务实例故障，将该实例从服务列表中剔除，这样消费者拉取服务时，就能将故障实例排除了。

• 创建新模块eureka-server，导入spring-cloud-starter-netflix-eureka-server坐标

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

• 编写启动类，并开启注册中心自动装配注解

  @SpringBootApplication
  @EnableEurekaServer
  public class EurekaApplication {
      public static void main(String[] args) {
          SpringApplication.run(EurekaApplication.class, args);
      }
  }

• 编写配置文件

  server:
    port: 10086 # 服务端口
  spring:
    application:
      name: eureka-server # eureka的服务名称
  eureka:
    client:
      service-url: # eureka的地址信息
        defaultZone: http://127.0.0.1:10086/eureka

  【tips】配置文件中的defaultZone 是因为前面配置类开启了注册中心所需要配置的 eureka 的地址信息，而且 eureka 本身也是一个微服务，这里也要将自己注册进来，当后面 eureka 集群时，这里就可以填写多个，使用 “,” 隔开。

• 在user-service模块中导入spring-cloud-starter-netflix-eureka-client坐标

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

• 编写配置文件

  spring:
    application:
      name: user-service # user-service服务名称
  eureka:
    client:
      service-url: # eureka的地址信息
        defaultZone: http://127.0.0.1:10086/eureka

• 【tips】IDEA模拟多实例部署：

• 修改order-service中访问的url路径，用★服务名称★代替ip地址和端口

  String url = "http://user-service/user/"+order.getUserId();

• 给启动类OrderApplication中的RestTemplate添加负载均衡注解

  @Bean
  @LoadBalanced
  public RestTemplate restTemplate(){
      return new RestTemplate();
  }

• 负载均衡的策略都定义在 IRule 接口中，而 IRule 有很多不同的实现类：

• 常见的负载均衡策略：

（3）修改负载均衡策略

• 代码方式：在启动类或配置类中定义一个新的IRule Bean，返回想要的负载均衡策略。

  @Bean
  public IRule randomRule(){
          //随机选择策略
      return new RandomRule();
  }

• 配置文件方式：在order-service的 application.yml 文件中，添加新的配置修改负载均衡策略：

  user-service: # 指定使用该负载均衡策略的微服务名称，比如这里是order-service调用user-service
    ribbon:
      NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule # 负载均衡规则

ribbon:
  eager-load:
    enabled: true # 开启饥饿加载
    clients: user-service # 项目启动时直接去拉取user-service的集群

./startup.cmd -m standalone # 单机启动

3.使用Nacos进行服务注册

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
    <version>2.2.6.RELEASE</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

spring:
  cloud:
    nacos:
      server-addr: localhost:8848 # nacos服务地址

@EnableDiscoveryClient
@SpringBootApplication
public class GulimallCouponApplication {

4.服务分级存储模型

• 一级是服务，例如user-service
• 二级是集群，例如杭州或上海
• 三级是实例，例如杭州机房的某台部署了user-service的服务器

spring:
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: HZ # 自定义集群名称，这里HZ代表杭州

5.NacosRule负载均衡

user-service:
  ribbon:
    NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule #负载均衡规则 

6.根据权重负载均衡

spring:
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: HZ
        namespace: namespace_id # 命名空间ID

8.临时实例与非临时实例

• 临时实例(默认)：如果实例宕机超过一定时间，会被注册中心从服务列表剔除。
• 非临时实例：如果实例宕机，不会从服务列表剔除，也可以叫永久实例。

spring:
  cloud:
    nacos:
      discovery:
        ephemeral: false # 设置为非临时实例，默认是临时实例(true)

9.Nacos与Eureka的比较

• 都支持服务注册和服务拉取(pull)
• 都支持服务提供者的心跳检测 

• Nacos支持服务端主动检测提供者状态：临时实例采用心跳模式，非临时实例采用主动检测模式
• 临时实例心跳不正常会被剔除，非临时实例则不会被剔除
• Nacos支持服务列表变更的消息推送(push)模式，服务列表更新更及时；Eureka只能进行pull
• Nacos集群默认采用AP方式(可用性)，当集群中存在非临时实例时，采用CP模式(一致性)；Eureka采用AP方式。

10.Nacos统一配置管理——配置中心

• 导入nacos-config坐标

  <!--nacos配置管理依赖-->
  <dependency>
      <groupId>com.alibaba.cloud</groupId>
      <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
  </dependency>

• 添加 bootstrap.yml并配置nacos服务端信息，这些配置信息决定了项目启动时去nacos读取哪个文件

  spring:
    application:
      name: userservice # 服务名称
    profiles:
      active: dev #所处环境，这里是dev 
    cloud:
      nacos:
        server-addr: localhost:8848 # Nacos地址
        config:
          file-extension: yaml # 文件后缀名

• 用 @value 读取配置时，搭配 @RefreshScope

• ★直接用 @ConfigurationProperties 读取配置（推荐）
•         在 user-service 服务中，添加一个 PatternProperties 类，读取 patterrn.dateformat 属性

  @Data
  @Component
  @ConfigurationProperties(prefix = "pattern")
  public class PatternProperties {
      public String dateformat;
  }

  @Autowired
  private PatternProperties patternProperties;
  
  @GetMapping("now2")
  public String now2(){
      //格式化时间
      return LocalDateTime.now().format(DateTimeFormatter.ofPattern(patternProperties.dateformat));
  }

• [spring.application.name]-[spring.profiles.active].yaml，例如：userservice-dev.yaml
• [spring.application.name].yaml，例如：userservice.yaml

• nacos1：127.0.0.1:8845
• nacos2：127.0.0.1:8846
• nacos3：127.0.0.1:8847

#it is ip
#example
127.0.0.1:8845
127.0.0.1.8846
127.0.0.1.8847

spring.datasource.platform=mysql
db.num=1
db.url.0=jdbc:mysql://127.0.0.1:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=root
db.password.0=1234

./startup.cmd

（3）配置Nginx反向代理

upstream nacos-cluster {
    server 127.0.0.1:8845;
    server 127.0.0.1:8846;
    server 127.0.0.1:8847;
}

server {
    listen       80;
    server_name  localhost;

    location /nacos {
        proxy_pass http://nacos-cluster;
    }
}

• 代码可读性差，编程体验不统一
• 参数复杂URL难以维护

2.Feign简介

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

• @FeignClient("user-service")：参数填写的是微服务名
• @GetMapping("/user/{id}")：参数填写的是请求路径
• 这个客户端主要是基于 SpringMVC 的注解 @GetMapping 来声明远程调用的信息
• Feign可以帮助我们发送 http 请求，因此无需自己使用 RestTemplate 来发送了

@FeignClient("user-service")
public interface UserClient {
    
    @GetMapping("/user/{id}")
    User getById(@PathVariable("id") Long id);
}

@Autowired
private UserClient userClient;

//基于Feign的远程调用
@GetMapping("{orderId}")
public Order queryOrderByUserId(@PathVariable("orderId") Long orderId) {
    //1.根据id查询订单
    Order order = orderService.queryOrderById(orderId);
    //2.查询用户
    User user = userClient.getById(orderId);
    //3.将user信息封装到order中
    order.setUser(user);
    //4.返回order
    return order;
}

4.自定义Feign的配置

• NONE：不记录任何日志信息(默认值)
• BASIC：仅记录请求的方法，URL以及响应状态码和执行时间
• HEADERS：在BASIC的基础上，额外记录了请求和响应的头信息
• FULL：记录所有请求和响应的明细，包括头信息、请求体、元数据

• 全局生效，针对所有服务

  feign:  
    client:
      config: 
        default: # 这里用default就是全局配置，如果是写服务名称，则是针对某个微服务的配置
          loggerLevel: FULL #  日志级别 

• 局部生效，针对某个微服务

  feign:  
    client:
      config: 
        user-service: # 针对某个微服务的配置
          loggerLevel: FULL #  日志级别 

public class DefaultFeignConfiguration  {
    @Bean
    public Logger.Level feignLogLevel(){
        return Logger.Level.BASIC; // 日志级别为BASIC
    }
}

• 全局生效：将上面的配置类放到启动类的 @EnableFeignClients 注解中

  @EnableFeignClients(defaultConfiguration = DefaultFeignConfiguration.class) 

• 局部生效：将上面的配置类放到对应的 @FeignClient 注解中

  @FeignClient(value = "user-service", configuration = DefaultFeignConfiguration.class) 

• URLConnection：默认实现，不支持连接池
• Apache HttpClient ：支持连接池
• OKHttp：支持连接池

• 使用连接池代替默认的 URLConnection
• 日志级别应该尽量用 basic/none，可以有效提高性能。 这里用 Apache 的HttpClient来演示连接池。

<!--httpClient的依赖 -->
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-httpclient</artifactId>
</dependency>

feign:
  client:
    config:
      default: # default全局的配置
        loggerLevel: BASIC # 日志级别，BASIC就是基本的请求和响应信息
  httpclient:
    enabled: true # 开启feign对HttpClient的支持
    max-connections: 200 # 最大的连接数
    max-connections-per-route: 50 # 每个路径的最大连接数

6.Feign的最佳实践分析

• 定义一个 API 接口，利用定义方法，并基于 SpringMVC 注解做声明
• 让order-service中的 Feign 客户端和user-service中的Controller 都继承该接口

• 服务提供方和服务消费方存在紧耦合
• 参数列表中的注解映射并不会继承，因此 Controller 中必须再次声明方法、参数列表、注解

<!--Feign客户端依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

@EnableFeignClients(basePackages = "com.itcast.feign.clients")

五、★统一网关Gateway

• gateway
• zuul

<!--网关-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

<!--nacos服务发现依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

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

server:
  port: 10010 # 网关端口
spring:
  application:
    name: gateway # 服务名称
  cloud:
    nacos:
      server-addr: localhost:8848 # nacos地址
    gateway:
      routes: # 网关路由配置
        - id: user-service # 路由id，自定义，只要唯一即可
          # uri: http://127.0.0.1:8081 # 路由的目标地址 http就是固定地址
          uri: lb://userservice # 路由的目标地址 lb就是负载均衡，后面跟服务名称
          predicates: # 路由断言，也就是判断请求是否符合路由规则的条件
            - Path=/user/** # 这个是按照路径匹配，只要以/user/开头就符合要求

gateway:
  routes: # 网关路由配置
    - id: user-service # 路由id，自定义，只要唯一即可
      # uri: http://127.0.0.1:8081 # 路由的目标地址 http就是固定地址
      uri: lb://user-service # 路由的目标地址 lb就是负载均衡，后面跟服务名称
      predicates: # 路由断言，也就是判断请求是否符合路由规则的条件
        - Path=/user/** # 这个是按照路径匹配，只要以/user/开头就符合要求
      filters:
        - AddRequestHeader=Truth,China No.1! # 添加请求头

@GetMapping("/{id}")
    public User queryById(@PathVariable("id") Long id, @RequestHeader String truth) {
        System.out.println("truth" + truth);
        return userService.queryById(id);
    }

（3）默认过滤器(default-filters)

spring:
  cloud:
    gateway:
      default-filters:
        - AddRequestHeader=Key,value # 添加请求头

（4）全局过滤器(GlobalFilter)

• 参数中是否有 authorization authorization
• 参数值是否为 admin

• 创建自定义接口，实现GlobalFilter接口
• 重写filter方法

  //@Order(-1) //设置过滤器优先级
  @Component
  public class AuthorizeFilter implements GlobalFilter, Ordered {
      @Override
      public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
          //1.获取信息
          MultiValueMap<String, String> params = exchange.getRequest().getQueryParams();
          //2.获取第一个 authorization 对应的参数
          String authorization = params.getFirst("authorization");
          //3.进行判断
          if ("admin".equals(authorization)) {
              //4.满足要求，放行
              return chain.filter(exchange);
          }
          //5.不满足要求，拦截
          //5.1 设置拦截状态码
          exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
          //5.2 设置拦截
          return exchange.getResponse().setComplete();
      }
  
      /**
       * 设置过滤器优先级，数越小优先级越高
       * @return
       */
      @Override
      public int getOrder() {
          return -1;
      }
  }

• 每一个过滤器都必须指定一个 int 类型的 order 值，order 值越小，执行顺序越靠前
•         GlobalFilter 通过实现 Ordered 接口，或者使用 @Order 注解来指定 order 值，由我们自己指定
•         路由过滤器和 defaultFilter 的 order 由 Spring 指定，默认是按照声明顺序从1递增
• 当过滤器的 order 值一样时，会按照 default-filters > 路由过滤器 > GlobalFilter 的顺序执行。

• 域名不同： www.taobao.com 和 www.taobao.org 和 www.jd.com 和 miaosha.jd.com
• 域名相同，端口不同：localhost:8080和localhost8081

spring:
  cloud:
    gateway:
      globalcors: # 全局的跨域处理
        add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题
        corsConfigurations:
          '[/**]':
            allowedOrigins: # 允许哪些网站的跨域请求 allowedOrigins: “*” 允许所有网站
              - "http://localhost:8090"
            allowedMethods: # 允许跨域ajax的请求方式
              - "GET"
              - "POST"
              - "DELETE"
              - "PUT"
              - "OPTIONS"
            allowedHeaders: "*" # 允许在请求中携带的头信息
            allowCredentials: true # 是否允许携带cookie
            maxAge: 360000 # 这次跨域检测的有效期

六、Docker

1.简介

• 依赖关系复杂，容易出现兼容性问题
• 开发、测试、生产环境有差异

• Docker允许开发中将应用、依赖、函数库、配置一起打包，形成可移植镜像
• Docker应用运行在容器中，使用沙箱机制，相互隔离

• Docker将用户程序与所需要调用的系统(比如Ubuntu)函数库一起打包
• Docker运行到不同操作系统时，直接基于打包的库函数，借助于操作系统的Linux内核来运行

• docker是一个系统进程；虚拟机是在操作系统中的操作系统
• docker体积小、启动速度快、性能好；虚拟机体积大、启动速度慢、性能一般

• 镜像（Image）：Docker将应用程序及其所需的依赖、函数库、环境、配置等文件打包在一起，称为镜像。
• 容器（Container）：镜像中的应用程序运行后形成的进程就是容器，只是Docker会给容器做隔离，对外不可见。

• 服务端(server)：Docker守护进程，负责处理Docker指令，管理镜像、容器等
• 客户端(client)：通过命令或RestAPI向Docker服务端发送指令。可以在本地或远程向服务端发送指令。

yum-config-manager \
    --add-repo \
    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    
sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/yum.repos.d/docker-ce.repo

yum makecache fast

yum install -y docker-ce

systemctl start docker  # 启动docker服务

systemctl stop docker  # 停止docker服务

systemctl restart docker  # 重启docker服务

systemctl status docker #查看docker状态

docker -v # 查看docker版本

systemctl enable docker

5.Docker基本操作命令

• 去镜像仓库(如DockerHub)搜索nginx镜像

• 通过命令：docker pull nginx 拉取需要的镜像

• 通过命令：docker images 查看拉取到的镜像

• 利用docker save --help命令查看打包命令docker save的用法

• 使用打包命令docker save -o nginx.tar nginx:latest将镜像打包

• 利用docker load --help命令查看docker load的用法

• 通过命令 docker rmi 将案例1拉取的镜像删除

• 通过命令 docker load -i 包名.tar 加载镜像nginx.tar

• 去docker hub查看Nginx的容器运行命令

  docker run --name myNginx -p 80:80 -d nginx

• 通过命令 docker ps 查看所有正在运行的容器和状态

        

• 访问nginx，并通过 docker logs myNginx 查看myNginx容器日志

• 通过 docker exec -it myNginx bash 进入myNginx容器

• 进入nginx的HTML所在目录 /usr/share/nginx/html

  cd /usr/share/nginx/html

• 修改index.html的内容

  sed -i 's#Welcome to nginx#hello Docker#g' index.html

• 使用exit命令退出容器
• 使用 docker stop myNginx 命令停止容器
• 使用 docker rm  myNginx 命令删除容器

• 不便于修改：当要修改容器的html内容时，需要进入容器内部修改，很不方便
• 数据不可复用：在容器内的修改对外是不可见的。所有修改对新创建的容器是不可复用的
• 升级维护困难：数据在容器内，如果要升级容器必然删除旧容器，所有数据都跟着删除了

（4）挂载数据卷

• 创建并运行mn容器，把html数据卷(位于宿主机)挂载到容器内的/usr/share/nginx/html这个目录

  docker run --name mn -p 80:80 -v html:/usr/share/nginx/html -d nginx

  -v html:/usr/share/nginx/html    将html这个数据卷挂载到容器内的/usr/share/nginx/html这个目录中

• 查看html数据卷在宿主机中的位置

  docker volume inspect html

  
  
• 进入挂载点目录并修改文件

  #进入该目录 
  cd /var/lib/docker/volumes/html/_data 
  
  # 修改文件 
  vim index.html

• 将资料中的mysql.tar文件上传到虚拟机，通过load命令加载为镜像
• 创建目录 /tmp/mysql/data 和目录 /tmp/mysql/conf，将资料提供的hmy.cnf文件上传到/tmp/mysql/conf
• 创建并运行MySQL容器，起名为mysql

  docker run \
    --name mysql \
    -e MYSQL_ROOT_PASSWORD=1234 \  #设置mysql密码
    -p 3306:3306 \  #将宿主机端口与容器端口映射   -v /usr/local/mysqlDocker/data:/var/lib/mysql \  #目录挂载：目录挂目录
    -v /usr/local/mysqlDocker/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf \  #目录挂载：文件挂文件
    -d \
    mysql:5.7.25

• 打开Navicat测试数据库连接

• 基础镜像层(BaseImage)：包含基本的系统函数库、环境变量、文件系统 
• 入口(Entrypoint)：是镜像中应用程序启动的命令 
• 其它层：在BaseImage基础上添加依赖、安装程序、完成整个应用的安装和配置

# 指定基础镜像
FROM ubuntu:16.04
# 配置环境变量，JDK的安装目录
ENV JAVA_DIR=/usr/local

# 拷贝jdk和java项目的包
COPY ./jdk8.tar.gz $JAVA_DIR/
COPY ./docker-demo.jar /tmp/app.jar

# 安装JDK
RUN cd $JAVA_DIR \
 && tar -xf ./jdk8.tar.gz \
 && mv ./jdk1.8.0_144 ./java8

# 配置环境变量
ENV JAVA_HOME=$JAVA_DIR/java8
ENV PATH=$PATH:$JAVA_HOME/bin

# 暴露端口
EXPOSE 8090
# 入口，java项目的启动命令
ENTRYPOINT java -jar /tmp/app.jar

• 新建一个空文件夹docker-demo
• 拷贝资料中的docker-demo.jar文件到docker-demo目录
• 拷贝资料中的jdk8.tar.gz文件到docker-demo目录
• 拷贝资料提供的Dockerfile到docker-demo目录
• 在docker-demo目录下执行命令

  docker build -t javaweb:1.0 .

• 创建并运行web容器，并进行访问测试

  docker run --name web -p 8090:8090 -d javaweb:1.0

• 新建一个空文件夹docker-demo2
• 拷贝资料中的docker-demo.jar文件到docker-demo2目录
• 重新编写Dockerfile文件：

  # 指定基础镜像
  FROM java:8-alpine
  #将app拷贝到镜像中
  COPY ./docker-demo.jar /tmp/app.jar
  # 暴露端口
  EXPOSE 8090
  # 入口，java项目的启动命令
  ENTRYPOINT java -jar /tmp/app.jar

• 在docker-demo目录下执行命令

  docker build -t javaweb:2.0 .

• 创建并运行web容器，并进行访问测试

  docker run --name web -p 8090:8090 -d javaweb:2.0

• 公共仓库：例如Docker官方的 Docker Hub，国内也有一些云服务商提供类似于 Docker Hub 的公开服务，比如 网易云镜像服务、DaoCloud 镜像服务、阿里云镜像服务等。
• 私有仓库：除了使用公开仓库外，用户还可以在本地搭建私有 Docker Registry。企业自己的镜像最好是采用私有Docker Registry来实现。

• ***采用的是http协议，默认不被Docker信任，所以搭建私有仓库前需要做一个配置：

  # 打开要修改的文件
  vi /etc/docker/daemon.json
  # 添加内容：
  "insecure-registries":["http://192.168.152.100:8080"]
  # 重加载
  systemctl daemon-reload
  # 重启docker
  systemctl restart docker

• 使用DockerCompose部署带有图象界面的DockerRegistry，命令如下：

  version: '3.0'
  services:
    registry:
      image: registry
      volumes:
        - ./registry-data:/var/lib/registry
    ui:
      image: joxit/docker-registry-ui:static
      ports:
        - 8080:80
      environment:
        - REGISTRY_TITLE=Docker_resp
        - REGISTRY_URL=http://registry:5000
      depends_on:
        - registry

• 访问测试，出现以下页面说明搭建成功：

• 推送本地镜像到仓库前都必须重命名(docker tag)镜像，并以镜像仓库地址为前缀

  docker tag nginx:latest 192.168.152.100:8080/nginx:1.0 

• 推送重命名后的镜像

  docker push 192.168.152.100:8080/nginx:1.0 

• 拉取镜像：复制代码并拉取

  docker pull 192.168.152.100:8080/nginx:1.0

version: "3.8"
    
services:
  mysql:
    image: mysql:5.7.25
    environment:
     MYSQL_ROOT_PASSWORD: 123 
    volumes:
     - "/tmp/mysql/data:/var/lib/mysql"
     -  "/tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf"
  web:
    build: .
    ports:
     - "8090:8090"

2.安装DockerCompose

chmod +x /usr/local/bin/docker-compose

curl -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose

echo "199.232.68.133 raw.githubusercontent.com" >> /etc/hosts

3.基于DockerCompose部署微服务

• 查看提供的cloud-demo文件夹，里面已经编写好了docker-compose文件
• 修改cloud-demo项目，将数据库、nacos地址都命名为docker-compose中的服务名
• 使用maven打包工具，将项目中的每个微服务都打包为app.jar
• 将打包好的app.jar拷贝到cloud-demo中的每一个对应的子目录中
• 将cloud-demo上传至虚拟机，利用 docker-compose up -d 来部署

• 资料提供的cloud-demo文件夹，里面已经编写好了docker-compose文件，而且每个微服务都准备了一个独立的目录：

• docker-compose文件内容如下：

  version: "3.2"
  
  # 5个微服务
  services:
    # nacos：作为注册中心和配置中心
    nacos: # 自定义容器名，下同
      image: nacos/nacos-server # 基于nacos/nacos-server镜像构建
      environment:
        MODE: standalone # 单点模式启动
      ports:
        - "8848:8848"
    mysql:
      image: mysql:5.7.25 # 基于mysql 5.7.25版本构建镜像
      environment:
        MYSQL_ROOT_PASSWORD: 123
      # 数据卷挂载，这里挂载了mysql的data、conf目录
      volumes:
        - "$PWD/mysql/data:/var/lib/mysql"
        - "$PWD/mysql/conf:/etc/mysql/conf.d/"
    # userservice、orderservice、gateway：都是基于各自文件夹下的Dockerfile文件临时构建的镜像
    userservice:
      build: ./user-service
    orderservice:
      build: ./order-service
    gateway:
      build: ./gateway
      ports:
        - "10010:10010"

• 查看微服务目录，可以看到每一个微服务都包含Dockerfile文件：

• Dockerfile文件内容如下：

  FROM java:8-alpine # 基于java:8-alpine构建镜像
  COPY ./app.jar /tmp/app.jar	# 将当前目录下的app.jar包拷贝到/tmp目录下
  ENTRYPOINT java -jar /tmp/app.jar # 执行启动java项目的命令

• 修改微服务配置：因为微服务要部署为docker容器，而容器之间互联不是通过IP地址，而是通过容器名。因此需要将order-service、user-service、gateway模块的mysql、nacos地址配置都修改为基于容器名的访问：

  spring:
    datasource:
      url: jdbc:mysql://mysql:3306/cloud_order?useSSL=false
      username: root
      password: 123
      driver-class-name: com.mysql.jdbc.Driver
    application:
      name: orderservice
    cloud:
      nacos:
        server-addr: nacos:8848 # nacos服务地址

• 打包：将每个微服务都打包。因为之前查看到Dockerfile中的jar包名称都是app.jar，因此每个微服务都需要用这个名称。 可以通过修改pom.xml中的打包名称来实现，每个微服务都需要修改：

  <build>
    <!-- 服务打包的最终名称 -->
    <finalName>app</finalName>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

• 编译打包好的app.jar文件，需要放到Dockerfile的同级目录中

• 将cloud-demo文件夹上传到虚拟机中，由DockerCompose部署：

  docker-compose up -d