docker+kubernetes+springcloud微服务集群部署，spring-cloud-kubernetes，使用k8s部署spring cloud并实现服务注册、负载均衡、网关等功能

最新推荐文章于 2024-05-14 23:02:17 发布
最新推荐文章于 2024-05-14 23:02:17 发布
阅读量1.1k 收藏 8
点赞数 2
分类专栏： k8s springcloud ingress-nginx 文章标签： kubernetes spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heliu3/article/details/109047788
版权

docker+kubernetes+springcloud微服务集群部署，spring-cloud-kubernetes，使用k8s部署spring cloud并实现服务注册、负载均衡、网关等功能

地址服务
192.168.0.11k8s-master
192.168.0.22k8s-node1 ， docker registry
192.168.0.33k8s-node2

代码见https://github.com/heliu0/springcloud-k8s.git

  • 生产者 producer

    • 1, 创建spring cloud项目。并编写ProducerApplication.java，ProducerController.java，Dockerfile，application.yaml， pom.xml，producer-service.yaml。
      • pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="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">
    <parent>
        <artifactId>springcloud-k8s-parent</artifactId>
        <groupId>com.yayiyo.k8s</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-k8s-producer</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>${spring-boot.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
            <version>${spring-cloud-openfegin.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <version>${spring-boot.version}</version>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>${spring-boot.version}</version>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-kubernetes</artifactId>
            <version>${spring-cloud.k8s}</version>
        </dependency>
    </dependencies>

</project>
  • ProducerApplication.java
package com.yayiyo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class ProducerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProducerApplication.class, args);
    }
}
  • RpcController.java
package com.yayiyo.controllers;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.net.InetAddress;
import java.net.UnknownHostException;

@Controller
public class RpcController {
    @GetMapping("/ping")
    @ResponseBody
    public String ping() {
        try {
            return InetAddress.getLocalHost().getHostName();
        } catch (UnknownHostException e) {
            return "Pong";
        }
    }
}
  • application.yaml
spring:
  application:
    name: producer-service
  cloud:
    kubernetes:
      config:
        sources:
          - name: ${spring.application.name}
            namespace: default
      reload:
        enabled: true
        mode: event
      discovery:
        all-namespaces: true
server:
  port: 8082

management:
  endpoint:
    restart:
      enabled: true
  endpoints:
    web:
      exposure:
        include: restart
  • 2. idea上配置docker服务，执行Dockerfile，打包镜像并把镜像推到docker服务器上。
    • Dockerfile
FROM openjdk:8-jdk-alpine

LABEL version="1.0" maintainer="yayiyo@chinaunicom.com"
VOLUME /tmp
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
ARG JAR_FILE
ADD target/springcloud-k8s-producer-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java", "-jar","/app.jar"]
EXPOSE 8082
  • idea的docker配置

在这里插入图片描述

  • 3. 把镜像推到docker仓库里面
#查看本地仓库里面是否有该镜像
docker images
# 推到远程镜像仓库
docker push 镜像名
  • 4.在k8s-master服务器上 编写 producer-service.yaml并执行
kubectl apply -f  producer-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: producer-service
  labels:
    app.kubernetes.io/name: producer-service
spec:
  type: ClusterIP
  ports:
    - port: 8082
      targetPort: 8082
      nodePort: 8082
      protocol: TCP
      name: http
  selector:
    app.kubernetes.io/name: producer-service

---
apiVersion: apps/v1producer-service
kind: Deployment
metadata:
  name: producer-service
  labels:
    app.kubernetes.io/name: producer-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/name: producer-service
  template:
    metadata:
      labels:
        app.kubernetes.io/name: producer-service
        app.kubernetes.io/instance: sad-markhor
    spec:
      containers:
        - name: producer-service
          # 镜像名需要与仓库中的镜像名一致
          image: "192.168.0.22:5000/spring-cloud-k8s-producer:1.0" 
          imagePullPolicy: Always
          ports:
            - name: http
              containerPort: 8082
              protocol: TCP

