streamalism.org

1. סקירה כללית

במדריך זה נציג שירות בצד הלקוח גילוי באמצעות “Spring Cloud Netflix יוריקה“.

גילוי שירות בצד הלקוח מאפשר לשירותים למצוא ולתקשר ביניהם ללא שם מארח ויציאה קשיחים. ה"נקודה הקבועה "היחידה בארכיטקטורה כזו מורכבת מ- רישום שירות שאליו כל שירות צריך להירשם.

חסרון הוא שכל הלקוחות חייבים ליישם היגיון מסוים כדי לקיים אינטראקציה עם נקודה קבועה זו. זה מניח נסיעה הלוך ושוב נוספת ברשת לפני הבקשה בפועל.

עם נטפליקס יוריקה כל לקוח יכול לפעול בו זמנית כשרת, כדי לשכפל את מעמדו לעמית מחובר. במילים אחרות, לקוח מאחזר רשימה של כל חבריהם המקושרים של רישום שירות ומגיש את כל הבקשות הנוספות לכל שירות אחר באמצעות אלגוריתם איזון עומסים.

כדי לקבל מידע על נוכחותו של לקוח, עליהם לשלוח אות דופק לרישום.

כדי להשיג את המטרה של כתיבה זו, נבצע שלוש שירותי מיקרו:

• א רישום שירות (שרת יוריקה),
• א מנוחה שירות שרושם את עצמו במרשם (לקוח יוריקה) ו
• יישום אינטרנט, אשר צורכת את מנוחה שירות כלקוח מודע לרישום (אביב ענן נטפליקס לקוח פיין).

2. שרת יוריקה

יישום א שרת יוריקה עבור רישום שירות קל כמו:

1. מוֹסִיף אביב-ענן-starter-netflix-eureka-server לתלות
2. אפשר את שרת Eureka ב @ SpringBootApplication על ידי הערת זה עם @EnableEurekaServer
3. להגדיר כמה מאפיינים

אבל נעשה זאת צעד אחר צעד.

ראשית ניצור פרויקט חדש של Maven ונכניס אליו את התלות. אתה צריך לשים לב שאנחנו מייבאים את אביב-ענן-התחל-הורה לכל הפרויקטים המתוארים במדריך זה:

 org.springframework.cloud spring-cloud-starter-netflix-eureka-server org.springframework.cloud spring-cloud-starter-parent Greenwich.RELEASE pom import 

הערה: אנו יכולים לבדוק את המהדורות האחרונות של Spring Cloud בתיעוד הפרויקטים של Spring.

לאחר מכן, אנו יוצרים את מחלקת היישומים הראשית:

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

לבסוף, אנו מגדירים את המאפיינים ב- יאמל פוּרמָט; אז an application.yml יהיה קובץ התצורה שלנו:

שרת: יציאה: 8761 eureka: client: registerWithEureka: fetch false Registry: false

כאן אנו מגדירים את יציאת היישום - 8761 הוא ברירת המחדל עבור יוריקה שרתים. אנו מספרים את המובנה לקוח יוריקה לא להירשם עם 'עצמו' מכיוון שהיישום שלנו צריך לשמש כשרת.

כעת נפנה את הדפדפן שלנו אל // localhost: 8761 לצפייה ב- יוריקה לוח המחוונים, שם נבדוק אחר כך את המקרים הרשומים.

כרגע אנו רואים אינדיקטורים בסיסיים כגון מדדי מצב ובריאות.

3. לקוח יוריקה

למשך @ SpringBootApplication כדי להיות מודעים לגילוי, עלינו לכלול כמה מהם לקוח דיסקברי אביב (לדוגמה אביב-ענן-סטרטר-נטפליקס-יוריקה-לקוח) לתוך שלנו מסלול כיתה.

ואז עלינו להוסיף הערה א @תְצוּרָה עם שניהם @EnableDiscoveryClient אוֹ @EnableEurekaClient - שים לב שהערה זו היא אופציונלית אם יש לנו את אביב-ענן-סטרטר-נטפליקס-יוריקה-לקוח תלות במסלול הכיתה.

האחרון מספר מגף אביב להשתמש באביב נטיקה יוריקה לגילוי שירות באופן מפורש. כדי למלא את אפליקציית הלקוח שלנו עם כמה חיי מדגם, נכלול גם את קפיץ-אתחול-רשת חבילה ב- pom.xml וליישם א מנוחה בקר.

אבל ראשית, נוסיף את התלות. שוב, אנחנו יכולים להשאיר את זה ל אביב-ענן-התחל-הורה תלות להבין את גרסאות החפץ עבורנו:

 org.springframework.cloud spring-cloud-starter-netflix-eureka-starter org.springframework.boot spring-boot-starter-web 

כאן ניישם את מחלקת היישומים הראשית:

