Among the topics that we covered were:
- How the OCI primarily focuses on areas where standardization is critical
- The OCI's relationship to the Cloud Native Computing Foundation
- Future directions, especially in distribution
- How the industry has changed to encourage this sort of organization
- Open Container Initiative
- Podcast with Dan Kohn of the Cloud Native Computing Foundation
- Cloud-native landscape on github
Transcript:
Gordon
Haff: First of all, probably a lot of our listeners know what the OCI
[Open Container Initiative] is, but maybe a little background for those who
don't.
Chris
Aniszczyk: The OCI came together a little over a year ago when there
was a desire to come and standardize on container runtime and format, instead
of having different competing implementations out there, which would ruin the
original promise of containers being truly portable, vendor neutral, and all
that good stuff. The OCI was created to build the standard around the container
format and runtime.
Gordon:
Has it been successful?
Chris:
I think it's been going great. We originally started out the project
with...Docker donated something at the time called Libcontainer, which morphed
into runC. runC has grown and seen lot of success. It's embedded in Cloud
Foundry.
Of
course it exists in Docker's containerd, Engine, and all that stuff. Kubernetes
is picking it up in its container runtime interface, and runC and the runtime
specification is becoming the de facto way to execute containers, which is
great.
Another
aspect of the OCI...when the OCI started, it focused just on the runtime spec.
About six months after the project was started, the OCI technical oversight board
said, "Hey, we should consider standardizing on the image format," so
the image specification project was created at OCI. There's been a lot of good
work in that area.
We've
seen just recently, like a week ago, Amazon announced in their ECR product, the
Elastic Container Registry, that they support the draft of the OCI
specifications. Pretty much, most other projects are adopting the image specs.
I think in general we've made a ton of progress in many fronts. Mostly any
system that runs a container is probably using some of form of OCI technology.
Gordon:
When do you see that spec being finalized, getting to a v 1.0 level?
Chris:
Last week, for both specifications ‑‑ the runtime spec and the image spec
‑‑ we released v1.0 RC4, release candidate 4. In OCI parlance, what that means
is there's been four release candidates, but in order for them to declare a
1.0, they need at least three.
We
have the minimum requirements set. It's just a matter of when developers are
happy with the stability, and when they want to bless it as a 1.0. My personal
feeling is we'll see RC5 or RC6 will be the 1.0 final. That's a month or two
away.
Gordon:
Obviously, the Cloud Native Computing Foundation is also a Linux
Foundation. Another podcast, which I did, which will be linked to from this
one, was with Dan Kohn, who's the executive director there. In your copious
spare time, you work with the CNCF, as well. How do you see, the groups
relating?
Chris:
I served as an executive director for CNCF, since the beginning, until
Dan came on board to help out. I transitioned to a more COO‑, CTO‑type thing,
so my role in CNCF is mostly focusing on attracting the projects, working with
the TOC and all that stuff, and trying to build out the Cloud Native Landscape,
technology‑wise, within CNCF.
In
terms of how these organizations relate, there's a lot of membership overlap.
There's probably 80 percent membership overlap between organizations, but OCI
was defined very narrow in scope. It's mostly focused on runtime and the image
format. There may be some other things that we consider in the future, but
things like networking, storage, these are all out of scope. These are things
that will exist in the CNCF in some fashion.
There
is this awesome thing that we developed called the Cloud Native Landscape. If
you go to github.com/cncf/landscape, you'll see this picture. OCI is featured
in there, and that's in the aspects of the container runtime bit. That's just
one piece of technology that we consider important in CNCF land, but as a
whole, there's a slew of stuff out there.
The
foundations work closely, lots of membership overlap. It's something we try to
do, make sure people talk to each other and all that good stuff.
Gordon:
I think you've just answered this question, but I'll ask it again in
slightly different way. Where do you see, from an OCI‑specific perspective,
where you want to standardize and where you want to innovate?
Chris:
Like I mentioned before, we've initially focused on the runtime
specification, then the image specification. That area is super important to
standardize, because people want to make sure their containers are portable and
will run on different things.
Other
aspects that have come up within what we call technical developer community
within OCI, distribution is one of those topics that people feel like there's a
lot of different registries out there. Maybe it's time to come together and
standardize on how containers are fetched and distributed.
That
discussion's happening in the OCI TDC. But in order for them to expand the
scope of the OCI, they're going to have a meeting with the Technical Oversight
Board, do a vote, and all that typical, wonderful governance process that you
see in open source foundations.
That
may be something else that will end up in the OCI in the future, but there's no
guarantees. It's whatever the TOB decides. But things like networking and
storage, those will most likely be permanently out of scope for OCI. There's
too much innovation going on in that space. There's lots of ways to do
container networking. There's tons of ways to do storage. Those are areas we
expect CNCF to take over and shepherd.
Gordon:
In terms of some of the specific work that's going on in terms of the
interfaces between Kubernetes and the container stuff, CRI-O and so forth,
where does that fit in here?
Chris:
CRI-O's an interesting project. Essentially, Kubernetes is doing the leg
work to extract itself from the underlining container engine, which is a smart
move. The Mesos community actually did this a long time ago with their external
containerizer.
CRI-O
is a similar effort in a similar vein. The goal is to support all the different
container engines out there. OCI will be supported by default, but Docker, rkt,
and all the other specific engines will be supported too with their specific
flavors of additional functionality.
CRI-O
will use the runtime format and the image format to support the basics, but
storage, how you fetch your stuff, that's not standardized yet. They'll use
other respective other technologies out there to make that happen.
Gordon:
To try and summarize here, you really see the OCI as focusing on
standardization to avoid fragmentation.
Chris:
Portability. I think if you are an end user, if you're a a developer and
you want to build your container and run it somewhere, you'd be really pissed
if you have to rebuild it to run it on a different cloud provider. I view this
like all the different browsers out there. There's Safari, Firefox, and so on,
but HTML CSS, if you write a page using the latest specs from W3C, it's going
to run on the different browsers.
But
the different browsers compete on performance and other types of little
features, developer tools. I think you'll see similar things in container
tools. The container format and execution of it will be standard across
everywhere, but the different engine or orchestrators will find different ways
of compete on performance, security, and so on.
Gordon:
But you don't really want to have two different web pages for Internet
Explorer, Firefox.
Chris:
As we've been saying, absolutely. [laughs]
Gordon:
You mentioned distribution, specifically. What are some of the other
areas that you think, at least potentially, might be interesting for the OCI in
the future?
Chris:
It's hard to say. I think networking could be interesting, but there's
too much. It's fertile ground. There's a lot of innovation going on. There's
different approaches. I don't know. It's like browsers. Over time, certain
things got standardized in CSS and HTML that may have been crazy at that time,
but down the road, who knows.
The
next year or so, I think distribution will be a hot topic within OCI. Anything after
that, it's really hard for me to say. It's up for the OCI technical development
community and the Oversight Board to make these decisions. But we'll see tons
of these projects in these spaces.
Over
time, I think developers will get together, "OK, it's really stupid for us
to like compete on maybe all these different registries. At least let's
standardize on some of the basics, and compete on, you know, the other 20
percent."
Gordon:
Chris, a slightly more meta question. Historically, companies haven't
wanted to standardize in most areas. It strikes me that, in the container
space, the virtualization format battles that went on for years and years,
there's been a lot more willingness to go, "OK, this area doesn't
differentiate. We're just going to..." you know, an HD DVD, Blu‑ray thing.
We
really all standardize here, and it's really happened fairly quickly.
Chris:
I think the industry has changed over the years. Open source is more
prevalent. People have learned a lot of lessons around lock‑in, and they don't
want to repeat the mistakes. The visualization fiasco with the format, VM, all
that, that's a painful memory in a lot of people. People are worried about
paying the "VMWare tax." Lots of lessons have been learned.
If
you remember from the Java EE days, the whole notion of you having a WAR file,
and you'd be able to deploy it on WebLogic versus WebSphere, that just worked.
That was good. There was lots of "gotchas" around that, but the idea,
in theory, was good.
People
have learned their lessons, and I think they want to standardize on the thing
that will allow the market to grow. Everyone wants containers to be super‑successful,
run everywhere, build out the business, and then compete on the actual higher
levels, sell services and products around that, and not try to fragment the
market in a way where people won't adopt containers, because they're scared
that it's not ready, it's a technology that's still [laughs] being developed.
Gordon:
I'm not sure if it's still a maturing industry or taking the desires of
their customers into account. Maybe a mature industry does that.
Chris:
I think customers are smarter these days, too. I think a lot of them are
making the demands, especially from our end‑users at least. I won't name
specific companies, but some of the higher‑end financial companies, this is
definitely 100 percent something that they ask for.
It
helps them for price pressure on different providers, like, "Hey, I can
move my stuff easily here." People are learning the lessons. It took a
generation for us to get there, but this is something people now ask for from
their vendors.
Gordon:
With containers, specifically, as you mentioned, portability is one of
the promises of containers. So if you don't get portability...
Chris:
Exactly! You're locked in, and no one wants that. It's great to see the
Windows folks contributing, Intel, all the OSs, architectures. Everyone is
contributing to make sure that this actually will work on different platforms,
so people will chose their platform, potentially, down the road.
I
think it's great. Definitely the industry has changed over the years,
especially if you look back a decade ago. A long time ago, it was mostly like,
"Let's lock people in and secure all the profits." That's not going
to [laughs] work anymore. You have to collaborate and build the business on the
actual thing you want to differentiate on.
Gordon:
Great. Thanks Chris. Any closing comments?
Chris:
OCI's definitely a growing project, and I look forward to seeing the 1.0
release in a couple of months.
