Alexis Moussine-Pouchkine: Hello and welcome back to Devoxx 2014.
I'm here with Ludovic Champenois,
and we're here to talk about something called Managed VM.
Ludo, welcome.
LUDOVIC CHAMPENOIS: Welcome.
Thank you.
MALE SPEAKER: And actually, Managed VM
is something I've heard about a long time ago.
Well, not that long ago, but it's been in the works
for a little while.
And it kind of changes the game, I
think, for App Engine users or the people that
looked at App Engine awhile back and maybe
it didn't fit their needs.
So maybe, I think, Managed VM is a reason
they should look at it, and of course, for everybody else,
it opens new possibilities.
So walk us through some of that.
LUDOVIC CHAMPENOIS: Managed VM was announced last week
in San Francisco, so it's brand new.
MALE SPEAKER: So everybody has access to this now?
LUDOVIC CHAMPENOIS: Everybody has access to it.
Before, we were running a private trusted tester trial,
but now everybody can try Managed VM.
Managed VM is really App Engine V2.
This is a new App Engine 2.0, which
is based on all the cloud platform features
that we launched over the last few years.
So it's basically you keep the App Engine model, very simple,
just work on your application, you deploy it
and it scales automatically.
We do failover.
We manage for it.
MALE SPEAKER: So keep all the goodness of App Engine.
LUDOVIC CHAMPENOIS: You keep everything
that was a value of App Engine as we know it today.
And then, in order to run in the old Google data centers,
App Engine had to give you some restrictions because you cannot
write to a file system, you could not use native code
because, guess what, with native code you can explore
the environment.
MALE SPEAKER: So for Java developers,
there was a [INAUDIBLE].
LUDOVIC CHAMPENOIS: Some people were not very happy with this.
I agree, but with value added on terms
of the scalability of the platform,
you had to give away a few features.
So App Engine v2, or Managed VMs,
is exactly removing all those restrictions.
Basically, you run a container.
You have heard at Devoxx this week,
everybody's taking about containers.
MALE SPEAKER: It's kind of a trending thing, yes.
LUDOVIC CHAMPENOIS: So a container is a new WAR format.
It's a new unit of deployment, but it's not a new Java.
It's your unit of processing, whether it's a JVM or a JVM
plus native code that you want to call because you want
to access a native image library, for example,
or a PDF generator, et cetera, et cetera.
So you can keep the simplicity of App Engine, deploy
it to Managed VM, and, for example,
use native code or AWG or--
MALE SPEAKER: All the things that
were forbidden, that you could not use before.
LUDOVIC CHAMPENOIS: While upgrading to Managed VM,
we also upgraded all the Servlet specifications
we are using in classic, and now you
can do Servlet 3.1 with annotation.
We're extremely efficient in terms
of processing those annotations at the SDK time,
before we deploy the container to the cloud.
Managed VM is based on Compute Engine,
so it's App Engine running on top of Compute Engine
and running inside of VM, but instead of giving you
pure access to the VM, we are running
a Docker system inside this VM.
So what you really develop locally
on your desktop is a Docker image,
so you test it with Docker containers,
and then once you're OK, you can deploy it
to the cloud using the same exact image you
have been using.
MALE SPEAKER: Which is part of the value of Docker,
is to be able to have the same exact environment
in development and production, no longer
it works on my machine.
But walk us through a little bit for the developer what
it means.
Are they exposed to Docker as such on the client side?
LUDOVIC CHAMPENOIS: No.
If you do nothing except changing one line in your App
Engine weblet XML, and the line is VM true.
So basically, you declare to the system,
I want to run in a VMware environment.
Then the SDK will create the Docker image,
instantiate a Docker container for you,
and you are not exposed to docker.
MALE SPEAKER: So the App Engine SDK
or the cloud SDK actually extracts all that.
LUDOVIC CHAMPENOIS: Same commands as before.
You run or you deploy your application, and underneath,
we will use a Docker system running on your desktop,
and we will execute this Docker container for you.
This is the out of the box experience for App Engine V2
or Managed VM.
One line in your code, and then suddenly, you're
running in the Docker environment.
So now, once you are running in this Docker environment,
we give you, again, access to the full JVM,
but we give you access to other runtimes.
So obviously, we have Java, Python, and Go,
like App Engine previously.
MALE SPEAKER: Even more recent versions of Java?
LUDOVIC CHAMPENOIS: Java 7 out of the box,
but if you want to start customizing those runtimes,
you can as well, because you can edit a Docker file, which
is a unit of description of what is your Docker container.
Instead of downloading the open JDK 7,
you can download JDK 8 if you want,
or even JDK 9, or even your own build of JDK if you want,
and this Managed VM will run with this new JVM if you want.
MALE SPEAKER: But you were about to say
that we can have also brand new runtimes.
LUDOVIC CHAMPENOIS: Of course, we
can customize all the ways JVM running in this container,
and we can also explore new runtime.
So for example, we have a custom runtime called NodeJS.
I guess NodeJS is extremely popular for mobile developers,
mobile back ends.
We kept the simplicity of App Engine.
We provide JavaScript or NodeJS App Engine
APIs for datastore, memcache, [INAUDIBLE].
All the APIs that are part of the App Engine ecosystem
can be accessed from a NodeJS application.
And suddenly you have a brand new runtime,
but using the same unit of deployment, unit of execution
and management in App Engine so that we can scale you
to many more VMs, depending on the traffic you have.
MALE SPEAKER: So NodeJS is even newer.
So Managed VM allowed for something like NodeJS to exist.
This is something that Google worked
on that is being offered.
LUDOVIC CHAMPENOIS: Yes.
It's still beta, but we did all the API bindings for NodeJS
for App Engine.
You can use also Google Cloud APIs as well.
So if you want to access Cloud Storage or mapreduce,
the big data capabilities of the cloud platform,
you can also use that from a generic NodeJS library
that you add packet JSON to describe that you depend on it.
MALE SPEAKER: Any other runtime?
I think Dart is supported on the server as well.
LUDOVIC CHAMPENOIS: We have dart as well because Dart
has been very, very popular on the client side,
and guess what, it's a full feature server side language
as well.
The Dart team worked with us to deliver a Dart runtime
for App Engine as well.
And same, instead of using Java or Node, you use Dart,
but the cloud SDK we are using for your local development is
the same.
Basically, it's just a Docker file saying,
I want to use a Java image or I want
to use a NodeJS image or a Dart image.
MALE SPEAKER: OK, great.
So I guess Google in the cloud is embracing
Docker, obviously, trying to [INAUDIBLE]?
LUDOVIC CHAMPENOIS: We are embracing containers.
I mean, we have been using containers forever.
App Engine in 2008 was running in a [INAUDIBLE] group isolated
environment in the cloud.
We cannot really talk about it, but this is how we were able
to scale App Engine as we know it today.
The nice thing about Docker is finally,
the entire world is recognizing that containers
is the way to go.
We are very happy that the Docker ecosystem is there
because it's not only Google doing private technology.
It's the entire community actively participating
in the Docker ecosystem, which is great.
MALE SPEAKER: And Docker is hitting the sweet spot
of being relevant both to developers and to production,
and I think that's very useful.
LUDOVIC CHAMPENOIS: Exactly.
This is the perfect model for the future
of cloud for all the cloud providers.
MALE SPEAKER: And so you mentioned also
that, obviously, Google is very invested in Docker.
We're also investing in things, I would say, on top of Docker,
things like [INAUDIBLE].
LUDOVIC CHAMPENOIS: [INAUDIBLE].
MALE SPEAKER: But that is a subject
of another interview we'll have soon.
LUDOVIC CHAMPENOIS: We have a continuum
from bare metal VMs to cluster management,
and then the other side of the spectrum, which is I
only focus on my application, I deploy it
and Google, please do the management for me.
MALE SPEAKER: And the scaling and the load balancing
and all of that.
LUDOVIC CHAMPENOIS: And from those two extremes,
you create a brand new VM through Managed VM,
we have a spectrum of capabilities and technology
that you can, if you want, start using.
MALE SPEAKER: Right.
So Managed VM, now in beta.
Anybody can use it.
Try it out.
I think if you've looked at App Engine
before, you probably should look at it again.
It removes pretty much all of the restrictions
you might have come across.
So thank you, Ludo.
LUDOVIC CHAMPENOIS: Thank you.
MALE SPEAKER: And looking forward
to the feedback of people using that.