Newer posts are loading.
You are at the newest post.
Click here to check if anything new just came in.

December 27 2013

20:13

Coding With Koding

Cloud IDEs have been around for a little while now, and they have been pretty good for things like pair programming, or cases where you want to code consistently no matter where you are. Koding just came out of private beta, and they would like to take this notion a couple steps further, with their “cloud ecosystem”.

In this article we will take a look at what Koding is, as-well as some of the benefits you can get from using it.

Koding is kind of hard to explain, because there isn’t really a product similar to it on the market. So to better illustrate all of its moving parts, let’s split the service up and begin with the development environment.


The Development Environment

When you sign up to Koding, out of the box you get your own sub-domain (.kd.io) your own VPS, and some built in web apps to manage your new resources.

Through the admin, you have the ability to create other sub-domains on top of your current URL and spin up new VPSs all through an easy to use UI.

The Dev Dashboard

VMs

Now these VMs are not your average micro instances that a lot of services offer, these are full fledged VMs with access to eight processors and a full GB of RAM so you can easily run just about any app, and if you want to play around with things like cluster setups or networks, you can easily spin up multiple instances for just $5 a month.

So in terms of processing power, these instances can potentially be as powerful as your own computer, and they are definitely better than loading a local virtual machine.

What the people over at Koding are trying to do is empower developers to learn through experimentation and just try things that they wouldn’t necessarily want to try locally, or just don’t have the resources to do it.

These instances initialize in a matter of seconds, and if you make mistakes and break some system files, you can easily just re-initialize the server and it will restore everything under the home folder. Essentially, you’ll have a new instance but all the files you created in the home folder are preserved.

Another thing they provide, which is actually a pretty big deal in some situations, is root access to all your servers. Koding is a very transparent service, you get a VM and you can literally do whatever you want with it. Anything you can do with a standard VPS, you can do with their VMs.

OS & Languages

As for the instances themselves, they come with Ubuntu installed, and pretty much every language I can think of, including:

  • PHP
  • GO
  • Node.js
  • Ruby
  • Perl
  • Haskell

Among others, so you are pretty much good to go out of the box.

Apps

With Koding, you sort of have two layers of applications. You have the VM, which like I mentioned, you can run anything you want on, but besides that, you have ‘Koding Apps’ which are web-apps that run on Koding itself and through them you can manage all of your Koding resources.

Some of the default apps you have available to you are things like admin panels for databases or frameworks and editors for code and images. The default code editor that comes pre-installed is the Ace code editor for regular development, or Firepad if you want to work collaboratively via the teamwork app.

Apps

Besides all these really cool apps, you have the ability to create your own. They are written using plain JavaScript (CoffeScript) and the KD framework (from Koding). Now because they have just come out of beta, there isn’t really a start-to-finish documentation site up yet, but there are two Koding apps available (kodepad and app maker) which are built to give you a sort of structure, with examples. Besides those, I’d advise searching Github for “.kdapp” and just looking at how other apps were built to get an idea of what sort of things are possible and how to accomplish them.

Altogether, it sort of has the feeling of a cloud “operating-system” where you have the VMs as resources but the Koding apps allow you to manage your resources and set them up just the way you like. This means if your company has a sort of boilerplate setup, you can create a kdapp which will configure a new VM with the files and software you need, and then whenever you spin up a new instance your app can configure it just the way you like.

Additionally, kdapps can be a standalone tool which just modifies files like the Ace editor, or image editors that are available. This means if you put in the time, you can essentially build your own dev environment, with all the custom tools which make you more efficient at building apps.

Everything I have mentioned up to now really only covers half of what Koding is, and that is the development environment part. Koding also has a social/organizational side of it, which compliments the development features and sort of boosts the platforms value.


Developer Community

By default, when you sign up to Koding, you are added to the Koding “group”; all the features, like the activity notifications, topics, code-snippets, etc.. are all coming from this default group. It’s kind of cool to get all the updates from users around the world, and you can filter by topic by going to the topics page and selecting something you are interested in. But where these features really show potential is when you create your own group.

