Commentaires (4)

Par Steven Lloyd Watkin , Mercredi 6 Janvier 2010 00h13

Afin de demandes directes de / sitemap.xml à un contrôleur de la coutume et l'action dans votre Zend Framework d'application il suffit d'ajouter les éléments suivants dans votre fichier de configuration ou de application.ini alternatives (par exemple, j'utilise navigation.ini):

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

Exemple de code pour la sortie peut être vu par la création d'une action dans le contrôleur approprié (par exemple, mon sitemap réside dans le contrôleur de l'indice, l'action sitemap):

 < php
 Classe IndexController
     étend Zend_Controller_Action
 {
     / **
      * Rend un plan du site basée sur la configuration Zend_Navigation
      * /
     sitemapAction fonction publique ()
     {
    	 echo $ this-> view-> Navigation () -> plan du site ();
    	 $ This-> view-> layout () -> disableLayout ();
    	 $ This-> _helper-> viewRenderer-> setNoRender (true);
     }
 }

Sitemaps peut rapidement et facilement être généré en utilisant Zend_Navigation , un bon tutoriel rapide (et généralement très utile pour les tutoriels Zend Framework) est Zend plâtres - créer dynamiquement un menu un sitemap et la chapelure .

Commentaires (8)

Par Steven Lloyd Watkin , Vendredi 1er Janvier 2010 22h40

J'ai créé un suivi à ce poste qui nécessite moins de configuration, s'il vous plaît voir la disposition des modules base - le Zend Framework .

Lorsque vous utilisez le Zend Framework avec des modules, son évident que si vous utilisez différents (sous-) sites au large de la même application que vous ne voulez pas nécessairement les mêmes scripts configuration pour chaque partie. J'ai décidé d'aller avec la structure du site suivant:

  / Application
     / Contrôleurs
         ...
     / Modèles
     / Modules
         / Par défaut
             / Contrôleurs
             / Mise en page
                 / Scripts
             / Vues
                 / Scripts
         / AnotherModule
             ...
     / Scripts

Le problème a été mise en place des scripts de disposition sur une base par module. La réponse est venue grâce à l'aide d'une aide d'action. Mise en place les mises sur une base par module comprend trois étapes:

1. Application.ini (ou procédure de configuration similaire):
   

     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 / membres / layouts / scripts"
    affiliate.resources.layout.layoutPath = APPLICATION_PATH "/ modules / affilié / layouts / scripts" 

2. Créez votre aide d'action:
   

     <? Php
    / **
     * Définit le chemin tracé sur une base par module
     *
     * @ Author Lloyd Watkin <lloyd@evilprofessor.co.uk>
     * @ Depuis 2010-01-01
     * /
    Classe Pro_Controller_Action_Helper_SetLayoutPath
        s'étend Zend_Controller_Action_Helper_Abstract
    {
        / **
         * Définit le chemin aménagement basé sur le module
         * /
        preDispatch fonction publique ()
        {
       	 $ Module = $ this-> getRequest () -> getModuleName ();
   
   	     if ($ bootstrap = $ this-> getActionController ()
   	                        -> GetInvokeArg («bootstrap»)) {
   
   	         $ Config = $ bootstrap-> getOptions ();
   
   	         if (isset ($ config [$ module] ['ressources'] ['layout'] ['layoutPath'])) {
   	             LayoutPath $ =
   	                  [Module $] $ config ['ressources'] ['layout'] ['layoutPath'];
   	             $ This-> getActionController ()
   	                  -> GetHelper ("layout")
   	                  -> SetLayoutPath (layoutPath $);
   	         }
       	 }
        }
    } 

3. Et enfin boostrap l'aide d'action:
   

     ...
        / **
         * Met en place des scripts sur une mise en page par module
         * /
        protégée fonction _initLayoutHelper ()
   	 {
   	     $ This-> bootstrap ('frontController');
   	     $ Layout = Zend_Controller_Action_HelperBroker:: addHelper (
   	         nouvelle Pro_Controller_Action_Helper_SetLayoutPath ());
   	 }
    ... 

Commentaires (5)

Par Steven Lloyd Watkin , Mercredi 30 Décembre 2009 18:30

J'ai été aux prises avec la mise en place un schéma de base pour un nouveau Zend Framework projet. Je suis utilisant d'essayer d'utiliser Doctrine ORM pour mes modèles de bases de données. J'ai besoin de mettre en place le schéma afin qu'il m'a permis de fixer une date et heure par défaut pour un `datetime` colonne, par exemple lorsque vous ajoutez un nouveau message je obtenir le timestamp courant. Après de longues recherches et d'expérimentation que j'ai trouvé la solution afin que je le partage.

Dans votre schéma YAML fichier simplement faire ce qui suit:

 Message:
   ActAs:
     Timestampable:
       créé:
         Nom: created_at
         Type: timestamp
         Format: Ymd H: i: s
       Mise à jour:
         Nom: LAST_UPDATED
         Type: timestamp
         Format: Ymd H: i: s
   colonnes:
     Identifiant:
       Type: entier
       primaires: vrai
       autoincrement: true
     Nom: string (255)
     courriel: string (300)
     message: String (2000)

Si d'autre part vous ne voulez pas une `updated_at` vous pouvez utiliser les éléments suivants:

 Message:
   ActAs:
     Timestampable:
       créé:
         Nom: created_at
         Type: timestamp
         Format: Ymd H: i: s
       Mise à jour:
         personnes handicapées: true
   colonnes:
     Identifiant:
       Type: entier
       primaires: vrai
       autoincrement: true
     Nom: string (255)
     courriel: string (300)
     message: String (2000)

Commentaires (3)

Par Steven Lloyd Watkin , Mardi 29 Décembre 2009 22:02

J'ai lu Head First Design Patterns récemment et ont décidé d'écrire quelques-uns des motifs comme des exemples de PHP pour mon propre bénéfice. Le premier que j'ai décidé de coder le modèle Observateur . La définition formelle du modèle Observateur est le suivant:

Le modèle d'observateur (un sous-ensemble de l'asynchrones publication / abonnement pattern ) est un logiciel de design pattern dans lequel un objet , appelé le sujet, maintient une liste de ses personnes à charge, a appelé les observateurs, et les informe automatiquement de tout changement d'État, généralement par téléphone un de leurs méthodes . Il est principalement utilisé pour mettre en œuvre des systèmes distribués de gestion des événements.

Comme les systèmes deviennent plus faiblement couplés en s'assurant que quand un événement se produit tous les systèmes qui exigent la connaissance de ces mises à jour sont informés. Par exemple, un billet de blog, après avoir enregistré un message nous pouvons avoir besoin de mettre à jour un moteur de recherche (par exemple, Lucene), mettre à jour notre plan du site, les tags, les utilisateurs de messagerie souscrit, etc Le modèle Observateur permet aux développeurs d'ajouter des écouteurs supplémentaires sans avoir à éditer leur objet observable . En injectant des observateurs (c'est à dire un moteur de recherche mise à jour observateur, un générateur de sitemap, etc) dans un sujet (blog-dire après l'édition du système), nous pouvons permettre de s'acquitter de l'ensemble des mises à jour nécessaires, sans aucune modification.

Continuer 'Design Patterns PHP - Modèle observateur «lecture»

Commentaires (2)

Par Steven Lloyd Watkin , Vendredi 4 Décembre 2009 11:59

Présentation

Je travaille dans une entreprise où nous courons le traitement batch de nombreux millions d'enregistrements de données chaque jour et j'ai pensé récemment à propos de toutes les machines qui sont assis autour de chaque et tous les jours à ne rien faire pendant plusieurs heures. Ce ne serait pas bien si on pouvait utiliser ces machines pour renforcer la puissance de traitement de nos systèmes? Dans cette série d'articles que je vais regarder les avantages potentiels d'employer un bureau de grille en utilisant les environnements virtualisés.

