डॉकर कम्पोज़ + कंसल + स्प्रिंग बूट + फ़िग्नक्लांट

यह आलेख डॉकटर कम्पोज़, कॉन्सल, मेक फॉर द स्प्रिंग बूट एप्लिकेशन (और न केवल), उदाहरण के लिए, पोस्टग्रेक्यूएल और ब्राउज़रलेस का उपयोग करके स्थानीय विकास पर्यावरण को कैसे बढ़ाएं, इसका एक उदाहरण दिखाता है।

योजना:

1. डॉकर कम्पोज़ में सेवाएँ कॉन्फ़िगर करना
2. कांसुली में सेवाओं का पंजीकरण और वाणिज्य दूतावास में चर जोड़ना
3. Makefile बनाएँ
4. PostgreSQL कॉन्फ़िगरेशन
5. FeignClient का उपयोग करना
6. निष्कर्ष

एप्लिकेशन बिल्कुल बेकार है: किसी पेज के लिंक के बाद, यह इस पेज से सबसे बड़ी छवि का लिंक देता है। छवि ब्राउज़र रहित द्वारा पुनर्प्राप्त की जाएगी, और PostgreSQL में यह मामला सहेजा जाएगा।

परियोजना से लिंक: https://bitbucket.org/maximka777/consul-docker-spring-cloud/src/master/ ।

1. डॉकर कम्पोज़ में सेवाओं की स्थापना

पहली बात यह है कि docker-compose.yml कॉन्फ़िगरेशन फ़ाइल docker-compose.yml कंटेनरों के लिए बनाना है:

 touch docker-compose.yml 

इस फ़ाइल में डॉक-कंपोज़ का संस्करण है:

 version: '3.4' 

नेटवर्क कॉन्फ़िगरेशन:

 networks: lan: 

और आवश्यक सेवाओं का विन्यास, इस मामले में कॉन्सल, ब्राउजरलेस और पोस्टग्रेक्यूएल:

 services: consul: image: consul:1.1.0 hostname: localhost networks: - lan ports: - 8500:8500 postgres: image: postgres:11.0 hostname: localhost networks: - lan ports: - 5432:5432 environment: POSTGRES_PASSWORD: password POSTGRES_DB: example_app browserless: image: browserless/chrome hostname: localhost networks: - lan ports: - 3000:3000 

POSTGRES_PASSWORD - डिफ़ॉल्ट रूप से उपयोगकर्ता डेटाबेस का पासवर्ड, POSTGRES_DB - स्वचालित रूप से कंटेनर में डेटाबेस बनाया जाता है।

कमांड चलाने के लिए आपको जिन सेवाओं की आवश्यकता है, उन्हें शुरू करने के लिए:

 docker-compose up 

हम कंटेनर छवियों को लोड करने और कंटेनर लॉन्च करने की प्रतीक्षा कर रहे हैं। कंटेनर को चलाने से रोकने के लिए, docker-compose down उपयोग करें। सभी कंटेनरों को शुरू करने के बाद, आप localhost:8500 ब्राउज़र में पते पर जा सकते हैं localhost:8500 - कॉन्सल वेब क्लाइंट को खोलना चाहिए (छवि 1)।

चित्र 1

2. कंसुल में सेवाओं का पंजीकरण और वाणिज्य दूतावास के भंडारण के लिए चर जोड़ना

आप localhost:8500/v1/agent/service/register पते पर कई पोस्ट-अनुरोध भेजकर कौंसुल में सेवाएं पंजीकृत कर सकते हैं localhost:8500/v1/agent/service/register , उदाहरण के लिए, कर्ल का उपयोग करके।