Koding Topics Page

If you use Koding as a group, then you can take advantage of all these features to easily see what your colleagues have done, get updates and snippets from them, and filter all the posts by project using the topics as tags.

In a group, you can create shared VMs which multiple users can have access to, or credit users in the group money so they can create their own VMs and work privately.

It’s one of those situations where they probably could’ve just released the cloud development environment, the social network, or the project management, and it would have fit a market; but having them all work together and for free, is something to really think about.

I have been saying a lot of positive things about cloud environments, but there are some drawbacks when comparing them to developing locally which are worth at least mentioning.


Cloud vs. Local Development

Drawbacks

One of the main things is that you aren’t really getting what I would call an IDE. For example, if you take a look at the Ace editor, it’s a great editor, but when you stack it up against a full fledged IDE like PhpStorm, they don’t compare. Ace is merely a code editor while PhpStorm contains all the tools you would need from testing to refactoring, all in one app.

The other drawback is simply latency, now compared to other web IDEs I haven’t had too much of an issue with this on Koding, but still, it doesn’t compare to a local setup. When you perform an action like opening a document, it could sometimes take a second to open.

So to summarize, developing online may not have all the tools you are used to working with, and it may not be as fast as doing it locally. But when you develop locally, you lose out on the powerful VMs and all the project management / social features.

Luckily you don’t have to make a choice. Editing code online is always possible so you don’t have to sacrifice on that front, but if you prefer coding locally with your own tools, you have full SSH access to your machines. So whether you want to use FTP, SCP, GIT, or any other kind of tool to transfer your changes to the server, you are given those options just like a standard VPS.


Setting Up SSH & Rsync

Now, I have already covered how to setup a bare GIT repo to deploy to your server, so it’s redundant to cover that process again, but let’s take a look at setting up your Koding account with an SSH key and using rsync to transfer your project to and from Koding.

For the unfamiliar, rsync is a utility for transferring large projects to and from your computer. Where it kind of differs from something like SCP, and the reason it’s good at working with large projects, is that it will scan the files both locally and remotely and only transfer the files that have changed. If you are working on any kind of project, you are going to have some framework system files, some boilerplate code, images, etc.. and you don’t really want to send them on every request, so rsync is a really good choice for stuff like this.

It’s not as good as GIT, you don’t get any form of version control, but if you are using Koding as a test environment and you just want to throw files up, or pull them down, rsync is the tool for the job.

The first step is pretty simple and it’s to get SSH setup; you just need to grab your public key (on a Mac you can run cat .ssh/id_rsa.pub | pbcopy from a terminal window to copy the key) and then add it to your account page on Koding. The next thing you need to do is configure your computer to connect. Koding requires you to use their proxy as a tunnel to your server, so on a Unix based system, you can just create a file named ‘config‘ with the following inside (you need to replace this with your Koding username):

Host *.kd.io
    User <username>
    ProxyCommand ssh %r@ssh.koding.com nc %h %p

If you are on a Windows system, refer to their guide to see how to setup the proxy using Putty.

With that in place, you can run:

ssh vm-<vm number>.<username>.koding.kd.io

So for example, using my username, on the first default VM (which is number 0) you would run the following:

ssh vm-0.gabrielmanricks.koding.kd.io

If all went well, you should connect and see the Koding terminal message. If it doesn’t want to connect, make sure you added the public key and make sure the VM is on in Koding (your VMs turn off when you haven’t used them for about 20 minutes).

With that setup, we can now create a local project. We don’t really need anything fancy here, so for this example I am just going to create a simple hello world HTML file inside a blank directory:

<!DOCTYPE HTML>
<html>
    <head>
        <title>Koding Demo</title>
    </head>
    <body>
        <h1>Hello rsync</h1>
    </body>
</html>

Save this file inside your projects folder and then run:

rsync -rvza --delete ./ vm-<vm number>.<username>.koding.kd.io:~/Web/

This will copy the entire contents of the current local folder to the remote directory deleting any remote files that are not in the current folder. If you ever make changes remotely, you can easily pull them down by reversing the paths like so:

rsync -rvza vm-<vm number>.<username>.koding.kd.io:~/Web/ ./

Now these commands are a bit long, and if you plan on developing in this manner, you are going to want to create some shortcuts. One simple way is to just create bash aliases, but you may have multiple servers, and for each you would need an alias for each direction, so let’s just create a simple bash script which can accept the VM number along with the username, and the desired direction you want the files to go, and it will perform the transfer.


Bash Primer

I’m not going to cover all of Bash’s syntax, just the parts we need for this script.

First we need the variables, inside a bash script you define variables by typing name=value. For example, if we wanted to set a variable that contains a message, we would type:

message="Hello"

There shouldn’t be any spaces around the equals sign for it to work. Once set, you can then retrieve the value of a variable by typing its name with a dollar sign before it. So to print the above variable’s value, we would type:

echo $message

Besides the variables that you define and set, you can use a couple of global variables that are set by your environment. These may be different according to your setup, but the ones we will be using are $USER for the currently logged in user and $PWD for the current folder. You can see what variables are in your environment by adding printenv to your code. This will print out all the environment’s current variables.

The next thing our script will need, is to be able to accept command line arguments. This is actually really easy to do, as they become numbered variables. So $1 represents the first parameter, $2 is the second and so on.

The last thing we will need to use in our script are if statements. These are similar to how you would write an if statement in most programming languages, with a few noticeable quirks:

if [ expression ]
then
    do something here
else
    do something else here
fi

In bash scripts you have the expression between a pair of square brackets, and you have to leave a space between the brackets and the expression. You should also note that the then line is a requirement. The last difference, which is a little different, and is found in other bash structures is the fi keyword. Basically you just type the if backwards, it’s the same for a switch statement for example, you start the switch block with case and then you end it with esac (case reversed).

So with this information, let’s construct a simple script to help us upload and download our code to Koding:


Building Our Script

To begin, we need the whole-shebang to tell the computer to run it as a shell script and then I will create a simple helper function which will tell the user how to use this command:

#!/bin/sh

function koding_usage
{
    echo "Usage: koding [push|pull] <vm_number> <username>"
    exit 1
}

If you are new to exit codes, 0 means it exited successfully and is the default returned when a script finishes, whereas anything else is an exit code for when an error has occurred. So if this function gets called, it means that the script wasn’t used correctly and we will exit with an error code.

Next, we need to make sure the arguments were passed in correctly and in the process, collect them and store them in some helper variables:

if [ "$1" = "" ]; then
    echo "Command Required"
    koding_usage
fi

if [ "$1" != "push" ] && [ "$1" != "pull" ]; then
    echo "You Can Only push or pull"
    koding_usage
else
    command=$1
fi

if [ "$2" = "" ]; then
    echo "VM Number Required"
    koding_usage
else
    vmnumber=$2
fi

if [ "$3" = "" ]; then
    username=$USER
else
    username=$3
fi

In this code, we are making four different checks:

  1. we check if there is a first parameter
  2. we check to make sure the first parameter is either ‘push‘ or ‘pull
  3. we make sure there is a second parameter
  4. we check whether the third parameter was set

In the first three if statements, if there was an issue we echo out a message and then call our helper method from above. For the last one though, if no username was supplied we will just use the currently logged in user’s username. So if your computer’s username is the same as your Koding username, you can leave the last parameter off.

The last thing we need to do, is actually run the rsync commands based on the command requested (push or pull):

if [ "$command" = "push" ]; then
    rsync -rvza --delete $PWD/ vm-$vmnumber.$username.koding.kd.io:~/Web
else
    rsync -rvza vm-$vmnumber.$username.koding.kd.io:~/Web/ $PWD
fi

You can see we are just placing the variables we collected (along with the current folder $PWD) right into the command. Since this is a shell script, you can just place shell commands straight in, like I did above

Now save the file and name it koding and then make it executable (you can do this by running chmod +x koding) and last but not least, move this file to your bin folder:

mv koding /usr/local/bin/

If you did everything correctly, you should be able to run koding and see our usage message come up. So now you can make a quick change to the example project above and simply run:

koding push 0

Assuming you don’t need the username property, and your current folder will be transferred as the Web directory on your server, named vm-0. The same goes for if you make changes online, you can cd into the local project folder and run:

koding pull 0

And you will receive all the updates.


Conclusion

Koding is a really powerful tool for prototyping and learning through experimentation. It has really cool social and project management capabilities and being able to code with someone else, live, can make a huge difference when you are trying to debug some code. Not to mention this all being free, means there really isn’t a reason you wouldn’t want to use this.

I really like the idea of having kd apps which run outside the VMs and I think it will be cool to see where people will take that and what kind of tools people will build.

You can sign up to Koding by visiting koding.com.

Thank you for reading, I hope you enjoyed it, if you have any questions feel free to leave me a comment down below, on twitter or via the Nettuts+ IRC channel (#nettuts on freenode).

September 18 2013

06:30

Freelancers Rejoice: Billbooks Helps You Run Your Business Successfully


  

Invoicing is a task that does not appeal to a lot of people. Yet, if it is not done properly, you’ll never get paid for all the great work you’ve done. There is no getting round it. Whether it is Google Sheets or Excel or any other kind of solution, you need an easy and reliable way to administer your bills and expenses. Billbooks is a fairly new service that wants to help you get these things done. We here at Noupe have taken a deeper look at what you can expect…

August 09 2013

15:52

MonstaFTP: FTP-Client as Cloud-App on Your Webspace


  

If there is a tiny little bit of space left on your webspace and you got that one sub-domain left to use, you should definitely take a look at MonstaFTP, a brand-new, free PHP script. MonstaFTP, released as Open Source under a GPL license, lets you access FTP server´s comfortably from right inside your browser. In combination with Chrome you can even upload whole folder structures via drag & drop. Generally, all modern browsers are supported.

February 27 2012

21:16

Elevate Your PHP to the Cloud

This article will walk you through cloud hosting for your PHP application with Pagoda Box. It’ll detail how to handle PHP dependencies, get your MySQL databases up and running (and debug locally), and customise various aspects of PHP with ease.


Introduction

As a developer who has been playing around with PHP since the age of 11, it’s hard to remember many things that have absolutely changed the way I develop. In 2007, I picked up CodeIgniter, which made me rethink how I structure my code and use OOP to get things done. In 2010, I began working with Git and Git Flow for teamwork and branching, but, recently, the biggest thing to change my development workflow has been one “Platform as a Service,” called Pagoda Box.

You might be a rockstar developer who knows how to set up a LAMP stack, but how much of your potential development time do you waste setting it up, optimizing it, securing things, locking it down, scaling resources and monitoring traffic.

Every day, I spot a developer battling to defend his server from some group of hackers or script kiddies, getting port flooded, having trouble getting some random security patch working, struggling to migrate to larger more powerful servers, getting mad trying to set up Capistrano, the list goes on. Services like Pagoda Box can help you skip all of that; so let’s see how.


Step 1 - Register With Pagoda Box

The first step is to grab yourself an account. It’s free, so go ahead.

Register

Step 2 - Create Your Application

Each application needs to have a unique name, as they are also used for preview URLs. You can call this application whatever you wish, as you will be hiding it behind a domain shortly, but call it something obvious and memorable.

SSH Key form

Step 3 - Set Up Git

Git is an extremely useful version management system. Right now, it is massively popular thanks to sites like GitHub who allow for free social code hosting, but it is also great for deploying your code.

If you are new to Git then try the crash course.

If you haven’t already, set up Git. Their documentation will help you get started. Windows users will find it a little more difficult than OSX or Linux users, so if you have a Virtual Machine of Ubuntu lying around, now would be a great time to fire it up.


Step 4 - Create Your SSH Key

To push your code to Pagoda Box you need to authorize your computer to have push access to applications on your account. Create an SSH key and paste it here.

SSH Key form

Step 5 - Deploy Your Code

First, set up a folder for your application and set the Git remotes. Remotes are essentially nicknames for a repository URL. By setting up this remote, we’re letting our local Git repo know how to push code to Pagoda Box.

	$ mkdir my-awesome-app && cd my-awesome-app
	$ git init
	Initialized empty Git repository in /Users/phil/Sites/my-awesome-app/.git/
	$ git remote add pagoda git@git.pagodabox.com:my-awesome-app.git

Now with all of this account and environment setup done, we can start deploying code. For now, we’ll deploy a simple Hello World app:

	$ echo '<?php echo "Hello World!";?>' > index.php

This is a little command line trick to put some text into a file. You could alternatively create this file with your favorite text editor or IDE.

	$ git add index.php
	$ git commit -m "OH HAI"
	[master (root-commit) 6aa23f4] OH HAI
	 1 files changed, 1 insertions(+), 0 deletions(-)
	 create mode 100644 index.php

So far, we have made a new folder for our website, initialized Git, added a remote which tells Git where the Pagoda Box app lives, and added a new index.php file, which will simply say Hello World!. Next:

	$ git push pagoda master
	Counting objects: 3, done.
	Writing objects: 100% (3/3), 244 bytes, done.
	Total 3 (delta 0), reused 0 (delta 0)

	:: Auto deploy enabled for 'master'
	 +> to change, visit https://dashboard.pagodabox.com/apps/my-awesome-app/admin
	:: Deploying to 6aa23f4 on master
	:: Parsing Boxfile
	:: Executing deploy
	 +> Init submodules
	 +> Booting web1.1
	  - [22-Feb-2012 20:38:41] NOTICE: fpm is running, pid 54
	  - [22-Feb-2012 20:38:41] NOTICE: ready to handle connections
	 +> Propagating network updates
	:: Cleaning up

	To git@git.pagodabox.com:my-awesome-app.git
	 * [new branch]  master -> master

This is where the magic happens. You will push to a Git remote like any other repository, but then you will see the output of Pagoda Box taking over and creating a deployment. This will fire up a new instance each time and switch over from the live instance to this new instance instantaneously, meaning immediate updates – unlike slow FTP-based file deployment systems. Also unlike some similar services, all of your temporary files (cache, logs, image uploads, etc) will be there after any resize or re-deployment. Awesome!

Now if you refresh the Pagoda Box page, you will see a Dashboard with all sorts of options.


Step 6 - Creating a Boxfile

Pagoda Box has a special config file: Boxfile. This goes in the root of your application. An advanced example may look something like this:

web1:

  ################################################
  ## GENERAL SETTINGS
  ################################################
  shared_writable_dirs: [/system/cms/cache, /system/cms/logs, /uploads, /addons]

  ################################################
  ## WEB SPECIFIC SETTINGS
  ################################################
  index_list: [index.php]

  ################################################
  ## PHP SPECIFIC SETTINGS
  ################################################
  php_version: 5.3.8
  php_extensions: [mysqli, curl, gd, mbstring]
  php_date_timezone: Europe/London
  php_max_execution_time: 30
  php_max_input_time: 60
  php_post_max_size: 25M
  php_file_uploads: On
  php_upload_max_filesize: 20M
  php_max_file_uploads: 20

This example gives you the chance to create writable folders, set your index_list (which is index.php by default) and change all sorts of PHP settings that would normally be in a php.ini file.

The most important line here is:

	php_extensions: [mysqli, curl, gd, mbstring]

Pagoda Box allows you to list your applications dependencies. The “mysqli” driver is “MySQL Improved” which you should start using, as “mysql” is going to be deprecated in PHP 5.4. “curl” and “gd” are fairly standard and “mbstring” helps you work with UTF-8 code.

It’s good to know they are available – along with plenty of others – but for this tutorial we’ll only need the following:

	php_extensions: [pdo, pdo_mysql]

So let’s make our new Boxfile and save it:

web1:
  php_extensions: [pdo, pdo_mysql]

We’ll be using this later on.


Step 7 - Create a Database

At the time of this writing, Pagoda Box only supports MySQL databases, which is fine as that is what the majority of developers use.

We can fire up as many small database instances as we like for free; we only start paying when they get bigger, so you won’t get surprised by a massive bill just for building a website. Just like the web instances, they can also be scaled to grow with your website.

New Database

To make a new one, click the + icon and give it a name. You’ll see a progress bar up top while it builds; then the page will refresh.


Step 8 - Connecting From Your App

Connecting via PHP is a cinch. You are given multiple $_SERVER variables, which contain credentials for each database you have. This means you can keep hard-coded passwords out of your application – which is very useful if you don’t want all of your developers to see live passwords, or if you have your complete website on GitHub, like some people are beginning to do.

$db = new PDO(sprintf('mysql:host=%s;dbname=%s;port=%s', $_SERVER['DB1_HOST'], $_SERVER['DB1_NAME'], $_SERVER['DB1_PORT']), $_SERVER['DB1_USER'], $_SERVER['DB1_PASS']);

This is a basic example of the variables in use – connecting to your MySQL database via the PDO extension. If you’re using a framework, such as CodeIgniter, you can shove those variables into your database.php config files.


Step 9 - Connecting Remotely

Some web servers – especially those run-of-the-mill cPanel set-ups – have phpMyAdmin installed and can be configured to allow remote access to the MySQL databases.

Instead of this approach, Pagoda Box uses Ruby Gem for – amongst other things – creating a temporary secure SSH tunnel. This means your MySQL databases are locked down behind a firewall and are only accessible via this secure SSH connection.

So, to install the gem run:

	$ sudo gem install pagoda

Then to create the tunnel, simply run:

	$ pagoda tunnel db1

The first time you run this (or any other pagoda gem command) you should be asked for a username and password. This is your Pagoda Box username and password, and is needed so that the gem can act on your behalf and is nothing to do with your database.

	$ pagoda tunnel db1
	it appears this is the first time you have used our client
	  Username: someguy
	  Password: 

	Tunnel Established!  Accepting connections on :
	-----------------------------------------------

	HOST : 127.0.0.1 (or localhost)
	PORT : 3307
	USER : (found in pagodabox dashboard)
	PASS : (found in pagodabox dashboard)

	-----------------------------------------------
	(note : ctrl-c To close this tunnel)

Go to your dashboard and click on the database, then click “Show Credentials” to see a info window like this:

Database Credentials

Use these credentials to connect. Don’t forget to specify which port; it is listed in the output from the gem above – not the green box. Remember, you are connecting to the local tunnel, not directly to the database.


Step 10 - Making a Blog

What sort of tutorial would this be if it didn’t involve making a blog in 20 minutes?

For all development you should really be building things locally using MAMP, XAMPP, WAMP, etc., then deploying code and database changes using some sort of “Migrations” or schema change tracking stuff, but we’ll do this the old fashioned way.

First connect to your database remotely via the tunnel, then run this query to build a new table:

CREATE TABLE posts (
  'id' int(11) NOT NULL AUTO_INCREMENT,
  'title' varchar(255) NOT NULL,
  'slug' varchar(255) NOT NULL,
  'summary' text NOT NULL,
  'body' text NOT NULL,
  'created_at' int(11) NOT NULL,
  'updated_at' int(11) NOT NULL,
  PRIMARY KEY (id)
) ENGINE=InnoDB;

INSERT INTO posts VALUES
('1', 'Women love guys who use FuelPHP', 'women-love-guys-who-use-fuelphp', 'It is a well proven fact that girls love developers, but things have never been so good for PHP developers. Everyone who starts using FuelPHP gets 150% more women within the first month. Fact.', 'It is a well proven fact that girls love developers, but things have never been so good for PHP developers. Everyone who starts using FuelPHP gets 150% more women within the first month. Fact.', '1322825332', '1322934052'),
('2', 'People who echo HTML from apps die younger', 'bad-practises', 'Scientists have proven that PHP developers who echo HTML directly our of PHP files die younger. Often it happens while the developer is in the office. While sat at their chairs they suffer multiple wounds, but apparently there are no witnesses, even though their colleagues were in the office "refactoring bad code" all day.', 'Important body text', '1322826479', '1322826479');

With some test posts in place we can create this index.php:

<?php 

	$db = new PDO(sprintf('mysql:host=%s;dbname=%s;port=%s', $_SERVER['DB1_HOST'], $_SERVER['DB1_NAME'], $_SERVER['DB1_PORT']), $_SERVER['DB1_USER'], $_SERVER['DB1_PASS']);

	$posts = array();
	foreach ($db->query('SELECT * from posts') as $row)
	{
		echo "<h2>{$row['title']}</h2>";
		echo "<p><em>Posted: ".date('l jS of F Y', $row['created_at'])."</em><br />";  		echo $row['summary']."</p>";
	}

With that file saved, and our new Boxfile (from step 6) in place, we can deploy these new changes:

	$ git add Boxfile index.php
	$ git commit -m "Added Boxfile and deployed index.php changes"
	$ git push pagoda master

Go to “http://my-awesome-app.pagodabox.com” and see the output:

Database Credentials

This is clearly not something that you’ll want running on your website, but it does enough. You can see that your database content is being output to the browser, and your demo URL is working. You can replace this with your CMS of choice, or build something custom.


Step 11 - Use a Real Domain

There is no point having your wonderful new blog on a pagodabox.com subdomain; so let’s park a domain on top of it.

First, in the DNS/SSL tab of your dashboard, add in some entries for your domain:

Database Credentials

Now that your application is ready to accept a domain you should head over to whoever handles the DNS for your domain. Go to the DNS management area and set an A record for "myawesomedomain.com" to be "50.97.141.37" – which is the IP address listed on the interface for your app. These IP addresses are not unique per application, but will not always be the same. Set a CNAME record for "www.myawesomedomain.com" to alias "myawesomedomain.com" and you should be all set.


Summary

This may all seem rather different from how you work at the moment, but start to think about how much work you are saving yourself in the long run. Using PaaS is the same reason we use jQuery over native JavaScript, or PHP frameworks over writing native PHP. Why mess around with minor details when you can instead focus on building an awesome app?

Other alternatives you might consider are [PHPFog](http://phpfog.com/) and [Orchestr.io](http://www.engineyard.com/products/orchestra), which both offer similar services. Have fun, and thanks for reading!


December 04 2011

10:00

Are We Ready For The Cloud?

Now we can’t imagine life without computers in our bags and smartphones in our pockets. Humans have now become ‘obsessed’ with connectivity. But how do we keep our gadgets and devices organized? How do we manage both our business and personal data across devices?

This is when today’s ‘hottest’ service in technology comes in. Cloud computing is a service whereby shared resources, data, and software are provided to computers and other devices over a network, usually via the internet. Apple’s version is the iCloud, which upon its introduction has replaced Apple’s MobileMe. Apple iCloud was introduced by Steve Jobs during Apple’s Worldwide Developers Conference in June of 2011–an event that announced the OS X Lion and the iOS 5 for the iPod, iPhone and the iPad.

iCloud in a Nutshell


iCloud, simply put, is a hard drive in the sky. It allows you to quickly access your data from your devices: Macbook, PC, iPhone, iPod and iPad. This data can be anything and everything you can think of: your music, applications, contacts and photos across all your devices. As long as you are connected, you can access your important images and documents when you’re on the go.

Image from Lets Go Ditigal

Cloud storage is not a new concept. It has been around for a while, but since iCloud’s introduction it has become a growing tech trend. Through cloud computing, cloud storage provides password-protected access to your online storage space. Cloud storage can be used as additional space and a back up copy of your hard drive. Moreover, it is an effective way to make the files available to your other gadgets and devices.

iCloud is not the first online storage service by Apple. MobileMe preceded iCloud, and offered synchronization services at an annual fee. MobileMe was created to ensure synchronization of data between all devices–including e-mails, calendars, contacts, photos, and iWeb and iDisk services. Apple then revamped MobileMe, merging its features with their newly offered Apple iCloud service. Since then iCloud has replaced MobileMe, with more features and more flexibility.

Like MobileMe, the biggest advantage of iCloud is its Apple software integration. This makes the iCloud the most practical cloud storage choice, especially if you own mostly Apple products: Macbook, iPod, iPad, iTouch, the like. It ensures that all data is continuously synchronized while connected to the internet. The iCloud can even include Apple devices owned by your family members and household, too.

The iCloud is now available to all Mac devices in the iOS 5 operating system, and Macs with the OS X Lion operating system. iCloud is free and comes with all the new devices. After getting an account for iCloud, you get 5 gigabytes worth of storage, for free. iCloud backups happen when you’re not using the device.

But, is iCloud Ready for Us?


iCloud does not offer the option to stream your music and videos from the cloud (as of writing). It would’ve been great if users could have the option to play the media content directly instead of the need to download it first. Partial backups are made while you are sleeping, and changes include personal device settings, text messages, ring tones, app data, e-books, videos and apps you bought from iTunes. In addition, backups are done automatically in case you upgrade your OS or new hardware.

iCloud still isn’t perfect, though. One example: iCloud users are limited to the software designed to access that particular cloud. iCloud service is available as long as you have internet access, but still requires an application to manage and synchronize the connection to your data.

The Photo Stream still has many flaws. iCloud only syncs and spreads photos taken during the past 30 days. Which is annoying especially if you want to look at pictures from more than the past 30 days–maybe you want to show off your daughter’s graduation months ago or remember last year’s family reunion. It can be an inconvenience that Photo Stream doesn’t have this option. Aside from that, you can’t delete anything off the Photo Stream–just hope you do not sync any embarrassing or scandalous photos accidentally.

The first 5 GB is free, but if the free storage space is no longer sufficient, you can get iCloud storage plans at $20 a year (15 GB), $40 a year (25 GB) and $100 a year (55 GB).

There are still some flaws and gaps here and there. it’s limited in features, but still quite convenient to use. It’s useful, fantastic as a free back up service but not yet worth the money for a storage plan. The big ‘boom’ moment for Apple didn’t come with the iCloud yet.

Other iCloud Alternatives


Box.com

One of its most promising features is its recent availability to the iOS; making it a good contender as Apple’s main competitor. While iCloud boasts in keeping your apps, photos, music and videos in place, it is certainly flawed in sharing documents with others. Box on the other hand, is a champ and it even comes with the Google Docs integration.Upon downloading and signing up, you get a whooping 50 GB of free storage space–now compare that to iCloud’s meager 5 GB. Moreover, Box allows you to stream photos and music from the cloud to the AppleTv via Airplay. It cannot accept bigger uploads more than 100 mb– but at a staggering 50 GB of free storage, we’re not complaining at all.

Amazon Cloud Driver

The Amazon Cloud Driver is similar to the iCloud in terms of services and purchasing content. However, the former is more indiscriminate in a particular OS, so it does well on both Mac and PC but it doesn’t have the deep OS integration iCloud offers on the Mac and iOS systems. After sign up you get 5 GB of free storage. If you need more space, Amazon offers storage plans at 20 GB to 1000 GB. Now, you don’t have to worry about losing your files if your hard drive crashes, or gets lost or stolen.


Dropbox

Dropbox does not offer iCloud’s deep Mac OS integration, but is compatible with the Mac, Windows, Linux and all major devices the iPhone, iPad, Blackberry and Android phones. Dropbox offers 2 GB free storage space upon signing up. It offers storage plans up to 100 GB for subscriptions. Unlike the iCloud, all types of stored files will be counted against your total storage space limit.

SkyDrive

This is Microsoft’s version of the iCloud, but designed more to sharing documents, photos and videos between multiple users.SkyDrive offers free storage for up to 25 GB. SkyDrive offers integration with Microsoft products, just as iCloud is with Apple.

Older posts are this way If this message doesn't go away, click anywhere on the page to continue loading posts.
Could not load more posts
Maybe Soup is currently being updated? I'll try again automatically in a few seconds...
Just a second, loading more posts...
You've reached the end.

Don't be the product, buy the product!

Schweinderl