• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Nubilus Perl
 

Nubilus Perl

on

  • 610 views

Una panoramica su Net::Amazon::EC2 e Net::RackSpace::Servers. Potete trovare la presentazione con le note qui: http://polettix.s3.amazonaws.com/IPW2011/nubilus-perl-1.1-note.pdf

Una panoramica su Net::Amazon::EC2 e Net::RackSpace::Servers. Potete trovare la presentazione con le note qui: http://polettix.s3.amazonaws.com/IPW2011/nubilus-perl-1.1-note.pdf

Statistics

Views

Total Views
610
Views on SlideShare
610
Embed Views
0

Actions

Likes
0
Downloads
6
Comments
1

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel

11 of 1 previous next

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
  • Una panoramica su Net::Amazon::EC2 e Net::RackSpace::Servers. Potete trovare la presentazione con le note qui: http://polettix.s3.amazonaws.com/IPW2011/nubilus-perl-1.1-note.pdf
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • \n
  • Di cloud c’è molto da parlare, soprattutto perché dopo il calcio sembra un argomento in cui ognuno ha una sua idea. La tassonomia di partenza più tipica è basata sull’utilizzatore finale: si parte da IaaS (Infrastructure as a Service), ove quello che si tratta sono sostanzialmente server virtuali che interessano un amministratore di sistema, si passa per PaaS (Platform as a Service) ove il fornitore mette a disposizione un ambiente software più o meno ampio che interessa uno sviluppatore, atterrando poi su SaaS (Software as a Service ed il suo cugino Application as a Service) in cui il fornitore mette a disposizione un vero e proprio servizio all’utente finale. Per fare un esempio di quest’ultimo... qualcuno usa Gmail? \n
  • Di cloud c’è molto da parlare, soprattutto perché dopo il calcio sembra un argomento in cui ognuno ha una sua idea. La tassonomia di partenza più tipica è basata sull’utilizzatore finale: si parte da IaaS (Infrastructure as a Service), ove quello che si tratta sono sostanzialmente server virtuali che interessano un amministratore di sistema, si passa per PaaS (Platform as a Service) ove il fornitore mette a disposizione un ambiente software più o meno ampio che interessa uno sviluppatore, atterrando poi su SaaS (Software as a Service ed il suo cugino Application as a Service) in cui il fornitore mette a disposizione un vero e proprio servizio all’utente finale. Per fare un esempio di quest’ultimo... qualcuno usa Gmail? \n
  • \n
  • Nemmeno a dirlo, c’è un modulo su CPAN per gestire la parte di computazione di Amazon (Amazon Elastic Cloud Computing o EC2).\n
  • Trattandosi di un servizio a pagamento, c’è bisogno di fornire delle credenziali di accesso che serviranno anche per la tariffazione dei servizi.\n
  • Queste credenziali le trovate nel profilo.\n
  • Una volta disponibile un oggetto $ec2, possiamo cominciare a lanciare dei server virtuali...\n
  • ... o, in terminologia Amazon, delle istanze.\n
  • Uno dei parametri da specificare obbligatoriamente è ImageId\n
  • Un’immagine è una fotografia di una macchina comprensiva dell’intero sistema operativo. Un po’ come se l’immagine fosse il programma, e l’istanza fosse il processo del programma in esecuzione: da un solo programma si possono lanciare più processi.\n
  • Un’immagine è una fotografia di una macchina comprensiva dell’intero sistema operativo. Un po’ come se l’immagine fosse il programma, e l’istanza fosse il processo del programma in esecuzione: da un solo programma si possono lanciare più processi.\n
  • Un’immagine è una fotografia di una macchina comprensiva dell’intero sistema operativo. Un po’ come se l’immagine fosse il programma, e l’istanza fosse il processo del programma in esecuzione: da un solo programma si possono lanciare più processi.\n
  • Un’immagine è una fotografia di una macchina comprensiva dell’intero sistema operativo. Un po’ come se l’immagine fosse il programma, e l’istanza fosse il processo del programma in esecuzione: da un solo programma si possono lanciare più processi.\n
  • Un’immagine è una fotografia di una macchina comprensiva dell’intero sistema operativo. Un po’ come se l’immagine fosse il programma, e l’istanza fosse il processo del programma in esecuzione: da un solo programma si possono lanciare più processi.\n
  • Un’immagine è una fotografia di una macchina comprensiva dell’intero sistema operativo. Un po’ come se l’immagine fosse il programma, e l’istanza fosse il processo del programma in esecuzione: da un solo programma si possono lanciare più processi.\n
  • Un’altra informazione necessaria è InstanceType\n
  • Il “tipo” rappresenta la classe di hardware virtuale su cui deve girare la nostra istanza. La stesa immagine, infatti, può essere lanciata su macchine virtuali aventi risorse differenti in termini di memoria, CPU e spazio disco disponibili.\n
  • Il “tipo” rappresenta la classe di hardware virtuale su cui deve girare la nostra istanza. La stesa immagine, infatti, può essere lanciata su macchine virtuali aventi risorse differenti in termini di memoria, CPU e spazio disco disponibili.\n
  • Il “tipo” rappresenta la classe di hardware virtuale su cui deve girare la nostra istanza. La stesa immagine, infatti, può essere lanciata su macchine virtuali aventi risorse differenti in termini di memoria, CPU e spazio disco disponibili.\n
  • Altri due parametri obbligatori sono MinCount e MaxCount, che consentono di impostare quante istanze vadano fatte partire all’interno del particolare “ordine”. Il parametro SecurityGroup non è obbligatorio ma consente di impostare delle opzioni di accesso particolari. Esistono ovviamente altri parametri!\n
  • Una volta dato l’ordine di lanciare una o più istanze occorre attendere che queste siano disponibili.\n
  • Il controllo è possibile utilizzando il metodo describe_instances(), che restituisce una struttura dati multilivello. Di fatto è un array anonimo che andrà a contenere tutti gli “ordini” effettuati nel tempo ($reservations); all’interno di ciascun ordine potremo accedere all’insieme delle istanze proprie dell’ordine (da ricordare che con MinCount e MaxCount diversi da 1 potremmo ritrovarci con più di un’istanza per ordine) e quindi allo stato di ciascuna istanza. Quando abbiamo raggiunto il livello ‘running’ la macchina virtuale è definitivamente pronta...\n
  • ... per cui possiamo reperire le informazioni salienti su di essa, come ad esempio l’indirizzo IP su cui è raggiungibile.\n
  • \n
  • \n
  • L’accesso in SSH alla macchina è condizionato però al fatto che siano state impostate opportune chiavi di accesso.\n
  • Queste possono essere impostate sia attraverso l’API che - più banalmente - attraverso la console web del servizio EC2.\n
  • A questo punto potete accedere via SSH come utente root. Yay!\n
  • L’ultima operazione principale di interesse è ovviamente la terminazione di una macchina virtuale, in modo da ridurre i costi quando questa non sia necessaria. Il metodo terminate_instances() richiede l’identificativo della macchina, che è reperibile attraverso l’oggetto di “prenotazione” dell’ordine.\n
  • Anche qui è opportuno verificare che lo stato della macchina virtuale sia cambiato opportunamente in modo da assicurarci che l’ordine di terminazione sia in effettivo corso di smaltimento.\n
  • \n
  • Anche per RackSpace è disponibile un modulo Perl di astrazione dell’API, per quanto non sia esattamente matura e presenti dei punti di possibile miglioramento o comunque raffinamento.\n
  • Analogamente a quanto avviene per Amazon, anche qui è necessario avere delle credenziali di accesso all’API che verranno utilizzate anche per la tariffazione dei servizi.\n
  • Il nome utente lo decidete voi all’atto dell’iscrizione, mentre la chiave per l’API è disponibile all’interno del vostro profilo.\n
  • Un altro aspetto che va indicato è se intendete connettervi all’infrastruttura americana (default) o a quella europea in UK. Si tratta in buona sostanza di due infrastrutture indipendenti che hanno punti di ingresso differenti (contrariamente ad Amazon che ha un punto di ingresso unico per l’API).\n
  • In particolare, se vi interessano macchine virtuali in Europa, il sistema di gestione si trova a Londra.\n
  • Arrivati a questo punto è possibile creare la descrizione di una macchina virtuale.\n
  • I concetti di base sono gli stessi di Amazon, anche se invece di “istanza” si parla di “server” ed invece di “tipo” si parla di “gusto”.\n
  • I concetti di base sono gli stessi di Amazon, anche se invece di “istanza” si parla di “server” ed invece di “tipo” si parla di “gusto”.\n
  • I concetti di base sono gli stessi di Amazon, anche se invece di “istanza” si parla di “server” ed invece di “tipo” si parla di “gusto”.\n
  • I concetti di base sono gli stessi di Amazon, anche se invece di “istanza” si parla di “server” ed invece di “tipo” si parla di “gusto”.\n
  • Ma quello che abbiamo - $server - è solo una descrizione e non c’è nessuna macchina virtuale in cantiere. Ancora.\n
  • Il metodo create_server() serve proprio ad utilizzare la descrizione creata per lanciare una macchina virtuale. Questa doppia strutturazione è uno dei punti di possibile miglioramento dell’interfaccia messa a disposizione dal modulo. Nel valore restituito - che rimappa la risposta proveniente da RackSpace - è anche disponibile la password dell’amministratore della macchina in corso di creazione.\n
  • \n
  • Anche qui c’è da aspettare un minimo per consentire alla macchina di essere lanciata propriamente...\n
  • ... ed anche qui è possibile controllare periodicamente lo stato della macchina finché questa non diventa ‘ACTIVE’.\n
  • Una volta attiva, possiamo sapere qual è l’indirizzo IP...\n
  • ... ed entrare in SSH con la password di root che abbiamo raccolto in precedenza.\n
  • \n
  • Purtroppo la password viene inviata anche via email...\n
  • \n
  • Un aspetto interessante messo a disposizione da RackSpace è la possibilità di personalizzare alcuni file in relazione alla particolare istanza con il parametro “personality”. Un possibile utilizzo consiste nell’impostare il file /root/.ssh/authorized_keys2 che consente di utilizzare le chiavi SSH invece delle password. Ovviamente il meccanismo può essere anche utilizzato per impostare i parametri distintivi dell’istanza, come ad esempio il suo ruolo rispetto ad altre istanze lanciate a partire dalla stessa immagine.\n
  • \n
  • Molto semplicemente, terminare un server.\n
  • Una volta lanciato il comando di terminazione la macchina virtuale viene subito fatta scomparire dalla lista delle macchine attive, quindi in questo caso il controllo è piuttosto semplice.\n
  • \n