सभी कर्ल कॉल को बैश स्क्रिप्ट में रखें।

 #!/bin/bash curl -s -XPUT -d"{ \"Name\": \"postgres\", \"ID\": \"postgres\", \"Tags\": [ \"postgres\" ], \"Address\": \"localhost\", \"Port\": 5432, \"Check\": { \"Name\": \"PostgreSQL TCP on port 5432\", \"ID\": \"postgres\", \"Interval\": \"10s\", \"TCP\": \"postgres:5432\", \"Timeout\": \"1s\", \"Status\": \"passing\" } }" localhost:8500/v1/agent/service/register curl -s -XPUT -d"{ \"Name\": \"browserless\", \"ID\": \"browserless\", \"Tags\": [ \"browserless\" ], \"Address\": \"localhost\", \"Port\": 3000, \"Check\": { \"Name\": \"Browserless TCP on port 3000\", \"ID\": \"browserless\", \"Interval\": \"10s\", \"TCP\": \"browserless:3000\", \"Timeout\": \"1s\", \"Status\": \"passing\" } }" localhost:8500/v1/agent/service/register curl -s -XPUT -d"{ \"Name\": \"example.app\", \"ID\": \"example.app\", \"Tags\": [ \"example.app\" ], \"Address\": \"localhost\", \"Port\": 8080, \"Check\": { \"Name\": \"example.app HTTP on port 8080\", \"ID\": \"example.app\", \"Interval\": \"10s\", \"HTTP\": \"example.app:8080/actuator/health\", \"Timeout\": \"1s\", \"Status\": \"passing\" } }" localhost:8500/v1/agent/service/register 

chmod +x register-services.sh - फ़ाइल को चलाने योग्य बनाने के लिए।

स्क्रिप्ट निष्पादित होने के बाद, हमारा PostgreSQSL और Browserless, Conusele .e (छवि 2) में पंजीकृत सेवाओं की सूची में दिखाई देगा।

चित्र 2

आंकड़ा दिखाता है कि PostgreSQL चेक एक त्रुटि के साथ विफल हो जाता है - (यह सार को प्रभावित नहीं करेगा) ।

कॉन्सल की कुंजी / मूल्य भंडारण के लिए कॉन्फ़िगरेशन जोड़ें। वेरिएबल test.property बनाएँ।

 curl --request PUT --data TEST \ localhost:8500/v1/kv/example.app/test.property 

यदि कई चर हैं, तो बैश स्क्रिप्ट का उपयोग करना बेहतर है।

3. मेकफिल बनाना

