ELIAS PINTO: Oh, hey there, Nick.
NICK PAN: Hey, Elias.
Fancy seeing you here.
ELIAS PINTO: I don't often see you down these parts.
Now, where's that old boat of yours?
NICK PAN: It's that beaut over there.
The one with that light blue spinnaker.
ELIAS PINTO: Spinnaker you say?
Now, what's that?
Is that one of those whiz bang new gizmos
I should be knowing more about?
NICK PAN: A spinnaker?
And you call yourself a sailor?
You old buccaneer.
A spinnaker is the front sail of your boat.
You know what else it is?
ELIAS PINTO: What?
NICK PAN: Spinnaker is an open source,
multi-cloud, continuous delivery platform
for releasing software changes with high velocity
and confidence.
Let's jump to a demo.
So this is the Spinnaker dashboard.
And on this dashboard, you're able to see the resources
that Spinnaker manages.
In this case, we're managing resources on Google Cloud
platform, and we're actually going
to exhibit a demo, which is a developer pushing code
into a release branch, having that release branch be built,
tested, validated, and then promoted into production,
and then deployed into production.
So as we see here, we have two load balancers--
an ingress load balancer for a staging environment,
as well as an ingress load balancer
for a production environment.
Both of these are hooked up to Google Kubernetes engine
clusters, and you'll see here they're
both wearing the same Go application
with a white background just exhibiting
the text "hello world."
So let's say I'm a developer and want to release a feature
change to this application.
In this case, we're just going to change the background color
from white to yellow, and to do this I would just
jump to my source code.
I go ahead and adjust the index at HTML
file to go from white to yellow, or in this case, light yellow.
And then I would just push this commit into my version control.
For this case, I'm using GitHub.
So we just go through the standard get commands,
and we add a commit to say that we're
adjusting to light yellow.
And then once we actually push that into our codebase,
we're able to kick off our CI/CD,
or Continuous Integration Continuous Deployment,
pipeline.
So I'll just go ahead and log in to GitHub, and then from here,
we'll kick off that process.
So if I hover back into the actual Google Cloud Platform
console, you'll see here that we have a tool known as Google
Cloud Source Repositories.
And what this tool does is allows
you to mirror GitHub repositories
within Google Cloud backed by reliable, durable object
storage.
If you see here, we've already noticed
that commit that I pushed into GitHub,
and you'll see that commit adjust
to light yellow background.
And here this is being noticed almost in real time.
From here, we have a container registry
build trigger that's basically monitoring
that cloud repository and building a container, which
will be our docker artifact that will then deploy
into the Kubernetes cluster.
So you'll see here there's a trigger that's
monitoring our GitHub repo.
So we have created this docker image.
It's been built just now.
It's 288 megabytes in size, and we've tagged it with two tags--
one, latest; and the other one, MD5
hash digest of the commit ID.
So this is where Spinnaker comes in.
What Spinnaker does is that it monitors a docker registry,
and when there's a new image that's
uploaded to that registry, it'll kick off a pipeline.
So I hit the Refresh button.
We should see a pipeline for deploying to stage
that's about to be run.
So you'll see here, it's now running.
So at this stage, what it does, if you see over here,
it's monitoring that docker registry
or that Google Container Registry
to see when an image is actually uploaded there.
Once it detects an image has been uploaded,
it then begins the deployment process.
So here you can see we're deploying it
to our staging environment using a red/black deployment
strategy.
So this takes some time to complete.
We're going to take a quick break,
and I'll come back once it's completed.
All right, and we're back.
You can see that that deployed a stage step completed,
and now we're held up at this validate stage.
What's awesome about Spinnaker is
that it gives you the ability to have a human intervention
in your pipeline.
So you have the manual judgment step,
which allows you to approve this pipeline
and move on to the next step when
you've confirmed that you're staging
environment looks good to go.
So I'll go back to our cluster side.
We'll click on that ingress load balancer, find that IP,
and I still have that opened in my tab.
So I'll go to my top right and check this page.
When I refresh this, it does show
that we've made that change, and it is now
a light yellow background.
If we looked at the production environment,
we'll see that's still showing a white background.
So we'll say this is good to go.
We'll hit Continue and now basically go to the next step.
We have confirmed that we've validated that the release
stage is good to go, and now we're
at the point where we're comfortable to promote
to production.
So in this promote to production pipeline,
we have numerous steps.
And this also takes some time to complete
but ensures we are able to do a reliable as well
as a repeatable deployment.
So I'm going to pause the video.
We're going to come back once it's completed.
And there we have it.
The promote to production stage has completed.
At this point we should have that pristine docker
image deployed into our production Kubernetes
environment.
So we go back to that ingress load balancer.
I still have that tab open with that IP.
At the moment, it's still showing white,
but when I hit Refresh, it should go to light yellow.
There you go.
So at this point, we've done an end-to-end CI/CD deployment
from source code into build steps,
released into a staging environment,
and then promoted into production.
And Spinnaker is what makes this all possible.
ELIAS PINTO: I thought I knew everything
about sailing and GCP.
But boy, I was wrong.
If you're working on cool projects
and you want to get in touch with us,
click on the link below to contact us.
Till next time.
[MUSIC PLAYING]