@SpringBootApplication @ RestController המחלקה הציבורית EurekaClientApplication מיישמת את GreetingController {@Autowired @Lazy EurekaClient הפרטי eurekaClient; @Value ("$ {spring.application.name}") פרטי מחרוזת appName; ריק סטטי ציבורי ראשי (String [] args) {SpringApplication.run (EurekaClientApplication.class, args); } @ ברכת מחרוזת ציבורית ציבורי () {return String.format ("שלום מ- '% s'!", EurekaClient.getApplication (appName) .getName ()); }}

וה GreetingController מִמְשָׁק:

ממשק ציבורי GreetingController {@RequestMapping ("/ greeting") ברכת מחרוזת (); }

כאן, במקום הממשק, נוכל גם להכריז על המיפוי בתוך ה- יישום לקוח EurekaClient מעמד. הממשק יכול להיות שימושי אם אנו רוצים לחלוק אותו בין שרת ללקוח.

לאחר מכן, עלינו להגדיר application.yml עם מוגדר אביב שם היישום כדי לזהות באופן ייחודי את הלקוח שלנו ברשימת היישומים הרשומים.

אנחנו יכולים לתת מגף אביב בחר עבורנו יציאה אקראית כי מאוחר יותר אנו ניגשים לשירות זה עם שמו.

לבסוף, עלינו לספר ללקוח שלנו היכן עליו לאתר את הרישום:

