Reacties (6)

Door Steven Lloyd Watkin , Donderdag 7 Januari 2010 22:50

In een vervolg op mijn vorige post over Zend_Navigation, Route verzoeken om sitemap.xml om aangepaste controller / actie , dit bericht gaat over dymnamically Pagina's toevoegen aan een Zend_Navigation container tijdens de uitvoering / uitvoeren van scripts.

Het is allemaal goed en wel met vermelding van uw pagina's in een ini-of xml -bestand, maar op een gegeven moment ga je De veranderende pagina's in uw site die u wilt als onderdeel van een menu, sitemap, of opgenomen worden in uw broodkruimelspoor. Dus wat we moeten doen is het toevoegen van pagina's op onze Zend_Navigation container tijdens de uitvoering. Voorbeelden hiervoor is het toevoegen van nieuws, blog posts, of pagina opmerkingen, etc.

Lees verder 'dynamisch pagina's toe te voegen aan Zend_Navigation container tijdens runtime' »

Reacties (4)

Door Steven Lloyd Watkin , woensdag 06 januari 2010 12:13 am

Met het oog op rechtstreekse verzoeken om / sitemap.xml om een aangepaste controller en werking op het Zend Framework applicatie simpelweg de volgende in uw application.ini of alternatieve config-bestand (bv. Ik gebruik navigation.ini):

 resources.router.routes.sitemap.route = "sitemap.xml"
 resources.router.routes.sitemap.defaults.controller = index
 resources.router.routes.sitemap.defaults.action = sitemap

Voorbeeld code voor het uitvoeren van kan worden gezien door het creëren van een actie in de juiste controller (bijv. mijn sitemap ligt in de index controller, sitemap actie):

 < php
 klasse IndexController
     breidt Zend_Controller_Action
 {
     / **
      * Renders een sitemap op basis van Zend_Navigation setup
      * /
     publieke functie sitemapAction ()
     {
    	 echo $ this-> view-> navigatie () -> sitemap ();
    	 $ This-> view-> lay-out () -> disableLayout ();
    	 $ This-> _helper-> viewRenderer-> setNoRender (true);
     }
 }

Sitemaps kunnen snel en eenvoudig worden gegenereerd met behulp van Zend_Navigation , een geweldige snelle tutorial (en over het algemeen zeer nuttig voor het Zend Framework tutorials) is Zend Afgietsels - Dynamisch maken van een menu van een sitemap en paneermeel .

Reacties (8)

Door Steven Lloyd Watkin , vrijdag 1 januari 2010 22:40

Ik heb een follow-up gemaakt om dit bericht die minder configuratie vereist, zie module gebaseerd Lay-out - Zend Framework .

Bij gebruik van de Zend Framework met modules, haar duidelijk dat als u gebruik maakt van verschillende (sub-) sites uit dezelfde toepassing die u niet per se hetzelfde wilt lay-out scripts voor elk onderdeel. Ik besloot om te gaan met de volgende site structuur:

  / Toepassing
     / Controllers
         ...
     / Modellen
     / Modules
         / Default
             / Controllers
             / Lay-out
                 / Scripts
             / Uitzicht
                 / Scripts
         / AnotherModule
             ...
     / Scripts

Het probleem is het opzetten van de lay-out scripts op een per-module basis. Het antwoord kwam door het gebruik van een Action Helper. Het instellen van de lay-outs op een per-module basis bestaat uit drie stappen:

1. Application.ini (of soortgelijke configuratie-instellingen):
   

     admin.resources.layout.layoutPath = APPLICATION_PATH "/ modules / admin / layouts / scripts"
    default.resources.layout.layoutPath = APPLICATION_PATH "/ modules / default / layouts / scripts"
    member.resources.layout.layoutPath = APPLICATION_PATH "/ modules / member / layouts / scripts"
    affiliate.resources.layout.layoutPath = APPLICATION_PATH "/ modules / affiliate / layouts / scripts" 

2. Maak je Actie Helper:
   

     <? Php
    / **
     * Stelt de lay-out pad op een per-module basis
     *
     * @ Author Lloyd Watkin <lloyd@evilprofessor.co.uk>
     * @ Sinds 2010-01-01
     * /
    klasse Pro_Controller_Action_Helper_SetLayoutPath
        breidt Zend_Controller_Action_Helper_Abstract
    {
        / **
         * Sets lay-out pad op basis van module
         * /
        publieke functie preDispatch ()
        {
       	 $ Module = $ this-> GetRequest () -> getModuleName ();
   
   	     if ($ bootstrap = $ this-> getActionController ()
   	                        -> GetInvokeArg (bootstrap)) {
   
   	         $ Config = $ bootstrap-> getOptions ();
   
   	         if (isset ($ config [$ module] ['middelen'] ['layout'] ['layoutPath'])) {
   	             $ LayoutPath =
   	                  $ Config [$ module] ['middelen'] ['layout'] ['layoutPath'];
   	             $ This-> getActionController ()
   	                  -> GetHelper ('lay-out')
   	                  -> SetLayoutPath ($ layoutPath);
   	         }
       	 }
        }
    } 

3. En tot slot bootstrap de actie helper:
   

     ...
        / **
         * Stelt lay-out scripts op een per-module basis
         * /
        beschermde functie _initLayoutHelper ()
   	 {
   	     $ This-> bootstrap ('FrontController');
   	     $ Layout = Zend_Controller_Action_HelperBroker :: addHelper (
   	         nieuwe Pro_Controller_Action_Helper_SetLayoutPath ());
   	 }
    ... 

Reacties (6)

Door Steven Lloyd Watkin , Woensdag 30 December 2009 18:30

Ik heb moeite met het opzetten van een database schema voor een nieuw Zend Framework project. Ik ben gebruik probeert te gebruiken Doctrine ORM voor mijn database modellen. Ik moet het opzetten van het schema, zodat het me toegestaan ​​om een ​​standaard datum en tijd instellen voor een `datetime` kolom, bijvoorbeeld bij het toevoegen van een nieuw bericht krijg ik de huidige tijd. Na veel zoeken en experimenteren heb ik de oplossing gevonden dus ik ben te delen.

In uw schema YAML bestand gewoon het volgende doen:

 Bericht:
   actas:
     Timestampable:
       gecreëerd:
         naam: created_at
         type: timestamp
         formaat: jmd H: i: s
       bijgewerkt:
         naam: last_updated
         type: timestamp
         formaat: jmd H: i: s
   kolommen:
     id:
       type: integer
       primaire: true
       autoincrement: true
     name: String (255)
     e-mail: string (300)
     message: String (2000)

Als aan de andere kant u niet wilt dat een `updated_at` kolom kun je het volgende gebruiken:

 Bericht:
   actas:
     Timestampable:
       gecreëerd:
         naam: created_at
         type: timestamp
         formaat: jmd H: i: s
       bijgewerkt:
         mensen met een handicap: true
   kolommen:
     id:
       type: integer
       primaire: true
       autoincrement: true
     name: String (255)
     e-mail: string (300)
     message: String (2000)

Reacties (3)

Door Steven Lloyd Watkin , dinsdag 29 december 2009 22:02

