See CodeStar and Cloud9 IDE in action with a fully-automated AWS-based CD pipeline.
- [Instructor] So, here I am inside of CodeStar in my example project that I opened and made a couple of changes to already, so let's tour through this interface. So, you can see, we have a dashboard here and we have various tiles. So, if I wanted to add a tile, you can see the types of integrations we have here. The tiles that I have set up are showing that I have a commit history on my master branch. I have a Cloud9 development environment, which we'll visit shortly. I have an application endpoint and I have CloudWatch monitoring on application activity.
Let's go ahead and hit our endpoint. This is our example application and I made a couple of modifications because I'm in California. This original source, you'll see, was made in Seattle. And over here is our pipeline objects. You can see that's associated on the left side as far as menus and they pop out to the different area. So, this would be Code, Build, Deploy, and Pipeline. And so, our continuous deployment code pipeline here is set up for a manual release of changes, so not fully automated.
And then we have Source, we have Build, and we have Deploy, and Source is using CodeCommit, Build is using CodeBuild, and Deploy is using CloudFormation. And then we also have our pipeline. So, if we click inside of here into commit history, if we open this in a new link, you can see that we've had several commits. And inside of here, we have a Visualizer and we can see the commit history and we can actually also compare across branches if we had multiple branches, which we don't.
We can look at pull requests, so it's a typical source repository. So, I'll close this and then we can go to CodeBuild, and you can see that we have our hello-node project here and we have build history and we can see the build runs. So, if we scroll in, there is information about our build run and we can get all the way into the logs here, and we're going into CloudWatch for our logs.
And then, in terms of our deployment, if we go to our deploy history, you can see that we are in CloudFormation because as mentioned earlier, this service integrates with CloudFormation. And we can see the changes that have been done and we can actually drill all the way down and we can see the template that was used to set this project up. Of course, we can also see our pipeline, so we could see that from here, and here's our complete pipeline. So, we've got Source with CodeCommit, Build with CodeBuild, and we've got Deploy, and notice we're working with change sets in CloudFormation.
Now let's go to our code editor and let's make a code change. So, let's say Designed, comma, developed and updated. And then let's go ahead and save everything and then let's do a git status and let's do a git commit -a, and then let's say added comma and let's do a git push. And we can see now, we've pushed. So, now let's go over to our pipeline, which we can see either in the pipeline or we can see it inside of CodeStar 'cause we created this pipeline in CodeStar.
We don't have any changes because we have this manual approval process here, that we have to have a person, this would usually be a product owner, has to review the status of the code and then release the change. We'll click Continue and then refresh, and there we can see that we're in progress. Now, this takes a couple of minutes. I'll pause the video and then as this is completed, I'll come back and show you the results. Alright, it's been a couple minutes and if we take a look at our continuous deployment pipeline steps, they look like they have all succeeded.
So, we have success on the Commit and on the Build and on the Deploy. Of course, the quickest way to check this would be to actually do a manual verification and we're expecting to see a comma right there, so that's looking good. So, now let's, again, understand what it is that we are working with here. So, if we go over to the Code section, we can see that we have a repository. And again, you can use GitHub with CodeStar, but I'm showing mostly the Amazon tools in this course because it is an Amazon course.
So, CodeCommit is a repository that they have available and it has code, has the pull requests if you had any, has the commits, so here we can see the commits and we can view differences. Here we see a comparison so we can easily see the change. And then we have branches, if we had that, we have tags and we have settings inside of here. So, the next piece that we can work with, of course, also we have our commit history shown on our dashboard. Before I leave, that is the Build.
So, in Build, what the build process is typically doing, if I go to the build history, is running verification tests. And in this very simplistic example, we don't have verification tests, those could be unit tests or integration tests, but we will be talking about that in our scenarios coming up in subsequent movies. So, you can see, as I mentioned earlier, we can go to the logs, we can also look at the artifacts, and the artifacts are gonna be placed into S3. So, all of this sits on top of S3 and these are artifacts that are designed to work with these pipelines.
Then we'll go to the Deploy step, and Deploy really just sits on top of CloudFormation. So, the idea with these tools is that you will use CloudFormation templates and stacks and you'll have all of the concepts that are familiar to us in working with CloudFormation, such as stack sets and diffing the stack sets, which are called change sets. And again, the assumption here is that you're already working with CloudFormation for automation and you can just add subsequent automation by using CloudFormation templates with CodeDeploy.
And then pulling it all together, of course, its code pipeline. So, this is just another version of this and you can actually view the pipeline history here, and you can see, again, all of the executions of the pipeline. Inside of here, we do have this manual button for releasing a change and this is a graphical interface for you to work with this pipeline. If I clicked Edit, I could then go ahead and I could add a stage. And I would then enter a stage name and I'd say next verify or something here and then add an action, and the action categories are Approval and then the approval type is a Manual approval.
So, basically for this, it would be next manager approves or something like that and then you would say Manual approval and then you would send a notification to a topic. I'm not gonna do that, actually, and then other actions are Source. So, you can pull from a different source location. Build, you can select a build provider. At the time of this recording, it's Jenkins, CodeBuild, or Solano CI. Test, and here are the associated providers.
Deploy, this is integration with other Amazon services, so Elastic Container Service is the first one, CloudFormation, CodeDeploy, Elastic Beanstalk, and OpsWorks Stacks, which are used with Puppet and Chef. And Invoke invokes a Lambda. So, I'm going to cancel this stage and I'm gonna save the pipeline changes so that you can see that working with CodeStar sample templates is a quick way to familiarize yourself with the Amazon CD tools.
- Understanding high availability (HA)
- Preparing for HA
- Designing for HA
- Understanding continuous deployment (CD)
- Types of verification tests used in CD
- Server mutability and CD
- Implementing CD
- Advanced CD pipeline techniques
- CD pipeline with Step Functions