Introduction détaillée au ruban de Springcloud

1: Qu'est-ce que le ruban?

Ribbon est un projet open source publié par Netflix. Sa fonction principale est de fournir des algorithmes d'équilibrage de la charge du logiciel côté client pour connecter ensemble les services de niveau intermédiaire de Netflix. Le composant client du ruban fournit une série d'éléments de configuration complets tels que le délai de connexion, la réessayer, etc. Le ruban vous aidera automatiquement à connecter ces machines en fonction de certaines règles (telles que des sondages simples, une connexion instantanée, etc.). Nous avons également un moyen très simple d'implémenter des algorithmes d'équilibrage de charge personnalisés à l'aide du ruban.

Deux: Classification du schéma LB

Actuellement, le schéma LB traditionnel peut être divisé en deux catégories: l'une est la LB centralisée, c'est-à-dire utiliser des installations LB indépendantes (peut être du matériel, comme F5, ou des logiciels, tels que Nginx) entre le consommateur de services et le fournisseur, et l'installation est responsable de la transmission des demandes d'accès au fournisseur de services par le biais d'une certaine politique; L'autre est LB en cours, qui intègre la logique LB dans le consommateur, et le consommateur sait dans le centre d'enregistrement des services que les adresses sont disponibles, puis sélectionne un serveur approprié dans ces adresses elles-mêmes. Le ruban appartient à ce dernier. Il s'agit d'une bibliothèque de classe intégrée au processus de consommation. Grâce à cela, les consommateurs obtiennent l'adresse du fournisseur de services.

Trois: les principaux composants et le flux de travail du ruban