Nubilus Perl Nubilus Perl Presentation Transcript

  • Nubilus PerlLibrerie Perl in the cloud
  • IaaS - PaaS - SaaS 2
  • IaaS - PaaS - SaaS 2
  • Amazon
  • require Net::Amazon::EC2;my $ec2 = Net::Amazon::EC2->new( AWSAccessKeyId => YOUR-AWS-KEY, SecretAccessKey => YOUR-AWS-SECRET,);
  • require Net::Amazon::EC2;my $ec2 = Net::Amazon::EC2->new( AWSAccessKeyId => YOUR-AWS-KEY, SecretAccessKey => YOUR-AWS-SECRET,);
  • my $res = $ec2->run_instances( ImageId => ami-8c1fece5, MinCount => 1, MaxCount => 1, SecurityGroup => quick-start-1, InstanceType => m1.small,);
  • Instance
  • my $res = $ec2->run_instances( ImageId => ami-8c1fece5, MinCount => 1, MaxCount => 1, SecurityGroup => quick-start-1, InstanceType => m1.small,);
  • Instance
  • Image Instance
  • Image Instance#!/usr/bin/env perl 10715 gnome-terminaluse strict; 10719 _ gnome-pty-helperuse warnings; 10720 _ bashuse 5.012; 24910 _ bash 32549 _ bashmy $message = shift 27438 | _ perl prg.pl || whatever!; 27444 _ bashwhile (necessary) { 27462 | _ perl prg.pl hey you! say $message; 27463 _ bash sleep 1; 27480 | _ perl prg.pl another}
  • my $res = $ec2->run_instances( ImageId => ami-8c1fece5, MinCount => 1, MaxCount => 1, SecurityGroup => quick-start-1, InstanceType => m1.small,);
  • Image Instance#!/usr/bin/env perl 10715 gnome-terminaluse strict; 10719 _ gnome-pty-helperuse warnings; 10720 _ bashuse 5.012; 24910 _ bash 32549 _ bashmy $message = shift 27438 | _ perl prg.pl || whatever!; 27444 _ bashwhile (necessary) { 27462 | _ perl prg.pl hey you! say $message; 27463 _ bash sleep 1; 27480 | _ perl prg.pl another}
  • Image Instance Type
  • my $res = $ec2->run_instances( ImageId => ami-8c1fece5, MinCount => 1, MaxCount => 1, SecurityGroup => quick-start-1, InstanceType => m1.small,);
  • RUNNING_CHECK:while (necessary) { my $reservations = $ec2->describe_instances() || []; foreach my $res (@$reservations) { foreach my $instance ($res->instances_set()) { if ($instance->{instance_state}{name} eq running) { say active, IP: , $instance->{ip_address}; last RUNNING_CHECK; } } } sleep 1;}
  • RUNNING_CHECK:while (necessary) { my $reservations = $ec2->describe_instances() || []; foreach my $res (@$reservations) { foreach my $instance ($res->instances_set()) { if ($instance->{instance_state}{name} eq running) { say active, IP: , $instance->{ip_address}; last RUNNING_CHECK; } } } sleep 1;}
  • Ora?
  • Beh... PRIMA...
  • Sì, SSH
  • my $res = $ec2->run_instances( RUNNING_CHECK: ImageId => ami-8c1fece5, while (necessary) { MinCount => 1, my $reservations MaxCount => 1, = $ec2->describe_instances() || []; SecurityGroup => quick-start-1, InstanceType => m1.small, foreach my $res (@$reservations) {); #... my $instance_id = $res->instance_id(); $ec2->terminate_instances( InstanceId => $instance_id, );
  • my $reservations = $ec2->describe_instances() || [];foreach my $res (@$reservations) { foreach my $instance ($res->instances_set()) { my $state = $instance->{instance_state}{name}; # ... utilizzare $state... }}
  • RackSpace
  • require Net::RackSpace::CloudServers;my $cs = Net::RackSpace::CloudServers->new( user => myusername, key => mysecretkey, location => UK,);
  • require Net::RackSpace::CloudServers;my $cs = Net::RackSpace::CloudServers->new( user => YOUR-CS-USERNAME, key => YOUR-CS-SECRETKEY, location => UK,);
  • require Net::RackSpace::CloudServers;my $cs = Net::RackSpace::CloudServers->new( user => YOUR-CS-USERNAME, key => YOUR-CS-SECRETKEY, location => UK,);
  • my $server = Net::RackSpace::CloudServers::Server->new( cloudservers => $cs, # N::R::CloudServers instance name => my-instance, imageid => 4, # Debian 5.0 (lenny) flavorid => 1, # basic server, 256 MB RAM);
  • Image Instance Type
  • Image Server Flavor
  • Ancora niente
  • my $real_server = $server->create_server();my $root_pass = $real_server->adminpass();
  • Ora sì
  • my $id = $real_server->id();RUNNING_CHECK:while (necessary) { my $instance = $cs->get_server($id); say completion status: , $server->progress(); if ($server->status eq ACTIVE) { say active, IP: , $instance->public_address()->[0]; last RUNNING_CHECK; } sleep 1;}
  • my $id = $real_server->id();RUNNING_CHECK:while (necessary) { my $instance = $cs->get_server($id); say completion status: , $server->progress(); if ($server->status eq ACTIVE) { say active, IP: , $instance->public_address()->[0]; last RUNNING_CHECK; } sleep 1;}
  • Ora?SSH con $root_pass
  • O anche...
  • Sì... root password via email
  • my $server = Net::RackSpace::CloudServers::Server->new( cloudservers => $cs, # N::R::CloudServers instance name => my-instance, imageid => 4, # Debian 5.0 (lenny) flavorid => 1, # basic server, 256 MB RAM personality => [ { path => /root/.ssh/authorized_keys2, contents => <<END_OF_BASE64SUlKckNyZWIxcU5NcGxuS1BIaFBBdFIxL2RMUVJ6SnNzSnNxTWUwRENlbXp5NlVMZ0g3Uy9seWZU...anExQWhSaE1zK0FHaDZDL01aV1N4QStZNmhqd2wwMFozSVl1R3AgaW1wb3J0ZWQtb3BlbnNzaC1rZXkKEND_OF_BASE64 }, ],);
  • Chiave SSH
  • $real_server->delete();
  • Adieu
  • 46