Dans la partie 3 nous avons créé notre machine de traitement virtuel et mettre en place les machines Windows de devenir inactif travailleurs à temps.

Exécution du dernier code

Inévitablement, après la création de votre logique métier travailleurs vont changer, les bugs seront trouvés, le code plus rapide et plus efficace sera produite laissant ainsi vos travailleurs assis autour du traitement des données à l'aide ancien code malodorants . Comment alors pouvons-nous nous assurer que nous sommes toujours en utilisant la dernière version du plus grand et de nos scripts de traitement?

Il ya quelques très facile des moyens simples que nous pouvions faire cela, le truc, cependant, est de réduire la puissance de traitement et le trafic réseau pour y parvenir. Commençons par le plus simple des solutions et il s'améliorer lentement sur une couple d'itérations.

La première méthode serait de tout simplement se connecter à notre serveur de contrôle d'emplois (via Samba, FTP, ou similaire) et tirer vers le bas de la dernière version du code. Pas très efficace, mais il faudra faire le travail. Permet d'améliorer ce peu, que diriez-vous de créer un script rsync et en utilisant à chaque fois que la place? Alternativement ce sujet mettant notre script de traitement plus tard dans la subversion vérifiant le code d'abord et ensuite seulement mettre à jour notre code sur chaque run ( svn update )?

En fin de compte on pourrait se retrouver avec un script bash (appelé par cron toutes les 10 minutes) qui est aussi simple que cela:

  #! / Bin / sh
 si ps ax | grep-v grep | grep php > / dev / null
 puis
     echo "l'emploi est en cours de traitement, la sortie"
 d'autre
     echo "Job ne fonctionne pas, commencer dès maintenant»
     cd / chemin / vers / travailler / copie
     svn update
     php yourJobProcessingScript.php
 fi 

Maintenant, nous pouvons être sûr que, avec chaque exécution, nous sommes définitivement tourner la dernière de code. Nous veillons à ce que cela en mettant à jour notre base de code chaque fois que nous effectuons une course et en réduisant le trafic réseau en transférant uniquement les différences de fichier à travers notre réseau.

Dans ma configuration de démonstration, j'ai fait exactement comme ci-dessus. Subversion a été installé sur mon serveur de traitement d'emplois et j'ai simplement tiré le dernier code à partir d'un «travailleur» en utilisant la branche 'svn update'. J'ai aussi ajouté un tag numéro de version à mon script de traitement qui a été retourné à la base de données dans le cadre du retour des résultats. De cette façon, j'ai pu voir que mon code a été mis à jour chaque fois que j'ai copié ma malle dans la branche des travailleurs à savoir que je n'étais définitivement l'exécution du script de traitement plus tard.

En utilisant les dernières données

Si votre traitement des tâches rend l'utilisation de sources de données, puis à un certain point ceux-ci vont être mis à jour aussi. Sauf si vous appelez de vos sources de données sur une base très rares que vous allez inonder votre réseau avec un trafic dès que vos travailleurs commencer à courir apportant tout à un arrêt. Pour ma solution, j'ai décidé que je voudrais passer mes sources de données avec mes machines virtuelles.

Tenez vous êtes des chevaux là-bas! Que faire si mes sources de données sont ÉNORMES? Eh bien c'est vraiment un cas de combien de données parlons-nous? Il peut être plus rentable d'installer un disque dur plus spacieux supplémentaires dans chaque machine que d'acheter un serveur de traitement supplémentaire. C'est une question de budget et appartient à l'entreprise de décider. Il se peut que vos sources de données sont si grands que c'est juste impossible de garder cette quantité de données dans vos machines travailleur. Dans ce cas, que feriez-vous? Eh bien, nous pourrions envisager d'appeler un serveur de données locales, mais cela pourrait provoquer des problèmes avec le réseau. Dans ce cas, un système de grille comme celle-ci peut devenir réaliste d'inclure dans votre environnement de bureau. Il se peut également que vous pouvez regarder dans les stratégies alternatives course, par exemple seulement appeler vos travailleurs 20 heures-six heures chaque nuit et / ou la limitation de requêtes de données source.

Déplacement sur le disons de nos sources de données s'élèvent à 100 Go de données. Eh bien oui, c'est un peu de données pour déplacer le réseau sur une mise à jour. Comment pourrions-nous nous assurer que nous avons de la dernière copie des données dans ce cas? Rsync est une possibilité, mais personnellement, je pense en exécutant votre source dernières données sur votre serveur de traitement d'emplois et de mettre cela en place comme un maître dans la réplication (avec un journal poubelle à long Nice) pourrait être la voie à suivre:

En fixant chacun de vos travailleurs comme un esclave pour les mises à jour d'emplois du contrôle serveur à vos sources de données sera retombée bien à vos travailleurs sans une énorme augmentation de l'activité du réseau (qui est moins que vous effectuez une mise à jour des données énormes et tous vos travailleurs coup de pied dans à la fois). Cela a des avantages sur rsync en ce que vous aurait pas une longue pause avant chaque emploi; que les mises à jour de bases de données, le mysql démon sur votre travailleur sera constamment mise à jour de ses données tandis que le traitement continue.

C'est ainsi que j'ai créé mon serveur de démonstration. Pour configurer la réplication, j'ai suivi le guide sur le site de MySQL ( Configuration de la réplication ) et dans les 20 minutes, j'ai eu mon agent inital reproduire le contrôle des tâches des serveurs jeu de données. Pour chaque travailleur supplémentaire les paramètres de réplication et de processus de travail chaque fois que la VM a été copié.

Résumé

Dans cette section de l'article, nous avons regardé comment facile et indolore, il est de garder votre code de traitement à jour par rsync using ou subverion (SVN) pour faire le travail et réduire le trafic réseau à la même time. Nous avons également discuté de la façon pour maintenir votre information de source de données mise à jour en lui permettant de couler vers le bas pour chacun de vos travailleurs. Ainsi, nous espace assurer que nous gardons avec la logique métier et de l'information dans notre système de quadrillage de bureau. Il y aura évidemment de multiples alternatives à la réalisation de ces tâches, mais voici deux exemples simples pour montrer avec quelle facilité une solution est à trouver.

Suivant le temps

Dans la dernière partie de cette série, bien nommé la partie 5 , nous allons discuter du déploiement de ce système pour. Je vais résumer ce qui a été appris et ce que j'ai réussi à créer.

Commentaires (3)

Par Steven Lloyd Watkin , Vendredi 4 Décembre 2009 23:37

Présentation

Je travaille dans une entreprise où nous courons le traitement batch de nombreux millions d'enregistrements de données chaque jour et j'ai pensé récemment à propos de toutes les machines qui sont assis autour de chaque et tous les jours à ne rien faire pendant plusieurs heures. Ce ne serait pas bien si on pouvait utiliser ces machines pour renforcer la puissance de traitement de nos systèmes? Dans cette série d'articles que je vais regarder les avantages potentiels d'employer un bureau de grille en utilisant les environnements virtualisés.

Dans la partie 2 nous avons regardé les emplois d'un serveur sera exécuté, et comment les emplois doivent être configurés afin d'atteindre le plus grand nombre de traitements tout en veillant à ce que chaque tâche est traitée sans échec.

Configuration de votre travail - ou d'un serveur LIMP

La prochaine étape dans le processus est de mettre en place vos travailleurs virtuels. Pour cela, je vais utiliser une installation de CentOS en utilisant VirtualBox. Je vais installer mySQL et PHP sur le serveur, aussi connu comme une boiterie (nux ​​Li, m ySQL, P HP) Servera (j'ai pu faire jusqu'à ce nom).

• Installer VirtualBox sur votre machine Windows (suivre le lien)
• Télécharger et installer CentOS (version actuelle 5.3) dans une machine virtuelle créée

Il est inutile de me passe à ce qu'il ya probablement 1000 's de tutoriels grand là-bas (OK, en voici une: Création et Managing CentOS machine virtuelle sous VirtualBox ). Le point important à noter est que je suppose que j'ai appelé ma machine virtuelle GridMachine.