Ik lees Head First Design Patterns onlangs hebben besloten om een ​​aantal van de patronen schrijven als PHP voorbeelden voor mijn eigen voordeel. De eerste die ik heb besloten om code is het Observer Pattern . De formele definitie van het Observer Pattern is:

De waarnemer patroon (een subset van de asynchrone publish / subscribe patroon ) is een software ontwerp patroon waarin een object , genaamd het onderwerp, houdt een lijst bij van de personen ten laste, de zogenaamde waarnemers, en deelt ze automatisch van een staat veranderingen, meestal door te bellen naar een van de methoden . Het wordt voornamelijk gebruikt om gedistribueerde event handling systemen te implementeren.

Als systemen steeds meer losjes gekoppelde ervoor te zorgen dat wanneer een gebeurtenis alle systemen die de kennis van deze updates nodig gebeurt hoogte worden gebracht. Bijvoorbeeld, een blog post, na het opslaan van een post moeten we wellicht een zoekmachine bij te werken (zoals Lucene), werken onze sitemap, tags, e-mail ingeschreven gebruikers, enz. De waarnemer patroon stelt ontwikkelaars in staat om extra luisteraars toe te voegen zonder het bewerken van hun waarneembare object . Door het injecteren van waarnemers (dat wil zeggen een zoekmachine update van waarnemer, een sitemap generator, etc) in een onderwerp (dat wil zeggen blog post editing systeem) kunnen we toestaan ​​dat de aan de nodige updates uit te voeren zonder enige veranderingen.

Continue reading 'PHP Design Patterns - Observer Pattern' »

Reacties (2)

Door Steven Lloyd Watkin , vrijdag 04 december 2009 23:59

Introductie

Ik werk in een bedrijf waar we lopen veel batch jobs verwerken van miljoenen records van de gegevens elke dag en ik heb onlangs na te denken over alle machines die zitten elke dag niets doen voor meerdere uren. Zou het niet goed zijn als we konden gebruiken deze machines om de rekenkracht van onze systemen te versterken? In deze reeks artikelen zal ik kijken naar de mogelijke voordelen van de tewerkstelling van een kantoor raster met behulp van gevirtualiseerde omgevingen.

In deel 3 hebben we onze virtuele machine en het opzetten van Windows-machines te worden idle-time werknemers.

Het uitvoeren van de laatste code

Het is onvermijdelijk dat na het maken van uw werknemers business logica zal veranderen, bugs worden gevonden, zal sneller meer efficiënte code worden geproduceerd waardoor het verlaten van uw werknemers zaten rond het verwerken van gegevens met behulp van oude stinkende code . Hoe dan zorgen we ervoor dat we altijd de nieuwste en beste versie van onze verwerking scripts gebruiken?

Er zijn een paar zeer eenvoudig eenvoudige manieren kunnen we dit doen, de truc is echter om processing power en netwerk verkeer terug te dringen om dit te bereiken. Laten we beginnen met de eenvoudigste van oplossingen en langzaam het over een paar iteraties te verbeteren.

De eerste methode zou zijn om gewoon verbinding te maken met ons werk control server (via samba, FTP, of iets dergelijks) en naar beneden trek de laatste versie van de code. Niet erg efficiënt, maar het zal het werk doen. Laten we verbeteren op dat enigszins, wat dacht je van het creëren van een rsync script en het gebruik van dat elke keer dat in plaats daarvan? Of wat te denken van zetten onze laatste verwerking script in subversie het controleren van de code in eerste instantie en dan gewoon updaten van onze code op elke run ( svn update )?

Uiteindelijk konden we eindigen met een bash-script (genoemd door cron elke 10 minuten), dat ziet er zo simpel als dit:

  #! / Bin / sh
 als ps ax | grep-v grep | grep php > / dev / null
 dan
     echo "Job is momenteel het verwerken, afslag"
 anders
     echo "Job niet wordt uitgevoerd, nu beginnen"
     cd / pad / naar / werken / kopiëren
     svn update
     php yourJobProcessingScript.php
 fi 

Nu kunnen we er zeker van zijn dat bij elke ronde we zeker bent van de laatste code draait. We zijn ervoor zorgt dat dit door een aanpassing van onze code base elke keer we een run en het verminderen van het netwerkverkeer door alleen de overdracht van het bestand verschillen tussen ons netwerk.

In mijn demonstratie setup, ik deed precies zoals hierboven. Subversion is geïnstalleerd op mijn werk verwerking server en ik gewoon trok de laatste code van een "werknemer" tak met 'svn update'. Ik heb ook een versienummer tag toe aan mijn verwerking script dat werd om de database terug als deel van de resultaten terug. Op deze manier kon ik zien dat mijn code werd elke keer als ik mijn koffer gekopieerd naar de werknemer tak dat wil zeggen dat ik zeker was de laatste verwerking script bijgewerkt.

Met behulp van de meest recente gegevens

Als uw baan verwerking wordt gebruik gemaakt van gegevensbronnen dan op een gegeven moment deze zullen ook worden bijgewerkt. Tenzij u contact opnemen met uw gegevensbronnen op een zeer zeldzaam basis je gaat om uw netwerk te overspoelen met verkeer zodra uw werknemers beginnen te lopen waardoor alles tot stilstand. Voor mijn oplossing heb ik besloten dat ik graag om te bewegen mijn gegevensbronnen met mijn VM's.

Houd je daar bent paarden! Wat als mijn bronnen zijn HUGE? Nou, dit is echt een kwestie van hoeveel data hebben we het? Het kan rendabeler om een extra grotere harde schijf te installeren in elke machine dan om een extra verwerking server te kopen. Dit is een kwestie van budget en is aan het bedrijf om te beslissen. Het misschien dat uw gegevens bronnen zijn zo groot dat het is gewoon niet haalbaar om die hoeveelheid gegevens bij te houden in uw werknemer machines. In dat geval wat zou jij doen? Wel konden we kijken naar het bellen van een lokale data server, maar dit kan leiden tot problemen met het netwerk. In dit geval een grid-systeem, zoals dit kan niet meer realistisch is om in uw kantooromgeving. Het kan ook zijn dat je kunt kijken naar alternatieve lopen strategieën, bijvoorbeeld alleen te bellen met uw werknemers tussen twintig en 6 uur per nacht en / of smoren gegevensbron verzoeken.

Bewegen op laten we zeggen onze bronnen bedraagt ​​100 GB aan gegevens. Nou ja dat is nogal wat gegevens om rond het netwerk te verplaatsen op een update. Hoe zouden we ervoor zorgen dat we de laatste kopie van de gegevens in dit geval hebben? Rsync is een mogelijkheid, maar persoonlijk denk ik dat door het uitvoeren van uw meest recente gegevensbron op uw werk verwerking server en het instellen van deze als een meester in het replicatie (met een mooie lange bak log) kan de weg te gaan zijn:

