ನಾವು ಚಿಲ್ಲರೆ ನೆಟ್ವರ್ಕ್ನ ತಂತ್ರಜ್ಞಾನ ಅಭಿವೃದ್ಧಿ ವಿಭಾಗವಾಗಿದ್ದೇವೆ. ಒಂದು ದಿನ, ಮ್ಯಾನೇಜ್ಮೆಂಟ್ MSSQL ಜೊತೆಗೆ ಅಪಾಚೆ ಇಗ್ನೈಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ದೊಡ್ಡ ಪ್ರಮಾಣದ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ವೇಗಗೊಳಿಸುವ ಕಾರ್ಯವನ್ನು ನಿಗದಿಪಡಿಸಿತು ಮತ್ತು ಜಾವಾ ಕೋಡ್ನ ಸುಂದರವಾದ ಚಿತ್ರಣಗಳು ಮತ್ತು ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ವೆಬ್ಸೈಟ್ ಅನ್ನು ತೋರಿಸಿತು. ನಾನು ತಕ್ಷಣ ಸೈಟ್ ಅನ್ನು ಇಷ್ಟಪಟ್ಟೆ
1. ಸಮಸ್ಯೆಯ ಹೇಳಿಕೆ
ಸಮಸ್ಯೆಯ ಸಾರವು ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ. ಸೇಲ್ಸ್ಪಾಯಿಂಟ್ ಸೇಲ್ಸ್ ಪಾಯಿಂಟ್ ಡೈರೆಕ್ಟರಿ ಮತ್ತು ಸ್ಕು (ಸ್ಟಾಕ್ ಕೀಪಿಂಗ್ ಯುನಿಟ್) ಉತ್ಪನ್ನ ಡೈರೆಕ್ಟರಿ ಇದೆ. ಮಾರಾಟದ ಬಿಂದುವು "ಚಿಕ್ಕ" ಮತ್ತು "ದೊಡ್ಡ" ಮೌಲ್ಯಗಳೊಂದಿಗೆ "ಸ್ಟೋರ್ ಪ್ರಕಾರ" ಗುಣಲಕ್ಷಣವನ್ನು ಹೊಂದಿದೆ. ವಿಂಗಡಣೆ (ಬಿಂದುವಿನ ಉತ್ಪನ್ನಗಳ ಪಟ್ಟಿ) ಮಾರಾಟದ ಪ್ರತಿ ಬಿಂದುವಿಗೆ (DBMS ನಿಂದ ಲೋಡ್ ಮಾಡಲಾಗಿದೆ) ಸಂಪರ್ಕ ಹೊಂದಿದೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ದಿನಾಂಕದಿಂದ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಉತ್ಪನ್ನವನ್ನು ಒದಗಿಸಲಾಗಿದೆ
ವಿಂಗಡಣೆಯಿಂದ ಹೊರಗಿಡಲಾಗಿದೆ ಅಥವಾ ವಿಂಗಡಣೆಗೆ ಸೇರಿಸಲಾಗಿದೆ.
ಮಾರಾಟದ ಬಿಂದುಗಳ ವಿಭಜಿತ ಸಂಗ್ರಹವನ್ನು ಸಂಘಟಿಸಲು ಮತ್ತು ಸಂಪರ್ಕಿತ ಉತ್ಪನ್ನಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒಂದು ತಿಂಗಳು ಮುಂಚಿತವಾಗಿ ಸಂಗ್ರಹಿಸಲು ಇದು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ. ಯುದ್ಧ ವ್ಯವಸ್ಥೆಯೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಯು ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲು ಇಗ್ನೈಟ್ ಕ್ಲೈಂಟ್ ನೋಡ್ ಅಗತ್ಯವಿದೆ, ಫಾರ್ಮ್ನ ಒಟ್ಟು ಮೊತ್ತವನ್ನು (ಸ್ಟೋರ್ ಪ್ರಕಾರ, ಉತ್ಪನ್ನ ಕೋಡ್, ದಿನ, number_of_sales_points) ಲೆಕ್ಕಾಚಾರ ಮಾಡಿ ಮತ್ತು ಅದನ್ನು DBMS ಗೆ ಮತ್ತೆ ಅಪ್ಲೋಡ್ ಮಾಡಿ.
2. ಸಾಹಿತ್ಯದ ಅಧ್ಯಯನ
ನನಗೆ ಇನ್ನೂ ಯಾವುದೇ ಅನುಭವವಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾನು ಒಲೆಯಿಂದ ನೃತ್ಯ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುತ್ತಿದ್ದೇನೆ. ಅಂದರೆ, ಪ್ರಕಟಣೆಗಳ ವಿಮರ್ಶೆಯಿಂದ.
ಲೇಖನ 2016
ಆಶಾವಾದಿಯಾಗಿ ಭರವಸೆ ನೀಡುತ್ತದೆ "ನೀವು ಕ್ಷಣಾರ್ಧದಲ್ಲಿ ಎದ್ದೇಳುತ್ತೀರಿ ಮತ್ತು ಓಡುತ್ತೀರಿ!" ನಾನು ಪರಿಸರ ವೇರಿಯಬಲ್ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಕಂಡುಹಿಡಿಯುತ್ತಿದ್ದೇನೆ, ಎರಡು ಅಪಾಚೆ ಇಗ್ನೈಟ್ ಎಸೆನ್ಷಿಯಲ್ಸ್ ವೀಡಿಯೊಗಳನ್ನು ವೀಕ್ಷಿಸುತ್ತಿದ್ದೇನೆ, ಆದರೆ ಅವು ನನ್ನ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಕ್ಕೆ ಹೆಚ್ಚು ಉಪಯುಕ್ತವಾಗಿರಲಿಲ್ಲ. ಮೊದಲ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸುವ ಪ್ರಮಾಣಿತ ಫೈಲ್ "example-ignite.xml" ನೊಂದಿಗೆ ನಾನು ಕಮಾಂಡ್ ಲೈನ್ನಿಂದ ಇಗ್ನೈಟ್ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಪ್ರಾರಂಭಿಸುತ್ತೇನೆ
ನಾನು ಮತ್ತಷ್ಟು ಓದುತ್ತೇನೆ ಮತ್ತು ಅಲ್ಲಿ ಉದಾಹರಣೆಯು ತಕ್ಷಣವೇ ಅಫಿನಿಟಿಕೀ ಅನ್ನು ಬಳಸುತ್ತದೆ (ಮೊದಲು SQL ಪ್ರಶ್ನೆಯ ಮೂಲಕ ರಚಿಸಲಾಗಿದೆ), ಮತ್ತು ನಿಗೂಢ ಬೈನರಿ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಸಹ ಬಳಸುತ್ತದೆ:
IgniteCache<BinaryObject, BinaryObject> people
= ignite.cache("Person").withKeepBinary();
ನಾನು ಅದನ್ನು ಓದಿದೆ
ನನ್ನ ಪ್ರಕರಣಕ್ಕೆ ಸರಿಹೊಂದುವಂತೆ ನಾನು ಕಂಪ್ಯೂಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರೀಮೇಕ್ ಮಾಡುತ್ತಿದ್ದೇನೆ. MSSQL ನಲ್ಲಿ ಮಾರಾಟದ ಬಿಂದುಗಳ ಡೈರೆಕ್ಟರಿಯ ಪ್ರಾಥಮಿಕ ಕೀಲಿಯನ್ನು [id] [int] ಶೂನ್ಯವಲ್ಲ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ, ನಾನು ಸಾದೃಶ್ಯದ ಮೂಲಕ ಸಂಗ್ರಹವನ್ನು ರಚಿಸುತ್ತೇನೆ
IgniteCache<Integer, SalesPoint> salesPointCache=ignite.cache("spCache")
xml ಸಂರಚನೆಯಲ್ಲಿ ನಾನು ಸಂಗ್ರಹವನ್ನು ವಿಭಜಿಸಲಾಗಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತೇನೆ
<bean class="org.apache.ignite.configuration.CacheConfiguration">
<property name="name" value="spCache"/>
<property name="cacheMode" value="PARTITIONED"/>
</bean>
ಪಾಯಿಂಟ್ ಆಫ್ ಸೇಲ್ ಮೂಲಕ ವಿಭಜನೆಯು ಪ್ರತಿ ಕ್ಲಸ್ಟರ್ ನೋಡ್ನಲ್ಲಿ ಲಭ್ಯವಿರುವ ಸೇಲ್ಸ್ಪಾಯಿಂಟ್ಕ್ಯಾಶ್ ದಾಖಲೆಗಳಿಗಾಗಿ ಅಗತ್ಯವಿರುವ ಒಟ್ಟು ಮೊತ್ತವನ್ನು ನಿರ್ಮಿಸಲಾಗುವುದು ಎಂದು ಊಹಿಸುತ್ತದೆ, ಅದರ ನಂತರ ಕ್ಲೈಂಟ್ ನೋಡ್ ಅಂತಿಮ ಸಂಕಲನವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.
ನಾನು ಟ್ಯುಟೋರಿಯಲ್ ಓದುತ್ತಿದ್ದೇನೆ
@Override
public void run() {
SalesPoint sp=salesPointCache.get(spId);
sp.calculateSalesPointCount();
..
}
ನಾನು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ ಮತ್ತು ಅಪ್ಲೋಡ್ ತರ್ಕವನ್ನು ಸೇರಿಸುತ್ತೇನೆ ಮತ್ತು ಅದನ್ನು ಪರೀಕ್ಷಾ ಡೇಟಾ ಸೆಟ್ನಲ್ಲಿ ರನ್ ಮಾಡುತ್ತೇನೆ. ಅಭಿವೃದ್ಧಿ ಸರ್ವರ್ನಲ್ಲಿ ಎಲ್ಲವೂ ಸ್ಥಳೀಯವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
ನಾನು ಎರಡು CentOs ಪರೀಕ್ಷಾ ಸರ್ವರ್ಗಳನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇನೆ, IP ವಿಳಾಸಗಳನ್ನು ಡೀಫಾಲ್ಟ್-config.xml ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿ, ಪ್ರತಿಯೊಂದರಲ್ಲೂ ಕಾರ್ಯಗತಗೊಳಿಸಿ
./bin/ignite.sh config/default-config.xml
ಎರಡೂ ಇಗ್ನೈಟ್ ನೋಡ್ಗಳು ಚಾಲನೆಯಲ್ಲಿವೆ ಮತ್ತು ಪರಸ್ಪರ ನೋಡಬಹುದು. ಕ್ಲೈಂಟ್ ಅಪ್ಲಿಕೇಶನ್ನ xml ಸಂರಚನೆಯಲ್ಲಿ ಅಗತ್ಯವಿರುವ ವಿಳಾಸಗಳನ್ನು ನಾನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತೇನೆ, ಅದು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ಟೋಪೋಲಜಿಗೆ ಮೂರನೇ ನೋಡ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ ಮತ್ತು ತಕ್ಷಣವೇ ಮತ್ತೆ ಎರಡು ನೋಡ್ಗಳಿವೆ. ಲಾಗ್ "ClassNotFoundException: model.SalesPoint" ಅನ್ನು ಸಾಲಿನಲ್ಲಿ ತೋರಿಸುತ್ತದೆ
SalesPoint sp=salesPointCache.get(spId);
CentOs ಸರ್ವರ್ಗಳಲ್ಲಿ ಯಾವುದೇ ಕಸ್ಟಮ್ ಸೇಲ್ಸ್ಪಾಯಿಂಟ್ ವರ್ಗ ಇಲ್ಲದಿರುವುದು ದೋಷಕ್ಕೆ ಕಾರಣ ಎಂದು StackOverflow ಹೇಳುತ್ತದೆ. ನಾವು ಬಂದಿದ್ದೇವೆ. "ಪ್ರತಿ ನೋಡ್ನಲ್ಲಿ ನಿಮ್ಮ ಜಾವಾ ಕೋಡ್ ಅನ್ನು ನೀವು ಹಸ್ತಚಾಲಿತವಾಗಿ ನಿಯೋಜಿಸಬೇಕಾಗಿಲ್ಲ" ಮತ್ತು ಹೀಗೆ ಹೇಗೆ? ಅಥವಾ "ನಿಮ್ಮ ಜಾವಾ ಕೋಡ್" ಸೇಲ್ಸ್ಪಾಯಿಂಟ್ ಬಗ್ಗೆ ಅಲ್ಲವೇ?
ನಾನು ಬಹುಶಃ ಏನನ್ನಾದರೂ ಕಳೆದುಕೊಂಡಿದ್ದೇನೆ - ನಾನು ಮತ್ತೆ ಹುಡುಕಲು ಪ್ರಾರಂಭಿಸುತ್ತೇನೆ, ಮತ್ತೆ ಓದುತ್ತೇನೆ ಮತ್ತು ಹುಡುಕುತ್ತೇನೆ. ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ, ನಾನು ವಿಷಯದ ಬಗ್ಗೆ ಎಲ್ಲವನ್ನೂ ಓದಿದ್ದೇನೆ ಎಂಬ ಭಾವನೆ ಬರುತ್ತದೆ, ಇನ್ನು ಹೊಸದೇನೂ ಇಲ್ಲ. ನಾನು ಹುಡುಕುತ್ತಿರುವಾಗ, ನಾನು ಕೆಲವು ಆಸಕ್ತಿದಾಯಕ ಕಾಮೆಂಟ್ಗಳನ್ನು ಕಂಡುಕೊಂಡೆ.
Model classes are not peer deployed, but you can use withKeepBinary() flag
on the cache and query BinaryObjects. This way you will avoid deserialization
on the server side and will not get ClassNotFoundException.
ಮತ್ತೊಂದು ಅಧಿಕೃತ ಅಭಿಪ್ರಾಯ:
ಹಬ್ರೆ ಕುರಿತು ಲೇಖನ
That's it. Start (..) node using MaintenanceServiceNodeStartup file or pass
maintenance-service-node-config.xml to Apache Ignite's ignite.sh/bat scripts.
If you prefer the latter then make sure to build a jar file that will contain
all the classes from java/app/common and java/services/maintenance directories.
The jar has to be added to the classpath of every node where the service
might be deployed.
ವಾಸ್ತವವಾಗಿ, ಅಷ್ಟೆ. ಇಲ್ಲಿ ಅದು ತಿರುಗುತ್ತದೆ, ಏಕೆ, ಈ ನಿಗೂಢ ಬೈನರಿ ಸ್ವರೂಪ!
3.SingleJar
ಡೆನಿಸ್ ನನ್ನ ವೈಯಕ್ತಿಕ ರೇಟಿಂಗ್ನಲ್ಲಿ ಮೊದಲ ಸ್ಥಾನ ಪಡೆದರು, ಲಭ್ಯವಿರುವ ಎಲ್ಲಕ್ಕಿಂತ ಹೆಚ್ಚು ಉಪಯುಕ್ತವಾದ ಟ್ಯುಟೋರಿಯಲ್ IMHO. ಅವನಲ್ಲಿ
ನಾನು ಅದೇ ರೀತಿ ಮಾಡುತ್ತೇನೆ ಮತ್ತು ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಅವಲಂಬಿಸಿ "ಡೇಟಾ ನೋಡ್" ಅಥವಾ "ಕ್ಲೈಂಟ್ ನೋಡ್" ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಒಂದು ಜಾರ್ ಫೈಲ್ ಅನ್ನು ಪಡೆಯುತ್ತೇನೆ. ಅಸೆಂಬ್ಲಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಶೂನ್ಯ ನಿಯೋಜನೆಯನ್ನು ಸೋಲಿಸಲಾಗಿದೆ.
ಪರೀಕ್ಷಾ ಡೇಟಾದ ಮೆಗಾಬೈಟ್ಗಳಿಂದ ಹತ್ತಾರು ಗಿಗಾಬೈಟ್ಗಳ ಯುದ್ಧ ಡೇಟಾಗೆ ಪರಿವರ್ತನೆಯು ಬೈನರಿ ಸ್ವರೂಪವು ಒಂದು ಕಾರಣಕ್ಕಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ತೋರಿಸಿದೆ. ನೋಡ್ಗಳಲ್ಲಿ ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಅತ್ಯುತ್ತಮವಾಗಿಸಲು ಇದು ಅಗತ್ಯವಾಗಿತ್ತು ಮತ್ತು ಇಲ್ಲಿಯೇ ಬೈನರಿ ಆಬ್ಜೆಕ್ಟ್ ತುಂಬಾ ಉಪಯುಕ್ತವಾಗಿದೆ.
4. ತೀರ್ಮಾನಗಳು
ಅಪಾಚೆ ಇಗ್ನೈಟ್ ಪ್ರಾಜೆಕ್ಟ್ ದಸ್ತಾವೇಜನ್ನು ಅಸ್ಪಷ್ಟತೆಯ ಬಗ್ಗೆ ಎದುರಿಸಿದ ಮೊದಲ ನಿಂದೆ ನ್ಯಾಯಯುತವಾಗಿದೆ; 2016 ರಿಂದ ಸ್ವಲ್ಪ ಬದಲಾಗಿದೆ. ವೆಬ್ಸೈಟ್ ಮತ್ತು/ಅಥವಾ ರೆಪೊಸಿಟರಿಯ ಆಧಾರದ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಮೂಲಮಾದರಿಯನ್ನು ಜೋಡಿಸುವುದು ಹರಿಕಾರನಿಗೆ ಸುಲಭವಲ್ಲ.
ಮಾಡಿದ ಕೆಲಸದ ಫಲಿತಾಂಶಗಳ ಆಧಾರದ ಮೇಲೆ, ಶೂನ್ಯ ನಿಯೋಜನೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬ ಅನಿಸಿಕೆ, ಆದರೆ ಸಿಸ್ಟಮ್ ಮಟ್ಟದಲ್ಲಿ ಮಾತ್ರ. ಈ ರೀತಿಯದ್ದು: ಕಸ್ಟಮ್ ತರಗತಿಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ರಿಮೋಟ್ ಕ್ಲಸ್ಟರ್ ನೋಡ್ಗಳನ್ನು ಕಲಿಸಲು ಬೈನರಿ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ; ಶೂನ್ಯ ನಿಯೋಜನೆ - ಆಂತರಿಕ ಕಾರ್ಯವಿಧಾನ
ಅಪಾಚೆ ಇಗ್ನೈಟ್ ಸ್ವತಃ ಮತ್ತು ಕ್ಲಸ್ಟರ್ನಾದ್ಯಂತ ಸಿಸ್ಟಮ್ ಆಬ್ಜೆಕ್ಟ್ಗಳನ್ನು ವಿತರಿಸುತ್ತದೆ.
ನನ್ನ ಅನುಭವವು ಹೊಸ ಅಪಾಚೆ ಇಗ್ನೈಟ್ ಬಳಕೆದಾರರಿಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.
ಮೂಲ: www.habr.com