- [Alana] As Raf and I mentioned earlier,
a pipeline is also programmable infrastructure.
For example, take CodeDeploy.
In Exercise 2 of the course, you created an application
and a deployment group in the console manually.
While you were doing that, I created an application
and deployment group in a CloudFormation template.
Here's what it looks like.
We have our application declared at the top
of the screen, here.
We gave it a name and we also determined
that we're deploying to Amazon EC2 as our compute platform.
So overall, six lines of code to declare
this resource. Not bad.
If I scroll down, you can also see my deployment group
and all of its properties.
So, not only do we have the name of the deployment group,
which application it belongs to, our configuration settings,
and the deployment style, we also declare
which EC2 instance we'll be deploying to, in this case,
the instance that's tagged as CodePipelineBlog.
And you can also see that it references the application,
so that means when I run this template through
the CloudFormation console, CloudFormation won't build
the deployment group until after it builds the application.
This makes sense because we need an application before
we can create a deployment group.
I also, in the same template, created a service role
for CodeDeploy and an EC2 instance that has
the CodeDeploy agents installed.
So basically, everything you did in Exercise 1 and 2
is now in this one template.
To build off of all that, I also created all
the other components of a pipeline,
including CodeCommit and CodeBuild.
And then, I created a code pipeline
with a source stage,
a deploy stage, and an acceptance test stage.
So, let's see this run.
I'll go to the AWS Management Console,
search for CloudFormation,
click Create stack,
upload this template file called final_pipeline,
and click Next.
Here, I'll have to name the stack.
I'll call it final-pipeline-stack,
and then, I'll call the pipeline, final-pipeline.
So, I'll go ahead and keep all the other defaults,
click Next, keep the defaults again, and Next again,
acknowledge that it might create IAM resources,
and click Create stack.
However, I've already created this CloudFormation stack
earlier to save us some waiting time,
which is why we got this error here,
so I'll go ahead and cancel out of this,
and click on the stack that I created earlier
to find all of its resources.
All right, so this CloudFormation template
has already been provisioned and everything looks good,
and if I click on this Resources tab here,
we can see all the resources that were created
when I ran this template.
So, let's jump over to our pipeline that was created
by this template by going to the CodePipeline console.
As you can see, the pipeline has already started running,
but here's what happened behind the scenes.
If I go back to the template, when I wrote the code
to create CodeCommit,
as you can see here,
I chose to propagate the repo with code from an S3 bucket.
So, the commit was made, which kicked off the deployment,
which if I go back to the console, I can see has succeeded.
If I click on the Details and scroll down,
I can find that the instance that it deployed
to is right here, so I'll go ahead and click it,
which brings me to the EC2 console.
Select the instance, copy the public IP address,
and paste it into my browser.
And it looks like the deploy worked!
My app is up and running.
Okay. let's go back to the pipeline and see the final stage,
the acceptance test.
All this test does is access the instance
and check if it can access the landing page.
If we click Details of this stage,
we can look at the commands we ran in the buildspec
and the output of those commands.
As you can see here, it pulls the HTML from our landing page
and that's exactly what we wanted to accomplish,
so everything looks good.
So that's how I automated a pipeline with CloudFormation.
If you're looking for this template to download
so you can try it yourself, I'll be providing it to you
in Exercise 3 of the course, along with
the buildspec file, the AppSpec file, and the app itself.
Now, if I wanted to take it a step further,
I could change the HTML file and commit it to my repo,
kicking off the pipeline once again,
and see my changes in real time,
but you'll be doing that in the next exercise,
so see you soon.