Door het instellen van elk van uw werknemers als een slaaf van de job control server updates om uw gegevens te bronnen zal mooi doorsijpelen naar uw werknemers zonder een enorme toename van de netwerkactiviteit (dat wil zeggen, tenzij u een enorme data update en al uw werknemers te schoppen in in een keer). Dit heeft voordelen ten opzichte van rsync in dat u niet een lange pauze voor elke taak, gelijk als de database-updates, de MySQL daemon op uw werknemer zal voortdurend geactualiseerd zijn gegevens, terwijl de verwerking wordt voortgezet.

Dit is hoe ik mijn demonstratie-server. Voor het instellen van replicatie volgde ik de gids op de MySQL site ( Het opzetten van replicatie ) en binnen 20 minuten had ik mijn aanvankelijke werknemer repliceren van de job control servers dataset. Voor elke extra werknemer van de replicatie-instellingen en het proces werkte elke keer als de VM werd gekopieerd.

Overzicht

In dit deel van het artikel hebben we gekeken naar hoe gemakkelijk en pijnloos het is om uw verwerking code up-to-date door using rsync of subverion (SVN) om het werk te doen en het netwerkverkeer te verminderen op hetzelfde time. We hebben ook besproken hoe om uw gegevensbron informatie up-to-date te houden door het te laten doorsijpelen aan elk van uw werknemers. Zo kunnen we ruimte ervoor te zorgen dat we gelijke tred te houden met de business logica en informatie in ons kantoor draagconstructie. Er zullen uiteraard tal van alternatieven voor het uitvoeren van deze taken, maar hier waren twee eenvoudige voorbeelden om te laten zien hoe makkelijk een oplossing te komen.

Volgende keer

In het laatste deel van deze serie, toepasselijke naam deel 5 bespreken we de implementatie van dit systeem voor. Ik zal een samenvatting van wat er is geleerd en wat ik wist te maken.

Reacties (3)

Door Steven Lloyd Watkin , vrijdag 04 december 2009 23:37

Introductie

Ik werk in een bedrijf waar we lopen veel batch jobs verwerken van miljoenen records van de gegevens elke dag en ik heb onlangs na te denken over alle machines die zitten elke dag niets doen voor meerdere uren. Zou het niet goed zijn als we konden gebruiken deze machines om de rekenkracht van onze systemen te versterken? In deze reeks artikelen zal ik kijken naar de mogelijke voordelen van de tewerkstelling van een kantoor raster met behulp van gevirtualiseerde omgevingen.

In deel 2 hebben we gekeken naar de taken van een server loopt, en hoe werk moet worden geconfigureerd om de grootste hoeveelheid van de verwerking te bereiken en daarbij te zorgen dat elke opdracht wordt verwerkt zonder mankeren.

Het instellen van uw werknemer - of slap server

De volgende stap in het proces is het opzetten van uw virtuele werknemers. Voor deze ga ik een installatie van CentOS met behulp van VirtualBox te gebruiken. Ik ga installeren MySQL en PHP op de server, ook wel bekend als een slap (Li nux, m ySQL, P HP) Servera (ik heb die naam boven).

• Installeer VirtualBox op uw Windows-machine (volg link)
• Download en CentOS (huidige versie 5.3) te installeren in een virtuele machine gemaakt

Het heeft geen zin mij gaat dit er waarschijnlijk 1000 's van de grote tutorials die er zijn (ok, hier is een: maken en Managing CentOS virtuele machine onder virtualbox ). Het belangrijkste punt om op te merken denk ik, is dat ik belde mijn virtuele machine GridMachine.

Wat mijn keuzes van virtualisatie-client en het besturingssysteem te gaan is er geen grote dwingende reden voor elke keuze. VirtualBox is iets wat ik op mijn eigen machine en wordt ondersteund door de drie grote besturingssystemen. Ik heb gekozen voor CentOS als een goede stabiele OS en ik gebruik het op mijn eigen webserver. Ik ben een groot voorstander van het juiste gereedschap voor de job (hoewel ik het toepassen van 'gebruik maken van de snelste en gemakkelijkste voor u' mentaliteit hier), dus als besturingssysteem X draait je code sneller en meer efficiënt te gebruiken dat in plaats :)

Belangrijk is ervoor te zorgen dat je VM DHCP gebruikt op andere wijze, voor elke nieuwe virtuele machine zou moeten apart worden geconfigureerd dat is iets wat we niet want.By gebruik maakt van DHCP we hoeven niet individueel te configureren netwerkinstellingen voor werknemer machines, zal DHCP overhandigen van IP's voor u. Daarom kunt u kopieert uw virtuele machine over het kantoor zonder zorgen te maken over het instellen van een ieder op (dit verbetert de schaalbaarheid en vermindert de werknemer administratie).

Het proces dat je moet streven te bereiken zou zijn om een ​​nieuwe fysieke machine, installatie VirtualBox te verkrijgen, en dan vrij veel inzetten het virtuele beeld zonder veel anders. Het kan verstandig zijn om al uw werknemers in te stellen op een ander subnet, zodat u kunt in ieder geval zien hoeveel machines draaien. U moet ook het instellen van uw machines op een erfpacht of een onbeperkte lease DHCP.

Hoe Jobs draaien op de werknemer

Dit is een interessant gebied en er zijn verschillende valide methoden voor de verwerking van taken van de werknemer. Hier zal ik alleen ingaan op de twee meest voor de hand liggende:

• Voortdurend uitgevoerd script: Een script, zij het een shell-script, of een PHP-script wordt eenmalig uitgevoerd op de werknemer en loopt als onderdeel van een oneindige lus. Ik heb verdisconteerd deze methode als een crash van het script en mogelijk uw medewerkers zullen houdt op te lopen zonder enige vorm van interventie.
• Cron op basis van het uitvoeren van scripts: elke x minuten de cron daemon start een oproep om je script om dingen te gaan. Zonder enige controle kan dit leiden tot vele, vele kopieën van uw werknemer script draait.

Mijn besluit was om te gaan met cron, die start een shell-script elke 10 minutes. mijn shell script voert de volgende taken:

1. Hier krijg je een lijst met processen en grep dit voor 'php'. Indien niet gevonden dan verder.
2. Bel uw taak-code, in mijn geval zou dit iets PHP zijn op basis
3. Worker script voltooid zijn run
4. Klaar om weer op de eerstvolgende oproep

Mijn bash script ziet er ongeveer als volgt:

  #! / Bin / sh
 als ps ax | grep-v grep | grep php> / dev / null
 dan
     echo "Job is momenteel het verwerken, afslag"
 anders
     echo "Job niet wordt uitgevoerd, nu beginnen"
     php yourJobProcessingScript.php
 fi 

Let op: de echo's zijn bijna volledig zinloos, maar kan de volgende persoon die langs komt om te proberen en te bewerken hen te helpen.

Hiermee zijn de opzet van de werknemer virtuele machine, snel, eenvoudig en makkelijk te kopiëren naar elk nieuw stuk hardware die wordt ontvangen. De 'slimheid' van het net is echt niet in de gevisualiseerde OS, zijn allemaal te maken met de code het leven geroepen om te banen, de baan configuratie, en ervoor te zorgen dat het werk wordt uitgevoerd indien van toepassing (dwz wanneer de host is niet actief ).

