‫Okay, so now let's have a look
‫at the CodeStar service.
‫So we are getting into the CodeStar
‫and we'll create a project.
‫And in this project,
‫we have to first choose a project template,
‫but before we do so,
‫as you can see there's a warning sign saying that,
‫CodeStar is using an IAM service role
‫that we have to create first.
‫So let's go ahead and create this service role,
‫and this is done behind the scenes,
‫just to allow a few moments for the changes to take effects.
‫Okay, so next we can use a project template
‫and as you can see,
‫it's filtered by type of services
‫the project is running from,
‫so maybe Lambda, maybe running on EC2 instances,
‫as we can see if you go to the next page,
‫there's also Beanstalk and so on.
‫So you have choose your platform,
‫but also to use your programming language that you want
‫so maybe you're using Python,
‫maybe using Express.js, Java Spring and so on.
‫For the purpose of this demo, really it doesn't matter.
‫What we do, we'll just use, for example,
‫a Python application running on Beanstalk,
‫but we can choose whatever we want.
‫It's actually quite interesting to see what CodeStar does
‫based on what AWS service you're using in the backend.
‫So let's Click on next.
‫Next we need to choose the project details.
‫So I'll just call it Democodestar
‫(keyboard typing)
‫The project repository
‫so your code is going to be stored somewhere
‫and remember CodeStar is a service
‫that orchestrates everything pretty much.
‫So where do you want to store your code?
‫Is it in CodeCommit or is it in GitHub?
‫But we'll use CodeCommit
‫and we'll use whatever repository name we want.
‫Then because we are using Elastic Beanstalk
‫as a platform to deploy our CodeStar projects.
‫We need to configure the EC2 instances.
‫So we use t2.micro to remain within the (indistinct) here,
‫a VPC and a Subnet, as well as a Key pair
‫so this is a new account.
‫So I'm just going to create a Key pair very quickly.
‫So for this, I'm going to go into the EC2 console
‫and I'm going to create a dummy Key pair
‫just to get started.
‫So create a Key pair.
‫And I'll call it test, and create Key pair.
‫That will be it.
‫That'll be enough for this purpose.
‫So I should refresh this and the test Key pair is selected.
‫Next I'm going to redo everything.
‫So everything looks good and I will create my project.
‫Now, as you can see,
‫CodeStar will be setting up your project resources
‫and that will take a while.
‫And so there's a lot of tabs that just appear.
‫So let's just wait a minute or two to see
‫what happens in the background.
‫So the project has been provisioned
‫and it is backed by CloudFormation stack.
‫Now CloudFormation, we'll see it very, very soon,
‫but it is a way for you to set up infrastructure as code
‫and so, through CloudFormation stacks
‫we're not using directly right now.
‫Resources are going to be set up by different services.
‫So just to quickly show you,
‫but we'll do a deep dive on this very soon.
‫Okay. So now for the CodeStar project, if I scroll down,
‫we can see that the Project resources has been created.
‫So a lot of IAM policies and roles.
‫A CodePipeline has been created.
‫A CodeCommit repository has been created.
‫CodeBuild, CloudFormation, and Amazon S3.
‫So a lot of things have been provisioned already by CodeStar
‫things that we would have to provision ourselves
‫if we wanted to link all these things together.
‫So if we go for example, to the CodeBuild projects,
‫we get directly into the CodeBuild interface,
‫and we can go into the Build's projects, the Build history
‫and we can see here that a Build has been run
‫and that it was successful.
‫If we go into CodeCommit,
‫we can find the code of our application,
‫that is going to be in this repository.
‫And if wanted to modify it,
‫this would be the place to do so.
‫But also if you scroll down,
‫you can see that clear that you could see the ReadMe
‫directly from the CodeStar project,
‫which corresponds to the ReadMe file in here
‫in your CodeStar, the CodeCommit repository.
‫And finally, a CodePipeline has been created for us.
‫So if we go to CodePipeline,
‫we can see the actual Build Pipeline
‫so it goes from the source from CodeCommit.
‫Then it goes into CodeBuild to build the code.
‫And finally it goes into deploy stage to deploy
‫the BuildCode into Beanstalk,
‫which is backed by CloudFormation.
‫So we have to wait for this to finish for it to go,
‫but let's have a look at what we can do with CodeStar.
‫So if we wanted to modify the code,
‫we could either use something called AWS Cloud9,
‫which is a cloud-based IDE.
‫So you can modify your code in the cloud directly,
‫and it's ready to use in seconds,
‫or if you have your own IDE.
‫And so some very popular ones are Visual Studio,
‫Eclipse, the CLI, or IntelliJ.
‫Then you can set up your CodeStar project
‫with these other IDEs.
‫So this is a way for you to do so.
‫You can set up Issue tracking,
‫So for doing so right now,
‫the only option is JIRA with Atlassian,
‫but it's possible that one day there will be more.
‫And then you can also add team members.
‫So this is a project
‫and you may want to have other team members in it.
‫So if you click on the team members,
‫you go to the left hand side
‫and Click on add team member.
‫Then you can select a user or create a new IAM user,
‫display name, email address,
‫and the role for the project owner or contributor or viewer,
‫and to allow whether or not they can get
‫SSH access to the project instances
‫behind the Beanstalk platform, for example.
‫So that's it. Now let's have a look at the IDE tab.
‫So the IDE tab is to get you access your code.
‫So again, Cloud9, CodeCommit
‫or setting up one of these tools, for example, locally.
‫The repo is yet to know the time
‫showing you what is in CodeCommit.
‫The Pipeline is a quick way to get
‫to the CodePipeline interface
‫without leaving the CodeStar console.
‫So we can see that
‫we're still in the deploy phase right now.
‫Monitoring gives us all the metrics
‫once a development has happened.
‫And so, because the deployment has not happened yet,
‫we cannot Click on the new application.
‫So again, I'm going to pause the video
‫and wait a little bit.
‫And so now if you go to Pipeline,
‫we can see that the status has succeeded.
‫So everything was deployed into Beanstalks.
‫So, if I Click on view application,
‫I can view my implication,
‫which is extremely basic, I have to say.
‫But the important thing is that if I go now, for example,
‫to Elastic Beanstalk,
‫I should be able to find my stack right away.
‫So let's go into Beanstalk
‫and we can see that there is the application here,
‫and I don't know why it's degraded.
‫It's been deployed (indistinct) to make sure it works.
‫But as you can see,
‫it has created this Beanstalk environment
‫from which we get the CodePipeline deployed into.
‫And there's an HTP server
‫that responds to some requests right now.
‫And then we can also get access to monitoring now
‫that the EC2 instances are up and running.
‫So that could be quite helpful.
‫So, that's it for the overview of CodeStar,
‫just to get an idea of it,
‫but you don't need to have deep knowledge about it
‫because this is just a service
‫that allows you to combine all the other code services
‫and developer services
‫that you get to unified view for you and your team.
‫So when you're done (indistinct) for this,
‫you can just delete the projects.
‫And for these, you just add delete
‫and it will delete also the resources.
‫If you tick the box
‫and make sure that you start with a clean States,
‫if you try to create another CodeStar projects, that's it.
‫I hope you liked this.
‫And it will see you in the next lecture.