Quant à mon choix du client de virtualisation et de système d'exploitation va il n'ya aucune raison convaincante pour chaque grande choix. VirtualBox est une chose que j'utilise sur mon ordinateur à domicile et est soutenu par les trois principaux systèmes d'exploitation. J'ai choisi CentOS comme un OS stable, bonne, et je l'utilise sur mon propre serveur Web. Je suis un grand croyant dans les bons outils pour le travail (même si je suis d'appliquer «l'utilisation la plus rapide et plus facile pour vous« la mentalité ici), donc si X système d'exploitation exécute votre code rapidement et plus efficacement utiliser à la place:)

Il est important de s'assurer que votre VM utilise le DHCP, sinon pour chaque nouvelle machine virtuelle aurait besoin d'être configurés séparément, ce qui est quelque chose que nous ne want.By utilisant DHCP nous n'avons pas besoin de configurer les paramètres réseau individuellement pour les machines des travailleurs, DHCP main IP pour vous. Par conséquent, vous pouvez copier votre machine virtuelle sur le bureau sans se soucier de la mise en place de chacun (ce qui améliore l'évolutivité et réduit l'administration travailleur).

Le processus que vous devriez viser à atteindre serait d'obtenir une nouvelle machine physique, installez VirtualBox, puis à peu près le déploiement de l'image virtuelle, sans beaucoup d'autre. Il pourrait être sage d'installer tous vos ouvriers sur un sous-réseau différent de sorte que vous pouvez au moins voir combien de machines sont en marche. Vous aurez également besoin de configurer votre machine sur un bail de longue ou illimitée bail DHCP.

Comment exécuter des tâches sur le travailleur

C'est un domaine intéressant et il ya plusieurs méthodes valables pour le traitement des travaux sur le travailleur. Ici, je vais juste parler des deux plus évidentes:

• Perpétuellement exécution de script: un script, que ce soit un script shell ou un script PHP est exécuté une fois sur le travailleur et s'exécute comme partie d'une boucle infinie. J'ai réduit cette méthode comme un accident du script et potentiellement vos travailleurs cesseront de courir sans une certaine forme d'intervention.
• L'exécution du script Cron base: toutes les X minutes le daemon cron coup d'envoi d'un appel à votre script pour faire avancer les choses. Sans quelques vérifications cela pourrait conduire à de nombreuses copies de votre exécution de script travailleur.

Ma décision était d'aller avec cron qui débutera un script shell toutes minutes. 10 Mon script shell effectue les tâches suivantes:

1. Obtenez une liste des processus et grep ce pour 'php'. S'il n'est pas trouvé avant de continuer.
2. Appelez votre code de travail, dans mon cas ce serait quelque chose en fonction PHP
3. Un script travailleur remplit sa course
4. Prêt à partir à nouveau sur le prochain appel appropriée

Mon script bash ressemble à quelque chose comme ce qui suit:

  #! / Bin / sh
 si ps ax | grep-v grep | grep php> / dev / null
 puis
     echo "l'emploi est en cours de traitement, la sortie"
 d'autre
     echo "Job ne fonctionne pas, commencer dès maintenant»
     php yourJobProcessingScript.php
 fi 

Remarque: le fait écho sont presque complètement inutile, mais peut aider la prochaine personne qui vient le long d'essayer de les modifier.

Cela conclut la mise en place de la machine virtuelle travailleur, rapide, simple et facile à copier à chaque nouveau morceau de matériel qui est reçu. Le «intelligence» du système de grille n'est pas vraiment dans le visualisés OS, son tout à voir avec le code créé pour traiter les tâches, la configuration d'emplois, et à faire en sorte que le travail s'exécute, le cas échéant (c'est à dire lorsque l'hôte est inactif ).

Configuration de Windows pour initialiser les travailleurs

La première tâche est de travailler à la commande nécessaire pour faire fonctionner la machine virtuelle à partir de la ligne de commande Windows. Si vous avez installé VirtualBox dans l'emplacement par défaut et que vous avez appelé votre GridMachine travailleur alors la commande nécessaire pour charger votre travailleur est:

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

Cependant, pour exécuter le script dans un «décapité» l'état, nous devons utiliser:

  "C: \ Program Files \ Sun \ VirtualBox \ VBoxHeadless.exe» startvm GridMachine - PRPPH = off 

Cela va démarrer la machine virtuelle sans l'interface graphique et lui permettre d'enregistrer l'état de grâce. Le second argument s'éteint RDP afin qu'il n'entre pas en conflit avec Windows RDP, ou vous donner un message à l'écoute sur le port 3389. Le nom de la machine virtuelle est sensible à la casse!

Ensuite, nous aurons besoin de mettre en place des fenêtres pour lancer notre VM travailleur une fois la machine a été ralenti. Pour ce faire (sous Windows XP), vous aurez besoin d'aller sur Démarrer -> Tous les programmes -> Accessoires -> Outils système -> Tâches planifiées comme suit:

Ensuite cliquez sur "Ajouter une tâche planifiée" suivie sur Parcourir pour ajouter un programme personnalisé. Accédez à votre script VBoxManage et cliquez sur OK. Programmez votre tâche pour l'une des options (nous allons changer cela en une minute) et continuer. Après sauter l'écran suivant Windows vous demandera qui vous voulez exécuter cette tâche, je vous suggère soit «Administrator» ou la création d'un nouvel utilisateur privilégié. N'oubliez pas que nous ne voulons pas interférer avec le compte personnel du standard sur la machine à tout moment. Cliquez sur Suivant et cochez la case Afficher les options avancées de cette tâche.

Pour la fin de la zone de texte exécuté ajoutez notre chaîne 'startvm GridMachine »et s'assurer que courir que lorsque vous êtes connecté est laissé décochées. Visitez la tâche prochain horaire et le changement du calendrier déroulant de l'option "en cas d'inactivité", choisissez la quantité de temps vous souhaitez que la machine soit inactif avant de passer à l'onglet suivant.

Enfin décocher l'option qui stipule arrêter la tâche si elle a été exécutée montant X de temps, mais ne cochez l'option pour arrêter la tâche si la machine n'est plus ralenti.

Ça y est alors pour la configuration d'hôte fenêtres!

Résumé

Dans cette partie, nous avons mis en place une machine virtuelle à agir en tant que travailleur, ainsi que la manière dont nous appeler et d'exécuter des scripts de traitement de notre travail (pour moi-même un script PHP). De là, nous regardons comment mettre en place nos copies de Windows pour démarrer la machine virtuelle en mode headless lorsque l'ordinateur est inactif, et enregistrer son état lorsque l'utilisateur reprend l'usage de la machine. Espérons à ce point que vous voyez combien il est simple à mettre en place un tel système et sont impatient de faire quelques expériences vous allez!

Suivant le temps

Dans la partie 4 , nous allons chercher à utiliser les outils pour s'assurer que vous utilisez la dernière version des sources de code et de données afin que les résultats obtenus sont toujours à jour avec les dernières informations d'affaires et de logique.

Commentaires (1)

Par Steven Lloyd Watkin , Vendredi 4 Décembre 2009 23:23

Présentation

Je travaille dans une entreprise où nous courons le traitement batch de nombreux millions d'enregistrements de données chaque jour et j'ai pensé récemment à propos de toutes les machines qui sont assis autour de chaque et tous les jours à ne rien faire pendant plusieurs heures. Ce ne serait pas bien si on pouvait utiliser ces machines pour renforcer la puissance de traitement de nos systèmes? Dans cette série d'articles que je vais regarder les avantages potentiels d'employer un bureau de grille en utilisant les environnements virtualisés.

En PHP développeur, je vais utiliser les outils que j'utilise chaque jour à savoir, Linux, mySQL , PHP, VirtualBox et Subversion (SVN). Cependant j'espère que ce guide va s'adapter à d'autres langues et des technologies tout aussi bien.