Het opzetten van Windows voor de werknemers initialiseren

De eerste taak is het uitwerken van de opdracht nodig is om de virtuele machine te lopen vanaf de Windows-opdrachtregel. Als u hebt geïnstalleerd VirtualBox in de standaard locatie en je hebt de naam van uw werknemer GridMachine vervolgens de opdracht nodig is om te laden van uw werknemer:

  "C: \ Program Files \ zon \ VirtualBox \ VBoxManage.exe" startvm GridMachine 

Maar om het script uit te voeren in een 'headless' staat die we moeten gebruiken:

  "C: \ Program Files \ zon \ VirtualBox \ VBoxHeadless.exe"-startvm GridMachine - vrdp = uit 

Dit start de virtuele machine zonder de GUI en laat het elegant op te slaan staat. Het tweede argument gaat uit RDP, zodat het niet in strijd is met Windows RDP, of geeft u een boodschap over te luisteren op poort 3389. De virtuele machine is hoofdlettergevoelig!

Vervolgens zullen we moeten ramen zetten de aftrap voor onze werknemer VM nadat de machine inactief is geweest. Om deze (op Windows XP) heb je nodig hebt om te gaan Start -> Alle Programma's -> Bureau-accessoires -> Systeemwerkset -> Geplande Taken zoals hieronder:

Klik vervolgens op 'Geplande taak toevoegen', gevolgd door bladeren naar een aangepast programma toe te voegen. Navigeer naar uw VBoxManage script en klik op ok. Plan uw taak voor een van de opties (we zullen dit te veranderen in een minuut) en ga verder. Na het overslaan van het volgende scherm Windows zal u vragen wie u deze taak uit te voeren, zou ik voor een 'Administrator' of het creëren van een nieuwe bevoorrechte gebruiker. Onthoud, wij willen niet met de standaard personeel account op de machine mengen op elk gewenst punt. Klik op volgende en controleer Toon geavanceerde opties voor deze taak.

Naar het einde van de run tekstvak toe te voegen onze 'startvm GridMachine' string en zorg ervoor dat run alleen wanneer ingelogd wordt gelaten afgevinkt. Bezoek de planning taak naast en verander het schema naar beneden, naar de optie 'idle', kies dan de hoeveelheid tijd die u wilt dat de machine inactief moet zijn voordat u naar het volgende tabblad.

Tot slot uitvinken van de optie die stelt De taak stoppen als deze is het draaien van X hoeveelheid tijd, maar de optie om de taak te stoppen als de machine is niet meer actief aan te vinken.

Dat is het dan voor de Windows host setup!

Overzicht

In dit deel hebben we het opzetten van een virtuele machine op te treden als een werknemer, maar ook de manier waarop we noemen en uit te voeren ons werk verwerking van scripts (voor mezelf een PHP-script). Vanaf hier kijken we naar hoe het opzetten van onze kopieën van Windows op te starten van de virtuele machine in headless mode als de computer inactief is, en sla de staat wanneer de gebruiker weer gebruik van de machine. Hopelijk op dit punt je ziet hoe eenvoudig het is het opzetten van een dergelijk systeem en staan ​​te popelen om nog wat experimenten gaan zelf!

Volgende keer

In deel 4 kijken we naar het gebruiken van hulpmiddelen om ervoor te zorgen dat u de laatste versie van de code en gegevensbronnen draaien en dat de verkregen resultaten zijn altijd up-to-date met de nieuwste zakelijke informatie en logica.

Reacties (1)

Door Steven Lloyd Watkin , vrijdag 04 december 2009 23:23

Introductie

Ik werk in een bedrijf waar we lopen veel batch jobs verwerken van miljoenen records van de gegevens elke dag en ik heb onlangs na te denken over alle machines die zitten elke dag niets doen voor meerdere uren. Zou het niet goed zijn als we konden gebruiken deze machines om de rekenkracht van onze systemen te versterken? In deze reeks artikelen zal ik kijken naar de mogelijke voordelen van de tewerkstelling van een kantoor raster met behulp van gevirtualiseerde omgevingen.

Als PHP ontwikkelaar Ik ga tools die ik gebruik, namelijk elke dag, Linux, gebruik maken van MySQL , PHP, VirtualBox en Subversion (SVN). Maar ik hoop dat deze gids aan te passen aan andere talen en technologieën net zo goed.

De oplossing I leveren zal losjes gebaseerd op de aard van de behandeling zouden we moeten echter hiertoe niet waar is door de gehele voorwerp als ik dingen veranderen eenvoud of meer interessante gebruik's te produceren.

Deze gevirtualiseerde omgevingen zal draaien op Windows-computers, omdat dit is wat de meerderheid van de kantoren uit te voeren. De verwerking dat de kantoormachines doen mag niet interfereren met het personeel het gebruik van deze machines, moet de verplichting geen onderhoud aan de machine, en makkelijk inzetbaar om nieuwe machines als ze beschikbaar zijn. Ook mag nieuwe virtuele machines vereisen geen extra configuratie, omdat dit sterk vermindert de schaalbaarheid en het gemak waarmee het net kan worden verlengd.

Waarom implementeren van een Office Computing Grid?

Ten eerste denk je misschien, waarom niet gewoon gebruik maken van een cloud computing bron, zoals EC2-platform van Amazon ? Wel redenen kan meerdere, bijvoorbeeld:

• Je zal niet toevertrouwen bepaalde gegevens aan een cloud computing-omgeving
• Je kunt het niet bepaalde gegevens in een cloud computing-omgeving om juridische redenen (bijvoorbeeld gegevens het verlaten van het land), mogelijk om juridische redenen, bijvoorbeeld NHS records.
• U wilt uw verwerkingseenheden te dicht en hebben volledige controle over de hardware
• U heeft niet het project middelen om cloud instances draaien
• Uw kantoor heeft geen verbinding met het internet en dus haar niet mogelijk om een ​​wolk gebruik van hulpbronnen
• Je hebt geen regen, wolken regen suggereren, dus je blijft uit de buurt

Ik weet zeker dat de lijst zou kunnen blijven, maar ik denk dat is genoeg voor nu.

Voordelen van een Office-Computing Grid

Nou, laat doen wat wiskunde (en in echte fysica stijl kunt maken wat vegen aannames). Stel je voor hebben grote vlezige verwerking server met 100 opdrachten per dag. In uw kantoor u 50 machines die niet actief 16 uur per dag hebben, elk van deze machines is 10% zo krachtig als je vlezige verwerking Sever. (Alle resultaten hier zijn afgerond om de prestaties te verhogen onderschatten).

Dus, 1 machine * 10% vermogen * 2/3 tijd = 0,067 dwz 1 desktop verwerking in idle-tijd zou kunnen verwerken 6 volledige banen per dag.

Als u nu schalen dit tot het duurt 15 ruststand desktops om zo veel opdrachten per dag te verwerken als uw belangrijkste verwerkende server doet.

Dus in ons doen alsof kantoor van 50 machines konden we verhogen onze processing power van 1 server tot 4 volledige verwerking van servers, of we kunnen de verwerking van 400 arbeidsplaatsen per dag in plaats van 100.

