Hello and welcome to this Pluralsight presentation.
My name is Andrew Mallet, and I'm here as your instructor, helping guide you
through every step of this module, where we take a look at implementing
configuration management and IaC, or Infrastructure as Code. As we go through
the module, we'll be taking a look at understanding a little bit more about
IaC, or Infrastructure as Code, which as we said then is the acronym IaC.
We'll be taking a look at different file formats that
are used to define our configuration.
These include things like JSON, YAML, but also can include Ruby
files such as our Vagrant file or Puppet manifests.
Our main utilities that we use that implement Infrastructure as Code will be
the products that we're concentrating on in this course,
believe it or not, the Ansible, Salt, Puppet,
Terraform, Vagrant, and so forth.
We'll be taking a look at provisioning. Whilst we can provision our
operating system, part of our structure is going to make sure that we
reliably deliver the operating system and all of the services and
configuration that are needed for our applications.
And we'll take a look, even in this section,
how we can start provisioning to make sure that we've got everything
that we need for a simple example of a web server.
We'll be taking a look at CI/CD, so our Continuous Integration and Continuous
Deployment, and people wiil also put in then Continuous Development as part of
that, just to show that it's a cycle where we're continually looking at
working with our code and integrating it into production being then our
deployment. As we continue through,
we'll be looking at Infrastructure as Code, and I say we need to
understand what we mean by that terminology.
This is the process of provisioning our systems using instead of a
manual process, by using code. Now the advantage of this is that we have
configuration files that define our desired state, and we use these
configuration files both to document our systems, so we know what's
installed and how it's configured, but also it becomes our dynamic
provisioner. We deploy the configuration file, the configuration file
reliably gives us our operating system and all of the services that we
require.
The rock star of this whole thing is the CI/CD process,
a term that is often banded around, but this is really our method where we're
frequently delivering our applications due to our customers,
our end users, using some form of automation.
We'll have different stages in our app development, but we're then
able to continually keep pushing out code updates to our end users,
and this becomes what we mean then by our CI, Continuous Integration
and Continuous Deployment.
Often, we have a department called DevOps that are working with it, which is
then developers and operations working together. The file formats that we're
going to then come across, depending on the different configuration
management system we're using, will use different configuration formats to
store the desired state. When we look at using things like Salt and Ansible,
we'll be taking a look at YAML. When we look at the back end of many of
these systems,
often JSON is being used. Whereas if we look at things like Vagrant,
Puppet, and Chef, they concentrate on a Ruby file format.
The tools that we use will be then things like Ansible, Chef,
Vagrant, and Puppet, as well as Terraform, and it's these that we look
at throughout our course. In this module, we'll further introduce
Vagrant to you. When we take a look at our Vagrant file, the first thing
I'm going to do is make sure that this file can be understood correctly
by our syntax highlighting.
So I'm going to go through into my .vimrc file and I configure the
option set modeline. I can create then a directory structure for me
to have a new Vagrant file, I move into the Apache directory, and I
create a new Vagrant file. Minimal will give me just a few basic
lines that I need,
but I'm going to insert, as line one, so long as it's near the top of the file,
a little bit of information that modeline is going to read. We're going to
specify that we should see syntax highlighting as part of filetype=ruby. I
want to set my tab stop to be 2 to auto indent and shift with, which is
used by auto indent, also to be 2 spaces. And I'm inserting this as the
first line to my Vagrant file.
Now, whilst these slides are totally awesome,
they're not quite as awesome as you learning this for yourself. Let's join the command‑line demonstration to see how this really works.