All right, we probably have a few things that we want to address as we dive into a CLI conversation.
First and foremost, is this even relevant in an SD-WAN world where we are doing most of our
configuration via manager? So the answer to that question is a little tricky. First of all,
we can't just say, well, we could use both because if a device is in manage mode, we can't actually
do CLI configuration. It won't allow us to commit anything. So we really do have to decide which
method we're going to use. But that said, being able to confirm configurations are correct at the
CLI is a wonderful thing. Having a graphical user interface to confirm things, it's gotten better
over the years. But just because I click a button and say apply, is it really working? Did it really
push that? So me being able to perform or at least read configuration is very important from a
validation perspective. Furthermore, we might have some sites that we don't want to be part of our
managed environment. And so maybe those sites, those edges are going to be configured via CLI.
Maybe we have some traditional Cisco engineers who just want to be able to log in and do things via
CLI. And so that would be a situation where we might have to do that. But it does beg the question
a little bit of how much longer are we going to really be doing CLI configs when SD-WAN
Manager is really where we're going to be doing things. I will say this, it is very much in the
scope of the exam and therefore it's very much in scope of this course. And so we're definitely going
to be covering it and I would definitely recommend paying attention and getting comfortable with CLI
configurations simply because Cisco does expect us to know it if we're going to be certified in it.
So the other question we have to ask is where are we doing our configurations?
Because I've got the controller pulled up here, but we also have our edges in our lab environment.
And so are we performing configurations for policies on the controller or on the edges?
Well, the answer is it depends. Although the deeper answer is it's mostly on the controller.
What we mean by that is if we have a centralized policy, it goes on the controller
because that's the device that's pushing the policy out or enforcing it via OMP,
those kinds of things. If we have a localized policy, it's going to go on the edge. The biggest
example of that is going to be our ACLs, our access control lists, are going to go on the
edge directly. But most everything else is going to go on to the controller. So pay attention to
that. The other thing, as I've already said, is if we do a config T here and maybe I just do some
kind of configuration where I try to go into policy mode and I go into lists and I create a
site list maybe called site 11, something like that, site ID 11. And then after all that,
I say commit. Well, oops. Well, let's go ahead and exit out of this first. So there is something to
commit. There's nothing to commit because I already have a site list called site 11. All right.
Well, that demonstration went a little awry. If I make a site list called something new,
sites new, and I add a site ID of 12, let's say in there. And now I try to commit there.
That is the error I was trying to get. It's not going to allow us to do any kind of committing
because it's in managed mode. So again, we have to ask the question as we're doing this lab
or this skill, which is basically one giant lab, how are we going to do our configuration?
Well, one of two things. First of all, we could go to our SD-WAN manager and pull the controller
out of managed mode. Depending on how disruptive we want to be to our lab environment, maybe that's
not the best idea. And so the good news is, as you noticed, it allowed me to perform that whole
configuration. It just didn't allow me to do a commit. And so what we can do is just practice
our configuration without actually committing. So that's what we're going to do. That's what
I'm going to do in my lab environment because I don't want to pull it out of managed mode.
And so all the demonstrations we're going to do are going to be just doing the configuration
without actually committing. The downside is that we can't actually validate that everything worked,
but we can also validate a little bit because the CLI syntax will still be recognized if it's
wrong for any reason. If I hit the wrong sequence of commands, then it's going to bark at me.
In your lab environment, if you're comfortable with doing that and pulling it out of managed
mode, then go ahead and then you can commit. But the only difference between our demonstrations
and our lab tasks and actually pulling the trigger on the commit would just be
typing in that commit keyword there as we just demonstrated. So that is a little bit of a
just a starter conversation around the concept of CLI, how much it matters. It does definitely
matter. This should be our conclusion. And so let's go ahead now and dive into CLI configuration
and see how we can configure all of the policy things that we've been doing,
but this time via the CLI rather than the GUI.