Let op, zonder investeringen in nieuwe hardware van uw bedrijf heeft zojuist verhoogde zijn batch-verwerking capaciteit 4 keer! Potentieel je gaat om je energieverbruik te verhogen, maar van de meeste kantooromgevingen Ik ben al naar machines zijn over het algemeen links op 's nachts toch, dus je kon zien dit als een groen initiatief.

Andere voordelen ook betekenen dat investeringen in nieuwe (of bijgewerkt) de verwerking servers kunnen worden uitgesteld als uw kantoormachines toereikend zijn en dat als je het verbeteren van de kracht van uw kantoormachines uw kantoor netwerk wordt krachtiger automatisch.

Technologies

Wat heb je nodig? (Of beter gezegd wat heb ik gebruikt):

• Idle kantoormachines (in mijn geval een reserve oude Windows XP laptop)
• VirtualBox (of een ander virtualisatie-client-software)
• Een virtuele machine met PHP, MySQL running het runnen van een omgehakte OS, ik bel deze mijn slappe servers :)
• Jobs te lopen
• Job server (kan een andere virtuele machine ergens)

Typische Jobs

De aard van de jobs die dit systeem is ontworpen om te draaien is als volgt:

• System ontvangt een lijst met gegevens waarop we nodig hebben aan te passen en terug te keren resultaten
• Matching gaat om het controleren / zoeken verschillende (redelijk statisch) gegevensbronnen
• Resultaten van gegevensbronnen kan verdere validatie, het samenvoegen, het controleren van de aanvullende gegevens bronnen in reactie op de resultaten
• De gegevens worden terug met overeenkomende records, volledig gevalideerd en verwerkt
• Elke record in een baan is onafhankelijk van de rest

Dus eigenlijk zijn we op zoek bij het runnen van banen die een mengsel van database lookups en wat rekenwerk, een vrij typisch scenario in een zakelijke omgeving vereisen.

Raster oplossingen niet alleen voordelig voor het verwerken banen van dit type. In principe kan elk proces kan worden gesplitst in zelfstandige eenheden worden uitgevoerd in parallel. Zie deze wikipedia voor voorbeelden en meer informatie: Grid Computing , maar een aantal beroemde voorbeelden zijn Seti @ Home en BIONC . Er zijn kaders voor het uitvoeren van computer netwerken, en deze zijn zeker de moeite waard op zoek naar.

Wat zullen we bereiken?

Tegen het einde van deze artikelen hoop ik aan te tonen dat de implementatie van een kantoor rooster hoeft niet enorm duur of tijdrovend. Ik ga om te bespreken:

• Het opzetten van de baan controlesysteem, het scheppen van de configuratie
• Het creëren van een juiste verwerking virtuele machine
• Hoe het systeem in te stellen op een windows machine
• Zorgen voor u de meest recente code en gegevens met behulp van
• Deployment en benchmarking
• Vooruitkijkend

Ik zal bouwen (ok ik heb gebouwd, dan heeft deze software geschreven) een voorbeeld aanvraag in bij de concepten te testen op een lokale machine met Windows XP en mijn 'GridMachine' virtuele machine. Mijn taak controle-server zal mijn voornaamste machine die draait zijn Fedora 11 .

Dit is op geen enkele manier bedoeld om een ​​volledig werkend robuust systeem te demonstreren, zijn betekende meer van een demonstratie en het bespreken waaruit blijkt dat deze dingen kunnen worden bereikt in een redelijk korte tijd en tegen weinig kosten. Aarzel niet om mij opmerkingen, correcties of verbeteringen en ik zal mijn best doen om dit artikel aan te passen bijgewerkt te houden te doen.

Volgende keer

In deel 2 zal ik beginnen door te kijken naar het werk controlesysteem, en kijk hoe banen moeten worden geconfigureerd om de grootste hoeveelheid van de verwerking te bereiken en daarbij te zorgen dat elke opdracht wordt verwerkt zonder mankeren.

Reacties (1)

Door Steven Lloyd Watkin , vrijdag 04 december 2009 23:23

Introductie

Ik werk in een bedrijf waar we lopen veel batch jobs verwerken van miljoenen records van de gegevens elke dag en ik heb onlangs na te denken over alle machines die zitten elke dag niets doen voor meerdere uren. Zou het niet goed zijn als we konden gebruiken deze machines om de rekenkracht van onze systemen te versterken? In deze reeks artikelen zal ik kijken naar de mogelijke voordelen van de tewerkstelling van een kantoor raster met behulp van gevirtualiseerde omgevingen.

In deel 1 heb ik een overzicht van het systeem en technologieën zal ik gebruik maken en gesproken over een aantal van de mogelijke redenen waarom je zou willen om een kantoor netwerk te creëren.

Job Control

Als je gaat worden uitgevoerd banen dan zul je een manier om ze te beheren nodig hebben. Het is jouw taak besturingssysteem (op je werk server) moet echt goed worden doordacht voordat zelfs maar te proberen om een ​​kantoor raster uit te voeren. Dus in de eerste plaats, wat zijn de taken voor een job control systeem:

• Uitdelen banen op verzoek van werknemers
• Vertel werknemers wat voor soort banen te lopen
• Track jobs
• Zorg ervoor dat alleen banen worden eenmaal uitgevoerd
• Zorg voor job data voor de werknemers, of op zijn minst vertellen waar het te krijgen

Het systeem moet ook uitbreidbaar, een oplossing die werkt voor nu in een enkel geval kan worden uitgebreid tot verschillende soorten van het werk als het bedrijf te runnen ziet de waarde in een raster oplossing. Bijvoorbeeld, banen kunnen prioriteiten te winnen, meer dan een baan type kan bestaan ​​(dat wil zeggen meerdere code bases), uiteindelijk je kan zelfs draaien op verschillende machines werknemer die zijn geoptimaliseerd voor elk type baan (hoewel dat niet af te stappen van de 'generieke werknemer 'idee). Probeer altijd om na te denken over de toekomst bij het ontwikkelen van systemen, kan een korte termijn visie leiden tot langere termijn frustratie en meer ontwikkelingstijd.

Job Server

We gaan ergens nodig hebben om onze banen te bedienen vanaf, moet dit het enige systeem in uw netwerk, dat een vaste Resource Locator heeft, zijn dat een IP-adres, de hostnaam, de URL (met behulp van interne DNS), enz. Dit komt omdat de werknemers moeten weten waar je moet zoeken naar banen, werknemers moeten om de klus te controlesysteem (niet de taak besturingssysteem vinden van de werknemers) te vinden.

De job server zelf niet echt een ingewikkelde taak hebben (in een basis systeem hoe dan ook), moet het een lijst van taken op te slaan, met de hand uit banen, de resultaten te ontvangen en ze vervolgens op te slaan voor later gebruik. Hoe deze onderdelen (zoals 'hand uit banen') worden gedefinieerd kan zeer basic. Later kunnen we het systeem uitbreiden tot een administratie-interface toe te voegen, bewerken, verwijderen, op te schorten banen, maar dit is buiten deze oefening op te nemen.

