અપાચે ઇગ્નાઇટ ઝીરો ડિપ્લોયમેન્ટ: ખરેખર શૂન્ય?

અમે રિટેલ નેટવર્કના ટેક્નોલોજી ડેવલપમેન્ટ વિભાગ છીએ. એક દિવસ, મેનેજમેન્ટે MSSQL સાથે જોડાણમાં Apache Ignite નો ઉપયોગ કરીને મોટા પાયે ગણતરીઓને ઝડપી બનાવવાનું કાર્ય સેટ કર્યું, અને જાવા કોડના સુંદર ચિત્રો અને ઉદાહરણો સાથેની વેબસાઇટ બતાવી. મને તરત જ સાઇટ ગમ્યું શૂન્ય જમાવટ, જેનું વર્ણન ચમત્કારોનું વચન આપે છે: તમારે ગ્રીડમાંના દરેક નોડ પર તમારા Java અથવા Scala કોડને મેન્યુઅલી જમાવવાની જરૂર નથી અને જ્યારે પણ તે બદલાય ત્યારે તેને ફરીથી જમાવવાની જરૂર નથી. જેમ જેમ કામ આગળ વધતું ગયું તેમ તેમ બહાર આવ્યું કે ઝીરો ડિપ્લોયમેન્ટના ચોક્કસ ઉપયોગો છે, જેની વિશેષતાઓ હું શેર કરવા માંગુ છું. કટની નીચે વિચારો અને અમલીકરણ વિગતો છે.

1. સમસ્યાનું નિવેદન

સમસ્યાનો સાર નીચે મુજબ છે. સેલ્સપોઈન્ટ સેલ્સ પોઈન્ટ ડિરેક્ટરી અને સ્કુ (સ્ટોક કીપિંગ યુનિટ) પ્રોડક્ટ ડિરેક્ટરી છે. વેચાણના બિંદુમાં "નાના" અને "મોટા" મૂલ્યો સાથે "સ્ટોર પ્રકાર" વિશેષતા છે. એક વર્ગીકરણ (વેચાણના બિંદુના ઉત્પાદનોની સૂચિ) વેચાણના દરેક બિંદુ સાથે જોડાયેલ છે (DBMS માંથી લોડ થયેલ છે) અને માહિતી પ્રદાન કરવામાં આવે છે કે નિર્દિષ્ટ તારીખથી ઉલ્લેખિત ઉત્પાદન
વર્ગીકરણમાંથી બાકાત અથવા ભાતમાં ઉમેરાયેલ.

વેચાણના પોઈન્ટ્સની પાર્ટીશન કરેલ કેશ ગોઠવવી અને તેમાં જોડાયેલ ઉત્પાદનો વિશેની માહિતી એક મહિના અગાઉથી સંગ્રહિત કરવી જરૂરી છે. કોમ્બેટ સિસ્ટમ સાથે સુસંગતતા માટે ઇગ્નાઇટ ક્લાયંટ નોડને ડેટા લોડ કરવા, ફોર્મની એકંદર ગણતરી (સ્ટોરનો પ્રકાર, ઉત્પાદન કોડ, દિવસ, નંબર_ઓફ_સેલ્સ_પોઇન્ટ્સ) અને તેને DBMS પર પાછું અપલોડ કરવાની જરૂર છે.

2. સાહિત્યનો અભ્યાસ

મને હજી સુધી કોઈ અનુભવ નથી, તેથી હું ચૂલા પરથી ડાન્સ કરવાનું શરૂ કરું છું. એટલે કે, પ્રકાશનોની સમીક્ષામાંથી.

કલમ 2016 અપાચે ઇગ્નાઇટનો પરિચય: પ્રથમ પગલાં અપાચે ઇગ્નાઇટ પ્રોજેક્ટના દસ્તાવેજીકરણની લિંક ધરાવે છે અને તે જ સમયે આ દસ્તાવેજીકરણની અસ્પષ્ટતા માટે નિંદા છે. મેં તેને બે વખત ફરીથી વાંચ્યું, સ્પષ્ટતા આવતી નથી. હું સત્તાવાર ટ્યુટોરીયલનો સંદર્ભ લઉં છું શરૂઆત, જે
આશાવાદી રીતે વચન આપે છે "તમે એક ક્ષણમાં ઉભા થઈ જશો!" હું પર્યાવરણ વેરીએબલ સેટિંગ્સ શોધી રહ્યો છું, બે Apache Ignite Essentials વિડિઓઝ જોઉં છું, પરંતુ તે મારા ચોક્કસ કાર્ય માટે ખૂબ ઉપયોગી ન હતા. મેં પ્રથમ એપ્લીકેશન બનાવીને પ્રમાણભૂત ફાઇલ “example-ignite.xml” સાથે કમાન્ડ લાઇનમાંથી સફળતાપૂર્વક ઇગ્નાઇટ લોન્ચ કર્યું છે. એપ્લિકેશનની ગણતરી કરો માવેનનો ઉપયોગ કરીને. એપ્લિકેશન કામ કરે છે અને ઝીરો ડિપ્લોયમેન્ટનો ઉપયોગ કરે છે, શું સુંદરતા છે!

