[MUSIC PLAYING]
MARK MANDEL: Hi, and
welcome to episode
number 151 of the weekly
Google Cloud Platform Podcast.
I'm Mark Mandel,
and I'm here with
my extra special
colleague, Melanie Warrick.
How are you doing
today, Melanie?
MELANIE WARRICK:
Hey, Mark, I'm good.
How are you?
MARK MANDEL: I'm very well.
It's Monday,
beginning of the week.
MELANIE WARRICK: It's Monday.
We love Mondays.
MARK MANDEL: Mondays are good.
Though when you're listening to
this, this will be Wednesday.
MELANIE WARRICK: Yes.
So Mark, who do we have
on the podcast this week?
MARK MANDEL: Yeah,
so this week we
are talking about Java and Jib
with Patrick Flynn and Mike
Eltsufin.
MELANIE WARRICK: Yes, this
will be a good episode.
MARK MANDEL: Yeah, so we're
talking about Spring Boot.
We're talking about Jib,
which is a tool for creating
Docker files from Java stuff.
It's basically a lot of
Java ecosystem stuff.
MELANIE WARRICK: Yeah.
But as we do, we
always start out
with our cool
things of the week,
and we end with the
question of the week.
And this week's question,
all the way from Mark--
what if we have an object
in Google Cloud Storage,
and I want to
automatically change
an aspect of it, such
as downgrade the storage
class of objects older than
365 days to Coldline storage,
delete objects created
before January 1, 2013,
or keep only the three
most recent versions
of each object in a bucket
with versioning enabled.
Mark, where did this come from?
[LAUGHTER]
MARK MANDEL: Actually, something
I needed to do a while ago.
And I came across
it again, and I
was like, that's a great
question of the week.
MELANIE WARRICK:
Sounds like a plan.
All right, well, the
cool things of the week,
let's get that kicked off.
And mark, I think you have
something from Kubernetes,
right?
MARK MANDEL: Oh, I always have
something from Kubernetes.
So this is pretty cool.
This is introducing
container-native load balancing
on Google Kubernetes engine.
So this is quite neat in
that previously you've
had things like Ingress,
you've had Services--
that's all been really great.
And generally speaking,
that's been fine.
Usually when that works, it
comes down through the nose,
and through iptables, and
then directly into the pods,
and sort of routed
through Kubernetes itself.
This cloud native load
balancing works a little bit
more efficiently in that it
comes straight into a network
endpoint group and actually gets
passed directly into the pods
themselves.
So it basically provides optimal
load balancing, native support
for health checking, some
graceful termination,
optimal data parts, increased
visibility and security.
So it's quite a
neat little project.
You should probably
check it out.
It is the network
endpoint groups,
so make sure and check it
out, and we'll have links.
MELANIE WARRICK:
It's a good post.
And it's also got great visuals,
which we're always a fan of.
MARK MANDEL: Yep.
MELANIE WARRICK:
Another cool thing
of the week that
we want to mention
is there's a post we're going to
share that's simplifying cloud
networking for enterprises,
and it's basically
announcing the Cloud NAT.
And the Cloud NAT is a new
Google-managed network address
translation service, thus "NAT."
Basically, you can provision
your application instances
without public IP addresses.
And that still allows you
to access the internet.
So it gives you the ability
and some functionality
around that in terms of
the Firewall Rules Logging,
managing the TLS
certificates for HTTPS.
Load balancers-- you don't
have to do that manually.
You can use their
more automated system.
And there's a number of
new load balancing features
that they share--
things like user-defined request
headers, and network tiers
for load balancing and
Cloud Armor, and so forth.
So you can check it out.
MARK MANDEL: I quite like this
because whenever I see it,
I think to myself a NAT
router is what I have at home.
But now they just have Google
Wi-Fi points in the data center
or something.
MELANIE WARRICK: Oh, yeah.
Yeah, good point.
All right, and next up--
MARK MANDEL: So we've got
some great new announcements
for Cloud Storage as well.
And there's several of
them, which is pretty neat.
So we have a new
dual region option
available in beta, which
I think is really nice.
So previously we've
had multi-region
and we've had single-region.
Now you can actually
do dual-region.
So if you want some
redundancy, but you
want to have particular locality
or particularly close to,
say, where you want to
do your computation,
you can choose that
as an option as well,
and that's in beta
at the moment.
MELANIE WARRICK: Apparently
it's also strongly consistent,
so when you create a
dual-region bucket then
follow up and request to fetch
a list of certain resources,
your resources will
be in that response.
MARK MANDEL: Yeah,
which is great.
MELANIE WARRICK: Yes.
MARK MANDEL: Also
the availability
has been raised for
Nearline and Coldline's data
in multi-region locations.
So Google is raising
its availability SLA
for Nearline and Coldline
data in multi-region locations
from 99.0% to 99.9%.
So that's actually
a decent raise.
MELANIE WARRICK: Yeah, I agree.
And basically the new Cloud
Storage as a C++ client
library.
MARK MANDEL: Yes, and I
like C++, because games.
MELANIE WARRICK:
Last thing we want
to mention for the week is that
our friends Liz and Seth, who
did this great SRE podcast
with us a little while back,
they just released another
video on postmortems
and retrospectives
for SREs and DevOps.
And so this is a nice
video that covers
how to handle postmortems
and especially
doing blameless postmortems,
which is a real crucial thing.
MARK MANDEL: Nice.
MELANIE WARRICK: And so
you know check this out.
MARK MANDEL:
Definitely, and if you
hadn't listened to
the episode before,
it's episode number 127.
And we'll make sure to put a
link in the show notes as well.
MELANIE WARRICK: Agreed.
Great, all right,
Mark, I think it's time
to get into the interview.
MARK MANDEL: Yeah, let's go
talk with Patrick and Mike.
Well, I'm very excited today
to have two staff software
engineers working on some
interesting projects for Java
for Google Cloud.
We have Patrick Flynn
and Mike Eltsufin.
Hopefully I got that right.
How are you both doing?
Patrick, how are
you doing today?
PATRICK FLYNN: I'm doing great.
Thanks.
How are you?
MARK MANDEL: I'm good.
How you doing, Mike?
MIKE ELTSUFIN: Pretty good.
How's it going?
MARK MANDEL: Good.
Well, thank you both
for joining us today.
I really appreciate you
both taking the time.
Or, we really appreciate
it I should say.
Before we get
started, I know we've
got a lot of fun and
interesting things happening
in the Java ecosystem
for Google Cloud,
but why don't you tell us a
little bit about who you are
and what you do.
Patrick, why don't you go first.
PATRICK FLYNN: You know
my name is Patrick Flynn.
I'm the Tech Lead of the Java
Tools Team for Google Cloud.
We build all kinds of useful
little tools for our Java
developers who target Cloud.
If you're familiar with
App Engine, we own the IDE
and build integrations
that you can
find in IntelliJ, and
Eclipse, and Maven,
and Gradle for App Engine.
And lately we've been focusing
on the Kubernetes workflow
and how to make that a less
painful experience for Java
developers.
MARK MANDEL: Nice.
And how about you Mike?
MIKE ELTSUFIN: Yeah,
so I'm also a software
engineer in Google Cloud.
I'm a Tech Lead of a team
called Cloud Java Frameworks.
And we've been recently
focusing mostly
on building integrations between
Spring Framework and Google
Cloud and bringing
all that goodness
of Spring Framework, Spring
Boot to Google Cloud users.
MARK MANDEL: Sweet.
So it sounds like
there are, what is it,
two big projects
that are happening.
I don't know.
Who can give us an overview
of the new stuff that's
been happening for
Java developers,
because it sounds like there's
been some cool stuff happening?
MIKE ELTSUFIN: So I guess
from my point of view,
in terms of the Frameworks,
we just released a few months
ago the first official
version of Spring Cloud GCP,
which is the project that
does this integration
between the Spring
Framework and Google Cloud.
So that's been new, and
that's pretty exciting for us.
And I think a large part of
the Java developer community
would be excited about
it as well, because we're
making it a lot easier now
for Spring developers to take
advantage of Google Cloud APIs.
That's from my point of view.
There's also a bunch of
tools that Patrick's team
is working on.
And he could talk
about that, I guess.
PATRICK FLYNN: Yeah, I guess
the latest thing that we've
released for tools has been
Jib, which is a Java-specific
Container Builder.
MELANIE WARRICK: For
those who might not know,
can you tell us
a little bit more
about what are
Spring Frameworks?
MIKE ELTSUFIN: Sure,
so Spring Framework
has been around for a long
time, well over 10 years now.
It started as a dependency
injection framework for Java.
And it was also sort of
an alternative to the JEE
framework that a
lot of people were
using to build
enterprise applications.
It has grown quite
a bit since then
and has become more of
an umbrella framework
with all kinds of integrations
for enterprise application
development.
And in the past few
years, they also
brought Spring Boot
which made it even easier
to build enterprise
applications by taking advantage
of this kind of principle of
convention over configuration.
So that that's Spring
and Spring Boot.
They're fairly popular
today among Java developers,
especially the
enterprise applications.
And that's part of
the reason why we
are focusing on that framework.
MARK MANDEL: What's
our integration there?
What are we actually doing to
make like Spring and Spring
Boot easier for
Google Cloud Platform?
Because, I mean, Spring's an
inversion of control framework,
and Spring Boot's and
MVC-type framework.
So what's the deal there?
MIKE ELTSUFIN: So there's a lot
of things in Spring Framework,
Spring Boot--
a lot of those things are
integrations with existing
tools that are useful for
enterprise application
development, like messaging
systems, different databases.
They really try to make
it very easy to use those.
However, there are no
out-of-the-box integrations,
at least in the past, that
would work with Google Cloud.
So what we've done
is we've basically
looked at all the different
sub-projects within Spring
Framework and try to find
a match in the Google Cloud
APIs and services where we
could apply those abstractions
and idioms and implement
those bindings, essentially.
So we've done that for a
bunch of different services
in Google Cloud now, including
databases like Spanner,
Datastore, CloudSQL, as well
as messaging, so Pub/Sub,
[INAUDIBLE], configuration.
Almost anywhere where
there is some kind of match
between Spring Framework
and Google Cloud,
we try to make that work
better through Spring.
MARK MANDEL: So does
the Spring Framework
have some kind of
higher-level abstraction?
Is that how the
developer sees things?
Is that how that works?
MIKE ELTSUFIN: Yeah, they have
a whole bunch of abstractions
for different purposes.
For example, for
databases they have
a project called Spring Data.
There are some interfaces
and abstractions
that apply across different
Spring Data implementations,
but they also leave the
flexibility to kind of expose
the specific features of a
database through that as well.
So as much as Spanner's
a relational database,
but there are some very
unique features of Spanner,
and we're able to expose
the unique features
as well as kind of comply
with idiomatic Spring Data
interfaces so that
people can easily
migrate from one
database to another,
yet they're still able to
use the unique features
if they need to.
MELANIE WARRICK: Why
is Google investing?
Why does this matter
for Google to develop
Spring Cloud for GCP?
MIKE ELTSUFIN: We care
about Java developers.
We want them to be
happy on GCP, so--
MELANIE WARRICK: Do we care?
Do we really care?
[LAUGHTER]
No, we care.
MIKE ELTSUFIN: We
really want to make
that experience great for them.
And we know that a
lot of Java developers
are on Spring
Framework, and we really
want to make it as
easy as possible
for them to move their
applications to GCP
or write new applications
using Spring Framework for GCP.
And we know that
there are a bunch
of benefits to using Spring
Framework and Spring Boot.
for example, it eliminates a
lot of the boilerplate code
that you have to write,
so it's a lot easier
to get started with.
We're really trying to meet
developers where they are,
and where they are.
is using Spring Framework,
as far as we can tell.
MELANIE WARRICK:
That makes sense.
MARK MANDEL: From a
developer perspective,
how do I set this up?
If I have a GCP project, do
I need to import credentials,
or is it seamless?
How does this work?
MIKE ELTSUFIN: Yeah, so we
have a bunch of Spring Boot
starters.
So I mentioned convention
over configuration--
so we tried to not make you
configure too many things
and instead auto-discover
whenever possible,
yet allowing, also, to
override those defaults.
With credentials,
for example, as soon
as you bring in our core
starter from Spring Cloud GCP,
it will try to
auto-detect credentials
wherever you're running.
If you're running
locally, it will
try to find your local
credentials that you've set up
using environment variables or G
Cloud If you're running on GCP,
it will also try to
auto-discover the normal places
where you'd find the credentials
on a GCE or what have you.
Alternatively, you could always
specify a path to the key,
so we'll add that to be
a possibility as well.
And for a lot of these
things, we kind of
make assumptions for
the configuration,
and you can always
override that.
MARK MANDEL: I guess
that's a nice, then.
It means if I'm using
Spanner or Google Cloud
Storage as a
development thing, I
don't have to have that locally.
And my local
environment can just
talk straight up to whatever
my development environment is.
MIKE ELTSUFIN: If you're
developing locally
and you want to use
Spanner, of course it
will need to talk
to Spanner remotely,
because there is no
emulator for a Spanner.
MARK MANDEL: Yep.
MIKE ELTSUFIN: If you
already have G Cloud set up,
and you set up credentials,
it will automatically
use those to connect to spanner.
You don't need to really
configure anything.
You just add our starter, and
it will work out of the box.
MELANIE WARRICK: I
was going to ask,
what are some of the
challenges you've
seen that you're working
on trying to address
for some of the users now?
MIKE ELTSUFIN: At
first, when we started,
we were trying to
basically guess
what the developers will
need, like which parts
to expose to the
Spring abstractions
and which ones we should hide.
It's challenging
when you don't really
have too many users
giving feedback initially.
But now that we've kind of
gone through the first official
release, we're getting
a lot more feedback,
and we're getting users
engaged on GitHub.
So it's getting a bit better
to set direction on what
we should be focusing on.
And there are so many
different possibilities
where we could do integration
between Spring and GCP.
And just prioritizing those
things are sometimes difficult.
So getting the user
feedback is very important.
MARK MANDEL: That sounds great.
MIKE ELTSUFIN: This
project is actually
a close collaboration
with the Spring team,
the creators of the
Spring Framework,
and Pivotal, which is the
company that houses them.
We've been working with
them from the very beginning
on this.
And they've been helping set
direction on this project,
and they've been
actively guiding us
throughout the whole process.
We frequently meet with
them and talk about design,
implementation, all of that.
So it's a very close
partnership with Pivotal
and Spring team on this.
So we have that expertise being
funneled into the project,
as well as from our side,
the Google Cloud expertise.
MARK MANDEL: Excellent.
So if I'm running a
Spring Boot application,
and I'm not that familiar
with that ecosystem,
are there any restrictions
on where I can run that app?
Is it just on App Engine maybe,
or just in a Docker container?
MIKE ELTSUFIN:
Yeah, at this point
you can pretty much
run it anywhere.
It works on App Engine.
It works on Kubernetes.
It works on GCE, wherever
you can run Java.
Spring Boot is essentially
an executable JAR,
so whenever you can run that,
it can also run as a WAR file.
So if you're using
App Engine standard,
you could also do it there.
MARK MANDEL: So
speaking of runtimes,
we have some new tools for being
able to run Java applications
inside containers.
Patrick, I know you're
joining us today
to talk to us about that.
Do you want to give us
a little rundown on Jib?
PATRICK FLYNN: Yeah,
I'd be happy to.
So what is Jib?
Jib is basically
an answer to what
should be the right way
to containerize a Java
application.
The thing that
kind of stands out
about using Jib from the way
that people traditionally
containerize using
Docker files--
there are a few things really.
The first is that you don't
need a Docker daemon running
on your machine,
which requires root.
And that kind of suits a lot
of people as well as enterprise
CI environments, which
have problems with that.
That wasn't the focus
for why we built Jib,
but it was kind of a nice
surprise that a lot of users
adopted it for that reason.
The main reasons we focused
on, on building Jib,
is because we felt that
the way that people
were packaging containers
using Docker file
tended to be inefficient.
So Jib typically will
build the Docker container
kind of marginally faster
in your first build.
But then the incremental builds
can be dramatically faster,
depending on the project.
And then the other aspect of
Jib that's pretty important
is that it's much
more declarative.
While a Docker file will allow
you to run arbitrary commands
and, therefore, it's pretty
much not a reproducible build,
a Jib build config
is declarative.
And that makes it really
easy for end users.
It means that we can
set a lot of defaults,
which means that you
have to configure
very little to get started.
And it allows our
tooling to sort
of incrementally
optimize both the build
and the eventual runtime.
So yeah, it's just
it just makes it
a lot easier for
Java developers who
have this hump of
needing to turn
their traditional packaging
formats into containers
so they can target new
platforms like Kubernetes.
MARK MANDEL: And from a
developer perspective,
how do I use jib?
PATRICK FLYNN:
Right, good question.
First, I'll start with
a little bit of context.
Jib actually came from this
local container guru at Google
called Matthew Moore.
If you're not
familiar with Basel,
Bazel is this
Google build system,
which we use
internally, and which
we've open sourced recently.
He built a bunch of
containerizers for Bazel
that worked very much like Jib.
But what we've
seen is that Bazel
is like a big hump for
people to adopt a better
way to containerize
their applications.
Most of our Java users
are on Maven or Gradle.
So what Jib does is it
takes a lot of that strategy
that the Bazel rules use and
implements it as a Java library
and integrates it into
Maven and Gradle plugins.
So if you wanted to use
Jib, all you have to do
is just set up your pom.xml,
or your build.gradle
to use our plugin.
And the most minimal
config you really need
is just specifying where
your container registry
images should be pushed.
MELANIE WARRICK: You'd mentioned
about Jib being more efficient
than Docker.
Can you explain
a little bit more
about how it is more efficient?
PATRICK FLYNN: First
of all, I think
Docker file was a really
great solution initially
to bring people into
the world of containers.
It's very flexible,
and it gives people
the tools they need to take
whatever arbitrary packages
they have and containerize them.
That being said, you really need
to understand a lot of things
about how Docker works to
optimally package your apps
and have a good
incremental build time.
So the first thing
that we do is we kind
of standardize the way
that we build our images.
And we layer them
in a way that makes
more sense for incrementality.
So for instance,
your dependencies--
so a lot of projects could
have tens or hundreds
of megabytes of JARs that
they use in their project.
Your dependencies will be put
into a Docker layer that will
probably not change very often.
And your source code
and your resources
also go into separate layers.
What that means is that, when
you do an incremental build,
instead of having to
repackage the entire container
and then push possibly
hundreds of megabytes,
you'll probably--
if your classes are
only a few megabytes--
you'll only
have to push that
change to the registry
to actually get that
new image out there.
MARK MANDEL: How does
this work without Docker?
Like, is this magic?
MELANIE WARRICK:
Everything's magic.
PATRICK FLYNN: I always assumed
that there is a lot of magic
there.
But when you kind of dig into
the container image spec,
it's not that complicated.
It's really a bunch of
tarballs with metadata.
So that's what the
layers are, kind
of these concentric tarballs.
So we just built a library
that anybody can use actually
if they want to integrate it
into their system of choice
to help you build a container
image using [INAUDIBLE]..
MARK MANDEL: This is nice.
Does this fit
anywhere specifically
into a Kubernetes
workflow, or are there
any hooks in that way?
PATRICK FLYNN: Yeah,
that's a good question.
The funny thing is, if you
talk to Kubernetes developers,
there's not really much of a
standard around a workflow.
Most people are
kind of asking me
about what their
workflow should be,
which is a shame, because I want
to find out what there's is.
And the one tool that we've
seen gain significant adoption
has been Scaffold, which
is a CLI tool also provided
by Google that basically will
wash your microservice project
or a set of microservice
projects based off of a YAML,
because this is Kubernetes,
and will actually
trigger rebuilds, and
push those images,
and update your cluster
config so that you kind of get
a hot reload feel
from your application,
assuming that your container
builds are fast enough.
So what we've been
doing is trying
to make sure that scaffold
users who are Java users
have a decent experience.
Scaffold in Java is not
great at the moment,
because as you can imagine,
a file watcher that basically
rebuilds on every
file change for Java
doesn't necessarily
make sense, especially
given like how heavyweight
some Java builds can be.
So we've been looking at that.
Some users have had, actually,
some pretty good success
by using this task that we
have in both of our plugins,
which generates
a Docker context.
So you get, effectively, kind
of the Docker version of what
Jib would have created and
pointing Scaffold at that
because Scaffold
understands Docker.
But we're actually
working currently
with the Scaffold team to build
a Jib builder for Scaffold.
MARK MANDEL: Nice.
PATRICK FLYNN: And that should
be available within the month
or so.
MELANIE WARRICK: What do
you enjoy most about working
with Jib and with Java?
PATRICK FLYNN: What I like
about working with Jib
is that I don't
have to think too
much about containerization.
And what I think is
powerful also about the way
that Jib packages your app--
because Jib doesn't take your
JAR or uber-JAR, or your WAR
and put it into a
Docker container.
It understands Java.
It understands that you
have resources, classes,
and libraries.
And it lays out a file system.
And the real package
is the container.
I think what people have sort
of missed about containerization
is that they've started like
packaging their packages.
And a lot of the complexity that
you see in the Java ecosystem
around uber-JARs
or executable JARs,
they're not really relevant
in the container world, where
you have your entry point,
and you can just arbitrarily
lay out files any
way that you like
and make it work, because you
have control over the Java
invocation.
And so that's what
kind of excites me
about Jib and the way it makes
containers a native packaging
format for Java.
MELANIE WARRICK: Nice.
PATRICK FLYNN:
The Java ecosystem
itself, I just think it's
amazing how long it's lasted
and how huge it is.
And it's incredibly
important for Google.
I think Java is the largest
code base internally at Google,
and we work with the
internal Java team as well.
A lot of the inspiration
for the way that Jib works
comes from the way that Google
containerizes applications
and has been for many years now.
I just love that
community out there, too.
I don't know if you've
heard of JHipster,
and Spring, and Micronaut.
There's just a lot of
innovation actually
happening in that ecosystem, as
well as the new JVM languages
that are getting popular,
like Kotlin, in particular,
with the adoption
it's had on Android.
It's just really exciting.
MARK MANDEL: So I'm
wondering if I'm
going to date myself
for how long I've
been out of the Java ecosystem.
Let's say I'm building a web
server with something like Jib.
I assume I still need
to embed something
like a Jetty or something
that actually runs the server.
How do I tell it--
how do I expose ports?
Is there a best practices there?
PATRICK FLYNN: Yes.
Currently the type
of applications
that we support in Jib are
only the Java dash type
applications.
They're not WAR
style applications,
although we're
adding WAR support,
and that should be
available pretty soon.
So anything that you could run
on your machine using Java dash
CP will work in Jib.
And what people typically
do for web services,
either they use Spring Boot
or some analog of that.
MARK MANDEL: I'm showing my age.
PATRICK FLYNN: Micronaut
is another framework.
There's a Play framework.
MARK MANDEL: There's a bunch.
PATRICK FLYNN: There's
so many of them.
MIKE ELTSUFIN: Yes, from the
Spring Boot point of view,
it produces a JAR, but it really
embed either Tomcat, or Jetty,
or more recently, it's actually
able to use a lower level
API which is called
Netty, a Netty server.
It's much more lightweight.
It's reactive, so
it's really cool.
In the new version of Spring
you could use that as well.
PATRICK FLYNN: And
since this is Google,
you can also, obviously,
create a gRPC endpoint--
MARK MANDEL: Of course.
PATRICK FLYNN: --very
easily, and package that.
MARK MANDEL: And since
you brought it up,
Mike, is there a
Jib, Spring Boot,
Google Cloud mashup musical
thing happening at some point?
Is that a thing?
Is there a workflow that way?
MELANIE WARRICK:
Especially musical--
it needs to be musical.
[LAUGHTER]
MARK MANDEL: It
needs to be musical.
MIKE ELTSUFIN: Yeah,
I'm probably not
the best person for
the musical part.
[LAUGHTER]
But we can get help for that.
There's no reason
why I shouldn't work,
I'm pretty sure
people have done it.
I don't know, Patrick, if you're
aware of any samples, demos,
that we have for that?
PATRICK FLYNN: You know,
they're very orthogonal tools,
so they just work well together.
I think there was a demo
at SpringOne for Knative
where you can actually--
one of the cool things
about both Maven and Gradle
is that you don't actually
have to configure a
plugin internally in your
build file to actually use it.
So what a Knative does with
their build template sets,
they have a Jib build template
that you can basically check
out any Spring Boot project.
And it'll build a container
without modifying the project
at all.
So that's a really nice
and easy entry point
to just go from an arbitrary
Spring Boot project
to something that's
running in Kubernetes.
MIKE ELTSUFIN: The other
thing with Spring Boot
is you're really write very
little code in Spring Boot.
There's a lot of
other dependencies
you might bring in.
And while you're
developing the application,
the fact that you're only
modifying this one class file,
Jib makes it very efficient
to update your container,
because it doesn't
have to update
all those other
dependencies that
are not changing in the
process of the development.
MELANIE WARRICK: So
how can developers
get involved in contributing
to these projects?
MIKE ELTSUFIN: Spring Cloud
GCP is obviously open source.
You can find us on GitHub.
We love all kinds of
contributions, feedback,
issue submissions,
bugs, pull requests--
all of that is welcome.
We always love when we see
the community contributing
and getting involved
in the project.
So just get on our
GitHub, and go from there.
PATRICK FLYNN: Yeah, I
would say the same for Jib.
We have-- I think it's called
Gitter chat from our GitHub
page.
You can find it under the
Google Container tools org.
There's also SIG App,
which we attend regularly,
which is a Kubernetes special
interest group, which talks
about some of these things.
And the Java and Scaffold
Slacks on Kubernetes--
the Scaffold one definitely
has a lot more people talking
than the Java one, but I'd love
to see more people participate
in that Slack channel.
And I think scaffold also has
a public bi-weekly meeting
that people are welcome
to attend as well.
MELANIE WARRICK: So
if somebody is new,
like never done anything
with Spring or with Jib
or with Java, and
they are interested,
how would you recommend
them getting involved?
MIKE ELTSUFIN: If they
have never used Spring,
there are a lot
of sample projects
we have in our GitHub repo
you can get started with.
We have pretty
good documentation.
And Spring itself has
great documentation.
There are so many books
on Spring and tutorials
you can find.
Besides that, we actually
have code labs, Google Cloud,
that you can follow
along on Google Cloud
and just get things running.
We'll link to that.
And that's just that you
can experience it right away
without really knowing too much
about how to build applications
with Spring or GCP.
MELANIE WARRICK: Cool.
Thank you.
MARK MANDEL: Patrick,
anything on your end?
PATRICK FLYNN: The best source
of documentation for Jib
is our GitHub page.
MELANIE WARRICK: Cool.
MARK MANDEL: Excellent.
MELANIE WARRICK: Thank you.
MARK MANDEL: Well,
before we wrap up today.
Is there anything that
you want to make sure
that our listeners know?
You going be at any events?
Is there anything
we haven't covered
in the podcast, anything at all?
We'd love to hear it.
MIKE ELTSUFIN: I just want to
say that even though we already
released the 1.0 GA
release of the project,
we're adding so many
new features right now.
And they're coming out soon.
We're bringing support
for DataSource,
so Spring beta data
store is coming soon.
We're looking into
the reactive APIs,
so look out for all
those new things coming.
And we're happy to hear
your feedback on helping
us set the direction.
PATRICK FLYNN: My team is going
to be at KubeCon in Shanghai
and at Oracle Code One.
And I'll be at
KubeCon in Seattle,
so if anybody wants to
get in touch with me,
definitely feel
free to reach out.
I'd love to talk to people.
MARK MANDEL: I'll see you there.
PATRICK FLYNN: Cool.
MELANIE WARRICK: Well, thank you
both for coming on the podcast.
MIKE ELTSUFIN:
Thanks for having us.
PATRICK FLYNN: Yeah,
thank you very much.
MIKE ELTSUFIN: That
was a blast, thanks.
MARK MANDEL: Cheers.
MELANIE WARRICK: Thank
you, Patrick and Mike,
for coming on the podcast.
It was great to talk to you guys
about Java, Jib, Spring, all
the things.
MARK MANDEL: Yeah, absolutely.
It was actually really fun.
I haven't touched Java
in a really long time.
So it was a really nice chance
to revisit the ecosystem.
MELANIE WARRICK: I know.
It's been a little
while for me as well.
So Mark, let me ask you
the question of the week,
as we never do.
What if we have an object
in Google Cloud Storage
and I want to automatically
change an aspect of it?
And some of the examples
that we were mentioning
is like downgrading the
storage class of objects
older than 365 days to Coldline
storage, which is definitely
a good question considering
I know a number of people
here about Coldline, but
they don't particularly
think about it; deleting objects
created before a certain date,
like January 1st of
2013 or something;
and keeping only the
three most recent versions
of each object in a bucket
with versioning enabled.
MARK MANDEL: Yeah,
so this is something
I actually also came across,
too, for the project I work on.
I work on Agones, and we
have development builds.
We have development
artifacts that
go into Google Cloud Storage
with every PR that comes in.
And obviously, that could grow
to really large proportions.
So what I wanted to be able
to do is basically say,
if there is a build
that's older than 30 days,
then just delete it.
We don't care.
I was thinking, oh, maybe
I have to write a script
or do all that kind of stuff.
I didn't want to do that work.
But within Google
Cloud Storage, there's
actually a thing called
Object Lifecycle Management,
which is really, really handy.
And you can do this
through gsutil.
You can do it
through the console.
You can do it through
REST APIs, too.
But basically you can kind of
just wander into the console,
and grab a bucket, and select
some object conditions-- say,
what age it is maybe,
or the creation date,
or what storage class
it currently is.
And then you can say, what is
the action that I want to take?
Do I want to set
this to Nearline?
Do I want to set it to Coldline?
Maybe I want to delete it.
And I can put these
across my buckets,
which is really nice as well.
And so this means, then,
that it's really easy
to be able to do some pretty
good management of the stuff
that you have in
Google Cloud Storage
and control both your costs, and
also how much stuff you store,
and where it goes without
having to really write any code
or do anything like that.
It's kind of just built
in, which is super nice.
MELANIE WARRICK: Nice.
MARK MANDEL: Yeah.
MELANIE WARRICK: You going
anywhere special next couple
weeks, next couple of months?
MARK MANDEL: No, I'm not really.
I'm going to take some vacation
at some point in November.
But outside of that,
I will be at KubeCon
in December, which I'm
super excited about.
MELANIE WARRICK: You're
going on vacation?
You're not allowed
to go on vacation.
MARK MANDEL: Yeah, I'm going
on vacation in November.
Bye.
[LAUGHTER]
MELANIE WARRICK:
Good luck, right?
All right, so anyways, you're
saying KubeCon in December?
MARK MANDEL: KubeCon
in December, which I'm
really, really excited about.
What are you up to?
MELANIE WARRICK: So this week,
Twilio's conference SIGNAL
and GitHub's conference Universe
are happening this week.
MARK MANDEL: Oh, nice.
MELANIE WARRICK: So a lot
of people are in town.
A lot of things are happening.
I'm planning on actually
going to Twilio's $BASH event
on Thursday.
So if anybody's
going to be there,
feel free to come up and say hi.
And then at the end of
November, I will be at SOCML.
MARK MANDEL: What is SOCML.
MELANIE WARRICK: I have no clue.
No, it's an unconference in
the machine learning space.
MARK MANDEL: Oh, fun.
MELANIE WARRICK: And
it'll be good fun
to connect with people on.
So looking forward to it.
MARK MANDEL: Excellent.
Fantastic.
All right, Melanie,
well, thank you
for joining me on the
podcast yet again this week.
MELANIE WARRICK: Good
to talk to you, Mark.
MARK MANDEL: And thank
you all for listening.
And we'll see you all next week.
[MUSIC PLAYING]