Les composants principaux du ruban (qui sont tous des types d'interface) ont ce qui suit:

Serveur

Utilisé pour obtenir la liste d'adresses. Il peut être statique (fournissant un ensemble fixe d'adresses) ou dynamique (requête récurrente pour les listes d'adresses du registre).

ServerlistFilter

Utilisé uniquement lors de l'utilisation de Dynamic ServerList, il est utilisé pour utiliser certaines stratégies de la liste des services d'origine pour considérer certaines adresses.

Irole

Sélectionnez une adresse de service finale comme résultat LB. Les politiques sélectionnées incluent le sondage, la pondération basée sur le temps de réponse, le disjoncteur (lorsque l'hystrix est disponible), etc.

Lorsque le ruban fonctionne, il est préféré d'utiliser ServerList pour obtenir toutes les listes de services disponibles, puis utiliser ServerListFilter pour considérer certaines des adresses, et enfin sélectionner un serveur dans les adresses restantes via Irule comme résultat final.

Quatre: Introduction aux principales stratégies d'équilibrage de la charge fournies par ruban

1: Équilibrage de la charge de sondage simple (Roundrobin)

Les demandes sont planifiées à leur tour d'une manière interrogée, c'est-à-dire que chaque calendrier est exécuté i = (i + 1) mod n, et le i-tème serveur est sélectionné.

2: Équilibrage de charge aléatoire (aléatoire)

Sélectionnez au hasard le serveur avec un statut UP

3: Équilibrage de la charge pondéré (pondéré)

Un poids est alloué en fonction du temps correspondant. Plus le temps correspondant est long, plus le poids est petit et plus la possibilité d'être sélectionnée.

4: Zoneavoidancerulle

Déterminez complètement les performances de la zone du serveur et du serveur de sélection de disponibilité du serveur

Comparaison des propres stratégies d'équilibrage de la charge du ruban

5: ruban seul

Créer un nom de projet maven ruban_client

contenu de pom

 <Dependances> <Dedency> <ProupId> com.netflix.ribbon </rom grouped> <ArtifActid> Ribbon-core </lefactive> <version> 2.2.0 </ version> </ Dependency> <Dependency> <ProupID> com.netflix.ribbon </proupId> <Artifactid> Ribbon </Dedited> </Depend> </Depend> </Depend> </DENDENDENCES>

Fichier de configuration de Client.Properties

 # MAX NOMBRE DE RETRES Sample-Client.Ribbon.MaxAutoreTries = 1 # Nombre maximum de serveurs suivants pour réessayer (à l'exclusion du premier serveur) Sample-Client.ribbon.MaxAutoretriesNextServer = 1 # Si toutes les opérations peuvent être réactivées pour cette clientèle Client Client.Ribbon.OktoretryOnalleperations = True # Interval Exemple-Client.Ribbon.ServerListreFreshInterval = 2000 # Connect Timeout utilisé par Apache httpclient Sample-Client.Ribbon.ConnectTimeout = 3000 # Read Timeout utilisé par Apache HttpClient Sample-Client.ribbon.Readtimeout = 3000 # Liste initiale des serveurs, peut être modifié via la propriété dynamique Archaius à Runtimeout = Runtime sample-client.ribbon.listofservers = www.sohu.com: 80, www.163.com: 80, www.sina.com.cn: 80sample-clilient.ribbon.enableprimeconnections = true =

Code de rubanmain

 Importer java.net.uri; import com.netflix.client.clientfactory; import com.netflix.client.http.httprequest; import com.netflix.client.http.httpresponse; import com.netflix.cononawarewarewaralder; com.netflix.niws.client.http.RestClient; public class Rubbonmain {public static void main (String [] args) lève exception {configurationManager.LoadPropertiesFromeResources ("sampe-Client.Properties"); System.out.println (configurationManager.getConfiginstance (). GetProperty ("Sample-Client.Ribbon.ListOfServers")); RESTClient client = (RESTClient) clientFactory.getNamedClient ("Sample-Client"); HttpRequest request = httprequest.newbuilder (). Uri (new uri ("/")). Build (); for (int i = 0; i <4; i ++) {httpResponse réponse = client.executewithloadBalancer (request); System.out.println ("Statut pour URI:" + Response.getRequetedUri () + "est:" + réponse.getStatus ()); } ZoneAwareLoadBalancer LB = (ZoneAwareLoadBalancer) client.getloadBalancer (); System.out.println (lb.getloadBalanceStAt ()); ConfigurationManager.getConfiginstance (). SetProperty ("Sample-Client.Ribbon.ListOfServers", "ccblog.cn:80 ,www.linkedin.com:80"); System.out.println ("Changer les serveurs ..."); Thread.Sleep (3000); for (int i = 0; i <3; i ++) {httpResponse réponse = client.executewithloadBalancer (request); System.out.println ("Statut pour URI:" + Response.getRequetedUri () + "est:" + réponse.getStatus ()); } System.out.println (lb.getloadBalanceStats ()); }}

Analyse de code

Utilisez Archaius ConfigurationManager pour charger les propriétés;

Utilisez ClientFactory pour créer des clients et charger des équilibreurs;

Utilisez Builder pour créer des demandes HTTP. Notez que nous ne soutenons que le chemin de la partie "/" de l'URI. Une fois le serveur sélectionné par l'équilibreur de charge, le client calculera l'URI complet;

Appeler API client.ExECuteWithLoadBalancer () n'est pas l'API EXEUCTE ();

Corrigez dynamiquement le pool de serveurs dans la configuration;

Attendez que la liste des serveurs actualisera (l'intervalle de réactualisation défini dans le fichier de configuration est de 3 secondes);

Imprimez les statistiques du serveur enregistrées par l'équilibreur de charge.

Six: ruban combiné avec eureka

Tout d'abord, démarrez le projet Eureka_Register_Service (Centre d'enregistrement) et le projet Biz-Service-0 (producteur de services)

Créer un projet Maven Eureka_Ribbon_Client Ce projet démarre et les configurations connexes dépendent de eureka_register_service et biz-service-0

pom rejoindre

 <parent> <proupId> org.springframework.boot </proupId> <Artifactid> printemps-boot-starter-Parent </ artifactid> <version> 1.4.3.release </-version> <loutpath /> <! - Lookup Parent from Repository -> </preater> <fedences> <fedency> <proupId> Org.spring <ArtefactId> Spring-Cloud-Starter-Ribbon </ Artifactid> </Dependency> <Dependance> <ProupId> org.SpringFramework.cloud </proupId> <ArtifActid> Spring-Cloud-Starter-Eureka </ Artifactid> </ Dependency> <Dependency> <ProupId> Org.SpringFrameworkwork. <ArtefactId> Spring-boot-starter-web </ artifactid> </dependency> <dependency> <proupId> org.springframework.boot </prôdId> <Artifactid> printemps-boot-starter-test </ artifactid> <ccope> test </cope> </d-starcy> </Dedencescy> <petendencymanagement> <predences> <fedency> </Dedency> <GroupId> org.springframework.cloud </proupId> <Artifactid> Spring-Cloud-Dependces </etefactId> <DERSE> BRIXTON.ReLEASE </ Version> <Type> POM </pype> <cope> Import </cope> </Dependency> </Dependance> </DependanceManagement>

Dans la classe principale de l'application, ajoutez des capacités de service de découverte via l'annotation @enablediscoveryclient. Créez une instance RestTemplate et activez l'équilibrage de la capacité de chargement via l'annotation @loadBalanced.

 @ SpringbootApplication @ ENablediscoveryClientPublic class rubbonApplication {@Bean @loadBalanced restTemplate restTEmplate () {return new RestTemplate (); } public static void main (String [] args) {SpringApplication.run (rubbonApplication.class, args); }}

Créez un ConsumerController pour consommer le service GetUser de Biz-Service-0. Appeler le service par Restemplate directement

 @RestControllerPublic Class ConsumerController {@Autowired RestTemplate RestTemplate; @RequestMapping (value = "/ getUserIrinfo", méthode = requestMethod.get) public String Add () {return restTemplate.getForentity ("http: // biz-Service-0 / Getuser", String.class) .getBody (); }}

Configurer le centre d'enregistrement des services Eureka dans Application.Properties

 Spring.Application.name = Ribbon-Consumerserver.port = 8003Eureka.Client.ServiceUrl.defaultZone = http: // localhost: 8000 / eureka /

Une fois terminé, vous pouvez ouvrir http: // localhost: 8003 / getUserRinfo pour voir les résultats

Résumé: Le ruban est en fait un composant client d'équilibrage de charge en douceur. Il peut être utilisé en combinaison avec d'autres demandes requises. Le combiner avec Eureka n'en est qu'un exemple.

Adresse du code: https://github.com/zhp8341/springclouddemo

Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.