Le cluster ipython démarre localement dès que ipyparallel est installé, mais ce n'est pas intéressant, j'ai donc mis la destination de distribution sur AWS. Mémorandum.

Personnage

utilisateur --Client (machine locale)

--Grappe

Controller/Hub (EC2)
Engine (EC2)

Diagramme schématique

L'histoire expliquée ici est une telle composition. Étant donné que chaque hôte est connecté par SSH, il est nécessaire de configurer chaque information de connexion à l'avance. En fait, ce serait plus facile si vous aviez la peine de préparer une AMI qui fonctionne comme un nœud pour Engine juste en le démarrant.

Créer des hôtes pour le moteur et le contrôleur

Créez une instance sur Amazon Linux, le cas échéant.

Ici, j'ai utilisé ʻAmazon Linux AMI 2015.09 (HVM) `et l'ai créé avec t2.micro dans la région de Tokyo.

Une fois installé, installez ʻipython et ʻipyparallel.

sudo yum groupinstall -y 'Development Tools'
sudo pip install ipython ipyparallel

Ici, le moteur est démarré via SSH, alors assurez-vous que vous pouvez ssh du contrôleur vers le serveur du moteur avec ec2-user sans mot de passe.

Créer un nouveau profil ipython dans Controller

ipython profile create --parallel --profile=myprofile

Cela générera un fichier comme celui ci-dessous.

tree .ipython/profile_myprofile/

~/.ipython/profile_myprofile/
├── ipcluster_config.py
├── ipcontroller_config.py
├── ipengine_config.py
├── ipython_config.py
├── ipython_kernel_config.py
├── log
├── pid
├── security
└── startup
    └── README

Nous allons définir les paramètres pour le fonctionnement du cluster.

ipcluster_config.py

Ajoutons le code suivant au début.

`ipcluster_config.py`


c = get_config()

c.IPClusterEngines.engine_launcher_class = 'SSHEngineSetLauncher'

c.SSHEngineSetLauncher.engines = {
    '<ENGINE_HOST1>' : 3,
    '<ENGINE_HOST2>' : 3
}

ipcontroller_config.py

Trouvez la partie commentée à l'intérieur et réécrivez la partie correspondante.

`ipcontroller_config.py`



...Omission...

c.IPControllerApp.reuse_files = True

...Omission...

c.RegistrationFactory.ip = u'*'

...

Si reuse_files est défini sur True, les fichiers sous .ipython / profile_ <PROFILE_NANE> / security / seront réutilisés. Ce qui se passe lorsqu'elle est réutilisée, c'est que la clé de cluster n'est pas régénérée, vous n'avez donc pas à mettre à jour le fichier de configuration à chaque redémarrage du contrôleur.

Démarrer le contrôleur

Exécutez la commande suivante sur le serveur du contrôleur.

ipcluster start --profile=myprofile

Si vous voulez une sortie plus détaillée, utilisez l'option --debug. De plus, le fichier journal est .ipython / profile_myprofile / log /.