spring: application: name: spring-cloud-eureka-client server: port: 0 eureka: client: serviceUrl: defaultZone: $ {EUREKA_URI: // localhost: 8761 / eureka} מופע: preferIpAddress: true

כשהחלטנו להקים את לקוח היוריקה שלנו בצורה כזו, היה לנו לזכור כי שירות מסוג זה אמור להיות ניתן להרחבה מאוחר יותר.

כעת נפעיל את הלקוח ונפנה אליו את הדפדפן // localhost: 8761 שוב, כדי לראות את מצב הרישום שלו בלוח המחוונים של יוריקה. באמצעות לוח המחוונים, אנו יכולים לבצע תצורה נוספת, למשל. לקשר את דף הבית של לקוח רשום עם לוח המחוונים למטרות ניהול. עם זאת אפשרויות התצורה אינן מתחום המאמר.

4. לקוח פיין

כדי לסיים את הפרויקט שלנו עם שלוש מיקרו-שירותים תלויים, נבצע כעת יישום מנוחה-צריכת יישום אינטרנט באמצעות לקוח האביב של Netflix Feign.

חשוב על לְהַעֲמִיד פָּנִים כמודע לגילוי אביבRestTemplate שימוש בממשקים לתקשורת עם נקודות קצה. ממשקים אלה יושמו אוטומטית בזמן הריצה ובמקום כתובות שירות, הוא משתמש שמות שירות.

לְלֹא לְהַעֲמִיד פָּנִים נצטרך לבצע חוט אוטומטי של מופע של EurekaClient אל הבקר שלנו שאיתו נוכל לקבל מידע על שירות שם השירות כמו יישום לְהִתְנַגֵד.

היינו משתמשים בזה יישום כדי לקבל רשימה של כל המקרים של שירות זה, בחר אחד מתאים והשתמש בו InstanceInfo כדי לקבל שם מארח ויציאה. בעזרת זה נוכל לעשות בקשה רגילה עם כל אחת מהן לקוח http.

לדוגמה:

@ EurekaClient פרטי eurowClient פרטי; חלל ציבורי doRequest () {Application application = eurekaClient.getApplication ("אביב-ענן-יוריקה-לקוח"); InstanceInfo instanceInfo = application.getInstances (). Get (0); שם מארח מחרוזת = instanceInfo.getHostName (); int port = instanceInfo.getPort (); // ...}

א RestTemplate יכול לשמש גם לגישה יוריקה שירותי לקוח לפי שם, אך נושא זה מעבר לכתיבה זו.

להקים את שלנו לקוח פיין בפרויקט, אנו נוסיף את ארבע התלות הבאות שלו pom.xml:

 org.springframework.cloud spring-cloud-starter-feign org.springframework.cloud spring-cloud-starter-netflix-eureka-client org.springframework.boot spring-boot-starter-web org.springframework.boot spring-boot-starter -תימלף 

ה לקוח פיין ממוקם ב אביב-ענן-התחל-פיין חֲבִילָה. כדי לאפשר זאת, עלינו להוסיף הערה א @תְצוּרָה עם @EnableFeignClients. כדי להשתמש בו, אנו פשוט מציינים ממשק עם @FeignClient ("שם שירות") ולחבר אותו אוטומטית לבקר.

שיטה טובה ליצור כאלה לְהַעֲמִיד פָּנִיםלקוחות זה ליצור ממשקים עם @ בקשת מיפוי שיטות ביאורים והכניסו אותם למודול נפרד. בדרך זו הם יכולים להיות משותפים בין השרת ללקוח. בצד השרת, אתה יכול ליישם אותם כ- @בקר, ומצד הלקוח, ניתן להרחיב אותם ולסמן אותם כ- @FeignClient.

יתר על כן, ה חבילת אביב-ענן-סטרטר-יוריקה צריך להיכלל בפרויקט ולהפעיל אותו על ידי הערת מחלקת היישומים הראשית עם @EnableEurekaClient.

ה קפיץ-אתחול-רשת ו אביב-אתחול-התחלה-טימילית תלות משמשות להצגת תצוגה המכילה נתונים שנאספו מאתנו מנוחה שֵׁרוּת.

זה יהיה שלנו לקוח פיין מִמְשָׁק:

ממשק ציבורי @FeignClient ("לקוח אביב-ענן-יוריקה") GreetingClient {@RequestMapping ("/ greeting") ברכת מחרוזת (); }

כאן ניישם את מחלקת היישומים הראשית המשמשת בו זמנית כבקר:

@SpringBootApplication @EnableFeignClients @Controller class public FeignClientApplication {@Autowired Private GreetingClient greetingClient; ריק סטטי ציבורי ראשי (String [] args) {SpringApplication.run (FeignClientApplication.class, args); } @ RequestMapping ("/ get-greeting") ברכת מחרוזת ציבורית (Model model) {model.addAttribute ("greeting", greetingClient.greeting ()); להחזיר "נוף ברכה"; }} 

זו תהיה תבנית ה- HTML לתצוגה שלנו:

   עמוד ברכה 

לפחות ה application.yml קובץ התצורה כמעט זהה לשלב הקודם:

spring: application: name: spring-cloud-eureka-feign-client server: port: 8080 eureka: client: serviceUrl: defaultZone: $ {EUREKA_URI: // localhost: 8761 / eureka}

כעת אנו יכולים לבנות ולהפעיל שירות זה. לבסוף, נפנה את הדפדפן שלנו אל // localhost: 8080 / קבל ברכה והוא אמור להציג משהו כמו הבא:

שלום מ- Spring-CLOUD-EUREKA-CLIENT!

5. ‘TransportException: לא ניתן לבצע בקשה בשום שרת ידוע '

בעת הפעלת שרת Eureka לעיתים קרובות אנו נתקלים בחריגים כמו:

com.netflix.discovery.shared.transport.TransportException: לא ניתן לבצע בקשה בשום שרת ידוע

בעיקרון, זה קורה בגלל התצורה הלא נכונה ב- application.properties אוֹ application.yml. יוריקה מספק ללקוח שני מאפיינים הניתנים להגדרה.

• registerWithEureka: אם נהפוך נכס זה כ- נָכוֹן ואז בזמן שהשרת מתחיל הלקוח המובנה ינסה לרשום את עצמו בשרת Eureka.
• fetchRegistry: הלקוח המובנה ינסה להביא את יוריקה אם אנו מגדירים נכס זה כנכון.

עַכשָׁיו כאשר אנו מפעילים את שרת Eureka, איננו רוצים לרשום את הלקוח המובנה כדי להגדיר את עצמו עם השרת.

אם נסמן את המאפיינים שלעיל כ- נָכוֹן (או לא להגדיר אותם כפי שהם נָכוֹן כברירת מחדל) בעת הפעלת השרת, הלקוח המובנה מנסה לרשום את עצמו ב- יוריקה שרת וגם מנסה להביא רישום שעדיין אינו זמין. כתוצאה מכך, אנו מקבלים TransportException.

לכן לעולם אל לנו להגדיר את המאפיינים האלה כ- נָכוֹן בתוך ה יוריקה יישומי שרת. ההגדרות הנכונות שיש להכניס application.yml מובאות להלן:

eureka: client: register WithEureka: fetch false רישום: false

6. מסקנה

כפי שראינו, כעת אנו יכולים ליישם רישום שירות באמצעות שרת יוריקה של נטפליקס באביב ולרשום כמה לקוחות יוריקה עם זה.

כי שלנו לקוח יוריקה משלב 3 מאזין ביציאה שנבחרה באופן אקראי, הוא אינו יודע את מיקומו ללא המידע מהרישום. עם לקוח פיין ואת הרישום שלנו, אנו יכולים לאתר ולצרוך את מנוחה שירות, גם כאשר המיקום משתנה.

לבסוף, יש לנו תמונה גדולה של שימוש בגילוי שירות בארכיטקטורת מיקרו-שירותים.

כרגיל, תוכלו למצוא את המקורות ב- GitHub, שכולל גם סט של דוקרקבצים הקשורים לשימוש עם docker-compose ליצור מכולות מהפרויקט שלנו.