Er is geen enkele reden dan is dat uw werk-server niet kon worden van een virtuele machine draaien binnen uw hoofdzone voor de verwerking server die het niet te veel middelen uitlekken van. De job server Wel dient er een hoge beschikbaarheid, als hij onderuit gaat op een vrijdag avond ga je een heel weekend van de verwerking te verliezen, mogelijk kost je een paar weken ter waarde van verwerkingstijd (in vergelijking met uw belangrijkste verwerking server alleen) . Misschien wilt u overwegen om uw werk-server op een load balanced omgeving voor hoge beschikbaarheid.

Basic Setup

De basis set-up voor ons werk server zal bestaan ​​uit wat ik bellen naar een van mijn slappe servers (dat is Li nux, m ySql, P HP). De code die op thee werknemers ook daadwerkelijk uit te werken welke taken het kan draaien door interactie met met job besturingssysteem databases. Later konden we een web service en eigenlijk uitdelen banen in plaats van de arbeiders doen het harde werk zelf, maar voor nu zullen we blijven maken van het KISS principe (Keep It Simple, Stupid!).

Dus, laat u drie mySQL tabellen om te gaan met banen. Dit zijn `werk`, `jobRecords`, en `jobResults`.

Hier ben ik met behulp van SQL Buddy een grote kleine alternatief voor phpMyAdmin , alleen maar omdat het makkelijker te installeren op CentOS (voor anderen te zien: 10 Great alternatieven voor phpMyAdmin )

Deze tabel bestaat uit 5 eenvoudige velden,

• id: een unieke identificatie van de baan
• naam: Kan een klant referentie, of een aantal andere identificatiegegevens
• Status: Je moet weten waar de baan is, bijvoorbeeld
  • 0: Niet gestart
  • 1: Opgehaald
  • 2: Voltooid
• started_by: Wie is begonnen met het doen van de baan? Dit is niet helemaal nodig, maar is een mooie aanvulling zijn. Ik stel voor het bijhouden van werknemers door hun IP-adres op je netwerk
• started_at: Wanneer heeft de werknemer start de baan? Door het volgen van banen die nog niet zijn afgerond binnen X tijd weten we dat we nodig hebben op te halen de baan weer en de verwerking te beginnen door een andere werknemer. Werknemers zouden stoppen met het verwerken / offline gaan voor een aantal redenen, stroomuitval, crash, netwerk verlies, enz.

Het is gemakkelijk is de manier waarop deze tabel kan worden uitgebreid met een paar extra velden toe te staan ​​voor statistieken bijhouden, een eindtijd kolom te zien hoe lang het werk heeft, een teller om te zien hoeveel werknemers pakte de baan (uiteraard dit moet de neiging om 1), job prioriteit, kan de lijst doorgaan. In meer complexe klus scenario's zou het mogelijk zijn om aan te geven hoeveel geheugen de werknemer zou toegang nodig te hebben (en dus gebruik alleen geschikte werknemers), of zelfs wat voor soort werknemer nodig zou zijn.

Laten we nog een paar voorbeeld vacatures:

De volgende tabel weer is vrij eenvoudig te begrijpen, dat zijn onze job records. Ze zijn gekoppeld aan de belangrijkste taken tafel door een kolom `jobs_id`. De make-up van deze tabel is sterk afhankelijk van de gegevens die u nodig heeft om te leveren aan uw medewerkers, laat een heel eenvoudig voorbeeld, waar we vier kolommen:

• id: ID van het record
• naam: naam van de persoon
• adres: Persoon adres van
• jobs_id: De functie ID dat dit record is gekoppeld aan

De derde en laatste tafel bestaat uit een tabel met resultaten, het heeft ongeveer dezelfde make-up als onze gegevens tafel, en met de toevoeging van een aantal kolommen zou kunnen zijn een deel van de records tabel:

• job_record_id: Koppel het resultaat aan het werk tafel
• resultaat: Het resultaat data

... En dat is alles wat je nodig hebt voor het scheppen van controle! (Zij het op een zeer basaal niveau) In mijn geval ben ik wees naar een andere tafel waar mijn gegevens te verwerken was gevestigd, maar dit kan net zo goed geweest een bestand, parameters om simulatie-code uit te voeren, noem maar op.

Het selecteren van een job

Zoals eerder vermeld, de arbeiders zal het onze taak het beheer voor ons doen voor nu, dus alles wat we nodig hebben om echt te doen is het vinden van een baan dat de verwerking nodig heeft en krijgt de informatie. Hoe zouden we dat doen? Nou halen onze taak selectiecriteria en zoek naar banen, in SQL heb ik het volgende:

1. Neem een ​​willekeurige opdrachten die niet zijn gemarkeerd als compleet, maar van onze werknemers en stel ze opnieuw (vervang __ ME__ met een identifier, gemakkelijkste zou IP-adres):

    UPDATE `werk` SET `status` = 0 WHERE `status` = 1 AND `started_by` = __ ME__; 

2. Met behulp van onze job selectiecriteria, selecteert u een opdracht en vertel het besturingssysteem dat deze werknemer te maken heeft met het:

     UPDATE `werk` SET `status` = 1, `started_by` = __ ME__, `started_at` = NOW () WHERE `status` = 0 of
    (`Status` = 1 AND `started_at`> DATE_SUB (NU (), INTERVAL x uur)) ORDER BY `id` ASC; 

   Door grijpen taken die niet tot resultaten hebben geleid terug in X hoeveelheid tijd zorgen we ervoor dat alle taken worden uitgevoerd in het geval van een werknemer crashen of gaan AWOL.

3. Vervolgens pak je de banen gegevens, gevolgd door de documenten zelf:

     SELECT * FROM `vacatures` WHERE `started_by` = __ ME__ LIMIT 1;
    SELECT * FROM `job_records` WHERE `id` = __ JOBID__; 

Na voltooiing van het werk dat wij voegen ons resultaat records en markeer de taak als voltooid. Vergeet niet als opdrachten kunnen suspend / resume te allen tijde zorgen voor een aantal robuustheid in het script. Het kan zijn dat de taak halverwege onderbreekt door het vernieuwen van de job controle systeem, dus het controleren van het aantal records in een baan en het aantal resultaten terug opgeslagen in het werk controlesysteem zou het een verstandige zet te zijn.

Daarnaast, terwijl dit toont aan hoe taken kunnen worden geselecteerd en beheerd vanuit een SQL-query frame dat u moet echt worden abstraheren je baan controle, zodat als je besluit over te schakelen naar het gebruik van een web service, een bestand gebaseerd systeem, XML , of enige andere aantal systemen is geen invloed op de code erboven.

Job Configuratie

Het volgende aspect dat aandacht verdient is het werk grootte en de configuratie. Door te spelen met werk-configuratie kunnen we slaan een uitstekende balans tussen snelheid, proces-replicatie, en betrouwbaarheid. Neem een ​​paar ofa scenario's:

