[MUSIC PLAYING]
MARK MIRCHANDANI: Google Cloud's Anthos helps support companies
in modernizing their services in hybrid and multi-cloud
environments.
But what does the stack actually look like, and what
use cases does it solve?
Join us as we talk to Arctiq about how they implemented
a hybrid cloud environment on this episode of "Stack Chat."
Thanks so much for joining us, Kyle.
Tell us a little bit more about what Arctiq does.
KYLE BASSETT: Yeah, thanks for having us.
Arctiq is focused on services, and we're born in cloud,
and focusing on helping developers
using Git code in production, and all the things that
go around that.
And most of the time, we're spending that with enterprises,
so helping them solve that culture condition
problem of moving from their old world to cloud.
And all this automation and everything that comes with it--
we're helping enable them and getting them to be successful.
MARK MIRCHANDANI: So tell us a little bit more
about the specific infrastructure.
KYLE BASSETT: Yeah, so this particular customer
we worked with, they have a traditional application.
They've made it a microservices.
It's cloud native.
It runs in GCP and GKE.
And it's very successful in that,
but they've got customers that have
challenges around locality, data residency, things like that.
So they may have to deploy in a region
where there isn't a Google Cloud or they don't have good network
connectivity.
So for them, they've had to manage
that in the past of deploying homegrown Kubernetes
environments in those places and trying to manage them,
and trying to keep them updated, and patched.
And it's a tough job to be able to manage these things.
So they were looking for a common experience and a way
to take all the automation and all the good things they've
done in cloud, and be able to apply that
into their on-prem offering.
And most importantly, offer a consistent experience that
is easy to support, and then the customer
is not getting a lackluster experience just because it's
not in cloud anymore.
So that's really what's given them the agility
to be able to do this.
MARK MIRCHANDANI: OK.
So if they've got their home base in the cloud,
but then they've got all these different customers
in different places, and there's no commonality between some
of those environments, then, as you said,
it's a pretty difficult thing to manage.
I hear that Anthos kind of played a big part in helping
standardize this environment.
So what does that actually look like?
KYLE BASSETT: Yeah.
So this customer was leveraging homegrown Kubernetes
in many cases, and when they saw Anthos, their interest was,
could we take Anthos and that reference architecture,
apply it into our customer scenarios,
but leverage our exact same CI/CD pipeline,
all our same Helm templates, all those charts
that we've been leveraging and deploy on there
without having to replatform all their deployment every time?
So they looked at that as a real game-changer
for them, to be able to go to market and solve
some of these customer challenges
that they hadn't been able to solve yet.
So we started the project and built the architecture
around this.
We deployed a VMware cluster in Berlin
and got that up and running.
And then it was taking all the lessons learned in cloud.
So they were using Cloud Build.
They were using GCR.
They were using a lot of those rapid cloud tools.
So really, all we had to do is get those artifacts now
into their private stack, and be able to deploy against Anthos.
So within a couple of weeks, we were able to stand all this up,
put it through performance testing.
It was a real lesson learned.
And the biggest impact was, can we take this common experience
and make this on-prem deployment look just
like another deployment region?
That was the real goal.
MARK MIRCHANDANI: Right.
So now, they've got all of these environments that
are kind of like offshoots of their core environment,
but they all look pretty much the same.
And then they roll out the code the same way
they were kind of rolling it out before,
but now it's easy to roll it out to all of those.
KYLE BASSETT: Yeah.
It really is that perfect hybrid story because that's
the deployment region, is the end-state code
after it's tested.
That's where it's going to run.
But they still have to do innovation and testing,
and put new features in.
So that's where the cloud comes in handy for them.
So they were able to spin up clusters on demand,
and we started looking at things like config management for them
and helping them Gitify all that workflow.
But they can spin up clusters on demand in GKE,
do all their testing, tear it back down.
Once they get a release ready, they can push that release out
to that on-prem environment, and it's all just
through standard automation framework.
So it takes away the whole worrying about a maintenance
window, or doing it on Sunday.
They can roll out changes and be really rapid and really agile
in their development cycle.
MARK MIRCHANDANI: So even though they've
kind of made all the other environments
common to their home environment,
how do they keep them in sync?
KYLE BASSETT: Well, keeping them in sync,
one of the big things we've been looking at
is doing everything through policy, so policy management.
And that's one of the things config
management, part of Anthos, brings
to the table is instead of people going in and making
manual changes to clusters, why isn't
it done through a Git workflow, or PR process and a peer
review?
And when that gets approved, it gets pushed out.
And not just to one cluster.
You can do that to many clusters.
You can also do it to clusters on-prem or in cloud.
The other piece it gives them is they
can add extra things that they're concerned about,
like security frameworks, or if they're doing custom Istio
rule sets, their developers-- they can start to make sure
that that framework is spread across all the environments.
And then that steps up the audit capability, the compliance
side.
So when someone comes in and says,
how are you managing these things?
They're able to build a report and say,
this is all driven from source.
Look at the Git log, and that's how
we manage our infrastructure.
MARK MIRCHANDANI: And it's all the same
across all those environments because the unified config
management makes it easy to roll out.
KYLE BASSETT: Yeah, even down to if someone jumps on
with an elevated access and makes
a manual change to a cluster, that drift that usually
happens?
Config Manager will change it back.
But if you put time into building the policies, and then
developers can focus on writing code,
and the security teams can focus on making sure
that that code is of the quality.
So if everyone puts time into this,
it just comes through a pipeline,
and it all drives the quality.
And people in various departments,
and most importantly, developers can
focus on developing and releasing at a high velocity.
MARK MIRCHANDANI: And their customers
just get to focus on using the same stable application
that now they feel more confident in because the parent
company kind of has that responsibility of making
sure it works everywhere.
KYLE BASSETT: Yeah.
In the end, the customer just wants
to be able to do their job, and they're buying the software.
And they want to know that they have the trust that it's
going to be up, because a lot of these
are billing-based application.
It's like the revenue-generating side of the business.
So they're looking at it as a managed service,
but they've got constraints that they have to be on-prem.
But they need to know that when new packages or new updates
come, they don't have that worry that they're
going to have to go through a lot of pain or an outage
to their customer, which isn't good, obviously.
MARK MIRCHANDANI: So as you were kind of helping them roll out
this entire architecture, what would you
say kind of the biggest hurdle that you jumped over was?
KYLE BASSETT: I would say just standardizing
all the configuration.
This particular customer spent a lot
of time putting the work in.
And knowing that they could do it manually
to get it working once, they actually
put the time into automating it all
and testing it, which really pays off
in folds as you start to scale.
So that was one of the challenges
we took is just getting that exact workflow they were
using in cloud and applying it and finding
the pipeline for on-prem.
Obviously there were some security restrictions
around networking and access.
We had to deploy an on-prem registry
and find a way to sync all the images down
so we have that workflow.
So the biggest thing is they put the time in
and we worked with them to enhance it,
and then now they're paying off in folds as they roll this out.
As they move forward to push this and scale their business,
they don't have a lot of technical debt.
It's all documentation is living.
It's all in the Git repo.
MARK MIRCHANDANI: Thanks so much for coming in and showing us
how you actually kind of built this architecture
with this customer to support all of their own customers.
KYLE BASSETT: Yeah, so thanks for having us.
We're really looking forward to rolling out Anthos
to more customers and getting it out in the market.
MARK MIRCHANDANI: Get Anthos ready by checking out
this quick lab on modernizing and deploying
your application with GKE.
Thanks for watching, and make sure to subscribe
for more great Google Cloud Platform content.
We'll see you next time on "Stack Chat."
[MUSIC PLAYING]