La solution que je fournis seront très vaguement basé sur le type de traitement que nous avions besoin pour atteindre cependant ce ne peut être vrai dans l'article en entier que je vais changer les choses pour plus de simplicité, ou pour produire des scénarios d'utilisation les plus intéressants.

Ces environnements virtualisés va fonctionner sur les machines Windows puisque c'est ce que la majorité des bureaux courir. Le traitement que les machines de bureau ne devrait pas interférer avec le personnel utilisant ces machines, devrait ne nécessitent aucun entretien à la machine, et être facilement déployable à de nouvelles machines à mesure qu'ils deviennent disponibles. Aussi, de nouvelles machines virtuelles ne devraient pas nécessiter aucune configuration supplémentaire car cela réduit considérablement l'évolutivité et la facilité avec laquelle le système de grille peut être prolongé.

Pourquoi déployer une grille de calcul Office?

Tout d'abord, vous pensez peut-être, pourquoi ne pas simplement utiliser une ressource de cloud computing tels que la plate-forme Amazon EC2 ? Bien des raisons pourrait être plusieurs, par exemple:

• Vous ne serez pas confier certaines données à un environnement de cloud computing
• Vous ne pouvez pas mettre certaines données dans un environnement de cloud computing pour des raisons légales (par exemple les données de quitter le pays), potentiellement, pour des raisons juridiques, par exemple les dossiers du NHS.
• Vous voulez garder vos unités de traitement à proximité et ont le plein contrôle sur le matériel trop
• Vous n'avez pas les fonds du projet pour exécuter les instances nuage
• Votre bureau n'a pas de connexion à l'internet et donc ce n'est pas possible d'utiliser une ressource nuage
• Vous n'aimez pas la pluie, les nuages ​​de pluie suggèrent donc vous gardez bien à l'écart

Je suis sûr que la liste pourrait continuer, mais je pense que ça suffit pour aujourd'hui.

Avantages d'un Grid Computing Bureau

Eh bien, laisse faire un peu de maths (et dans un style vraie physique permet de faire quelques hypothèses de balayage). Imaginez que vous avez grand serveur de traitement costaud courir 100 emplois par jour. Dans votre bureau, vous avez 50 machines qui sont inactifs 16 heures par jour, chacune de ces machines est de 10% plus puissant que votre traitement de rompre les costauds. (Tous les résultats ici sont arrondies à sous-estimer augmenter les performances).

Ainsi, une alimentation de la machine * 10% * 2 / 3 du temps de traitement = 0,067 soit 1 bureau dans les temps d'inactivité pourrait traiter six emplois à plein par jour.

Si maintenant vous ampleur de cette place qu'il faut 15 ordinateurs de bureau inactif pour traiter autant d'emplois par jour en tant que votre serveur de traitement principal ne.

Ainsi, dans notre bureau de faire semblant de 50 machines nous pourrions accroître notre puissance de traitement du serveur 1 jusqu'à 4 serveurs de traitement complet, ou nous pourrions être le traitement de 400 emplois par jour au lieu de 100.

Notez, par aucun investissement dans du nouveau matériel de votre entreprise vient d'augmenter sa capacité de traitement par lots 4 fois! Potentiellement vous allez augmenter votre consommation d'énergie mais de la plupart des environnements de bureau que j'ai été à des machines sont généralement laissés sur la nuit de toute façon, on pouvait voir cela comme une initiative verte.

D'autres avantages aussi signifier que l'investissement dans de nouvelles (ou mise à jour) des serveurs de traitement peut être retardé si vos machines de bureau sont suffisantes et que vous améliorez la puissance de vos machines de bureau de votre grille de bureau devient plus puissant automatiquement.

Technologies

Qu'est-ce que vous avez besoin? (Ou plus exactement ce que j'ai utilisé):

• Machines de bureau Idle (dans mon cas une pièce de rechange vieux Windows XP ordinateur portable)
• VirtualBox (ou un autre logiciel client de virtualisation)
• Une machine virtuelle avec PHP, mySQL running l'exécution d'un coupé OS, je vais appeler ces serveurs LIMP mon:)
• Emplois à courir
• Job Server (peut être une autre machine virtuelle, quelque part)

Emplois typiques

Les types d'emplois que ce système est conçu pour fonctionner comme suit:

• Système reçoit une liste de données sur lesquelles nous avons besoin de match et le retour des résultats
• Matching consiste à vérifier / chercher plusieurs (assez statique) sources de données
• Résultats à partir de sources de données peuvent nécessiter une validation plus poussée, la fusion, la vérification des sources de données supplémentaires en réponse aux résultats
• Les données sont retournés avec des enregistrements correspondants, entièrement validée et traitée
• Chaque enregistrement dans un travail est indépendant du reste

Donc, fondamentalement, nous cherchons à faire tourner des tâches qui exigent un mélange de recherches en base et quelques calculs numéro, un scénario assez typique dans un environnement des affaires.

Grille des solutions sont non seulement avantageux pour le traitement des emplois de ce type. Fondamentalement, tout processus qui peut être divisé en unités indépendantes peuvent être exécutés en parallèle. Voir cette wikipedia pour des exemples et plus d'informations: Grid Computing , mais quelques exemples célèbres sont Seti @ Home et BIONC . Il ya des cadres pour faire fonctionner les grilles de calcul, et elles sont bien dignes d'intérêt.

Que ferons-nous atteindre?

À la fin de ces articles, j'espère que pour montrer que le déploiement d'un réseau de bureaux ne doivent pas être extrêmement coûteux ou consomment du temps. Je vais discuter:

• Mise en place du système de contrôle des tâches de configuration d'emplois,
• Créer une machine virtuelle appropriée de traitement
• Comment installer le système sur une machine Windows
• Assurer que vous utilisez le dernier code et les données
• Le déploiement et l'analyse comparative
• Pour l'avenir

