Courseiva
JNCIA-JUNOSChapter 1 of 15Objective 1.1

Juniper Networks and Junos OS Overview

Juniper Networks and the Junos OS are the foundation of modern high-performance networking. They exist to solve the problem of managing thousands of devices with a single, consistent operating system, rather than treating each device as a unique puzzle. For your JNCIA-JUNOS exam, understanding the separation between the physical hardware and the software that controls it is the single most important idea you will learn.

12 min read
Beginner
Updated Jul 23, 2026
Editorial oversight: Johnson Ajibi· Security Systems Architect · MSc IT Security · IEEE Senior Member

A simple way to picture Juniper Networks and Junos OS Overview

The Large Office Building Analogy

The large office building stands at the corner of two busy city streets. Its function is to provide a stable, secure, and organised workspace for hundreds of employees from many different companies. The building's architecture separates the physical structure (the concrete, steel, and glass) from the management systems (the building's rules, security passes, and maintenance schedules). This separation is key: you can renovate a single floor without demolishing the entire building.

In this analogy, the Juniper Networks device (the physical router or switch) is the office building itself. The Junos OS (operating system) is the building's management team and its rulebook. The building's management handles everything from granting access passes (security policies) to scheduling meeting rooms (traffic prioritisation) and ensuring the lifts work reliably (network stability). Crucially, the management team runs a single, unified set of rules for the entire building. If a new company moves in on the fifth floor, the management team updates its records in one place, not on fifty separate clipboards. This mirrors Junos's single software image that runs identically on every device, from a small desktop switch to a massive core router. The building's tenants (data packets) move between floors via the elevators and corridors (the device's forwarding plane), while the management team stays in the back office (the control plane), updating maps and handling guest registrations without ever slowing down the tenants.

How It Actually Works

Juniper Networks builds networking devices — routers, switches, and firewalls — that move data across the internet and inside large companies. But what makes Juniper special is not just the hardware; it is the operating system that runs on all of those devices: the Junos OS (Junos Operating System). Before we dive into the details, let's define a few core terms you will see repeatedly.

A router is a device that forwards data packets between different computer networks. Think of it as a postal sorting office: it looks at the destination address of each parcel (data packet) and decides the best next stop on the journey. A switch is similar, but it works inside a single network (like an office LAN) to connect devices directly to each other. A firewall inspects traffic and decides whether to allow or block it based on security rules. The operating system is the software that manages the hardware's resources and provides the interface for you to configure and control the device.

Now, the key architectural insight. Junos OS is built with a modular, layered design that separates two major functions:

The control plane is the brain of the device. It runs all the protocols that figure out the best paths for traffic (routing protocols like OSPF and BGP), handles user logins, and manages configuration changes. It uses its own dedicated CPU and memory, separate from the data traffic.

The forwarding plane is the muscle. It is a specialised hardware component (often custom ASICs — Application-Specific Integrated Circuits) that actually moves data packets at incredible speeds. It does not think about routes; it just follows a precomputed forwarding table provided by the control plane.

This separation brings a huge advantage: the control plane can take time to compute the best path or apply a new configuration rule without ever slowing down the forwarding of live traffic. In older routers (and many cheaper ones today), a single CPU does both jobs, so every configuration change or route calculation can cause delays or dropped packets.

Another critical idea is the single software image. Unlike many other vendors who have different operating systems for different device models, Junos OS is a single code base. A router used in a small branch office and a core router in a major internet exchange point run the same Junos OS. This means you learn one set of commands, one syntax, one way of configuring devices, and it works everywhere Juniper sells. This dramatically reduces training costs and operational complexity.

Finally, Junos OS uses a coherent configuration model. You do not enter a series of commands that take effect immediately and are hard to reverse. Instead, you build a candidate configuration, review it, and then commit it (make it active). If the commit causes a problem, you can roll back to a previous configuration instantly. This commit-and-rollback model is a lifesaver in production networks, where one typo can knock thousands of users offline.

In summary, Juniper devices consist of a physical chassis (the metal box, line cards that hold ports, and power supplies) running Junos OS, which separates control (brains) from forwarding (muscle), provides a single consistent interface across all models, and gives you a safe way to change configurations without fear.

This flowchart shows the separation of control and forwarding planes in a Juniper device, and the commit/rollback configuration lifecycle.

Walk-Through

1

Power On and Boot

When you power on a Juniper device, the Junos OS kernel loads from flash storage. The system performs hardware self-tests and initialises the control plane (Routing Engine) and forwarding plane (Packet Forwarding Engine). This boot process is similar to starting a computer, but specialised for networking.

2

Login and Access the CLI

After boot, you connect via the console port or SSH and log in with a username and password. You enter the operational mode, where you can check device status, view logs, and monitor performance. This is the 'read-only' view of the device.

3

Enter Configuration Mode

To make changes, you type `configure`. This enters a separate configuration mode where you build a candidate configuration. At this point, nothing you type affects the running device. This separation prevents accidental outages during configuration.

4

Build and Verify the Candidate Configuration

You add statements like setting an IP address on an interface, enabling a routing protocol, or defining security policies. You can verify your changes with `show | compare` to see a diff of what will change. This allows you to catch errors before they go live.

5

Commit the Configuration

When you are satisfied, you type `commit`. Junos OS validates the candidate configuration for syntax errors. If valid, it activates the new configuration and saves it as the current active configuration. If you mistype something invalid, Junos rejects the commit and gives an error message, preventing a bad configuration from taking effect.

6

Rollback if Necessary

After a commit, if you discover a problem, you can type `rollback 1` to revert to the immediately previous configuration, then commit again. Junos stores up to 50 previous configurations, giving you plenty of fallback options. This is a hallmark of Juniper's safe configuration model.

What This Looks Like on the Job

Imagine you work as a junior network administrator for a medium-sized company called 'QuickShip Logistics'. The company has three offices: headquarters in London with 500 employees, a warehouse in Manchester with 50 employees, and a small sales office in Edinburgh with 10 employees. You have been tasked with replacing the aging network equipment. Your manager tells you to buy Juniper switches and routers because the company is expanding and needs reliable, centralised management.

Here is what you actually do. First, you unbox the Juniper switch for the Edinburgh office. It is a small desktop device called an EX2300. You power it on, connect a laptop to its console port using a special serial cable, and open a terminal program (like PuTTY). The switch boots Junos OS automatically. You log in with the default credentials (which you immediately change for security reasons).

Your first real task: configure the switch to connect to the Manchester router over a VPN (Virtual Private Network) to securely share inventory data. In Junos OS, this means entering configuration mode by typing configure. Now you are editing the candidate configuration. You add an IP address to the switch's management interface, set up a default route to the Manchester router, and enable the OSPF routing protocol so the device automatically learns which networks are reachable. Notice: none of these changes are active yet; you are simply building a plan.

You check your configuration with show | compare to see what has changed. Then you type commit. The configuration is applied, and the device immediately starts talking to Manchester. Two hours later, you realise you made a mistake: you set the wrong subnet mask. Because you used the commit model, you can type rollback 1 to revert to the previous configuration, then commit again to make the fix live. Your manager sees zero downtime.

Later, the company grows and you need to add a second switch in London. You buy an EX3400, which runs the exact same Junos OS. You do not need to learn a new command set. You copy the configuration from the first London switch, change the IP address, and commit. The entire process takes ten minutes.

Finally, you use Junos Space (a centralised management tool) to push a security policy to all switches at once, blocking a newly discovered malware domain. Because every device runs the same OS, the policy works identically on every device. Without this consistency, you would have to log into each switch separately and issue different commands for different models — a nightmare for a small team.

Key actions in this scenario include:

Logging into the console port for initial setup.

Using the configure command to enter a safe editing mode.

Reviewing changes with show | compare before making them live.

Using commit to apply changes and rollback to undo mistakes.

Leveraging a single OS across different hardware models to simplify management.

How JNCIA-JUNOS Actually Tests This

The JNCIA-JUNOS exam (exam code JN0-104) tests objective 1.1 — 'Describe the function and architecture of Juniper Networks devices and the Junos OS' — with a heavy focus on the core architectural separation and the configuration model. You can expect at least 4-6 questions on this specific topic out of the 65 exam questions. The exam loves to test these exact concepts:

The control plane versus forwarding plane separation: You will be asked which component handles routing protocols (answer: control plane) and which handles packet forwarding (answer: forwarding plane). A common trap is offering 'Routing Engine' as the answer for packet forwarding — remember, the Routing Engine is the control plane. The correct answer for forwarding is the Packet Forwarding Engine (PFE) or 'forwarding plane'.

The single software image: Expect a question like 'Which statement is true about Junos OS?' with a distractor saying 'Different models run different operating systems'. The correct answer is always 'Junos OS runs a single code base across all supported platforms.'

The commit model: They will test that configuration changes are not active until you issue the commit command. A common trap is a question asking 'What happens immediately after entering configuration mode?' The answer is 'The candidate configuration is created; no changes are applied to the active configuration.' Never choose 'Changes take effect immediately' — that is the trap for beginners who think like Windows users.

The definition of a router, switch, and firewall: The exam expects you to know the basic function of each. A trap question might describe a switch doing routing (wrong — routing is for routers) or a firewall doing switching (wrong).

The concept of modularity: They might ask 'What is a key benefit of separating control and forwarding planes?' The correct answer is 'The control plane can process routing updates without affecting packet forwarding performance.'

Key terms to memorise for this section:

Control Plane: The brain — runs routing protocols, handles management.

Forwarding Plane (or Data Plane): The muscle — forwards packets based on a forwarding table.

Routing Engine: The physical hardware component that runs the control plane software.

Packet Forwarding Engine (PFE): The hardware component that runs the forwarding plane.

Commit: The command that activates a candidate configuration.

Rollback: The command that reverts to a previously committed configuration.

Single Software Image: Junos OS is a single code base for all devices.

Candidate Configuration: The set of changes you have made but not yet activated.

Exam traps to watch for:

Mixing up control plane and forwarding plane responsibilities.

Believing that changes made in configuration mode take effect immediately.

Thinking that different Juniper device models require different operating systems.

Confusing the term 'Junos OS' with a specific hardware model (e.g., thinking 'Junos' is a router model).

Key Takeaways

Junos OS is a single, unified operating system that runs identically across all Juniper router, switch, and firewall models.

The control plane (Routing Engine) handles routing protocols and management, while the forwarding plane (Packet Forwarding Engine) handles high-speed data packet forwarding.

Configuration changes in Junos OS are made to a candidate configuration and only become active after the `commit` command is issued.

The `rollback` command allows you to revert to a previously committed configuration, providing a safety net against configuration errors.

Juniper's architecture prevents control plane processing from affecting forwarding performance, ensuring stable packet delivery even during routing updates.

A router connects different networks, a switch connects devices within the same network, and a firewall filters traffic based on security rules.

Easy to Mix Up

These come up on the exam all the time. Here's how to tell them apart.

Control Plane (Routing Engine)

Handles routing protocols like OSPF and BGP

Uses its own dedicated CPU and memory

Does not forward user data traffic

Forwarding Plane (Packet Forwarding Engine)

Forwards individual data packets using hardware ASICs

Operates at wire speed without processing routing logic

Relies on a forwarding table built by the control plane

Commit Model (Junos OS)

Changes made to a candidate configuration first

Requires explicit 'commit' command to activate changes

Supports 'rollback' to revert to previous configuration

Immediate-Apply Model (Typical home router)

Every change applies instantly when you click 'save'

No separation between editing and active config

Usually no built-in rollback mechanism

Juniper Router (e.g., MX Series)

Designed to connect different networks (WAN)

Supports many routing protocols for path selection

Often has modular line cards and high-speed interfaces

Juniper Switch (e.g., EX Series)

Designed to connect devices within one network (LAN)

Primarily forwards based on MAC addresses (switching)

Often has fixed ports for desktop connectivity

Juniper Firewall (SRX Series)

Focuses on security: stateful inspection, VPN, intrusion prevention

Uses security policies to allow or deny traffic

Includes routing features but security is primary role

Juniper Router (MX Series)

Focuses on routing: forwarding packets between networks

Uses routing tables and protocols to determine best paths

May include basic firewall features, but routing is primary role

Watch Out for These

Mistake

The Junos OS is just the name for the software running on Juniper routers, and it is similar to Windows or macOS.

Correct

Junos OS is a specialised network operating system derived from the FreeBSD UNIX kernel. It is not a general-purpose OS like Windows; it is purpose-built for high-speed packet forwarding and network management.

Beginners come from a PC background and assume all operating systems are interchangeable. They do not realise that Junos OS is built on UNIX and that its command-line interface (CLI) resembles UNIX shell commands, not a graphical desktop.

Mistake

All network device manufacturers use the same separation of control and forwarding planes as Juniper.

Correct

Many vendors, especially in lower-end devices, use a single CPU to handle both control and forwarding. Juniper's architecture is not universal; it is a design choice that prioritises stability and performance.

This misconception arises because beginners often learn from one vendor's study materials first. They assume every router works the same way. The exam specifically tests that this separation is a defining feature of Juniper's architecture.

Mistake

If you make a configuration change on a Juniper device, it takes effect immediately, just like changing settings on a home router.

Correct

Configuration changes on Junos OS are made to a candidate configuration and only become active after you issue the `commit` command. This is fundamentally different from consumer routers where every click immediately applies the setting.

Home networking gear (like a TP-Link or Netgear router) applies changes instantly. Beginners assume enterprise gear works the same way. The exam exploits this assumption by offering 'immediate effect' as a distractor answer.

Mistake

Juniper Networks only makes routers — switches and firewalls are made by other companies.

Correct

Juniper makes a wide range of networking hardware, including EX series switches (for enterprise LANs), SRX series firewalls (for security), and QFX series switches (for data centres), all running Junos OS.

The company name 'Juniper Networks' sounds router-focused, and beginners often see only routers mentioned in passing. The exam tests your knowledge of the full product portfolio, even though the chapter focuses on architecture.

Do You Actually Know This?

Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.

Frequently Asked Questions

What is the difference between a router and a switch in Juniper's product line?

A router connects different networks (e.g., your office to the internet) and uses routing protocols to decide paths. A switch connects devices within the same network (e.g., all the computers on your office floor) and uses MAC addresses to forward frames. Juniper makes both, running Junos OS.

Do I need to learn different commands for Juniper routers versus Juniper switches?

No. Because all Juniper devices run Junos OS, the commands are identical across routers (MX series), switches (EX series), and firewalls (SRX series). This single OS is one of the biggest selling points of Juniper networks.

What does 'commit and rollback' mean in the context of Junos OS?

A 'commit' makes your candidate configuration active. If that configuration causes problems, you use 'rollback' to revert to a previous working configuration. This prevents downtime from configuration errors.

What happens if I type a command in Junos OS configuration mode and then immediately disconnect the power?

The configuration change is lost because it was only in the candidate configuration and was never committed. The device will boot with the last committed configuration. This is intentional — it protects against incomplete or erroneous changes.

Is Junos OS based on Linux or Windows?

Junos OS is based on the FreeBSD UNIX kernel. It is not related to Windows. Understanding this is important because the CLI uses UNIX-style commands (e.g., `ls`, `show`, `grep`) and file paths.

What is the 'Routing Engine' versus the 'Packet Forwarding Engine'?

The Routing Engine (RE) is the control plane — it runs routing protocols and handles management. The Packet Forwarding Engine (PFE) is the forwarding plane — it forwards data packets at high speed using dedicated hardware. They are separate components in Juniper's architecture.

Terms Worth Knowing

Keep going

You've finished Juniper Networks and Junos OS Overview. Continue through the JNCIA-JUNOS study guide to build a complete picture of the exam.

Done with this chapter?