1. Jobs neemt een dag per uit te voeren: Dit betekent dat uw werknemers 15 dagen nodig hebt om elke taak te verwerken (denk aan 10% van het vermogen voor 2/3e van de tijd). Dit is niet duidelijk een wijs configuratie, je baan grootte is veel te groot! Het zou op zijn minst het dubbele van de tijd om een ​​baan verwerkt moeten de eerste werknemer gaat AWOL (tijd op te halen dat het niet een plus opwerking tijd terug). In een ideale zou je ten minste een volledige functiebeschrijving gemakkelijk goedgekeurd door het einde van elke lange tijd niet gebruikt, op die manier je de banen tikt te houden over en in het ergste geval een baan zou twee dagen duren om te verwerken moet de eerste vermist.
2. Jobs neemt een minuut te lopen: Dit betekent dat uw werknemers ongeveer 15 minuten te nemen om elke taak uit te voeren. Hoewel dit in eerste instantie kan ideaal lijken, kunt u extra werk verwerking te krijgen tijdens de lunch, koffiepauzes, vergaderingen, enz. dit scenario zet druk op andere gebieden van uw systeem en introduceert zijn eigen problemen. Bijvoorbeeld, in de eerste plaats je setup / verwerkingstijd verhouding gaat naar rechts naar beneden gaan, dus het verliezen van het systeem efficiëntie. Uw netwerk zal voortdurend streaming taak informatie aan de verschillende werknemers frustrerend medewerkers die dong hun dagelijkse werk. Je bent ook gaan om meer spanning op je werk verwerking server als het moet schotel uit heel veel kleine stukjes van het werk op een regelmatige basis. Tot slot, in deze situatie als de taak de server down gaat je gaat een enorme achterstand van onvoltooid werk dat de grotere klussen kunnen van voortgezet verwerking zalig niet van bewust dat de klus server werd moeilijkheden ondervindt te creëren.

In werkelijkheid zal er geen een ideale configuratie voor uw netwerk setup zijn, hangt veel af van de beschikbare middelen, soorten werk, job doorlooptijd eisen, netwerkcapaciteit, en ga zo maar door. Maar een aantal richtlijnen zijn:

• Grootte opdrachten zo, dat elke werknemer kan krijgen door middel van minimaal 3-4 banen in een periode van 15 uur (de langste waarschijnlijk inactieve periode)
• Speel met hoe groot de opdracht, zodat setup-tijd wordt vrij onbeduidend in vergelijking met de verwerking tijd (rekening houdend met het bovenstaande punt).
• Als een opdracht niet volledig in het dubbele van de hoeveelheid tijd (misschien minder) je verwacht dat het voltooien ervan uit dat haar verdwenen AWOL en beginnen met de verwerking door een andere werknemer. Dit betekent dat u moet wachten tot drie keer de normale lengte van een baan voor het in te vullen (eventueel langer als de daarop volgende taak niet). U kunt deze tijd te beperken, maar wees voorzichtig niet te verminderen te veel als je kan beginnen dupliceren verwerking van taken op een regelmatige basis.
• Banen moet onafhankelijk zijn van eisen zoveel mogelijk. Het werk-server, bijvoorbeeld, mogen alleen gecontacteerd worden op het begin en einde van elke opdracht.
• Niet je netwerk te verzadigen, zal dit twee negatieve gevolgen zal hebben, zal je overdag personeel te vinden met behulp van het netwerk frustrerend en problemen kunnen worden ervaren met aansluitingen time-out een probleem dat alleen maar erger wordt als je schalen je raster.
• Zorg ervoor dat taken kunnen uitvoeren op uw werknemers. Als taken worden te veel geheugen of schijfruimte intensieve banen zal beginnen afbreken en het enige wat je zal opvallen is een daling van aantal banen verwerkt met geen echte reden waarom.

Overleggen van de resultaten van een baan

Bij indiening van de resultaten van een baan is het belangrijk om te controleren of de resultaten niet zijn ingediend door een andere werknemer, zeker als de huidige werknemer slapende al enige tijd.

Wanneer resultaten dienen ervoor te zorgen dat het aantal resultaten dat het aantal records dat overeenkomt met in de taak.

Zoals eerder, en kan niet genoeg benadrukt worden, bouwen fout-tolerantie in printopdrachten en resultaten onderwerping. De arbeiders kunnen (en waarschijnlijk zal) gaan in slaapstand op de meest ongelegen tijden en dit moet worden verzorgd. Ook weer abstraheren weg uw resultaten inzending zal helpen inspelen op toekomstige veranderingen in uw werk besturingssysteem veel gemakkelijker te behandelen.

Overzicht

In deze section hebben we gekeken naar wat een baan controle-server moet doen en hoe je een zeer fundamentele opgezet. We bespraken hoe je een opdracht uit het besturingssysteem en de beste manier om banen te configureren om het behouden van uw kantoor net in te halen. Om te eindigen, werd een paragraaf of twee aan overleggen van de resultaten terug naar de job control server gepresenteerd.

• Een job controle-server beheert banen en zorgt ervoor dat alle werk-eenheden zijn afgerond
• Door te abstraheren van uw taak te selecteren / resultaten indiening kunnen we de technologie van de controle-server zonder veel problemen
• Stel uw taken om ervoor te zorgen dat ze snel en efficiënt uit te voeren zonder te veel druk op uw netwerk infrastructuur, en zonder doublures verwerking taken op een regelmatige basis.
• Zorg ervoor dat u fouttolerantie en opstaan ​​checking in uw routines op te bouwen, kunnen werknemers op te schorten en te hervatten en de meest ongelegen tijden. Vergeet niet om te controleren of er reeds is ingediend door een andere werknemer.

Volgende keer

In deel 3 gaan we creëren onze virtuele machine en het opzetten van onze Windows-machines te worden idle-time werknemers.

Reacties (3)

Door Steven Lloyd Watkin , vrijdag 04 december 2009 23:03

Introductie

Ik werk in een bedrijf waar we lopen veel batch jobs verwerken van miljoenen records van de gegevens elke dag en ik heb onlangs na te denken over alle machines die zitten elke dag niets doen voor meerdere uren. Zou het niet goed zijn als we konden gebruiken deze machines om de rekenkracht van onze systemen te versterken? In deze reeks artikelen zal ik kijken naar de mogelijke voordelen van de tewerkstelling van een kantoor raster met behulp van gevirtualiseerde omgevingen.

In deel 4 hebben we gekeken naar het gebruik van gereedschap om ervoor te zorgen dat we de laatste versie van de code en gegevensbronnen draaien en dat de verkregen resultaten zijn altijd up-to-date met de nieuwste zakelijke informatie en logica.

Pre-implementatie

Voor het inzetten van je grid-systeem als er een ding dat je doet en een ding alleen al is het benchmarken van uw huidige systeem! Het maakt niet uit wat je collega's over hoeveel extra werk het systeem gaat doen, tenzij je nummers van deze back-up van uw garanties te vertellen zijn niets. Dus,

• hoeveel records kunt u op dit moment te verwerken? Per dag? Per uur?
• Hoe lang duurt het normaal gesproken te nemen om te draaien een baan?
• Hoe veel meer capaciteit hebt u?

Er is ook aanvullende vragen:

