The key to reach this flexibility is the API that gives developers the ability to startup a server, configure it, use it and shut it down. There are libraries for many programming languages but I like the way the boto python library makes it really simple do these things (and a lot more).

Here I’ll show how to use boto to start a server instance then how to send a file to the instance and execute a command on the remote server, and finally I’ll show how to terminate the instance.

To use the boto library you’ll need to install it locally (on your computer) and to use the EC2 api you’ll need to import them:

from boto.ec2.connection import EC2Connection

As with  other AWS services you’ll need to pass the access key and the secret access key to the library (in this case when creating a connection). You can get the keys from the Amazon Web Services “Access Identifiers” page. It’s possible to just set two environment variables holding the keys or you can pass them in to the method calls, I’ll assume for this example that the keys are written inside the script and passed to the methods:

AWS_ACCESS_KEY_ID = 'yourkey'
AWS_SECRET_ACCESS_KEY = 'yoursecret'

conn = EC2Connection(AWS_ACCESS_KEY_ID,
AWS_SECRET_ACCESS_KEY)

First step is to make the connection, Once the connection is created we can use the run_instance to start an instance of an EC2 server image. You can think of a server image as a pre-built virtual server that’s idle waiting to be run. There are public images we can choose from (I’ll use the base Linux Fedora for this example), but any user can customize a running instance and build a private image from that ready to be used.

reservation = conn.run_instances('ami-5647a33f',
                               instance_type='m1.small',
                               key_name='mykey')

instance = reservation.instances[0]

while not instance.update() == 'running':
  time.sleep(5)

the run_instances can take various parameters but only the image is required. Here I’m passing in also the instance type (in this case the “Small” instance type) and a key to use. The key to be used should have been previously generated and/or uploaded to EC2 (e.g. using the AWS Management Console).

The run_instances methods returns a reservation object representing the instance(s) startup request. This also holds the list of instances that are going to be started (we may launch more than one instance in a single run_instances call), in this case (since we are launching just one) we take the first one.

Each instance object has an attribute status which returns its current status, to check for the current status we need to call the update method (which itself returns the current status). When the instance is running it is given a public IP and a public dns name, which we may use to connect.

EC2 has a very flexible shared firewall whose rules and permissions may be manipulated via the API, for instance to enable or disable  connecting via SSH. Different security groups may be defined, to partition our instances into different logical sets e.g. web servers versus backend databases, and each group can be assigned different permissions. All the instances are assigned the ‘default’ security group if not otherwise specified.

With a call to the authorize_security_group method we can allow a specific connection for a given group. E.g. with the following call we  allow SSH to any instance in the default group from the specified IP.

conn.authorize_security_group('default',
                ip_protocol='tcp',
                from_port='22',
                to_port='22',
                cidr_ip='%s/32' % our_ip)

with the following call we can revoke the SSH permission

conn.revoke_security_group('default',
                ip_protocol='tcp',
                from_port='22',
                to_port='22',
                cidr_ip='%s/32' % our_ip)

Once the instance is running and the permissions are setup to allow connecting via ssh, we can connect to it and to run a script on the instance we may simply scp the script and then connect via ssh to run it.

When we are done with the work we can stop use the stop method of the instance object to shut it down:

instance.stop()

For a simple, yet complete example here is a script that can be used to run the benchmarks for the redis key-value store on EC2. In the archive, together with the python script there is a shell script which is copied to the server which downloads the redis code, compiles it and runs the benchmarks:

redis-bench-ec2.zip

That’s all!

The real breakthrough is that this will enable a whole sector within our industry to transition to a modern architecture. There are a lot of ISVs which have invested heavily and have a great knowhow in mainframe technologies and those were facing tough times with clients lending towards web services and cloud systems to renew their IT (this is specially true for many small italian software houses working on ERP systems).

With this offering those ISVs will be able to transition current clients to cloud systems and perhaps they will be able to re-engineer and modernize their software one piece at a time as hopefully the Microfocus service will enable new ways to integrate mainframe software and internet services.

It’s rather trivial but I was able to keep it so simple, thanks to it’s use of the Boto python library to do all of the AWS heavywork. Anyhow I think it may be useful.

A few examples:

Here is the code: