AWS DevOps Engineer Professional: AWS DevOps Engineer - Professional (DOP-C01) certification video training course by prepaway along with practice test questions and answers, study guide and exam dumps provides the ultimate training package to help you pass.

Configuration Management and Infrastructure

1. CloudFormation Overview

We are getting to the fascinating section on cloud formation, and cloud formation is one of my favourite topics in AWS. It is something I could talk about for hours and hours, but I'll try to make it short for you and for this exam. So, infrastructure as code, what is it? Well, currently, we've been doing a lot of manual work. I mean, we've been doing manual work; we've automated it a little bit with elastic beanstalk. We configured our pipelines so that we could automate our CI CD using code bills, etc., and a code pipeline. But all this manual work that we've been doing is kind of tough to reproduce, right? If we want to reproduce it in another region, here we go again.

We click, click, click everywhere. and that's a bit boring. It would be even more difficult to do it in another AWS account. Even if someone in my company went ahead and deleted everything, forcing me to recreate everything in my region, that would be a nightmare. So what we really want is code for our infrastructure. And so that's a new concept, and this is quite a new phenomenon—a new training in the IT world called infrastructure as code. And so that means that this code that we're going to write will be able to be deployed, which will in turn create, update, and delete our infrastructure. This is where cloud formation comes in. Cloud formation is going to be a declarative way of outlining your infrastructure for any kind of resource. and most of them are supported.

For example, let's take a high-level sudo confirmation template and say I want a security group and I want to get machines using this group; I want two elastic IPS for these machines; and, by the way, I want the load balancer that is connected to this machine. So we say it in a declarative way because this is what we want cloud formation to do. And then cloud formation creates all these things for us in the right order with the exact configuration that we specify. And that's quite nice. So the benefits of cloud formation, but I guess you already have a good idea of them, are that, number one, we get our infrastructure as code, so no resources will be manually created, which is excellent for control. All the code can be version controlled, for example, using Git, so we can version control our cloud formation, which is nice. And all the changes to the infrastructure will be reviewed through code review, which is also very nice.

In terms of cost, confirmation itself is free, but each stack that you create has an identifier, so you can easily track the cost of a stack and estimate the cost of your resources using the confirmation template itself. So, if you want to use cloud formation as a saving strategy in your development environment or your small interests account, You could automate the deletion of all the templates at 5:00 p.m. and then recreate them at 8:00 a.m. safely. And so, because your infrastructure is code, everything will come back up, and you will save a lot of money. Productivity will benefit from cloud formation as well. So you're able to destroy and recreate your infrastructure on the fly as many times as you want. You can automate the generation of diagrams for your templates, which is very useful if you make presentations, and it's declarative programming, so you don't have to figure out what comes before—in terms of ordering or orchestration—cloud formation tracks and it does that for you. There's a true separation of concerns as well. So you can have as many tags as you want for many apps and many layers.

And so it's quite common to have a VPC confirmation stack that creates all the networks and the subnets. There is an application stack, so for each application you'll deploy, there's going to be an application stack. So that's something we've already seen with Elastic Beanstalk. Each time we created an environment in Elastic Beanstalk, it went ahead and created cloud formation templates behind the scenes. And so the idea is that we want to reuse as much work as possible out there, so we're not going to reinvent the wheel. There are a lot of confirmation templates on the web that we can already leverage, and we can also leverage the documentation, which is huge and sometimes hard to navigate, but on the documentation you will find everything you will ever need to know. So, for confirmation, how do they work?

So, behind the scenes, we'll all upload the templates to Amazon S3, and Cloudformation will pull them from there. And so when we want to update a template, we actually can't edit a previous template, as we'll see in the next lecture anyway. But what we have to do is upload a new version of the template to AWS, and then Cloudformation will do something different and figure out what it needs to do to update from version one to version two. Stacks will be identified by a name, and the names can be very long. And if you delete a stack, every single artefact created by the cloudformation stack is also deleted. So it's really nice because you can delete all these resources that have been created with one click, and you're sure that you're not leaving anything behind.

Now to deploy cloud formation templates. There's a manual way in which we added templates into cloud formation designer and used the console to input parameters, and then there's the automated way, which is to add a template in a YAML file using a text editor, and then you use the AmazonCLI or command line interface to deploy the templates. It's the recommended way when you want to take some automation out of your flow, but you're free to choose either manual or automated; I think they're both fine. In terms of the building blocks, you're going to learn quite a lot about those in the section, but there are the template components, so we'll get the resources, and the resources are basically the AWS resources that we'll declare in the template, and that has to be a mandatory section.

OK, your confirmation template cannot work if you don't specify resources. So resources can be easy to access for machines: elastic, IP, security groups, load balancers, name it; everything you can think of really has parameters. So these are dynamic inputs that you can ask for in your templates. So users will just reference those mappings, which are static inputs for your templates, static variables, and outputs, which is basically saying, "Okay, out of our template, we can export some stuff, and other templates can reference it conditionally," which is a list of conditions.

So if statements are basically to control what gets created and metadata overall, we'll see a deep dive into all of those. So don't worry too much; you'll get to understand them in their own time. And for templates, you get helpers. And so you can use references, so you can basically link your stuff within your template, and you can use functions to transform data within your templates. So, again, a high-level overview, but I just wanted to give you this 101. Now this is an introduction to confirmation to me; it takes over 3 hours to properly learn and master cloud formation, and I do teach it somewhere else. So this section is really meant for you to get a good idea of how it works, but not drill too deep into it because it's not needed for the exam. So we'll be slightly less hands-on than in other sections, but still hands-on enough so you get a good idea of how things work. We'll learn everything.

There are numerous ways to answer exam questions, so don't be concerned. And the exam does not require you to actually write down cloud formation. It will mostly ask you about what feature you should use in cloud formation to perform XYZ. As a result, you should be fine. So the exam, though, expects you to understand how to read cloud formation, and we're going to read a lot of cloud formation in this course. So there was a short introduction to cloud formation in the next lecture. We'll go ahead with a small example to get an idea of how it actually works. So, until the next lecture.

2. CloudFormation Create Stack Hands On

So let's go through an introduction example together. And so we're going to just create a simple, easy-to-instance class, and then we're going to add an elastic IP to it. And then we're going to also add to the number of security groups.

And for now, I'm just asking you to forget about the code syntax; right now, we're just going to see how to use cloud formation and how it works. We'll look at the structure of the file later on. Now we'll see how quickly.

Cloud formation will be extremely simple to use via the console. So follow me. Okay, so we are in the AWS console, and I was just going to type "confirmation" and click on it. We are now in your zone, which we have been working on since mid-September. And as you can see, we already have two cloud formation stacks that have been created, and they basically represent Elastic Beanstalk environments. Remember when we created a web app? I had my dev environment and my production environment.

As a result, one cloud formation template is created for each. And you're actually free to just have a look at all these templates, at output resources, event templates, and all these things. As you can see, this is the code for your CloudFormation template. And I think it is madly complicated. very, very complicated. Something cool we could do, though: let's click on Prodis to view and edit the template and designer. So when you do click on this, we actually get to see, and this is quite nice, I think. Let me just resize my screen. But you get to see exactly what goes on in your CloudFormation templates. So this Elastic Beanstalk production confirmation template created all of these things, and they're all licked in some way.

So this is like level 9000 for cloud formation. You really need to be good to understand how everything was created and stuff. But it gives you an idea that, using this cloud formation designer, we can see visually how everything works. And so if we click on this load balancer, for example, we can get an idea of how it was coded, and we can choose between JSON and YAML language. So if we click on this load balancer again, we can see the block here that defines the load balancer one. Later on in this course, you'll understand exactly what this block means, but for now, it gives you a great idea of how things work, and I think it is quite nice. Okay, so this is just a little parenthesis to show you the confirmation designer.

I'll go back and leave this page. I don't want to edit anything. So this is my confirmation, and it's a little complicated. So let's just start over. I want you all to go to the US-East-North Virginia region, and the reason is because I made the templates work for there, and it will be more complicated for me to make them work for every region. So we're heading to North Virginia to get a blank canvas for cloud formation.

Unless you've been doing your tutorial in North Virginia, in which case that's just fine. What we're going to do then is create a stack. So we're going to create a stack, and we have to select a template. So we can either design a template through the cloud formation designer that we've just seen, but we won't do that, or we can just select a sample template, or we can upload a template to Amazon S3, or we can specify an Amazon S3 template URL. So, as I said, the templates go to Amazon's three.

So let's just choose to upload a template to Amazon's Story. And so the template we're going to upload is going to be this one called just EC2 YAML. So this template is the smallest we can ever have for cloud formation. It has resources, and it has an EC2 instance with three properties. And it just gives us the AMI ID, the instance type, which is T, two micro, and the availability zone, which is us. East One A. So without knowing YAML really well or confirmation really well, this is actually quite readable, and we understand what it does. This will create a simple instance for us. And here are the three configuration parameters we're going to tell the EC2 instance.

This is why I want you to do the tutorial on US East 1. It's because the availability zone for this instance is going to be us. one in the east So this looks good. Now let's go ahead and upload the template to Amazon's Three. So I select it, and I click on Next. Okay, so for the stack name, we can name it whatever we want. I'll just call it my first CloudFormation template, but you're free to give it whatever name you want. Click on "next." And now we have options.

So we can specify tags for our template, and any tags you specify will be propagated to any resource we create. So we will not specify anything we don't need to. We can attach an IAM role to Cloud Formation to do the modifications. It's optional. If we don't use it, then Cloud Formation will use the permissions defined in our account. And because we are administrators, cloud formation should be able to do everything we want.

You can define rollbacks, but they are a bit more complicated, and you have advanced features where you can notify. What happens to your CloudFormation tasks? You can stack using Amazon SNS Topic, and you can protect against termination so you can make sure no one deletes your confirmation. You can provide a timeout. So after maybe ten minutes, we don't want the stack to continue. We just want you to time out and fail. A rollback on failure is basically saying, "Do you want to go back to your previous states in case you have a failure?" Yes, if you do; no, if you don't, then that allows you to debug.

I'll simply leave it at yes. And stack policies are a bit advanced without asking about the events in the exam. So we'll just click Next, and we get the template URL, which was uploaded to Amazon S3, and we get an estimate of the cost. So if you click on this cost right here, we get to the AWS Simple Monthly Calculator, which is, in my opinion, a great tool. And so it says, "Okay, we have my instance, we have one instance, and we're going to use it 24 hours a day." It runs Linux on a two-microcomputer system. It's on demand; it's going to cost me $800.

So basically, the more confirmation stuff you put there, the more it will appear, and it can just estimate the cost for you. It's quite nice; it's just a little goodie. Now we can review the options, and they all look great. And we click on "Create." Now, when you first create your confirmation, we can see what happens. We have a stack name, and this is a stack we manually created.

We have a creative team. So this is when the stack was actually created, and we have the status. So when we are creating a cloud formation, it goes into Create in Progress. Super important. Now we have a lot of tabs down here, so let's take a look at the most important one for now, which is Events. Events are basically all the things that will happen during cloud formation. And this is an event log. So each event has a timestamp, has a status, and has a type.

So at first, we created an AWS Cloud Formation stack and initiated it. So that makes sense, because we're attempting to create a simple instance. It says I'm creating your ECTwo instance; it's in progress. And the reason we get the status is because the resource creation was initiated. So now we have to wait for the E-2 instance to be created. But if we go do a sneak peek into EC2, let's have a look into EC2 and click on instances.

Hey, we see our EC Two instance being created in the Two micro. If we do look at the tags on it, we see that there is a logical idea, a stack idea, and a slate name, all with the key of a bit of cloud formation. So this instance is the one that got created by our cloud formation templates, which is pretty cool. So you can get an idea by looking at the key in values.

Okay, we have two more events available to display. When the credit is active and completed, it says Create Complete all green. Because things worked and because all the creativity is within my template, I get this nice little Create Complete status. Now, if we look at Resources, Resources is going to be a summary of everything that was created for your confirmation template. So we have my instance, and it has a physical ID.

And so if I click here, I get teleported straight to my EC2 instance in the EC2 UI, which is quite nice, and it happens for a lot of resources as well. And we can also look at outputs. Outputs is going to be empty for now, and we'll see why when we do go over the output section. Parameters are also going to be empty, and tags are empty as well. But you get the idea that your cloud formation can have a lot of different tabs, and the most important one is the template. And so here we can review the templates of what we created. So here are our resources and the instance and the properties, etc., etc. And you could always, if you're curious and this is not your template, go into cloud formation designer and observe your templates. And what do we see here?

We see that we have one instance of two, which is very simple and very easy. So this is it. Just to get started, let me just go back and leave this. OK, so this is it. Just to get started, let me refresh the page. OK, we have our first-class formation templates. This was a little test. In the next lecture, we're going to update this template and see what happens.

3. CloudFormation Update and Delete Stack

So now we have our infrastructure as code, and we have basically coded through this template AEC-2 machine that was created with this physical idea. And so over time, we may want to update and add stuff to the EC2 instance, maybe add an IP. As a result, we might just provide a new platform from the mission template to replace this one.

So this is what we're going to do. We're going to go and update this cloud formation template. Now, as you can see, this cloudformation template is now 58 lines. So a little bit more, but if we just read through it, just as with a quick glance, we see that there is a parameter in which we'll have to specify the security group description. So let's take a look at what it does in a second. In terms of resources, we have our EC2 instance, but it has more parameters, including some security group parameters. We are creating an elastic IP.

So AC2E IP stands for ElasticIP, and we're creating two security groups. So now this is a little bit more complicated. We went from eight lines to 48 lines of infrastructure as code, but let's see how things work. We'll be able to understand this, by the way, with the next lectures. So let's go back to our stack. And if you go to action, you are able to update the stack. When you update the stack, you can do so in the designer tool or by directly uploading a template to Amazon S3. We'll just choose that one, and we're going to click on this one, EC 2 with SGIP YAML, and click on Next. And now we get to specify some details. So just like before, we have the stack name, but now it's greyed out. Indeed, we cannot change the name of an already created cloud formation template.

So we just have to keep that name. But now we get a parameter section that we did not have before, and that's because we set up a parameter right here and it is asking for our security group description. So I'll just say this is a great security group, and we'll just leave it as is. You can put whatever you want, but this is something that I, as a user, just created. Let's click on "next." We could specify some tags, permissions, rollback triggers, and so on. We will not change anything that was created before. I'll click on "next." And so now, when we get to review the details, we see that by scrolling down, we can preview your changes. So we are updating our confirmation stack, and now we have changes because we're doing an update.

And so what is going to happen? Well, we are going to have an EIP that will be added. We're also going to have some security groups right here, two of them that are going to be added, so they'll be created, and my instance, which is an easy-two instance, is going to be modified. And it turns out that there is a column called Replacement True. So "replacement true" means that the previous ECTwo instance is going to be deleted and a new one will be created. You may receive a false replacement for a variety of reasons. And so that just means that your ECTwo instance is not going to be replaced, or whatever resource type you have here. So we get an idea of all the things that need to happen. There will be an EC2 instance going away, a new one coming in, new security groups, and a new EIP.

The idea is that cloud formation is going to take care of all the complexity of doing these operations for us. The only thing we specified in this resource section was what we wanted declaratively, and cloud formation automatically figures out the changes and what needs to happen in what order. Let's go and try it out. We'll click on Update, and now we go to Update in Progress. So Update in Progress says that the stack is being updated by the user, and so now we just have to wait and see what happens. So we started an update in progress, but now we can see that there is an update in progress happening for some security groups. And now we get an update in progress in my IS-2 instance, and it says the requested update requires the creation of a new physical resource, hence creating one.

So I went ahead and created a new E2 instance. Then he created for me an elastic IP. And so if we refresh this one more time, we can see that the previous EC2 instance is now being deleted. So we delete it in progress right here. So this is the last thing that needs to happen. Remember that it was replacement true for the changes made prior to casting. And so that means that my EC2 instance gets replaced, a new one gets created, and the old one is being deleted. So let's just wait a little bit of time. So now we have the update being completed. And so the delete was completed from my EC2 instance. Let's have a look at the resources tab. And now in the resources tab, we see four things. We have an EC2 instance, but we also have an elastic IP, and we have two security groups that were created.

So this is quite great. If we go to the parameter tab, we can see that for the parameter named "security group description," we gave it a value. This is a great security group. So now let's go to the ECQ console and click on Instances. And now, yes, we see that one instance was being terminated because it was being replaced, and the other one is up and running. It looks like this EC2 instance has a public IP, which is right here. And also in terms of security groups, it has two security groups attached to it. Let's have a look at the public IP first.

So I click on Elastic IP, and yes, we can see that this IP is attached to my instance. So this is great. Now if we go to the security groups, we can see that we have two security groups that have been created, and the group name is actually prefixed by my first confirmation template, which happens to be the stack name. So, as you can see, the resources are prefixed. And if we look at the inbound rule for this one, it has the two parts we've defined. If we look at the description, the group description is "this is a great security group," and this is exactly what we just did as an input in the parameter.

So we can see that the parameter trickled down all the way to the group description. If you look at tags, we can see again that the key is basically representative confirmation and the link to the confirmation templates we have created, which is really, really nice. So we have these two security groups, and they're linked to my EC2 instance. So here we saw how to update the AWS cloud formation template, which is very, very cool. And now, lastly, say we want to get rid of all these things. So we have created an instance and two security groups, and we want to just get rid of them.

Well, instead of going to the EC to console and right clicking and doing termination and then deleting the security groups and then deleting the EIP, which would be a nightmare to do, we're going to just go into confirmation, click on action, and delete stack, which will basically delete all the stack resources. So I'll select Delete, and we'll return to the delete in progress status. So if we go there, we can see that the resources are being deleted, and on top of being deleted, they're being deleted in the right order. So we don't even have to think about what order we should delete the stuff in. Confirmation does that for us. And so we can really understand, when we had the elastic beanstalk, we had something like 16 resources and confirmation.

We had to figure out how to create them one by one in the right order. And then, if we were to delete our Elastic Beanstalk template, again with confirmation, we would figure out how to delete this naturally. So confirmation is a great helper in the AWS stack, and so we just need to wait. But now we can see that the delete was completed from my elastic IP. And so if I wait a little bit more, everything should go away, and my stack will go away as well. So that's it for the introduction to cloud formation, in which we did create, update, delete, and understand the perks of cloud formation, and also had a small sneak peek into parameters, which was great. So I hope that was helpful, and I will see you in the next lecture.

4. YAML Crash Course

So YAML is what we use all across AWS for many types, including cloud formation. And so cloud formation supports YAML and Jason's. And these are basically some scripting languages or data languages that you can use for confirmation. And to be honest, I'll be very honest with you: Jason is absolutely horrible at cloud formation. It is unreadable. It is unwritable. And YAML is great in so many ways. And this is what language will be used at the exam to show you some cloud formation templates. And this is what I've been using so far.

So let's learn a little bit about it. Even though we've been in touch with it so many times, now is the time, I think, to formalise how YAML works. And so this is a YAML file. As a result, the YAML file contains a large number of key-value pairs, also known as key-value pairs. And to me, they're very readable objects. Okay, we can just look at the left side and make sense of it. If I ask you, what's the invoice number? You don't need to be a genius to tell me that the invoice number is 34843. And so this is great. If I tell you the date, you can also tell me the dates. If I ask you, "Hey, what are the quantities of the product we've ordered?" You can look at products, and then you can look within the product. There's a list of quantities, and we have four and one.

So you get the idea, right? With YAML, we can have key-value pairs at the top level as well as nested objects. It has support for arrays. So, if we look at product, we can see that there is a minus sign here, which means array. So the product is an array of SKU, quantity, description, etc. And then we can look at, for example, building two. It contains a nested object named Given Chris Family DeMars. And then your dress also has a nested object within it, which is called line, city, post, state, and postal. Looking at the lines, we can see that there is multi-line string support. So we have a small vertical bar right here, and this is called a multi-line string.

So we can easily add multi-line strings through YAML. And we can also include comments, although they're not shown on this page. So YAML is a great way for me to read and write. Obviously, some YAML files can be quite complicated, but overall, we get the idea. Let's take a look at the simplest of the confirmations we've received. We can see this one from the YAML file. The first top-level key was resources. Then there is a second nested object within it called My Instance, which has more nested stuff within it such as type and properties. And properties were again nested as key-value pairs. If we look at the other one, we can see we have the parameters, the top level, the resource, and more nested stuff. And if you look at security groups, because there's a little minus sign right here, it's a list. So we have a list of security groups that we've defined right here, the first security group and the second security group.

So you can navigate through this and really understand that, you know, it looks like we can read this YAML template just using the small concepts we've learned from before. I encourage you to go online and learn a little bit more about YAML and even practise converting JSON documents to YAML. But overall, it is something that I think is quite easy to read. And what you really should understand is that you can nest objects by the column, the key, and the value. And using the minus sign, you get to assign a list. So that's it for gambling. I hope this makes more sense to you now, and I will see you in the next lecture.

Prepaway's AWS DevOps Engineer Professional: AWS DevOps Engineer - Professional (DOP-C01) video training course for passing certification exams is the only solution which you need.