[MUSIC PLAYING]
KELSEY HIGHTOWER: Hi, I'm Kelsey Hightower, a staff developer
advocate for Google Cloud Platform.
ARMON DADGAR: And I'm Armon Dadgar, co-founder
and CTO of HashiCorp.
KELSEY HIGHTOWER: This is the first video in our series
covering open-source tools from HashiCorp
and how we can use them with Google Cloud Platform.
In the next few videos, you're going
to learn about using Vagrant, Packer, and Terraform with GCP.
Armon, can you briefly explain those videos?
ARMON DADGAR: Sure.
You know, Vagrant is a pretty popular tool
that many people have maybe played
with or at least heard of.
And it's commonly used to bring up a development environment
in a quick, repeatable manner.
Packer falls sort of right after that,
helping people to build those machine images
and build those sort of environments,
either for development, so build images for Vagrant,
or to build production-oriented images,
for example, a GCP, a VM image.
And then Terraform is kind of next
on the kind of development-to-production
lifecycle, and it helps people provision infrastructure,
whether that's a vSphere cluster locally
or a GCP cluster in the cloud.
KELSEY HIGHTOWER: So if I'm a user,
I'm hearing all of these tools.
I'm like, that's a lot of puzzle pieces.
Can you touch on how you tie all of these tools together?
ARMON DADGAR: Sure.
I think this really goes back to kind
of our mission at HashiCorp and why the company even exists.
When we started the company, it was really
to look at that application delivery
process from development through to production,
and say, like, what are those pieces that you really need,
the necessary and sufficient components?
And then building an open-source tool to do each of those things
so that you can provision, secure, and run
any type of infrastructure for any type of application.
KELSEY HIGHTOWER: Awesome.
And users who I know have played with HashiCorp tools,
they all tell me it's like all the tools have a similar look
and feel.
Is there a common approach you take to building these tools?
ARMON DADGAR: Yeah, I'm glad you asked.
There's a document we've published
called the "Tao of HashiCorp," where we talk about what
the design principles and kind of the core philosophy
is behind kind of our approach to infrastructure,
as well as our approach to actually building tools.
And that comes across in kind of the look
and feel of the tools themselves.
KELSEY HIGHTOWER: So I think that's
one thing that sets HashiCorp apart,
is how this look and feel of the tools are.
Can you talk about some of the principles
behind that look and feel?
ARMON DADGAR: Sure.
We outline all of them in the "Tao."
There's maybe six or seven of them.
But I think the three that are kind of the most important
for people is a focus on workflows,
infrastructure as code, and immutability.
The workflow focus for us is very, very important,
because our view is that users are going to bring
their own technology, right?
So some users, they're going to be
living in a world of vSphere and on-premise,
and how do we meet them there?
And other users are going to be fully
in the cloud, running everything in GCP,
and how do we support that?
And other people are going to cross this entire spectrum.
So that's sort of our focus on workflow
as opposed to technology.
And then when we get to immutability, the idea is--
how do we avoid changing our applications, our machines,
our infrastructure in place, where we might introduce errors
into production and then cause things
to fail in sort of unexpected ways,
and instead build brand-new versions that we fully know
and understand and can vet?
And I think then the third kind of most important one
is this notion of infrastructure as code, which
is another technique to kind of manage the complexity
and make sure we can go to large scale in a sane way.
KELSEY HIGHTOWER: So I have a lot of experience
with infrastructure as code.
But maybe for some of the people out there watching,
could you give me a little bit more detail
about what infrastructure as code is
and what it means to HashiCorp?
ARMON DADGAR: Yeah.
I think it's a pretty general idea.
It can apply to all sorts of things.
But I think the kernel of it is this notion
that what we're used to is having sort of in our heads
the idea of how our development environment is built,
how our clusters are managed.
And what we're really trying to do
is take that that's locked away in our head,
and bring it in and have it live as code
that actually can be executed.
Right?
And this way we can version control it.
We can reuse it.
We can share it with one another.
We can extend it over time.
And we can really begin to apply the best practices of software
development to infrastructure management, right?
And so the goal is to kind of get away
from the oral tradition where you're like, Bob in the corner
really knows how everything works, and nobody else does.
KELSEY HIGHTOWER: All right, so let's be honest.
Is this technique unique to Terraform?
Or do you see this technique in other places?
ARMON DADGAR: So it's a bit loaded, because I know
you used to work at Puppet.
But you know, I think to give credit where credit is due,
I think this idea was really first pioneered by the config
management community, where they really
realized that it's getting increasingly complicated
to manage a modern server.
So just understanding users and packages and files
and directories and permissions, blah, is too much.
So how do we have all of that live as code
and be able to manage our servers
in this programmatic way?
So I think the config management community really pioneered it,
and now we've taken that and are applying it
to sort of the broader HashiCorp tool chain.
KELSEY HIGHTOWER: Awesome.
So you talked about this focus on workflows.
How does that focus on workflows affect HashiCorp and GCP?
ARMON DADGAR: Yeah, that's a great question.
Like I said, for us it's this belief
that we have to meet our users where they are, in terms
of their technology choices.
And for us, a huge part of our community
lives and operates and consumes GCP.
So for us, it's really important to make sure with Vagrant,
you can have a development box on GCP.
With Packer, you can build images for it.
Terraform, you can manage your GCP clusters,
so on and so forth.
It's that all of the tool chains should integrate with GCP,
because that's a technology choice users want to make.
KELSEY HIGHTOWER: All right, so hey.
Thanks, Armon, for joining me today.
How can more people learn about more of HashiCorp tools
and the philosophy behind HashiCorp?
ARMON DADGAR: Yeah, thanks for having me.
It's always a pleasure, Kelsey.
I'd recommend people visit our homepage, HashiCorp.com,
to learn more about the company and the tools.
Or alternatively, people can just watch your talk on YouTube
that you gave at Hashi-Con about delivering a 12-factor app
with the Hashi stack.
KELSEY HIGHTOWER: Cool.
So hey, thanks everyone for watching.
Don't forget to subscribe to the channel
to keep up with more of the open-source videos
in this series.
We've got more to come for how you
can use other open-source tools with GCP.
[MUSIC PLAYING]
All right.
Thanks for watching.
Make sure to check out these other cool videos
on the channel, and don't forget to subscribe.