Si tout se passe bien, après le démarrage du contrôleur, vous verrez un journal qui semble avoir transféré ʻipcontroller-client.json et ʻipcontroller-engine.json vers chaque nœud. Si le contrôleur ne démarre pas, les fichiers associés à ʻipcontroller- * `ne seront pas générés. (Par conséquent, si le contrôleur ne parvient pas à démarrer, il affichera un message indiquant que le contrôleur s'est arrêté par hasard, puis il sera dit que ipcontroller-client.json ne peut pas être transféré à chaque nœud du moteur.

2015-10-04 11:15:21.568 [IPClusterStart] Engines appear to have started successfully

Lorsqu'un journal comme celui-ci apparaît, le démarrage est terminé.

Si vous voulez en faire un démon, ajoutez l'option --daemonize.

Se connecter depuis le client

A partir de maintenant, je vais le faire depuis la machine locale.

Obtenez ipcontroller-client.json depuis Controller

Ce fichier est créé au démarrage du contrôleur.

Déposez ce fichier localement sur le client avec scp ou quelque chose.

scp ec2-user@<CONTROLLER_HOST>:./.ipython/profile_myprofile/security/ipcontroller-client.json ./

Création d'un script de confirmation de connexion

Ici, j'ai préparé le script de confirmation suivant en faisant référence à diverses choses.

`cluster_check.py`


from ipyparallel import Client
rc = Client("ipcontroller-client.json", sshserver="ec2-user@<CONTROLLER_HOST>")
print rc.ids

dview = rc[:]
@dview.remote(block=True)
def gethostname():
    import socket
    return socket.getfqdn()

print gethostname()

Si vous l'exécutez avec ceci, cela devrait ressembler à ceci.

$ python cluster_check.py

[0, 1, 2, 3, 4, 5]
[<HOSTNAME>, <HOSTNAME>, <HOSTNAME>, <HOSTNAME2>, <HOSTNAME2>, <HOSTNAME2>]

Si vous suivez les paramètres ci-dessus, vous devriez démarrer 3 hôtes chacun.

Le cluster ipython peut désormais distribuer le processus sur plusieurs nœuds.

la programmation

L'import se fait dans la fonction

Comme le code de contrôle d'opération ci-dessus, vous devez effectuer l'importation nécessaire, etc. dans le code qui s'exécute sur plusieurs nœuds.

Utilisez les décorateurs @ require et @ depend pour exécuter du code qui peut être exécuté correctement sur ce nœud. (Veuillez vous référer à cette zone)

Peut être utilisé comme une file d'attente de tâches

https://ipython.org/ipython-doc/2/parallel/parallel_task.html

Utilisez LoadBalancedView si vous souhaitez traiter des tâches en séquence sur plusieurs nœuds.

Obtenez load_balanced_view et appliquez une carte asynchrone avec map_async

In [1]: from ipyparallel import Client
In [3]: a = Client("ipcontroller-client.json", sshserver="ec2-user@<CONTROLLER_HOST>")
In [4]: views = a.load_balanced_view()
In [5]: result = views.map_async(lambda x: x*x , (x for x in xrange(10000)))
In [6]: result
Out[6]: <AsyncMapResult: <lambda>>

Cet exemple est inutile car il transfère une valeur à un autre contrôleur, transfère l'expression lambda, l'alloue séparément à chaque moteur, calcule et reçoit le résultat pour tous les éléments de la liste. C'est un bon endroit, mais ce n'est qu'un exemple.

Après l'exécution, vous pouvez voir la situation avec progress et ready () d'AsyncMapResult.

In [8]: result.progress
Out[8]: 8617
In [9]: result.progress
Out[9]: 9557

In [11]: result.progress
Out[11]: 10000

In [12]: result.ready()
Out[12]: True

In [13]: result
Out[13]: <AsyncMapResult: finished>

Le résultat du mappage est stocké dans le résultat «.result».

In [14]: len(result.result)
Out[14]: 10000
In [15]: type(result.result)
Out[15]: list

Veuillez noter que si vous accédez à «.result» par négligence, il sera verrouillé jusqu'à ce que le traitement distribué soit terminé.

Résumé

Ainsi, il est désormais possible de créer des clusters et d'effectuer un traitement distribué.

Je pensais qu'ipython n'était qu'un "environnement repl pratique", mais c'est incroyable.

Il semble difficile de sécuriser dynamiquement les nœuds ou d'augmenter ou de diminuer le nombre de clusters en fonction de la charge, mais surtout, c'est un rêve que le code créé en localisant la destination de distribution puisse être mis sur une distribution à grande échelle. Au contraire, est-ce amusant de pouvoir exécuter du code qui fonctionne dans une distribution à grande échelle en mode local tel quel? Au fur et à mesure que l'échelle grandira, la gestion des clusters sera probablement un autre défi.

référence

Je l'ai beaucoup utilisé comme référence.

http://qiita.com/chokkan/items/750cc12fb19314636eb7

J'ai essayé de lancer le cluster ipython au minimum sur AWS