可以看到有 producer-service 的pod正常运行。

  • 消费者 customer

    • 1, 创建spring cloud项目。并编写CustomerApplication.java，CustomerController.java，ProducerClient.java，ProducerClientFallback Dockerfile，application.yaml， pom.xml，customer-service.yaml。
      • pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="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">
    <parent>
        <artifactId>springcloud-k8s-parent</artifactId>
        <groupId>com.yayiyo.k8s</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-k8s-customer</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>${spring-boot.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
            <version>${spring-cloud-openfegin.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
            <version>${spring-cloud-openfegin.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <version>${spring-boot.version}</version>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>${spring-boot.version}</version>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-kubernetes</artifactId>
            <version>${spring-cloud.k8s}</version>
        </dependency>
    </dependencies>


</project>
  • CustomerApplication.java
package com.yayiyo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class CustomerApplication {
    public static void main(String[] args) {
        SpringApplication.run(CustomerApplication.class, args);
    }
}
  • RpcController.java
package com.yayiyo.controllers;

import com.yayiyo.client.ProducerClient;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@Slf4j
public class CoustomerController {
    @Autowired
    private DiscoveryClient discoveryClient;

    @Autowired
    private ProducerClient producerClient;


    @GetMapping("/service")
    public Object getClient() {
        return discoveryClient.getServices();
    }

    @GetMapping("/instance")
    public List<ServiceInstance> getInstance(String instanceId) {
        return discoveryClient.getInstances(instanceId);
    }

    @GetMapping("/ping")
    public String ping() {
        return producerClient.ping();
    }
}
  • ProducerClient.java
package com.yayiyo.client;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@FeignClient(name = "http://producer-service:8082", url = "http://producer-service:8082", fallback = ProducerClientFallback.class)
public interface  ProducerClient {
    @RequestMapping(value = "/ping", method = RequestMethod.GET)
    String  ping();
}

@Component
class ProducerClientFallback implements ProducerClient{

    @Override
    public String ping() {
        return "Error";
    }
}
  • application.yaml
spring:
  application:
    name: customer-service
  cloud:
    kubernetes:
      config:
        sources:
          - name: ${spring.application.name}
            namespace: default
      reload:
        enabled: true
        mode: event
      discovery:
        all-namespaces: true
server:
  port: 8081

management:
  endpoint:
    restart:
      enabled: true
  endpoints:
    web:
      exposure:
        include: restart
  • 2. idea上配置docker服务，执行Dockerfile，打包镜像并把镜像推到docker服务器上。
    • Dockerfile
FROM openjdk:8-jdk-alpine

LABEL version="1.0" maintainer="yayiyo@chinaunicom.com"
VOLUME /tmp
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
ARG JAR_FILE
ADD target/springcloud-k8s-customer-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java", "-jar","/app.jar"]
EXPOSE 808
  • idea的docker配置

在这里插入图片描述

  • 3. 把镜像推到docker仓库里面
#查看本地仓库里面是否有该镜像
docker images
# 推到远程镜像仓库
docker push 镜像名
  • 4.在k8s-master服务器上 编写 customer-service.yaml并执行
kubectl apply -f  customer-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: customer-service
  labels:
    app.kubernetes.io/name: customer-service
spec:
  # 可以直接使用NodePort方式放开端口，这里使用ClusterIP+nginx的方式，其好处是使用负载均衡以及nginx代理。
  # 注意：如果使用NodePort方式，则不用编写ingress-nginx-controller以及tcp-services-configmap
  type: ClusterIP
  ports:
    - port: 8081
      targetPort: 8081
      nodePort: 8081
      protocol: TCP
      name: http
  selector:
    app.kubernetes.io/name: customer-service

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: customer-service
  labels:
    app.kubernetes.io/name: customer-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/name: customer-service
  template:
    metadata:
      labels:
        app.kubernetes.io/name: customer-service
        app.kubernetes.io/instance: sad-markhor
    spec:
      containers:
        - name: customer-service
          image: "192.168.0.22:5000/spring-cloud-k8s-customer:1.0"
          imagePullPolicy: Always
          ports:
            - name: http
              containerPort: 8081
              protocol: TCP
---
# Source: ingress-nginx/templates/controller-service.yaml
apiVersion: v1
kind: Service
metadata:
  labels:
    helm.sh/chart: ingress-nginx-2.13.0
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/instance: ingress-nginx
    app.kubernetes.io/version: 0.35.0
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/component: controller
  name: ingress-nginx-controller
  namespace: ingress-nginx
spec:
  type: LoadBalancer
  externalTrafficPolicy: Cluster
  ports:
    # 该名称需要与消费者service中的name保持一致
    - name: customer-service
      port: 8081
      protocol: TCP
      targetPort: 8081
      nodePort: 8081
  selector:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/instance: ingress-nginx
    app.kubernetes.io/component: controller
---
apiVersion: v1
kind: ConfigMap
metadata:
  # 该文件需要在ingress-nginx-controller中引用。
  name: tcp-services-configmap
  namespace: ingress-nginx
data:
  "8081": "default/customer-service:8081"

正常可以在浏览器中看到：
在这里插入图片描述

  • 注意问题：

  1. 在ide编辑时一定要用LF格式
    在这里插入图片描述
  2. 执行dockerfile后记得在服务器上push镜像。
  3. customer中的producerCLient.java中FeignClient 的url要写ip:port，只写服务名是找不到该服务的。
@FeignClient(name = "http://producer-service:8082", url = "http://producer-service:8082", fallback = ProducerClientFallback.class)
  1. 如果想在本机测试，可以在host里面设置producer-service
127.0.0.1 producer-service
heliu3
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
k8s部署springcloud_k8s部署springcloud落地实战步骤
weixin_39600400的博客
01-22 3908
前言k8s部署springcloud实际落地操作 在我的这篇文章中，我介绍了工作中实际落地的方案，大家都很感兴趣，想要更详细地介绍，这里我在本地用minikube给大家做一个演示。演示的最终效果如下图，把网关部分和ingress去掉了，这里只演示核心，写了一个提供者和一个消费者，然后把他们注册到外部到注册中心nacos中，然后浏览器访问消费者的时候，消费者用注册中心获取的服务名远程去访问提供者的数...
springcloud和kubernetes对比
cxzhq2002的杂记
12-15 3179
请问：由于这两个都不熟，所以在考虑学哪个？ 先说结论：都要学，但是重点学k8s，k8s是一个更加完善的解决方案，springcloud被淘汰只是时间的问题。 从自己的经历和网上的文章两方面分析 个人经历： 目前所在的公司的系统是springcloud和k8s混合使用，目前正在逐步用k8s中的功能替代springcloud里的功能。 已经替代掉的：服务发现。以前用的是eureka，目前删除里eureka，直接用feignclient访问k8s里的service地址。 正在考虑中的：配置中心。目
Spring Cloud + Docker + K8S 项目优化
sinat_27143551的博客
12-17 5861
1.1 spring cloud框架 Spring Cloud从技术架构上降低了对大型系统构建的要求，使我们以非常低的成本（技术或者硬件）搭建一套高效、分布式、容错的平台。 Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot...
基于SpringCloudAlibaba+Docker+K8s的服务自动扩容设计
最新发布
huxian1234的专栏
05-14 732
胡弦，视频号2023年度优秀创作者，互联网大厂P8技术专家，Spring Cloud Alibaba微服务架构实战派(上下册)和RocketMQ消息中间件实战派(上下册)的作者，资深架构师，技术负责人，极客时间训练营讲师，四维口袋KVP最具价值技术专家，技术领域专家团成员，2021电子工业出版社年度优秀作者，获得2023电子工业出版技术成长领路人称号，荣获2024年电子工业出版社博文视点20周年荣誉专家称号。
Kubernetes部署SpringCloud微服务
weixin_43876317的博客
04-02 2504
Kubernetes部署SpringCloud项目 一.Kubernetes集群版本 版本情况 NAME STATUS ROLES AGE VERSION server101 Ready <none> 6d18h v1.15.1 server88 Ready master 6d19h v1.15.1 二.K8S 部...
Spring Cloud + Kubernetes 微服务框架原理和实践
热门推荐
文西
12-06 1万+
早在半年前，公司开始推行容器化部署方案 AppOS，虽然发布界面过于极客，十分晦涩，不过仔细研究起来真的觉得十分强大，容器化推行后，计算资源（CPU、内存）的利用率可以极大提高，降低服务器数量，从而节约技术成本。恰巧，若干个朋友所在创业公司最近也在尝试做微服务、容器化。架构上摒弃 SOA 的 dubbo，加入Spring Cloud阵营；部署方案上从过去的云服务器直接部署，升级到基于Kuberne
Docker+Kubernetes(k8s)微服务容器化实践1
08-08
而SpringCloud则是一系列框架的集合，用于解决微服务架构中的配置管理、服务注册与发现、服务间调用、负载均衡、分布式锁和Session等问题。 在【微服务开发】部分，通过实际的Thrift示例，展示了如何创建和验证...
K8S+Docker 部署 Spring Cloud 集群
04-19
k8s docker 部署springcloud集群文档。 部署开发、云平台、容器技术
部署微服务：SpringCloud和Kubernetes的比较
02-25
当我们需要部署微服务的时候，哪个更好...最近我读了A.Lukyanchikov写的一篇非常精彩的文章，讲的是用SpringCloud和Docker来构建微服务架构。如果你还没读过，你应该读一下，因为它给出了一个关于如何利用SpringCloud来
Kubernetes部署SpringCloud微服务架构高级项目实战
06-17
SpringCloud 微服务编排 、kubernetes + Docker 、Java小白也能学会
sample-spring-microservices-kubernetes：使用Spring Cloud Kubernetes，Spring Cloud Ribbon和部署在Kubernetes上的zuul代理提供的一些功能的示例Spring Boot应用程序
01-30
Kubernetes演示项目上带有Spring Boot和Spring Cloud的微服务 在这个项目中，我将向您展示最有趣的功能，用于构建在Kubernetes上部署的基于微服务的架构。 所有示例都可以轻松部署在本地Kubernetes单节点群集-...
Win10安装docker，部署springboot项目到docker上
huguang0809的博客
03-24 870
Win10安装docker+k8s，部署springboot项目到docker+k8s上 参考： 1、Windows Docker 安装 2、win10安装k8s 3、k8s通过docker desktop启动并且基于docker部署springboot项目 4、KUBERNETES部署-基于DOCKER DESKTOP 一、安装dcoker desktop Docker Desktop 官方下载地址： https://hub.docker.com/editions/community/docker-ce-
基于Docker+Kubernetes，微服务容器化开发实战
weixin_57907028的博客
05-10 1104
前言 微服务和Docker容器技术是目前分布式架构中常用的主流技术，结合Kubemetes强大的容器服务编排与调度能力，中小企业能够简单快速地构建自己的分布式互联网架构系统。本篇文章结合实际生产项目的架构重构过程和经验，详细介绍从单体架构过渡到微服务容器化的分布式架构的各方面，主要包括**微服务开发和运维技术梭的选型、Spring Cloud微服务开发、Rancher和Kubemetes生产离线环境下的安装与部署、微服务的容器化与服务编排、日志调用链的采集和展示、基于 Prometheu 的系统监控，以及微
K8s部署Spring Cloud应用
qq_54781283的博客
06-17 595
https://github.com/benwang6/spring-cloud-repo只导入前5个项目修改2,3,4,5项目的yml配置,添加相面配置,使用ip注册 按项目顺序执行:创建四个空文件夹,将2,3,4,5四个项目的jar文件复制到四个文件夹中:复制centos7-docker-image.gz到服务器并导入新建文件夹 jdk, 复制jdk-8u212-linux-x64.tar.gz到jdk目录在 jdk目录创建 Dockerfile 文件 构建镜像 eureka镜像 进入eureka目录,
技术实践｜SpringCloud在k8s下的应用分享
zhongdianjinxin的博客
08-31 3707
在k8s中，可直接使用云原生的k8s注册中心完成服务的注册及发现，网关可使用ingress完成类似的工作，然后类似于非k8s的以服务名称调用模式完成微服务的调用。在命名空间中运行的最小单元，可将之视作一个个的虚拟机，我们的应用程序都是运行于POD中。通过不同的形态可发现，在k8s中已提供了完整的运行SpringCloud的原生生态，并且通过SpringCloudKubernetes的顶层实现，完全屏蔽了底层，我们可以在微服务的层面完全无感的切换至k8s平台，甚至在应用程序层完全无侵入。...
k8s部署SpringCloud应用
zhanlijuan
10-25 649
一、准备工作 将v2目录下的文件夹上传到/root/目录 下载地址 springcloud1 项目，用k8s部署 eureka： eureka1、eureka2 item user order 相应的jar包和Dockerfile文件v2目录已写好 二、构建镜像 1 构建 jdk8 镜像 2 构建 eureka 镜像 3 构建 item 镜像 4 构建 user 镜像 5 构建 order 镜像 ...
spring cloud vs k8s
yzh_1346983557的博客
12-28 6262
个人总结： spring cloud是从应用框架层面解决了微服务架构的一部分(网关、服务发现，负载平衡，配置管理，指标跟踪等)，易于java开发者上手，缺乏打包、持续集成、伸缩、高可用和自我修复等，而且局限于java平台； k8s从平台层面解决了微服务架构整个流程，并且不限语言，上手难度稍高些。(可管理应用程序整个生命周期，应用自动扩展、持续集成、伸缩、高可用和自我修复等) Spring Cloud的微服务架构： 该图展示了运行时的方方面面，但没有包括打包、持续集成、伸缩、高可用和自我修复等在微
部署微服务的时候，Spring Cloud 和 Kubernetes 哪个更好？
Docker的专栏
12-28 3228
当我们需要部署微服务的时候，哪个更好？Spring Cloud还是Kubernetes？答案是都可以，只是各自有其优势。Spring Cloud 和 Kubernetes 都宣称自己是开发和运行微服务的最佳环境，但是它们的本质非常不一样，所追求的目标也不同。本文我们分析一下两个平台是如何在其擅长的、实现基于微服务的架构（MSA）上起到作用的，并判断如何利用两者的强项，来帮助我们在微服务旅程上获得成

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值