Pagpapakilala
trabaho ko sa isang kumpanya na kung saan tumakbo kami maraming jobs batch processing milyon-milyong mga talaan ng data sa bawat araw at ako ay iisip kamakailan lamang tungkol sa lahat ng mga makina na umupo sa paligid ng bawat at bawat araw paggawa ng wala para sa ilang oras. Gusto hindi na ito maging mabuti kung maaari naming gamitin ang mga makina sa magbolster ang pagpoproseso ng kapangyarihan ng aming mga sistema? Sa set na ito ng mga artikulo na ako ng pagpunta sa tumingin sa mga potensyal na benepisyo ng employing isang opisina parilya gamit virtualised kapaligiran.
Sa Part 1 ako nagbigay ng isang pangkalahatang ideya ng mga sistema at teknolohiya ay ako ay gumagamit pati na rin ang usapan na ang ilan sa mga potensyal na kadahilanan kung bakit nais mo nais na lumikha ng isang opisina grid.
Job Control
Kung ikaw ay pagpunta upang patakbuhin ang mga trabaho pagkatapos ikaw ay pagpunta sa kailangan ang ilang mga paraan upang pamahalaan ang mga ito. Ang iyong trabaho control system (sa iyong trabaho server) pangangailangan upang maging tunay mabuti Akala out bago kahit na pagtatangka upang patakbuhin ang isang opisina grid. Kaya una, ano ang mga gawain para sa isang sistema ng trabaho control:
- Hand out jobs sa kahilingan mula sa mga manggagawa
- Sabihin sa mga manggagawa kung ano ang uri ng mga trabaho na tumakbo
- Subaybayan trabaho
- Tiyakin na ang mga trabaho ay tatakbo lamang sa sandaling
- Magbigay ng mga data na trabaho sa mga manggagawa, o hindi bababa sa sabihin sa kanila kung saan sa kumuha ito
Ang sistema rin pangangailangan upang maging extensible, ang isang solusyon na gumagana para sa ngayon sa isang solong kaso ay maaaring extended na tumakbo ng ilang mga uri ng mga trabaho bilang negosyo ang nakikita ng mga katumbas ng halaga sa isang solusyon grid. Halimbawa, mga trabaho ay maaaring makakuha ng prayoridad, higit sa isang uri ng trabaho ay maaaring umiiral (ibig sabihin ng ilang mga code base), sa huli ay maaari kang kahit na tumakbo ng ilang iba't-ibang machine na manggagawa ay optimized para sa bawat uri ng trabaho (kahit na ay ilipat ang layo mula sa 'generic worker 'ideya). Laging subukan na isipin ang tungkol sa hinaharap kapag pagbuo ng mga sistema, ang isang maikling kataga ng paningin ay maaaring humantong sa mas matagal na kataga ng kabiguan at nadagdagan ang pag-unlad ng oras.
Job Server
Kami ay pagpunta sa kailangan lugar upang makontrol ang aming mga trabaho mula sa, ito ay dapat na lamang ang sistema sa iyong parilya na may isang nakapirming locator mapagkukunan, maging na ang isang IP address, host name, URL (gamit ang panloob na DNS), atbp Ito ay dahil ang mga manggagawa na kailangan upang malaman kung saan sa hitsura para sa mga trabaho, mga manggagawa na kailangan upang mahanap ang mga trabaho system control (hindi ang trabaho system control mahanap ang mga manggagawa).
Ang trabaho server hindi mismo ay hindi tunay magkaroon ng isang komplikadong gawain (sa isang pangunahing sistema sa papaano mang paraan), ang mga pangangailangan sa tindahan ng isang listahan ng mga trabaho, kamay out jobs, tumanggap ng mga resulta, at sa dakong huli tindahan ito para sa mamaya pagsasauli. Paano ang mga bahagi (tulad ng 'kamay out jobs') ay tinukoy ay maaaring maging lubhang basic. Mamaya sa maaari naming palawakin ang sistema ng isama ang isang administrasyon interface upang idagdag, i-edit, tanggalin, isuspinde trabaho ngunit ito ay lampas na ito ehersisyo.
May dahilan walang anomang pagkatapos na ang iyong trabaho ng server ay hindi maaaring maging isang virtual machine na tumatakbo sa loob ng iyong pangunahing processing server na ibinigay ito ay hindi alisan ng tubig masyadong maraming mga resources mula sa mga ito. Ang trabaho server gayunpaman ay kailangan mataas na availability, kung ito goes down sa isang Biyernes gabi ikaw ay pagpunta sa mawalan ng isang buong weekend ng processing, potensyal na gastos sa iyo ng isang pares ng mga linggo na nagkakahalaga ng processing time (kapag inihambing sa iyong pangunahing pagpoproseso ng server lamang) . Baka gusto mong isaalang-alang ang paglagay ng iyong trabaho sa server ang isang load balanseng kapaligiran para sa mataas availability.
Basic Setup
Ang basic na setup para sa aming mga server ng trabaho ay binubuo ng ano ako ng pagtawag ng isa sa aking mga server Limp (iyon ay Li nux, m ySql, P HP). Ang code na tumatakbo sa Thea manggagawa ay tunay na trabaho sa labas kung ano ang trabaho ito maaari tumakbo sa pamamagitan ng pakikipag-ugnay sa trabaho control database system. Mamaya sa maaari naming lumikha ng isang web service at ang tunay na kamay ang trabaho sa halip na sa pagkakaroon ng mga manggagawa gawin ang mga hirap sa trabaho sa kanilang sarili, ngunit sa ngayon kami ay patuloy na magamit ang mga prinsipyo KISS (Panatilihin itong Simple, Stupid!).
Kaya, nagbibigay-daan sa lumikha ng tatlong MySQL talahanayan sa pakikitungo sa mga trabaho. Ang mga ito ay `jobs`, `jobRecords`, at `` jobResults.
Narito ako gamit SQL Buddy ng isang magandang maliit na alternatibo sa phpMyAdmin dahil lang nito mas madali na i-install sa centOS (para sa iba na makita: 10 Great alternatibo sa phpMyAdmin )
table na ito ay binubuo ng 5 mga simpleng mga patlang,
- id: natatanging kilalanin ang mga trabaho
- pangalan: Puwede maging isang client sanggunian, o anumang bilang ng iba pang mga tagapagpakilala
- Status: kailangan mong malaman kung ang trabaho ay sa, halimbawa,
- 0: Hindi makapagsimula
- 1: Napili up
- 2: Nakumpleto
- started_by: Sino ang nagsimula paggawa ng mga trabaho? Ito ay hindi lubos na kinakailangan ngunit ay isang nice na magkaroon. gusto ko iminumungkahi tracking manggagawa sa pamamagitan ng kanilang mga IP address sa iyong network
- started_at: Kailan worker ang simula ng trabaho? Sa pamamagitan ng pagsubaybay sa mga trabaho na hindi natapos sa loob ng X halaga ng oras na alam namin na kailangan namin upang kunin ang trabaho na naman at simulan ang proseso sa pamamagitan ng isa pang manggagawa. Manggagawa ay maaaring ihinto ang processing / offline pumunta para sa anumang bilang ng mga dahilan, kapangyarihan kabiguan, crash, network pagkawala, atbp
Ito ay madaling kung paano talahanayan na ito ay maaaring pinalawak na may ilang karagdagang mga patlang upang pahintulutan para sa mga istatistika sa pagsubaybay, ang isang tapusin ng haligi na oras upang makita kung gaano katagal trabaho ang kinuha, ang isang counter upang makita kung gaano karaming mga manggagawa pumili ng up ang trabaho (malinaw naman ito ng mga pangangailangan upang magkaroon ng hilig sa 1), trabaho priority, ang listahan ay maaaring pumunta sa at sa. Sa mga mas kumplikadong mga pangyayari trabaho ay ito ay posible na tukuyin kung magkano ang memory ang manggagawa ay kailangan ng access sa (at sa gayon lamang gamitin na mga manggagawa), o kahit anong uri ng manggagawa ay kinakailangan.
Lets magdagdag ng ilang mga trabaho halimbawa:
Ang susunod na talahanayan muli ay ganap simple sa maintindihan, ang mga ito ay ang aming trabaho mga talaan. Sila ay naka-link ang pangunahing table jobs pamamagitan ng isang hanay `` jobs_id. Ang mga gumawa ng up ng talahanayan na ito very much ay depende sa mga data na kailangan mo sa supply sa iyong mga manggagawa, pinapayagan gumawa ng isang tunay simpleng halimbawa kung saan kami ay may apat na mga haligi:
- id: ID ng mga record
- pangalan: Person's name
- address: Person's address
- jobs_id: Ang trabaho ID record na ito ay naka-link sa
Ang ikatlo at huling mesa ay binubuo ng isang talahanayan na resulta, ito ay may marami ang parehong gumawa ng up bilang aming mga rekord table, at kasama ang karagdagan ng ilang mga hanay ay maaaring maging bahagi ng talahanayan ng mga talaan:
- job_record_id: Link ang resulta sa talahanayan sa trabaho
- resulta: Ang mga resulta ng data
…and that's all you need for job control! (albeit at a very basic level) In my case I'm pointed to another table where my data to process was located, but this could just as easily been a file, parameters to run simulation code, you name it.
Selecting a job
Katulad ng nakasaad sa dati, ang mga manggagawa ay gawin ang aming trabaho sa pamamahala para sa amin para sa ngayon, kaya lahat ng kailangan naming talagang gawin ay ang makahanap ng trabaho na nangangailangan ng processing at makakuha ng impormasyon. Kung paano namin gawin ito? Well pick sa aming pamantayan sa pagpili ng trabaho at hitsura para sa mga trabaho, sa SQL ko ang mga sumusunod:
- Gumawa ng anumang trabaho na hindi na minarkahan bilang kumpleto ngunit mula sa aming mga manggagawa at i-reset ito (kapalit __ME__ sa isang identifier, pinakamadaling ay IP address):
UPDATE `` jobs SET `status` = 0 SAAN `status` = 1 AT `started_by` = __ME__;
- Paggamit ng aming trabaho pamantayan pagpili, piliin ang isang trabaho at sabihin ang control system na worker na ito ay ang pakikitungo sa mga ito:
UPDATE `` jobs SET `status` = 1, `started_by` = __ME__, `started_at` = NGAYON () SAAN `status` = 0 OR
(`Status` = 1 AT `` started_at> DATE_SUB (NGAYON (), na pagitan X HOUR)) MAAYOS NG `id` ASC;
Sa pamamagitan ng daklot jobs na hindi na bumalik sa mga resulta ng X na halaga ng oras namin matiyak na ang lahat ng mga trabaho ay tatakbo sa kaganapan ng isang worker crashing o pagpunta AWOL.
- Susunod na sunggaban ang mga detalye ng mga trabaho na sinusundan ng mga talaan sa kanilang sarili:
PUMILI MULA * `jobs` `WHERE started_by` = __ME__ LIMIT 1;
PUMILI * MULA `job_records` SAAN `id` = __JOBID__;
Upon completion of the job we insert our result records and mark the job as complete. Remember as jobs can suspend/resume at any time allow for some robustness in your script. It might be that the task suspends half way through updating the job control system, so checking the number of records in a job and the number of results saved back to the job control system would be a wise move.
In addition, whilst this demonstrates how jobs can be selected and managed from an SQL-query frame you should really be abstracting your job control so that if you decide to switch to using a web service, a file based system, XML , or any other number of systems it will not affect the code above it.
Job Configuration
The next aspect to consider is job size and configuration. By playing with job configuration we can strike an excellent balance between speed, process replication, and reliability. Take a couple of scenarios:
- Jobs take 1 day each to run: This means that your workers need 15 days to process each job (remember 10% of the power for 2/3rds of the time). This is clearly not a wise configuration, your job size is way too big! It would take at least double the time to get a job processed should the initial worker go AWOL (time to pick up that it hasn't returned a result plus reprocessing time). In an ideal you'd have at least one full job easily cleared by the end of each long idle period, that way you keep the jobs ticking over and at worst case a job would take two days to process should the first go missing.
- Jobs take 1 minute to run: This means that your workers take about 15 minutes to run each job. Whilst this may initially seem ideal, you gain additional work processing during lunch time, coffee breaks, meetings, etc this scenario puts strain on other areas of your system and introduces its own problems. For example, firstly your setup/processing time ratio is going to go right down, therefore losing system efficiency. Your network is going to be constantly streaming job information to the various workers frustrating staff who are dong their day to day work. You're also going to put more strain on your job processing server as it has to dish out lots and lots of small pieces of work on a regular basis. Lastly, in this situation if your job server goes down you're going to create a huge back log of uncompleted work whereas bigger jobs could of continued processing blissfully unaware that the job server was experiencing difficulties.
In reality there will be no one ideal configuration for your grid setup, much depends on the available resources, types of job, job turnaround time requirements, network capability, and so on. However some guidelines would be:
- Size jobs so that each worker can get through at least 3-4 jobs in a period of 15 hours (the longest likely idle time period)
- Play with the job size so that setup time becomes fairly insignificant compared to the processing time (bearing in mind the above point).
- If a job doesn't complete in double the amount of time (maybe less) you expect it to complete it assume that its gone AWOL and start processing it with another worker. This means you may have to wait up to three times the normal length of a job for it to complete (possibly longer if the subsequent job fails). You may want to reduce this time, but be careful not to reduce it too much as you may start duplicating processing tasks on a regular basis.
- Jobs should be independent of outside requirements as much as possible. The job server, for example, should only be contacted at the start and end of every job.
- Don't saturate your network, this will have two negative effects, your daytime staff will find using the network frustrating and problems may be experienced with connections timing out a problem that will only get worse as you scale your grid.
- Ensure jobs can run on your workers. If jobs become too memory intensive or disk space intensive jobs will start aborting and the only thing you'll notice is a drop in number of jobs processed with no real reason why.
Submitting Results of a Job
When submitting the results of a job it is important to check that results have not been submitted by another worker, especially if the current worker has been dormant for some time.
When results are submitted ensure that the number of results matches the number of records within the job.
As stated previously, and can not be over emphasised, build fault tolerance into job retrieval and results submission. The workers can (and most likely will) go into suspend mode at the most inconvenient of times and this needs to be catered for. Also once again abstracting away your results submission will help cater for future changes to your job control system much easier to deal with.
Buod
In this section we have looked at what a job control server needs to do and how to get a very basic system set up. We discussed how to retrieve a job from the control system and how best to configure jobs to get the most our of your office grid system. To finish, a paragraph or two on submitting results back to the job control server was presented.
- A job control server manages jobs and ensures that all work units are completed
- By abstracting your job select/results submission we can change the technology of the control server without much problems
- Isaayos ang iyong trabaho upang tiyakin na sila ay tumakbo nang mabilis at mahusay walang paglagay ng masyadong maraming presyon sa iyong network ng imprastraktura, at walang pagkokopya processing gawain sa isang regular na batayan.
- Tiyakin na ang build mo kasalanan tolerance at error checking sa iyong gawain, mga manggagawa ay maaaring suspindihin at ipagpatuloy at ang pinaka panggulo ng beses. Tandaan na suriin kung may resulta naisumite na ng ibang worker.
Susunod na panahon
Sa part 3 kami gumawa ng aming mga virtual machine processing at set up ng aming mga machine bintana para maging idle-time manggagawa.
Comments (0) 