મેં આગળ વાંચ્યું, અને ત્યાં ઉદાહરણ તરત જ affinityKey નો ઉપયોગ કરે છે (SQL ક્વેરી દ્વારા અગાઉ બનાવેલ), અને રહસ્યમય BinaryObject નો પણ ઉપયોગ કરે છે:

IgniteCache<BinaryObject, BinaryObject> people 
        = ignite.cache("Person").withKeepBinary(); 

મેં તે વાંચ્યું થોડુંક: બાઈનરી ફોર્મેટ - પ્રતિબિંબ જેવું કંઈક, નામ દ્વારા ઑબ્જેક્ટના ક્ષેત્રોને ઍક્સેસ કરવું. ઑબ્જેક્ટને સંપૂર્ણપણે ડિસિરિયલાઇઝ કર્યા વિના ફીલ્ડની કિંમત વાંચી શકે છે (મેમરી સાચવી). પરંતુ ઝીરો ડિપ્લોયમેન્ટ હોવાથી વ્યક્તિની જગ્યાએ BinaryObject શા માટે વપરાય છે? શા માટે IgniteCache IgniteCache પર સ્થાનાંતરિત ? તે હજુ સ્પષ્ટ નથી.

હું મારા કેસને અનુરૂપ કોમ્પ્યુટ એપ્લિકેશન રિમેક કરી રહ્યો છું. MSSQL માં પૉઇન્ટ ઑફ સેલની ડિરેક્ટરીની પ્રાથમિક કી [id] [int] NOT NULL તરીકે વ્યાખ્યાયિત કરવામાં આવી છે, હું સાદ્રશ્ય દ્વારા કેશ બનાવીશ

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>

વેચાણ બિંદુ દ્વારા વિભાજન ધારે છે કે જરૂરી એકંદર દરેક ક્લસ્ટર નોડ પર ત્યાં ઉપલબ્ધ સેલ્સપોઈન્ટકેશ રેકોર્ડ્સ માટે બનાવવામાં આવશે, જે પછી ક્લાયંટ નોડ અંતિમ સમીકરણ કરશે.

હું ટ્યુટોરીયલ વાંચી રહ્યો છું પ્રથમ ઇગ્નાઇટ કોમ્પ્યુટ એપ્લિકેશન, હું સાદ્રશ્ય દ્વારા કરું છું. દરેક ક્લસ્ટર નોડ પર હું IgniteRunnable(), કંઈક આના જેવું ચલાવું છું:

  @Override
  public void run() {
    SalesPoint sp=salesPointCache.get(spId);
    sp.calculateSalesPointCount();
    ..
  }

હું એકત્રીકરણ અને અપલોડિંગ તર્ક ઉમેરું છું અને તેને ટેસ્ટ ડેટા સેટ પર ચલાવું છું. વિકાસ સર્વર પર બધું સ્થાનિક રીતે કામ કરે છે.

હું બે CentOs ટેસ્ટ સર્વર્સ લૉન્ચ કરું છું, IP એડ્રેસને default-config.xml માં સ્પષ્ટ કરું છું, દરેક પર એક્ઝિક્યુટ કરું છું

./bin/ignite.sh config/default-config.xml

બંને ઇગ્નાઇટ નોડ્સ ચાલી રહ્યા છે અને એકબીજાને જોઈ શકે છે. હું ક્લાયંટ એપ્લિકેશનની xml રૂપરેખામાં જરૂરી સરનામાંનો ઉલ્લેખ કરું છું, તે શરૂ થાય છે, ટોપોલોજીમાં ત્રીજો નોડ ઉમેરે છે અને તરત જ ફરીથી બે નોડ આવે છે. લોગ લાઇનમાં “ClassNotFoundException: model.SalesPoint” દર્શાવે છે

SalesPoint sp=salesPointCache.get(spId);

સ્ટેકઓવરફ્લો કહે છે કે ભૂલનું કારણ એ છે કે CentOs સર્વર્સ પર કોઈ કસ્ટમ સેલ્સપોઈન્ટ વર્ગ નથી. અમે પહોંચી ગયા છીએ. "તમારે દરેક નોડ પર તમારા જાવા કોડને મેન્યુઅલી જમાવવાની જરૂર નથી" અને આગળ ટેક્સ્ટમાં કેવી રીતે? અથવા "તમારો જાવા કોડ" SalesPoint વિશે નથી?

હું કદાચ કંઈક ચૂકી ગયો છું - હું ફરીથી શોધવાનું, વાંચવાનું અને ફરીથી શોધવાનું શરૂ કરું છું. થોડા સમય પછી, મને અનુભૂતિ થાય છે કે મેં વિષય પર બધું વાંચ્યું છે, હવે કંઈ નવું નથી. જ્યારે હું શોધ કરી રહ્યો હતો, ત્યારે મને કેટલીક રસપ્રદ ટિપ્પણીઓ મળી.