• Als de verwerking van de server (of een van uw verwerking servers) naar beneden gaat hoe zal dit invloed hebben op uw mogelijkheden, wordt u kreupel?
• Welke voordelen hoop je / verwacht te krijgen van een grid-systeem?
• Zijn uw kantoor machines die het uitvoeren van de taken?
• Zijn uw (of kunt u banen worden omgezet) om wrok in deze stijl van draaien?

Het laatste belangrijke punt is om je tijd te nemen bij alle andere grote verandering als deze. Update uw verwerking van code aan de slag met de nieuwe methodiek, benchmark opnieuw. Mogelijk het instellen van uw verwerking server naar een virtuele machine draaien, na al uw verwerking server zal gewoon een andere werknemer (slechts een zeer krachtig een relatief). Laat het nieuwe proces om zich te vestigen.

Deployment

Mijn suggestie zou zijn om pop in het kantoor een weekend alle installaties en installatie uit te voeren. Doe dit net voor vakantie van twee weken en laat zo andere arme vent om te gaan met de gevolgen ... misschien ook niet ...

Inzet voor een dergelijk systeem moet langzaam. Ondanks dat het relatief eenvoudig op te zetten dit systeem zal invloed hebben op uw hele kantoor infrastructuur (zowel de digitale een). Ten eerste, uit te rollen naar een paar machines op een moment, monitor netwerkverkeer, de manier waarop de werknemer hosts uit te voeren op een dag-tot-dag basis. Het kan nodig zijn om uw werk te kunnen veranderen naar aanleiding van uw bevindingen.

Zodra het systeem heeft afgedaan met een paar machines (laten we zeggen 10% van alle kantoormachines, dat wil zeggen 5) houden toezicht op het netwerkverkeer en de host machine performance. Volgende maatstaf weer, moet je nu de verwerking van 33% meer arbeidsplaatsen dan de eerste benchmarks. Controleer of dit zo is, of dat je in ieder geval in deze orde van grootte. Zo niet, dan onderzoeken wat er aan de hand voordat u verder gaat. Herhaal deze cyclus tot je gelukkig alle kantoormachines draaien zonder het doden van de individuele prestaties van de machine of slijpen van uw netwerk tot stilstand.

Te allen tijde te houden benchmarking, zelfs nadat alle implementaties worden gemaakt. Controleer hoe de nieuwe code-updates snelheid van uw systeem beïnvloeden, controleer dan alle werknemers rapporteren in en verwerken van orders. Langzaam (heel langzaam), verhoog uw baan configuratie om het beste te halen uit uw werknemers en netwerk.

Stop!

Wat als u wilt dat uw werknemers niet meer vertoond op een bepaald moment? Ze zijn allemaal die er lopen, regenereren, en proberen hun best om de gegevens als hongerige insecten te verwerken. Het antwoord lijkt vanzelfsprekend, maar zijn waarde toe te voegen voor het geval dat haar over het hoofd gezien. Bewerk uw verwerking script met een exit (0) or die () of een andere verklaring aan uw verwerking van job te doden. Een belangrijke reden waarom we altijd proberen om te updaten naar de laatste verwerking script voordat er een run!

Demonstratie System

Met het oog op deze set van korte artikelen heb ik een heel klein rooster aan de technologieën en methodologieën aan te tonen te schrijven. Ik lees veel artikelen, tutorials, en gebruikt verschillende instrumenten te installeren en wat er gaande was op de monitor. In geen geval heb ik uitgegaan en verzadigd een hele kantoor met verkeer en noch heb ik toegang had tot een vaste medewerkers PC om te zien hoe gastheer prestatie werd beïnvloed.

Mijn demonstratie systeem was zeer bescheiden inderdaad. Ik gebruikte mijn gewone desktop opgezet als een baan controle server. Op deze had ik geïnstalleerd MySQL server geïnstalleerd opgezet als een meester in replicatie, PHP , Â en SVN met elkaar verbonden door apache (voor toegang via werknemer VM).

I then created a centOS worker machine on VirtualBox on a 6 year old windows XP laptop. I setup scheduled tasks as specified after copying the VM onto the machine and let it go.

The virtual machine was set up with PHP, subversion, and mySQL. I checked out a branch named 'worker' from my job control servers repository and made sure it could be updated using 'svn update'. Next I setup mySQL as a slave and checked that data was replicating from mySQL on the job control server down to the worker VM. After all this I setup the bash script and the cron job.

Mijn verwerking script eigenlijk ging langs de lijnen van deze (zeer eenvoudige dingen):

• Read in the name field
• Counted the number of similar names in a table from the data source held on the VM
• Counted the number of names as above but splitting the name by spaces (ie forename, middle, surname)
• Repeated this process 1,000 times

Each job took approximately 20 minutes to run. At one point I opened several copies of the worker VM on the windows laptop and watched the jobs be checked off by each of the worker IP addresses. At this point I also confirmed that replication automatically restarted.

Leaving the laptop to idle resulted in a worker starting to process jobs from the job control server. When resuming laptop usage there was a delay of about 30-60 seconds, this is a fair amount of time and staff would need to be made aware that their machine may pause for a short while when returning to the machine. Nieuwere machines kunnen niet over een pauze van deze lange. The benefit of the amount of processing performed by these machines during idle periods would more that outweigh staff members having to wait a short period (say 1 minute) on arriving at their machines of a morning (I frequently wait longer that this for a Windows Defender update to take place) provided they were made aware of this (useful time to grab a morning coffee!).

Overall I feel confident that I have demonstrated the technologies that could be used to create such a system. I have shown that such a system does work on a (very) small scale and with some more experimenting could be scaled up utilise the resources of an office's machines. Als ik niet op het punt om dit te doen zou ik zeer geïnteresseerd om te weten / als iemand anders het doet zien.

Conclusions / Evaluation

The next obvious step would be to actually get a real world example and start to deploy a system such as this within an office environment and see what happens. Asking a business to commit to this without a trail blazing company to prove the technology and effectiveness may be a little difficult. Grid / Distributed computing is erg populair is sommige kringen en heeft een aantal grote applicaties (BIONC, SETI @ Home, Folding @ Home, etc). I did not, however, find a smaller scale and simple system like this in my searches that could be rolled out within an office environment.

I created a basically free system using mostly open source software and tools available in almost any office. The technologies were basically demonstrated and show to perform and work as expected. Hopefully I have show that with not much work and with a very simple setup you can deploy an office grid computing system that is powerful, cheap, and scalable all at the same time.

Once a system is up and running there is almost no end to the amount of customisation and improvements you can make. Bijvoorbeeld statistiek / benchmarking eenvoudig worden toegevoegd die de waarde van een dergelijk systeem dagelijks. Nieuwe machines kunnen snel en gemakkelijk worden toegevoegd en wanneer ze komen met upgrades van bestaande hardware versterking van je processing power.

I hope you've enjoyed reading this series of articles and its given you food for thought on running an office grid system. The solution presented here won't necessarily work in all situations but should be adaptable to allow you to get your data processing done using your own solution.

Aarzel niet om mij opmerkingen, correcties of verbeteringen en ik zal mijn best doen om dit artikel aan te passen bijgewerkt te houden te doen.