Now friends, everyone agrees that NetSpark Automation is absolutely awesome.
Who could disagree after all?
But the reality is there is more than one way to implement NetSpark Automation.
So what I want to do in this particular video is to talk to you about the
concept of agent
based automation as well as what is known as agent less automation.
And what we'll also do is mention some very common utilities that are used with
this particular
architecture.
So let's talk about it.
So the way I like to describe this is if you look at this little topology right WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
So the way I like to describe this is if you look at this little topology right
here,
what I actually have are four Cisco switches.
And over here, this is actually just my little Linux server.
Basically this device here, this Linux machine can talk to all the devices in
my topology.
Now right now, I just said that these four devices were all Cisco based.
Now what I would like you to do is to close your eyes, use your imagination.
So let's just say that for the moment, they were all Linux servers.
Okay, so this is Linux. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
Okay, so this is Linux.
This is Linux.
As is this, as is this.
And this one over here too.
Okay.
So a Linux environment is what we've got.
So right now we're more doing automation for a system of administration as
opposed to
networking.
Now here's the cool thing.
This is the advantage of doing automation in the Linux world.
Is it because they're just regular servers?
What you can essentially do is install new software onto them.
So this is something that you can't actually do on old legacy Cisco iOS devices
.
Let me show you what I mean. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
Let me show you what I mean.
If I go to this device here, as it is, open up a terminal window, what I can't
say is
you know, install the Python programming language.
This is going to give me an error.
Even if I type the actual correct syntax that I would use on a Linux machine,
so the
we have to install Python three, for example, or whatever it may be, still
going to get
an error.
Because this particular operating system is really locked down.
It's only going to accept Cisco specific syntax.
So straight away, because we can actually install anything on this particular WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
So straight away, because we can actually install anything on this particular
device, we
actually have a little bit of a hurdle when it comes to our automation tools.
Because here is our first architecture, the agent based architecture.
Now again, let's imagine that these are all Linux machines and I can install
new software
on them.
Then what I can actually do is I can install a little agent on each of these
machines.
And this is just like on your phone if you download a new application, okay, it
's a very
particular piece of software that does a very particular thing.
So I find all this agent, this piece of software on all the devices that I want
to manage, WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
to manage,
as well as over here, I install whatever software I need.
Then what it does is that it gives my management station over here a way to
communicate with
the devices under my control.
So we can have this nice detail conversation between each other.
Let me just first begin by talking about a particular configuration management
tool known as puppets,
okay.
Now puppets happens to be very well known in the world of automation and system
administration
i.e. managing servers with automation.
And this is precisely what is going to happen. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
And this is precisely what is going to happen.
You happen to have, like say, for example, your Linux machine over here, you
install the
puppet software on it.
And then all the devices that you're managing, you also install this little
puppet agent,
okay, every device gets the puppet agent.
And the management point gets the full puppet software.
And what this one is referred to is the puppet master.
And this is where we decide what should actually happen within the network.
Quite simply, what we do is we configure particular files on this device.
And these are known as manifest files. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
And these are known as manifest files.
And this is used to describe what the configurations of all these devices here
should actually be.
Now here's what's going to happen because this device here actually has an
agent installed.
What it's going to do is going to continually talk back to the puppet master.
And it's going to ask the question, is my configuration correct?
Now at this point here, the puppet master is going to compare what is actually
being sent
from the agent right here and compare it against what it has in the manifest
file i.e.
what should the configuration actually be? WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
what should the configuration actually be?
Now let's imagine for whatever reason that happens to be some type of discrepan
cy, maybe
someone's logged into this machine remotely and made a configuration change.
So if there is an error, then the puppet master is going to pretty much inform
and say,
hey, no, your configuration is wrong.
You should have x, y, and z.
Now at this stage here, having now been informed of this, the actual node is
going to reach out
to the actual puppet master and say, hey, send me the configurations that it
should have.
And what is going to happen is the puppet agent will then apply these configs WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
And what is going to happen is the puppet agent will then apply these configs
to the machine.
And ultimately, any problems are going to be resolved.
Now what we just talked about here was agent-based automation.
Now the utility that I happen to specify was something known as puppets.
And this is just one of the options that utilizes this particular architecture.
Now just some things to note about puppet, it's written in the Ruby programming
language.
But the good news is that you do not have to know how to write Ruby code in
order to use
puppets.
Instead of writing Ruby code, you just write these what are called manifest WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
Instead of writing Ruby code, you just write these what are called manifest
files that
basically describe the state of your network.
And ultimately, under the hood, puppet acts as a type of translation layer.
So that was an example of an agent-based solution.
Another one would be a tool called chef.
Once again, very, very popular in the world of server administration for
similar reasons.
Because once again, chef involves that you actually install some type of
software on the devices
that you're going to be managing.
In this case here, it is the chef client.
So the chef client gets installed on all of the target devices to be managed.
And on your management node, you just install the regular chef software. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
And on your management node, you just install the regular chef software.
Now in Shefflingo, as opposed to be known as a puppet master, this is just
simply known
as the chef server.
So basically we've got the chef server as well as our chef clients.
And in a similar way, because we have this ability to have this two-way
conversation, the
devices being managed can reach out to the actual server in check that the
configurations
are indeed correct.
And if there are any problems, then once again, those configurations can be
pulled in by
the client and repaired.
Now, one thing to note about chef, and this is not a small problem, is that it WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
Now, one thing to note about chef, and this is not a small problem, is that it
's
kind of complex to use.
This too is also written in the Ruby programming language.
And in order to use chef effectively, you kind of really have to understand a
little bit
of Ruby programming.
This is obviously a barrier of entry.
And it's one of the reasons why chef did not take off in the world of network
automation
the way it did in the world of server administration automation.
Okay, now here is the part where I abandoned all pretends entirely. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
Okay, now here is the part where I abandoned all pretends entirely.
The only reason I am talking to you about them is because they are listed on
the exam objectives.
Pretty much nobody uses chef or puppet to automate networks.
It just simply is not a thing.
Now don't think that this is a good reason just to skip over what we've talked
about.
The reality is you still might get a question on these particular technologies.
So understanding that they can utilize agents and understanding the general
workflow of
these type of solutions is important to understand. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
these type of solutions is important to understand.
However, these tools do have some traction in the world of server admin.
So what's the big difference?
What is the problem?
Let me tell you it again relates to this idea of an agent on these old dusty
Cisco devices.
We do not have the ability to install an agent.
So would we do them?
Do we just not automate?
Well, that isn't a very good solution.
Obviously, instead, what if we could have an agent less solution?
Now this here, this would actually be very, very useful for us as network
engineers. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
engineers.
And drumroll please, you'll be happy to hear that we actually do have such a
solution.
Now the way an agent less solution happens to operate is quite simply the
devices that
we're actually managing.
We don't have to worry about them.
Well, we do have to worry about them.
We are managing them.
But what I mean is we don't have to worry about installing any type of software
on them,
some specific agent in order to be able to automate the devices.
In the case here, if these devices are simply capable of, say, for example,
talking over SSH, WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
talking over SSH,
we can use, say, for example, a Linux server over here, install some type of
software on
it, some type of agent less software.
And all we'll do is utilize our SSH channel or maybe our HTTP channel.
However it is, you can talk to these devices.
And quite simply, you can just render all the automated configurations on the
device itself
and then just send those configs directly down an SSH channel.
So these devices here could be made in the 1990s.
So long as they're capable of SSH, then they can be automated in this agentless WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
So long as they're capable of SSH, then they can be automated in this agentless
manner.
Now unlike Chef and unlike puppet, there is one mega monster in the world of
network
automation.
Perhaps you have heard about it.
This is the utility known as Ansible.
So let's dive in and talk about the details.