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
| Nom de stratégie | Déclaration de politique | Description de la politique | Instructions de mise en œuvre |
| BestAvailableRule | Classe publique BestAvailableLerule étend ClientConfiGenabledRoundRobinrule | Sélectionnez un serveur avec la plus petite demande simultanée | Vérifiez le serveur un par un. Si le serveur est déclenché, ignorez-le. Sélectionnez le serveur avec le plus petit activité |
| Disponibilité | Disponibilité de classe publique, le Filteringrule étend PredicateBasedrule | Filtrez ces serveurs backend marqués comme un circuit déclenché en raison de la défaillance de la connexion et filtrez ces serveurs backend avec une concurrence élevée (les connexions actives dépassent le seuil configuré) | Utilisation d'une disponibilité PRÉCITE pour inclure la logique des serveurs de filtrage, c'est en fait vérifier l'état exécuté de chaque serveur enregistré en statut |
| Pondération | Classe publique Pondérés Responserimerule étend Roundrobinrule | 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. | Un thread d'arrière-plan lit régulièrement le temps de réponse d'évaluation à partir de l'état et calcule un poids pour chaque serveur. Le calcul du poids est également relativement simple. ResponseTime moins Le temps de réponse moyen de chaque serveur est le poids du serveur. Lorsque le statut vient de démarrer et qu'aucune statistique n'est formée, utilisez la stratégie Roubine pour sélectionner le serveur. |
| Retryrule | La classe publique Retryrule étend AbstractloadBalanCerrule | Réessayez le mécanisme de la machine pour la politique d'équilibrage de charge sélectionnée. | Pendant une période de configuration, lorsque la sélection du serveur échoue, vous continuez à essayer de sélectionner un serveur disponible à l'aide de sous-héros |
| Roundrobinrule | classe publique Roundrobinrule étend AbstractloadBalanCerrule | Roundrobin Méthode d'interrogation pour sélectionner le serveur | Index du sondage et sélectionnez le serveur correspondant à l'index |
| Aléatoire | La classe publique Randomrule étend AbstractloadBalanCerrule | Sélectionnez au hasard un serveur | Au hasard sur l'index, sélectionnez le serveur correspondant à la position d'index |
| Zoneavoidancerule | La classe publique Zoneavoidancerrule étend PredicateBasedrule | Déterminez complètement les performances de la zone du serveur et du serveur de sélection de disponibilité du serveur | Utilisez ZoneAavoidancePredicate et la disponibilité PRÉCITE pour déterminer si un serveur est sélectionné. Le précédent détermine si les performances opérationnelles d'une zone sont disponibles. Exclure les zones indisponibles (tous les serveurs). Disponibilité PRÉSICATE est utilisée pour filtrer les serveurs avec trop de connexions. |
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.