So let's talk about the three
different buckets that exist with
technology nowadays in the cloud,
native space or technology in
general.
You have the traditional way of
doing it.
Now you have this new wave or cloud
native coming down the line.
And then also you have the
serverless platform that is
pretty new and still
has a level of risk that you need to
think about.
So let's dig into each one of these
a little bit deeper.
We have our traditional ways of
doing things.
We used to have this little WAR file
or EAR file or something like that
to deploy our code to our servers.
Then we'd have something
that would sometimes take months or
if not weeks to deploy.
And it costs so many frustrations.
Well, we're moving past this, and
now we're moving to our new wave.
Frankly speaking, I'm calling it New
Wave because I don't want to say
cloud native over and over again.
But what is it?
It's our next step.
It's what we're moving past our
traditional way of doing things.
We have these great things called
containers now, which allows us
to be able to package
up our code in smaller bits
and be able to push things out
in a fast, efficient way
and share code where it "works on
my laptop" no longer means
it just works on your laptop.
It works anywhere.
Anywhere a container can run.
And another great thing about the
new wave or the cloud native space
is that it only takes minutes to
deploy.
But you're probably wondering why
am I talking about all this when I
should be talking about risk?
We need to have some level set of
understanding of all these different
technologies before we dig into the
risk profiles of each of these,
and hopefully it'll open up some
spaces for us.
Serverless is still built off of
containers, just like our new wave
or cloud native space.
But the beauty of it is, is it's
so small.
It's just the changes you need to
worry about.
It leverages true microservices
where functions do all the work.
But that brings in an interesting
risk profile when you start talking
about these technologies.
So let's actually take this next
step and talk about what happens
when you start worrying about these
different systems for your risks.
So how do companies actually
mitigate risk when it comes to
moving to Cloud Native?
First thing they do is they start to
learn to trust their engineers.
But with that trust takes a little
bit of time.
They leverage something called the
"four eye" rule and make
small, iterative changes.
With that comes at least
four eyes looking at every small
change to be able to
be merged into the main
branch.
But when that gets merged, what
happens next?
They go over to the bots to do the
work for you.
No longer do you have someone
releasing some code at three in the
morning.
Instead, when you merge it into
the main branch, the bots take
over and release the code for you.
This means you no longer have a
council of elders, of senior
engineers and executives discussing
every single change.
Now you let the bots do the work for
you.
But with that comes complexity.
We're going to talk about how to
take care of some of that complexity
over something called GitOps,
which, believe it or not, is pretty
dang cool.
So what is GitOps?
Simply said it's leveraging
a git repository as your source of
truth for the deployment of your
applications.
It can be production.
It can be development, could be even
dev.
So how does GitOps actually make
your life easier when it comes from
from the angle of risk?
First thing first, you can actually
audit any change you've ever made.
Can you actually answer when the
last time you deployed your
application and who made
what change?
Majority of people out there, they
can't. Leveraging GitOps, you
actually have an auditable system
through the Git history.
With that too, that
means you can also verify what
the change has been made because
it's cryptographically signed using
the githash algorithm.
This is important, especially in
regulated environments.
Taking it a step farther, if
something horrible goes wrong, you
actually take that git repository
and recreate whatever you're trying
to do in another environment.
This gives you the ability to
make sure that it comes out exactly
how you want, every single time.
You have to leverage different
technologies, though, to
enforce these GitOps principles like
Argo CD or Flux CD.
But that means you need to start
trusting the bots to do the work for
you.
This is going to be a big problem
for a lot of companies because
no longer will you have humans do
these changes, you're now
having the machines do the changes.
So you're going to have to spend
some time with the operations team,
your SRE team, your DevOps
team, to really be
able to embrace this new mentality.
But you will
reduce your risk in the long term
because you'll be able to enforce
things leveraging the get off the
principles.
Thank you. If you like this video
and want to see more like it, please
like & subscribe.
If you have any questions, please
drop them in the comments below.