
New version of Google App Engine supports all programming languages - tobltobs
https://techcrunch.com/2017/03/09/new-version-of-google-app-engine-supports-all-programming-languages/
======
deepsun
There's a big drawbacks of Flex App Engine, comparing to Standard App Engine:

1\. Deployment of a new version can take up to 30 minutes. It seems to do the
following:

    
    
      * Spins up two new GCE instances, that will build your code to a Docker image (and you pay for them).
    
      * Uploads all of your code to those instances (even the files that weren't changed, contrary to Standard GAE).
    
      * Then you just wait until it builds the code and deploys it to Flex environment.
    

In Standard env, only changed files were uploaded, and no extra building step
occurred, so the whole process was less than a minute.

2\. Static files -- now you have to manage them yourself: either serving them
from server (bad), or, as they recommend -- upload it to GCS or any other CDN,
and serve from there (good). With Standard environment you just didn't care --
statics were served from some internal CDN (not touching your server), and
were always in sync with your currently active code version. We're not ready
for going that hassle now.

~~~
rdcastro
Deployments should not be taking that long at all if the app code is coming up
healthy when it gets started on the VM (for crashes at code startup we also
fail the deployments early). If the app comes up but isn't healthy (like
serving 500 or not listening on the right port), we try multiple times to get
the app started.

Can you share more information about your app and deployments so we can
investigate further?

PS: It's worth mentioning we have active development to bring down deployments
times and improve the deployment experience.

------
filleokus
I've used GAE quite extensively at my last place of work and really liked it
overall. I experienced some large pain points when I was unable to use
libraries that used C extensions, which I guess should be solvable now. The
GAE runtime was (is?) also only available for Python 2.7.

I wonder if there is a future possible migration path from the standard
environment (Classical GAE) to the new flexible environment.

For our product we also decided to use the Google NoSQL database Datastore.
Since this is/was tightly integrated in the GAE Python runtime, with its own
data model layer, it was an easy choice to implement. But, of course, made
migration away from the Google Cloud really cumbersome.

I guess you still are limited to use some of the Google Cloud Databases, but
if you chose Cloud SQL maybe the migration is more feasible?

~~~
rdcastro
We do have migration guides to the Flexible environment available per
language. This is the link to the Python version:
[https://cloud.google.com/appengine/docs/flexible/python/migr...](https://cloud.google.com/appengine/docs/flexible/python/migrating)

I hope that helps. A key tenet in the Flexible environment is portability. In
the Datastore case, in particular, if you move to Cloud Datastore, that gives
you portability across the Cloud Platform offerings or even if you want to run
on premises or in a different Cloud provider.

------
ungzd
If it uses Docker, how it's different from Google Container Engine?

Is it possible to make it start container lazily on HTTP request and stop
after inactivity, like regular App Engine?

~~~
rdcastro
App Engine Flexible is a PaaS (Platform-as-a-Service) with the mission that
you bring the code and we do the rest for you. As an example, although we run
the app as a Docker container, one doesn't need to understand Docker at all to
get started. :-) It's a great place to get started without needing to
understand how the infrastructure works. However, if you'd like to go beyond
and provide your own Docker container, that works too. That is one of the
exciting things we're making available with this new version.

In addition to App Engine Flexible, you can deploy Docker container to both
Container Engine and regular GCE VMs in Google Cloud Platform. Each different
offering will come with different set of features and different investment
level on the user's side. A GCE VM will probably be the one with the ultimate
flexibility on what one can do, but will typically require more time
investment.

Regarding starting the container lazily and suspending it while inactive, that
is not currently supported.

------
Mister_Snuggles
This seems to be the most interesting thing:

> Finally, the company will let developers bring a programming package
> (binary) to App Engine as a Docker image.

This sounds like someone could package up any piece of software (assuming that
it's compatible with the underlying OS, of course) into a Docker image and
deploy it on Google App Engine. This isn't limited to just programming
languages.

~~~
rdcastro
You're totally right. Some some examples of crazy stuff you can run on App
Engine: [https://github.com/GoogleCloudPlatform/appengine-custom-
runt...](https://github.com/GoogleCloudPlatform/appengine-custom-runtimes-
samples)

