As far as I can see, GKE seems to be slighty more complex to configure and deploy an application (using Kubernetes direct files or Helm Charts or something else ?). Furthermore it seems to have no better pod failure detection or better performances ?
Why should we use GKE whereas there is GAE which only needs dispatch.yaml, app.yaml files and gcloud cli to deploy ?
Is there any technical or financial feedback against GAE ?
Finally, how can we make a choice between GKE and GAE ? What whould be the reason to not choose GAE ?
Google Kubernetes Engine(GKE) is a cluster manager and orchestration system for running your Docker containers. Google App Engine(GAE) is basically google managed containers.
They both try to provide you similar main benefits(scalability, redundancy, rollouts, rollbacks, etc.). The main difference is in their philosophy: GKE tries to provide you very fine grained control over everything about your cluster. GAE tries to get you run your apps with as little configuration/management as possible.
With GKE you have more control, but also more work for you. You need to configure the network, security, software updates etc. With GAE you don't need to worry about many of these things, and you can focus on your app.
One overseen benefit of using GKE is to be independent from the cloud provider.
When using kubernetes it is much easier to migrate to another cloud provider or even to a private cloud.
As a rule of thumb, when using a propietary solution you are bound to a cloud provider for good and bad. For example what will you do when your cloud provider decides to deprecate a certain runtime.
When using open source solutions, even when they are managed you are still a free person.
App engine is PaaS where as GKE is CaaS. Below are the comparison among than
Trying to share my thoughts for future visitors
Let me start with the below image and then we will see the OP's questions one-by-one:
As far as I can see, GKE seems to be slighty more complex to configure
and deploy an application (using Kubernetes direct files or Helm
Charts or something else ?).
When you see from the perspective of a client who does not want the overhead of managing the environment - basically a PaaS client - then, yes, Google Kubernetes Engine is slightly more complex as compared to Google App Engine.
As you can see in the above diagram as well - GKE is more towards the left, which it is a less vendor-managed cloud solution, so environment configuration and management overheads are expected.
Furthermore it seems to have no better pod failure detection or better
performances ?
I have not used Google App Engine but I can assure you that Google Kubernetes Engine is a certified Kubernetes (check more over here) so if you are running Kubernetes on Google App Engine, you can be sure that GKE is offering you same performance and features as Google App Engine.
Why should we use GKE whereas there is GAE which only needs
dispatch.yaml, app.yaml files and gcloud cli to deploy ?
As I mentioned in the start and as you can see in the above diagram as well that it is all about control over the environment - the more control you want over your environment, you will select a solution farther on the left side. And please note that more control means more overhead of environment management, and exactly that's the reason why people tend to choose solutions from farther on the right side.
Is there any technical or financial feedback against GAE ?
Both Google Kubernetes Engine and Google App Engine are highly successful and production-grade offerings from Google, so you can be sure about technical aspects. For financial aspects - you need to check their pricing model and see which will go more smoothly in your pockets.
Finally, how can we make a choice between GKE and GAE ? What whould be
the reason to not choose GAE ?
IMHO - the top three decision points could be:
How much you control you want over your environment
More control comes with more self-management, so are you ready to go through the overheads of a self-managed environment
Your budget
Specific to Docker based deployment, what are the differences between those two? Since Google App Engine Flexible now also supports Dockerfile based deployment and it is also fully-managed service, seems it's more preferred option rather than configuring Kubernetes deployment on Container Engine, isn't it?
What are the use cases where it's more preferred to use Google Container Engine over App Engine Flexible?
They are different things. App Engine Flexible is focused on application development - i.e. you have an application and you want to be deployed and managed by Google). On the other hand, Kubernetes is more about having your own infrastructure. Obviously, you can also deploy applications in Kubernetes but, as it's your "own" infrastructure, you are the one to directly manage how both the and the application will behave (create services, create scalability policies, RBAC, security policies...).
In this sense, Kubernetes is more flexible in what you can achieve. However, as a developer, you may not be interested in the infrastructure at all, only that your application works and scales. For this kind of profile, App Engine Flexible is more suitable.
If, on the other side, want to manage a complete Container infrastructure (more SRE profile), then Kubernetes is for you.
The main benefit apart from what is mentioned in Javier's answer is that using Kubernetes makes your application portable and independent of the underlying cloud platform. If you ever want to move your application to AWS, Azure, on-prem etc. you can do that with very few changes if you're using Kubernetes, while if you're on App Engine Flex, it'll require a lot more changes.
Another difference is if you want to create lots of different micro-services with complex structure, Kubernetes is more suited to that, instead of App Engine. It's not impossible to implement micro-service architecture in App Engine too. You can certainly use different yaml files, but those doesn't give you a lot of flexibility and any complex application will ultimately need to be ported.
Also, if you want to have stateful containers, you can't do that with App Engine Flex.
Kubernetes being an open-source project has more vibrant community than App Engine. Google is more focused on Kubernetes than App Engine and updates to Kubernetes are more frequent than App Engine.
But that doesn't mean App Engine is any less powerful. I have worked on complex applications serving hundreds of thousands (probably a million now) of users with App Engine (Both standard and flexible environment) and we never thought of migrating it out of GAE. I mean, if it can handle the traffic of Pokemon Go, it can certainly handle your app's too.
Performance wise someone did a comparison here. The summary results are as follows -
An important difference between the services is that App Engine Flex
biases automation to Google’s control whereas Kubernetes Engine
requires more oversight by the customer. Kubernetes Engine is evolving
more rapidly and is adding more powerful automation.
A subtle difference is that Flex uses containers as a means to an end.
Customarily, users of Flex could ignore that containers are being
employed because this is done behind the scenes. Kubernetes
Engine — as the name suggests — is predicated on containers and is
explicitly designed as a tool that facilitates the management of
services built from containers. With Flex, a service is always
n-containers of one type. With Kubernetes Engine, a service comprises
m-pods and the pods may themselves comprise p-containers.
It is practical to migrate an App Engine Flex deployment to GKE
In this case (!) Flex achieved greater throughput than GKE.
The increased velocity appears due to the rapidity with which App Engine
is able to signal auto-scaling events; GKE scales pods promptly
within an existing cluster of nodes but slightly more slowly to scale
up the number of nodes.
App Engine and GKE share fundamental GCP resources including the HTTP/S Load-Balancer service and Managed Infrastructure Groups auto-scaling.
For the same load, using the same VM size (1 vCPU and 1GB RAM): App Engine Flex scaled to 6 containers on 6 instances VMs (1 instance/VM ); GKE scaled to 10 pods (1 container/pod) on 3 VMs (50%).
If you are looking to run your application 24/7, GKE also offers more vCPU and RAM resources at a lower price compared to the App Engine as well. You can further reduce your running cost if you run your applications with preemptible VMs (up to 80% cheaper than regular VMs), on Kubernetes, your app will be restarted with seconds of downtime.
Another advantage of GKE is that you can run multiple applications within the same cluster whereas App Engine charges you per app deployed.
PS: I run multiple sites on a GKE cluster. Doing this on App Engine will cost me a few times more than what I am currently paying.
In addition to what already explained above, both GKE and APP Engine Flexible don't scale to zero. however GKE does come with persistent disks and TPU/GPU access which are not available with APP Engine Flexible.
I was wondering what the difference between App Engine & Compute Engine are. Can anyone explain the difference to me?
App Engine is a Platform-as-a-Service. It means that you simply deploy your code, and the platform does everything else for you. For example, if your app becomes very successful, App Engine will automatically create more instances to handle the increased volume.
Read more about App Engine
Compute Engine is an Infrastructure-as-a-Service. You have to create and configure your own virtual machine instances. It gives you more flexibility and generally costs much less than App Engine. The drawback is that you have to manage your app and virtual machines yourself.
Read more about Compute Engine
You can mix both App Engine and Compute Engine, if necessary. They both work well with the other parts of the Google Cloud Platform.
EDIT (May 2016):
One more important distinction: projects running on App Engine can scale down to zero instances if no requests are coming in. This is extremely useful at the development stage as you can go for weeks without going over the generous free quota of instance-hours. Flexible runtime (i.e. "managed VMs") require at least one instance to run constantly.
EDIT (April 2017):
Cloud Functions (currently in beta) is the next level up from App Engine in terms of abstraction - no instances! It allows developers to deploy bite-size pieces of code that execute in response to different events, which may include HTTP requests, changes in Cloud Storage, etc.
The biggest difference with App Engine is that functions are priced per 100 milliseconds, while App Engine's instances shut down only after 15 minutes of inactivity. Another advantage is that Cloud Functions execute immediately, while a call to App Engine may require a new instance - and cold-starting a new instance may take a few seconds or longer (depending on runtime and your code).
This makes Cloud Functions ideal for (a) rare calls - no need to keep an instance live just in case something happens, (b) rapidly changing loads where instances are often spinning and shutting down, and possibly more use cases.
Read more about Cloud Functions
Basic difference is that Google App Engine (GAE) is a Platform as a Service (PaaS) whereas Google Compute Engine (GCE) is an Infrastructure as a Service (IaaS).
To run your application in GAE you just need to write your code and deploy it into GAE, no other headache. Since GAE is fully scalable, it will automatically acquire more instances in case the traffic goes higher and decrease the instances when traffic decreases. You will be charged for the resources you really use, I mean, you will be billed for the Instance-Hours, Transferred Data, Storage etc your app really used. But the restriction is, you can create your application in only Python, PHP, Java, NodeJS, .NET, Ruby and **Go.
On the other hand, GCE provides you full infrastructure in the form of Virtual Machine. You have complete control over those VMs' environment and runtime as you can write or install any program there. Actually GCE is the way to use Google Data Centers virtually. In GCE you have to manually configure your infrastructure to handle scalability by using Load Balancer.
Both GAE and GCE are part of Google Cloud Platform.
Update: In March 2014 Google announced a new service under App Engine named Managed Virtual Machine. Managed VMs offers app engine applications a bit more flexibility over app platform, CPU and memory options. Like GCE you can create a custom runtime environment in these VMs for app engine application. Actually Managed VMs of App Engine blurs the frontier between IAAS and PAAS to some extent.
To put it simply: compute engine gives you a server which you have full control/responsibility for. You have direct access to the operating system, and you install all the software that you want, which is usually a web server, database, etc...
In app engine you don't manage the operating system of any of the underlying software. You only upload code (Java, PHP, Python, or Go) and voila - it just runs...
App engine saves tons of headache, especially for inexperienced people but it has 2 significant drawbacks:
1. more expensive (but it does have a free quota which compute engine doesn't)
2. you have less control, thus certain things are just not possible, or only possible in one specific way (for example saving and writing files).
Or to make it even simpler (since at times we fail to differentiate between GAE Standard and GAE Flex):
Compute Engine is analogous to a virtual PC, where you'd deploy a small website + database, for instance. You manage everything, including control of installed disk drives. If you deploy a website, you're in charge of setting up DNS etc.
Google App Engine (Standard) is like a read-only sandboxed folder where you upload code to execute from and don't worry about the rest (yes: read-only - there are a fixed set of libraries installed for you and you cannot deploy 3rd party libraries at will). DNS / Sub-domains etc are so much easier to map.
Google App Engine (Flexible) is in fact like a whole file system (not just a locked down folder), where you have more power than the Standard engine, e.g. you have read/write permissions, (but less compared to a Compute Engine). In the GAE standard, you have a fixed set of libraries installed for you and you cannot deploy 3rd party libraries at will. In the Flexible environment, you can install whatever library your app depends on, including custom build environments (such as Python 3).
Although GAE Standard is very cumbersome to deal with (although Google makes it sound simple), it scales really well when put under pressure. It's cumbersome because you need to test and ensure compatibility with the locked-down environment and ensure any 3rd party library you use does not use any other 3rd party library you're unaware of which may not work on GAE standard. It takes longer to set it up in practice but can be more rewarding in the long run for simple deployments.
In addition to the App Engine vs Compute Engine notes above the list here also includes a comparison with Google Kubernete Engine and some notes based on experience with a wide range of apps from small to very large. For more points see the Google Cloud Platform documentation high level description of features in App Engine Standard and Flex on the page Choosing an App Engine Environment. For another comparison of deployment of App Engine and Kubernetes see the post by Daz Wilkin App Engine Flex or Kubernetes Engine.
App Engine Standard
Pros
Very economical for low traffic apps in terms of direct costs and
also the cost of maintaining the app.
Auto scaling is fast. Autoscaling in App Engine is based on
lightweight instance classes F1-F4.
Version management and traffic splitting are fast and convenient. These features are built into App Engine (both Standard and Flex) natively.
Minimal management, developers need focus only on their app.
Developers do not need to worry about managing VMs in a reliable, as
in GCE, or learning about clusters, as with GKE.
Access to Datastore is fast. When App Engine was first released, the runtime was co-located with Datastore. Later Datastore was split out
as the standalone product Cloud Datastore but the co-location of App Engine Standard serving with Datastore remains.
Access to Memcache is supported.
The App Engine sandbox is very secure. Compared with development on
GCE or other virtual machines, where you need to do your own
diligence to prevent the virtual machine from being taken over at the
operating system level, the App Engine Standard sandbox is relatively
secure by default.
Cons
Generally more constrained than other environments Instances are
smaller. Although this is good for rapid autoscaling, many apps can
benefit from larger instances, such as GCE instance sizes up to 96
cores.
Networking is not integrated with GCE
Cannot put App Engine behind a Google Cloud Load Balancer. Limited to
supported runtimes: Python 2.7, Java 7 and 8, Go 1.6-1.9, and PHP
5.5. In Java, there is some support for Servlets but not the full J2EE standard.
App Engine Flex
Pros
Can use a custom runtime
Native integration with GCE networking
Version and traffic management is convenient, same as Standard
The larger instance sizes may be more suitable to to large complex applications, especially Java applications that can use a lot of memory
Cons
Network integration is not perfect - no integration with internal load balancers or Shared Virtual Private Clouds
Access to managed Memcache not generally available
Google Kubernetes Engine
Pros
Native integration with containers allows custom runtimes and greater
control over cluster configuration.
Embodies many best practices working with virtual machines, such as immutable runtime environments and easy ability to roll back to previous versions
Provides a consistent and repeatable deployment framework
Based on open standards, notably Kubernetes, for portability between clouds and on-premises.
Version management can accomplished with Docker containers and the
Google Container Registry
Cons
Traffic splitting and management is do-it-yourself, possibly
leveraging Istio and Envoy
Some management overhead
Some time to ramp up on Kubernetes concepts, such as pods, deployments, services, ingress, and namespaces
Need to expose some public IPs unless using Private Clusters, now in beta, eliminate that need but you still need to provide access to
locations where kubectl commands will be run from.
Monitoring integration not perfect
While L3 internal load balancing is supported natively on Kubernetes Engine, L7 internal load balancing is do-it-yourself, possibly leveraging Envoy
Compute Engine
Pros
Easy to ramp up - no need to ramp up on Kubernetes or App Engine,
just reuse whatever you know from previous experience. This is
probably the main reason for using Compute Engine directly.
Complete control - you can leverage many Compute Engine features
directly and install the latest of all your favorite stuff to stay on
the bleeding edge.
No need for public IPs. Some legacy software may be too hard to lock
down if anything is exposed on public IPs.
You can leverage the Container-Optimized OS for running Docker
containers
Cons
Mostly do-it-yourself, which can be challenging to do adequately for
reliability and security, although you can reuse solutions from
various places, including the Cloud Launcher.
More management overhead. There are many management tools for Compute Engine but they will not necessarily understand how you have deployed your application, like the App Engine and Kubernetes Engine monitoring tools do
Autoscaling is based on GCE instances, which can be slower than App
Engine
Tendency is to install software on snowflake GCE instances, which can
be some effort to maintain
As explained already Google Compute Engine (GCE) is the Infrastructure as a service (IaaS) while Google App Engine (GAE) is Platform as a Service (PaaS). You can check the following diagram to understand the difference in a better way (Taken from and better explained here) -
Google Compute Engine
GCE is an important service provided from Google Cloud Platform (GCP) since most of the GCP services use GCE instances (VMs) beneath the management layer (not sure which one don't). This includes App Engine, Cloud Functions, Kubernetes Engine (Earlier Container Engine), Cloud SQL, etc. GCE instances are the most customisable unit there and thus should only be used when your application can't run on any other GCP services. Most of the time people use GCE to transfer their On-Prem applications to GCP, since it requires minimal changes. Later, they can choose to use other GCP services for separate component of their apps.
Google App Engine
GAE is the first service offered by GCP (Long before Google came to the cloud business). It autoscales from 0 to unlimited instances (It uses GCE underneath). It comes with 2 flavors Standard Environment and Flexible Environment.
Standard Environment is really fast, scales down to 0 instance when no-one is using your app, scales up and down in seconds and have dedicated Google services and libraries for caching, authentication etc. The caveat with Standard environment is that it is very restrictive since it runs in a sandbox. You have to use managed runtimes for specific programming languages only. The recent additions are Node.js (8.x) and Python 3.x. The older runtimes are available for Go, PHP, Python 2.7, Java etc.
Flexible Environment is more open as it allows you to use custom runtimes as it uses docker containers. Thus if your runtime is not available in the provided runtimes, you can always create your own dockerfile for the execution environment. The caveat with it is, it requires having at least 1 instance running, even if no-one is using your app, plus the scaling up and down requires few minutes.
Don't confuse GAE flexible with Kubernetes Engine, as the later one uses actual Kubernetes and provides much more customisation and features. GAE Flex is useful when you want stateless containers and your application rely on HTTP or HTTPS protocols only. For other protocols Kubernetes Engine (GKE) or GCE is your only choice. Check my other answer for better explanation.
If you're familiar with other popular services:
Google Compute Engine -> AWS EC2
Google App Engine -> Heroku or AWS Elastic Beanstalk
Google Cloud Functions -> AWS Lambda Functions
I'll explain it in a way that made sense to me:
Compute Engine: If you are do-it-yourself person or have an IT team and you just want to rent a computer on cloud that has specific OS (for example linux), you go for the Compute Engine. You have to do everything by yourself.
App Engine: If you are (for example) a python programmer and you want to rent a pre-configured computer on cloud that has Linux with a running web-server and the latest python 3 with necessary modules and some plug-ins to integrate with other external services, you go for the App Engine.
Serverless Container (Cloud Run): If you would like to deploy the exact image of your local setup environment (for example: python 3.7+flask+sklearn) but you do not want to deal with server, scaling, etc. You create a container on your local machine (through docker) and then deploy it to Google Run.
Serverless Microservice (Cloud Functions): If you want to write bunch of APIs (functions) that do specific job, you go for google Cloud Functions. You just focus on those specific functions, the rest of the job (server, maintenance, scaling, etc.) is done for you in order to expose your functions as microservices.
As you go deeper, you lose some flexibility but you are not worried about unnecessary technical aspects. You also pay a little more but you save time and cost (IT part): someone else (google) is doing it for you.
If you want to not care about load balancing, scaling, etc., it is crucial to split your app to bunch of "stateless" web services that writes anything persistent in a separate storage (database or blob storage). Then you will found how awesome is Cloud Run and Cloud Functions.
Personally, I found Google Cloud Run an awesome solution, absolute freedom in development (as long as stateless), expose it as a web service, docker your solution, deploy it with Cloud Run. Let google be your IT and DevOps, you do not need to care about scaling and maintenance.
I have tried all other options and each one is good for different purpose but Google Run is just awesome. To me, it is the real serverless without losing flexibility in development.
Google Compute Engine (GCE)
Virtual Machines (VMs) hosted in the cloud. Before the cloud, these were often called Virtual Private Servers (VPS). You'd use these the same way you'd use a physical server, where you install and configure the operating system, install your application, install the database, keep the OS up-to-date, etc. This is known as Infrastructure-as-a-Service (IaaS).
VMs are most useful when you have an existing application running on a VM or server in your datacenter, and want to easily migrate it to GCP.
Google App Engine
App Engine hosts and runs your code, without requiring you to deal with the operating system, networking, and many of the other things you'd have to manage with a physical server or VM. Think of it as a runtime, which can automatically deploy, version, and scale your application. This is called Platform-as-a-Service (PaaS).
App Engine is most useful when you want automated deployment and automated scaling of your application. Unless your application requires custom OS configuration, App Engine is often advantageous over configuring and managing VMs by hand.
App Engine gives developers the ability to control Google Compute Engine cores, as well as provide a web-facing front end for Google Compute Engine data processing applications.
On the other hand, Compute Engine offers direct and complete operating system management of your virtual machines. To present your App, you're going to need resources, and Google Cloud Storage is ideal for storing your assets and data, whatever they're used for. You get fast data access with hosting around the globe. Reliability is guaranteed at a 99.95% up-time, and Google also provides the ability to back up and restore your data, and believe it or not, storage is unlimited.
You can manage your assets with Google Cloud Storage, storing, retrieving, displaying, and deleting them. You can also quickly read and write to flat datasheets that are kept in Cloud Storage. Next in the Google Cloud lineup is BigQuery. With BigQuery, you can analyze massive amounts of data, we're talking millions of records, within seconds. Access is handled via a straightforward UI, or a Representational State Transfer, or REST interface.
Data storage is, as you might suspect, not a problem, and scales to hundreds of TB. BigQuery is accessible via a host of client libraries, including those for Java, .NET, Python, Go, Ruby, PHP, and Javascript. A SQL-like syntax called NoSQL is available which can be accessed through these client libraries, or through a web user interface. Finally, let's talk about the Google Cloud platform database options, Cloud SQL and Cloud Datastore.
There is a major difference. Cloud SQL is for relational databases, primarily MySQL, whereas Cloud Datastore is for non-relational databases using noSQL. With Cloud SQL, you have the choice of either hosting in the US, Europe, or Asia, with 100 GB of storage, and 16 GB of RAM per database instance.
Cloud Datastore is available at no charge for up to 50 K read/write instructions per month and 1 GB of data stored also per month. There is a fee if you exceed these quotas, however. App Engine can also work with other lesser known, more targeted members of the Google Cloud platform, including the Cloud Endpoints for creating API backends, Google Prediction API for data analysis and trend forecasting, or the Google Translate API, for multilingual output.
While you can do a fair amount with App Engine on its own, It's potential skyrockets when you factor in its ability to work easily and efficiently with its fellow Google Cloud platform services.
The cloud services provides a range of options from fully managed to less managed services. Less managed services gives more control to the developers. The same is the difference in Compute and App engine also. The below image elaborate more on this point
App Engine is a virtual server.
Compute Engine - it's like a full server.
I'm going to start a simple SaaS application and am considering which cloud technology to go with(Azure, EC2 or Google).
Can someone who experience both (actual use)point the pros and cons(performence,costs,easy to develop,easy to maintain) of each technology and recommend his favorite?
Have you google'd this question?
https://softwareengineering.stackexchange.com/questions/64727/windows-azure-vs-amazon-ec2-vs-google-app-engine
Windows Azure for web developers vs Amazon EC2
http://programmerpayback.com/2009/02/04/scalable-windows-hosting-mosso-vs-ec2-vs-azure/
http://news.techworld.com/data-centre/3228389/windows-azure-versus-amazon-ec2/
This has been asked quite frequently with some fantastic answers.
If you are big into Java(Grails, JRuby etc)+MySql+ tomcat development nothing beats AWS elastic beanstalk. It let's you create a "real" relational mysql database on their infrastructure. And they provide 1 year free usage tier but it does not include RDS
Azures is great for all things microsoft. Though one can use AWS for IIS and MSSQL based app I have not done the price comparison myself.
Google AE is great from price point of view but you have to leave some of your conventional development practices on a side, one of them being relational database. This was one of the biggest reason why I did not try GAE. There is no fun in writing Grails app without the powerful GORM.
In current market other also provide cloud services like Microsoft Azure, Google. Then why Amazon? and what different service AWS provide than others. Amazon holds more than 36% stake in the cloud market. Also, top companies including Fortune 500 use Amazon Web Services. They all host their servers on AWS. The main reason behind is Amazon provide good service also its services are low cost comparatively others service, providers.
Why we need to learn AWS?
1) AWS is the leader and Fastest growing in the Cloud Computing market
2) It has more job opportunities than any other Cloud Provider
3) It has a more mature model of infrastructure, hence has a full stack of services, which complement each other
4) Companies are reserving a large share of their IT budget for upgrades and innovations in the cloud.
Here You will get a detailed description
https://answerdone.blogspot.com/2018/04/why-learn-amazon-web-services-aws-and.html
I am asking this in very general sense. Both from cloud provider and cloud consumer's perspective. Also the question is not for any specific kind of application (in fact the intention is to know which type of applications/domains can fit into which of the cloud slab -SaaS PaaS IaaS).
My understanding so far is:
IaaS: Raw Hardware (Processors, Networks, Storage).
PaaS: OS, System Softwares, Development Framework, Virtual Machines.
SaaS: Software Applications.
It would be great if Stackoverflower's can share their understanding and experiences of cloud computing concept.
EDIT: Ok, I will put it in more specific way -
Amazon EC2: You don't have control over hardware layer. But you can take your choice of OS image, Dev Framework (.NET, J2EE, LAMP) and Application and put it on EC2 hardware. Can you deploy an applications built with Google App Engine or Azure on EC2?
Google App Engine: You don't have control over hardware and OS and you get a specific Dev Framework to build your application. Can you take any existing Java or Python application and port it to GAE? Or vice versa, can applications that were built on GAE be taken out of GAE and ported to any Application Server like Websphere or Weblogic?
Azure: You don't have control over hardware and OS and you get a specific Dev Framework to build your application. Can you take any existing .NET application and port it to Azure? Or vice versa, can applications that were built on Azure be taken out of Azure and ported to any Application Server like Biztalk?
Good question! As you point out, the different offerings fit into different categories:
EC2 is Infrastructure as a Service; you get VM instances, and do with them as you wish. Rackspace Cloud Servers are more or less the same.
Azure, App Engine, and Salesforce are all Platform as a Service; they offer different levels of integration, though: Azure pretty much lets you run arbitrary background services, while App Engine is oriented around short lived request handler tasks (though it also supports a task queue and scheduled tasks). I'm not terribly familiar with Salesforce's offering, but my understanding is that it's similar to App Engine in some respects, though more specialized for its particular niche.
Cloud offerings that fall under Software as a Service are everything from infrastructure pieces like Amazon's Simple Storage Service and SimpleDB through to complete applications like Fog Creek's hosted FogBugz and, of course, StackExchange.
A good general rule is that the higher level the offering, the less work you'll have to do, but the more specific it is. If you want a bug tracker, using FogBugz is obviously going to be the least work; building one on top of App Engine or Azure is more work, but provides for more versatility, while building one on top of raw VMs like EC2 is even more work (quite a lot more, in fact), but provides for even more versatility. My general advice is to pick the highest level platform that still meets your requirements, and build from there.
This is an excellent question. Full disclosure as I am partial to Azure but have experience with the others.
Where I think Azure stands out from the others is the quick transition from on prem to the cloud. For example -
SQL Azure - change connection string, upload DB, go!
Queues work a lot like MSMQ.
Blobs are pretty much blobs any way you shake them but they scale like crazy.
The table storage component is good because it provides incredible scalability for name/value pairs - but takes some getting used to.
Service Bus is my favorite of the services because it allows for a variety of communications paradigms. Two SB endpoints first try to connect to each other, if they cannot, then they route through the cloud - makes for very secure and scalable processing when firewalls tend to get in the way.
Access control list - paired typically with the service bus to make sure the right people access the right things - think SAML in the cloud.
I hope that helps!
My cloud experience is currently limited to Salesforce.com
For standard business operations and automation it provides a significant number of features that allow us to get apps up and running very quickly. We are particularly benefitting from the following:
Security (Administrators can control access to objects and fields)
Workflow & Approvals
Automatic UI generation
Built in reporting and dashboards
Entire system (including our custom changes) is accessible via web services
Ability to make the data in the system available through public sites (e.g. eCommerce)
Large library of third party apps to solve standard problems
The platform does NOT solve every problem.
I would not use the platform to model a nuclear power station or build the next twitter.
The major points of cloud computing is to save on costs by paying for usage and enable immediate deployment of computing resources.
The costs are not purely x amount of cents per instance per hour. The costs include maintenance, development, administration, etc. The huge benefit of cloud, in my mind is to liberate the customers from having to manage anything that is not within the realm of their core business competency. If I am an insurance business, I want my developers to concentrate on my insurance problems that help solve needs of my claims, rates, etc. I would rather avoid dealing with problems of email servers, file servers, document repositories, and administrating OS patches, service packs, etc.
Thus, in my opinion, the biggest benefits are derived from the SaaS and PaaS cloud offerings. One should go to IaaS only when PaaS or SaaS have serious restrictions to specific needs (i.e. I need to install a set of proprietary COM components and Azure does not support them).
SaaS is good for commodity type of applications that are not the core line of business for the client, but are more of a utility. These are your typical Messaging systems, Portals, Document Repositories, Email systems, CRMs, ERP's, Accounting, etc. etc. etc. Why reinvent the wheel by writing your own when you can customize a well supported third party product.
PaaS is great for core line of business software that supports companies' main business offering. Abstracts clients from having to deal with OS management and lets clients concentrate on the business system development - something that noone else can do for the client.
One can also take advantage of the benefits of PaaS (let's say, Google App Engine) and extend it, at times and if necessary, by pulling out some virtual machines from IaaS providers (e.g. Amazon) to do some number crunching then just send back the output to Google App Engine.
This way, you get the best of both worlds -- you can rapidly develop scalable apps in GAE, then you can always augment it by running any program you want from Amazon virtual machines.
This keeps changing, now Windows Azure also supports VM, so it is also an IaaS provider now.
Now how about Free Amazon EC2 for a year to do a better comparision. Check this out.
http://www.buzzingup.com/2010/10/amazon-announces-free-cloud-services-for-new-developers/