વેલેન્ટિન કુલિચેન્કો, ગ્રીડગેઈન સિસ્ટમ્સ ખાતે લીડ આર્કિટેક્ટ, જવાબ આપો સ્ટેકઓવરફ્લો પર, એપ્રિલ 2016:

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.

અન્ય અધિકૃત અભિપ્રાય: ડેનિસ મેગ્ડા, પ્રોડક્ટ મેનેજમેન્ટ ડિરેક્ટર, ગ્રીડગેન સિસ્ટમ્સ.

હેબ્રે પરનો લેખ માઇક્રોસર્વિસિસ વિશે ડેનિસ મેગ્ડાના ત્રણ લેખોનો સંદર્ભ આપે છે: માઇક્રોસર્વિસિસ ભાગ I, માઇક્રોસર્વિસિસ ભાગ II, માઇક્રોસર્વિસિસ ભાગ III 2016-2017. બીજા લેખમાં, ડેનિસ MaintenanceServiceNodeStartup.jar દ્વારા ક્લસ્ટર નોડ શરૂ કરવાનું સૂચન કરે છે. તમે xml રૂપરેખાંકન અને આદેશ વાક્ય સાથે લોન્ચનો ઉપયોગ પણ કરી શકો છો, પરંતુ પછી તમારે દરેક જમાવટ કરાયેલ ક્લસ્ટર નોડ પર મેન્યુઅલી કસ્ટમ વર્ગો મૂકવાની જરૂર છે:

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.સિંગલ જાર

ડેનિસે મારા વ્યક્તિગત રેટિંગમાં પ્રથમ સ્થાન મેળવ્યું, IMHO ઉપલબ્ધ તમામમાંથી સૌથી ઉપયોગી ટ્યુટોરીયલ. તેના માં માઇક્રોસેવાઓનું ઉદાહરણ Github ક્લસ્ટર નોડ્સ સેટ કરવા માટે સંપૂર્ણપણે તૈયાર ઉદાહરણ ધરાવે છે, જે કોઈપણ વધારાના સ્ક્વોટિંગ વિના કમ્પાઇલ કરે છે.

હું તે જ રીતે કરું છું અને કમાન્ડ લાઇન દલીલના આધારે "ડેટા નોડ" અથવા "ક્લાયન્ટ નોડ" લૉન્ચ કરતી સિંગલ જાર ફાઇલ મેળવીશ. એસેમ્બલી શરૂ થાય છે અને કામ કરે છે. ઝીરો ડિપ્લોયમેન્ટનો પરાજય થયો છે.

મેગાબાઇટ્સ ટેસ્ટ ડેટામાંથી દસ ગીગાબાઇટ્સ કોમ્બેટ ડેટામાં સંક્રમણ દર્શાવે છે કે દ્વિસંગી ફોર્મેટ એક કારણસર અસ્તિત્વમાં છે. નોડ્સ પર મેમરી વપરાશને ઑપ્ટિમાઇઝ કરવું જરૂરી હતું, અને આ તે છે જ્યાં બાઈનરી ઑબ્જેક્ટ ખૂબ જ ઉપયોગી બન્યું.

4. નિષ્કર્ષ

અપાચે ઇગ્નાઇટ પ્રોજેક્ટ દસ્તાવેજીકરણની અસ્પષ્ટતા વિશે પ્રથમ ઠપકોનો સામનો કરવો પડ્યો હતો, તે વાજબી હોવાનું બહાર આવ્યું છે; 2016 થી થોડો બદલાયો છે. વેબસાઈટ અને/અથવા રીપોઝીટરીના આધારે કાર્યકારી પ્રોટોટાઈપને એસેમ્બલ કરવું શિખાઉ માણસ માટે સરળ નથી.

કરવામાં આવેલ કાર્યના પરિણામોના આધારે, છાપ એવી હતી કે ઝીરો ડિપ્લોયમેન્ટ કામ કરે છે, પરંતુ માત્ર સિસ્ટમ સ્તરે. આના જેવું કંઈક: BinaryObject નો ઉપયોગ રિમોટ ક્લસ્ટર નોડ્સને કસ્ટમ વર્ગો સાથે કામ કરવા શીખવવા માટે થાય છે; ઝીરો ડિપ્લોયમેન્ટ - આંતરિક મિકેનિઝમ
અપાચે પોતે જ પ્રજ્વલિત કરે છે અને સમગ્ર ક્લસ્ટરમાં સિસ્ટમ ઑબ્જેક્ટ્સનું વિતરણ કરે છે.

મને આશા છે કે મારો અનુભવ નવા Apache Ignite વપરાશકર્તાઓ માટે ઉપયોગી થશે.

સોર્સ: www.habr.com