| .. Licensed to the Apache Software Foundation (ASF) under one |
| or more contributor license agreements. See the NOTICE file |
| distributed with this work for additional information# |
| regarding copyright ownership. The ASF licenses this file |
| to you under the Apache License, Version 2.0 (the |
| "License"); you may not use this file except in compliance |
| with the License. You may obtain a copy of the License at |
| http://www.apache.org/licenses/LICENSE-2.0 |
| Unless required by applicable law or agreed to in writing, |
| software distributed under the License is distributed on an |
| "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| KIND, either express or implied. See the License for the |
| specific language governing permissions and limitations |
| under the License. |
| |
| |
| CloudStack Installation from Source for Developers |
| ================================================== |
| |
| This book is aimed at CloudStack developers who need to build the code. |
| These instructions are valid on a Ubuntu 12.04 and CentOS 6.4 systems |
| and were tested with the 4.2 release of Apache CloudStack, please adapt |
| them if you are on a different operating system or using a newer/older |
| version of CloudStack. This book is composed of the following sections: |
| |
| #. Installation of the prerequisites |
| |
| #. Compiling and installation from source |
| |
| #. Using the CloudStack simulator |
| |
| #. Installation with DevCloud the CloudStack sandbox |
| |
| #. Building your own packages |
| |
| #. The CloudStack API |
| |
| #. Testing the AWS API interface |
| |
| |
| Prerequisites |
| ------------- |
| |
| In this section we'll look at installing the dependencies you'll need |
| for Apache CloudStack development. |
| |
| |
| On Ubuntu 12.04 |
| ~~~~~~~~~~~~~~~ |
| |
| First update and upgrade your system: |
| |
| :: |
| |
| apt-get update |
| apt-get upgrade |
| |
| NTP might already be installed, check it with ``service ntp status``. If |
| it's not then install NTP to synchronize the clocks: |
| |
| :: |
| |
| apt-get install openntpd |
| |
| Install ``openjdk``. As we're using Linux, OpenJDK is our first choice. |
| |
| :: |
| |
| apt-get install openjdk-6-jdk |
| |
| Install ``tomcat6``, note that the new version of tomcat on |
| `Ubuntu <http://packages.ubuntu.com/precise/all/tomcat6>`__ is the |
| 6.0.35 version. |
| |
| :: |
| |
| apt-get install tomcat6 |
| |
| Next, we'll install MySQL if it's not already present on the system. |
| |
| :: |
| |
| apt-get install mysql-server |
| |
| Remember to set the correct ``mysql`` password in the CloudStack |
| properties file. Mysql should be running but you can check it's status |
| with: |
| |
| :: |
| |
| service mysql status |
| |
| Developers wanting to build CloudStack from source will want to install |
| the following additional packages. If you dont' want to build from |
| source just jump to the next section. |
| |
| Install ``git`` to later clone the CloudStack source code: |
| |
| :: |
| |
| apt-get install git |
| |
| Install ``Maven`` to later build CloudStack |
| |
| :: |
| |
| apt-get install maven |
| |
| This should have installed Maven 3.0, check the version number with |
| ``mvn --version`` |
| |
| A little bit of Python can be used (e.g simulator), install the Python |
| package management tools: |
| |
| :: |
| |
| apt-get install python-pip python-setuptools |
| |
| Finally install ``mkisofs`` with: |
| |
| :: |
| |
| apt-get install genisoimage |
| |
| |
| On CentOS 6.4 |
| ~~~~~~~~~~~~~ |
| |
| First update and upgrade your system: |
| |
| :: |
| |
| yum -y update |
| yum -y upgrade |
| |
| If not already installed, install NTP for clock synchornization |
| |
| :: |
| |
| yum -y install ntp |
| |
| Install ``openjdk``. As we're using Linux, OpenJDK is our first choice. |
| |
| :: |
| |
| yum -y install java-1.6.0-openjdk |
| |
| Install ``tomcat6``, note that the version of tomcat6 in the default |
| CentOS 6.4 repo is 6.0.24, so we will grab the 6.0.35 version. The |
| 6.0.24 version will be installed anyway as a dependency to cloudstack. |
| |
| :: |
| |
| wget https://archive.apache.org/dist/tomcat/tomcat-6/v6.0.35/bin/apache-tomcat-6.0.35.tar.gz |
| tar xzvf apache-tomcat-6.0.35.tar.gz -C /usr/local |
| |
| Setup tomcat6 system wide by creating a file |
| ``/etc/profile.d/tomcat.sh`` with the following content: |
| |
| :: |
| |
| export CATALINA_BASE=/usr/local/apache-tomcat-6.0.35 |
| export CATALINA_HOME=/usr/local/apache-tomcat-6.0.35 |
| |
| Next, we'll install MySQL if it's not already present on the system. |
| |
| :: |
| |
| yum -y install mysql mysql-server |
| |
| Remember to set the correct ``mysql`` password in the CloudStack |
| properties file. Mysql should be running but you can check it's status |
| with: |
| |
| :: |
| |
| service mysqld status |
| |
| Install ``git`` to later clone the CloudStack source code: |
| |
| :: |
| |
| yum -y install git |
| |
| Install ``Maven`` to later build CloudStack. Grab the 3.0.5 release from |
| the Maven `website <http://maven.apache.org/download.cgi>`__ |
| |
| :: |
| |
| wget http://mirror.cc.columbia.edu/pub/software/apache/maven/maven-3/3.0.5/binaries/apache-maven-3.0.5-bin.tar.gz |
| tar xzf apache-maven-3.0.5-bin.tar.gz -C /usr/local |
| cd /usr/local |
| ln -s apache-maven-3.0.5 maven |
| |
| Setup Maven system wide by creating a ``/etc/profile.d/maven.sh`` file |
| with the following content: |
| |
| :: |
| |
| export M2_HOME=/usr/local/maven |
| export PATH=${M2_HOME}/bin:${PATH} |
| |
| Log out and log in again and you will have maven in your PATH: |
| |
| :: |
| |
| mvn --version |
| |
| This should have installed Maven 3.0, check the version number with |
| ``mvn --version`` |
| |
| A little bit of Python can be used (e.g simulator), install the Python |
| package management tools: |
| |
| :: |
| |
| yum -y install python-setuptools |
| |
| To install python-pip you might want to setup the Extra Packages for |
| Enterprise Linux (EPEL) repo |
| |
| :: |
| |
| cd /tmp |
| wget http://mirror-fpt-telecom.fpt.net/fedora/epel/6/i386/epel-release-6-8.noarch.rpm |
| rpm -ivh epel-release-6-8.noarch.rpm |
| |
| Then update you repository cache ``yum update`` and install pip |
| ``yum -y install python-pip`` |
| |
| Finally install ``mkisofs`` with: |
| |
| :: |
| |
| yum -y install genisoimage |
| |
| |
| Installing from Source |
| ---------------------- |
| |
| CloudStack uses git for source version control, if you know little about |
| `git <http://book.git-scm.com/>`__ is a good start. Once you have git |
| setup on your machine, pull the source with: |
| |
| :: |
| |
| git clone https://git-wip-us.apache.org/repos/asf/cloudstack.git |
| |
| To build the latest stable release: |
| |
| :: |
| |
| git checkout 4.2 |
| |
| To compile Apache CloudStack, go to the cloudstack source folder and |
| run: |
| |
| :: |
| |
| mvn -Pdeveloper,systemvm clean install |
| |
| If you want to skip the tests add ``-DskipTests`` to the command above. |
| Do NOT use ``-Dmaven.test.skip=true`` because that will break the build. |
| |
| You will have made sure to set the proper db password in |
| ``utils/conf/db.properties`` |
| |
| Deploy the database next: |
| |
| :: |
| |
| mvn -P developer -pl developer -Ddeploydb |
| |
| Run Apache CloudStack with jetty for testing. Note that ``tomcat`` maybe |
| be running on port 8080, stop it before you use ``jetty`` |
| |
| :: |
| |
| mvn -pl :cloud-client-ui jetty:run |
| |
| Log Into Apache CloudStack: |
| |
| Open your Web browser and use this URL to connect to CloudStack: |
| |
| :: |
| |
| http://localhost:8080/client/ |
| |
| Replace ``localhost`` with the IP of your management server if need be. |
| |
| .. note:: |
| If you have iptables enabled, you may have to open the ports used by |
| CloudStack. Specifically, ports 8080, 8250, and 9090. |
| |
| You can now start configuring a Zone, playing with the API. Of course we |
| did not setup any infrastructure, there is no storage, no |
| hypervisors...etc. However you can run tests using the simulator. The |
| following section shows you how to use the simulator so that you don't |
| have to setup a physical infrastructure. |
| |
| |
| Using the Simulator |
| ------------------- |
| |
| CloudStack comes with a simulator based on Python bindings called |
| *Marvin*. Marvin is available in the CloudStack source code or on Pypi. |
| With Marvin you can simulate your data center infrastructure by |
| providing CloudStack with a configuration file that defines the number |
| of zones/pods/clusters/hosts, types of storage etc. You can then develop |
| and test the CloudStack management server *as if* it was managing your |
| production infrastructure. |
| |
| Do a clean build: |
| |
| :: |
| |
| mvn -Pdeveloper -Dsimulator -DskipTests clean install |
| |
| Deploy the database: |
| |
| :: |
| |
| mvn -Pdeveloper -pl developer -Ddeploydb |
| mvn -Pdeveloper -pl developer -Ddeploydb-simulator |
| |
| Install marvin. Note that you will need to have installed ``pip`` |
| properly in the prerequisites step. |
| |
| :: |
| |
| pip install tools/marvin/dist/Marvin-0.1.0.tar.gz |
| |
| Stop jetty (from any previous runs) |
| |
| :: |
| |
| mvn -pl :cloud-client-ui jetty:stop |
| |
| Start jetty |
| |
| :: |
| |
| mvn -pl client jetty:run |
| |
| Setup a basic zone with Marvin. In a separate shell:// |
| |
| :: |
| |
| mvn -Pdeveloper,marvin.setup -Dmarvin.config=setup/dev/basic.cfg -pl :cloud-marvin integration-test |
| |
| At this stage log in the CloudStack management server at |
| http://localhost:8080/client with the credentials admin/password, you |
| should see a fully configured basic zone infrastructure. To simulate an |
| advanced zone replace ``basic.cfg`` with ``advanced.cfg``. |
| |
| You can now run integration tests, use the API etc... |
| |
| |
| Using DevCloud |
| -------------- |
| |
| The Installing from source section will only get you to the point of |
| runnign the management server, it does not get you any hypervisors. The |
| simulator section gets you a simulated datacenter for testing. With |
| DevCloud you can run at least one hypervisor and add it to your |
| management server the way you would a real physical machine. |
| |
| `DevCloud <https://cwiki.apache.org/confluence/display/CLOUDSTACK/DevCloud>`__ |
| is the CloudStack sandbox, the standard version is a VirtualBox based |
| image. There is also a KVM based image for it. Here we only show steps |
| with the VirtualBox image. For KVM see the |
| `wiki <https://cwiki.apache.org/confluence/display/CLOUDSTACK/devcloud-kvm>`__. |
| |
| \*\* DevCloud Pre-requisites |
| |
| #. Install `VirtualBox <http://www.virtualbox.org>`__ on your machine |
| |
| #. Run VirtualBox and under >Preferences create a *host-only interface* |
| on which you disable the DHCP server |
| |
| #. Download the DevCloud `image |
| <http://people.apache.org/~bhaisaab/cloudstack/devcloud/devcloud2.ova>`__ |
| |
| #. In VirtualBox, under File > Import Appliance import the DevCloud |
| image. |
| |
| #. Verify the settings under > Settings and check the ``enable PAE`` |
| option in the processor menu |
| |
| #. Once the VM has booted try to ``ssh`` to it with credentials: |
| ``root/password`` |
| |
| ssh root@192.168.56.10 |
| |
| |
| Adding DevCloud as an Hypervisor |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| |
| Picking up from a clean build: |
| |
| :: |
| |
| mvn -Pdeveloper,systemvm clean install |
| mvn -P developer -pl developer,tools/devcloud -Ddeploydb |
| |
| At this stage install marvin similarly than with the simulator: |
| |
| :: |
| |
| pip install tools/marvin/dist/Marvin-0.1.0.tar.gz |
| |
| Start the management server |
| |
| :: |
| |
| mvn -pl client jetty:run |
| |
| Then you are going to configure CloudStack to use the running DevCloud |
| instance: |
| |
| :: |
| |
| cd tools/devcloud |
| python ../marvin/marvin/deployDataCenter.py -i devcloud.cfg |
| |
| If you are curious, check the ``devcloud.cfg`` file and see how the data |
| center is defined: 1 Zone, 1 Pod, 1 Cluster, 1 Host, 1 primary Storage, |
| 1 Seondary Storage, all provided by Devcloud. |
| |
| You can now log in the management server at |
| ``http://localhost:8080/client`` and start experimenting with the UI or |
| the API. |
| |
| Do note that the management server is running in your local machine and |
| that DevCloud is used only as a n Hypervisor. You could potentially run |
| the management server within DevCloud as well, or memory granted, run |
| multiple DevClouds. |
| |
| |
| Building Packages |
| ----------------- |
| |
| Working from source is necessary when developing CloudStack. As |
| mentioned earlier this is not primarily intended for users. However some |
| may want to modify the code for their own use and specific |
| infrastructure. The may also need to build their own packages for |
| security reasons and due to network connectivity constraints. This |
| section shows you the gist of how to build packages. We assume that the |
| reader will know how to create a repository to serve this packages. The |
| complete documentation is available on the |
| `website <http://cloudstack.apache.org/docs/en-US/Apache_CloudStack/4.2.0/html/Installation_Guide/sect-source-builddebs.html>`__ |
| |
| To build debian packages you will need couple extra packages that we did |
| not need to install for source compilation: |
| |
| :: |
| |
| apt-get install python-mysqldb |
| apt-get install debhelper |
| |
| Then build the packages with: |
| |
| :: |
| |
| dpkg-buildpackage -uc -us |
| |
| One directory up from the CloudStack root dir you will find: |
| |
| :: |
| |
| cloudstack_4.2.0_amd64.changes |
| cloudstack_4.2.0.dsc |
| cloudstack_4.2.0.tar.gz |
| cloudstack-agent_4.2.0_all.deb |
| cloudstack-awsapi_4.2.0_all.deb |
| cloudstack-cli_4.2.0_all.deb |
| cloudstack-common_4.2.0_all.deb |
| cloudstack-docs_4.2.0_all.deb |
| cloudstack-management_4.2.0_all.deb |
| cloudstack-usage_4.2.0_all.deb |
| |
| Of course the community provides a repository for these packages and you |
| can use it instead of building your own packages and putting them in |
| your own repo. Instructions on how to use this community repository are |
| available in the installation book. |
| |
| |
| The CloudStack API |
| ------------------ |
| |
| The CloudStack API is a query based API using http that return results |
| in XML or JSON. It is used to implement the default web UI. This API is |
| not a standard like `OGF |
| OCCI <http://www.ogf.org/gf/group_info/view.php?group=occi-wg>`__ or |
| `DMTF CIMI <http://dmtf.org/standards/cloud>`__ but is easy to learn. |
| Mapping exists between the AWS API and the CloudStack API as will be |
| seen in the next section. Recently a Google Compute Engine interface was |
| also developed that maps the GCE REST API to the CloudStack API |
| described here. The API |
| `docs <http://cloudstack.apache.org/docs/api/>`__ are a good start to |
| learn the extent of the API. Multiple clients exist on |
| `github <https://github.com/search?q=cloudstack+client&ref=cmdform>`__ |
| to use this API, you should be able to find one in your favorite |
| language. The reference documentation for the API and changes that might |
| occur from version to version is availble |
| `on-line <http://cloudstack.apache.org/docs/en-US/Apache_CloudStack/4.1.1/html/Developers_Guide/index.html>`__. |
| This short section is aimed at providing a quick summary to give you a |
| base understanding of how to use this API. As a quick start, a good way |
| to explore the API is to navigate the dashboard with a firebug console |
| (or similar developer console) to study the queries. |
| |
| In a succint statement, the CloudStack query API can be used via http |
| GET requests made against your cloud endpoint (e.g |
| http://localhost:8080/client/api). The API name is passed using the |
| ``command`` key and the various parameters for this API call are passed |
| as key value pairs. The request is signed using the access key and |
| secret key of the user making the call. Some calls are synchronous while |
| some are asynchronous, this is documented in the API |
| `docs <http://cloudstack.apache.org/docs/api/>`__. Asynchronous calls |
| return a ``jobid``, the status and result of a job can be queried with |
| the ``queryAsyncJobResult`` call. Let's get started and give an example |
| of calling the ``listUsers`` API in Python. |
| |
| First you will need to generate keys to make requests. Going through the |
| dashboard, go under ``Accounts`` select the appropriate account then |
| click on ``Show Users`` select the intended users and generate keys |
| using the ``Generate Keys`` icon. You will see an ``API Key`` and |
| ``Secret Key`` field being generated. The keys will be of the form: |
| |
| :: |
| |
| API Key : XzAz0uC0t888gOzPs3HchY72qwDc7pUPIO8LxC-VkIHo4C3fvbEBY_Ccj8fo3mBapN5qRDg_0_EbGdbxi8oy1A |
| Secret Key: zmBOXAXPlfb-LIygOxUVblAbz7E47eukDS_0JYUxP3JAmknOYo56T0R-AcM7rK7SMyo11Y6XW22gyuXzOdiybQ |
| |
| Open a Python shell and import the basic modules necessary to make the |
| request. Do note that this request could be made many different ways, |
| this is just a low level example. The ``urllib*`` modules are used to |
| make the http request and do url encoding. The ``hashlib`` module gives |
| us the sha1 hash function. It used to geenrate the ``hmac`` (Keyed |
| Hashing for Message Authentication) using the secretkey. The result is |
| encoded using the ``base64`` module. |
| |
| :: |
| |
| $python |
| Python 2.7.3 (default, Nov 17 2012, 19:54:34) |
| [GCC 4.2.1 Compatible Apple Clang 4.1 ((tags/Apple/clang-421.11.66))] on darwin |
| Type "help", "copyright", "credits" or "license" for more information. |
| >>> import urllib2 |
| >>> import urllib |
| >>> import hashlib |
| >>> import hmac |
| >>> import base64 |
| |
| Define the endpoint of the Cloud, the command that you want to execute, |
| the type of the response (i.e XML or JSON) and the keys of the user. |
| Note that we do not put the secretkey in our request dictionary because |
| it is only used to compute the hmac. |
| |
| :: |
| |
| >>> baseurl='http://localhost:8080/client/api?' |
| >>> request={} |
| >>> request['command']='listUsers' |
| >>> request['response']='json' |
| >>> request['apikey']='plgWJfZK4gyS3mOMTVmjUVg-X-jlWlnfaUJ9GAbBbf9EdM-kAYMmAiLqzzq1ElZLYq_u38zCm0bewzGUdP66mg' |
| >>> secretkey='VDaACYb0LV9eNjTetIOElcVQkvJck_J_QljX_FcHRj87ZKiy0z0ty0ZsYBkoXkY9b7eq1EhwJaw7FF3akA3KBQ' |
| |
| Build the base request string, the combination of all the key/pairs of |
| the request, url encoded and joined with ampersand. |
| |
| :: |
| |
| >>> request_str='&'.join(['='.join([k,urllib.quote_plus(request[k])]) for k in request.keys()]) |
| >>> request_str |
| 'apikey=plgWJfZK4gyS3mOMTVmjUVg-X-jlWlnfaUJ9GAbBbf9EdM-kAYMmAiLqzzq1ElZLYq_u38zCm0bewzGUdP66mg&command=listUsers&response=json' |
| |
| Compute the signature with hmac, do a 64 bit encoding and a url |
| encoding, the string used for the signature is similar to the base |
| request string shown above but the keys/values are lower cased and |
| joined in a sorted order |
| |
| :: |
| |
| >>> sig_str='&'.join(['='.join([k.lower(),urllib.quote_plus(request[k].lower().replace('+','%20'))])for k in sorted(request.iterkeys())]) |
| >>> sig_str |
| 'apikey=plgwjfzk4gys3momtvmjuvg-x-jlwlnfauj9gabbbf9edm-kaymmailqzzq1elzlyq_u38zcm0bewzgudp66mg&command=listusers&response=json' |
| >>> sig=hmac.new(secretkey,sig_str,hashlib.sha1).digest() |
| >>> sig |
| 'M:]\x0e\xaf\xfb\x8f\xf2y\xf1p\x91\x1e\x89\x8a\xa1\x05\xc4A\xdb' |
| >>> sig=base64.encodestring(hmac.new(secretkey,sig_str,hashlib.sha1).digest()) |
| >>> sig |
| 'TTpdDq/7j/J58XCRHomKoQXEQds=\n' |
| >>> sig=base64.encodestring(hmac.new(secretkey,sig_str,hashlib.sha1).digest()).strip() |
| >>> sig |
| 'TTpdDq/7j/J58XCRHomKoQXEQds=' |
| >>> sig=urllib.quote_plus(base64.encodestring(hmac.new(secretkey,sig_str,hashlib.sha1).digest()).strip()) |
| |
| Finally, build the entire string by joining the baseurl, the request str |
| and the signature. Then do an http GET: |
| |
| :: |
| |
| >>> req=baseurl+request_str+'&signature='+sig |
| >>> req |
| 'http://localhost:8080/client/api?apikey=plgWJfZK4gyS3mOMTVmjUVg-X-jlWlnfaUJ9GAbBbf9EdM-kAYMmAiLqzzq1ElZLYq_u38zCm0bewzGUdP66mg&command=listUsers&response=json&signature=TTpdDq%2F7j%2FJ58XCRHomKoQXEQds%3D' |
| >>> res=urllib2.urlopen(req) |
| >>> res.read() |
| { |
| "listusersresponse" : { |
| "count":1 , |
| "user" : [ |
| { |
| "id":"7ed6d5da-93b2-4545-a502-23d20b48ef2a", |
| "username":"admin", |
| "firstname":"admin", |
| "lastname":"cloud", |
| "created":"2012-07-05T12:18:27-0700", |
| "state":"enabled", |
| "account":"admin", |
| "accounttype":1, |
| "domainid":"8a111e58-e155-4482-93ce-84efff3c7c77", |
| "domain":"ROOT", |
| "apikey":"plgWJfZK4gyS3mOMTVmjUVg-X-jlWlnfaUJ9GAbBbf9EdM-kAYMmAiLqzzq1ElZLYq_u38zCm0bewzGUdP66mg", |
| "secretkey":"VDaACYb0LV9eNjTetIOElcVQkvJck_J_QljX_FcHRj87ZKiy0z0ty0ZsYBkoXkY9b7eq1EhwJaw7FF3akA3KBQ", |
| "accountid":"7548ac03-af1d-4c1c-9064-2f3e2c0eda0d" |
| } |
| ] |
| } |
| } |
| |
| |
| All the clients that you will find on github will implement this |
| signature technique, you should not have to do it by hand. Now that you |
| have explored the API through the UI and that you understand how to make |
| low level calls, pick your favorite client of use |
| `CloudMonkey <https://pypi.python.org/pypi/cloudmonkey/>`__. CloudMonkey |
| is a sub-project of Apache CloudStack and gives operators/developers the |
| ability to use any of the API methods. It has nice auto-completion and |
| help feature as well as an API discovery mechanism since 4.2. |
| |
| |
| Testing the AWS API interface |
| ----------------------------- |
| |
| While the native CloudStack API is not a standard, CloudStack provides a |
| AWS EC2 compatible interface. It has the great advantage that existing |
| tools written with EC2 libraries can be re-used against a CloudStack |
| based cloud. In the installation books we described how to run this |
| interface from installing packages. In this section we show you how to |
| compile the interface with ``maven`` and test it with Python boto |
| module. |
| |
| Starting from a running management server (with DevCloud for instance), |
| start the AWS API interface in a separate shell with: |
| |
| :: |
| |
| mvn -Pawsapi -pl :cloud-awsapi jetty:run |
| |
| Log into the CloudStack UI ``http://localhost:8080/client``, go to |
| *Service Offerings* and edit one of the compute offerings to have the |
| name ``m1.small`` or any of the other AWS EC2 instance types. |
| |
| With access and secret keys generated for a user you should now be able |
| to use Python `Boto <http://docs.pythonboto.org/en/latest/>`__ module: |
| |
| :: |
| |
| import boto |
| import boto.ec2 |
| |
| accesskey="2IUSA5xylbsPSnBQFoWXKg3RvjHgsufcKhC1SeiCbeEc0obKwUlwJamB_gFmMJkFHYHTIafpUx0pHcfLvt-dzw" |
| secretkey="oxV5Dhhk5ufNowey7OVHgWxCBVS4deTl9qL0EqMthfPBuy3ScHPo2fifDxw1aXeL5cyH10hnLOKjyKphcXGeDA" |
| |
| region = boto.ec2.regioninfo.RegionInfo(name="ROOT", endpoint="localhost") |
| conn = boto.connect_ec2(aws_access_key_id=accesskey, aws_secret_access_key=secretkey, is_secure=False, region=region, port=7080, path="/awsapi", api_version="2012-08-15") |
| |
| images=conn.get_all_images() |
| print images |
| |
| res = images[0].run(instance_type='m1.small',security_groups=['default']) |
| |
| Note the new ``api_version`` number in the connection object and also |
| note that there was no user registration to make like in previous |
| CloudStack releases. |
| |
| |
| Conclusions |
| ----------- |
| |
| CloudStack is a mostly Java application running with Tomcat and Mysql. |
| It consists of a management server and depending on the hypervisors |
| being used, an agent installed on the hypervisor farm. To complete a |
| Cloud infrastructure however you will also need some Zone wide storage |
| a.k.a Secondary Storage and some Cluster wide storage a.k.a Primary |
| storage. The choice of hypervisor, storage solution and type of Zone |
| (i.e Basic vs. Advanced) will dictate how complex your installation can |
| be. As a quick start, you might want to consider KVM+NFS and a Basic |
| Zone. |
| |
| If you've run into any problems with this, please ask on the |
| cloudstack-dev `mailing list </mailing-lists.html>`__. |