Eureka应用
Eureka[ju?ri?k?]简介Eureka是Netflix服务发现的服务端与客户端，Eureka提供服务注册以及服务发现的能力，当是Eureka Server时(注册中心)，所有的客户端会向其注册，当是Eureka Client时，可以从注册中心获取对应的服务信息，或者是向Eureka Server将自己作为实例注册进去，每个Eureka不仅仅是一个服务端同时还是一个客户端。注册中心当Eureka想要成为注册中心时，必须将注册中心的服务地址指向自己，同时禁用服务检索的功能。Eureka是一个高可用的组件，它没有后端缓存，每一个实例注册之后需要向注册中心发送心跳来检测服务的可用性，注册中心不处理请求的转发，只是记录每个实例注册进来的信息。mark项目搭建导入依赖编写配置文件开启这个功能 @EnableXXXXXX配置类Eureka服务pom<?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</artifactId>
<groupId>cn.com.codingce</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>springcloud-eureka-7001</artifactId>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka-server</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<!--热部署工具-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
</dependencies>
</project>EurekaServerpackage cn.com.codingce;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@SpringBootApplication
@EnableEurekaServer //EnableEurekaServer 服务端启动类
public class EurekaServer {
public static void main(String[] args) {
SpringApplication.run(EurekaServer.class, args);
}
}application.ymlserver:
port: 7001
# Eureka配置
eureka:
instance:
hostname: localhost #Eureka服务端实例的名字
client:
register-with-eureka: false # 表示是否向eureka注册中心注册自己
fetch-registry: false # 表示如果 false 则表示自己为注册中心
service-url:
defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/Eureka 的自我保护模式详解访问Eureka主页时，如果看到这样一段大红色的句子：EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY’RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE.（那么就表明着Eureka的 自我保护模式(self-preservation mode) 被启动了，当 Eureka Server 节点在短时间内丢失了过多实例的连接时（比如网络故障或频繁的启动关闭客户端），那么这个节点就会进入自我保护模式，一旦进入到该模式，Eureka server 就会保护服务注册表中的信息，不再删除服务注册表中的数据（即不会注销任何微服务），当网络故障恢复后，该 Ereaka Server 节点就会自动退出自我保护模式）在自我保护模式中, EurekaServe 会保护注册表中的信息, 不再注销任何服务实例. 当他重新收到心跳数重新恢复到阈值以上时, 该EurekaServe节点就会自动推出自我保护模式. 它的哲学就是宁可保存错误的服务注册信息, 也不盲目注销任何可能健康的实例, 一句话：好死不如赖活着综上, 自我保护模式中, 自我保护模式是一种应对网络异常安全保护措施, 它的架构哲学是宁可同时保留所有微服务(健康的服务和不健康的服务都会保留), 也不盲目注销任何健康的服务. 使用自我保护模式, 可以让Eureka集群更加健壮和稳定.在SpringCloud中, 可以使用eureka.serve.enable-self-preservation = false 禁用自我保护模式 [不推荐关闭自我保护机制]默认情况下，如果 Ereaka Server 在一段时间内没有接受到某个微服务示例的心跳，便会注销该实例（默认90秒），而一旦进入自我保护模式，那么即使你关闭了指定实例，仍然会发现该 Ereaka Server 的注册实例中会存在被关闭的实例信息，如果你对该实例做了负载均衡，那么仅关闭了其中一个实例，则通过网关调用接口api时很可能会发生如下异常：{
"timestamp": 1507707671780,
"status": 500,
"error": "Internal Server Error",
"exception": "com.netflix.zuul.exception.ZuulException",
"message": "GENERAL"
}解决这种情况的方法主要有几种方式：等待 Eureka Server 自动恢复 正常的情况下，等待网络恢复（或者没有频繁的启动与关闭实例）后，等待一段时间 Eureka Server 会自动关闭自我保护模式，但是如果它迟迟没有关闭该模式，那么便可以尝试手动关闭，如下。重启 Eureka Server 通常而言，PRD 环境建议对 Eureka Server 做负载均衡，这样在依次关闭并开启 Eureka Server 后，无效的实例会被清除，并且不会对正常的使用照成影响。关闭 Eureka 的自我保护模式 在yml配置文件中新增如下配置：eureka:
server:
enable-self-preservation: false
eviction-interval-timer-in-ms: 4000 # This is not required对比Zookeeper回顾CAP原则 RDBMS(Mysql、Oracle、sqlServer) ==>ACID NoSQL(redis、 mongdb)==>CAPACID是什么A(Atomicity)原子性：事务里面的所有操作，要么全部做完，要么都不做，只要有一个失败，整个事务都失败，需要回滚C(Consistency)一致性：以转账案例为例，假设有五个账户，每个账户余额是100元，那么五个账户总额是500元，如果在这个5个账户之间同时发生多个转账，无论并发多少个，比如在A与B账户之间转账5元，在C与D账户之间转账10元，在B与E之间转账15元，五个账户总额也应该还是500元，这就是保护性和不变性I(Isolation)隔离性：并发的事务之间互不影响D(Durability)持久性：事务一旦提交，数据将永久保存在数据库上CAP是什么C(Consistency)强一致性A(Availability)可用性P(Partition tolerance) 分区容错性CAP的三进二 CA AP CPCAP理论核心一个分布式系统不可能同时很好的满足一致性、可用性和分区容错性三个要求根据CAP原理, 将NOSQL数据库分成了满足CA原则， 满足CP原则满足AP原则三大类CA：单点集群, 满足一致性, 可用性的系统, 通常可扩展性差CP: 满足一致性, 分区容错性的系统, 通常性能不是特别高AP：满足可用性，分区容错性的系统，通常可能对一致性要求低一点作为服务注册中心, Eureka比Zookeeper好在哪里 著名的CAP理论指出, 一个分布式系统不可能同时满足C(一致性)A(可用性)P(容错性) 由于分区容错性P在分布式系统中是必须要保证的, 因此我们只能在A和C之前进行权衡Zookeeper保证的是CPEureka保证的是APZookeeper保证的是CP当向注册中心查询服务列表时，我们可以容忍注册中心返回的是几分钟以前的信息，但不能就收服务直接 down 掉不可用。也就是说服务注册的可用性要高于一致性 当时 zk 会出现这么一个情况，当 mastr 节点因网络故障和其他节点失去联系时，剩余节点会重新进行选举。问题在于，选举时间比较长，30s~120s，且选举期间，整个 zk 是不可用的。这就导致了在选举期间，注册服务的瘫痪。在云部署的环境下，因网络问题使 zk 集群时区 master 节点是交大概率会发生的事情，虽然服务能够最终恢复，但是漫长的选举时间导致的注册服务长期不可用是不能容忍的。Eureka保证的是APEureka 明白这一点，因此在设计时，就优先保证可用性. Eureka 各个节点是平等的 ，几个节点挂掉不会影响正常工作，只要有一台 Eureka 存在，就可以保证注册服务可用（保证可用性），只不过查到的信息可能不是最新的（不保证强一致性）。除此之外，Eureka 还有一种自我保护机制，如果在 15 分钟内超过 85% 的节点没有正常的心跳，那么 Eureka 就会认为客户端与注册中心出现了故障，此时会出现以下几种情况：Eureka 不再从注册列表中移出因长时间没收到心跳而应该过期的服务Eureka 仍然能够接受新服务的注册和查询要求，但是不会被同步到其他节点上（即保证当前节点依然可用）当网络稳定时，当前实例新的注册信息会被同步到其他节点中结论 Eureka 可以很好的应对因网络故障导致部分节点失去联系的情况，而不会像 zookeeper 那样使整个注册服务瘫痪服务注册集群搭建springcloud-eureka-7002pom<?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</artifactId>
<groupId>cn.com.codingce</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>springcloud-eureka-7002</artifactId>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka-server</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<!--热部署工具-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
</dependencies>
</project>application.ymlserver:
port: 7002
# Eureka配置
eureka:
instance:
hostname: eureka7002.com #Eureka服务端实例的名字
client:
register-with-eureka: false # 表示是否向eureka注册中心注册自己
fetch-registry: false # 表示如果 false 则表示自己为注册中心
service-url:
defaultZone: http://eureka7001.com:7001/eureka/, http://eureka7003.com:7003/eureka/启动类package cn.com.codingce;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@SpringBootApplication
@EnableEurekaServer //EnableEurekaServer 服务端启动类
public class EurekaServer_7003 {
public static void main(String[] args) {
SpringApplication.run(EurekaServer_7003.class, args);
}
}springcloud-eureka-7003pom<?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</artifactId>
<groupId>cn.com.codingce</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>springcloud-eureka-7003</artifactId>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka-server</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<!--热部署工具-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
</dependencies>
</project>application.ymlserver:
port: 7003
# Eureka配置
server:
port: 7003
# Eureka配置
eureka:
instance:
hostname: eureka7003.com #Eureka服务端实例的名字
client:
register-with-eureka: false # 表示是否向eureka注册中心注册自己
fetch-registry: false # 表示如果 false 则表示自己为注册中心
service-url:
defaultZone: http://eureka7001.com:7001/eureka/, http://eureka7002.com:7002/eureka/启动类package cn.com.codingce;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@SpringBootApplication
@EnableEurekaServer //EnableEurekaServer 服务端启动类
public class EurekaServer_7003 {
public static void main(String[] args) {
SpringApplication.run(EurekaServer_7003.class, args);
}
}
Ribbon讲解与应用
Ribbon [?r?b?n]Ribbon是什么Spring Cloud Ribbon是一个基于HTTP和TCP的 客户端 负载均衡 工具 简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，就是在配置文件中列出Load Balancer（简称LB）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等）去连接这些机器。我们也很容易使用Ribbon实现自定义的负载均衡算法。它基于Netflix Ribbon实现。通过Spring Cloud的封装，可以让我们轻松地将面向服务的REST模版请求自动转换成客户端负载均衡的服务调用。Spring Cloud Ribbon虽然只是一个工具类框架，它不像服务注册中心、配置中心、API网关那样需要独立部署，但是它几乎存在于每一个Spring Cloud构建的微服务和基础设施中。因为微服务间的调用，API网关的请求转发等内容，实际上都是通过Ribbon来实现的，包括后续我们将要介绍的Feign，它也是基于Ribbon实现的工具。所以，对Spring Cloud Ribbon的理解和使用，对于我们使用Spring Cloud来构建微服务非常重要。面试造飞机, 工作拧螺丝 负载均衡-1.1Ribbon能干嘛LB（负载均衡 LB，即负载均衡(Load Balance)，在微服务或分布式集群中经常用的一种应用。负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA。常见的负载均衡有软件Nginx，LVS，硬件 F5等。相应的在中间件，例如：dubbo和SpringCloud中均给我们提供了负载均衡，SpringCloud的负载均衡算法可以自定义。负载均衡的简单分类集中式LB 即在服务的消费方和提供方之间使用独立的LB设施 (可以是硬件，如F5, 也可以是软件，如nginx), 由该设施负责把访问请求通过某种策略转发至服务的提供方；将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择出一个合适的服务器。Ribbon就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址。注意：Ribbon就属于进程内LB ，它只是一个类库，集成于消费方进程，消费方通过它来 获取到服务提供方的地址 。? 负载均衡-2.1具体操作pom<?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</artifactId>
<groupId>cn.com.codingce</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>springcloud-consumer-dept</artifactId>
<dependencies>
<!--我们需要拿到实体类, 所以要配置api -module-->
<dependency>
<groupId>cn.com.codingce</groupId>
<artifactId>springcloud-api</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<!--热部署工具-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--Ribbon-->
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-ribbon -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-ribbon</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<!--Eureka 客户端-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
</dependencies>
</project>ConfigBeanpackage cn.com.codingce.springcloud.config;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration
public class ConfigBean { //configuration -- spring applicationContext.xml
//配置负载均衡实现RestTemplate @LoadBalanced
//IRule
//AvailabilityFilteringRule: 先会过滤掉, 跳闸, 访问故障服务器
//RoundRobinRule 轮询
//RandomRule 随机
//RetryRule： 会按照轮询获取服务~ 如果服务获取失败, 则会在指定的时间内进行, 重试
@Bean
@LoadBalanced
public RestTemplate getRestTemplate() {
return new RestTemplate();
}
}DeptConsumerControllerpackage cn.com.codingce.springcloud.controller;
import cn.com.codingce.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import java.util.List;
@RestController
public class DeptConsumerController {
// 理解消费者, 不应该有service层
//RestFul风格
//(url, 实体: Map classs<T> responseType)
@Autowired
private RestTemplate restTemplate; //提供多种便捷访问远程http服务的方法
//原 private static final String REST_URL_PREFIX = "http://localhost:8001";
// Ribbon 我们这里是地址 因该是一个变量 通过服务来访问
private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";
@RequestMapping("/consumer/dept/add")
public boolean add(Dept dept) {
return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);
}
//http://localhost:8001/dept/list
@RequestMapping("/consumer/dept/get/{id}")
public Dept get(@PathVariable("id") Long id) {
return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class );
}
@RequestMapping("/consumer/dept/list")
public List<Dept> list() {
return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list" , List.class );
}
}自定义负载均衡注意一点: 自定义类 单独拿出来 该类不能被@ComponentScan扫描到项目截图自定义CodingCeRandomRulepackage cn.com.codingce.myrule;
import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
/**
* 该类不能被@ComponentScan扫描到
* @author xzMa
*/
public class CodingCeRandomRule extends AbstractLoadBalancerRule {
//自定义 每个服务, 访问5次, 换下一个服务(3个)
//total = 0 默认=0 如果=5 我们指向下一个服务点
private int total = 0; //被调用的次数
private int currentIndex = 0; //当前是谁在提供服务
public CodingCeRandomRule() {}
// @SuppressWarnings({"RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})
public Server choose(ILoadBalancer lb, Object key) {
if (lb == null) {
return null;
} else {
Server server = null;
while(server == null) {
//线程中断
if (Thread.interrupted()) {
return null;
}
List<Server> upList = lb.getReachableServers(); //获得活着的服务
List<Server> allList = lb.getAllServers(); //获得全部服务
int serverCount = allList.size();
if (serverCount == 0) {
return null;
}
//int index = this.chooseRandomInt(serverCount); //生成区间随机数
//server = (Server)upList.get(index); //从活着的服务, 随机获取一个
//===================================================================
if (total < 5) {
server = upList.get(currentIndex);
total++;
} else {
total = 0;
currentIndex++;
//判断当前数量是否大于活着的数量
if(currentIndex > upList.size()) {
currentIndex = 0;
}
server = upList.get(currentIndex); //从活着的服务中, 获取指定指定的服务进行操作
}
if (server == null) {
Thread.yield();
} else {
if (server.isAlive()) {
return server;
}
server = null;
Thread.yield();
}
}
return server;
}
}
protected int chooseRandomInt(int serverCount) {
return ThreadLocalRandom.current().nextInt(serverCount);
}
@Override
public Server choose(Object key) {
return this.choose(this.getLoadBalancer(), key);
}
@Override
public void initWithNiwsConfig(IClientConfig clientConfig) {
}
}CodingCeRulepackage cn.com.codingce.myrule;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class CodingCeRule {
@Bean
public IRule myRule() {
return new CodingCeRandomRule();
//默认是轮询 现在我们定义为 CodingCeRandomRule
// 本次自定义 频繁操作 会出现 500 错误 继续自定义写RetryRule
}
}项目地址: https://github.com/xzMhehe/codingce-java
Feign讲解与应用(文末送书)
Feign[fe?n]什么是Feign？Feign 的英文表意为“假装，伪装，变形”， 是一个http请求调用的轻量级框架，可以以Java接口注解的方式调用Http请求，而不用像Java中通过封装HTTP请求报文的方式直接调用。Feign通过处理注解，将请求模板化，当实际调用的时候，传入参数，根据参数再应用到请求上，进而转化成真正的请求，这种请求相对而言比较直观。Feign被广泛应用在Spring Cloud 的解决方案中，是学习基于Spring Cloud 微服务架构不可或缺的重要组件。它让微服务之间调用变得更简单了, 类似controller调用service. SpringCloud集成了Ribbon Eureka, 可以在使用Feign时提供 负载均衡 的客户端只需要一个接口, 然后添加注解即可feign主要是社区, 大家都习惯面向接口编程. 这是很多开发人员的规范. 调用微服务有两种方法微服务名字(ribbon)接口和注解(feign)Feign能干什么Feign旨在编写Java Http客户端变得更容易前面使用Ribbon + RestTemplate时, 利用RestTemplate对Http请求的封装处理, 形成了一套模块化用法. 但是实际开发中, 由于服务的依赖的调用可能不止一处, 往往一个接口会被多处调用, 所以都会针对每一个服务自行封装一些客户端类来包装这些依赖服务的调用. 所以Feign在此基础上做了进一步封装, 由他来帮助我们定义和实现依赖服务接口的定义, ?**在Feign的实现下, 我们只需要创建一个接口并使用注解的方式来配置它(类似于以前Dao接口上标注@Mapper注解, 现在是一个微服务接口上面标注一个Feign注解即可.) 即可完成对服务同提供方的接口绑定, 简化了使用SpringCloud Ribbon时, 自动封装服务调用客户端的开发量使用feign 就是代替 RestTemplate具体实现实体类项目 加入 接口(和注解)项目结构pom<?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</artifactId>
<groupId>cn.com.codingce</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>springcloud-api</artifactId>
<dependencies>
<!--当前module自己需要的依赖, 如果父依赖中已经配置了版本-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!--junit-->
<!-- <dependency>-->
<!-- <groupId>junit</groupId>-->
<!-- <artifactId>junit</artifactId>-->
<!-- </dependency>-->
<!--feign-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-feign</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
</dependency>
</dependencies>
</project>DeptClientServicepackage cn.com.codingce.service;
import cn.com.codingce.pojo.Dept;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import java.util.List;
/**
* @author xzMa
*
* feign（面向接口编程） 练习 在实体类项目 创建service包 并创建 DeptClientService接口
*
*
* 调用微服务两种方式 1 微服务名字 ribbon 2 接口和注解 feign
*
*
* 只需要 接口和注解
*
* 注解
*/
@Component
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT")
public interface DeptClientService {
//接口
@GetMapping("/dept/get/{id}")
public Dept queryById(@PathVariable("id") Long id);
@GetMapping("/dept/list")
public List<Dept> queryAll();
@PostMapping("/dept/add")
public boolean addDept(Dept dept);
}新建客户端项目(springcloud-cusumer-dept-feign)项目结构pom<?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</artifactId>
<groupId>cn.com.codingce</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<description>也是用来做客户端的</description>
<artifactId>springcloud-cusumer-dept-feign</artifactId>
<dependencies>
<!--feign-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-feign</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<!--我们需要拿到实体类, 所以要配置api -module-->
<dependency>
<groupId>cn.com.codingce</groupId>
<artifactId>springcloud-api</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<!--热部署工具-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--Ribbon-->
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-ribbon -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-ribbon</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<!--Eureka 客户端-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
</dependencies>
</project>DeptConsumerControllerpackage cn.com.codingce.springcloud.controller;
import cn.com.codingce.pojo.Dept;
import cn.com.codingce.service.DeptClientService;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.List;
@RestController
public class DeptConsumerController {
@Resource
private DeptClientService deptClientService = null;
@RequestMapping("/consumer/dept/add")
public boolean add(Dept dept) {
return this.deptClientService.addDept(dept);
}
@RequestMapping("/consumer/dept/get/{id}")
public Dept get(@PathVariable("id") Long id) {
return this.deptClientService.queryById(id);
}
@RequestMapping("/consumer/dept/list")
public List<Dept> list() {
return this.deptClientService.queryAll();
}
}ConfigBean(配置Ribbon)package cn.com.codingce.springcloud.config;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration
public class ConfigBean { //configuration -- spring applicationContext.xml
//配置负载均衡实现RestTemplate @LoadBalanced
//IRule
//AvailabilityFilteringRule: 先会过滤掉, 跳闸, 访问故障服务器
//RoundRobinRule 轮询
//RandomRule 随机
//RetryRule： 会按照轮询获取服务~ 如果服务获取失败, 则会在指定的时间内进行, 重试
@Bean
@LoadBalanced
public RestTemplate getRestTemplate() {
return new RestTemplate();
}
@Bean
public IRule myRule() {
return new RandomRule();
}
}启动类FeginDeptConsumer_80package cn.com.codingce.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.ComponentScan;
/**
* @author xzMa
* 在微服务启动的时候就能加载我们自定义的Ribbon类
*/
@SpringBootApplication
@EnableEurekaClient //Eureka 客户端
@EnableFeignClients(basePackages = {"cn.com.codingce"})
@ComponentScan("cn.com.codingce")
public class FeginDeptConsumer_80 {
public static void main(String[] args) {
SpringApplication.run(FeginDeptConsumer_80.class, args);
}
}运行截图本项目地址:https://github.com/xzMhehe/codingce-java?开源项目地址：https://github.com/OpenFeign/feign
云服务器第一阶段学习
一、nginx1.前言 为什么要使用nginx？不直接用tomcat，还做多了一次接请求？2.为什么要使用nginx 在传统的Web项目中，并发量小，用户使用的少。所以在低并发的情况下，用户可以直接访问tomcat服务器，然后tomcat服务器返回消息给用户。比如，我们上传图片：当然我们知道，为了解决并发，可以使用负载均衡：也就是我们多增加几个tomcat服务器。当用户访问的时候，请求可以提交到空闲的tomcat服务器上。http://localhost:8080/crm ? ?8081 ?crm8082 ?crm但是这种情况下可能会有一种这样的问题：上传图片操作。我们把图片上传到了tomcat1上了，当我们要访问这个图片的时候，tomcat1正好在工作，所以访问的请求就交给其他的tomcat操作，而tomcat之间的数据没有进行同步，所以就发生了我们要请求的图片找不到。??????为了解决这种情况，我们就想出了分布式。我们专门建立一个图片服务器，用来存储图片。这样当我们都把图片上传的时候，不管是哪个服务器接收到图片，都把图片上传到图片服务器。??????图片服务器上需要安装一个http服务器，可以使用tomcat、apache、nginx。看到这里有人可能会问，既然我们要选择的是http服务器，为什么不继续使用tomcat，而要使用Nginx？??????原因如下：nginx常用做静态内容服务和代理服务器（不是你FQ那个代理），直面外来请求转发给后面的应用服务（tomcat），tomcat更多用来做做一个应用容器，让java web app跑在里面的东西，对应同级别的有jboss,jetty等东西。3.什么是Nginx？ 根据前面的对比，我们可以了解到Nginx是一个http服务器。是一个使用c语言开发的高性能的http服务器及反向代理服务器。Nginx是一款高性能的http 服务器/反向代理服务器及电子邮件（IMAP/POP3）代理服务器。由俄罗斯的程序设计师Igor Sysoev所开发，官方测试nginx能够支支撑5万并发链接，并且cpu、内存等资源消耗却非常低，运行非常稳定。4.Nginx的应用场景 1、 http服务器。Nginx是一个http服务可以独立提供http服务。可以做网页静态服务器。 2、 虚拟主机。可以实现在一台服务器虚拟出多个网站。例如个人网站使用的虚拟主机。 ??基于端口的，不同的端口 ??基于域名的，不同域名? 3、 反向代理，负载均衡。当网站的访问量达到一定程度后，单台服务器不能满足用户的请求时，需要用多台服务器集群可以使用nginx做反向代理。并且多台服务器可以平均分担负载，不会因为某台服务器负载高宕机而某台服务器闲置的情况。5.总结 通过了解Nginx也算是多了一门技术，而且还是挺简单的，使用也比较方便。重点是可以给系统带来很大的性能提升。
Nginx实现负载均衡(整合SpringBoot小demo)
1.前言要理解负载均衡，必须先搞清楚正向代理和反向代理。注：正向代理，代理的是用户。反向代理，代理的是服务器。2.什么是负载均衡当一台服务器的单位时间内的访问量越大时，服务器压力就越大，大到超过自身承受能力时，服务器就会崩溃。为了避免服务器崩溃，让用户有更好的体验，我们通过负载均衡的方式来分担服务器压力。我们可以建立很多很多服务器，组成一个服务器集群，当用户访问网站时，先访问一个中间服务器，在让这个中间服务器在服务器集群中选择一个压力较小的服务器，然后将该访问请求引入该服务器。如此以来，用户的每次访问，都会保证服务器集群中的每个服务器压力趋于平衡，分担了服务器压力，避免了服务器崩溃的情况。负载均衡是用反向代理的原理实现的。3.准备工作结合本文场景，需要安装Nginx和Java环境（运行SpringBoot项目）3.1 关于Mac系统安装Nginx3.1 关于Mac系统安装本次用的是 homebrew 安装的大家也可前去官网下载3.2 测试项目说明3由于只是测试, SpringBoot只是映射了根路径，端口分别是 10001 和 10002 ，分别返回 demo1 和 demo2 字符串作为区分。4.Nginx负载均衡的集中方式介绍4.1 轮询4.1 轮询4.1 轮询轮询方式是Nginx负载默认的方式，顾名思义，所有请求都按照时间顺序分配到不同的服务上，如果服务Down掉，可以自动剔除，如下配置后轮训10001服务和10002服务。upstream codingce-nginx {
server localhost:10001;
server localhost:10002;
}44.2 权重.2 权重指定每个服务的权重比例，weight和访问比率成正比，通常用于后端服务机器性能不统一，将性能好的分配权重高来发挥服务器最大性能，如下配置后10002服务的访问比率会是10001服务的二倍。upstream codingce-nginx {
server localhost:10001 weight=1;
server localhost:10002 weight=2;
}44.3 iphash.3 iphash每个请求都根据访问ip的hash结果分配，经过这样的处理，每个访客固定访问一个后端服务，如下配置（ip_hash可以和weight配合使用）。upstream codingce-nginx {
ip_hash;
server localhost:10001 weight=1;
server localhost:10002 weight=2;
}44.4 最少连接.4 最少连接将请求分配到连接数最少的服务上。upstream codingce-nginx {
least_conn;
server localhost:10001 weight=1;
server localhost:10002 weight=2;
}44.5 fair（第三方）.5 fair（第三方）按后端服务器的响应时间来分配请求，响应时间短的优先分配。upstream codingce-nginx {
server localhost:10001 weight=1;
server localhost:10002 weight=2;
fair;
}44.6 url_hash（第三方）.6 url_hash（第三方）按访问url的hash结果来分配请求，使每个url定向到同一个后端服务器，后端服务器为缓存时比较有效。upstream codingce-nginx {
server localhost:10001;
server localhost:10002;
hash $request_uri;
hash_method crc32;
}5.测试(以轮询为例子)访问http://localhost:10000轮询方式，刷新后依次切换后端服务如果要修改负载均衡算法修改对应upstream模块即可。此次nginx路径展示主配置与自定义配置注意：下方自定义配置文件是自定义配置文件目录 vhost/轮询配置 在nginx.conf文件中配置的upstream codingce-nginx {
server localhost:10001;
server localhost:10002;
}进入自定义配置文件夹配置自定义配置williamma@WilliamdeMacBook-Pro nginx % cd vhost
williamma@WilliamdeMacBook-Pro vhost % ll
total 16
drwxr-xr-x 4 williamma admin 128 5 13 15:17 ./
drwxr-xr-x 19 williamma admin 608 5 13 15:28 ../
-rw-r--r-- 1 williamma admin 549 4 16 16:17 gulimall.conf
-rw-r--r-- 1 williamma admin 167 5 13 15:17 mytest.conf
williamma@WilliamdeMacBook-Pro vhost % vim mytest.conf配置文件展示server {
listen 10000;
server_name localhost;
location / {
#用在此处
proxy_pass http://codingce-nginx;
proxy_redirect default;
}
}测试SpringBoot项目地址[Github]：https://github.com/xzMhehe/codingce-java[Gitee]”https://gitee.com/codingce/codingce-java
接口测试(27)session、cookie和token的区别1
本章目录1.任务目标2.底理解cookie，session，token的使用及原理3.Cookie4.Session5.Token6.小结1.任务目标了解session、cookie和token的区别，并且熟练掌握。2.底理解cookie，session，token的使用及原理发展史1、很久很久以前，Web 基本上就是文档的浏览而已， 既然是浏览，作为服务器， 不需要记录谁在某一段时间里都浏览了什么文档，每次请求都是一个新的HTTP协议， 就是请求加响应， 尤其是我不用记住是谁刚刚发了HTTP请求， 每个请求对我来说都是全新的。这段时间很嗨皮2、但是随着交互式Web应用的兴起，像在线购物网站，需要登录的网站等等，马上就面临一个问题，那就是要管理会话，必须记住哪些人登录系统， 哪些人往自己的购物车中放商品， 也就是说我必须把每个人区分开，这就是一个不小的挑战，因为HTTP请求是无状态的，所以想出的办法就是给大家发一个会话标识(session id), 说白了就是一个随机的字串，每个人收到的都不一样， 每次大家向我发起HTTP请求的时候，把这个字符串给一并捎过来， 这样我就能区分开谁是谁了3、这样大家很嗨皮了，可是服务器就不嗨皮了，每个人只需要保存自己的session id，而服务器要保存所有人的session id ！ 如果访问服务器多了， 就得由成千上万，甚至几十万个。这对服务器说是一个巨大的开销 ， 严重的限制了服务器扩展能力， 比如说我用两个机器组成了一个集群， 小F通过机器A登录了系统， 那session id会保存在机器A上， 假设小F的下一次请求被转发到机器B怎么办？ 机器B可没有小F的 session id啊。有时候会采用一点小伎俩： session sticky ， 就是让小F的请求一直粘连在机器A上， 但是这也不管用， 要是机器A挂掉了， 还得转到机器B去。那只好做session 的复制了， 把session id 在两个机器之间搬来搬去， 快累死了。后来有个叫Memcached的支了招： 把session id 集中存储到一个地方， 所有的机器都来访问这个地方的数据， 这样一来，就不用复制了， 但是增加了单点失败的可能性， 要是那个负责session 的机器挂了， 所有人都得重新登录一遍， 估计得被人骂死。也尝试把这个单点的机器也搞出集群，增加可靠性， 但不管如何， 这小小的session 对我来说是一个沉重的负担4 .于是有人就一直在思考， 我为什么要保存这可恶的session呢， 只让每个客户端去保存该多好？可是如果不保存这些session id , 怎么验证客户端发给我的session id 的确是我生成的呢？ 如果不去验证，我们都不知道他们是不是合法登录的用户， 那些不怀好意的家伙们就可以伪造session id , 为所欲为了。嗯，对了，关键点就是验证 ！比如说， 小F已经登录了系统， 我给他发一个令牌(token)， 里边包含了小F的 user id， 下一次小F 再次通过Http 请求访问我的时候， 把这个token 通过Http header 带过来不就可以了。不过这和session id没有本质区别啊， 任何人都可以可以伪造， 所以我得想点儿办法， 让别人伪造不了。那就对数据做一个签名吧， 比如说我用HMAC-SHA256 算法，加上一个只有我才知道的密钥， 对数据做一个签名， 把这个签名和数据一起作为token ， 由于密钥别人不知道， 就无法伪造token了。这个token 我不保存， 当小F把这个token 给我发过来的时候，我再用同样的HMAC-SHA256 算法和同样的密钥，对数据再计算一次签名， 和token 中的签名做个比较， 如果相同， 我就知道小F已经登录过了，并且可以直接取到小F的user id , 如果不相同， 数据部分肯定被人篡改过， 我就告诉发送者： 对不起，没有认证。Token 中的数据是明文保存的（虽然我会用Base64做下编码， 但那不是加密）， 还是可以被别人看到的， 所以我不能在其中保存像密码这样的敏感信息。当然， 如果一个人的token 被别人偷走了， 那我也没办法， 我也会认为小偷就是合法用户， 这其实和一个人的session id 被别人偷走是一样的。这样一来， 我就不保存session id 了， 我只是生成token , 然后验证token ， 我用我的CPU计算时间获取了我的session 存储空间 ！解除了session id这个负担， 可以说是无事一身轻， 我的机器集群现在可以轻松地做水平扩展， 用户访问量增大， 直接加机器就行。 这种无状态的感觉实在是太好了！3.Cookiecookie 是一个非常具体的东西，指的就是浏览器里面能永久存储的一种数据，仅仅是浏览器实现的一种数据存储功能。cookie由服务器生成，发送给浏览器，浏览器把cookie以kv形式保存到某个目录下的文本文件内，下一次请求同一网站时会把该cookie发送给服务器。由于cookie是存在客户端上的，所以浏览器加入了一些限制确保cookie不会被恶意使用，同时不会占据太多磁盘空间，所以每个域的cookie数量是有限的。4.Sessionsession 从字面上讲，就是会话。这个就类似于你和一个人交谈，你怎么知道当前和你交谈的是张三而不是李四呢？对方肯定有某种特征（长相等）表明他就是张三。session 也是类似的道理，服务器要知道当前发请求给自己的是谁。为了做这种区分，服务器就要给每个客户端分配不同的“身份标识”，然后客户端每次向服务器发请求的时候，都带上这个“身份标识”，服务器就知道这个请求来自于谁了。至于客户端怎么保存这个“身份标识”，可以有很多种方式，对于浏览器客户端，大家都默认采用 cookie 的方式。服务器使用session把用户的信息临时保存在了服务器上，用户离开网站后session会被销毁。这种用户信息存储方式相对cookie来说更安全，可是session有一个缺陷：如果web服务器做了负载均衡，那么下一个操作请求到了另一台服务器的时候session会丢失。5.Token在Web领域基于Token的身份验证随处可见。在大多数使用Web API的互联网公司中，tokens 是多用户下处理认证的最佳方式。以下几点特性会让你在程序中使用基于Token的身份验证1.无状态、可扩展2.支持移动设备3.跨程序调用4.安全那些使用基于Token的身份验证的大佬们大部分你见到过的API和Web应用都使用tokens。例如Facebook, Twitter, Google+, GitHub等6.小结未完待续
尚硅谷Zookeeper学习笔记（一）
第 1 章 Zookeeper 入门1.1概述Zookeeper 是一个开源的分布式的，为分布式框架提供协调服务的 Apache 项目。1.2 特点1）Zookeeper：一个领导者（Leader），多个跟随者（Follower）组成的集群。2）集群中只要有 半数以上节点存活，Zookeeper集群就能正常服务。所以Zookeeper适合安装奇数台服务器。3）全局数据一致：每个Server保存一份相同的数据副本，Client无论连接到哪个Server，数据都是一致的。4）更新请求顺序执行，来自同一个Client的更新请求按其发送顺序依次执行。5）数据更新原子性，一次数据更新要么成功，要么失败。6）实时性，在一定时间范围内，Client能读到最新数据。1.3 数据结构ZooKeeper 数据模型的结构与 Unix 文件系统很类似，整体上可以看作是一棵树，每个节点称做一个 ZNode。每一个 ZNode 默认能够存储 1MB 的数据，每个 ZNode 都可以通过其路径唯一标识。1.4 应用场景提供的服务包括：统一命名服务、统一配置管理、统一集群管理、服务器节点动态上下线、软负载均衡等。1.5 下载地址1） 官网首页：https://zookeeper.apache.org/2） 下载截图第 2 章 Zookeeper 本地 安装2.1 本地模式 安装1） 安装前准备（1）安装 JDK（2）拷贝 apache-zookeeper-3.5.7-bin.tar.gz 安装包到 Linux 系统下（3）解压到指定目录[atguigu@hadoop102 software]$ tar -zxvf apache-zookeeper-3.5.7-bin.tar.gz -C /opt/module/
（4）修改名称[atguigu@hadoop102 module]$ mv apache-zookeeper-3.5.7 -bin/
zookeeper-3.5.72) 配置修改（1）将/opt/module/zookeeper-3.5.7/conf 这个路径下的 zoo_sample.cfg 修改为 zoo.cfg；[atguigu@hadoop102 conf]$ mv zoo_sample.cfg zoo.cfg（2）打开 zoo.cfg 文件，修改 dataDir 路径：[atguigu@hadoop102 zookeeper-3.5.7]$ vim zoo.cfg修改如下内容：dataDir=/opt/module/zookeeper-3.5.7/zkData（3）在/opt/module/zookeeper-3.5.7/这个目录上创建 zkData 文件夹[atguigu@hadoop102 zookeeper-3.5.7]$ mkdir zkData3） 操作 Zookeeper（1）启动 Zookeeper[atguigu@hadoop102 zookeeper-3.5.7]$ bin/zkServer.sh start（2）查看进程是否启动[atguigu@hadoop102 zookeeper-3.5.7]$ jps4020 Jps4001 QuorumPeerMain（3）查看状态[atguigu@hadoop102 zookeeper-3.5.7]$ bin/zkServer.sh statusZooKeeper JMX enabled by defaultUsing config: /opt/module/zookeeper-3.5.7/bin/…/conf/zoo.cfgMode: standalone（4）启动客户端[atguigu@hadoop102 zookeeper-3.5.7]$ bin/zkCli.sh（5）退出客户端：[zk: localhost:2181(CONNECTED) 0] quit（6）停止 Zookeeper[atguigu@hadoop102 zookeeper-3.5.7]$ bin/zkServer.sh stop2.2 配置参数 解读Zookeeper中的配置文件zoo.cfg中参数含义解读如下：1 ）tickTime = 2000：通信心跳 时间，Zookeeper 服务器 与 客户端 心跳时间，单位毫秒2 ）initLimit = 10?：LF初始通信时限3 ）syncLimit = 5?：LF 同步通信时限Leader和Follower之间通信时间如果超过syncLimit * tickTime，Leader认为Follwer死掉，从服务器列表中删除Follwer。4 ）dataDir ：保存Zookeeper中的数据注意：默认的tmp目录，容易被Linux系统定期删除，所以一般不用默认的tmp目录5 ）clientPort = 2181 ：客户端连接端口,通常不做修改。第 3 章 Zookeeper 集群3.1 集群操作3.1.1 集群安装1） 集群 规划在 hadoop102、hadoop103 和 hadoop104 三个节点上都部署 Zookeeper。思考：如果是 10 台服务器，需要部署多少台 Zookeeper ？2） 解压安装（1）在 hadoop102 解压 Zookeeper 安装包到/opt/module/目录下[atguigu@hadoop102 software]$ tar -zxvf apache-zookeeper-3.5.7-bin.tar.gz -C /opt/module/
（2）修改 apache-zookeeper-3.5.7-bin 名称为 zookeeper-3.5.7[atguigu@hadoop102 module]$ mv apache-zookeeper-3.5.7-bin/zookeeper-3.5.73） 配置服务器 编号（1）在/opt/module/zookeeper-3.5.7/这个目录下创建 zkData[atguigu@hadoop102 zookeeper-3.5.7]$ mkdir zkData2）在/opt/module/zookeeper-3.5.7/zkData 目录下创建一个 myid 的文件[atguigu@hadoop102 zkData]$ vi myid在文件中添加与 server 对应的编号（注意：上下不要有空行，左右不要有空格）2注意：添加 myid 文件，一定要在 Linux 里面创建，在 notepad++里面很可能乱码（3）拷贝配置好的 zookeeper 到其他机器上[atguigu@hadoop102 module ]$ xsync zookeeper-3.5.7并分别在 hadoop103、hadoop104 上修改 myid 文件中内容为 3、44） 配置zoo.cfg 文件（1）重命名/opt/module/zookeeper-3.5.7/conf 这个目录下的 zoo_sample.cfg 为 zoo.cfg[atguigu@hadoop102 conf]$ mv zoo_sample.cfg zoo.cfg（2）打开 zoo.cfg 文件[atguigu@hadoop102 conf]$ vim zoo.cfg#修改数据存储路径配置dataDir=/opt/module/zookeeper-3.5.7/zkData#增加如下配置#######################cluster##########################
server.2=hadoop102:2888:3888
server.3=hadoop103:2888:3888
server.4=hadoop104:2888:3888
（3）配置参数解读server.A=B:C:D。A 是一个数字，表示这个是第几号服务器；集群模式下配置一个文件 myid，这个文件在 dataDir 目录下，这个文件里面有一个数据就是 A 的值，Zookeeper 启动时读取此文件，拿到里面的数据与 zoo.cfg 里面的配置信息比较从而判断到底是哪个 server。B 是这个服务器的地址；C 是这个服务器 Follower 与集群中的 Leader 服务器交换信息的端口；D 是万一集群中的 Leader 服务器挂了，需要一个端口来重新进行选举，选出一个新的Leader，而这个端口就是用来执行选举时服务器相互通信的端口。(4)同步 zoo.cfg 配置文件[atguigu@hadoop102 conf]$ xsync zoo.cfg5） 集群操作（1）分别启动 Zookeeper[atguigu@hadoop102 zookeeper-3.5.7]$ bin/zkServer.sh start
[atguigu@hadoop103 zookeeper-3.5.7]$ bin/zkServer.sh start
[atguigu@hadoop104 zookeeper-3.5.7]$ bin/zkServer.sh start
（2）查看状态[atguigu@hadoop102 zookeeper-3.5.7]# bin/zkServer.sh statusJMX enabled by defaultUsing config: /opt/module/zookeeper-3.5.7/bin/…/conf/zoo.cfgMode: follower[atguigu@hadoop103 zookeeper-3.5.7]# bin/zkServer.sh status
JMX enabled by defaultUsing config: /opt/module/zookeeper-3.5.7/bin/…/conf/zoo.cfgMode: leader[atguigu@hadoop104 zookeeper-3.4.5]# bin/zkServer.sh statusJMX enabled by defaultUsing config: /opt/module/zookeeper-3.5.7/bin/…/conf/zoo.cfgMode: follower
loadrunner入门教程(1)--概述
@[TOC]1. loadrunner介绍LoadRunner是用于测试应用程序性能的常用工具。通过向整个应用程序施压，从而找出并确定潜在的客户端、网络和服务器瓶颈。LoadRunner 包括VuGen、Controller、Analysis三个部分：VuGen：它是用于创建Vuser脚本的工具。可以使用VuGen通过录制用户执行的典型业务流程来开发Vuser脚本。使用此脚本可以模拟用户使用系统实际情况。Controller：可以从单一控制点轻松、有效地控制所有Vuser，并在测试执行期间监控场景性能。Analysis：在HP LoadRunner Controller内运行负载测试场景后可以使用Analysis分析运行结果数据。Analysis图可以确定系统性能并提供有关事务及Vuser的信息。通过合并多个负载测试场景的结果或将多个图合并为一个图，可以比较多个图。2. 特性2.1 轻松创建虚拟用户使用LoadRunner的Virtual User Generator，能便捷地创立起系统负载。该引擎能够生成虚拟用户，以虚拟用户的方式模拟真实用户的业务操作行行为2.2 创建真实的负载Virtual Users建立后，需要确定负载方案、业务流程组合和虚拟用户数量；使用LoadRunner的Controller，能很快组织起多用户的测试方案。2.3 定位性能问题LoadRunner内含集成的实时监测器，在负载测试过程的任何时候，都可以观察到应用系统的运行性能。这些性能监测器将实时显示交易性能数据（如响应时间）和其他系统组件，包括Application Server、Web Server、网络设备和数据库等的实时性能。这样，就可以在测试过程中从客户和服务器双方评估这些系统组件的运行性能，从而更快地发现问题。3. 工作原理3.1 VuGen发生器在录制脚本前首先选择一种协议；接着在客户端模拟客户实际使用过程中的业务流程，并录制成一个脚本；然后编辑脚本和设置Run-Time Settings项；最后VuGen通过对脚本的编译生成一个没有错误的可运行的脚本。3.2 控制器（Controller）第一：设计场景。脚本编辑完成后，必须对脚本如何运行设计一种策略。场景设计主要包括手动场景设计和目标场景设计两种方式；场景设计的目的是设计出一个最接近用户实际使用的场景，场景设计越接近用户使用的实际情况，测试出来的数据就越接近真实值。否则测试出来的数据是不可靠的，到系统上线时可能还是会出现性能问题，场景设计也涉及很多技巧，如IP欺骗、负载均衡等一些手段。第二：场景监控。控制器可以实时监控脚本运行的情况。可以通过添加计数器来监控Windows资源、应用服务器和数据库使用情况。3.3 分析器（Analysis）Analysis分析器中提供了很多基础的数据，但是仅仅依靠这些基础的数据是不够的，客户看到这样的报告也不会满意。在这里涉及到很多分析技术，常用的分析技术有：合并、叠加、页面细分和钻取技术等。Analysis的另一个优点就是它本身提供了很多报告的形式，包括PDF、HTML等。4. 工作过程第一步：通过VuGen来设计脚本。设计脚本包括录制脚本和编辑脚本。但在录制脚本之前需要分析业务模式并建立业务模式（通过对业务模式的分析可使模拟过程更接近用户的实际使用）。脚本录制完成之后，需要对脚本进行编辑，主要是对脚本进行修改和增强。第二步：通过Controller来设计场景和执行场景。在场景设计之前必须对业务环境的场景进行充分的分析，然后新建场景，这样才能设计出更接近用户实际使用的场景模型。接下来要执行场景，Controller通过加载脚本的形式来控制虚拟用户脚本运行的情况以保证虚拟用户按录制时的业务流程来执行。第三步：虚拟用户并发执行。Controller控制器控制着脚本运行时的负载机（也就是虚拟用户），虚拟用户是通过负载机产生的，在场景设计时其中有一项便是用来设计负载发生器的，只有设计好这项内容Controller才可以调度负载机。第四步：结果分析。当场景执行测试结束后，会生成一些分析结果的数据，这时测试工程师需要对这些数据进行分析，如果结果能满足需求，那么说明系统性能满足需求，反之，就有可能需要多次进行实验，来找到性能瓶颈并向开发工程师提出解决的建议和性能调优的建议。5. 测试步骤1.制定测试方案2.创建Virtual Users3.设计测试场景4.执行场景5.分词测试结果
微服务洞察，让微服务更透明
微服务作为云原生时代下一种开发软件的架构和组织方法，通过将明确定义的功能分成更小的服务，并让每个服务独立迭代，增加了应用程序的灵活性，允许开发者根据需要更轻松地更改部分应用程序。同时每个微服务可以由单独的团队进行管理，使用适当的语言编写，并根据需要进行独立扩缩容。但微服务同样也并非“银弹”，在带来如此多的优势的同时，逐渐膨胀的微服务数量也为系统带来了空前的复杂度，服务之间错综复杂的调用、协作关系如同一层迷雾笼罩在系统之上，借助Trace、Log、Metric三驾马车我们的系统具备了一定的可观测性，但所能得到信息是标准化且固定的，往往不能够满足复杂场景下的观测需求，比如微服务引擎MSE（Microservices Engine）中的微服务治理功能模块为用户用好微服务提供了诸多帮助，但其中的很多功能，比如全链路灰度、无损上下线等会涉及多个应用，且所涉及的信息又不被标准的可观测系统覆盖。而微服务洞察通过动态的信息采集能够填补这其中的一部分空缺，更好地满足这些微服务场景的观测需求，同时也将他们纳入到标准的观测体系中来。微服务洞察设想这样一个问题现场，线上系统出现了一个奇怪的问题，某一个接口偶现错误，频率不高，出现时间毫无规律，但是没有发现任何有效的错误日志。这时，在通常的实践中，除非具备脑内debug的神力，不然我们往往需要在代码中增加日志逻辑，然后重启应用，静静等待问题复现后查询日志，如果定位了问题范围需要更多的信息，就需要我们不断循环 编写日志逻辑->重启应用->静静等待 的步骤直到解决bug。但这还不是最令人头疼的，如果给这个问题加上问题触发伴随应用重启、pod内日志丢失、重启后问题无法复现等debuff，排查的难度将会进一步上升。而由于微服务洞察具备任意位置类粒度的动态信息采集的核心能力，能够帮助我们解决上述场景中的一些痛点。首先在第一次发现这个问题后，我们可以直接在线上环境中通过配置一条微服务洞察的规则，来收集一些初步信息来帮助我们判断可能的问题原因。由于收集的信息会以调用链的形式组织，我们可以从中获取问题出现的频率、时间、参数分布、上下游调用信息等。同时由于信息会直接上报并集中存储到远端系统，因此不受应用重启的影响，我们也不需要一台一台实例去查询日志。在对问题有了初步的判断之后，我们往往能够将问题定位到一个范围之内，这时我们可以进一步锁定某些方法，通过配置规则，打印它们的入参、返回值、调用堆栈等信息来判断其执行是否符合预期。通过上述的举例可以发现，借助微服务洞察的能力，我们能够轻松地探知标准的可观测系统难以触达的角落，从而满足我们对一些微服务场景的观测需求。洞察微服务场景无损下线无损下线是微服务治理中的一个功能，主要是为了解决在发布过程中的微服务在下线的过程中可能存在的流量损失。其大致流程如下图所示。通过一系列的策略和措施，能够做到服务的完全无损下线。但这样就导致无损下线的流程比较复杂，同时还涉及到多个节点之间的通知机制，特别是在大规模之下，下线流程的完整性以及可靠性的确认变得非常复杂与繁琐。这就是前文所提到的难以触达的角落，我们可以通过微服务洞察的能力帮助我们观测这个场景。针对无损下线的场景，微服务洞察提供了场景化的规则，简单配置一键开启。在开启了规则之后，微服务洞察会收集无损下线流程中值得关心的信息，组织成调用链的形式展示。如下图场景，我们对 108 节点进行缩容操作，我们就可以得到一条 Tracing 链路，其中包含主动通知、服务注销、应用停止等几个步骤，并且我们可以在每个步骤中看到所需的信息。在主动通知环节我们可以看到当前 Provider 节点对哪些 Consumer 进行 GoAway 请求的调用，如下图所示我们将主动通知 10.0.0.90、10.0.0.176 两个 Consumer 节点。当 Consumer 收到 GoAway 调用后，会进行负载均衡列表的刷新以及路由的隔离，我们将在负载均衡地址列表中显示最新抓到的当前 Consumer 对于当前服务缓存的最新地址列表，我们可以在下图中看到，地址列表中只剩下 10.0.0.204 这个服务提供者节点的调用地址。我们也可以看到 Spring Cloud 向 Nacos（注册中心）执行服务下线的调用结果，注销成功。微服务洞察通过将无损下线的 workflow 抽象成 Tracing 结构的策略，可以帮助我们降低大规模场景、复杂链路下无损下线问题的排查成本。全链路灰度全链路灰度是微服务治理中的另一个功能。有时某个功能发版依赖多个服务同时升级上线，我们希望可以对这些服务的新版本同时进行小流量灰度验证，这就是微服务架构中特有的全链路灰度场景，通过构建从网关到整个后端服务的环境隔离来对多个不同版本的服务进行灰度验证。在发布过程中，我们只需部署服务的灰度版本，流量在调用链路上流转时，由流经的网关、各个中间件以及各个微服务来识别灰度流量，并动态转发至对应服务的灰度版本。如下图：而在使用该能力的时候，要想探清流量的匹配情况以及流量的走向具有较大的难度。而借助微服务洞察的能力可以帮助我们便捷地感知这些信息。这部分的示例将基于A、B、C三个应用，其中A、B应用分别部署一个基线版本和一个灰度版本，其内部存在/a -> /b -> /c 的调用链路。我们只需要配置如下的规则可以看到流量的路径，以及实例和流量的标签信息。从所展示的信息中可以看到，灰度流量正确地流经了灰度实例而不是非灰度实例（其中mse.app.tag是应用的标签，mse.tag是流量的标签）全链路灰度支持按照headers中的信息来匹配灰度流量，因此我们也在上一条规则的基础上，增加如下的规则来观测灰度流量的headers信息，来帮助我们判断流量匹配是否符合预期。开启规则后，对于/a -> /b -> /c链路中的带有gray全链路灰度标签的流量，会在采集上一条规则所定义的信息的基础上，同时采集Headers信息，在链路展示页面详情展示如下：借助微服务洞察的能力，我们只需要简单的规则配置，就可以完成对复杂的全链路灰度场景的观测，让我们在使用全链路灰度时不再提心吊胆。引用的框架/组件内部微服务架构下的开发往往会使用很多框架或是中间件，这些框架和中间件的内部无法添加日志逻辑，因此在使用时对开发者来说时黑盒的，极大地增加了观测的难度。而借助微服务洞察，任意位置都只需要通过配置规则的方式就可以获取到现场信息。接下来以负载均衡和Nacos为例。NacosNacos借用官网的描述，致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据及流量管理。处于微服务架构中的关键位置，但是目前在可观测方面Nacos服务端能够获取一些信息，但是客户端则成了黑暗的角落，开发者也不能随意地添加日志信息，想要关注其中的信息难上加难。而在微服务洞察的帮助下，通过简单的规则配置，就可以获取到客户端内部的信息，来补全这部分的观测需求。我们以服务变更回调的方法以及收取订阅服务内容的方法为例，前者会在所订阅的服务发生变更时被触发，后者会在收到订阅的服务内容时被触发，通过关注这两个方法的入参，我们便可以获取到此时服务的详细信息。负载均衡以 Spring Cloud 常用的客户端负载均衡组件Ribbon作为示例，Ribbon位于客户端一侧，通过服务注册中心（本文中为Nacos）获取到一份服务端提供的可用服务列表。随后，在客户端发送请求时通过负载均衡算法选择一个服务端实例再进行访问，以达到负载均衡的目的。通过分析代码可以发现，Ribbon内部的updateZoneServerMapping方法的参数Map<String, List<Server>> map基本等同于每次更新动作最后所更新的可用服务列表。我们只需要配置一条规则来获取这个方法的入参就可以获取到当时真实的可用服务列表信息。小结本文以一个假象的场景出发，介绍了微服务引擎MSE（Microservices Engine）微服务治理功能模块中微服务洞察功能的应用场景和简单的使用介绍。借助微服务洞察，我们可以便捷地观测到一些不被标准可观测系统覆盖的角落。在提供任意位置类粒度的动态信息采集这一核心能力的同时，我们也会结合微服务开发者们的微服务开发运维经验，不断去探索更多有价值的微服务场景，在核心能力的基础上以更加贴近场景的方式收集并采集信息，旨在帮助我们更好地治理我们的微服务应用，助力于云上帮助企业构建完整的微服务体系。欢迎大家尝鲜与体验～
缺了这项功能，网站营销难上加难
科技的发展永远是服务于人的，但如果摆脱了这一前提，那科技的进步将失去意义，只有解放了更多的劳动力，大家才能更加专注的去推动社会进步。如今，CDN已被越来越多的人使用，已然成为新时代趋势。但为什么要使用CDN呢？CDN有什么作用呢？要想明白这个问题，就得先了解为什么网站访问会变慢。假设你访问一个随意的网站，时间超过了8秒，我相信你肯定会失去兴趣。大部分的人的耐心都撑不住8秒，加载时间过长的话，很多人就会放弃访问，即便这个网站的内容做得再丰富多彩，它加载速度过慢，我们也会选择放弃访问它。为了避免此类问题的扩大，大家都会想法设法提高网站访问加载速度，否则就会降低转换率。所以速度已成为成功网站的必备要素之一。网站为什么会变慢？网站访问速度慢有很多因素，我们可以简单归纳以下几点：1. 共享主机服务器不堪重负，响应速度慢2. 网站的图片和内容太大，需要更多的时间下载3. 网站服务器位置与你网站访问者的地理位置存在差异……那么我们没有办法对该问题进行补救了吗？这时CDN的出现极大地解决了这项难题。什么是CDN？CDN全称Content Delivery Network，即内容分发网络。CDN是架构在网络之上的分发网络，依靠部署在世界各地的边缘服务器，通过中心平台的负载均衡、内容分发、调度等功能模块，使用户可以就近获取数据，从而降低网络堵塞，提高用户响应速度跟成功率。通俗一点讲CDN就是网站加速，可以解决跨运营商跟地区以及服务器负载过大造成用户访问速度慢的问题。对网站而言，CDN加速会有什么好处？网站不容易宕机当网站同时间涌入巨大流量时，使用了CDN之后，可以减少网站宕机的情况，同时你的网站可以接收更多的流量。用户访问网站的时间提高了，跳出率将会大大降低，这也有利于网站的各类转化。减少攻击影响网站受攻击是极有可能发生的事，尤其中大型网站更避免不了，常见的DDOS攻击可以通过海量流量大幅度占用服务器资源，造成网站无法打开。而 CDN 服务技术可以在节点与节点之间分布智能冗余机制，有效防止黑客入侵及流量攻击对网站的影响，提高网站服务质量。更有利于搜索引擎排名许多搜索引擎会把网站打开速度当一个重要指标，所以网站的打开速度会影响到搜索排名。使用CDN加速后，网站打开变快，还能增加用户友好体验。网站如何获取CDN网络加速？阿里云全集成，无需单独购买如果说您个人或您的企业有网站建设需求，不妨打开阿里云官网搜索【网站建设】，阿里云建站标配网络加速服务（海外版标配全球CDN加速），通过节点可以确保全国各地用户用最快路径访问到网站，保证网站快速打开。除此之外还标配云盾安全服务，最大化为网站抵御恶意攻击。使用CDN不必考虑服务器的投入与托管、不必考虑新增带宽的成本、不必考虑多台服务器的镜像同步……让您的网站能更加安全、快速获客，得到更多收益。网站架构师将协助您梳理功能需求，让您获得专业的建站解决方案建议，点击此处咨询在线客服，进一步了解商城网站搭建详情。?阿里云官网在售：搜索“阿里云官网”-云市场-网站建设-商城定制开发，或直接搜索“网站定制开发”，获取更多建站产品详情。