Je serai bâtiment (ok, j'ai construit, puis écrit ce) un exemple d'application pour tester les concepts sur une machine locale sous Windows XP et mon «GridMachine« machine virtuelle. Mon serveur de contrôle des travaux sera ma machine principale qui va de Fedora 11 .

Ce n'est en aucune façon pour but de démontrer un système entièrement fonctionnel robuste, son signifié plus d'une démonstration et discussion montrant que ces choses peuvent être réalisées dans un espace de temps relativement court et à peu de frais. S'il vous plaît, n'hésitez pas à m'envoyer vos commentaires, corrections ou améliorations, et je ferai de mon mieux pour garder cet article mis à jour pour correspondre.

Suivant le temps

Dans la partie 2 je vais commencer par regarder le système de contrôle du travail, et examiner comment les emplois doivent être configurés afin d'atteindre le plus grand nombre de traitements tout en veillant à ce que chaque tâche est traitée sans échec.

Commentaires (1)

Par Steven Lloyd Watkin , Vendredi 4 Décembre 2009 23:23

Présentation

Je travaille dans une entreprise où nous courons le traitement batch de nombreux millions d'enregistrements de données chaque jour et j'ai pensé récemment à propos de toutes les machines qui sont assis autour de chaque et tous les jours à ne rien faire pendant plusieurs heures. Ce ne serait pas bien si on pouvait utiliser ces machines pour renforcer la puissance de traitement de nos systèmes? Dans cette série d'articles que je vais regarder les avantages potentiels d'employer un bureau de grille en utilisant les environnements virtualisés.

Dans la partie 1 que j'ai donné un aperçu du système et des technologies, je vais utiliser aussi bien comme nous le verrons quelques-unes des raisons potentielles pour lesquelles vous voulez créer une grille de bureau.

Job Control

Si vous allez faire tourner les emplois, alors vous allez avoir besoin d'une certaine façon de les gérer. Votre système de contrôle du travail (sur votre serveur de travail) doit être vraiment bien pensé, avant même de tenter d'exécuter une grille de bureau. Donc premièrement, quelles sont les tâches d'un système de contrôle des tâches:

• Emplois sur la main sur demande auprès de travailleurs
• Dites travailleurs quel type d'emplois à courir
• Emplois piste
• Assurez-vous que les emplois ne sont exécutées une fois
• Fournir des données d'emplois pour les travailleurs, ou tout au moins leur dire où se le procurer

Le système doit également être extensible, une solution qui fonctionne pour l'instant dans un seul cas peut être prolongée d'exécuter plusieurs types d'emplois que l'entreprise voit la valeur dans une solution de la grille. Par exemple, les emplois peuvent gagner des priorités, plus d'un type d'emploi peuvent exister (c'est à dire de plusieurs bases de code), vous finirez peut même exécuter plusieurs machines différentes des travailleurs qui sont optimisés pour chaque type d'emploi (bien que cela s'éloigner de l'ouvrier «génériques 'idée). Toujours essayer de penser à l'avenir lors de l'élaboration des systèmes, une vision à court terme peut conduire à la frustration à long terme et le temps de développement accru.

Job Server

Nous allons avoir besoin de quelque part pour contrôler nos offres d'emploi de ce devrait être le seul système dans votre grille qui a une ressource fixe localisateur, que ce soit une adresse IP, nom d'hôte, URL (en utilisant le DNS interne), etc C'est parce que les travailleurs ont besoin de savoir où chercher un emploi, les travailleurs ont besoin de trouver le système de contrôle du travail (et non le système de contrôle d'emploi à trouver des travailleurs).

Le serveur poste lui-même n'a pas vraiment une tâche compliquée (dans un système de base de toute façon), il a besoin de stocker une liste d'emplois, la main sur l'emploi, de recevoir les résultats, et ensuite les stocker pour une utilisation ultérieure. Comment ces pièces (comme «la main sur des emplois») sont définis peuvent être très basiques. Plus tard, nous pouvons étendre le système pour inclure une interface d'administration pour ajouter, modifier, supprimer, suspendre emplois, mais c'est au-delà de cet exercice.

Il n'y a aucune raison que ce soit alors que votre serveur de travail ne pouvait pas être une machine virtuelle fonctionnant au sein de votre serveur de traitement principal à condition qu'il ne s'écoule pas trop de ressources d'elle. Le serveur d'emploi ne doivent toutefois une haute disponibilité, si elle descend sur un vendredi soir, vous allez perdre tout un week end de traitement, potentiellement vous coûter une couple de semaines de temps de traitement (par rapport à votre serveur de traitement principal seul) . Vous voudrez peut-être envisager de mettre votre serveur d'emplois sur un environnement à charge équilibrée pour une haute disponibilité.

Configuration de base

La configuration de base pour notre serveur d'emplois sera composée de ce que j'appelle un de mes serveurs LIMP (c'est-nux Li, m ySql, P HP). Le code s'exécutant sur les travailleurs thea fonctionnera réellement quels emplois il peut fonctionner en interaction avec des bases de données d'emplois de contrôle du système. Plus tard, nous pourrions créer un service web et fait distribuer des emplois plutôt que d'avoir des ouvriers faire le dur travail eux-mêmes, mais pour l'instant nous allons continuer à utiliser le principe KISS (Keep It Simple, Stupid!).

Alors, laisse créer trois mySQL tables pour faire face à l'emploi. Ces emplois seront ``, `jobRecords` et `jobResults`.

Ici, je suis en utilisant SQL amis une excellente alternative peu de phpMyAdmin juste parce que c'est plus facile à installer sur CentOS (pour les autres voir: 10 alternatives aux phpMyAdmin )

Ce tableau se compose de 5 champs simples,

• Identifiant: Conçus pour identifier l'emploi
• Nom: Pourrait être une référence client, ou n'importe quel nombre d'autres identificateurs
• Statut: Vous avez besoin de savoir où le travail est moins, par exemple
  • 0: Pas encore commencé
  • 1: Ramassé
  • 2: Terminé
• started_by: Qui a commencé à faire le travail? Ce n'est pas entièrement nécessaire, mais est une agréable d'avoir. Je vous suggère de suivi des travailleurs par leur adresse IP sur votre réseau
• started_at: Lorsque le travailleur ne commence le travail? En faisant le suivi des emplois qui n'ont pas terminé dans le montant X de temps, nous savons que nous devons ramasser les emplois une fois de plus et de commencer le traitement par un autre travailleur. Les travailleurs pourraient arrêter le traitement / go offline pour toutes sortes de raisons, une panne de courant, crash, perte de réseau, etc

Il est facile comment ce tableau pourrait être étendue avec quelques champs supplémentaires pour permettre le suivi des statistiques, une colonne de temps d'arrivée pour voir combien de temps le travail a pris, un compteur pour voir combien de travailleurs repris le travail (évidemment cela doit tendance à 1), priorité d'emploi, la liste peut continuer encore et encore. Dans les scénarios d'emplois plus complexes, il serait possible de spécifier la quantité de mémoire que le travailleur aurait besoin d'accéder à (et donc utiliser uniquement des travailleurs qui conviennent), ou même ce type de travailleurs serait nécessaire.

Permet d'ajouter un peu d'emplois par exemple:

Le tableau suivant est encore assez simple à comprendre, ce sont nos dossiers d'emploi. Elles sont liées à la table principale d'emplois par une colonne `jobs_id`. La composition de ce tableau dépend beaucoup des données que vous devez fournir à vos employés, permet de faire un exemple très simple où nous avons quatre colonnes:

• ID: ID de l'enregistrement
• Nom: Nom de la personne
• Adresse: adresse personne
• jobs_id: L'ID d'emplois que ce record est lié à

Le troisième et dernier tableau se compose d'une table de résultats, il a sensiblement la même représenter jusqu'à notre table les dossiers, et avec l'ajout de certaines colonnes pourrait faire partie de la table des dossiers:

• job_record_id: Link le résultat à la table de travail
• Résultat: Les données de résultat

... Et c'est tout ce dont vous avez besoin pour le contrôle de boulot! (Quoique à un niveau très basique) Dans mon cas, je suis a souligné une autre table où mes données à traiter a été localisé, mais cela pourrait tout aussi bien pu un fichier, les paramètres d'exécuter du code de simulation, you name it.

Sélection d'un emploi

Comme indiqué précédemment, les travailleurs ferons de notre gestion du travail pour nous pour l'instant, donc tout ce que nous devons vraiment faire, c'est de trouver un emploi qui nécessite un traitement et obtenir l'information. Comment ferions-nous cela? Eh bien choisir nos critères de sélection d'emploi et chercher un emploi, dans SQL, je ne les suivantes:

1. Prenez n'importe quel emploi qui ne sont pas marquées comme terminées, mais de nos travailleurs et les réinitialiser (substitut __ME__ avec un identifiant plus simple, serait d'adresse IP):

     UPDATE `emplois` SET `status` = 0 WHERE `status` = 1 et `started_by` = __ME__; 

2. En utilisant nos critères de sélection des tâches, sélectionnez un emploi et dire au système de contrôle que ce travailleur a affaire avec elle:

     UPDATE `emplois` SET `status` = 1, `started_by` = __ME__, `started_at` = MAINTENANT () WHERE `status` = 0 ou
    (`Status` = 1 et `started_at`> DATE_SUB (NOW (), heures d'intervalle X)) ORDER BY `id` ASC; 

   En récupérant des emplois qui ne sont pas retournés en résulte une quantité X de temps nous nous assurons que tous les emplois sont gérés dans le cas d'un travailleur ou d'aller s'écraser AWOL.

3. Suivant récupérer les détails d'emplois suivis par les documents eux-mêmes:

     SELECT * FROM `emplois` WHERE `started_by` = __ME__ LIMIT 1;
    SELECT * FROM `job_records` WHERE `id` = __JOBID__; 

À la fin de l'emploi, nous insérons nos dossiers résultat et indiquer que le travail le plus complet. N'oubliez pas que les emplois peuvent suspendre / reprendre à tout moment permettre une certaine robustesse dans votre script. Il se pourrait que la tâche suspend mi-chemin de la modernisation du système de contrôle du travail, donc vérifier le nombre d'enregistrements dans un emploi et le nombre de résultats enregistrées sur le système de contrôle du travail serait une sage décision.

De plus, tout cela démontre comment les emplois peuvent être sélectionnés et gérés à partir d'un cadre de requête SQL, vous devriez vraiment être abstraction de votre volonté d'emplois de sorte que si vous décidez de passer à l'aide d'un service Web, un système de fichiers basé, XML , ou tout autre nombre de systèmes de cela n'affectera pas le code au-dessus.

Configuration d'emploi

Le prochain aspect à considérer est la taille d'emploi et de configuration. En jouant avec la configuration de travail que nous pouvons trouver un excellent équilibre entre la vitesse, la réplication de processus et de fiabilité. Prenez un des scénarios OFA couple:

1. Emplois de prendre un jour de chaque lancer: Cela signifie que vos employés ont besoin de 15 jours pour traiter chaque tâche (souvenez-vous de 10% de la puissance pour 2/3rds de l'époque). Ce n'est clairement pas un sage de configuration, la taille de votre travail est beaucoup trop grand! Il faudrait au moins doubler le temps d'obtenir un emploi traitées si le travailleur initiales vont AWOL (le temps de ramasser ce qu'il n'a pas retourné un résultat plus le temps de retraitement). Dans l'idéal, vous auriez au moins un emploi à plein facilement dégagé par la fin de chaque longue période d'inactivité, de cette façon vous conserver les emplois et à retardement sur ​​le pire des cas un travail prendrait deux jours pour le premier processus devrait vont manquer.
2. Emplois prendre 1 minute pour lancer: Cela signifie que vos employés prennent environ 15 minutes pour effectuer chaque tâche. Bien que cela puisse paraître initialement idéal, vous gagnez le traitement du travail supplémentaire pendant l'heure du déjeuner, les pauses café, réunions, etc ce scénario met une pression sur d'autres domaines de votre système et introduit ses propres problèmes. Par exemple, tout d'abord votre ratio temps d'installation / de traitement va aller droit vers le bas, donc de perdre l'efficacité du système. Votre réseau va être en permanence en continu des informations d'emplois pour le personnel de divers travailleurs qui sont frustrantes dong de leur travail quotidien. Vous allez aussi de mettre plus de pression sur votre serveur de traitement d'emplois comme il l'a à plat sur des tas de petits morceaux de travailler sur une base régulière. Enfin, dans cette situation si votre serveur tombe en panne d'emplois que vous allez créer un journal de retour énorme de travail inachevé alors plus d'emplois pourraient poursuite de la procédure parfaitement inconscients que le serveur de travail connaît des difficultés.

En réalité, il n'y aura pas de configuration idéale pour une configuration de votre réseau, beaucoup dépend des ressources disponibles, les types d'exigences métier, les délais, la capacité du réseau, et ainsi de suite. Toutefois, certaines lignes directrices seraient:

• Taille d'emplois afin que chaque travailleur peut obtenir à travers au moins 3-4 dans une emplois période de 15 heures (la plus longue période probable temps d'inactivité)
• Jouer avec la taille du travail afin que les temps d'installation devient assez insignifiant par rapport au temps de traitement (en gardant à l'esprit le point ci-dessus).
• Si un travail ne se termine pas au double de la quantité de temps (peut-être moins) que vous attendez qu'elle soit terminée il supposer que son parti AWOL et commencer le traitement avec un autre travailleur. Cela signifie que vous pourriez avoir à attendre jusqu'à trois fois la durée normale d'un emploi qu'elle se termine (peut-être plus si le travail ultérieur échoue). Vous pouvez réduire ce temps, mais attention à ne pas le réduire trop car vous pouvez commencer à dupliquer les tâches de traitement sur ​​une base régulière.
• Jobs devrait être indépendant des exigences de l'extérieur autant que possible. Le serveur d'emplois, par exemple, ne devraient être contactés au début et à la fin de chaque travail.
• Ne pas saturer votre réseau, ce qui a deux effets négatifs, vos collaborateurs pendant la journée se trouve en utilisant le réseau de frustration et de problèmes peuvent être expérimentés avec des connexions moment sur un problème qui ne fera que s'aggraver à mesure que vous réduisez votre grille.
• Assurer des emplois peut fonctionner sur vos travailleurs. Si les emplois deviennent trop de mémoire emplois d'espace disque intensive ou intensive commencera avorter et la seule chose que vous remarquerez est une baisse du nombre de tâches traitées sans véritable raison.

Résultats Soumission d'un job

Lors de la soumission des résultats d'un travail, il est important de vérifier que les résultats n'ont pas été soumis par un autre travailleur, surtout si le travailleur actuelle est inactif depuis un certain temps.

Lorsque les résultats sont soumis s'assurer que le nombre de résultats correspondant au nombre d'enregistrements dans le travail.

Comme indiqué précédemment, et ne peut pas être surestimée, de construire la tolérance de panne dans la récupération d'emplois et la soumission des résultats. Les travailleurs peuvent (et très probablement) passer en mode suspend à la plus dérangeante des temps et cela doit être pris en compte. Aussi une fois de s'abstraire de votre soumission résultats aideront répondre aux futurs changements à votre système de contrôle du travail beaucoup plus facile à traiter.

Résumé

Dans cette Section A, nous avons regardé ce que un serveur de contrôle d'emplois doit faire et comment obtenir un système de base mis en place. Nous avons discuté de la façon de récupérer un travail à partir du système de contrôle et de la meilleure façon de configurer des travaux pour obtenir le maximum de votre système de quadrillage de bureau. Pour finir, un paragraphe ou deux sur la présentation des résultats vers le serveur de contrôle des travaux a été présenté.

• Un serveur de contrôle de tâche gère les emplois et garantit que toutes les unités de travail sont terminées
• En faisant abstraction de sélectionner votre travail / résultats de soumission que nous pouvons changer la technologie du serveur de contrôle, sans beaucoup de problèmes
• Configurez votre emploi afin de s'assurer qu'ils sont gérés rapidement et efficacement sans mettre trop de pression sur votre infrastructure réseau, et sans duplication des tâches de traitement sur une base régulière.
• Assurez-vous que vous construisez une tolérance aux pannes et de checking erreur dans vos routines, les travailleurs peuvent suspendre et reprendre et le plus incommode de fois. N'oubliez pas de vérifier si les résultats ont déjà été soumis par un autre travailleur.

Suivant le temps

Dans la partie 3 , nous allons créer notre machine virtuelle de traitement et de mettre en place nos machines fenêtres de devenir inactif travailleurs à temps.

Commentaires (3)

Par Steven Lloyd Watkin , Vendredi 4 Décembre 2009 23:03

Présentation

Je travaille dans une entreprise où nous courons le traitement batch de nombreux millions d'enregistrements de données chaque jour et j'ai pensé récemment à propos de toutes les machines qui sont assis autour de chaque et tous les jours à ne rien faire pendant plusieurs heures. Ce ne serait pas bien si on pouvait utiliser ces machines pour renforcer la puissance de traitement de nos systèmes? Dans cette série d'articles que je vais regarder les avantages potentiels d'employer un bureau de grille en utilisant les environnements virtualisés.

Dans la partie 4 , nous avons examiné en utilisant des outils pour s'assurer que nous sommes la dernière version des sources de code et de données afin que les résultats obtenus sont toujours à jour avec les dernières informations d'affaires et de logique.

Pré-déploiement

Avant de déployer votre système de grille, si il ya une chose que vous faites et une seule chose c'est de référence de votre système actuel! Peu importe ce que vous dites au sujet de combien collègues de travail supplémentaire de votre système va faire sauf si vous avez un nombre pour étayer cette thèse vos garanties ne sont rien. Ainsi,

• combien d'enregistrements peut vous traitez actuellement? Par jour? Par heure?
• Combien de temps faut-il habituellement à tourner autour d'un emploi?
• Combien plus la capacité de avez-vous?

Il ya aussi d'autres questions:

• Si votre serveur de traitement (ou un de vos serveurs de traitement) descend comment cela affectera vos capacités, vous serez paralysé?
• Quels avantages espérez-vous / attendre à obtenir à partir d'un système de grille?
• Vos machines de bureau capable d'exécuter les travaux?
• Sont vos (ou pouvez-vous être converti emplois) à travailler dans ce style de course?

Le dernier point important est de prendre votre temps sur tout changement majeur comme celui-ci. Mettez à jour votre code de traitement au travail en utilisant la nouvelle méthodologie, point de repère à nouveau. Peut-être configurer votre serveur de traitement d'exécuter une machine virtuelle, après tout votre serveur de traitement sera juste un autre travailleur (juste un très puissant relativement). Laisser le nouveau processus à régler.

Déploiement

Ma suggestion serait de pop dans le bureau un week-end effectuer toutes les installations et de configuration. Pour ce faire, juste avant quinze jours de vacances et de laisser d'autres si pauvres gars pour faire face aux conséquences ... peut-être pas ...

Déploiement d'un système comme celui-ci doit être lente. Malgré qu'il soit relativement simple à mettre en place ce système aura une incidence sur votre infrastructure de bureau entier (ainsi le numérique). Tout d'abord, rouler à un couple de machines à la fois, de surveiller le trafic réseau, comment les hôtes travailleur effectuer sur une base de jour en jour. Vous pouvez avoir besoin de modifier votre configuration d'emplois en réponse à vos résultats.

Une fois le système installé avec un peu de machines (disons 10% de toutes les machines de bureau, c'est à dire 5) continuer à surveiller le trafic réseau et l'ordinateur hôte de référence performance. à nouveau sur Suivant, vous devriez maintenant être le traitement des travaux de 33% de plus que votre premiers benchmarks. Vérifiez c'est le cas, ou que vous êtes au moins dans ce stade. Si non, enquêter sur ce qui se passe avant de repartir. Répétez ce cycle jusqu'à ce que vous avez joyeusement toutes les machines de bureau fonctionnant sans tuer les performances des machines individuelles ou de broyage de votre réseau à un arrêt.

En tout temps garder l'analyse comparative, même après tous les déploiements sont faites. Vérifiez la façon dont les mises à jour nouveau code affectent la vitesse de votre système, vérifier tous les travailleurs sont dans des rapports et le traitement des emplois. Lentement (très lentement) incrément de la configuration de votre poste pour obtenir le meilleur de vos travailleurs et votre réseau.

Stop!

Que faire si vous voulez arrêter vos travailleurs de courir à un certain moment? Ils sont tous là-bas courir, régénérantes, et en essayant de leur mieux pour traiter les données comme des insectes affamés. La réponse peut sembler évidente, mais sa valeur en ajoutant juste au cas où son négligé. Il suffit de modifier votre script de traitement avec une sortie (0) or die () ou une autre déclaration de tuer votre travail de traitement. Une raison importante pour laquelle nous essayons toujours de mettre à jour le script de traitement avant toute dernière course!

Système de démonstration

Pour écrire cette série de courts articles, j'ai créé une grille très petit pour démontrer les technologies et méthodologies. J'ai lu beaucoup d'articles, de tutoriels et de divers outils utilisés pour configurer et surveiller ce qui se passait. En aucun cas je n'ai sorti et saturée d'un bureau entier avec le trafic et je n'ai pas eu accès à un ordinateur personnel de membres réguliers pour voir comment la performance d'hôte a été affectée.

Mon système de démonstration a été très humble en effet. J'ai utilisé mon bureau ordinaire mis en place un serveur de contrôle d'emplois. Sur ce que j'avais installé mySQL serveur installé configuré comme un maître dans la réplication, PHP , A et SVN liés par Apache (pour l'accès via travailleur VM).

J'ai ensuite créé une machine CentOS travailleur sur VirtualBox sur un ordinateur portable de 6 ans windows XP. Je configurer les tâches planifiées comme spécifié après la copie de la VM sur la machine et laisser faire.

La machine virtuelle a été mis en place avec PHP, la subversion, et mySQL. J'ai vérifié une branche nommée «travailleur» à partir de mon contrôle serveurs référentiel emplois et fait en sorte qu'il pourrait être mis à jour en utilisant 'svn update'. Ensuite, j'ai configurer MySQL comme un esclave et vérifié que les données ont été répliquant de MySQL sur le serveur de contrôle d'emplois vers le VM travailleur. Après tout cela j'ai configuré le script bash et la tâche cron.

Mon script de traitement de fond est allé le long des lignes de ce (slideshows très simple):

• Lire dans le champ Nom
• Compté le nombre de noms similaires dans une table de la source de données stockée sur le VM
• Compté le nombre de noms que ci-dessus, mais le nom de fractionnement par des espaces (par exemple prénom, second prénom, nom)
• Répété ce processus 1000 fois

Chaque tâche a pris environ 20 minutes à courir. A un moment, j'ai ouvert plusieurs copies de la VM travailleur sur le portable sous Windows et regardé les emplois être coché par chacune des adresses IP des travailleurs. À ce stade, je confirme également que la réplication automatiquement redémarré.

Laissant l'ordinateur portable au ralenti abouti à un travailleur de commencer à traiter les travaux à partir du serveur de contrôle des travaux. Si on reprend l'utilisation ordinateur portable il y avait un retard d'environ 30-60 secondes, il s'agit d'une quantité considérable de temps et le personnel aurait besoin d'être mis au courant que leur machine peut s'interrompre pendant une courte période lors du retour à la machine. Les nouvelles machines ne peuvent pas avoir une pause de ce terme. Le bénéfice de la quantité de traitement effectué par ces machines durant les périodes d'inactivité serait plus que l'emportent les membres du personnel d'avoir à attendre une courte période (par exemple 1 minute) en arrivant à leurs machines d'un matin (j'ai souvent attendre plus longtemps que ce pour un Windows Defender mise à jour aura lieu) à condition qu'ils soient mis au courant de ce (temps utile de prendre un café le matin!).

Globalement, je suis convaincu que je l'ai démontré les technologies qui pourraient être utilisées pour créer un tel système. J'ai montré que ce système fonctionne sur une échelle de (très) petites et avec un peu plus de l'expérimentation pourrait être étendue utiliser les ressources des machines d'un bureau. Si je n'obtiens pas au point de le faire, je serais très intéressé de savoir / voir quand quelqu'un d'autre.

Conclusions / évaluation

La prochaine étape évidente serait de réellement obtenir un exemple du monde réel et de commencer à déployer un tel système dans un environnement de bureau et de voir ce qui se passe. Poser une entreprise à s'engager sur cette piste, sans une compagnie flamboyant pour prouver l'efficacité de la technologie et peut-être un peu difficile. Grille / Distributed computing est très populaire est certains milieux et a quelques grosses applications (BIONC, SETI @ Home, Folding @ Home, etc.) Je n'ai pas, cependant, trouver une plus petite échelle et un système simple comme ça dans mes recherches qui pourraient être mis en œuvre au sein d'un environnement de bureau.

J'ai créé un système fondamentalement libre en utilisant un logiciel de source ouverte et la plupart des outils disponibles dans presque n'importe quel bureau. Les technologies ont été essentiellement démontrée et montrer à réaliser et fonctionne comme prévu. J'espère avoir montrer que le travail n'est pas beaucoup et avec une configuration très simple, vous pouvez déployer un système informatique, bureautique, grille qui est puissant, bon marché, une et évolutive tout au même moment.

Une fois qu'un système est en marche il ya presque pas de fin à la quantité de personnalisation et d'améliorations que vous pouvez faire. Par exemple les statistiques / benchmarking peuvent facilement être ajoutés montrant la valeur d'un tel système chaque jour. De nouvelles machines peuvent être ajoutées facilement et rapidement comme et quand ils arrivent avec des améliorations apportées au matériel existant renforcer votre puissance de traitement.

J'espère que vous avez apprécié la lecture de cette série d'articles et de son donné matière à réflexion sur exécutant un système de grille de bureau. La solution présentée ici ne fonctionnera pas nécessairement dans toutes les situations, mais devrait être adaptable afin de vous permettre d'obtenir votre traitement de données fait en utilisant votre propre solution.

S'il vous plaît, n'hésitez pas à m'envoyer vos commentaires, corrections ou améliorations, et je ferai de mon mieux pour garder cet article mis à jour pour correspondre.

Commentaires (3)

Par Steven Lloyd Watkin , samedi 28 Novembre 2009 22h42

Mon employeur a récemment payé pour un groupe d'entre nous de prendre les développeurs de Zend Framework: Fondements bien sûr, ici, je vais résumer mes pensées et mes opinions sur le parcours pour les autres. Pour ceux qui cherchent à gagner du temps, voici mon résumé:

Pour les développeurs qui n'ont pas eu le temps de regarder le Zend Framework ce cours (Zend Framework: Fondamentaux) offre une bonne vue d'ensemble du cadre de vous présenter les principaux domaines et de donner suffisamment d'informations pour continuer. Pour ceux qui ont passé du temps à regarder le cadre et ont suivi un ou deux tutoriels ce cours n'offre pas beaucoup au-delà.

Contexte

J'ai été un PHP développeur pour environ 5-6 ans, et ont commencé à travailler avec le Zend Framework pour chaque composante au cours des 6 derniers mois. J'ai développé et / ou un développeur sur un couple de petits Zend Framework MVC sites. Je vais être honnête, je n'ai pas eu une énorme quantité d'exposition à d'autres cadres d'un point de vue du code, mais ont passé plusieurs heure des recherches sur les sites du projet et évaluer them.â Le cadre et la communauté environnante du Zend Framework, il est tout à fait passionnant et il semble y avoir des possibilités énormes dans où il va.

À propos du cours

Le cours est dispensé plus de 9 deux sessions WebEx heures (avec une pause de 10 minutes dans le milieu). Le temps est passé en passant par une série de diapositives fournies par Zend avec une discussion à tout moment. Vous pouvez utiliser un microphone pour parler à l'instructeur, mais pour être honnête, je n'ai vu personne utiliser autre chose que la fenêtre de chat. En plus d'une machine VMWare Ubuntu est fourni qui a des exemples de code et des projets mis en place une version d'essai a de Zend Studio. Les pourparlers animateur de cours aux participants soit plus d'une solution intégrée de VoIP, ou vous pouvez composer en utilisant l'une des nombreuses composer dans le monde en chiffres.

Au cours de la matière se compose d'un bref aperçu du cadre et le modèle MVC avant d'aller dans un exemple d'application le livre d'or. La discussion a démontré bootstrapping, Zend_Application, tables DB, la base de données d'accès, les formes, filtrage, ACL, Validation, etc, etc Fondamentalement couvrant tous les sujets que vous avais besoin pour obtenir un site de base jusqu'à une marche tout le temps en vous donnant les outils pour aller chercher plus avancés dans le cadre (bien que cela ne montant à 'Voir le site "la plupart du temps).

Temps est donné au code de quelques exemples, et de développer le «livre» et simple application «wiki». Personnellement je me suis senti que fournir le code ou chaque application et ensuite nous demander de développer ce qui était essentiellement une copie aux côtés n'a pas vraiment une bonne expérience d'apprentissage. J'aurais préféré pour développer une application similaire mais non identique. à l'exemple d'application avec l'avantage d'avoir un guide à consulter. Alternativement construire des applications à partir de zéro avec le démonstrateur serait d'éventuellement conduit à davantage de questions sur pourquoi et comment, donnant ainsi une meilleure compréhension du cadre, après tout, vous pouvez consulter les détails après le cours.

La dernière conférence a consisté à travailler sur l'application wiki avec l'aide / des conseils de l'instructeur. Après la rétroaction cours a été suivi, il a été souligné à plusieurs reprises à travers le cours que prend Zend commentaires très au sérieux, en fait, apparemment notre version de ce cours était tout à fait nouveau. Certains des autres développeurs de la société sera de suivre le cours dès sorte qu'il sera intéressant de voir si ce qui s'est passé.

Le style bien sûr était informelle, a permis pour la rétroaction et la collaboration entre les participants et le formateur. Le chef de cours a été conviviale, abordable (adresses e-mail ont été partagés pour les questions), et tandis que sa présentation de la glisse a été un peu fragile semblait pleinement compétente dans le cadre. Il était clairement quelqu'un qui a utilisé le cadre sur une base régulière plutôt que quelqu'un qui est appris à enseigner le cours, j'ai aimé l'expérience du «monde réel» à cet égard.

Sentiment général

D'une certaine manière j'ai trouvé le cours une perte de temps, dans d'autres elle était très pratique. J'espère que je vais obtenir mon raisons travers clairement, et peut-être apporter quelques éléments de réflexion ou de rétroaction utile (me connaissant il est peu probable!).

Pour moi ce cours était destiné à un niveau trop bas. Ayant passé par le guide de démarrage rapide, lisez Rob Allen Zend Framework in Action, et a travaillé avec le cadre un peu, je n'ai pas vraiment obtenir quelque chose trop. Je voudrais d'aimé le cours de ramasser de la fin de l'installation rapide et de développer des compétences supplémentaires.

Cela dit, le titre du cours ne énoncer clairement "Zend Framework: Principes fondamentaux» et dans cet aspect du cours atteint ce qu'il se propose de faire. Les autres membres de l'équipe de développement qui n'ont pas passé le temps à la recherche dans le cadre de chaque session terminée avec enthousiasme et ont posé des questions qui était vraiment agréable à voir.

Tout n'était pas perdu, il était bon de passer du temps pour confirmer les détails de base du cadre et l'occasion de poser quelques questions dans des domaines où je n'étais pas à 100%. Il était également temps que j'ai obtenu de s'asseoir chaque jour et penser à codage utilisant le cadre et les projets futurs, quelque chose que je ne serait pas d'été en mesure de faire autrement (pouvez-vous imaginer votre entreprise acceptant que:?)). Last but not least, vous obtenez également un certificat de Nice à partir de Zend à dire que vous avez fréquenté le cours (quoique par email).

Certification Zend Framework

Cela a été une question qui revenait à l'esprit pendant le cours, ne serait-il me préparer à la certification? Le simple, rapide est un non retentissant. L'instructeur a été très clair sur ce avec les conseils supplémentaires que pour la certification, vous devez vraiment être en utilisant le cadre sur une base quotidienne et se sentir très à l'aise et confiant dans son utilisation et de méthodologies.

Résumé

Compte tenu de tout ce que j'ai écrit ci-dessus, je vais tout résumer en deux points de balle facile:

• Nouveau à Zend Framework: Ce cours fait exactement ce que vous attendez, il vous donne une bonne introduction au cadre et une bonne base sur les bases à partir de laquelle vous pouvez construire. Le cours semble susciter l'intérêt et l'enthousiasme pour le cadre parmi les développeurs.
• Utilisé le Zend Framework: Bien qu'il était agréable de consolider certaines des bases très J'ai senti le temps, d'efforts et de fonds de suivre le cours de l'été pourrait mieux dépensé ailleurs. Il sera agréable de SCEE Zend créer un cours de niveau plus élevé de nouveaux développeurs pour prendre au prochain niveau -. Au moins à la norme de certification et au-delà pour que je signe immédiatement.