- [Alana] We walked you
through the core components of AWS CodeDeploy in a previous video, but it's time to get a bit
deeper into one of them, the AppSpec file. It's important to have a good
understanding of this file, as CodeDeploy relies on it heavily. This AppSpec is a YAML or JSON file that contains locations for
all the installation files, scripts, and when to
initiate specific actions. This is where you get to control how your revision deployments
are actually managed, and how you determine a
deployment was successful. Let's take a look at the AppSpec file that we'll be using later in the labs. Note that this is an AppSpec file that's used for Amazon
EC2 based deployments. If you're looking for more information on serverless AppSpec files, check out the reading
following this video. All right, so this AppSpec
file is a YAML file, and it's pretty simplistic in nature. A lot of AppSpec files can
get pretty complicated, but I'll talk you through all your options and why we chose the ones we
did for this specific file. So, this file is broken
out into four sections: version, os, files, and hooks. We could additionally have another section called the permissions section, which we'll talk about a bit later. Out of all the sections, the version and the os
are the simplest parts. The version refers to the
CodeDeploy AppSpec version, and not the version of your specific
application or deployments. And currently, the only
accepted value is 0.0. The os section, as you
may have already guessed, stands for operating system, and it only accepts two possible
values, Linux or Windows. The EC2 instance you'll
be working with in the lab is a Linux box, so we chose Linux. Now, all the rest of the
sections are optional. That means the hooks, files,
and the permissions sections are not required. So let's talk about why. The files section is only necessary, if you're going to be copying
files to your instance during the deployments. It has a source and
destination subsection. The source subsection
identifies a file or directory from your revision to copy. The destination identifies
the location on this instance of where the file or
directory should be copied. So for our AppSpec file,
we want the index.html file to be copied to the var/www/html directory on our instance. The next section we are going to review is the hooks section. The hooks direct the CodeDeploy agent as to what it needs to
do and in what sequence. Some of the main hooks that
you can use are BeforeInstall, AfterInstall, ApplicationStart,
ApplicationStop, and ValidateService. Each of these is used to
run scripts that you specify when the hook is initiated. You'll notice that each of these hooks is structured the same way. You specify the location of the script, the timeout you want
to allow for it to run, and if you're running a Linux deployment, runas refers to the level at which you want to run the script. Or, in other words, the
user on your Linux instance you want to use to run
the script, such as root. Note that we're not using
every one of these hooks. In our file, we're only
using three of these hooks, BeforeInstall, ApplicationStop,
and ApplicationStart. That's because they're
the only ones necessary for this deployment, so
we've completely omitted the other options from the file. Let's talk about each of
these hooks in detail. The Before and AfterInstall
hooks are used for the script that you need to run before
the installation happens, and after the installation is complete. For example, here, we're
linking to a script that installs the dependencies needed to run our application. If I look at the script, you can see that I'm installing
an Apache web server here, which is needed for the site. Going back to the AppSpec file, the ApplicationStop and
ApplicationStart hooks are used to run any scripts needed to stop and start the application. We're using these hooks to start
and stop our Apache server. So, looking at the start_server
script in a text editor, you can see we're doing just
that, starting the server. And in this stop_server script, you can see that I'm checking to see if the Apache
web server is running, and if it is, I stop it. Now, there is another
hook that you cannot use to initiate a script,
and it's called Install. In CodeDeploy, the Install
stage is just the stage where it copies over the
files from the source to the destination on your behalf. Lastly, you can use the
ValidateService hook to run any scripts that
you will use to test and make sure that
everything has been installed and started correctly. After the hooks, that leaves
us with one last section, the permissions section. I'll go ahead and paste in a permissions section to this file, so that you can see some of the settings. The permissions section is only valid if the os setting is set to Linux. It refers to the permissions
you want to apply to the files being copied
in the file section. If you're specifying permissions, then the file section is required. I won't go through every
part of the permissions, but I do want to state that
if you use permissions, the one required part within permissions that you must include
is the object section. Object refers to the set
of system files, folders, or directories that the
specified permissions are applied to after
the file system objects are copied to the instance. There's a lot more to the AppSpec file that I can cover in this video, so make sure to check
out the notes section for more information and resources. I'll also provide examples of how you can use the permissions section for your deployments.