इस सब के प्रक्षेपण को आसान बनाने के लिए, Makefile` लिखें:

 docker_up: @docker-compose up -d consul_up: @./register-services.sh && \ ./register-variables.sh compile: @cd example.app && mvn package run: @cd example.app && java -jar target/example.app-1.0-SNAPSHOT.jar up: docker_up consul_up compile run down: @docker-compose down 

चेतावनी: Makefile एक विशेष प्रकार के इंडेंटेशन का उपयोग करता है!

make up कमांड से पूरा वातावरण शुरू होगा।

4. PostgreSQL कॉन्फ़िगरेशन

अगला, स्प्रिंग बूट एप्लिकेशन इनिशियलाइज़र https://start.spring.io/ का उपयोग करके एक मूल स्प्रिंग बूट प्रोजेक्ट (मावेन) उत्पन्न किया गया।

निम्नलिखित निर्भरता pom.xml में जोड़ी गई है:

  <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-consul-config</artifactId> <version>2.0.1.RELEASE</version> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-consul-discovery</artifactId> <version>2.0.1.RELEASE</version> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> <version>2.0.2.RELEASE</version> </dependency> <dependency> <groupId>org.postgresql</groupId> <artifactId>postgresql</artifactId> <scope>runtime</scope> </dependency> 

संकुल के नामों से यह स्पष्ट है कि उनकी आवश्यकता क्यों है।
चलिए DataSource के लिए कॉन्फ़िगरेशन लिखते हैं। bootstrap.properties फ़ाइल में, कॉन्फिग ड्रॉप करें:

 spring.cloud.consul.host=localhost spring.cloud.consul.port=8500 spring.cloud.consul.config.enabled=true spring.cloud.consul.config.prefix= spring.cloud.consul.config.defaultContext=example.app spring.cloud.consul.discovery.register=false spring.cloud.service-registry.auto-registration.enabled=false spring.jpa.properties.hibernate.temp.use_jdbc_metadata_defaults = false spring.jpa.database-platform=org.hibernate.dialect.PostgreSQL9Dialect spring.jpa.show-sql=false spring.jpa.hibernate.ddl-auto=create 

application.yml :

 example.app: db: name: 'example_app' feign: client: config: default: connectTimeout: 20000 readTimeout: 20000 loggerLevel: basic management: endpoint: health: show-details: always endpoints: web.exposure: include: '*' 

और विन्यास वर्ग ही:

 @Configuration public class PersistenceConfiguration { @Value("${example.app.db.name}") private String databaseName; @Autowired private DiscoveryClient discoveryClient; @Bean @Primary public DataSource dataSource() { var postgresInstance = getPostgresInstance(); return DataSourceBuilder .create() .username("postgres") .password("password") .url(format("jdbc:postgresql://%s:%s/%s", postgresInstance.getHost(), postgresInstance.getPort(), databaseName)) .driverClassName("org.postgresql.Driver") .build(); } private ServiceInstance getPostgresInstance() { return discoveryClient.getInstances("postgres") .stream() .findFirst() .orElseThrow(() -> new IllegalStateException("Unable to discover a Postgres instance")); } } 

getPostgresInstance() विधि Consul में पंजीकृत postgres टैग के साथ पहला सेवा उदाहरण लेती है। dataSource() विधि DataSource की सेम है।

अगला, हम Image इकाई पर मूल संचालन के साथ एक रिपॉजिटरी की घोषणा करते हैं, जो पेज एड्रेस और इमेज एड्रेस को स्टोर करता है:

 @Repository public interface ImageRepository extends JpaRepository<Image, Long> { } 

5. FeignClient का उपयोग करना

अगला, हम संसाधनों में एक जेएस स्क्रिप्ट छोड़ देंगे, जो पेज से सबसे बड़ी छवि को खींच लेगा।

 module.exports = async ({page, context}) => { const {url} = context; await page.goto(url); await page.evaluate(_ => { window.scrollBy(0, window.innerHeight); }); const data = await page._client.send('Page.getResourceTree') .then(tree => { return Array.from(tree.frameTree.resources) .filter(resource => resource.type === 'Image' && resource.url && resource.url.indexOf('.svg') == -1) .sort((a, b) => b.contentSize - a.contentSize)[0]; }); return { data, type: 'json' }; }; 

BlserlessClient इंटरफ़ेस को परिभाषित करें:

 @FeignClient("browserless") //   browserless      public interface BrowserlessClient { @PostMapping("/function") ImageInfo findLargestImage(LargestImageRequest request); //       Browserless'     class ImageInfo { private String url; public String getUrl() { return url; } } //  ,    Browserless  ,    class LargestImageRequest { private String code; private BrowserlessContext context; public LargestImageRequest(String code, BrowserlessContext context) { this.code = code; this.context = context; } public String getCode() { return code; } public BrowserlessContext getContext() { return context; } } //        class BrowserlessContext { private String url; public BrowserlessContext(String url) { this.url = url; } public String getUrl() { return url; } } } 

सेवा विधि एक छवि का अनुरोध और डेटाबेस में भंडारण:

 public Image findLargestImage(String url) { var browserlessContext = new BrowserlessContext(url); var largestImageRequest = new LargestImageRequest(getLargestImageScript, browserlessContext); var imageInfo = browserlessClient.findLargestImage(largestImageRequest); var image = new Image(); image.setSourceUrl(url); image.setImageUrl(imageInfo.getUrl()); return imageRepository.save(image); } 

कार्यक्षमता नियंत्रक:

 public class MainController { private static Logger log = LoggerFactory.getLogger(MainController.class); @Autowired private ImageService imageService; @Value("${test.property}") private String testProperty; @GetMapping("/largest-image") public ResponseEntity<Image> getTitle(@RequestParam("url") String url) { return ResponseEntity.ok(imageService.findLargestImage(url)); } @GetMapping("/property") public ResponseEntity<String> getProperty() { return ResponseEntity.ok(testProperty); } } 

यहाँ testProperty फ़ील्ड testProperty की की / वैल्यू स्टोर से खींचा गया है।

6. अंत

वह सब है!

मुझे उम्मीद है कि मैं प्रस्तुत टूल का एक संभावित कॉन्फ़िगरेशन दिखाने में सक्षम था और यह लेख किसी के लिए उपयोगी होगा।

इस लेख में कई स्पष्टीकरण नहीं हैं, क्योंकि मेरा मानना ​​है कि इस मामले में कोड को समझना आसान है।

उपयोगी लिंक:
1) https://docs.docker.com/compose/overview/ - डॉकटर रचना प्रलेखन
2) https://www.consul.io/intro/index.html - कंसुल का परिचय
3) http://matt.might.net/articles/intro-to-make/ - बनाने के लिए परिचय
4) https://cloud.spring.io/spring-cloud-netflix/multi/multi_spring-cloud-feign.html - Feign पर प्रलेखन